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