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