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