X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=net%2Fnet.c;h=d1a15e2a096d81a07a2e5c8fcb6d8f9240713784;hb=77ddac9480d63a80b6bb76d7ee4dcc2d1070867e;hp=ce7934180b6134b98d41f961fbd30ee5d64c9ed8;hpb=8bde7f776c77b343aca29b8c7b58464d915ac245;p=u-boot diff --git a/net/net.c b/net/net.c index ce7934180b..d1a15e2a09 100644 --- a/net/net.c +++ b/net/net.c @@ -40,10 +40,10 @@ * * DHCP: * - * Prerequisites: - own ethernet address - * We want: - IP, Netmask, ServerIP, Gateway IP - * - bootfilename, lease time - * Next step: - TFTP + * Prerequisites: - own ethernet address + * We want: - IP, Netmask, ServerIP, Gateway IP + * - bootfilename, lease time + * Next step: - TFTP * * TFTP: * @@ -55,6 +55,22 @@ * derived from our own IP address) * We want: - load the boot file * Next step: none + * + * NFS: + * + * Prerequisites: - own ethernet address + * - own IP address + * - name of bootfile (if unknown, we use a default name + * derived from our own IP address) + * We want: - load the boot file + * Next step: none + * + * SNTP: + * + * Prerequisites: - own ethernet address + * - own IP address + * We want: - network time + * Next step: none */ @@ -65,6 +81,14 @@ #include "bootp.h" #include "tftp.h" #include "rarp.h" +#include "nfs.h" +#ifdef CONFIG_STATUS_LED +#include +#include +#endif +#if (CONFIG_COMMANDS & CFG_CMD_SNTP) +#include "sntp.h" +#endif #if (CONFIG_COMMANDS & CFG_CMD_NET) @@ -84,6 +108,9 @@ IPaddr_t NetOurSubnetMask=0; /* Our subnet mask (0=unknown) */ IPaddr_t NetOurGatewayIP=0; /* Our gateways IP address */ IPaddr_t NetOurDNSIP=0; /* Our DNS IP address */ +#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_DNS2) +IPaddr_t NetOurDNS2IP=0; /* Our 2nd DNS IP address */ +#endif char NetOurNISDomain[32]={0,}; /* Our NIS domain */ char NetOurHostName[32]={0,}; /* Our hostname */ char NetOurRootPath[64]={0,}; /* Our bootpath */ @@ -104,6 +131,10 @@ uchar NetBcastAddr[6] = /* Ethernet bcast address */ { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; uchar NetEtherNullAddr[6] = { 0, 0, 0, 0, 0, 0 }; +#if (CONFIG_COMMANDS & CFG_CMD_CDP) +uchar NetCDPAddr[6] = /* Ethernet bcast address */ + { 0x01, 0x00, 0x0c, 0xcc, 0xcc, 0xcc }; +#endif int NetState; /* Network loop state */ #ifdef CONFIG_NET_MULTI int NetRestartWrap = 0; /* Tried all network devices */ @@ -111,6 +142,10 @@ static int NetRestarted = 0; /* Network loop restarted */ static int NetDevExists = 0; /* At least one device configured */ #endif +/* XXX in both little & big endian machines 0xFFFF == ntohs(-1) */ +ushort NetOurVLAN = 0xFFFF; /* default is without VLAN */ +ushort NetOurNativeVLAN = 0xFFFF; /* ditto */ + char BootFile[128]; /* Boot File name */ #if (CONFIG_COMMANDS & CFG_CMD_PING) @@ -119,13 +154,28 @@ IPaddr_t NetPingIP; /* the ip address to ping */ static void PingStart(void); #endif +#if (CONFIG_COMMANDS & CFG_CMD_CDP) +static void CDPStart(void); +#endif + +#if (CONFIG_COMMANDS & CFG_CMD_SNTP) +IPaddr_t NetNtpServerIP; /* NTP server IP address */ +int NetTimeOffset=0; /* offset time from UTC */ +#endif + +#ifdef CONFIG_NETCONSOLE +void NcStart(void); +int nc_input_packet(uchar *pkt, unsigned dest, unsigned src, unsigned len); +#endif + volatile uchar PktBuf[(PKTBUFSRX+1) * PKTSIZE_ALIGN + PKTALIGN]; volatile uchar *NetRxPackets[PKTBUFSRX]; /* Receive packets */ static rxhand_f *packetHandler; /* Current RX packet handler */ static thand_f *timeHandler; /* Current timeout handler */ -static ulong timeValue; /* Current timeout value */ +static ulong timeStart; /* Time base value */ +static ulong timeDelta; /* Current timeout value */ volatile uchar *NetTxPacket = 0; /* THE transmit packet */ static int net_check_prereq (proto_t protocol); @@ -135,50 +185,51 @@ static int net_check_prereq (proto_t protocol); IPaddr_t NetArpWaitPacketIP; IPaddr_t NetArpWaitReplyIP; uchar *NetArpWaitPacketMAC; /* MAC address of waiting packet's destination */ -uchar *NetArpWaitTxPacket; /* THE transmit packet */ +uchar *NetArpWaitTxPacket; /* THE transmit packet */ int NetArpWaitTxPacketSize; uchar NetArpWaitPacketBuf[PKTSIZE_ALIGN + PKTALIGN]; ulong NetArpWaitTimerStart; int NetArpWaitTry; -void ArpRequest(void) +void ArpRequest (void) { int i; volatile uchar *pkt; - ARP_t * arp; + ARP_t *arp; #ifdef ET_DEBUG - printf("ARP broadcast %d\n", NetArpWaitTry); + printf ("ARP broadcast %d\n", NetArpWaitTry); #endif pkt = NetTxPacket; - NetSetEther(pkt, NetBcastAddr, PROT_ARP); - pkt += ETHER_HDR_SIZE; + pkt += NetSetEther (pkt, NetBcastAddr, PROT_ARP); - arp = (ARP_t *)pkt; + arp = (ARP_t *) pkt; - arp->ar_hrd = htons(ARP_ETHER); - arp->ar_pro = htons(PROT_IP); + arp->ar_hrd = htons (ARP_ETHER); + arp->ar_pro = htons (PROT_IP); arp->ar_hln = 6; arp->ar_pln = 4; - arp->ar_op = htons(ARPOP_REQUEST); + arp->ar_op = htons (ARPOP_REQUEST); - memcpy (&arp->ar_data[0], NetOurEther, 6); /* source ET addr */ - NetWriteIP((uchar*)&arp->ar_data[6], NetOurIP); /* source IP addr */ - for (i=10; i<16; ++i) { - arp->ar_data[i] = 0; /* dest ET addr = 0 */ + memcpy (&arp->ar_data[0], NetOurEther, 6); /* source ET addr */ + NetWriteIP ((uchar *) & arp->ar_data[6], NetOurIP); /* source IP addr */ + for (i = 10; i < 16; ++i) { + arp->ar_data[i] = 0; /* dest ET addr = 0 */ } - if((NetArpWaitPacketIP & NetOurSubnetMask) != (NetOurIP & NetOurSubnetMask)) { - if (NetOurGatewayIP == 0) { - puts ("## Warning: gatewayip needed but not set\n"); - } - NetArpWaitReplyIP = NetOurGatewayIP; - } else - NetArpWaitReplyIP = NetArpWaitPacketIP; + if ((NetArpWaitPacketIP & NetOurSubnetMask) != + (NetOurIP & NetOurSubnetMask)) { + if (NetOurGatewayIP == 0) { + puts ("## Warning: gatewayip needed but not set\n"); + } + NetArpWaitReplyIP = NetOurGatewayIP; + } else { + NetArpWaitReplyIP = NetArpWaitPacketIP; + } - NetWriteIP((uchar*)&arp->ar_data[16], NetArpWaitReplyIP); - (void) eth_send(NetTxPacket, ETHER_HDR_SIZE + ARP_HDR_SIZE); + NetWriteIP ((uchar *) & arp->ar_data[16], NetArpWaitReplyIP); + (void) eth_send (NetTxPacket, (pkt - NetTxPacket) + ARP_HDR_SIZE); } void ArpTimeoutCheck(void) @@ -232,7 +283,6 @@ NetLoop(proto_t protocol) if (!NetTxPacket) { int i; - /* * Setup packet buffers, aligned correctly. */ @@ -241,7 +291,6 @@ NetLoop(proto_t protocol) for (i = 0; i < PKTBUFSRX; i++) { NetRxPackets[i] = NetTxPacket + (i+1)*PKTSIZE_ALIGN; } - } if (!NetArpWaitTxPacket) { @@ -251,8 +300,13 @@ NetLoop(proto_t protocol) } eth_halt(); - if(eth_init(bd) < 0) - return(-1); +#ifdef CONFIG_NET_MULTI + eth_set_current(); +#endif + if (eth_init(bd) < 0) { + eth_halt(); + return(-1); + } restart: #ifdef CONFIG_NET_MULTI @@ -270,15 +324,28 @@ restart: */ switch (protocol) { +#if (CONFIG_COMMANDS & CFG_CMD_NFS) + case NFS: +#endif #if (CONFIG_COMMANDS & CFG_CMD_PING) case PING: #endif +#if (CONFIG_COMMANDS & CFG_CMD_SNTP) + case SNTP: +#endif + case NETCONS: case TFTP: NetCopyIP(&NetOurIP, &bd->bi_ip_addr); NetOurGatewayIP = getenv_IPaddr ("gatewayip"); NetOurSubnetMask= getenv_IPaddr ("netmask"); + NetOurVLAN = getenv_VLAN("vlan"); + NetOurNativeVLAN = getenv_VLAN("nvlan"); switch (protocol) { +#if (CONFIG_COMMANDS & CFG_CMD_NFS) + case NFS: +#endif + case NETCONS: case TFTP: NetServerIP = getenv_IPaddr ("serverip"); break; @@ -286,6 +353,11 @@ restart: case PING: /* nothing */ break; +#endif +#if (CONFIG_COMMANDS & CFG_CMD_SNTP) + case SNTP: + /* nothing */ + break; #endif default: break; @@ -299,7 +371,12 @@ restart: * IP addr assigned to us by the BOOTP / RARP server */ NetOurIP = 0; - NetServerIP = 0; + NetServerIP = getenv_IPaddr ("serverip"); + NetOurVLAN = getenv_VLAN("vlan"); /* VLANs must be read */ + NetOurNativeVLAN = getenv_VLAN("nvlan"); + case CDP: + NetOurVLAN = getenv_VLAN("vlan"); /* VLANs must be read */ + NetOurNativeVLAN = getenv_VLAN("nvlan"); break; default: break; @@ -308,6 +385,7 @@ restart: switch (net_check_prereq (protocol)) { case 1: /* network not configured */ + eth_halt(); return (-1); #ifdef CONFIG_NET_MULTI @@ -329,8 +407,9 @@ restart: #if (CONFIG_COMMANDS & CFG_CMD_DHCP) case DHCP: /* Start with a clean slate... */ + BootpTry = 0; NetOurIP = 0; - NetServerIP = 0; + NetServerIP = getenv_IPaddr ("serverip"); DhcpRequest(); /* Basically same as BOOTP */ break; #endif /* CFG_CMD_DHCP */ @@ -348,6 +427,26 @@ restart: case PING: PingStart(); break; +#endif +#if (CONFIG_COMMANDS & CFG_CMD_NFS) + case NFS: + NfsStart(); + break; +#endif +#if (CONFIG_COMMANDS & CFG_CMD_CDP) + case CDP: + CDPStart(); + break; +#endif +#ifdef CONFIG_NETCONSOLE + case NETCONS: + NcStart(); + break; +#endif +#if (CONFIG_COMMANDS & CFG_CMD_SNTP) + case SNTP: + SntpStart(); + break; #endif default: break; @@ -357,10 +456,22 @@ restart: break; } +#if defined(CONFIG_MII) || (CONFIG_COMMANDS & CFG_CMD_MII) +#if defined(CFG_FAULT_ECHO_LINK_DOWN) && defined(CONFIG_STATUS_LED) && defined(STATUS_LED_RED) + /* + * Echo the inverted link state to the fault LED. + */ + if(miiphy_link(CFG_FAULT_MII_ADDR)) { + status_led_set (STATUS_LED_RED, STATUS_LED_OFF); + } else { + status_led_set (STATUS_LED_RED, STATUS_LED_ON); + } +#endif /* CFG_FAULT_ECHO_LINK_DOWN, ... */ +#endif /* CONFIG_MII, ... */ /* * Main packet reception loop. Loop receiving packets until - * someone sets `NetQuit'. + * someone sets `NetState' to a state that terminates. */ for (;;) { WATCHDOG_RESET(); @@ -381,7 +492,7 @@ restart: */ if (ctrlc()) { eth_halt(); - printf("\nAbort\n"); + puts ("\nAbort\n"); return (-1); } @@ -391,9 +502,23 @@ restart: * Check for a timeout, and run the timeout handler * if we have one. */ - if (timeHandler && (get_timer(0) > timeValue)) { + if (timeHandler && ((get_timer(0) - timeStart) > timeDelta)) { thand_f *x; +#if defined(CONFIG_MII) || (CONFIG_COMMANDS & CFG_CMD_MII) +# if defined(CFG_FAULT_ECHO_LINK_DOWN) && \ + defined(CONFIG_STATUS_LED) && \ + defined(STATUS_LED_RED) + /* + * Echo the inverted link state to the fault LED. + */ + if(miiphy_link(CFG_FAULT_MII_ADDR)) { + status_led_set (STATUS_LED_RED, STATUS_LED_OFF); + } else { + status_led_set (STATUS_LED_RED, STATUS_LED_ON); + } +# endif /* CFG_FAULT_ECHO_LINK_DOWN, ... */ +#endif /* CONFIG_MII, ... */ x = timeHandler; timeHandler = (thand_f *)0; (*x)(); @@ -416,6 +541,9 @@ restart: NetBootFileXferSize); sprintf(buf, "%lx", NetBootFileXferSize); setenv("filesize", buf); + + sprintf(buf, "%lX", (unsigned long)load_addr); + setenv("fileaddr", buf); } eth_halt(); return NetBootFileXferSize; @@ -440,36 +568,42 @@ startAgainHandler(uchar * pkt, unsigned dest, unsigned src, unsigned len) /* Totally ignore the packet */ } -void -NetStartAgain(void) +void NetStartAgain (void) { -#ifndef CONFIG_NET_MULTI - NetSetTimeout(10 * CFG_HZ, startAgainTimeout); - NetSetHandler(startAgainHandler); -#else +#ifdef CONFIG_NET_MULTI DECLARE_GLOBAL_DATA_PTR; +#endif + char *nretry; + int noretry = 0, once = 0; - eth_halt(); - eth_try_another(!NetRestarted); - eth_init(gd->bd); - if (NetRestartWrap) - { + if ((nretry = getenv ("netretry")) != NULL) { + noretry = (strcmp (nretry, "no") == 0); + once = (strcmp (nretry, "once") == 0); + } + if (noretry) { + eth_halt (); + NetState = NETLOOP_FAIL; + return; + } +#ifndef CONFIG_NET_MULTI + NetSetTimeout (10 * CFG_HZ, startAgainTimeout); + NetSetHandler (startAgainHandler); +#else /* !CONFIG_NET_MULTI*/ + eth_halt (); + eth_try_another (!NetRestarted); + eth_init (gd->bd); + if (NetRestartWrap) { NetRestartWrap = 0; - if (NetDevExists) - { - NetSetTimeout(10 * CFG_HZ, startAgainTimeout); - NetSetHandler(startAgainHandler); - } - else - { + if (NetDevExists && !once) { + NetSetTimeout (10 * CFG_HZ, startAgainTimeout); + NetSetHandler (startAgainHandler); + } else { NetState = NETLOOP_FAIL; } - } - else - { + } else { NetState = NETLOOP_RESTART; } -#endif +#endif /* CONFIG_NET_MULTI */ } /**********************************************************************/ @@ -485,13 +619,14 @@ NetSetHandler(rxhand_f * f) void -NetSetTimeout(int iv, thand_f * f) +NetSetTimeout(ulong iv, thand_f * f) { if (iv == 0) { timeHandler = (thand_f *)0; } else { timeHandler = f; - timeValue = get_timer(0) + iv; + timeStart = get_timer(0); + timeDelta = iv; } } @@ -505,6 +640,8 @@ NetSendPacket(volatile uchar * pkt, int len) int NetSendUDPPacket(uchar *ether, IPaddr_t dest, int dport, int sport, int len) { + uchar *pkt; + /* convert to new style broadcast */ if (dest == 0) dest = 0xFFFFFFFF; @@ -519,16 +656,17 @@ NetSendUDPPacket(uchar *ether, IPaddr_t dest, int dport, int sport, int len) #ifdef ET_DEBUG printf("sending ARP for %08lx\n", dest); #endif - NetArpWaitPacketIP = dest; NetArpWaitPacketMAC = ether; - NetSetEther (NetArpWaitTxPacket, NetArpWaitPacketMAC, PROT_IP); - NetSetIP (NetArpWaitTxPacket + ETHER_HDR_SIZE, dest, dport, sport, len); - memcpy(NetArpWaitTxPacket + ETHER_HDR_SIZE + IP_HDR_SIZE, - (uchar *)NetTxPacket + ETHER_HDR_SIZE + IP_HDR_SIZE, len); + + pkt = NetArpWaitTxPacket; + pkt += NetSetEther (pkt, NetArpWaitPacketMAC, PROT_IP); + + NetSetIP (pkt, dest, dport, sport, len); + memcpy(pkt + IP_HDR_SIZE, (uchar *)NetTxPacket + (pkt - (uchar *)NetArpWaitTxPacket) + IP_HDR_SIZE, len); /* size of the waiting packet */ - NetArpWaitTxPacketSize = ETHER_HDR_SIZE + IP_HDR_SIZE + len; + NetArpWaitTxPacketSize = (pkt - NetArpWaitTxPacket) + IP_HDR_SIZE + len; /* and do the ARP request */ NetArpWaitTry = 1; @@ -539,14 +677,15 @@ NetSendUDPPacket(uchar *ether, IPaddr_t dest, int dport, int sport, int len) #ifdef ET_DEBUG printf("sending UDP to %08lx/%02x:%02x:%02x:%02x:%02x:%02x\n", - dest, ether[0], ether[1], ether[2], ether[3], ether[4], ether[5]); + dest, ether[0], ether[1], ether[2], ether[3], ether[4], ether[5]); #endif - NetSetEther (NetTxPacket, ether, PROT_IP); - NetSetIP (NetTxPacket + ETHER_HDR_SIZE, dest, dport, sport, len); - (void) eth_send(NetTxPacket, ETHER_HDR_SIZE + IP_HDR_SIZE + len); + pkt = (uchar *)NetTxPacket; + pkt += NetSetEther (pkt, ether, PROT_IP); + NetSetIP (pkt, dest, dport, sport, len); + (void) eth_send(NetTxPacket, (pkt - NetTxPacket) + IP_HDR_SIZE + len); - return 0; /* transmited */ + return 0; /* transmitted */ } #if (CONFIG_COMMANDS & CFG_CMD_PING) @@ -557,6 +696,7 @@ int PingSend(void) static uchar mac[6]; volatile IP_t *ip; volatile ushort *s; + uchar *pkt; /* XXX always send arp request */ @@ -569,9 +709,10 @@ int PingSend(void) NetArpWaitPacketIP = NetPingIP; NetArpWaitPacketMAC = mac; - NetSetEther(NetArpWaitTxPacket, mac, PROT_IP); + pkt = NetArpWaitTxPacket; + pkt += NetSetEther(pkt, mac, PROT_IP); - ip = (volatile IP_t *)(NetArpWaitTxPacket + ETHER_HDR_SIZE); + ip = (volatile IP_t *)pkt; /* * Construct an IP and ICMP header. (need to set no fragment bit - XXX) @@ -596,7 +737,7 @@ int PingSend(void) s[1] = ~NetCksum((uchar *)s, 8/2); /* size of the waiting packet */ - NetArpWaitTxPacketSize = ETHER_HDR_SIZE + IP_HDR_SIZE_NO_UDP + 8; + NetArpWaitTxPacketSize = (pkt - NetArpWaitTxPacket) + IP_HDR_SIZE_NO_UDP + 8; /* and do the ARP request */ NetArpWaitTry = 1; @@ -627,45 +768,469 @@ PingHandler (uchar * pkt, unsigned dest, unsigned src, unsigned len) static void PingStart(void) { +#if defined(CONFIG_NET_MULTI) + printf ("Using %s device\n", eth_get_name()); +#endif /* CONFIG_NET_MULTI */ NetSetTimeout (10 * CFG_HZ, PingTimeout); NetSetHandler (PingHandler); PingSend(); } +#endif /* CFG_CMD_PING */ + +#if (CONFIG_COMMANDS & CFG_CMD_CDP) + +#define CDP_DEVICE_ID_TLV 0x0001 +#define CDP_ADDRESS_TLV 0x0002 +#define CDP_PORT_ID_TLV 0x0003 +#define CDP_CAPABILITIES_TLV 0x0004 +#define CDP_VERSION_TLV 0x0005 +#define CDP_PLATFORM_TLV 0x0006 +#define CDP_NATIVE_VLAN_TLV 0x000a +#define CDP_APPLIANCE_VLAN_TLV 0x000e +#define CDP_TRIGGER_TLV 0x000f +#define CDP_POWER_CONSUMPTION_TLV 0x0010 +#define CDP_SYSNAME_TLV 0x0014 +#define CDP_SYSOBJECT_TLV 0x0015 +#define CDP_MANAGEMENT_ADDRESS_TLV 0x0016 + +#define CDP_TIMEOUT (CFG_HZ/4) /* one packet every 250ms */ + +static int CDPSeq; +static int CDPOK; + +ushort CDPNativeVLAN; +ushort CDPApplianceVLAN; + +static const uchar CDP_SNAP_hdr[8] = { 0xAA, 0xAA, 0x03, 0x00, 0x00, 0x0C, 0x20, 0x00 }; + +static ushort CDP_compute_csum(const uchar *buff, ushort len) +{ + ushort csum; + int odd; + ulong result = 0; + ushort leftover; + ushort *p; + + if (len > 0) { + odd = 1 & (ulong)buff; + if (odd) { + result = *buff << 8; + len--; + buff++; + } + while (len > 1) { + p = (ushort *)buff; + result += *p++; + buff = (uchar *)p; + if (result & 0x80000000) + result = (result & 0xFFFF) + (result >> 16); + len -= 2; + } + if (len) { + leftover = (signed short)(*(const signed char *)buff); + /* * XXX CISCO SUCKS big time! (and blows too) */ + result = (result & 0xffff0000) | ((result + leftover) & 0x0000ffff); + } + while (result >> 16) + result = (result & 0xFFFF) + (result >> 16); + + if (odd) + result = ((result >> 8) & 0xff) | ((result & 0xff) << 8); + } + + /* add up 16-bit and 17-bit words for 17+c bits */ + result = (result & 0xffff) + (result >> 16); + /* add up 16-bit and 2-bit for 16+c bit */ + result = (result & 0xffff) + (result >> 16); + /* add up carry.. */ + result = (result & 0xffff) + (result >> 16); + + /* negate */ + csum = ~(ushort)result; + + /* run time endian detection */ + if (csum != htons(csum)) /* little endian */ + csum = htons(csum); + + return csum; +} + +int CDPSendTrigger(void) +{ + volatile uchar *pkt; + volatile ushort *s; + volatile ushort *cp; + Ethernet_t *et; + int len; + ushort chksum; +#if defined(CONFIG_CDP_DEVICE_ID) || defined(CONFIG_CDP_PORT_ID) || \ + defined(CONFIG_CDP_VERSION) || defined(CONFIG_CDP_PLATFORM) + char buf[32]; +#endif + + pkt = NetTxPacket; + et = (Ethernet_t *)pkt; + + /* NOTE: trigger sent not on any VLAN */ + + /* form ethernet header */ + memcpy(et->et_dest, NetCDPAddr, 6); + memcpy(et->et_src, NetOurEther, 6); + + pkt += ETHER_HDR_SIZE; + + /* SNAP header */ + memcpy((uchar *)pkt, CDP_SNAP_hdr, sizeof(CDP_SNAP_hdr)); + pkt += sizeof(CDP_SNAP_hdr); + + /* CDP header */ + *pkt++ = 0x02; /* CDP version 2 */ + *pkt++ = 180; /* TTL */ + s = (volatile ushort *)pkt; + cp = s; + *s++ = htons(0); /* checksum (0 for later calculation) */ + + /* CDP fields */ +#ifdef CONFIG_CDP_DEVICE_ID + *s++ = htons(CDP_DEVICE_ID_TLV); + *s++ = htons(CONFIG_CDP_DEVICE_ID); + memset(buf, 0, sizeof(buf)); + sprintf(buf, CONFIG_CDP_DEVICE_ID_PREFIX "%02X%02X%02X%02X%02X%02X", + NetOurEther[0] & 0xff, NetOurEther[1] & 0xff, + NetOurEther[2] & 0xff, NetOurEther[3] & 0xff, + NetOurEther[4] & 0xff, NetOurEther[5] & 0xff); + memcpy((uchar *)s, buf, 16); + s += 16 / 2; +#endif + +#ifdef CONFIG_CDP_PORT_ID + *s++ = htons(CDP_PORT_ID_TLV); + memset(buf, 0, sizeof(buf)); + sprintf(buf, CONFIG_CDP_PORT_ID, eth_get_dev_index()); + len = strlen(buf); + if (len & 1) /* make it even */ + len++; + *s++ = htons(len + 4); + memcpy((uchar *)s, buf, len); + s += len / 2; +#endif + +#ifdef CONFIG_CDP_CAPABILITIES + *s++ = htons(CDP_CAPABILITIES_TLV); + *s++ = htons(8); + *(ulong *)s = htonl(CONFIG_CDP_CAPABILITIES); + s += 2; +#endif + +#ifdef CONFIG_CDP_VERSION + *s++ = htons(CDP_VERSION_TLV); + memset(buf, 0, sizeof(buf)); + strcpy(buf, CONFIG_CDP_VERSION); + len = strlen(buf); + if (len & 1) /* make it even */ + len++; + *s++ = htons(len + 4); + memcpy((uchar *)s, buf, len); + s += len / 2; +#endif + +#ifdef CONFIG_CDP_PLATFORM + *s++ = htons(CDP_PLATFORM_TLV); + memset(buf, 0, sizeof(buf)); + strcpy(buf, CONFIG_CDP_PLATFORM); + len = strlen(buf); + if (len & 1) /* make it even */ + len++; + *s++ = htons(len + 4); + memcpy((uchar *)s, buf, len); + s += len / 2; +#endif + +#ifdef CONFIG_CDP_TRIGGER + *s++ = htons(CDP_TRIGGER_TLV); + *s++ = htons(8); + *(ulong *)s = htonl(CONFIG_CDP_TRIGGER); + s += 2; +#endif + +#ifdef CONFIG_CDP_POWER_CONSUMPTION + *s++ = htons(CDP_POWER_CONSUMPTION_TLV); + *s++ = htons(6); + *s++ = htons(CONFIG_CDP_POWER_CONSUMPTION); +#endif + + /* length of ethernet packet */ + len = (uchar *)s - ((uchar *)NetTxPacket + ETHER_HDR_SIZE); + et->et_protlen = htons(len); + + len = ETHER_HDR_SIZE + sizeof(CDP_SNAP_hdr); + chksum = CDP_compute_csum((uchar *)NetTxPacket + len, (uchar *)s - (NetTxPacket + len)); + if (chksum == 0) + chksum = 0xFFFF; + *cp = htons(chksum); + + (void) eth_send(NetTxPacket, (uchar *)s - NetTxPacket); + return 0; +} + +static void +CDPTimeout (void) +{ + CDPSeq++; + + if (CDPSeq < 3) { + NetSetTimeout (CDP_TIMEOUT, CDPTimeout); + CDPSendTrigger(); + return; + } + + /* if not OK try again */ + if (!CDPOK) + NetStartAgain(); + else + NetState = NETLOOP_SUCCESS; +} + +static void +CDPDummyHandler (uchar * pkt, unsigned dest, unsigned src, unsigned len) +{ + /* nothing */ +} + +static void +CDPHandler(const uchar * pkt, unsigned len) +{ + const uchar *t; + const ushort *ss; + ushort type, tlen; + uchar applid; + ushort vlan, nvlan; + + /* minimum size? */ + if (len < sizeof(CDP_SNAP_hdr) + 4) + goto pkt_short; + + /* check for valid CDP SNAP header */ + if (memcmp(pkt, CDP_SNAP_hdr, sizeof(CDP_SNAP_hdr)) != 0) + return; + + pkt += sizeof(CDP_SNAP_hdr); + len -= sizeof(CDP_SNAP_hdr); + + /* Version of CDP protocol must be >= 2 and TTL != 0 */ + if (pkt[0] < 0x02 || pkt[1] == 0) + return; + + /* if version is greater than 0x02 maybe we'll have a problem; output a warning */ + if (pkt[0] != 0x02) + printf("** WARNING: CDP packet received with a protocol version %d > 2\n", + pkt[0] & 0xff); + + if (CDP_compute_csum(pkt, len) != 0) + return; + + pkt += 4; + len -= 4; + + vlan = htons(-1); + nvlan = htons(-1); + while (len > 0) { + if (len < 4) + goto pkt_short; + + ss = (const ushort *)pkt; + type = ntohs(ss[0]); + tlen = ntohs(ss[1]); + if (tlen > len) { + goto pkt_short; + } + + pkt += tlen; + len -= tlen; + + ss += 2; /* point ss to the data of the TLV */ + tlen -= 4; + + switch (type) { + case CDP_DEVICE_ID_TLV: + break; + case CDP_ADDRESS_TLV: + break; + case CDP_PORT_ID_TLV: + break; + case CDP_CAPABILITIES_TLV: + break; + case CDP_VERSION_TLV: + break; + case CDP_PLATFORM_TLV: + break; + case CDP_NATIVE_VLAN_TLV: + nvlan = *ss; + break; + case CDP_APPLIANCE_VLAN_TLV: + t = (const uchar *)ss; + while (tlen > 0) { + if (tlen < 3) + goto pkt_short; + + applid = t[0]; + ss = (const ushort *)(t + 1); + +#ifdef CONFIG_CDP_APPLIANCE_VLAN_TYPE + if (applid == CONFIG_CDP_APPLIANCE_VLAN_TYPE) + vlan = *ss; +#else + vlan = ntohs(*ss); /* XXX will this work; dunno */ +#endif + t += 3; tlen -= 3; + } + break; + case CDP_TRIGGER_TLV: + break; + case CDP_POWER_CONSUMPTION_TLV: + break; + case CDP_SYSNAME_TLV: + break; + case CDP_SYSOBJECT_TLV: + break; + case CDP_MANAGEMENT_ADDRESS_TLV: + break; + } + } + + CDPApplianceVLAN = vlan; + CDPNativeVLAN = nvlan; + + CDPOK = 1; + return; + + pkt_short: + printf("** CDP packet is too short\n"); + return; +} +static void CDPStart(void) +{ +#if defined(CONFIG_NET_MULTI) + printf ("Using %s device\n", eth_get_name()); #endif + CDPSeq = 0; + CDPOK = 0; + + CDPNativeVLAN = htons(-1); + CDPApplianceVLAN = htons(-1); + + NetSetTimeout (CDP_TIMEOUT, CDPTimeout); + NetSetHandler (CDPDummyHandler); + + CDPSendTrigger(); +} +#endif /* CFG_CMD_CDP */ + void -NetReceive(volatile uchar * pkt, int len) +NetReceive(volatile uchar * inpkt, int len) { Ethernet_t *et; IP_t *ip; ARP_t *arp; IPaddr_t tmp; int x; + uchar *pkt; +#if (CONFIG_COMMANDS & CFG_CMD_CDP) + int iscdp; +#endif + ushort cti = 0, vlanid = VLAN_NONE, myvlanid, mynvlanid; - NetRxPkt = pkt; +#ifdef ET_DEBUG + printf("packet received\n"); +#endif + + NetRxPkt = inpkt; NetRxPktLen = len; - et = (Ethernet_t *)pkt; + et = (Ethernet_t *)inpkt; + + /* too small packet? */ + if (len < ETHER_HDR_SIZE) + return; + +#if (CONFIG_COMMANDS & CFG_CMD_CDP) + /* keep track if packet is CDP */ + iscdp = memcmp(et->et_dest, NetCDPAddr, 6) == 0; +#endif + + myvlanid = ntohs(NetOurVLAN); + if (myvlanid == (ushort)-1) + myvlanid = VLAN_NONE; + mynvlanid = ntohs(NetOurNativeVLAN); + if (mynvlanid == (ushort)-1) + mynvlanid = VLAN_NONE; x = ntohs(et->et_protlen); +#ifdef ET_DEBUG + printf("packet received\n"); +#endif + if (x < 1514) { /* * Got a 802 packet. Check the other protocol field. */ x = ntohs(et->et_prot); - ip = (IP_t *)(pkt + E802_HDR_SIZE); + + ip = (IP_t *)(inpkt + E802_HDR_SIZE); len -= E802_HDR_SIZE; - } else { - ip = (IP_t *)(pkt + ETHER_HDR_SIZE); + + } else if (x != PROT_VLAN) { /* normal packet */ + ip = (IP_t *)(inpkt + ETHER_HDR_SIZE); len -= ETHER_HDR_SIZE; + + } else { /* VLAN packet */ + VLAN_Ethernet_t *vet = (VLAN_Ethernet_t *)et; + +#ifdef ET_DEBUG + printf("VLAN packet received\n"); +#endif + /* too small packet? */ + if (len < VLAN_ETHER_HDR_SIZE) + return; + + /* if no VLAN active */ + if ((ntohs(NetOurVLAN) & VLAN_IDMASK) == VLAN_NONE +#if (CONFIG_COMMANDS & CFG_CMD_CDP) + && iscdp == 0 +#endif + ) + return; + + cti = ntohs(vet->vet_tag); + vlanid = cti & VLAN_IDMASK; + x = ntohs(vet->vet_type); + + ip = (IP_t *)(inpkt + VLAN_ETHER_HDR_SIZE); + len -= VLAN_ETHER_HDR_SIZE; } #ifdef ET_DEBUG printf("Receive from protocol 0x%x\n", x); #endif +#if (CONFIG_COMMANDS & CFG_CMD_CDP) + if (iscdp) { + CDPHandler((uchar *)ip, len); + return; + } +#endif + + if ((myvlanid & VLAN_IDMASK) != VLAN_NONE) { + if (vlanid == VLAN_NONE) + vlanid = (mynvlanid & VLAN_IDMASK); + /* not matched? */ + if (vlanid != (myvlanid & VLAN_IDMASK)) + return; + } + switch (x) { case PROT_ARP: @@ -679,7 +1244,7 @@ NetReceive(volatile uchar * pkt, int len) * the server ethernet address */ #ifdef ET_DEBUG - printf("Got ARP\n"); + puts ("Got ARP\n"); #endif arp = (ARP_t *)ip; if (len < ARP_HDR_SIZE) { @@ -710,15 +1275,16 @@ NetReceive(volatile uchar * pkt, int len) switch (ntohs(arp->ar_op)) { case ARPOP_REQUEST: /* reply with our IP address */ #ifdef ET_DEBUG - printf("Got ARP REQUEST, return our IP\n"); + puts ("Got ARP REQUEST, return our IP\n"); #endif - NetSetEther((uchar *)et, et->et_src, PROT_ARP); + pkt = (uchar *)et; + pkt += NetSetEther(pkt, et->et_src, PROT_ARP); arp->ar_op = htons(ARPOP_REPLY); memcpy (&arp->ar_data[10], &arp->ar_data[0], 6); NetCopyIP(&arp->ar_data[16], &arp->ar_data[6]); memcpy (&arp->ar_data[ 0], NetOurEther, 6); NetCopyIP(&arp->ar_data[ 6], &NetOurIP); - (void) eth_send((uchar *)et, ((uchar *)arp-pkt) + ARP_HDR_SIZE); + (void) eth_send((uchar *)et, (pkt - (uchar *)et) + ARP_HDR_SIZE); return; case ARPOP_REPLY: /* arp reply */ @@ -737,11 +1303,14 @@ NetReceive(volatile uchar * pkt, int len) /* matched waiting packet's address */ if (tmp == NetArpWaitReplyIP) { #ifdef ET_DEBUG - printf("Got it\n"); + puts ("Got it\n"); #endif /* save address for later use */ memcpy(NetArpWaitPacketMAC, &arp->ar_data[0], 6); +#ifdef CONFIG_NETCONSOLE + (*packetHandler)(0,0,0,0); +#endif /* modify header, and transmit it */ memcpy(((Ethernet_t *)NetArpWaitTxPacket)->et_dest, NetArpWaitPacketMAC, 6); (void) eth_send(NetArpWaitTxPacket, NetArpWaitTxPacketSize); @@ -759,10 +1328,11 @@ NetReceive(volatile uchar * pkt, int len) #endif return; } + break; case PROT_RARP: #ifdef ET_DEBUG - printf("Got RARP\n"); + puts ("Got RARP\n"); #endif arp = (ARP_t *)ip; if (len < ARP_HDR_SIZE) { @@ -775,10 +1345,11 @@ NetReceive(volatile uchar * pkt, int len) (ntohs(arp->ar_pro) != PROT_IP) || (arp->ar_hln != 6) || (arp->ar_pln != 4)) { - printf("invalid RARP header\n"); + puts ("invalid RARP header\n"); } else { NetCopyIP(&NetOurIP, &arp->ar_data[16]); - NetCopyIP(&NetServerIP, &arp->ar_data[ 6]); + if (NetServerIP == 0) + NetCopyIP(&NetServerIP, &arp->ar_data[ 6]); memcpy (NetServerEther, &arp->ar_data[ 0], 6); (*packetHandler)(0,0,0,0); @@ -787,7 +1358,7 @@ NetReceive(volatile uchar * pkt, int len) case PROT_IP: #ifdef ET_DEBUG - printf("Got IP\n"); + puts ("Got IP\n"); #endif if (len < IP_HDR_SIZE) { debug ("len bad %d < %d\n", len, IP_HDR_SIZE); @@ -808,7 +1379,7 @@ NetReceive(volatile uchar * pkt, int len) return; } if (!NetCksumOk((uchar *)ip, IP_HDR_SIZE_NO_UDP / 2)) { - printf("checksum bad\n"); + puts ("checksum bad\n"); return; } tmp = NetReadIP(&ip->ip_dst); @@ -837,12 +1408,12 @@ NetReceive(volatile uchar * pkt, int len) switch (icmph->type) { case ICMP_REDIRECT: - if (icmph->code != ICMP_REDIR_HOST) + if (icmph->code != ICMP_REDIR_HOST) + return; + puts (" ICMP Host Redirect to "); + print_IPaddr(icmph->un.gateway); + putc(' '); return; - puts (" ICMP Host Redirect to "); - print_IPaddr(icmph->un.gateway); - putc(' '); - break; #if (CONFIG_COMMANDS & CFG_CMD_PING) case ICMP_ECHO_REPLY: /* @@ -850,7 +1421,7 @@ NetReceive(volatile uchar * pkt, int len) */ /* XXX point to ip packet */ (*packetHandler)((uchar *)ip, 0, 0, 0); - break; + return; #endif default: return; @@ -859,6 +1430,52 @@ NetReceive(volatile uchar * pkt, int len) return; } +#ifdef CONFIG_UDP_CHECKSUM + if (ip->udp_xsum != 0) { + ulong xsum; + ushort *sumptr; + ushort sumlen; + + xsum = ip->ip_p; + xsum += (ntohs(ip->udp_len)); + xsum += (ntohl(ip->ip_src) >> 16) & 0x0000ffff; + xsum += (ntohl(ip->ip_src) >> 0) & 0x0000ffff; + xsum += (ntohl(ip->ip_dst) >> 16) & 0x0000ffff; + xsum += (ntohl(ip->ip_dst) >> 0) & 0x0000ffff; + + sumlen = ntohs(ip->udp_len); + sumptr = (ushort *) &(ip->udp_src); + + while (sumlen > 1) { + ushort sumdata; + + sumdata = *sumptr++; + xsum += ntohs(sumdata); + sumlen -= 2; + } + if (sumlen > 0) { + ushort sumdata; + + sumdata = *(unsigned char *) sumptr; + sumdata = (sumdata << 8) & 0xff00; + xsum += sumdata; + } + while ((xsum >> 16) != 0) { + xsum = (xsum & 0x0000ffff) + ((xsum >> 16) & 0x0000ffff); + } + if ((xsum != 0x00000000) && (xsum != 0x0000ffff)) { + printf(" UDP wrong checksum %08x %08x\n", xsum, ntohs(ip->udp_xsum)); + return; + } + } +#endif + +#ifdef CONFIG_NETCONSOLE + nc_input_packet((uchar *)ip +IP_HDR_SIZE, + ntohs(ip->udp_dst), + ntohs(ip->udp_src), + ntohs(ip->udp_len) - 8); +#endif /* * IP header OK. Pass the packet to the current handler. */ @@ -866,7 +1483,6 @@ NetReceive(volatile uchar * pkt, int len) ntohs(ip->udp_dst), ntohs(ip->udp_src), ntohs(ip->udp_len) - 8); - break; } } @@ -877,64 +1493,76 @@ NetReceive(volatile uchar * pkt, int len) static int net_check_prereq (proto_t protocol) { switch (protocol) { - /* Fall through */ + /* Fall through */ #if (CONFIG_COMMANDS & CFG_CMD_PING) case PING: - if (NetPingIP == 0) { - puts ("*** ERROR: ping address not given\n"); - return (1); - } - goto common; + if (NetPingIP == 0) { + puts ("*** ERROR: ping address not given\n"); + return (1); + } + goto common; +#endif +#if (CONFIG_COMMANDS & CFG_CMD_SNTP) + case SNTP: + if (NetNtpServerIP == 0) { + puts ("*** ERROR: NTP server address not given\n"); + return (1); + } + goto common; #endif +#if (CONFIG_COMMANDS & CFG_CMD_NFS) + case NFS: +#endif + case NETCONS: case TFTP: - if (NetServerIP == 0) { - puts ("*** ERROR: `serverip' not set\n"); - return (1); - } - -#if (CONFIG_COMMANDS & CFG_CMD_PING) - common: + if (NetServerIP == 0) { + puts ("*** ERROR: `serverip' not set\n"); + return (1); + } +#if (CONFIG_COMMANDS & (CFG_CMD_PING | CFG_CMD_SNTP)) + common: #endif - if (NetOurIP == 0) { - puts ("*** ERROR: `ipaddr' not set\n"); - return (1); - } - /* Fall through */ + if (NetOurIP == 0) { + puts ("*** ERROR: `ipaddr' not set\n"); + return (1); + } + /* Fall through */ case DHCP: case RARP: case BOOTP: - if (memcmp(NetOurEther, "\0\0\0\0\0\0", 6) == 0) { + case CDP: + if (memcmp (NetOurEther, "\0\0\0\0\0\0", 6) == 0) { #ifdef CONFIG_NET_MULTI - extern int eth_get_dev_index (void); - int num = eth_get_dev_index(); + extern int eth_get_dev_index (void); + int num = eth_get_dev_index (); - switch (num) { - case -1: + switch (num) { + case -1: puts ("*** ERROR: No ethernet found.\n"); return (1); - case 0: + case 0: puts ("*** ERROR: `ethaddr' not set\n"); break; - default: + default: printf ("*** ERROR: `eth%daddr' not set\n", num); break; - } + } - NetStartAgain (); - return (2); + NetStartAgain (); + return (2); #else - puts ("*** ERROR: `ethaddr' not set\n"); - return (1); + puts ("*** ERROR: `ethaddr' not set\n"); + return (1); #endif - } - /* Fall through */ - default: - return(0); + } + /* Fall through */ + default: + return (0); } - return (0); /* OK */ + return (0); /* OK */ } /**********************************************************************/ @@ -949,26 +1577,52 @@ unsigned NetCksum(uchar * ptr, int len) { ulong xsum; + ushort *p = (ushort *)ptr; xsum = 0; while (len-- > 0) - xsum += *((ushort *)ptr)++; + xsum += *p++; xsum = (xsum & 0xffff) + (xsum >> 16); xsum = (xsum & 0xffff) + (xsum >> 16); return (xsum & 0xffff); } +int +NetEthHdrSize(void) +{ + ushort myvlanid; + + myvlanid = ntohs(NetOurVLAN); + if (myvlanid == (ushort)-1) + myvlanid = VLAN_NONE; -void + return ((myvlanid & VLAN_IDMASK) == VLAN_NONE) ? ETHER_HDR_SIZE : VLAN_ETHER_HDR_SIZE; +} + +int NetSetEther(volatile uchar * xet, uchar * addr, uint prot) { Ethernet_t *et = (Ethernet_t *)xet; + ushort myvlanid; + + myvlanid = ntohs(NetOurVLAN); + if (myvlanid == (ushort)-1) + myvlanid = VLAN_NONE; memcpy (et->et_dest, addr, 6); memcpy (et->et_src, NetOurEther, 6); + if ((myvlanid & VLAN_IDMASK) == VLAN_NONE) { et->et_protlen = htons(prot); -} + return ETHER_HDR_SIZE; + } else { + VLAN_Ethernet_t *vet = (VLAN_Ethernet_t *)xet; + vet->vet_vlan_type = htons(PROT_VLAN); + vet->vet_tag = htons((0 << 5) | (myvlanid & VLAN_IDMASK)); + vet->vet_type = htons(prot); + return VLAN_ETHER_HDR_SIZE; + } +} void NetSetIP(volatile uchar * xip, IPaddr_t dest, int dport, int sport, int len) @@ -985,7 +1639,7 @@ NetSetIP(volatile uchar * xip, IPaddr_t dest, int dport, int sport, int len) /* * Construct an IP and UDP header. - (need to set no fragment bit - XXX) + * (need to set no fragment bit - XXX) */ ip->ip_hl_v = 0x45; /* IP_HDR_SIZE / 4 (not including UDP) */ ip->ip_tos = 0; @@ -1004,7 +1658,7 @@ NetSetIP(volatile uchar * xip, IPaddr_t dest, int dport, int sport, int len) ip->ip_sum = ~NetCksum((uchar *)ip, IP_HDR_SIZE_NO_UDP / 2); } -void copy_filename (uchar *dst, uchar *src, int size) +void copy_filename (char *dst, char *src, int size) { if (*src && (*src == '"')) { ++src; @@ -1021,13 +1675,12 @@ void copy_filename (uchar *dst, uchar *src, int size) void ip_to_string (IPaddr_t x, char *s) { - x = ntohl(x); - sprintf (s,"%d.%d.%d.%d", - (int)((x >> 24) & 0xff), - (int)((x >> 16) & 0xff), - (int)((x >> 8) & 0xff), - (int)((x >> 0) & 0xff) - ); + x = ntohl (x); + sprintf (s, "%d.%d.%d.%d", + (int) ((x >> 24) & 0xff), + (int) ((x >> 16) & 0xff), + (int) ((x >> 8) & 0xff), (int) ((x >> 0) & 0xff) + ); } IPaddr_t string_to_ip(char *s) @@ -1051,16 +1704,49 @@ IPaddr_t string_to_ip(char *s) return (htonl(addr)); } +void VLAN_to_string(ushort x, char *s) +{ + x = ntohs(x); + + if (x == (ushort)-1) + x = VLAN_NONE; + + if (x == VLAN_NONE) + strcpy(s, "none"); + else + sprintf(s, "%d", x & VLAN_IDMASK); +} + +ushort string_to_VLAN(char *s) +{ + ushort id; + + if (s == NULL) + return htons(VLAN_NONE); + + if (*s < '0' || *s > '9') + id = VLAN_NONE; + else + id = (ushort)simple_strtoul(s, NULL, 10); + + return htons(id); +} + void print_IPaddr (IPaddr_t x) { - char tmp[16]; + char tmp[16]; - ip_to_string(x, tmp); + ip_to_string (x, tmp); - puts(tmp); + puts (tmp); } IPaddr_t getenv_IPaddr (char *var) { return (string_to_ip(getenv(var))); } + +ushort getenv_VLAN(char *var) +{ + return (string_to_VLAN(getenv(var))); +}