net/net.c: cosmetic: fix indentation
[platform/kernel/u-boot.git] / net / net.c
1 /*
2  *      Copied from Linux Monitor (LiMon) - Networking.
3  *
4  *      Copyright 1994 - 2000 Neil Russell.
5  *      (See License)
6  *      Copyright 2000 Roland Borde
7  *      Copyright 2000 Paolo Scaffardi
8  *      Copyright 2000-2002 Wolfgang Denk, wd@denx.de
9  */
10
11 /*
12  * General Desription:
13  *
14  * The user interface supports commands for BOOTP, RARP, and TFTP.
15  * Also, we support ARP internally. Depending on available data,
16  * these interact as follows:
17  *
18  * BOOTP:
19  *
20  *      Prerequisites:  - own ethernet address
21  *      We want:        - own IP address
22  *                      - TFTP server IP address
23  *                      - name of bootfile
24  *      Next step:      ARP
25  *
26  * RARP:
27  *
28  *      Prerequisites:  - own ethernet address
29  *      We want:        - own IP address
30  *                      - TFTP server IP address
31  *      Next step:      ARP
32  *
33  * ARP:
34  *
35  *      Prerequisites:  - own ethernet address
36  *                      - own IP address
37  *                      - TFTP server IP address
38  *      We want:        - TFTP server ethernet address
39  *      Next step:      TFTP
40  *
41  * DHCP:
42  *
43  *     Prerequisites:   - own ethernet address
44  *     We want:         - IP, Netmask, ServerIP, Gateway IP
45  *                      - bootfilename, lease time
46  *     Next step:       - TFTP
47  *
48  * TFTP:
49  *
50  *      Prerequisites:  - own ethernet address
51  *                      - own IP address
52  *                      - TFTP server IP address
53  *                      - TFTP server ethernet address
54  *                      - name of bootfile (if unknown, we use a default name
55  *                        derived from our own IP address)
56  *      We want:        - load the boot file
57  *      Next step:      none
58  *
59  * NFS:
60  *
61  *      Prerequisites:  - own ethernet address
62  *                      - own IP address
63  *                      - name of bootfile (if unknown, we use a default name
64  *                        derived from our own IP address)
65  *      We want:        - load the boot file
66  *      Next step:      none
67  *
68  * SNTP:
69  *
70  *      Prerequisites:  - own ethernet address
71  *                      - own IP address
72  *      We want:        - network time
73  *      Next step:      none
74  */
75
76
77 #include <common.h>
78 #include <watchdog.h>
79 #include <command.h>
80 #include <net.h>
81 #include "bootp.h"
82 #include "tftp.h"
83 #ifdef CONFIG_CMD_RARP
84 #include "rarp.h"
85 #endif
86 #include "nfs.h"
87 #ifdef CONFIG_STATUS_LED
88 #include <status_led.h>
89 #include <miiphy.h>
90 #endif
91 #if defined(CONFIG_CMD_SNTP)
92 #include "sntp.h"
93 #endif
94 #if defined(CONFIG_CDP_VERSION)
95 #include <timestamp.h>
96 #endif
97 #if defined(CONFIG_CMD_DNS)
98 #include "dns.h"
99 #endif
100
101 DECLARE_GLOBAL_DATA_PTR;
102
103 #ifndef CONFIG_ARP_TIMEOUT
104 /* Milliseconds before trying ARP again */
105 # define ARP_TIMEOUT            5000UL
106 #else
107 # define ARP_TIMEOUT            CONFIG_ARP_TIMEOUT
108 #endif
109
110
111 #ifndef CONFIG_NET_RETRY_COUNT
112 # define ARP_TIMEOUT_COUNT      5       /* # of timeouts before giving up  */
113 #else
114 # define ARP_TIMEOUT_COUNT      CONFIG_NET_RETRY_COUNT
115 #endif
116
117 /** BOOTP EXTENTIONS **/
118
119 /* Our subnet mask (0=unknown) */
120 IPaddr_t        NetOurSubnetMask;
121 /* Our gateways IP address */
122 IPaddr_t        NetOurGatewayIP;
123 /* Our DNS IP address */
124 IPaddr_t        NetOurDNSIP;
125 #if defined(CONFIG_BOOTP_DNS2)
126 /* Our 2nd DNS IP address */
127 IPaddr_t        NetOurDNS2IP;
128 #endif
129 /* Our NIS domain */
130 char            NetOurNISDomain[32] = {0,};
131 /* Our hostname */
132 char            NetOurHostName[32] = {0,};
133 /* Our bootpath */
134 char            NetOurRootPath[64] = {0,};
135 /* Our bootfile size in blocks */
136 ushort          NetBootFileSize;
137
138 #ifdef CONFIG_MCAST_TFTP        /* Multicast TFTP */
139 IPaddr_t Mcast_addr;
140 #endif
141
142 /** END OF BOOTP EXTENTIONS **/
143
144 /* The actual transferred size of the bootfile (in bytes) */
145 ulong           NetBootFileXferSize;
146 /* Our ethernet address */
147 uchar           NetOurEther[6];
148 /* Boot server enet address */
149 uchar           NetServerEther[6];
150 /* Our IP addr (0 = unknown) */
151 IPaddr_t        NetOurIP;
152 /* Server IP addr (0 = unknown) */
153 IPaddr_t        NetServerIP;
154 /* Current receive packet */
155 volatile uchar *NetRxPacket;
156 /* Current rx packet length */
157 int             NetRxPacketLen;
158 /* IP packet ID */
159 unsigned        NetIPID;
160 /* Ethernet bcast address */
161 uchar           NetBcastAddr[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
162 uchar           NetEtherNullAddr[6];
163 #ifdef CONFIG_API
164 void            (*push_packet)(volatile void *, int len) = 0;
165 #endif
166 #if defined(CONFIG_CMD_CDP)
167 /* Ethernet bcast address */
168 uchar           NetCDPAddr[6] = { 0x01, 0x00, 0x0c, 0xcc, 0xcc, 0xcc };
169 #endif
170 /* Network loop state */
171 int             NetState;
172 #ifdef CONFIG_NET_MULTI
173 /* Tried all network devices */
174 int             NetRestartWrap;
175 /* Network loop restarted */
176 static int      NetRestarted;
177 /* At least one device configured */
178 static int      NetDevExists;
179 #endif
180
181 /* XXX in both little & big endian machines 0xFFFF == ntohs(-1) */
182 /* default is without VLAN */
183 ushort          NetOurVLAN = 0xFFFF;
184 /* ditto */
185 ushort          NetOurNativeVLAN = 0xFFFF;
186
187 /* Boot File name */
188 char            BootFile[128];
189
190 #if defined(CONFIG_CMD_PING)
191 /* the ip address to ping */
192 IPaddr_t        NetPingIP;
193
194 static void PingStart(void);
195 #endif
196
197 #if defined(CONFIG_CMD_CDP)
198 static void CDPStart(void);
199 #endif
200
201 #if defined(CONFIG_CMD_SNTP)
202 /* NTP server IP address */
203 IPaddr_t        NetNtpServerIP;
204 /* offset time from UTC */
205 int             NetTimeOffset;
206 #endif
207
208 #ifdef CONFIG_NETCONSOLE
209 void NcStart(void);
210 int nc_input_packet(uchar *pkt, unsigned dest, unsigned src, unsigned len);
211 #endif
212
213 volatile uchar  PktBuf[(PKTBUFSRX+1) * PKTSIZE_ALIGN + PKTALIGN];
214
215 /* Receive packet */
216 volatile uchar *NetRxPackets[PKTBUFSRX];
217
218 /* Current RX packet handler */
219 static rxhand_f *packetHandler;
220 /* Current timeout handler */
221 static thand_f *timeHandler;
222 /* Time base value */
223 static ulong    timeStart;
224 /* Current timeout value */
225 static ulong    timeDelta;
226 /* THE transmit packet */
227 volatile uchar *NetTxPacket;
228
229 static int net_check_prereq(proto_t protocol);
230
231 static int NetTryCount;
232
233 /**********************************************************************/
234
235 IPaddr_t        NetArpWaitPacketIP;
236 IPaddr_t        NetArpWaitReplyIP;
237 /* MAC address of waiting packet's destination */
238 uchar          *NetArpWaitPacketMAC;
239 /* THE transmit packet */
240 uchar          *NetArpWaitTxPacket;
241 int             NetArpWaitTxPacketSize;
242 uchar           NetArpWaitPacketBuf[PKTSIZE_ALIGN + PKTALIGN];
243 ulong           NetArpWaitTimerStart;
244 int             NetArpWaitTry;
245
246 void ArpRequest(void)
247 {
248         int i;
249         volatile uchar *pkt;
250         ARP_t *arp;
251
252         debug("ARP broadcast %d\n", NetArpWaitTry);
253
254         pkt = NetTxPacket;
255
256         pkt += NetSetEther(pkt, NetBcastAddr, PROT_ARP);
257
258         arp = (ARP_t *) pkt;
259
260         arp->ar_hrd = htons(ARP_ETHER);
261         arp->ar_pro = htons(PROT_IP);
262         arp->ar_hln = 6;
263         arp->ar_pln = 4;
264         arp->ar_op = htons(ARPOP_REQUEST);
265
266         /* source ET addr */
267         memcpy(&arp->ar_data[0], NetOurEther, 6);
268         /* source IP addr */
269         NetWriteIP((uchar *) &arp->ar_data[6], NetOurIP);
270         for (i = 10; i < 16; ++i) {
271                 /* dest ET addr = 0 */
272                 arp->ar_data[i] = 0;
273         }
274
275         if ((NetArpWaitPacketIP & NetOurSubnetMask) !=
276             (NetOurIP & NetOurSubnetMask)) {
277                 if (NetOurGatewayIP == 0) {
278                         puts("## Warning: gatewayip needed but not set\n");
279                         NetArpWaitReplyIP = NetArpWaitPacketIP;
280                 } else {
281                         NetArpWaitReplyIP = NetOurGatewayIP;
282                 }
283         } else {
284                 NetArpWaitReplyIP = NetArpWaitPacketIP;
285         }
286
287         NetWriteIP((uchar *) &arp->ar_data[16], NetArpWaitReplyIP);
288         (void) eth_send(NetTxPacket, (pkt - NetTxPacket) + ARP_HDR_SIZE);
289 }
290
291 void ArpTimeoutCheck(void)
292 {
293         ulong t;
294
295         if (!NetArpWaitPacketIP)
296                 return;
297
298         t = get_timer(0);
299
300         /* check for arp timeout */
301         if ((t - NetArpWaitTimerStart) > ARP_TIMEOUT) {
302                 NetArpWaitTry++;
303
304                 if (NetArpWaitTry >= ARP_TIMEOUT_COUNT) {
305                         puts("\nARP Retry count exceeded; starting again\n");
306                         NetArpWaitTry = 0;
307                         NetStartAgain();
308                 } else {
309                         NetArpWaitTimerStart = t;
310                         ArpRequest();
311                 }
312         }
313 }
314
315 static void
316 NetInitLoop(proto_t protocol)
317 {
318         static int env_changed_id;
319         bd_t *bd = gd->bd;
320         int env_id = get_env_id();
321
322         /* update only when the environment has changed */
323         if (env_changed_id != env_id) {
324                 NetCopyIP(&NetOurIP, &bd->bi_ip_addr);
325                 NetOurGatewayIP = getenv_IPaddr("gatewayip");
326                 NetOurSubnetMask = getenv_IPaddr("netmask");
327                 NetServerIP = getenv_IPaddr("serverip");
328                 NetOurNativeVLAN = getenv_VLAN("nvlan");
329                 NetOurVLAN = getenv_VLAN("vlan");
330 #if defined(CONFIG_CMD_DNS)
331                 NetOurDNSIP = getenv_IPaddr("dnsip");
332 #endif
333                 env_changed_id = env_id;
334         }
335
336         return;
337 }
338
339 /**********************************************************************/
340 /*
341  *      Main network processing loop.
342  */
343
344 int
345 NetLoop(proto_t protocol)
346 {
347         bd_t *bd = gd->bd;
348
349 #ifdef CONFIG_NET_MULTI
350         NetRestarted = 0;
351         NetDevExists = 0;
352 #endif
353
354         /* XXX problem with bss workaround */
355         NetArpWaitPacketMAC = NULL;
356         NetArpWaitTxPacket = NULL;
357         NetArpWaitPacketIP = 0;
358         NetArpWaitReplyIP = 0;
359         NetArpWaitTxPacket = NULL;
360         NetTxPacket = NULL;
361         NetTryCount = 1;
362
363         if (!NetTxPacket) {
364                 int     i;
365                 /*
366                  *      Setup packet buffers, aligned correctly.
367                  */
368                 NetTxPacket = &PktBuf[0] + (PKTALIGN - 1);
369                 NetTxPacket -= (ulong)NetTxPacket % PKTALIGN;
370                 for (i = 0; i < PKTBUFSRX; i++)
371                         NetRxPackets[i] = NetTxPacket + (i+1)*PKTSIZE_ALIGN;
372         }
373
374         if (!NetArpWaitTxPacket) {
375                 NetArpWaitTxPacket = &NetArpWaitPacketBuf[0] + (PKTALIGN - 1);
376                 NetArpWaitTxPacket -= (ulong)NetArpWaitTxPacket % PKTALIGN;
377                 NetArpWaitTxPacketSize = 0;
378         }
379
380         eth_halt();
381 #ifdef CONFIG_NET_MULTI
382         eth_set_current();
383 #endif
384         if (eth_init(bd) < 0) {
385                 eth_halt();
386                 return -1;
387         }
388
389 restart:
390 #ifdef CONFIG_NET_MULTI
391         memcpy(NetOurEther, eth_get_dev()->enetaddr, 6);
392 #else
393         eth_getenv_enetaddr("ethaddr", NetOurEther);
394 #endif
395
396         NetState = NETLOOP_CONTINUE;
397
398         /*
399          *      Start the ball rolling with the given start function.  From
400          *      here on, this code is a state machine driven by received
401          *      packets and timer events.
402          */
403         NetInitLoop(protocol);
404
405         switch (net_check_prereq(protocol)) {
406         case 1:
407                 /* network not configured */
408                 eth_halt();
409                 return -1;
410
411 #ifdef CONFIG_NET_MULTI
412         case 2:
413                 /* network device not configured */
414                 break;
415 #endif /* CONFIG_NET_MULTI */
416
417         case 0:
418 #ifdef CONFIG_NET_MULTI
419                 NetDevExists = 1;
420 #endif
421                 switch (protocol) {
422                 case TFTP:
423                         /* always use ARP to get server ethernet address */
424                         TftpStart();
425                         break;
426
427 #if defined(CONFIG_CMD_DHCP)
428                 case DHCP:
429                         BootpTry = 0;
430                         NetOurIP = 0;
431                         DhcpRequest();          /* Basically same as BOOTP */
432                         break;
433 #endif
434
435                 case BOOTP:
436                         BootpTry = 0;
437                         NetOurIP = 0;
438                         BootpRequest();
439                         break;
440
441 #if defined(CONFIG_CMD_RARP)
442                 case RARP:
443                         RarpTry = 0;
444                         NetOurIP = 0;
445                         RarpRequest();
446                         break;
447 #endif
448 #if defined(CONFIG_CMD_PING)
449                 case PING:
450                         PingStart();
451                         break;
452 #endif
453 #if defined(CONFIG_CMD_NFS)
454                 case NFS:
455                         NfsStart();
456                         break;
457 #endif
458 #if defined(CONFIG_CMD_CDP)
459                 case CDP:
460                         CDPStart();
461                         break;
462 #endif
463 #ifdef CONFIG_NETCONSOLE
464                 case NETCONS:
465                         NcStart();
466                         break;
467 #endif
468 #if defined(CONFIG_CMD_SNTP)
469                 case SNTP:
470                         SntpStart();
471                         break;
472 #endif
473 #if defined(CONFIG_CMD_DNS)
474                 case DNS:
475                         DnsStart();
476                         break;
477 #endif
478                 default:
479                         break;
480                 }
481
482                 NetBootFileXferSize = 0;
483                 break;
484         }
485
486 #if defined(CONFIG_MII) || defined(CONFIG_CMD_MII)
487 #if     defined(CONFIG_SYS_FAULT_ECHO_LINK_DOWN)        && \
488         defined(CONFIG_STATUS_LED)                      && \
489         defined(STATUS_LED_RED)
490         /*
491          * Echo the inverted link state to the fault LED.
492          */
493         if (miiphy_link(eth_get_dev()->name, CONFIG_SYS_FAULT_MII_ADDR))
494                 status_led_set(STATUS_LED_RED, STATUS_LED_OFF);
495         else
496                 status_led_set(STATUS_LED_RED, STATUS_LED_ON);
497 #endif /* CONFIG_SYS_FAULT_ECHO_LINK_DOWN, ... */
498 #endif /* CONFIG_MII, ... */
499
500         /*
501          *      Main packet reception loop.  Loop receiving packets until
502          *      someone sets `NetState' to a state that terminates.
503          */
504         for (;;) {
505                 WATCHDOG_RESET();
506 #ifdef CONFIG_SHOW_ACTIVITY
507                 {
508                         extern void show_activity(int arg);
509                         show_activity(1);
510                 }
511 #endif
512                 /*
513                  *      Check the ethernet for a new packet.  The ethernet
514                  *      receive routine will process it.
515                  */
516                 eth_rx();
517
518                 /*
519                  *      Abort if ctrl-c was pressed.
520                  */
521                 if (ctrlc()) {
522                         eth_halt();
523                         puts("\nAbort\n");
524                         return -1;
525                 }
526
527                 ArpTimeoutCheck();
528
529                 /*
530                  *      Check for a timeout, and run the timeout handler
531                  *      if we have one.
532                  */
533                 if (timeHandler && ((get_timer(0) - timeStart) > timeDelta)) {
534                         thand_f *x;
535
536 #if defined(CONFIG_MII) || defined(CONFIG_CMD_MII)
537 #if     defined(CONFIG_SYS_FAULT_ECHO_LINK_DOWN)        && \
538         defined(CONFIG_STATUS_LED)                      && \
539         defined(STATUS_LED_RED)
540                         /*
541                          * Echo the inverted link state to the fault LED.
542                          */
543                         if (miiphy_link(eth_get_dev()->name,
544                                        CONFIG_SYS_FAULT_MII_ADDR)) {
545                                 status_led_set(STATUS_LED_RED, STATUS_LED_OFF);
546                         } else {
547                                 status_led_set(STATUS_LED_RED, STATUS_LED_ON);
548                         }
549 #endif /* CONFIG_SYS_FAULT_ECHO_LINK_DOWN, ... */
550 #endif /* CONFIG_MII, ... */
551                         x = timeHandler;
552                         timeHandler = (thand_f *)0;
553                         (*x)();
554                 }
555
556
557                 switch (NetState) {
558
559                 case NETLOOP_RESTART:
560 #ifdef CONFIG_NET_MULTI
561                         NetRestarted = 1;
562 #endif
563                         goto restart;
564
565                 case NETLOOP_SUCCESS:
566                         if (NetBootFileXferSize > 0) {
567                                 char buf[20];
568                                 printf("Bytes transferred = %ld (%lx hex)\n",
569                                         NetBootFileXferSize,
570                                         NetBootFileXferSize);
571                                 sprintf(buf, "%lX", NetBootFileXferSize);
572                                 setenv("filesize", buf);
573
574                                 sprintf(buf, "%lX", (unsigned long)load_addr);
575                                 setenv("fileaddr", buf);
576                         }
577                         eth_halt();
578                         return NetBootFileXferSize;
579
580                 case NETLOOP_FAIL:
581                         return -1;
582                 }
583         }
584 }
585
586 /**********************************************************************/
587
588 static void
589 startAgainTimeout(void)
590 {
591         NetState = NETLOOP_RESTART;
592 }
593
594 static void
595 startAgainHandler(uchar *pkt, unsigned dest, IPaddr_t sip,
596                   unsigned src, unsigned len)
597 {
598         /* Totally ignore the packet */
599 }
600
601 void NetStartAgain(void)
602 {
603         char *nretry;
604         int retry_forever = 0;
605         unsigned long retrycnt = 0;
606
607         nretry = getenv("netretry");
608         if (nretry) {
609                 if (!strcmp(nretry, "yes"))
610                         retry_forever = 1;
611                 else if (!strcmp(nretry, "no"))
612                         retrycnt = 0;
613                 else if (!strcmp(nretry, "once"))
614                         retrycnt = 1;
615                 else
616                         retrycnt = simple_strtoul(nretry, NULL, 0);
617         } else
618                 retry_forever = 1;
619
620         if ((!retry_forever) && (NetTryCount >= retrycnt)) {
621                 eth_halt();
622                 NetState = NETLOOP_FAIL;
623                 return;
624         }
625
626         NetTryCount++;
627
628 #ifndef CONFIG_NET_MULTI
629         NetSetTimeout(10000UL, startAgainTimeout);
630         NetSetHandler(startAgainHandler);
631 #else   /* !CONFIG_NET_MULTI*/
632         eth_halt();
633 #if !defined(CONFIG_NET_DO_NOT_TRY_ANOTHER)
634         eth_try_another(!NetRestarted);
635 #endif
636         eth_init(gd->bd);
637         if (NetRestartWrap) {
638                 NetRestartWrap = 0;
639                 if (NetDevExists) {
640                         NetSetTimeout(10000UL, startAgainTimeout);
641                         NetSetHandler(startAgainHandler);
642                 } else {
643                         NetState = NETLOOP_FAIL;
644                 }
645         } else {
646                 NetState = NETLOOP_RESTART;
647         }
648 #endif  /* CONFIG_NET_MULTI */
649 }
650
651 /**********************************************************************/
652 /*
653  *      Miscelaneous bits.
654  */
655
656 void
657 NetSetHandler(rxhand_f *f)
658 {
659         packetHandler = f;
660 }
661
662
663 void
664 NetSetTimeout(ulong iv, thand_f *f)
665 {
666         if (iv == 0) {
667                 timeHandler = (thand_f *)0;
668         } else {
669                 timeHandler = f;
670                 timeStart = get_timer(0);
671                 timeDelta = iv;
672         }
673 }
674
675
676 void
677 NetSendPacket(volatile uchar *pkt, int len)
678 {
679         (void) eth_send(pkt, len);
680 }
681
682 int
683 NetSendUDPPacket(uchar *ether, IPaddr_t dest, int dport, int sport, int len)
684 {
685         uchar *pkt;
686
687         /* convert to new style broadcast */
688         if (dest == 0)
689                 dest = 0xFFFFFFFF;
690
691         /* if broadcast, make the ether address a broadcast and don't do ARP */
692         if (dest == 0xFFFFFFFF)
693                 ether = NetBcastAddr;
694
695         /*
696          * if MAC address was not discovered yet, save the packet and do
697          * an ARP request
698          */
699         if (memcmp(ether, NetEtherNullAddr, 6) == 0) {
700
701                 debug("sending ARP for %08lx\n", dest);
702
703                 NetArpWaitPacketIP = dest;
704                 NetArpWaitPacketMAC = ether;
705
706                 pkt = NetArpWaitTxPacket;
707                 pkt += NetSetEther(pkt, NetArpWaitPacketMAC, PROT_IP);
708
709                 NetSetIP(pkt, dest, dport, sport, len);
710                 memcpy(pkt + IP_HDR_SIZE, (uchar *)NetTxPacket +
711                        (pkt - (uchar *)NetArpWaitTxPacket) + IP_HDR_SIZE, len);
712
713                 /* size of the waiting packet */
714                 NetArpWaitTxPacketSize = (pkt - NetArpWaitTxPacket) +
715                         IP_HDR_SIZE + len;
716
717                 /* and do the ARP request */
718                 NetArpWaitTry = 1;
719                 NetArpWaitTimerStart = get_timer(0);
720                 ArpRequest();
721                 return 1;       /* waiting */
722         }
723
724         debug("sending UDP to %08lx/%pM\n", dest, ether);
725
726         pkt = (uchar *)NetTxPacket;
727         pkt += NetSetEther(pkt, ether, PROT_IP);
728         NetSetIP(pkt, dest, dport, sport, len);
729         (void) eth_send(NetTxPacket, (pkt - NetTxPacket) + IP_HDR_SIZE + len);
730
731         return 0;       /* transmitted */
732 }
733
734 #if defined(CONFIG_CMD_PING)
735 static ushort PingSeqNo;
736
737 int PingSend(void)
738 {
739         static uchar mac[6];
740         volatile IP_t *ip;
741         volatile ushort *s;
742         uchar *pkt;
743
744         /* XXX always send arp request */
745
746         memcpy(mac, NetEtherNullAddr, 6);
747
748         debug("sending ARP for %08lx\n", NetPingIP);
749
750         NetArpWaitPacketIP = NetPingIP;
751         NetArpWaitPacketMAC = mac;
752
753         pkt = NetArpWaitTxPacket;
754         pkt += NetSetEther(pkt, mac, PROT_IP);
755
756         ip = (volatile IP_t *)pkt;
757
758         /*
759          * Construct an IP and ICMP header.
760          * (need to set no fragment bit - XXX)
761          */
762         /* IP_HDR_SIZE / 4 (not including UDP) */
763         ip->ip_hl_v  = 0x45;
764         ip->ip_tos   = 0;
765         ip->ip_len   = htons(IP_HDR_SIZE_NO_UDP + 8);
766         ip->ip_id    = htons(NetIPID++);
767         ip->ip_off   = htons(IP_FLAGS_DFRAG);   /* Don't fragment */
768         ip->ip_ttl   = 255;
769         ip->ip_p     = 0x01;            /* ICMP */
770         ip->ip_sum   = 0;
771         /* already in network byte order */
772         NetCopyIP((void *)&ip->ip_src, &NetOurIP);
773         /* - "" - */
774         NetCopyIP((void *)&ip->ip_dst, &NetPingIP);
775         ip->ip_sum   = ~NetCksum((uchar *)ip, IP_HDR_SIZE_NO_UDP / 2);
776
777         s = &ip->udp_src;               /* XXX ICMP starts here */
778         s[0] = htons(0x0800);           /* echo-request, code */
779         s[1] = 0;                       /* checksum */
780         s[2] = 0;                       /* identifier */
781         s[3] = htons(PingSeqNo++);      /* sequence number */
782         s[1] = ~NetCksum((uchar *)s, 8/2);
783
784         /* size of the waiting packet */
785         NetArpWaitTxPacketSize =
786                 (pkt - NetArpWaitTxPacket) + IP_HDR_SIZE_NO_UDP + 8;
787
788         /* and do the ARP request */
789         NetArpWaitTry = 1;
790         NetArpWaitTimerStart = get_timer(0);
791         ArpRequest();
792         return 1;       /* waiting */
793 }
794
795 static void
796 PingTimeout(void)
797 {
798         eth_halt();
799         NetState = NETLOOP_FAIL;        /* we did not get the reply */
800 }
801
802 static void
803 PingHandler(uchar *pkt, unsigned dest, IPaddr_t sip, unsigned src,
804             unsigned len)
805 {
806         if (sip != NetPingIP)
807                 return;
808
809         NetState = NETLOOP_SUCCESS;
810 }
811
812 static void PingStart(void)
813 {
814 #if defined(CONFIG_NET_MULTI)
815         printf("Using %s device\n", eth_get_name());
816 #endif  /* CONFIG_NET_MULTI */
817         NetSetTimeout(10000UL, PingTimeout);
818         NetSetHandler(PingHandler);
819
820         PingSend();
821 }
822 #endif
823
824 #if defined(CONFIG_CMD_CDP)
825
826 #define CDP_DEVICE_ID_TLV               0x0001
827 #define CDP_ADDRESS_TLV                 0x0002
828 #define CDP_PORT_ID_TLV                 0x0003
829 #define CDP_CAPABILITIES_TLV            0x0004
830 #define CDP_VERSION_TLV                 0x0005
831 #define CDP_PLATFORM_TLV                0x0006
832 #define CDP_NATIVE_VLAN_TLV             0x000a
833 #define CDP_APPLIANCE_VLAN_TLV          0x000e
834 #define CDP_TRIGGER_TLV                 0x000f
835 #define CDP_POWER_CONSUMPTION_TLV       0x0010
836 #define CDP_SYSNAME_TLV                 0x0014
837 #define CDP_SYSOBJECT_TLV               0x0015
838 #define CDP_MANAGEMENT_ADDRESS_TLV      0x0016
839
840 #define CDP_TIMEOUT                     250UL   /* one packet every 250ms */
841
842 static int CDPSeq;
843 static int CDPOK;
844
845 ushort CDPNativeVLAN;
846 ushort CDPApplianceVLAN;
847
848 static const uchar CDP_SNAP_hdr[8] = { 0xAA, 0xAA, 0x03, 0x00, 0x00, 0x0C, 0x20,
849                                        0x00 };
850
851 static ushort CDP_compute_csum(const uchar *buff, ushort len)
852 {
853         ushort csum;
854         int     odd;
855         ulong   result = 0;
856         ushort  leftover;
857         ushort *p;
858
859         if (len > 0) {
860                 odd = 1 & (ulong)buff;
861                 if (odd) {
862                         result = *buff << 8;
863                         len--;
864                         buff++;
865                 }
866                 while (len > 1) {
867                         p = (ushort *)buff;
868                         result += *p++;
869                         buff = (uchar *)p;
870                         if (result & 0x80000000)
871                                 result = (result & 0xFFFF) + (result >> 16);
872                         len -= 2;
873                 }
874                 if (len) {
875                         leftover = (signed short)(*(const signed char *)buff);
876                         /* CISCO SUCKS big time! (and blows too):
877                          * CDP uses the IP checksum algorithm with a twist;
878                          * for the last byte it *sign* extends and sums.
879                          */
880                         result = (result & 0xffff0000) |
881                                  ((result + leftover) & 0x0000ffff);
882                 }
883                 while (result >> 16)
884                         result = (result & 0xFFFF) + (result >> 16);
885
886                 if (odd)
887                         result = ((result >> 8) & 0xff) |
888                                  ((result & 0xff) << 8);
889         }
890
891         /* add up 16-bit and 17-bit words for 17+c bits */
892         result = (result & 0xffff) + (result >> 16);
893         /* add up 16-bit and 2-bit for 16+c bit */
894         result = (result & 0xffff) + (result >> 16);
895         /* add up carry.. */
896         result = (result & 0xffff) + (result >> 16);
897
898         /* negate */
899         csum = ~(ushort)result;
900
901         /* run time endian detection */
902         if (csum != htons(csum))        /* little endian */
903                 csum = htons(csum);
904
905         return csum;
906 }
907
908 int CDPSendTrigger(void)
909 {
910         volatile uchar *pkt;
911         volatile ushort *s;
912         volatile ushort *cp;
913         Ethernet_t *et;
914         int len;
915         ushort chksum;
916 #if     defined(CONFIG_CDP_DEVICE_ID) || defined(CONFIG_CDP_PORT_ID)   || \
917         defined(CONFIG_CDP_VERSION)   || defined(CONFIG_CDP_PLATFORM)
918         char buf[32];
919 #endif
920
921         pkt = NetTxPacket;
922         et = (Ethernet_t *)pkt;
923
924         /* NOTE: trigger sent not on any VLAN */
925
926         /* form ethernet header */
927         memcpy(et->et_dest, NetCDPAddr, 6);
928         memcpy(et->et_src, NetOurEther, 6);
929
930         pkt += ETHER_HDR_SIZE;
931
932         /* SNAP header */
933         memcpy((uchar *)pkt, CDP_SNAP_hdr, sizeof(CDP_SNAP_hdr));
934         pkt += sizeof(CDP_SNAP_hdr);
935
936         /* CDP header */
937         *pkt++ = 0x02;                          /* CDP version 2 */
938         *pkt++ = 180;                           /* TTL */
939         s = (volatile ushort *)pkt;
940         cp = s;
941         /* checksum (0 for later calculation) */
942         *s++ = htons(0);
943
944         /* CDP fields */
945 #ifdef CONFIG_CDP_DEVICE_ID
946         *s++ = htons(CDP_DEVICE_ID_TLV);
947         *s++ = htons(CONFIG_CDP_DEVICE_ID);
948         sprintf(buf, CONFIG_CDP_DEVICE_ID_PREFIX "%pm", NetOurEther);
949         memcpy((uchar *)s, buf, 16);
950         s += 16 / 2;
951 #endif
952
953 #ifdef CONFIG_CDP_PORT_ID
954         *s++ = htons(CDP_PORT_ID_TLV);
955         memset(buf, 0, sizeof(buf));
956         sprintf(buf, CONFIG_CDP_PORT_ID, eth_get_dev_index());
957         len = strlen(buf);
958         if (len & 1)    /* make it even */
959                 len++;
960         *s++ = htons(len + 4);
961         memcpy((uchar *)s, buf, len);
962         s += len / 2;
963 #endif
964
965 #ifdef CONFIG_CDP_CAPABILITIES
966         *s++ = htons(CDP_CAPABILITIES_TLV);
967         *s++ = htons(8);
968         *(ulong *)s = htonl(CONFIG_CDP_CAPABILITIES);
969         s += 2;
970 #endif
971
972 #ifdef CONFIG_CDP_VERSION
973         *s++ = htons(CDP_VERSION_TLV);
974         memset(buf, 0, sizeof(buf));
975         strcpy(buf, CONFIG_CDP_VERSION);
976         len = strlen(buf);
977         if (len & 1)    /* make it even */
978                 len++;
979         *s++ = htons(len + 4);
980         memcpy((uchar *)s, buf, len);
981         s += len / 2;
982 #endif
983
984 #ifdef CONFIG_CDP_PLATFORM
985         *s++ = htons(CDP_PLATFORM_TLV);
986         memset(buf, 0, sizeof(buf));
987         strcpy(buf, CONFIG_CDP_PLATFORM);
988         len = strlen(buf);
989         if (len & 1)    /* make it even */
990                 len++;
991         *s++ = htons(len + 4);
992         memcpy((uchar *)s, buf, len);
993         s += len / 2;
994 #endif
995
996 #ifdef CONFIG_CDP_TRIGGER
997         *s++ = htons(CDP_TRIGGER_TLV);
998         *s++ = htons(8);
999         *(ulong *)s = htonl(CONFIG_CDP_TRIGGER);
1000         s += 2;
1001 #endif
1002
1003 #ifdef CONFIG_CDP_POWER_CONSUMPTION
1004         *s++ = htons(CDP_POWER_CONSUMPTION_TLV);
1005         *s++ = htons(6);
1006         *s++ = htons(CONFIG_CDP_POWER_CONSUMPTION);
1007 #endif
1008
1009         /* length of ethernet packet */
1010         len = (uchar *)s - ((uchar *)NetTxPacket + ETHER_HDR_SIZE);
1011         et->et_protlen = htons(len);
1012
1013         len = ETHER_HDR_SIZE + sizeof(CDP_SNAP_hdr);
1014         chksum = CDP_compute_csum((uchar *)NetTxPacket + len,
1015                                   (uchar *)s - (NetTxPacket + len));
1016         if (chksum == 0)
1017                 chksum = 0xFFFF;
1018         *cp = htons(chksum);
1019
1020         (void) eth_send(NetTxPacket, (uchar *)s - NetTxPacket);
1021         return 0;
1022 }
1023
1024 static void
1025 CDPTimeout(void)
1026 {
1027         CDPSeq++;
1028
1029         if (CDPSeq < 3) {
1030                 NetSetTimeout(CDP_TIMEOUT, CDPTimeout);
1031                 CDPSendTrigger();
1032                 return;
1033         }
1034
1035         /* if not OK try again */
1036         if (!CDPOK)
1037                 NetStartAgain();
1038         else
1039                 NetState = NETLOOP_SUCCESS;
1040 }
1041
1042 static void
1043 CDPDummyHandler(uchar *pkt, unsigned dest, IPaddr_t sip, unsigned src,
1044                 unsigned len)
1045 {
1046         /* nothing */
1047 }
1048
1049 static void
1050 CDPHandler(const uchar *pkt, unsigned len)
1051 {
1052         const uchar *t;
1053         const ushort *ss;
1054         ushort type, tlen;
1055         uchar applid;
1056         ushort vlan, nvlan;
1057
1058         /* minimum size? */
1059         if (len < sizeof(CDP_SNAP_hdr) + 4)
1060                 goto pkt_short;
1061
1062         /* check for valid CDP SNAP header */
1063         if (memcmp(pkt, CDP_SNAP_hdr, sizeof(CDP_SNAP_hdr)) != 0)
1064                 return;
1065
1066         pkt += sizeof(CDP_SNAP_hdr);
1067         len -= sizeof(CDP_SNAP_hdr);
1068
1069         /* Version of CDP protocol must be >= 2 and TTL != 0 */
1070         if (pkt[0] < 0x02 || pkt[1] == 0)
1071                 return;
1072
1073         /*
1074          * if version is greater than 0x02 maybe we'll have a problem;
1075          * output a warning
1076          */
1077         if (pkt[0] != 0x02)
1078                 printf("** WARNING: CDP packet received with a protocol version %d > 2\n",
1079                                 pkt[0] & 0xff);
1080
1081         if (CDP_compute_csum(pkt, len) != 0)
1082                 return;
1083
1084         pkt += 4;
1085         len -= 4;
1086
1087         vlan = htons(-1);
1088         nvlan = htons(-1);
1089         while (len > 0) {
1090                 if (len < 4)
1091                         goto pkt_short;
1092
1093                 ss = (const ushort *)pkt;
1094                 type = ntohs(ss[0]);
1095                 tlen = ntohs(ss[1]);
1096                 if (tlen > len)
1097                         goto pkt_short;
1098
1099                 pkt += tlen;
1100                 len -= tlen;
1101
1102                 ss += 2;        /* point ss to the data of the TLV */
1103                 tlen -= 4;
1104
1105                 switch (type) {
1106                 case CDP_DEVICE_ID_TLV:
1107                         break;
1108                 case CDP_ADDRESS_TLV:
1109                         break;
1110                 case CDP_PORT_ID_TLV:
1111                         break;
1112                 case CDP_CAPABILITIES_TLV:
1113                         break;
1114                 case CDP_VERSION_TLV:
1115                         break;
1116                 case CDP_PLATFORM_TLV:
1117                         break;
1118                 case CDP_NATIVE_VLAN_TLV:
1119                         nvlan = *ss;
1120                         break;
1121                 case CDP_APPLIANCE_VLAN_TLV:
1122                         t = (const uchar *)ss;
1123                         while (tlen > 0) {
1124                                 if (tlen < 3)
1125                                         goto pkt_short;
1126
1127                                 applid = t[0];
1128                                 ss = (const ushort *)(t + 1);
1129
1130 #ifdef CONFIG_CDP_APPLIANCE_VLAN_TYPE
1131                                 if (applid == CONFIG_CDP_APPLIANCE_VLAN_TYPE)
1132                                         vlan = *ss;
1133 #else
1134                                 /* XXX will this work; dunno */
1135                                 vlan = ntohs(*ss);
1136 #endif
1137                                 t += 3; tlen -= 3;
1138                         }
1139                         break;
1140                 case CDP_TRIGGER_TLV:
1141                         break;
1142                 case CDP_POWER_CONSUMPTION_TLV:
1143                         break;
1144                 case CDP_SYSNAME_TLV:
1145                         break;
1146                 case CDP_SYSOBJECT_TLV:
1147                         break;
1148                 case CDP_MANAGEMENT_ADDRESS_TLV:
1149                         break;
1150                 }
1151         }
1152
1153         CDPApplianceVLAN = vlan;
1154         CDPNativeVLAN = nvlan;
1155
1156         CDPOK = 1;
1157         return;
1158
1159  pkt_short:
1160         printf("** CDP packet is too short\n");
1161         return;
1162 }
1163
1164 static void CDPStart(void)
1165 {
1166 #if defined(CONFIG_NET_MULTI)
1167         printf("Using %s device\n", eth_get_name());
1168 #endif
1169         CDPSeq = 0;
1170         CDPOK = 0;
1171
1172         CDPNativeVLAN = htons(-1);
1173         CDPApplianceVLAN = htons(-1);
1174
1175         NetSetTimeout(CDP_TIMEOUT, CDPTimeout);
1176         NetSetHandler(CDPDummyHandler);
1177
1178         CDPSendTrigger();
1179 }
1180 #endif
1181
1182 #ifdef CONFIG_IP_DEFRAG
1183 /*
1184  * This function collects fragments in a single packet, according
1185  * to the algorithm in RFC815. It returns NULL or the pointer to
1186  * a complete packet, in static storage
1187  */
1188 #ifndef CONFIG_NET_MAXDEFRAG
1189 #define CONFIG_NET_MAXDEFRAG 16384
1190 #endif
1191 /*
1192  * MAXDEFRAG, above, is chosen in the config file and  is real data
1193  * so we need to add the NFS overhead, which is more than TFTP.
1194  * To use sizeof in the internal unnamed structures, we need a real
1195  * instance (can't do "sizeof(struct rpc_t.u.reply))", unfortunately).
1196  * The compiler doesn't complain nor allocates the actual structure
1197  */
1198 static struct rpc_t rpc_specimen;
1199 #define IP_PKTSIZE (CONFIG_NET_MAXDEFRAG + sizeof(rpc_specimen.u.reply))
1200
1201 #define IP_MAXUDP (IP_PKTSIZE - IP_HDR_SIZE_NO_UDP)
1202
1203 /*
1204  * this is the packet being assembled, either data or frag control.
1205  * Fragments go by 8 bytes, so this union must be 8 bytes long
1206  */
1207 struct hole {
1208         /* first_byte is address of this structure */
1209         u16 last_byte;  /* last byte in this hole + 1 (begin of next hole) */
1210         u16 next_hole;  /* index of next (in 8-b blocks), 0 == none */
1211         u16 prev_hole;  /* index of prev, 0 == none */
1212         u16 unused;
1213 };
1214
1215 static IP_t *__NetDefragment(IP_t *ip, int *lenp)
1216 {
1217         static uchar pkt_buff[IP_PKTSIZE] __attribute__((aligned(PKTALIGN)));
1218         static u16 first_hole, total_len;
1219         struct hole *payload, *thisfrag, *h, *newh;
1220         IP_t *localip = (IP_t *)pkt_buff;
1221         uchar *indata = (uchar *)ip;
1222         int offset8, start, len, done = 0;
1223         u16 ip_off = ntohs(ip->ip_off);
1224
1225         /* payload starts after IP header, this fragment is in there */
1226         payload = (struct hole *)(pkt_buff + IP_HDR_SIZE_NO_UDP);
1227         offset8 =  (ip_off & IP_OFFS);
1228         thisfrag = payload + offset8;
1229         start = offset8 * 8;
1230         len = ntohs(ip->ip_len) - IP_HDR_SIZE_NO_UDP;
1231
1232         if (start + len > IP_MAXUDP) /* fragment extends too far */
1233                 return NULL;
1234
1235         if (!total_len || localip->ip_id != ip->ip_id) {
1236                 /* new (or different) packet, reset structs */
1237                 total_len = 0xffff;
1238                 payload[0].last_byte = ~0;
1239                 payload[0].next_hole = 0;
1240                 payload[0].prev_hole = 0;
1241                 first_hole = 0;
1242                 /* any IP header will work, copy the first we received */
1243                 memcpy(localip, ip, IP_HDR_SIZE_NO_UDP);
1244         }
1245
1246         /*
1247          * What follows is the reassembly algorithm. We use the payload
1248          * array as a linked list of hole descriptors, as each hole starts
1249          * at a multiple of 8 bytes. However, last byte can be whatever value,
1250          * so it is represented as byte count, not as 8-byte blocks.
1251          */
1252
1253         h = payload + first_hole;
1254         while (h->last_byte < start) {
1255                 if (!h->next_hole) {
1256                         /* no hole that far away */
1257                         return NULL;
1258                 }
1259                 h = payload + h->next_hole;
1260         }
1261
1262         /* last fragment may be 1..7 bytes, the "+7" forces acceptance */
1263         if (offset8 + ((len + 7) / 8) <= h - payload) {
1264                 /* no overlap with holes (dup fragment?) */
1265                 return NULL;
1266         }
1267
1268         if (!(ip_off & IP_FLAGS_MFRAG)) {
1269                 /* no more fragmentss: truncate this (last) hole */
1270                 total_len = start + len;
1271                 h->last_byte = start + len;
1272         }
1273
1274         /*
1275          * There is some overlap: fix the hole list. This code doesn't
1276          * deal with a fragment that overlaps with two different holes
1277          * (thus being a superset of a previously-received fragment).
1278          */
1279
1280         if ((h >= thisfrag) && (h->last_byte <= start + len)) {
1281                 /* complete overlap with hole: remove hole */
1282                 if (!h->prev_hole && !h->next_hole) {
1283                         /* last remaining hole */
1284                         done = 1;
1285                 } else if (!h->prev_hole) {
1286                         /* first hole */
1287                         first_hole = h->next_hole;
1288                         payload[h->next_hole].prev_hole = 0;
1289                 } else if (!h->next_hole) {
1290                         /* last hole */
1291                         payload[h->prev_hole].next_hole = 0;
1292                 } else {
1293                         /* in the middle of the list */
1294                         payload[h->next_hole].prev_hole = h->prev_hole;
1295                         payload[h->prev_hole].next_hole = h->next_hole;
1296                 }
1297
1298         } else if (h->last_byte <= start + len) {
1299                 /* overlaps with final part of the hole: shorten this hole */
1300                 h->last_byte = start;
1301
1302         } else if (h >= thisfrag) {
1303                 /* overlaps with initial part of the hole: move this hole */
1304                 newh = thisfrag + (len / 8);
1305                 *newh = *h;
1306                 h = newh;
1307                 if (h->next_hole)
1308                         payload[h->next_hole].prev_hole = (h - payload);
1309                 if (h->prev_hole)
1310                         payload[h->prev_hole].next_hole = (h - payload);
1311                 else
1312                         first_hole = (h - payload);
1313
1314         } else {
1315                 /* fragment sits in the middle: split the hole */
1316                 newh = thisfrag + (len / 8);
1317                 *newh = *h;
1318                 h->last_byte = start;
1319                 h->next_hole = (newh - payload);
1320                 newh->prev_hole = (h - payload);
1321                 if (newh->next_hole)
1322                         payload[newh->next_hole].prev_hole = (newh - payload);
1323         }
1324
1325         /* finally copy this fragment and possibly return whole packet */
1326         memcpy((uchar *)thisfrag, indata + IP_HDR_SIZE_NO_UDP, len);
1327         if (!done)
1328                 return NULL;
1329
1330         localip->ip_len = htons(total_len);
1331         *lenp = total_len + IP_HDR_SIZE_NO_UDP;
1332         return localip;
1333 }
1334
1335 static inline IP_t *NetDefragment(IP_t *ip, int *lenp)
1336 {
1337         u16 ip_off = ntohs(ip->ip_off);
1338         if (!(ip_off & (IP_OFFS | IP_FLAGS_MFRAG)))
1339                 return ip; /* not a fragment */
1340         return __NetDefragment(ip, lenp);
1341 }
1342
1343 #else /* !CONFIG_IP_DEFRAG */
1344
1345 static inline IP_t *NetDefragment(IP_t *ip, int *lenp)
1346 {
1347         u16 ip_off = ntohs(ip->ip_off);
1348         if (!(ip_off & (IP_OFFS | IP_FLAGS_MFRAG)))
1349                 return ip; /* not a fragment */
1350         return NULL;
1351 }
1352 #endif
1353
1354 void
1355 NetReceive(volatile uchar *inpkt, int len)
1356 {
1357         Ethernet_t *et;
1358         IP_t    *ip;
1359         ARP_t   *arp;
1360         IPaddr_t tmp;
1361         IPaddr_t src_ip;
1362         int     x;
1363         uchar *pkt;
1364 #if defined(CONFIG_CMD_CDP)
1365         int iscdp;
1366 #endif
1367         ushort cti = 0, vlanid = VLAN_NONE, myvlanid, mynvlanid;
1368
1369         debug("packet received\n");
1370
1371         NetRxPacket = inpkt;
1372         NetRxPacketLen = len;
1373         et = (Ethernet_t *)inpkt;
1374
1375         /* too small packet? */
1376         if (len < ETHER_HDR_SIZE)
1377                 return;
1378
1379 #ifdef CONFIG_API
1380         if (push_packet) {
1381                 (*push_packet)(inpkt, len);
1382                 return;
1383         }
1384 #endif
1385
1386 #if defined(CONFIG_CMD_CDP)
1387         /* keep track if packet is CDP */
1388         iscdp = memcmp(et->et_dest, NetCDPAddr, 6) == 0;
1389 #endif
1390
1391         myvlanid = ntohs(NetOurVLAN);
1392         if (myvlanid == (ushort)-1)
1393                 myvlanid = VLAN_NONE;
1394         mynvlanid = ntohs(NetOurNativeVLAN);
1395         if (mynvlanid == (ushort)-1)
1396                 mynvlanid = VLAN_NONE;
1397
1398         x = ntohs(et->et_protlen);
1399
1400         debug("packet received\n");
1401
1402         if (x < 1514) {
1403                 /*
1404                  *      Got a 802 packet.  Check the other protocol field.
1405                  */
1406                 x = ntohs(et->et_prot);
1407
1408                 ip = (IP_t *)(inpkt + E802_HDR_SIZE);
1409                 len -= E802_HDR_SIZE;
1410
1411         } else if (x != PROT_VLAN) {    /* normal packet */
1412                 ip = (IP_t *)(inpkt + ETHER_HDR_SIZE);
1413                 len -= ETHER_HDR_SIZE;
1414
1415         } else {                        /* VLAN packet */
1416                 VLAN_Ethernet_t *vet = (VLAN_Ethernet_t *)et;
1417
1418                 debug("VLAN packet received\n");
1419
1420                 /* too small packet? */
1421                 if (len < VLAN_ETHER_HDR_SIZE)
1422                         return;
1423
1424                 /* if no VLAN active */
1425                 if ((ntohs(NetOurVLAN) & VLAN_IDMASK) == VLAN_NONE
1426 #if defined(CONFIG_CMD_CDP)
1427                                 && iscdp == 0
1428 #endif
1429                                 )
1430                         return;
1431
1432                 cti = ntohs(vet->vet_tag);
1433                 vlanid = cti & VLAN_IDMASK;
1434                 x = ntohs(vet->vet_type);
1435
1436                 ip = (IP_t *)(inpkt + VLAN_ETHER_HDR_SIZE);
1437                 len -= VLAN_ETHER_HDR_SIZE;
1438         }
1439
1440         debug("Receive from protocol 0x%x\n", x);
1441
1442 #if defined(CONFIG_CMD_CDP)
1443         if (iscdp) {
1444                 CDPHandler((uchar *)ip, len);
1445                 return;
1446         }
1447 #endif
1448
1449         if ((myvlanid & VLAN_IDMASK) != VLAN_NONE) {
1450                 if (vlanid == VLAN_NONE)
1451                         vlanid = (mynvlanid & VLAN_IDMASK);
1452                 /* not matched? */
1453                 if (vlanid != (myvlanid & VLAN_IDMASK))
1454                         return;
1455         }
1456
1457         switch (x) {
1458
1459         case PROT_ARP:
1460                 /*
1461                  * We have to deal with two types of ARP packets:
1462                  * - REQUEST packets will be answered by sending  our
1463                  *   IP address - if we know it.
1464                  * - REPLY packates are expected only after we asked
1465                  *   for the TFTP server's or the gateway's ethernet
1466                  *   address; so if we receive such a packet, we set
1467                  *   the server ethernet address
1468                  */
1469                 debug("Got ARP\n");
1470
1471                 arp = (ARP_t *)ip;
1472                 if (len < ARP_HDR_SIZE) {
1473                         printf("bad length %d < %d\n", len, ARP_HDR_SIZE);
1474                         return;
1475                 }
1476                 if (ntohs(arp->ar_hrd) != ARP_ETHER)
1477                         return;
1478                 if (ntohs(arp->ar_pro) != PROT_IP)
1479                         return;
1480                 if (arp->ar_hln != 6)
1481                         return;
1482                 if (arp->ar_pln != 4)
1483                         return;
1484
1485                 if (NetOurIP == 0)
1486                         return;
1487
1488                 if (NetReadIP(&arp->ar_data[16]) != NetOurIP)
1489                         return;
1490
1491                 switch (ntohs(arp->ar_op)) {
1492                 case ARPOP_REQUEST:
1493                         /* reply with our IP address */
1494                         debug("Got ARP REQUEST, return our IP\n");
1495                         pkt = (uchar *)et;
1496                         pkt += NetSetEther(pkt, et->et_src, PROT_ARP);
1497                         arp->ar_op = htons(ARPOP_REPLY);
1498                         memcpy(&arp->ar_data[10], &arp->ar_data[0], 6);
1499                         NetCopyIP(&arp->ar_data[16], &arp->ar_data[6]);
1500                         memcpy(&arp->ar_data[0], NetOurEther, 6);
1501                         NetCopyIP(&arp->ar_data[6], &NetOurIP);
1502                         (void) eth_send((uchar *)et,
1503                                         (pkt - (uchar *)et) + ARP_HDR_SIZE);
1504                         return;
1505
1506                 case ARPOP_REPLY:               /* arp reply */
1507                         /* are we waiting for a reply */
1508                         if (!NetArpWaitPacketIP || !NetArpWaitPacketMAC)
1509                                 break;
1510
1511 #ifdef CONFIG_KEEP_SERVERADDR
1512                         if (NetServerIP == NetArpWaitPacketIP) {
1513                                 char buf[20];
1514                                 sprintf(buf, "%pM", arp->ar_data);
1515                                 setenv("serveraddr", buf);
1516                         }
1517 #endif
1518
1519                         debug("Got ARP REPLY, set server/gtwy eth addr (%pM)\n",
1520                                 arp->ar_data);
1521
1522                         tmp = NetReadIP(&arp->ar_data[6]);
1523
1524                         /* matched waiting packet's address */
1525                         if (tmp == NetArpWaitReplyIP) {
1526                                 debug("Got it\n");
1527                                 /* save address for later use */
1528                                 memcpy(NetArpWaitPacketMAC,
1529                                        &arp->ar_data[0], 6);
1530
1531 #ifdef CONFIG_NETCONSOLE
1532                                 (*packetHandler)(0, 0, 0, 0, 0);
1533 #endif
1534                                 /* modify header, and transmit it */
1535                                 memcpy(((Ethernet_t *)NetArpWaitTxPacket)->et_dest, NetArpWaitPacketMAC, 6);
1536                                 (void) eth_send(NetArpWaitTxPacket,
1537                                                 NetArpWaitTxPacketSize);
1538
1539                                 /* no arp request pending now */
1540                                 NetArpWaitPacketIP = 0;
1541                                 NetArpWaitTxPacketSize = 0;
1542                                 NetArpWaitPacketMAC = NULL;
1543
1544                         }
1545                         return;
1546                 default:
1547                         debug("Unexpected ARP opcode 0x%x\n",
1548                               ntohs(arp->ar_op));
1549                         return;
1550                 }
1551                 break;
1552
1553 #ifdef CONFIG_CMD_RARP
1554         case PROT_RARP:
1555                 debug("Got RARP\n");
1556                 arp = (ARP_t *)ip;
1557                 if (len < ARP_HDR_SIZE) {
1558                         printf("bad length %d < %d\n", len, ARP_HDR_SIZE);
1559                         return;
1560                 }
1561
1562                 if ((ntohs(arp->ar_op) != RARPOP_REPLY) ||
1563                         (ntohs(arp->ar_hrd) != ARP_ETHER)   ||
1564                         (ntohs(arp->ar_pro) != PROT_IP)     ||
1565                         (arp->ar_hln != 6) || (arp->ar_pln != 4)) {
1566
1567                         puts("invalid RARP header\n");
1568                 } else {
1569                         NetCopyIP(&NetOurIP, &arp->ar_data[16]);
1570                         if (NetServerIP == 0)
1571                                 NetCopyIP(&NetServerIP, &arp->ar_data[6]);
1572                         memcpy(NetServerEther, &arp->ar_data[0], 6);
1573
1574                         (*packetHandler)(0, 0, 0, 0, 0);
1575                 }
1576                 break;
1577 #endif
1578         case PROT_IP:
1579                 debug("Got IP\n");
1580                 /* Before we start poking the header, make sure it is there */
1581                 if (len < IP_HDR_SIZE) {
1582                         debug("len bad %d < %lu\n", len, (ulong)IP_HDR_SIZE);
1583                         return;
1584                 }
1585                 /* Check the packet length */
1586                 if (len < ntohs(ip->ip_len)) {
1587                         printf("len bad %d < %d\n", len, ntohs(ip->ip_len));
1588                         return;
1589                 }
1590                 len = ntohs(ip->ip_len);
1591                 debug("len=%d, v=%02x\n", len, ip->ip_hl_v & 0xff);
1592
1593                 /* Can't deal with anything except IPv4 */
1594                 if ((ip->ip_hl_v & 0xf0) != 0x40)
1595                         return;
1596                 /* Can't deal with IP options (headers != 20 bytes) */
1597                 if ((ip->ip_hl_v & 0x0f) > 0x05)
1598                         return;
1599                 /* Check the Checksum of the header */
1600                 if (!NetCksumOk((uchar *)ip, IP_HDR_SIZE_NO_UDP / 2)) {
1601                         puts("checksum bad\n");
1602                         return;
1603                 }
1604                 /* If it is not for us, ignore it */
1605                 tmp = NetReadIP(&ip->ip_dst);
1606                 if (NetOurIP && tmp != NetOurIP && tmp != 0xFFFFFFFF) {
1607 #ifdef CONFIG_MCAST_TFTP
1608                         if (Mcast_addr != tmp)
1609 #endif
1610                                 return;
1611                 }
1612                 /* Read source IP address for later use */
1613                 src_ip = NetReadIP(&ip->ip_src);
1614                 /*
1615                  * The function returns the unchanged packet if it's not
1616                  * a fragment, and either the complete packet or NULL if
1617                  * it is a fragment (if !CONFIG_IP_DEFRAG, it returns NULL)
1618                  */
1619                 if (!(ip = NetDefragment(ip, &len)))
1620                         return;
1621                 /*
1622                  * watch for ICMP host redirects
1623                  *
1624                  * There is no real handler code (yet). We just watch
1625                  * for ICMP host redirect messages. In case anybody
1626                  * sees these messages: please contact me
1627                  * (wd@denx.de), or - even better - send me the
1628                  * necessary fixes :-)
1629                  *
1630                  * Note: in all cases where I have seen this so far
1631                  * it was a problem with the router configuration,
1632                  * for instance when a router was configured in the
1633                  * BOOTP reply, but the TFTP server was on the same
1634                  * subnet. So this is probably a warning that your
1635                  * configuration might be wrong. But I'm not really
1636                  * sure if there aren't any other situations.
1637                  */
1638                 if (ip->ip_p == IPPROTO_ICMP) {
1639                         ICMP_t *icmph = (ICMP_t *)&(ip->udp_src);
1640
1641                         switch (icmph->type) {
1642                         case ICMP_REDIRECT:
1643                                 if (icmph->code != ICMP_REDIR_HOST)
1644                                         return;
1645                                 printf(" ICMP Host Redirect to %pI4 ",
1646                                         &icmph->un.gateway);
1647                                 return;
1648 #if defined(CONFIG_CMD_PING)
1649                         case ICMP_ECHO_REPLY:
1650                                 /*
1651                                  * IP header OK.  Pass the packet to the
1652                                  * current handler.
1653                                  */
1654                                 /* XXX point to ip packet */
1655                                 (*packetHandler)((uchar *)ip, 0, src_ip, 0, 0);
1656                                 return;
1657                         case ICMP_ECHO_REQUEST:
1658                                 debug("Got ICMP ECHO REQUEST, return %d bytes\n",
1659                                       ETHER_HDR_SIZE + len);
1660
1661                                 memcpy(&et->et_dest[0], &et->et_src[0], 6);
1662                                 memcpy(&et->et_src[0], NetOurEther, 6);
1663
1664                                 ip->ip_sum = 0;
1665                                 ip->ip_off = 0;
1666                                 NetCopyIP((void *)&ip->ip_dst, &ip->ip_src);
1667                                 NetCopyIP((void *)&ip->ip_src, &NetOurIP);
1668                                 ip->ip_sum = ~NetCksum((uchar *)ip,
1669                                                        IP_HDR_SIZE_NO_UDP >> 1);
1670
1671                                 icmph->type = ICMP_ECHO_REPLY;
1672                                 icmph->checksum = 0;
1673                                 icmph->checksum = ~NetCksum((uchar *)icmph,
1674                                         (len - IP_HDR_SIZE_NO_UDP) >> 1);
1675                                 (void) eth_send((uchar *)et,
1676                                                 ETHER_HDR_SIZE + len);
1677                                 return;
1678 #endif
1679                         default:
1680                                 return;
1681                         }
1682                 } else if (ip->ip_p != IPPROTO_UDP) {   /* Only UDP packets */
1683                         return;
1684                 }
1685
1686 #ifdef CONFIG_UDP_CHECKSUM
1687                 if (ip->udp_xsum != 0) {
1688                         ulong   xsum;
1689                         ushort *sumptr;
1690                         ushort  sumlen;
1691
1692                         xsum  = ip->ip_p;
1693                         xsum += (ntohs(ip->udp_len));
1694                         xsum += (ntohl(ip->ip_src) >> 16) & 0x0000ffff;
1695                         xsum += (ntohl(ip->ip_src) >>  0) & 0x0000ffff;
1696                         xsum += (ntohl(ip->ip_dst) >> 16) & 0x0000ffff;
1697                         xsum += (ntohl(ip->ip_dst) >>  0) & 0x0000ffff;
1698
1699                         sumlen = ntohs(ip->udp_len);
1700                         sumptr = (ushort *) &(ip->udp_src);
1701
1702                         while (sumlen > 1) {
1703                                 ushort sumdata;
1704
1705                                 sumdata = *sumptr++;
1706                                 xsum += ntohs(sumdata);
1707                                 sumlen -= 2;
1708                         }
1709                         if (sumlen > 0) {
1710                                 ushort sumdata;
1711
1712                                 sumdata = *(unsigned char *) sumptr;
1713                                 sumdata = (sumdata << 8) & 0xff00;
1714                                 xsum += sumdata;
1715                         }
1716                         while ((xsum >> 16) != 0) {
1717                                 xsum = (xsum & 0x0000ffff) +
1718                                        ((xsum >> 16) & 0x0000ffff);
1719                         }
1720                         if ((xsum != 0x00000000) && (xsum != 0x0000ffff)) {
1721                                 printf(" UDP wrong checksum %08lx %08x\n",
1722                                         xsum, ntohs(ip->udp_xsum));
1723                                 return;
1724                         }
1725                 }
1726 #endif
1727
1728
1729 #ifdef CONFIG_NETCONSOLE
1730                 nc_input_packet((uchar *)ip + IP_HDR_SIZE,
1731                                                 ntohs(ip->udp_dst),
1732                                                 ntohs(ip->udp_src),
1733                                                 ntohs(ip->udp_len) - 8);
1734 #endif
1735                 /*
1736                  *      IP header OK.  Pass the packet to the current handler.
1737                  */
1738                 (*packetHandler)((uchar *)ip + IP_HDR_SIZE,
1739                                                 ntohs(ip->udp_dst),
1740                                                 src_ip,
1741                                                 ntohs(ip->udp_src),
1742                                                 ntohs(ip->udp_len) - 8);
1743                 break;
1744         }
1745 }
1746
1747
1748 /**********************************************************************/
1749
1750 static int net_check_prereq(proto_t protocol)
1751 {
1752         switch (protocol) {
1753                 /* Fall through */
1754 #if defined(CONFIG_CMD_PING)
1755         case PING:
1756                 if (NetPingIP == 0) {
1757                         puts("*** ERROR: ping address not given\n");
1758                         return 1;
1759                 }
1760                 goto common;
1761 #endif
1762 #if defined(CONFIG_CMD_SNTP)
1763         case SNTP:
1764                 if (NetNtpServerIP == 0) {
1765                         puts("*** ERROR: NTP server address not given\n");
1766                         return 1;
1767                 }
1768                 goto common;
1769 #endif
1770 #if defined(CONFIG_CMD_DNS)
1771         case DNS:
1772                 if (NetOurDNSIP == 0) {
1773                         puts("*** ERROR: DNS server address not given\n");
1774                         return 1;
1775                 }
1776                 goto common;
1777 #endif
1778 #if defined(CONFIG_CMD_NFS)
1779         case NFS:
1780 #endif
1781         case TFTP:
1782                 if (NetServerIP == 0) {
1783                         puts("*** ERROR: `serverip' not set\n");
1784                         return 1;
1785                 }
1786 #if     defined(CONFIG_CMD_PING) || defined(CONFIG_CMD_SNTP) || \
1787         defined(CONFIG_CMD_DNS)
1788 common:
1789 #endif
1790                 /* Fall through */
1791
1792         case NETCONS:
1793                 if (NetOurIP == 0) {
1794                         puts("*** ERROR: `ipaddr' not set\n");
1795                         return 1;
1796                 }
1797                 /* Fall through */
1798
1799 #ifdef CONFIG_CMD_RARP
1800         case RARP:
1801 #endif
1802         case BOOTP:
1803         case CDP:
1804         case DHCP:
1805                 if (memcmp(NetOurEther, "\0\0\0\0\0\0", 6) == 0) {
1806 #ifdef CONFIG_NET_MULTI
1807                         extern int eth_get_dev_index(void);
1808                         int num = eth_get_dev_index();
1809
1810                         switch (num) {
1811                         case -1:
1812                                 puts("*** ERROR: No ethernet found.\n");
1813                                 return 1;
1814                         case 0:
1815                                 puts("*** ERROR: `ethaddr' not set\n");
1816                                 break;
1817                         default:
1818                                 printf("*** ERROR: `eth%daddr' not set\n",
1819                                         num);
1820                                 break;
1821                         }
1822
1823                         NetStartAgain();
1824                         return 2;
1825 #else
1826                         puts("*** ERROR: `ethaddr' not set\n");
1827                         return 1;
1828 #endif
1829                 }
1830                 /* Fall through */
1831         default:
1832                 return 0;
1833         }
1834         return 0;               /* OK */
1835 }
1836 /**********************************************************************/
1837
1838 int
1839 NetCksumOk(uchar *ptr, int len)
1840 {
1841         return !((NetCksum(ptr, len) + 1) & 0xfffe);
1842 }
1843
1844
1845 unsigned
1846 NetCksum(uchar *ptr, int len)
1847 {
1848         ulong   xsum;
1849         ushort *p = (ushort *)ptr;
1850
1851         xsum = 0;
1852         while (len-- > 0)
1853                 xsum += *p++;
1854         xsum = (xsum & 0xffff) + (xsum >> 16);
1855         xsum = (xsum & 0xffff) + (xsum >> 16);
1856         return xsum & 0xffff;
1857 }
1858
1859 int
1860 NetEthHdrSize(void)
1861 {
1862         ushort myvlanid;
1863
1864         myvlanid = ntohs(NetOurVLAN);
1865         if (myvlanid == (ushort)-1)
1866                 myvlanid = VLAN_NONE;
1867
1868         return ((myvlanid & VLAN_IDMASK) == VLAN_NONE) ? ETHER_HDR_SIZE :
1869                 VLAN_ETHER_HDR_SIZE;
1870 }
1871
1872 int
1873 NetSetEther(volatile uchar *xet, uchar * addr, uint prot)
1874 {
1875         Ethernet_t *et = (Ethernet_t *)xet;
1876         ushort myvlanid;
1877
1878         myvlanid = ntohs(NetOurVLAN);
1879         if (myvlanid == (ushort)-1)
1880                 myvlanid = VLAN_NONE;
1881
1882         memcpy(et->et_dest, addr, 6);
1883         memcpy(et->et_src, NetOurEther, 6);
1884         if ((myvlanid & VLAN_IDMASK) == VLAN_NONE) {
1885                 et->et_protlen = htons(prot);
1886                 return ETHER_HDR_SIZE;
1887         } else {
1888                 VLAN_Ethernet_t *vet = (VLAN_Ethernet_t *)xet;
1889
1890                 vet->vet_vlan_type = htons(PROT_VLAN);
1891                 vet->vet_tag = htons((0 << 5) | (myvlanid & VLAN_IDMASK));
1892                 vet->vet_type = htons(prot);
1893                 return VLAN_ETHER_HDR_SIZE;
1894         }
1895 }
1896
1897 void
1898 NetSetIP(volatile uchar *xip, IPaddr_t dest, int dport, int sport, int len)
1899 {
1900         IP_t *ip = (IP_t *)xip;
1901
1902         /*
1903          *      If the data is an odd number of bytes, zero the
1904          *      byte after the last byte so that the checksum
1905          *      will work.
1906          */
1907         if (len & 1)
1908                 xip[IP_HDR_SIZE + len] = 0;
1909
1910         /*
1911          *      Construct an IP and UDP header.
1912          *      (need to set no fragment bit - XXX)
1913          */
1914         /* IP_HDR_SIZE / 4 (not including UDP) */
1915         ip->ip_hl_v  = 0x45;
1916         ip->ip_tos   = 0;
1917         ip->ip_len   = htons(IP_HDR_SIZE + len);
1918         ip->ip_id    = htons(NetIPID++);
1919         ip->ip_off   = htons(IP_FLAGS_DFRAG);   /* Don't fragment */
1920         ip->ip_ttl   = 255;
1921         ip->ip_p     = 17;              /* UDP */
1922         ip->ip_sum   = 0;
1923         /* already in network byte order */
1924         NetCopyIP((void *)&ip->ip_src, &NetOurIP);
1925         /* - "" - */
1926         NetCopyIP((void *)&ip->ip_dst, &dest);
1927         ip->udp_src  = htons(sport);
1928         ip->udp_dst  = htons(dport);
1929         ip->udp_len  = htons(8 + len);
1930         ip->udp_xsum = 0;
1931         ip->ip_sum   = ~NetCksum((uchar *)ip, IP_HDR_SIZE_NO_UDP / 2);
1932 }
1933
1934 void copy_filename(char *dst, const char *src, int size)
1935 {
1936         if (*src && (*src == '"')) {
1937                 ++src;
1938                 --size;
1939         }
1940
1941         while ((--size > 0) && *src && (*src != '"'))
1942                 *dst++ = *src++;
1943         *dst = '\0';
1944 }
1945
1946 #if     defined(CONFIG_CMD_NFS)         || \
1947         defined(CONFIG_CMD_SNTP)        || \
1948         defined(CONFIG_CMD_DNS)
1949 /*
1950  * make port a little random (1024-17407)
1951  * This keeps the math somewhat trivial to compute, and seems to work with
1952  * all supported protocols/clients/servers
1953  */
1954 unsigned int random_port(void)
1955 {
1956         return 1024 + (get_timer(0) % 0x4000);
1957 }
1958 #endif
1959
1960 void ip_to_string(IPaddr_t x, char *s)
1961 {
1962         x = ntohl(x);
1963         sprintf(s, "%d.%d.%d.%d",
1964                 (int) ((x >> 24) & 0xff),
1965                 (int) ((x >> 16) & 0xff),
1966                 (int) ((x >> 8) & 0xff), (int) ((x >> 0) & 0xff)
1967         );
1968 }
1969
1970 void VLAN_to_string(ushort x, char *s)
1971 {
1972         x = ntohs(x);
1973
1974         if (x == (ushort)-1)
1975                 x = VLAN_NONE;
1976
1977         if (x == VLAN_NONE)
1978                 strcpy(s, "none");
1979         else
1980                 sprintf(s, "%d", x & VLAN_IDMASK);
1981 }
1982
1983 ushort string_to_VLAN(const char *s)
1984 {
1985         ushort id;
1986
1987         if (s == NULL)
1988                 return htons(VLAN_NONE);
1989
1990         if (*s < '0' || *s > '9')
1991                 id = VLAN_NONE;
1992         else
1993                 id = (ushort)simple_strtoul(s, NULL, 10);
1994
1995         return htons(id);
1996 }
1997
1998 ushort getenv_VLAN(char *var)
1999 {
2000         return string_to_VLAN(getenv(var));
2001 }