net/net.c

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