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 ==
1132                                             CONFIG_CDP_APPLIANCE_VLAN_TYPE)
1133                                                 vlan = *ss;
1134 #else
1135                                         /* XXX will this work; dunno */
1136                                         vlan = ntohs(*ss);
1137 #endif
1138                                         t += 3; tlen -= 3;
1139                                 }
1140                                 break;
1141                         case CDP_TRIGGER_TLV:
1142                                 break;
1143                         case CDP_POWER_CONSUMPTION_TLV:
1144                                 break;
1145                         case CDP_SYSNAME_TLV:
1146                                 break;
1147                         case CDP_SYSOBJECT_TLV:
1148                                 break;
1149                         case CDP_MANAGEMENT_ADDRESS_TLV:
1150                                 break;
1151                 }
1152         }
1153
1154         CDPApplianceVLAN = vlan;
1155         CDPNativeVLAN = nvlan;
1156
1157         CDPOK = 1;
1158         return;
1159
1160  pkt_short:
1161         printf("** CDP packet is too short\n");
1162         return;
1163 }
1164
1165 static void CDPStart(void)
1166 {
1167 #if defined(CONFIG_NET_MULTI)
1168         printf("Using %s device\n", eth_get_name());
1169 #endif
1170         CDPSeq = 0;
1171         CDPOK = 0;
1172
1173         CDPNativeVLAN = htons(-1);
1174         CDPApplianceVLAN = htons(-1);
1175
1176         NetSetTimeout(CDP_TIMEOUT, CDPTimeout);
1177         NetSetHandler(CDPDummyHandler);
1178
1179         CDPSendTrigger();
1180 }
1181 #endif
1182
1183 #ifdef CONFIG_IP_DEFRAG
1184 /*
1185  * This function collects fragments in a single packet, according
1186  * to the algorithm in RFC815. It returns NULL or the pointer to
1187  * a complete packet, in static storage
1188  */
1189 #ifndef CONFIG_NET_MAXDEFRAG
1190 #define CONFIG_NET_MAXDEFRAG 16384
1191 #endif
1192 /*
1193  * MAXDEFRAG, above, is chosen in the config file and  is real data
1194  * so we need to add the NFS overhead, which is more than TFTP.
1195  * To use sizeof in the internal unnamed structures, we need a real
1196  * instance (can't do "sizeof(struct rpc_t.u.reply))", unfortunately).
1197  * The compiler doesn't complain nor allocates the actual structure
1198  */
1199 static struct rpc_t rpc_specimen;
1200 #define IP_PKTSIZE (CONFIG_NET_MAXDEFRAG + sizeof(rpc_specimen.u.reply))
1201
1202 #define IP_MAXUDP (IP_PKTSIZE - IP_HDR_SIZE_NO_UDP)
1203
1204 /*
1205  * this is the packet being assembled, either data or frag control.
1206  * Fragments go by 8 bytes, so this union must be 8 bytes long
1207  */
1208 struct hole {
1209         /* first_byte is address of this structure */
1210         u16 last_byte;  /* last byte in this hole + 1 (begin of next hole) */
1211         u16 next_hole;  /* index of next (in 8-b blocks), 0 == none */
1212         u16 prev_hole;  /* index of prev, 0 == none */
1213         u16 unused;
1214 };
1215
1216 static IP_t *__NetDefragment(IP_t *ip, int *lenp)
1217 {
1218         static uchar pkt_buff[IP_PKTSIZE] __attribute__((aligned(PKTALIGN)));
1219         static u16 first_hole, total_len;
1220         struct hole *payload, *thisfrag, *h, *newh;
1221         IP_t *localip = (IP_t *)pkt_buff;
1222         uchar *indata = (uchar *)ip;
1223         int offset8, start, len, done = 0;
1224         u16 ip_off = ntohs(ip->ip_off);
1225
1226         /* payload starts after IP header, this fragment is in there */
1227         payload = (struct hole *)(pkt_buff + IP_HDR_SIZE_NO_UDP);
1228         offset8 =  (ip_off & IP_OFFS);
1229         thisfrag = payload + offset8;
1230         start = offset8 * 8;
1231         len = ntohs(ip->ip_len) - IP_HDR_SIZE_NO_UDP;
1232
1233         if (start + len > IP_MAXUDP) /* fragment extends too far */
1234                 return NULL;
1235
1236         if (!total_len || localip->ip_id != ip->ip_id) {
1237                 /* new (or different) packet, reset structs */
1238                 total_len = 0xffff;
1239                 payload[0].last_byte = ~0;
1240                 payload[0].next_hole = 0;
1241                 payload[0].prev_hole = 0;
1242                 first_hole = 0;
1243                 /* any IP header will work, copy the first we received */
1244                 memcpy(localip, ip, IP_HDR_SIZE_NO_UDP);
1245         }
1246
1247         /*
1248          * What follows is the reassembly algorithm. We use the payload
1249          * array as a linked list of hole descriptors, as each hole starts
1250          * at a multiple of 8 bytes. However, last byte can be whatever value,
1251          * so it is represented as byte count, not as 8-byte blocks.
1252          */
1253
1254         h = payload + first_hole;
1255         while (h->last_byte < start) {
1256                 if (!h->next_hole) {
1257                         /* no hole that far away */
1258                         return NULL;
1259                 }
1260                 h = payload + h->next_hole;
1261         }
1262
1263         /* last fragment may be 1..7 bytes, the "+7" forces acceptance */
1264         if (offset8 + ((len + 7) / 8) <= h - payload) {
1265                 /* no overlap with holes (dup fragment?) */
1266                 return NULL;
1267         }
1268
1269         if (!(ip_off & IP_FLAGS_MFRAG)) {
1270                 /* no more fragmentss: truncate this (last) hole */
1271                 total_len = start + len;
1272                 h->last_byte = start + len;
1273         }
1274
1275         /*
1276          * There is some overlap: fix the hole list. This code doesn't
1277          * deal with a fragment that overlaps with two different holes
1278          * (thus being a superset of a previously-received fragment).
1279          */
1280
1281         if ((h >= thisfrag) && (h->last_byte <= start + len)) {
1282                 /* complete overlap with hole: remove hole */
1283                 if (!h->prev_hole && !h->next_hole) {
1284                         /* last remaining hole */
1285                         done = 1;
1286                 } else if (!h->prev_hole) {
1287                         /* first hole */
1288                         first_hole = h->next_hole;
1289                         payload[h->next_hole].prev_hole = 0;
1290                 } else if (!h->next_hole) {
1291                         /* last hole */
1292                         payload[h->prev_hole].next_hole = 0;
1293                 } else {
1294                         /* in the middle of the list */
1295                         payload[h->next_hole].prev_hole = h->prev_hole;
1296                         payload[h->prev_hole].next_hole = h->next_hole;
1297                 }
1298
1299         } else if (h->last_byte <= start + len) {
1300                 /* overlaps with final part of the hole: shorten this hole */
1301                 h->last_byte = start;
1302
1303         } else if (h >= thisfrag) {
1304                 /* overlaps with initial part of the hole: move this hole */
1305                 newh = thisfrag + (len / 8);
1306                 *newh = *h;
1307                 h = newh;
1308                 if (h->next_hole)
1309                         payload[h->next_hole].prev_hole = (h - payload);
1310                 if (h->prev_hole)
1311                         payload[h->prev_hole].next_hole = (h - payload);
1312                 else
1313                         first_hole = (h - payload);
1314
1315         } else {
1316                 /* fragment sits in the middle: split the hole */
1317                 newh = thisfrag + (len / 8);
1318                 *newh = *h;
1319                 h->last_byte = start;
1320                 h->next_hole = (newh - payload);
1321                 newh->prev_hole = (h - payload);
1322                 if (newh->next_hole)
1323                         payload[newh->next_hole].prev_hole = (newh - payload);
1324         }
1325
1326         /* finally copy this fragment and possibly return whole packet */
1327         memcpy((uchar *)thisfrag, indata + IP_HDR_SIZE_NO_UDP, len);
1328         if (!done)
1329                 return NULL;
1330
1331         localip->ip_len = htons(total_len);
1332         *lenp = total_len + IP_HDR_SIZE_NO_UDP;
1333         return localip;
1334 }
1335
1336 static inline IP_t *NetDefragment(IP_t *ip, int *lenp)
1337 {
1338         u16 ip_off = ntohs(ip->ip_off);
1339         if (!(ip_off & (IP_OFFS | IP_FLAGS_MFRAG)))
1340                 return ip; /* not a fragment */
1341         return __NetDefragment(ip, lenp);
1342 }
1343
1344 #else /* !CONFIG_IP_DEFRAG */
1345
1346 static inline IP_t *NetDefragment(IP_t *ip, int *lenp)
1347 {
1348         u16 ip_off = ntohs(ip->ip_off);
1349         if (!(ip_off & (IP_OFFS | IP_FLAGS_MFRAG)))
1350                 return ip; /* not a fragment */
1351         return NULL;
1352 }
1353 #endif
1354
1355 void
1356 NetReceive(volatile uchar * inpkt, int len)
1357 {
1358         Ethernet_t *et;
1359         IP_t    *ip;
1360         ARP_t   *arp;
1361         IPaddr_t tmp;
1362         IPaddr_t src_ip;
1363         int     x;
1364         uchar *pkt;
1365 #if defined(CONFIG_CMD_CDP)
1366         int iscdp;
1367 #endif
1368         ushort cti = 0, vlanid = VLAN_NONE, myvlanid, mynvlanid;
1369
1370         debug("packet received\n");
1371
1372         NetRxPacket = inpkt;
1373         NetRxPacketLen = len;
1374         et = (Ethernet_t *)inpkt;
1375
1376         /* too small packet? */
1377         if (len < ETHER_HDR_SIZE)
1378                 return;
1379
1380 #ifdef CONFIG_API
1381         if (push_packet) {
1382                 (*push_packet)(inpkt, len);
1383                 return;
1384         }
1385 #endif
1386
1387 #if defined(CONFIG_CMD_CDP)
1388         /* keep track if packet is CDP */
1389         iscdp = memcmp(et->et_dest, NetCDPAddr, 6) == 0;
1390 #endif
1391
1392         myvlanid = ntohs(NetOurVLAN);
1393         if (myvlanid == (ushort)-1)
1394                 myvlanid = VLAN_NONE;
1395         mynvlanid = ntohs(NetOurNativeVLAN);
1396         if (mynvlanid == (ushort)-1)
1397                 mynvlanid = VLAN_NONE;
1398
1399         x = ntohs(et->et_protlen);
1400
1401         debug("packet received\n");
1402
1403         if (x < 1514) {
1404                 /*
1405                  *      Got a 802 packet.  Check the other protocol field.
1406                  */
1407                 x = ntohs(et->et_prot);
1408
1409                 ip = (IP_t *)(inpkt + E802_HDR_SIZE);
1410                 len -= E802_HDR_SIZE;
1411
1412         } else if (x != PROT_VLAN) {    /* normal packet */
1413                 ip = (IP_t *)(inpkt + ETHER_HDR_SIZE);
1414                 len -= ETHER_HDR_SIZE;
1415
1416         } else {                        /* VLAN packet */
1417                 VLAN_Ethernet_t *vet = (VLAN_Ethernet_t *)et;
1418
1419                 debug("VLAN packet received\n");
1420
1421                 /* too small packet? */
1422                 if (len < VLAN_ETHER_HDR_SIZE)
1423                         return;
1424
1425                 /* if no VLAN active */
1426                 if ((ntohs(NetOurVLAN) & VLAN_IDMASK) == VLAN_NONE
1427 #if defined(CONFIG_CMD_CDP)
1428                                 && iscdp == 0
1429 #endif
1430                                 )
1431                         return;
1432
1433                 cti = ntohs(vet->vet_tag);
1434                 vlanid = cti & VLAN_IDMASK;
1435                 x = ntohs(vet->vet_type);
1436
1437                 ip = (IP_t *)(inpkt + VLAN_ETHER_HDR_SIZE);
1438                 len -= VLAN_ETHER_HDR_SIZE;
1439         }
1440
1441         debug("Receive from protocol 0x%x\n", x);
1442
1443 #if defined(CONFIG_CMD_CDP)
1444         if (iscdp) {
1445                 CDPHandler((uchar *)ip, len);
1446                 return;
1447         }
1448 #endif
1449
1450         if ((myvlanid & VLAN_IDMASK) != VLAN_NONE) {
1451                 if (vlanid == VLAN_NONE)
1452                         vlanid = (mynvlanid & VLAN_IDMASK);
1453                 /* not matched? */
1454                 if (vlanid != (myvlanid & VLAN_IDMASK))
1455                         return;
1456         }
1457
1458         switch (x) {
1459
1460         case PROT_ARP:
1461                 /*
1462                  * We have to deal with two types of ARP packets:
1463                  * - REQUEST packets will be answered by sending  our
1464                  *   IP address - if we know it.
1465                  * - REPLY packates are expected only after we asked
1466                  *   for the TFTP server's or the gateway's ethernet
1467                  *   address; so if we receive such a packet, we set
1468                  *   the server ethernet address
1469                  */
1470                 debug("Got ARP\n");
1471
1472                 arp = (ARP_t *)ip;
1473                 if (len < ARP_HDR_SIZE) {
1474                         printf("bad length %d < %d\n", len, ARP_HDR_SIZE);
1475                         return;
1476                 }
1477                 if (ntohs(arp->ar_hrd) != ARP_ETHER)
1478                         return;
1479                 if (ntohs(arp->ar_pro) != PROT_IP)
1480                         return;
1481                 if (arp->ar_hln != 6)
1482                         return;
1483                 if (arp->ar_pln != 4)
1484                         return;
1485
1486                 if (NetOurIP == 0)
1487                         return;
1488
1489                 if (NetReadIP(&arp->ar_data[16]) != NetOurIP)
1490                         return;
1491
1492                 switch (ntohs(arp->ar_op)) {
1493                 case ARPOP_REQUEST:
1494                         /* reply with our IP address */
1495                         debug("Got ARP REQUEST, return our IP\n");
1496                         pkt = (uchar *)et;
1497                         pkt += NetSetEther(pkt, et->et_src, PROT_ARP);
1498                         arp->ar_op = htons(ARPOP_REPLY);
1499                         memcpy(&arp->ar_data[10], &arp->ar_data[0], 6);
1500                         NetCopyIP(&arp->ar_data[16], &arp->ar_data[6]);
1501                         memcpy(&arp->ar_data[0], NetOurEther, 6);
1502                         NetCopyIP(&arp->ar_data[6], &NetOurIP);
1503                         (void) eth_send((uchar *)et,
1504                                         (pkt - (uchar *)et) + ARP_HDR_SIZE);
1505                         return;
1506
1507                 case ARPOP_REPLY:               /* arp reply */
1508                         /* are we waiting for a reply */
1509                         if (!NetArpWaitPacketIP || !NetArpWaitPacketMAC)
1510                                 break;
1511
1512 #ifdef CONFIG_KEEP_SERVERADDR
1513                         if (NetServerIP == NetArpWaitPacketIP) {
1514                                 char buf[20];
1515                                 sprintf(buf, "%pM", arp->ar_data);
1516                                 setenv("serveraddr", buf);
1517                         }
1518 #endif
1519
1520                         debug("Got ARP REPLY, set server/gtwy eth addr (%pM)\n",
1521                                 arp->ar_data);
1522
1523                         tmp = NetReadIP(&arp->ar_data[6]);
1524
1525                         /* matched waiting packet's address */
1526                         if (tmp == NetArpWaitReplyIP) {
1527                                 debug("Got it\n");
1528                                 /* save address for later use */
1529                                 memcpy(NetArpWaitPacketMAC,
1530                                        &arp->ar_data[0], 6);
1531
1532 #ifdef CONFIG_NETCONSOLE
1533                                 (*packetHandler)(0, 0, 0, 0, 0);
1534 #endif
1535                                 /* modify header, and transmit it */
1536                                 memcpy(((Ethernet_t *)NetArpWaitTxPacket)->et_dest, NetArpWaitPacketMAC, 6);
1537                                 (void) eth_send(NetArpWaitTxPacket,
1538                                                 NetArpWaitTxPacketSize);
1539
1540                                 /* no arp request pending now */
1541                                 NetArpWaitPacketIP = 0;
1542                                 NetArpWaitTxPacketSize = 0;
1543                                 NetArpWaitPacketMAC = NULL;
1544
1545                         }
1546                         return;
1547                 default:
1548                         debug("Unexpected ARP opcode 0x%x\n",
1549                               ntohs(arp->ar_op));
1550                         return;
1551                 }
1552                 break;
1553
1554 #ifdef CONFIG_CMD_RARP
1555         case PROT_RARP:
1556                 debug("Got RARP\n");
1557                 arp = (ARP_t *)ip;
1558                 if (len < ARP_HDR_SIZE) {
1559                         printf("bad length %d < %d\n", len, ARP_HDR_SIZE);
1560                         return;
1561                 }
1562
1563                 if ((ntohs(arp->ar_op) != RARPOP_REPLY) ||
1564                         (ntohs(arp->ar_hrd) != ARP_ETHER)   ||
1565                         (ntohs(arp->ar_pro) != PROT_IP)     ||
1566                         (arp->ar_hln != 6) || (arp->ar_pln != 4)) {
1567
1568                         puts("invalid RARP header\n");
1569                 } else {
1570                         NetCopyIP(&NetOurIP, &arp->ar_data[16]);
1571                         if (NetServerIP == 0)
1572                                 NetCopyIP(&NetServerIP, &arp->ar_data[6]);
1573                         memcpy(NetServerEther, &arp->ar_data[0], 6);
1574
1575                         (*packetHandler)(0, 0, 0, 0, 0);
1576                 }
1577                 break;
1578 #endif
1579         case PROT_IP:
1580                 debug("Got IP\n");
1581                 /* Before we start poking the header, make sure it is there */
1582                 if (len < IP_HDR_SIZE) {
1583                         debug("len bad %d < %lu\n", len, (ulong)IP_HDR_SIZE);
1584                         return;
1585                 }
1586                 /* Check the packet length */
1587                 if (len < ntohs(ip->ip_len)) {
1588                         printf("len bad %d < %d\n", len, ntohs(ip->ip_len));
1589                         return;
1590                 }
1591                 len = ntohs(ip->ip_len);
1592                 debug("len=%d, v=%02x\n", len, ip->ip_hl_v & 0xff);
1593
1594                 /* Can't deal with anything except IPv4 */
1595                 if ((ip->ip_hl_v & 0xf0) != 0x40)
1596                         return;
1597                 /* Can't deal with IP options (headers != 20 bytes) */
1598                 if ((ip->ip_hl_v & 0x0f) > 0x05)
1599                         return;
1600                 /* Check the Checksum of the header */
1601                 if (!NetCksumOk((uchar *)ip, IP_HDR_SIZE_NO_UDP / 2)) {
1602                         puts("checksum bad\n");
1603                         return;
1604                 }
1605                 /* If it is not for us, ignore it */
1606                 tmp = NetReadIP(&ip->ip_dst);
1607                 if (NetOurIP && tmp != NetOurIP && tmp != 0xFFFFFFFF) {
1608 #ifdef CONFIG_MCAST_TFTP
1609                         if (Mcast_addr != tmp)
1610 #endif
1611                         return;
1612                 }
1613                 /* Read source IP address for later use */
1614                 src_ip = NetReadIP(&ip->ip_src);
1615                 /*
1616                  * The function returns the unchanged packet if it's not
1617                  * a fragment, and either the complete packet or NULL if
1618                  * it is a fragment (if !CONFIG_IP_DEFRAG, it returns NULL)
1619                  */
1620                 if (!(ip = NetDefragment(ip, &len)))
1621                         return;
1622                 /*
1623                  * watch for ICMP host redirects
1624                  *
1625                  * There is no real handler code (yet). We just watch
1626                  * for ICMP host redirect messages. In case anybody
1627                  * sees these messages: please contact me
1628                  * (wd@denx.de), or - even better - send me the
1629                  * necessary fixes :-)
1630                  *
1631                  * Note: in all cases where I have seen this so far
1632                  * it was a problem with the router configuration,
1633                  * for instance when a router was configured in the
1634                  * BOOTP reply, but the TFTP server was on the same
1635                  * subnet. So this is probably a warning that your
1636                  * configuration might be wrong. But I'm not really
1637                  * sure if there aren't any other situations.
1638                  */
1639                 if (ip->ip_p == IPPROTO_ICMP) {
1640                         ICMP_t *icmph = (ICMP_t *)&(ip->udp_src);
1641
1642                         switch (icmph->type) {
1643                         case ICMP_REDIRECT:
1644                                 if (icmph->code != ICMP_REDIR_HOST)
1645                                         return;
1646                                 printf(" ICMP Host Redirect to %pI4 ",
1647                                         &icmph->un.gateway);
1648                                 return;
1649 #if defined(CONFIG_CMD_PING)
1650                         case ICMP_ECHO_REPLY:
1651                                 /*
1652                                  * IP header OK.  Pass the packet to the
1653                                  * current handler.
1654                                  */
1655                                 /* XXX point to ip packet */
1656                                 (*packetHandler)((uchar *)ip, 0, src_ip, 0, 0);
1657                                 return;
1658                         case ICMP_ECHO_REQUEST:
1659                                 debug("Got ICMP ECHO REQUEST, return %d bytes\n",
1660                                       ETHER_HDR_SIZE + len);
1661
1662                                 memcpy(&et->et_dest[0], &et->et_src[0], 6);
1663                                 memcpy(&et->et_src[0], NetOurEther, 6);
1664
1665                                 ip->ip_sum = 0;
1666                                 ip->ip_off = 0;
1667                                 NetCopyIP((void*)&ip->ip_dst, &ip->ip_src);
1668                                 NetCopyIP((void*)&ip->ip_src, &NetOurIP);
1669                                 ip->ip_sum = ~NetCksum((uchar *)ip,
1670                                                        IP_HDR_SIZE_NO_UDP >> 1);
1671
1672                                 icmph->type = ICMP_ECHO_REPLY;
1673                                 icmph->checksum = 0;
1674                                 icmph->checksum = ~NetCksum((uchar *)icmph,
1675                                         (len - IP_HDR_SIZE_NO_UDP) >> 1);
1676                                 (void) eth_send((uchar *)et,
1677                                                 ETHER_HDR_SIZE + len);
1678                                 return;
1679 #endif
1680                         default:
1681                                 return;
1682                         }
1683                 } else if (ip->ip_p != IPPROTO_UDP) {   /* Only UDP packets */
1684                         return;
1685                 }
1686
1687 #ifdef CONFIG_UDP_CHECKSUM
1688                 if (ip->udp_xsum != 0) {
1689                         ulong   xsum;
1690                         ushort *sumptr;
1691                         ushort  sumlen;
1692
1693                         xsum  = ip->ip_p;
1694                         xsum += (ntohs(ip->udp_len));
1695                         xsum += (ntohl(ip->ip_src) >> 16) & 0x0000ffff;
1696                         xsum += (ntohl(ip->ip_src) >>  0) & 0x0000ffff;
1697                         xsum += (ntohl(ip->ip_dst) >> 16) & 0x0000ffff;
1698                         xsum += (ntohl(ip->ip_dst) >>  0) & 0x0000ffff;
1699
1700                         sumlen = ntohs(ip->udp_len);
1701                         sumptr = (ushort *) &(ip->udp_src);
1702
1703                         while (sumlen > 1) {
1704                                 ushort sumdata;
1705
1706                                 sumdata = *sumptr++;
1707                                 xsum += ntohs(sumdata);
1708                                 sumlen -= 2;
1709                         }
1710                         if (sumlen > 0) {
1711                                 ushort sumdata;
1712
1713                                 sumdata = *(unsigned char *) sumptr;
1714                                 sumdata = (sumdata << 8) & 0xff00;
1715                                 xsum += sumdata;
1716                         }
1717                         while ((xsum >> 16) != 0) {
1718                                 xsum = (xsum & 0x0000ffff) +
1719                                        ((xsum >> 16) & 0x0000ffff);
1720                         }
1721                         if ((xsum != 0x00000000) && (xsum != 0x0000ffff)) {
1722                                 printf(" UDP wrong checksum %08lx %08x\n",
1723                                         xsum, ntohs(ip->udp_xsum));
1724                                 return;
1725                         }
1726                 }
1727 #endif
1728
1729
1730 #ifdef CONFIG_NETCONSOLE
1731                 nc_input_packet((uchar *)ip + IP_HDR_SIZE,
1732                                                 ntohs(ip->udp_dst),
1733                                                 ntohs(ip->udp_src),
1734                                                 ntohs(ip->udp_len) - 8);
1735 #endif
1736                 /*
1737                  *      IP header OK.  Pass the packet to the current handler.
1738                  */
1739                 (*packetHandler)((uchar *)ip + IP_HDR_SIZE,
1740                                                 ntohs(ip->udp_dst),
1741                                                 src_ip,
1742                                                 ntohs(ip->udp_src),
1743                                                 ntohs(ip->udp_len) - 8);
1744                 break;
1745         }
1746 }
1747
1748
1749 /**********************************************************************/
1750
1751 static int net_check_prereq(proto_t protocol)
1752 {
1753         switch (protocol) {
1754                 /* Fall through */
1755 #if defined(CONFIG_CMD_PING)
1756         case PING:
1757                 if (NetPingIP == 0) {
1758                         puts("*** ERROR: ping address not given\n");
1759                         return (1);
1760                 }
1761                 goto common;
1762 #endif
1763 #if defined(CONFIG_CMD_SNTP)
1764         case SNTP:
1765                 if (NetNtpServerIP == 0) {
1766                         puts("*** ERROR: NTP server address not given\n");
1767                         return (1);
1768                 }
1769                 goto common;
1770 #endif
1771 #if defined(CONFIG_CMD_DNS)
1772         case DNS:
1773                 if (NetOurDNSIP == 0) {
1774                         puts("*** ERROR: DNS server address not given\n");
1775                         return 1;
1776                 }
1777                 goto common;
1778 #endif
1779 #if defined(CONFIG_CMD_NFS)
1780         case NFS:
1781 #endif
1782         case TFTP:
1783                 if (NetServerIP == 0) {
1784                         puts("*** ERROR: `serverip' not set\n");
1785                         return (1);
1786                 }
1787 #if     defined(CONFIG_CMD_PING) || defined(CONFIG_CMD_SNTP) || \
1788         defined(CONFIG_CMD_DNS)
1789 common:
1790 #endif
1791                 /* Fall through */
1792
1793         case NETCONS:
1794                 if (NetOurIP == 0) {
1795                         puts("*** ERROR: `ipaddr' not set\n");
1796                         return (1);
1797                 }
1798                 /* Fall through */
1799
1800 #ifdef CONFIG_CMD_RARP
1801         case RARP:
1802 #endif
1803         case BOOTP:
1804         case CDP:
1805         case DHCP:
1806                 if (memcmp(NetOurEther, "\0\0\0\0\0\0", 6) == 0) {
1807 #ifdef CONFIG_NET_MULTI
1808                         extern int eth_get_dev_index(void);
1809                         int num = eth_get_dev_index();
1810
1811                         switch (num) {
1812                         case -1:
1813                                 puts("*** ERROR: No ethernet found.\n");
1814                                 return (1);
1815                         case 0:
1816                                 puts("*** ERROR: `ethaddr' not set\n");
1817                                 break;
1818                         default:
1819                                 printf("*** ERROR: `eth%daddr' not set\n",
1820                                         num);
1821                                 break;
1822                         }
1823
1824                         NetStartAgain();
1825                         return (2);
1826 #else
1827                         puts("*** ERROR: `ethaddr' not set\n");
1828                         return (1);
1829 #endif
1830                 }
1831                 /* Fall through */
1832         default:
1833                 return (0);
1834         }
1835         return (0);             /* OK */
1836 }
1837 /**********************************************************************/
1838
1839 int
1840 NetCksumOk(uchar * ptr, int len)
1841 {
1842         return !((NetCksum(ptr, len) + 1) & 0xfffe);
1843 }
1844
1845
1846 unsigned
1847 NetCksum(uchar * ptr, int len)
1848 {
1849         ulong   xsum;
1850         ushort *p = (ushort *)ptr;
1851
1852         xsum = 0;
1853         while (len-- > 0)
1854                 xsum += *p++;
1855         xsum = (xsum & 0xffff) + (xsum >> 16);
1856         xsum = (xsum & 0xffff) + (xsum >> 16);
1857         return (xsum & 0xffff);
1858 }
1859
1860 int
1861 NetEthHdrSize(void)
1862 {
1863         ushort myvlanid;
1864
1865         myvlanid = ntohs(NetOurVLAN);
1866         if (myvlanid == (ushort)-1)
1867                 myvlanid = VLAN_NONE;
1868
1869         return ((myvlanid & VLAN_IDMASK) == VLAN_NONE) ? ETHER_HDR_SIZE :
1870                 VLAN_ETHER_HDR_SIZE;
1871 }
1872
1873 int
1874 NetSetEther(volatile uchar * xet, uchar * addr, uint prot)
1875 {
1876         Ethernet_t *et = (Ethernet_t *)xet;
1877         ushort myvlanid;
1878
1879         myvlanid = ntohs(NetOurVLAN);
1880         if (myvlanid == (ushort)-1)
1881                 myvlanid = VLAN_NONE;
1882
1883         memcpy(et->et_dest, addr, 6);
1884         memcpy(et->et_src, NetOurEther, 6);
1885         if ((myvlanid & VLAN_IDMASK) == VLAN_NONE) {
1886         et->et_protlen = htons(prot);
1887                 return ETHER_HDR_SIZE;
1888         } else {
1889                 VLAN_Ethernet_t *vet = (VLAN_Ethernet_t *)xet;
1890
1891                 vet->vet_vlan_type = htons(PROT_VLAN);
1892                 vet->vet_tag = htons((0 << 5) | (myvlanid & VLAN_IDMASK));
1893                 vet->vet_type = htons(prot);
1894                 return VLAN_ETHER_HDR_SIZE;
1895         }
1896 }
1897
1898 void
1899 NetSetIP(volatile uchar * xip, IPaddr_t dest, int dport, int sport, int len)
1900 {
1901         IP_t *ip = (IP_t *)xip;
1902
1903         /*
1904          *      If the data is an odd number of bytes, zero the
1905          *      byte after the last byte so that the checksum
1906          *      will work.
1907          */
1908         if (len & 1)
1909                 xip[IP_HDR_SIZE + len] = 0;
1910
1911         /*
1912          *      Construct an IP and UDP header.
1913          *      (need to set no fragment bit - XXX)
1914          */
1915         /* IP_HDR_SIZE / 4 (not including UDP) */
1916         ip->ip_hl_v  = 0x45;
1917         ip->ip_tos   = 0;
1918         ip->ip_len   = htons(IP_HDR_SIZE + len);
1919         ip->ip_id    = htons(NetIPID++);
1920         ip->ip_off   = htons(IP_FLAGS_DFRAG);   /* Don't fragment */
1921         ip->ip_ttl   = 255;
1922         ip->ip_p     = 17;              /* UDP */
1923         ip->ip_sum   = 0;
1924         /* already in network byte order */
1925         NetCopyIP((void*)&ip->ip_src, &NetOurIP);
1926         /* - "" - */
1927         NetCopyIP((void*)&ip->ip_dst, &dest);
1928         ip->udp_src  = htons(sport);
1929         ip->udp_dst  = htons(dport);
1930         ip->udp_len  = htons(8 + len);
1931         ip->udp_xsum = 0;
1932         ip->ip_sum   = ~NetCksum((uchar *)ip, IP_HDR_SIZE_NO_UDP / 2);
1933 }
1934
1935 void copy_filename(char *dst, const char *src, int size)
1936 {
1937         if (*src && (*src == '"')) {
1938                 ++src;
1939                 --size;
1940         }
1941
1942         while ((--size > 0) && *src && (*src != '"'))
1943                 *dst++ = *src++;
1944         *dst = '\0';
1945 }
1946
1947 #if     defined(CONFIG_CMD_NFS)         || \
1948         defined(CONFIG_CMD_SNTP)        || \
1949         defined(CONFIG_CMD_DNS)
1950 /*
1951  * make port a little random (1024-17407)
1952  * This keeps the math somewhat trivial to compute, and seems to work with
1953  * all supported protocols/clients/servers
1954  */
1955 unsigned int random_port(void)
1956 {
1957         return 1024 + (get_timer(0) % 0x4000);
1958 }
1959 #endif
1960
1961 void ip_to_string(IPaddr_t x, char *s)
1962 {
1963         x = ntohl(x);
1964         sprintf(s, "%d.%d.%d.%d",
1965                 (int) ((x >> 24) & 0xff),
1966                 (int) ((x >> 16) & 0xff),
1967                 (int) ((x >> 8) & 0xff), (int) ((x >> 0) & 0xff)
1968         );
1969 }
1970
1971 void VLAN_to_string(ushort x, char *s)
1972 {
1973         x = ntohs(x);
1974
1975         if (x == (ushort)-1)
1976                 x = VLAN_NONE;
1977
1978         if (x == VLAN_NONE)
1979                 strcpy(s, "none");
1980         else
1981                 sprintf(s, "%d", x & VLAN_IDMASK);
1982 }
1983
1984 ushort string_to_VLAN(const char *s)
1985 {
1986         ushort id;
1987
1988         if (s == NULL)
1989                 return htons(VLAN_NONE);
1990
1991         if (*s < '0' || *s > '9')
1992                 id = VLAN_NONE;
1993         else
1994                 id = (ushort)simple_strtoul(s, NULL, 10);
1995
1996         return htons(id);
1997 }
1998
1999 ushort getenv_VLAN(char *var)
2000 {
2001         return (string_to_VLAN(getenv(var)));
2002 }