]> git.ipfire.org Git - people/ms/u-boot.git/blob - net/net.c
projects / people / ms / u-boot.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* Patch by Philippe Robin, 09 Mar 2004:
[people/ms/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
69
70 #include <common.h>
71 #include <watchdog.h>
72 #include <command.h>
73 #include <net.h>
74 #include "bootp.h"
75 #include "tftp.h"
76 #include "rarp.h"
77 #include "nfs.h"
78 #ifdef CONFIG_STATUS_LED
79 #include <status_led.h>
80 #include <miiphy.h>
81 #endif
82
83 #if (CONFIG_COMMANDS & CFG_CMD_NET)
84
85 #define ARP_TIMEOUT 5 /* Seconds before trying ARP again */
86 #ifndef CONFIG_NET_RETRY_COUNT
87 # define ARP_TIMEOUT_COUNT 5 /* # of timeouts before giving up */
88 #else
89 # define ARP_TIMEOUT_COUNT (CONFIG_NET_RETRY_COUNT)
90 #endif
91
92 #if 0
93 #define ET_DEBUG
94 #endif
95
96 /** BOOTP EXTENTIONS **/
97
98 IPaddr_t NetOurSubnetMask=0; /* Our subnet mask (0=unknown) */
99 IPaddr_t NetOurGatewayIP=0; /* Our gateways IP address */
100 IPaddr_t NetOurDNSIP=0; /* Our DNS IP address */
101 #if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_DNS2)
102 IPaddr_t NetOurDNS2IP=0; /* Our 2nd DNS IP address */
103 #endif
104 char NetOurNISDomain[32]={0,}; /* Our NIS domain */
105 char NetOurHostName[32]={0,}; /* Our hostname */
106 char NetOurRootPath[64]={0,}; /* Our bootpath */
107 ushort NetBootFileSize=0; /* Our bootfile size in blocks */
108
109 /** END OF BOOTP EXTENTIONS **/
110
111 ulong NetBootFileXferSize; /* The actual transferred size of the bootfile (in bytes) */
112 uchar NetOurEther[6]; /* Our ethernet address */
113 uchar NetServerEther[6] = /* Boot server enet address */
114 { 0, 0, 0, 0, 0, 0 };
115 IPaddr_t NetOurIP; /* Our IP addr (0 = unknown) */
116 IPaddr_t NetServerIP; /* Our IP addr (0 = unknown) */
117 volatile uchar *NetRxPkt; /* Current receive packet */
118 int NetRxPktLen; /* Current rx packet length */
119 unsigned NetIPID; /* IP packet ID */
120 uchar NetBcastAddr[6] = /* Ethernet bcast address */
121 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
122 uchar NetEtherNullAddr[6] =
123 { 0, 0, 0, 0, 0, 0 };
124 int NetState; /* Network loop state */
125 #ifdef CONFIG_NET_MULTI
126 int NetRestartWrap = 0; /* Tried all network devices */
127 static int NetRestarted = 0; /* Network loop restarted */
128 static int NetDevExists = 0; /* At least one device configured */
129 #endif
130
131 char BootFile[128]; /* Boot File name */
132
133 #if (CONFIG_COMMANDS & CFG_CMD_PING)
134 IPaddr_t NetPingIP; /* the ip address to ping */
135
136 static void PingStart(void);
137 #endif
138
139 volatile uchar PktBuf[(PKTBUFSRX+1) * PKTSIZE_ALIGN + PKTALIGN];
140
141 volatile uchar *NetRxPackets[PKTBUFSRX]; /* Receive packets */
142
143 static rxhand_f *packetHandler; /* Current RX packet handler */
144 static thand_f *timeHandler; /* Current timeout handler */
145 static ulong timeStart; /* Time base value */
146 static ulong timeDelta; /* Current timeout value */
147 volatile uchar *NetTxPacket = 0; /* THE transmit packet */
148
149 static int net_check_prereq (proto_t protocol);
150
151 /**********************************************************************/
152
153 IPaddr_t NetArpWaitPacketIP;
154 IPaddr_t NetArpWaitReplyIP;
155 uchar *NetArpWaitPacketMAC; /* MAC address of waiting packet's destination */
156 uchar *NetArpWaitTxPacket; /* THE transmit packet */
157 int NetArpWaitTxPacketSize;
158 uchar NetArpWaitPacketBuf[PKTSIZE_ALIGN + PKTALIGN];
159 ulong NetArpWaitTimerStart;
160 int NetArpWaitTry;
161
162 void ArpRequest(void)
163 {
164 int i;
165 volatile uchar *pkt;
166 ARP_t * arp;
167
168 #ifdef ET_DEBUG
169 printf("ARP broadcast %d\n", NetArpWaitTry);
170 #endif
171 pkt = NetTxPacket;
172
173 NetSetEther(pkt, NetBcastAddr, PROT_ARP);
174 pkt += ETHER_HDR_SIZE;
175
176 arp = (ARP_t *)pkt;
177
178 arp->ar_hrd = htons(ARP_ETHER);
179 arp->ar_pro = htons(PROT_IP);
180 arp->ar_hln = 6;
181 arp->ar_pln = 4;
182 arp->ar_op = htons(ARPOP_REQUEST);
183
184 memcpy (&arp->ar_data[0], NetOurEther, 6); /* source ET addr */
185 NetWriteIP((uchar*)&arp->ar_data[6], NetOurIP); /* source IP addr */
186 for (i=10; i<16; ++i) {
187 arp->ar_data[i] = 0; /* dest ET addr = 0 */
188 }
189
190 if((NetArpWaitPacketIP & NetOurSubnetMask) != (NetOurIP & NetOurSubnetMask)) {
191 if (NetOurGatewayIP == 0) {
192 puts ("## Warning: gatewayip needed but not set\n");
193 }
194 NetArpWaitReplyIP = NetOurGatewayIP;
195 } else
196 NetArpWaitReplyIP = NetArpWaitPacketIP;
197
198 NetWriteIP((uchar*)&arp->ar_data[16], NetArpWaitReplyIP);
199 (void) eth_send(NetTxPacket, ETHER_HDR_SIZE + ARP_HDR_SIZE);
200 }
201
202 void ArpTimeoutCheck(void)
203 {
204 ulong t;
205
206 if (!NetArpWaitPacketIP)
207 return;
208
209 t = get_timer(0);
210
211 /* check for arp timeout */
212 if ((t - NetArpWaitTimerStart) > ARP_TIMEOUT * CFG_HZ) {
213 NetArpWaitTry++;
214
215 if (NetArpWaitTry >= ARP_TIMEOUT_COUNT) {
216 puts ("\nARP Retry count exceeded; starting again\n");
217 NetArpWaitTry = 0;
218 NetStartAgain();
219 } else {
220 NetArpWaitTimerStart = t;
221 ArpRequest();
222 }
223 }
224 }
225
226 /**********************************************************************/
227 /*
228 * Main network processing loop.
229 */
230
231 int
232 NetLoop(proto_t protocol)
233 {
234 DECLARE_GLOBAL_DATA_PTR;
235
236 bd_t *bd = gd->bd;
237
238 #ifdef CONFIG_NET_MULTI
239 NetRestarted = 0;
240 NetDevExists = 0;
241 #endif
242
243 /* XXX problem with bss workaround */
244 NetArpWaitPacketMAC = NULL;
245 NetArpWaitTxPacket = NULL;
246 NetArpWaitPacketIP = 0;
247 NetArpWaitReplyIP = 0;
248 NetArpWaitTxPacket = NULL;
249 NetTxPacket = NULL;
250
251 if (!NetTxPacket) {
252 int i;
253
254 /*
255 * Setup packet buffers, aligned correctly.
256 */
257 NetTxPacket = &PktBuf[0] + (PKTALIGN - 1);
258 NetTxPacket -= (ulong)NetTxPacket % PKTALIGN;
259 for (i = 0; i < PKTBUFSRX; i++) {
260 NetRxPackets[i] = NetTxPacket + (i+1)*PKTSIZE_ALIGN;
261 }
262
263 }
264
265 if (!NetArpWaitTxPacket) {
266 NetArpWaitTxPacket = &NetArpWaitPacketBuf[0] + (PKTALIGN - 1);
267 NetArpWaitTxPacket -= (ulong)NetArpWaitTxPacket % PKTALIGN;
268 NetArpWaitTxPacketSize = 0;
269 }
270
271 eth_halt();
272 if(eth_init(bd) < 0)
273 return(-1);
274
275 restart:
276 #ifdef CONFIG_NET_MULTI
277 memcpy (NetOurEther, eth_get_dev()->enetaddr, 6);
278 #else
279 memcpy (NetOurEther, bd->bi_enetaddr, 6);
280 #endif
281
282 NetState = NETLOOP_CONTINUE;
283
284 /*
285 * Start the ball rolling with the given start function. From
286 * here on, this code is a state machine driven by received
287 * packets and timer events.
288 */
289
290 switch (protocol) {
291 #if (CONFIG_COMMANDS & CFG_CMD_NFS)
292 case NFS:
293 #endif
294 #if (CONFIG_COMMANDS & CFG_CMD_PING)
295 case PING:
296 #endif
297 case TFTP:
298 NetCopyIP(&NetOurIP, &bd->bi_ip_addr);
299 NetOurGatewayIP = getenv_IPaddr ("gatewayip");
300 NetOurSubnetMask= getenv_IPaddr ("netmask");
301
302 switch (protocol) {
303 #if (CONFIG_COMMANDS & CFG_CMD_NFS)
304 case NFS:
305 #endif
306 case TFTP:
307 NetServerIP = getenv_IPaddr ("serverip");
308 break;
309 #if (CONFIG_COMMANDS & CFG_CMD_PING)
310 case PING:
311 /* nothing */
312 break;
313 #endif
314 default:
315 break;
316 }
317
318 break;
319 case BOOTP:
320 case RARP:
321 /*
322 * initialize our IP addr to 0 in order to accept ANY
323 * IP addr assigned to us by the BOOTP / RARP server
324 */
325 NetOurIP = 0;
326 NetServerIP = getenv_IPaddr ("serverip");
327 break;
328 default:
329 break;
330 }
331
332 switch (net_check_prereq (protocol)) {
333 case 1:
334 /* network not configured */
335 return (-1);
336
337 #ifdef CONFIG_NET_MULTI
338 case 2:
339 /* network device not configured */
340 break;
341 #endif /* CONFIG_NET_MULTI */
342
343 case 0:
344 #ifdef CONFIG_NET_MULTI
345 NetDevExists = 1;
346 #endif
347 switch (protocol) {
348 case TFTP:
349 /* always use ARP to get server ethernet address */
350 TftpStart();
351 break;
352
353 #if (CONFIG_COMMANDS & CFG_CMD_DHCP)
354 case DHCP:
355 /* Start with a clean slate... */
356 NetOurIP = 0;
357 NetServerIP = getenv_IPaddr ("serverip");
358 DhcpRequest(); /* Basically same as BOOTP */
359 break;
360 #endif /* CFG_CMD_DHCP */
361
362 case BOOTP:
363 BootpTry = 0;
364 BootpRequest ();
365 break;
366
367 case RARP:
368 RarpTry = 0;
369 RarpRequest ();
370 break;
371 #if (CONFIG_COMMANDS & CFG_CMD_PING)
372 case PING:
373 PingStart();
374 break;
375 #endif
376 #if (CONFIG_COMMANDS & CFG_CMD_NFS)
377 case NFS:
378 NfsStart();
379 break;
380 #endif
381 default:
382 break;
383 }
384
385 NetBootFileXferSize = 0;
386 break;
387 }
388
389 #if defined(CONFIG_MII) || (CONFIG_COMMANDS & CFG_CMD_MII)
390 #if defined(CFG_FAULT_ECHO_LINK_DOWN) && defined(CONFIG_STATUS_LED) && defined(STATUS_LED_RED)
391 /*
392 * Echo the inverted link state to the fault LED.
393 */
394 if(miiphy_link(CFG_FAULT_MII_ADDR)) {
395 status_led_set (STATUS_LED_RED, STATUS_LED_OFF);
396 } else {
397 status_led_set (STATUS_LED_RED, STATUS_LED_ON);
398 }
399 #endif /* CFG_FAULT_ECHO_LINK_DOWN, ... */
400 #endif /* CONFIG_MII, ... */
401
402 /*
403 * Main packet reception loop. Loop receiving packets until
404 * someone sets `NetQuit'.
405 */
406 for (;;) {
407 WATCHDOG_RESET();
408 #ifdef CONFIG_SHOW_ACTIVITY
409 {
410 extern void show_activity(int arg);
411 show_activity(1);
412 }
413 #endif
414 /*
415 * Check the ethernet for a new packet. The ethernet
416 * receive routine will process it.
417 */
418 eth_rx();
419
420 /*
421 * Abort if ctrl-c was pressed.
422 */
423 if (ctrlc()) {
424 eth_halt();
425 printf("\nAbort\n");
426 return (-1);
427 }
428
429 ArpTimeoutCheck();
430
431 /*
432 * Check for a timeout, and run the timeout handler
433 * if we have one.
434 */
435 if (timeHandler && ((get_timer(0) - timeStart) > timeDelta)) {
436 thand_f *x;
437
438 #if defined(CONFIG_MII) || (CONFIG_COMMANDS & CFG_CMD_MII)
439 #if defined(CFG_FAULT_ECHO_LINK_DOWN) && defined(CONFIG_STATUS_LED) && defined(STATUS_LED_RED)
440 /*
441 * Echo the inverted link state to the fault LED.
442 */
443 if(miiphy_link(CFG_FAULT_MII_ADDR)) {
444 status_led_set (STATUS_LED_RED, STATUS_LED_OFF);
445 } else {
446 status_led_set (STATUS_LED_RED, STATUS_LED_ON);
447 }
448 #endif /* CFG_FAULT_ECHO_LINK_DOWN, ... */
449 #endif /* CONFIG_MII, ... */
450 x = timeHandler;
451 timeHandler = (thand_f *)0;
452 (*x)();
453 }
454
455
456 switch (NetState) {
457
458 case NETLOOP_RESTART:
459 #ifdef CONFIG_NET_MULTI
460 NetRestarted = 1;
461 #endif
462 goto restart;
463
464 case NETLOOP_SUCCESS:
465 if (NetBootFileXferSize > 0) {
466 char buf[10];
467 printf("Bytes transferred = %ld (%lx hex)\n",
468 NetBootFileXferSize,
469 NetBootFileXferSize);
470 sprintf(buf, "%lx", NetBootFileXferSize);
471 setenv("filesize", buf);
472 }
473 eth_halt();
474 return NetBootFileXferSize;
475
476 case NETLOOP_FAIL:
477 return (-1);
478 }
479 }
480 }
481
482 /**********************************************************************/
483
484 static void
485 startAgainTimeout(void)
486 {
487 NetState = NETLOOP_RESTART;
488 }
489
490 static void
491 startAgainHandler(uchar * pkt, unsigned dest, unsigned src, unsigned len)
492 {
493 /* Totally ignore the packet */
494 }
495
496 void
497 NetStartAgain(void)
498 {
499 #ifndef CONFIG_NET_MULTI
500 NetSetTimeout(10 * CFG_HZ, startAgainTimeout);
501 NetSetHandler(startAgainHandler);
502 #else
503 DECLARE_GLOBAL_DATA_PTR;
504
505 eth_halt();
506 eth_try_another(!NetRestarted);
507 eth_init(gd->bd);
508 if (NetRestartWrap)
509 {
510 NetRestartWrap = 0;
511 if (NetDevExists)
512 {
513 NetSetTimeout(10 * CFG_HZ, startAgainTimeout);
514 NetSetHandler(startAgainHandler);
515 }
516 else
517 {
518 NetState = NETLOOP_FAIL;
519 }
520 }
521 else
522 {
523 NetState = NETLOOP_RESTART;
524 }
525 #endif
526 }
527
528 /**********************************************************************/
529 /*
530 * Miscelaneous bits.
531 */
532
533 void
534 NetSetHandler(rxhand_f * f)
535 {
536 packetHandler = f;
537 }
538
539
540 void
541 NetSetTimeout(int iv, thand_f * f)
542 {
543 if (iv == 0) {
544 timeHandler = (thand_f *)0;
545 } else {
546 timeHandler = f;
547 timeStart = get_timer(0);
548 timeDelta = iv;
549 }
550 }
551
552
553 void
554 NetSendPacket(volatile uchar * pkt, int len)
555 {
556 (void) eth_send(pkt, len);
557 }
558
559 int
560 NetSendUDPPacket(uchar *ether, IPaddr_t dest, int dport, int sport, int len)
561 {
562 /* convert to new style broadcast */
563 if (dest == 0)
564 dest = 0xFFFFFFFF;
565
566 /* if broadcast, make the ether address a broadcast and don't do ARP */
567 if (dest == 0xFFFFFFFF)
568 ether = NetBcastAddr;
569
570 /* if MAC address was not discovered yet, save the packet and do an ARP request */
571 if (memcmp(ether, NetEtherNullAddr, 6) == 0) {
572
573 #ifdef ET_DEBUG
574 printf("sending ARP for %08lx\n", dest);
575 #endif
576
577 NetArpWaitPacketIP = dest;
578 NetArpWaitPacketMAC = ether;
579 NetSetEther (NetArpWaitTxPacket, NetArpWaitPacketMAC, PROT_IP);
580 NetSetIP (NetArpWaitTxPacket + ETHER_HDR_SIZE, dest, dport, sport, len);
581 memcpy(NetArpWaitTxPacket + ETHER_HDR_SIZE + IP_HDR_SIZE,
582 (uchar *)NetTxPacket + ETHER_HDR_SIZE + IP_HDR_SIZE, len);
583
584 /* size of the waiting packet */
585 NetArpWaitTxPacketSize = ETHER_HDR_SIZE + IP_HDR_SIZE + len;
586
587 /* and do the ARP request */
588 NetArpWaitTry = 1;
589 NetArpWaitTimerStart = get_timer(0);
590 ArpRequest();
591 return 1; /* waiting */
592 }
593
594 #ifdef ET_DEBUG
595 printf("sending UDP to %08lx/%02x:%02x:%02x:%02x:%02x:%02x\n",
596 dest, ether[0], ether[1], ether[2], ether[3], ether[4], ether[5]);
597 #endif
598
599 NetSetEther (NetTxPacket, ether, PROT_IP);
600 NetSetIP (NetTxPacket + ETHER_HDR_SIZE, dest, dport, sport, len);
601 (void) eth_send(NetTxPacket, ETHER_HDR_SIZE + IP_HDR_SIZE + len);
602
603 return 0; /* transmited */
604 }
605
606 #if (CONFIG_COMMANDS & CFG_CMD_PING)
607 static ushort PingSeqNo;
608
609 int PingSend(void)
610 {
611 static uchar mac[6];
612 volatile IP_t *ip;
613 volatile ushort *s;
614
615 /* XXX always send arp request */
616
617 memcpy(mac, NetEtherNullAddr, 6);
618
619 #ifdef ET_DEBUG
620 printf("sending ARP for %08lx\n", NetPingIP);
621 #endif
622
623 NetArpWaitPacketIP = NetPingIP;
624 NetArpWaitPacketMAC = mac;
625
626 NetSetEther(NetArpWaitTxPacket, mac, PROT_IP);
627
628 ip = (volatile IP_t *)(NetArpWaitTxPacket + ETHER_HDR_SIZE);
629
630 /*
631 * Construct an IP and ICMP header. (need to set no fragment bit - XXX)
632 */
633 ip->ip_hl_v = 0x45; /* IP_HDR_SIZE / 4 (not including UDP) */
634 ip->ip_tos = 0;
635 ip->ip_len = htons(IP_HDR_SIZE_NO_UDP + 8);
636 ip->ip_id = htons(NetIPID++);
637 ip->ip_off = htons(0x4000); /* No fragmentation */
638 ip->ip_ttl = 255;
639 ip->ip_p = 0x01; /* ICMP */
640 ip->ip_sum = 0;
641 NetCopyIP((void*)&ip->ip_src, &NetOurIP); /* already in network byte order */
642 NetCopyIP((void*)&ip->ip_dst, &NetPingIP); /* - "" - */
643 ip->ip_sum = ~NetCksum((uchar *)ip, IP_HDR_SIZE_NO_UDP / 2);
644
645 s = &ip->udp_src; /* XXX ICMP starts here */
646 s[0] = htons(0x0800); /* echo-request, code */
647 s[1] = 0; /* checksum */
648 s[2] = 0; /* identifier */
649 s[3] = htons(PingSeqNo++); /* sequence number */
650 s[1] = ~NetCksum((uchar *)s, 8/2);
651
652 /* size of the waiting packet */
653 NetArpWaitTxPacketSize = ETHER_HDR_SIZE + IP_HDR_SIZE_NO_UDP + 8;
654
655 /* and do the ARP request */
656 NetArpWaitTry = 1;
657 NetArpWaitTimerStart = get_timer(0);
658 ArpRequest();
659 return 1; /* waiting */
660 }
661
662 static void
663 PingTimeout (void)
664 {
665 eth_halt();
666 NetState = NETLOOP_FAIL; /* we did not get the reply */
667 }
668
669 static void
670 PingHandler (uchar * pkt, unsigned dest, unsigned src, unsigned len)
671 {
672 IPaddr_t tmp;
673 volatile IP_t *ip = (volatile IP_t *)pkt;
674
675 tmp = NetReadIP((void *)&ip->ip_src);
676 if (tmp != NetPingIP)
677 return;
678
679 NetState = NETLOOP_SUCCESS;
680 }
681
682 static void PingStart(void)
683 {
684 NetSetTimeout (10 * CFG_HZ, PingTimeout);
685 NetSetHandler (PingHandler);
686
687 PingSend();
688 }
689
690 #endif
691
692 void
693 NetReceive(volatile uchar * pkt, int len)
694 {
695 Ethernet_t *et;
696 IP_t *ip;
697 ARP_t *arp;
698 IPaddr_t tmp;
699 int x;
700
701 NetRxPkt = pkt;
702 NetRxPktLen = len;
703 et = (Ethernet_t *)pkt;
704
705 x = ntohs(et->et_protlen);
706
707 if (x < 1514) {
708 /*
709 * Got a 802 packet. Check the other protocol field.
710 */
711 x = ntohs(et->et_prot);
712 ip = (IP_t *)(pkt + E802_HDR_SIZE);
713 len -= E802_HDR_SIZE;
714 } else {
715 ip = (IP_t *)(pkt + ETHER_HDR_SIZE);
716 len -= ETHER_HDR_SIZE;
717 }
718
719 #ifdef ET_DEBUG
720 printf("Receive from protocol 0x%x\n", x);
721 #endif
722
723 switch (x) {
724
725 case PROT_ARP:
726 /*
727 * We have to deal with two types of ARP packets:
728 * - REQUEST packets will be answered by sending our
729 * IP address - if we know it.
730 * - REPLY packates are expected only after we asked
731 * for the TFTP server's or the gateway's ethernet
732 * address; so if we receive such a packet, we set
733 * the server ethernet address
734 */
735 #ifdef ET_DEBUG
736 printf("Got ARP\n");
737 #endif
738 arp = (ARP_t *)ip;
739 if (len < ARP_HDR_SIZE) {
740 printf("bad length %d < %d\n", len, ARP_HDR_SIZE);
741 return;
742 }
743 if (ntohs(arp->ar_hrd) != ARP_ETHER) {
744 return;
745 }
746 if (ntohs(arp->ar_pro) != PROT_IP) {
747 return;
748 }
749 if (arp->ar_hln != 6) {
750 return;
751 }
752 if (arp->ar_pln != 4) {
753 return;
754 }
755
756 if (NetOurIP == 0) {
757 return;
758 }
759
760 if (NetReadIP(&arp->ar_data[16]) != NetOurIP) {
761 return;
762 }
763
764 switch (ntohs(arp->ar_op)) {
765 case ARPOP_REQUEST: /* reply with our IP address */
766 #ifdef ET_DEBUG
767 printf("Got ARP REQUEST, return our IP\n");
768 #endif
769 NetSetEther((uchar *)et, et->et_src, PROT_ARP);
770 arp->ar_op = htons(ARPOP_REPLY);
771 memcpy (&arp->ar_data[10], &arp->ar_data[0], 6);
772 NetCopyIP(&arp->ar_data[16], &arp->ar_data[6]);
773 memcpy (&arp->ar_data[ 0], NetOurEther, 6);
774 NetCopyIP(&arp->ar_data[ 6], &NetOurIP);
775 (void) eth_send((uchar *)et, ((uchar *)arp-pkt) + ARP_HDR_SIZE);
776 return;
777
778 case ARPOP_REPLY: /* arp reply */
779 /* are we waiting for a reply */
780 if (!NetArpWaitPacketIP || !NetArpWaitPacketMAC)
781 break;
782 #ifdef ET_DEBUG
783 printf("Got ARP REPLY, set server/gtwy eth addr (%02x:%02x:%02x:%02x:%02x:%02x)\n",
784 arp->ar_data[0], arp->ar_data[1],
785 arp->ar_data[2], arp->ar_data[3],
786 arp->ar_data[4], arp->ar_data[5]);
787 #endif
788
789 tmp = NetReadIP(&arp->ar_data[6]);
790
791 /* matched waiting packet's address */
792 if (tmp == NetArpWaitReplyIP) {
793 #ifdef ET_DEBUG
794 printf("Got it\n");
795 #endif
796 /* save address for later use */
797 memcpy(NetArpWaitPacketMAC, &arp->ar_data[0], 6);
798
799 /* modify header, and transmit it */
800 memcpy(((Ethernet_t *)NetArpWaitTxPacket)->et_dest, NetArpWaitPacketMAC, 6);
801 (void) eth_send(NetArpWaitTxPacket, NetArpWaitTxPacketSize);
802
803 /* no arp request pending now */
804 NetArpWaitPacketIP = 0;
805 NetArpWaitTxPacketSize = 0;
806 NetArpWaitPacketMAC = NULL;
807
808 }
809 return;
810 default:
811 #ifdef ET_DEBUG
812 printf("Unexpected ARP opcode 0x%x\n", ntohs(arp->ar_op));
813 #endif
814 return;
815 }
816
817 case PROT_RARP:
818 #ifdef ET_DEBUG
819 printf("Got RARP\n");
820 #endif
821 arp = (ARP_t *)ip;
822 if (len < ARP_HDR_SIZE) {
823 printf("bad length %d < %d\n", len, ARP_HDR_SIZE);
824 return;
825 }
826
827 if ((ntohs(arp->ar_op) != RARPOP_REPLY) ||
828 (ntohs(arp->ar_hrd) != ARP_ETHER) ||
829 (ntohs(arp->ar_pro) != PROT_IP) ||
830 (arp->ar_hln != 6) || (arp->ar_pln != 4)) {
831
832 printf("invalid RARP header\n");
833 } else {
834 NetCopyIP(&NetOurIP, &arp->ar_data[16]);
835 if (NetServerIP == 0)
836 NetCopyIP(&NetServerIP, &arp->ar_data[ 6]);
837 memcpy (NetServerEther, &arp->ar_data[ 0], 6);
838
839 (*packetHandler)(0,0,0,0);
840 }
841 break;
842
843 case PROT_IP:
844 #ifdef ET_DEBUG
845 printf("Got IP\n");
846 #endif
847 if (len < IP_HDR_SIZE) {
848 debug ("len bad %d < %d\n", len, IP_HDR_SIZE);
849 return;
850 }
851 if (len < ntohs(ip->ip_len)) {
852 printf("len bad %d < %d\n", len, ntohs(ip->ip_len));
853 return;
854 }
855 len = ntohs(ip->ip_len);
856 #ifdef ET_DEBUG
857 printf("len=%d, v=%02x\n", len, ip->ip_hl_v & 0xff);
858 #endif
859 if ((ip->ip_hl_v & 0xf0) != 0x40) {
860 return;
861 }
862 if (ip->ip_off & htons(0x1fff)) { /* Can't deal w/ fragments */
863 return;
864 }
865 if (!NetCksumOk((uchar *)ip, IP_HDR_SIZE_NO_UDP / 2)) {
866 printf("checksum bad\n");
867 return;
868 }
869 tmp = NetReadIP(&ip->ip_dst);
870 if (NetOurIP && tmp != NetOurIP && tmp != 0xFFFFFFFF) {
871 return;
872 }
873 /*
874 * watch for ICMP host redirects
875 *
876 * There is no real handler code (yet). We just watch
877 * for ICMP host redirect messages. In case anybody
878 * sees these messages: please contact me
879 * (wd@denx.de), or - even better - send me the
880 * necessary fixes :-)
881 *
882 * Note: in all cases where I have seen this so far
883 * it was a problem with the router configuration,
884 * for instance when a router was configured in the
885 * BOOTP reply, but the TFTP server was on the same
886 * subnet. So this is probably a warning that your
887 * configuration might be wrong. But I'm not really
888 * sure if there aren't any other situations.
889 */
890 if (ip->ip_p == IPPROTO_ICMP) {
891 ICMP_t *icmph = (ICMP_t *)&(ip->udp_src);
892
893 switch (icmph->type) {
894 case ICMP_REDIRECT:
895 if (icmph->code != ICMP_REDIR_HOST)
896 return;
897 puts (" ICMP Host Redirect to ");
898 print_IPaddr(icmph->un.gateway);
899 putc(' ');
900 break;
901 #if (CONFIG_COMMANDS & CFG_CMD_PING)
902 case ICMP_ECHO_REPLY:
903 /*
904 * IP header OK. Pass the packet to the current handler.
905 */
906 /* XXX point to ip packet */
907 (*packetHandler)((uchar *)ip, 0, 0, 0);
908 break;
909 #endif
910 default:
911 return;
912 }
913 } else if (ip->ip_p != IPPROTO_UDP) { /* Only UDP packets */
914 return;
915 }
916
917 /*
918 * IP header OK. Pass the packet to the current handler.
919 */
920 (*packetHandler)((uchar *)ip +IP_HDR_SIZE,
921 ntohs(ip->udp_dst),
922 ntohs(ip->udp_src),
923 ntohs(ip->udp_len) - 8);
924
925 break;
926 }
927 }
928
929
930 /**********************************************************************/
931
932 static int net_check_prereq (proto_t protocol)
933 {
934 switch (protocol) {
935 /* Fall through */
936 #if (CONFIG_COMMANDS & CFG_CMD_PING)
937 case PING:
938 if (NetPingIP == 0) {
939 puts ("*** ERROR: ping address not given\n");
940 return (1);
941 }
942 goto common;
943 #endif
944 #if (CONFIG_COMMANDS & CFG_CMD_NFS)
945 case NFS:
946 #endif
947 case TFTP:
948 if (NetServerIP == 0) {
949 puts ("*** ERROR: `serverip' not set\n");
950 return (1);
951 }
952
953 #if (CONFIG_COMMANDS & CFG_CMD_PING)
954 common:
955 #endif
956
957 if (NetOurIP == 0) {
958 puts ("*** ERROR: `ipaddr' not set\n");
959 return (1);
960 }
961 /* Fall through */
962
963 case DHCP:
964 case RARP:
965 case BOOTP:
966 if (memcmp(NetOurEther, "\0\0\0\0\0\0", 6) == 0) {
967 #ifdef CONFIG_NET_MULTI
968 extern int eth_get_dev_index (void);
969 int num = eth_get_dev_index();
970
971 switch (num) {
972 case -1:
973 puts ("*** ERROR: No ethernet found.\n");
974 return (1);
975 case 0:
976 puts ("*** ERROR: `ethaddr' not set\n");
977 break;
978 default:
979 printf ("*** ERROR: `eth%daddr' not set\n",
980 num);
981 break;
982 }
983
984 NetStartAgain ();
985 return (2);
986 #else
987 puts ("*** ERROR: `ethaddr' not set\n");
988 return (1);
989 #endif
990 }
991 /* Fall through */
992 default:
993 return(0);
994 }
995 return (0); /* OK */
996 }
997 /**********************************************************************/
998
999 int
1000 NetCksumOk(uchar * ptr, int len)
1001 {
1002 return !((NetCksum(ptr, len) + 1) & 0xfffe);
1003 }
1004
1005
1006 unsigned
1007 NetCksum(uchar * ptr, int len)
1008 {
1009 ulong xsum;
1010
1011 xsum = 0;
1012 while (len-- > 0)
1013 xsum += *((ushort *)ptr)++;
1014 xsum = (xsum & 0xffff) + (xsum >> 16);
1015 xsum = (xsum & 0xffff) + (xsum >> 16);
1016 return (xsum & 0xffff);
1017 }
1018
1019
1020 void
1021 NetSetEther(volatile uchar * xet, uchar * addr, uint prot)
1022 {
1023 Ethernet_t *et = (Ethernet_t *)xet;
1024
1025 memcpy (et->et_dest, addr, 6);
1026 memcpy (et->et_src, NetOurEther, 6);
1027 et->et_protlen = htons(prot);
1028 }
1029
1030
1031 void
1032 NetSetIP(volatile uchar * xip, IPaddr_t dest, int dport, int sport, int len)
1033 {
1034 volatile IP_t *ip = (IP_t *)xip;
1035
1036 /*
1037 * If the data is an odd number of bytes, zero the
1038 * byte after the last byte so that the checksum
1039 * will work.
1040 */
1041 if (len & 1)
1042 xip[IP_HDR_SIZE + len] = 0;
1043
1044 /*
1045 * Construct an IP and UDP header.
1046 (need to set no fragment bit - XXX)
1047 */
1048 ip->ip_hl_v = 0x45; /* IP_HDR_SIZE / 4 (not including UDP) */
1049 ip->ip_tos = 0;
1050 ip->ip_len = htons(IP_HDR_SIZE + len);
1051 ip->ip_id = htons(NetIPID++);
1052 ip->ip_off = htons(0x4000); /* No fragmentation */
1053 ip->ip_ttl = 255;
1054 ip->ip_p = 17; /* UDP */
1055 ip->ip_sum = 0;
1056 NetCopyIP((void*)&ip->ip_src, &NetOurIP); /* already in network byte order */
1057 NetCopyIP((void*)&ip->ip_dst, &dest); /* - "" - */
1058 ip->udp_src = htons(sport);
1059 ip->udp_dst = htons(dport);
1060 ip->udp_len = htons(8 + len);
1061 ip->udp_xsum = 0;
1062 ip->ip_sum = ~NetCksum((uchar *)ip, IP_HDR_SIZE_NO_UDP / 2);
1063 }
1064
1065 void copy_filename (uchar *dst, uchar *src, int size)
1066 {
1067 if (*src && (*src == '"')) {
1068 ++src;
1069 --size;
1070 }
1071
1072 while ((--size > 0) && *src && (*src != '"')) {
1073 *dst++ = *src++;
1074 }
1075 *dst = '\0';
1076 }
1077
1078 #endif /* CFG_CMD_NET */
1079
1080 void ip_to_string (IPaddr_t x, char *s)
1081 {
1082 x = ntohl(x);
1083 sprintf (s,"%d.%d.%d.%d",
1084 (int)((x >> 24) & 0xff),
1085 (int)((x >> 16) & 0xff),
1086 (int)((x >> 8) & 0xff),
1087 (int)((x >> 0) & 0xff)
1088 );
1089 }
1090
1091 IPaddr_t string_to_ip(char *s)
1092 {
1093 IPaddr_t addr;
1094 char *e;
1095 int i;
1096
1097 if (s == NULL)
1098 return(0);
1099
1100 for (addr=0, i=0; i<4; ++i) {
1101 ulong val = s ? simple_strtoul(s, &e, 10) : 0;
1102 addr <<= 8;
1103 addr |= (val & 0xFF);
1104 if (s) {
1105 s = (*e) ? e+1 : e;
1106 }
1107 }
1108
1109 return (htonl(addr));
1110 }
1111
1112 void print_IPaddr (IPaddr_t x)
1113 {
1114 char tmp[16];
1115
1116 ip_to_string(x, tmp);
1117
1118 puts(tmp);
1119 }
1120
1121 IPaddr_t getenv_IPaddr (char *var)
1122 {
1123 return (string_to_ip(getenv(var)));
1124 }
"Das U-Boot" Source Tree