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 * SPDX-License-Identifier: GPL-2.0 10 */ 11 12 /* 13 * General Desription: 14 * 15 * The user interface supports commands for BOOTP, RARP, and TFTP. 16 * Also, we support ARP internally. Depending on available data, 17 * these interact as follows: 18 * 19 * BOOTP: 20 * 21 * Prerequisites: - own ethernet address 22 * We want: - own IP address 23 * - TFTP server IP address 24 * - name of bootfile 25 * Next step: ARP 26 * 27 * LINK_LOCAL: 28 * 29 * Prerequisites: - own ethernet address 30 * We want: - own IP address 31 * Next step: ARP 32 * 33 * RARP: 34 * 35 * Prerequisites: - own ethernet address 36 * We want: - own IP address 37 * - TFTP server IP address 38 * Next step: ARP 39 * 40 * ARP: 41 * 42 * Prerequisites: - own ethernet address 43 * - own IP address 44 * - TFTP server IP address 45 * We want: - TFTP server ethernet address 46 * Next step: TFTP 47 * 48 * DHCP: 49 * 50 * Prerequisites: - own ethernet address 51 * We want: - IP, Netmask, ServerIP, Gateway IP 52 * - bootfilename, lease time 53 * Next step: - TFTP 54 * 55 * TFTP: 56 * 57 * Prerequisites: - own ethernet address 58 * - own IP address 59 * - TFTP server IP address 60 * - TFTP server ethernet address 61 * - name of bootfile (if unknown, we use a default name 62 * derived from our own IP address) 63 * We want: - load the boot file 64 * Next step: none 65 * 66 * NFS: 67 * 68 * Prerequisites: - own ethernet address 69 * - own IP address 70 * - name of bootfile (if unknown, we use a default name 71 * derived from our own IP address) 72 * We want: - load the boot file 73 * Next step: none 74 * 75 * SNTP: 76 * 77 * Prerequisites: - own ethernet address 78 * - own IP address 79 * We want: - network time 80 * Next step: none 81 */ 82 83 84 #include <common.h> 85 #include <command.h> 86 #include <environment.h> 87 #include <errno.h> 88 #include <net.h> 89 #if defined(CONFIG_STATUS_LED) 90 #include <miiphy.h> 91 #include <status_led.h> 92 #endif 93 #include <watchdog.h> 94 #include <linux/compiler.h> 95 #include "arp.h" 96 #include "bootp.h" 97 #include "cdp.h" 98 #if defined(CONFIG_CMD_DNS) 99 #include "dns.h" 100 #endif 101 #include "link_local.h" 102 #include "nfs.h" 103 #include "ping.h" 104 #include "rarp.h" 105 #if defined(CONFIG_CMD_SNTP) 106 #include "sntp.h" 107 #endif 108 #include "tftp.h" 109 110 DECLARE_GLOBAL_DATA_PTR; 111 112 /** BOOTP EXTENTIONS **/ 113 114 /* Our subnet mask (0=unknown) */ 115 struct in_addr net_netmask; 116 /* Our gateways IP address */ 117 struct in_addr net_gateway; 118 /* Our DNS IP address */ 119 struct in_addr net_dns_server; 120 #if defined(CONFIG_BOOTP_DNS2) 121 /* Our 2nd DNS IP address */ 122 struct in_addr net_dns_server2; 123 #endif 124 /* Our NIS domain */ 125 char NetOurNISDomain[32] = {0,}; 126 /* Our hostname */ 127 char NetOurHostName[32] = {0,}; 128 /* Our bootpath */ 129 char NetOurRootPath[64] = {0,}; 130 131 #ifdef CONFIG_MCAST_TFTP /* Multicast TFTP */ 132 struct in_addr net_mcast_addr; 133 #endif 134 135 /** END OF BOOTP EXTENTIONS **/ 136 137 /* Our ethernet address */ 138 uchar NetOurEther[6]; 139 /* Boot server enet address */ 140 uchar NetServerEther[6]; 141 /* Our IP addr (0 = unknown) */ 142 struct in_addr net_ip; 143 /* Server IP addr (0 = unknown) */ 144 struct in_addr net_server_ip; 145 /* Current receive packet */ 146 uchar *NetRxPacket; 147 /* Current rx packet length */ 148 int NetRxPacketLen; 149 /* IP packet ID */ 150 unsigned NetIPID; 151 /* Ethernet bcast address */ 152 uchar NetBcastAddr[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; 153 uchar NetEtherNullAddr[6]; 154 #ifdef CONFIG_API 155 void (*push_packet)(void *, int len) = 0; 156 #endif 157 /* Network loop state */ 158 enum net_loop_state net_state; 159 /* Tried all network devices */ 160 int NetRestartWrap; 161 /* Network loop restarted */ 162 static int NetRestarted; 163 /* At least one device configured */ 164 static int NetDevExists; 165 166 /* XXX in both little & big endian machines 0xFFFF == ntohs(-1) */ 167 /* default is without VLAN */ 168 ushort NetOurVLAN = 0xFFFF; 169 /* ditto */ 170 ushort NetOurNativeVLAN = 0xFFFF; 171 172 /* Boot File name */ 173 char net_boot_file_name[128]; 174 /* The actual transferred size of the bootfile (in bytes) */ 175 u32 net_boot_file_size; 176 /* Boot file size in blocks as reported by the DHCP server */ 177 u32 net_boot_file_expected_size_in_blocks; 178 179 #if defined(CONFIG_CMD_SNTP) 180 /* NTP server IP address */ 181 struct in_addr net_ntp_server; 182 /* offset time from UTC */ 183 int NetTimeOffset; 184 #endif 185 186 static uchar PktBuf[(PKTBUFSRX+1) * PKTSIZE_ALIGN + PKTALIGN]; 187 #ifdef CONFIG_DM_ETH 188 /* Receive packets */ 189 uchar *net_rx_packets[PKTBUFSRX]; 190 #else 191 /* Receive packet */ 192 uchar *NetRxPackets[PKTBUFSRX]; 193 #endif 194 /* Current UDP RX packet handler */ 195 static rxhand_f *udp_packet_handler; 196 /* Current ARP RX packet handler */ 197 static rxhand_f *arp_packet_handler; 198 #ifdef CONFIG_CMD_TFTPPUT 199 /* Current ICMP rx handler */ 200 static rxhand_icmp_f *packet_icmp_handler; 201 #endif 202 /* Current timeout handler */ 203 static thand_f *timeHandler; 204 /* Time base value */ 205 static ulong timeStart; 206 /* Current timeout value */ 207 static ulong timeDelta; 208 /* THE transmit packet */ 209 uchar *NetTxPacket; 210 211 static int net_check_prereq(enum proto_t protocol); 212 213 static int NetTryCount; 214 215 int __maybe_unused net_busy_flag; 216 217 /**********************************************************************/ 218 219 static int on_bootfile(const char *name, const char *value, enum env_op op, 220 int flags) 221 { 222 switch (op) { 223 case env_op_create: 224 case env_op_overwrite: 225 copy_filename(net_boot_file_name, value, 226 sizeof(net_boot_file_name)); 227 break; 228 default: 229 break; 230 } 231 232 return 0; 233 } 234 U_BOOT_ENV_CALLBACK(bootfile, on_bootfile); 235 236 /* 237 * Check if autoload is enabled. If so, use either NFS or TFTP to download 238 * the boot file. 239 */ 240 void net_auto_load(void) 241 { 242 #if defined(CONFIG_CMD_NFS) 243 const char *s = getenv("autoload"); 244 245 if (s != NULL && strcmp(s, "NFS") == 0) { 246 /* 247 * Use NFS to load the bootfile. 248 */ 249 NfsStart(); 250 return; 251 } 252 #endif 253 if (getenv_yesno("autoload") == 0) { 254 /* 255 * Just use BOOTP/RARP to configure system; 256 * Do not use TFTP to load the bootfile. 257 */ 258 net_set_state(NETLOOP_SUCCESS); 259 return; 260 } 261 TftpStart(TFTPGET); 262 } 263 264 static void NetInitLoop(void) 265 { 266 static int env_changed_id; 267 int env_id = get_env_id(); 268 269 /* update only when the environment has changed */ 270 if (env_changed_id != env_id) { 271 net_ip = getenv_ip("ipaddr"); 272 net_gateway = getenv_ip("gatewayip"); 273 net_netmask = getenv_ip("netmask"); 274 net_server_ip = getenv_ip("serverip"); 275 NetOurNativeVLAN = getenv_VLAN("nvlan"); 276 NetOurVLAN = getenv_VLAN("vlan"); 277 #if defined(CONFIG_CMD_DNS) 278 net_dns_server = getenv_ip("dnsip"); 279 #endif 280 env_changed_id = env_id; 281 } 282 if (eth_get_dev()) 283 memcpy(NetOurEther, eth_get_ethaddr(), 6); 284 285 return; 286 } 287 288 static void net_clear_handlers(void) 289 { 290 net_set_udp_handler(NULL); 291 net_set_arp_handler(NULL); 292 NetSetTimeout(0, NULL); 293 } 294 295 static void net_cleanup_loop(void) 296 { 297 net_clear_handlers(); 298 } 299 300 void net_init(void) 301 { 302 static int first_call = 1; 303 304 if (first_call) { 305 /* 306 * Setup packet buffers, aligned correctly. 307 */ 308 int i; 309 310 NetTxPacket = &PktBuf[0] + (PKTALIGN - 1); 311 NetTxPacket -= (ulong)NetTxPacket % PKTALIGN; 312 #ifdef CONFIG_DM_ETH 313 for (i = 0; i < PKTBUFSRX; i++) { 314 net_rx_packets[i] = NetTxPacket + (i + 1) * 315 PKTSIZE_ALIGN; 316 } 317 #else 318 for (i = 0; i < PKTBUFSRX; i++) 319 NetRxPackets[i] = NetTxPacket + (i + 1) * PKTSIZE_ALIGN; 320 #endif 321 ArpInit(); 322 net_clear_handlers(); 323 324 /* Only need to setup buffer pointers once. */ 325 first_call = 0; 326 } 327 328 NetInitLoop(); 329 } 330 331 /**********************************************************************/ 332 /* 333 * Main network processing loop. 334 */ 335 336 int NetLoop(enum proto_t protocol) 337 { 338 int ret = -EINVAL; 339 340 NetRestarted = 0; 341 NetDevExists = 0; 342 NetTryCount = 1; 343 debug_cond(DEBUG_INT_STATE, "--- NetLoop Entry\n"); 344 345 bootstage_mark_name(BOOTSTAGE_ID_ETH_START, "eth_start"); 346 net_init(); 347 if (eth_is_on_demand_init() || protocol != NETCONS) { 348 eth_halt(); 349 eth_set_current(); 350 ret = eth_init(); 351 if (ret < 0) { 352 eth_halt(); 353 return ret; 354 } 355 } else 356 eth_init_state_only(); 357 358 restart: 359 #ifdef CONFIG_USB_KEYBOARD 360 net_busy_flag = 0; 361 #endif 362 net_set_state(NETLOOP_CONTINUE); 363 364 /* 365 * Start the ball rolling with the given start function. From 366 * here on, this code is a state machine driven by received 367 * packets and timer events. 368 */ 369 debug_cond(DEBUG_INT_STATE, "--- NetLoop Init\n"); 370 NetInitLoop(); 371 372 switch (net_check_prereq(protocol)) { 373 case 1: 374 /* network not configured */ 375 eth_halt(); 376 return -ENODEV; 377 378 case 2: 379 /* network device not configured */ 380 break; 381 382 case 0: 383 NetDevExists = 1; 384 net_boot_file_size = 0; 385 switch (protocol) { 386 case TFTPGET: 387 #ifdef CONFIG_CMD_TFTPPUT 388 case TFTPPUT: 389 #endif 390 /* always use ARP to get server ethernet address */ 391 TftpStart(protocol); 392 break; 393 #ifdef CONFIG_CMD_TFTPSRV 394 case TFTPSRV: 395 TftpStartServer(); 396 break; 397 #endif 398 #if defined(CONFIG_CMD_DHCP) 399 case DHCP: 400 BootpReset(); 401 net_ip.s_addr = 0; 402 DhcpRequest(); /* Basically same as BOOTP */ 403 break; 404 #endif 405 406 case BOOTP: 407 BootpReset(); 408 net_ip.s_addr = 0; 409 BootpRequest(); 410 break; 411 412 #if defined(CONFIG_CMD_RARP) 413 case RARP: 414 RarpTry = 0; 415 net_ip.s_addr = 0; 416 RarpRequest(); 417 break; 418 #endif 419 #if defined(CONFIG_CMD_PING) 420 case PING: 421 ping_start(); 422 break; 423 #endif 424 #if defined(CONFIG_CMD_NFS) 425 case NFS: 426 NfsStart(); 427 break; 428 #endif 429 #if defined(CONFIG_CMD_CDP) 430 case CDP: 431 CDPStart(); 432 break; 433 #endif 434 #if defined (CONFIG_NETCONSOLE) && !(CONFIG_SPL_BUILD) 435 case NETCONS: 436 NcStart(); 437 break; 438 #endif 439 #if defined(CONFIG_CMD_SNTP) 440 case SNTP: 441 SntpStart(); 442 break; 443 #endif 444 #if defined(CONFIG_CMD_DNS) 445 case DNS: 446 DnsStart(); 447 break; 448 #endif 449 #if defined(CONFIG_CMD_LINK_LOCAL) 450 case LINKLOCAL: 451 link_local_start(); 452 break; 453 #endif 454 default: 455 break; 456 } 457 458 break; 459 } 460 461 #if defined(CONFIG_MII) || defined(CONFIG_CMD_MII) 462 #if defined(CONFIG_SYS_FAULT_ECHO_LINK_DOWN) && \ 463 defined(CONFIG_STATUS_LED) && \ 464 defined(STATUS_LED_RED) 465 /* 466 * Echo the inverted link state to the fault LED. 467 */ 468 if (miiphy_link(eth_get_dev()->name, CONFIG_SYS_FAULT_MII_ADDR)) 469 status_led_set(STATUS_LED_RED, STATUS_LED_OFF); 470 else 471 status_led_set(STATUS_LED_RED, STATUS_LED_ON); 472 #endif /* CONFIG_SYS_FAULT_ECHO_LINK_DOWN, ... */ 473 #endif /* CONFIG_MII, ... */ 474 #ifdef CONFIG_USB_KEYBOARD 475 net_busy_flag = 1; 476 #endif 477 478 /* 479 * Main packet reception loop. Loop receiving packets until 480 * someone sets `net_state' to a state that terminates. 481 */ 482 for (;;) { 483 WATCHDOG_RESET(); 484 #ifdef CONFIG_SHOW_ACTIVITY 485 show_activity(1); 486 #endif 487 /* 488 * Check the ethernet for a new packet. The ethernet 489 * receive routine will process it. 490 * Most drivers return the most recent packet size, but not 491 * errors that may have happened. 492 */ 493 eth_rx(); 494 495 /* 496 * Abort if ctrl-c was pressed. 497 */ 498 if (ctrlc()) { 499 /* cancel any ARP that may not have completed */ 500 net_arp_wait_packet_ip.s_addr = 0; 501 502 net_cleanup_loop(); 503 eth_halt(); 504 /* Invalidate the last protocol */ 505 eth_set_last_protocol(BOOTP); 506 507 puts("\nAbort\n"); 508 /* include a debug print as well incase the debug 509 messages are directed to stderr */ 510 debug_cond(DEBUG_INT_STATE, "--- NetLoop Abort!\n"); 511 goto done; 512 } 513 514 ArpTimeoutCheck(); 515 516 /* 517 * Check for a timeout, and run the timeout handler 518 * if we have one. 519 */ 520 if (timeHandler && ((get_timer(0) - timeStart) > timeDelta)) { 521 thand_f *x; 522 523 #if defined(CONFIG_MII) || defined(CONFIG_CMD_MII) 524 #if defined(CONFIG_SYS_FAULT_ECHO_LINK_DOWN) && \ 525 defined(CONFIG_STATUS_LED) && \ 526 defined(STATUS_LED_RED) 527 /* 528 * Echo the inverted link state to the fault LED. 529 */ 530 if (miiphy_link(eth_get_dev()->name, 531 CONFIG_SYS_FAULT_MII_ADDR)) { 532 status_led_set(STATUS_LED_RED, STATUS_LED_OFF); 533 } else { 534 status_led_set(STATUS_LED_RED, STATUS_LED_ON); 535 } 536 #endif /* CONFIG_SYS_FAULT_ECHO_LINK_DOWN, ... */ 537 #endif /* CONFIG_MII, ... */ 538 debug_cond(DEBUG_INT_STATE, "--- NetLoop timeout\n"); 539 x = timeHandler; 540 timeHandler = (thand_f *)0; 541 (*x)(); 542 } 543 544 if (net_state == NETLOOP_FAIL) 545 ret = NetStartAgain(); 546 547 switch (net_state) { 548 549 case NETLOOP_RESTART: 550 NetRestarted = 1; 551 goto restart; 552 553 case NETLOOP_SUCCESS: 554 net_cleanup_loop(); 555 if (net_boot_file_size > 0) { 556 printf("Bytes transferred = %d (%x hex)\n", 557 net_boot_file_size, net_boot_file_size); 558 setenv_hex("filesize", net_boot_file_size); 559 setenv_hex("fileaddr", load_addr); 560 } 561 if (protocol != NETCONS) 562 eth_halt(); 563 else 564 eth_halt_state_only(); 565 566 eth_set_last_protocol(protocol); 567 568 ret = net_boot_file_size; 569 debug_cond(DEBUG_INT_STATE, "--- NetLoop Success!\n"); 570 goto done; 571 572 case NETLOOP_FAIL: 573 net_cleanup_loop(); 574 /* Invalidate the last protocol */ 575 eth_set_last_protocol(BOOTP); 576 debug_cond(DEBUG_INT_STATE, "--- NetLoop Fail!\n"); 577 goto done; 578 579 case NETLOOP_CONTINUE: 580 continue; 581 } 582 } 583 584 done: 585 #ifdef CONFIG_USB_KEYBOARD 586 net_busy_flag = 0; 587 #endif 588 #ifdef CONFIG_CMD_TFTPPUT 589 /* Clear out the handlers */ 590 net_set_udp_handler(NULL); 591 net_set_icmp_handler(NULL); 592 #endif 593 return ret; 594 } 595 596 /**********************************************************************/ 597 598 static void 599 startAgainTimeout(void) 600 { 601 net_set_state(NETLOOP_RESTART); 602 } 603 604 int NetStartAgain(void) 605 { 606 char *nretry; 607 int retry_forever = 0; 608 unsigned long retrycnt = 0; 609 int ret; 610 611 nretry = getenv("netretry"); 612 if (nretry) { 613 if (!strcmp(nretry, "yes")) 614 retry_forever = 1; 615 else if (!strcmp(nretry, "no")) 616 retrycnt = 0; 617 else if (!strcmp(nretry, "once")) 618 retrycnt = 1; 619 else 620 retrycnt = simple_strtoul(nretry, NULL, 0); 621 } else { 622 retrycnt = 0; 623 retry_forever = 0; 624 } 625 626 if ((!retry_forever) && (NetTryCount >= retrycnt)) { 627 eth_halt(); 628 net_set_state(NETLOOP_FAIL); 629 /* 630 * We don't provide a way for the protocol to return an error, 631 * but this is almost always the reason. 632 */ 633 return -ETIMEDOUT; 634 } 635 636 NetTryCount++; 637 638 eth_halt(); 639 #if !defined(CONFIG_NET_DO_NOT_TRY_ANOTHER) 640 eth_try_another(!NetRestarted); 641 #endif 642 ret = eth_init(); 643 if (NetRestartWrap) { 644 NetRestartWrap = 0; 645 if (NetDevExists) { 646 NetSetTimeout(10000UL, startAgainTimeout); 647 net_set_udp_handler(NULL); 648 } else { 649 net_set_state(NETLOOP_FAIL); 650 } 651 } else { 652 net_set_state(NETLOOP_RESTART); 653 } 654 return ret; 655 } 656 657 /**********************************************************************/ 658 /* 659 * Miscelaneous bits. 660 */ 661 662 static void dummy_handler(uchar *pkt, unsigned dport, 663 struct in_addr sip, unsigned sport, 664 unsigned len) 665 { 666 } 667 668 rxhand_f *net_get_udp_handler(void) 669 { 670 return udp_packet_handler; 671 } 672 673 void net_set_udp_handler(rxhand_f *f) 674 { 675 debug_cond(DEBUG_INT_STATE, "--- NetLoop UDP handler set (%p)\n", f); 676 if (f == NULL) 677 udp_packet_handler = dummy_handler; 678 else 679 udp_packet_handler = f; 680 } 681 682 rxhand_f *net_get_arp_handler(void) 683 { 684 return arp_packet_handler; 685 } 686 687 void net_set_arp_handler(rxhand_f *f) 688 { 689 debug_cond(DEBUG_INT_STATE, "--- NetLoop ARP handler set (%p)\n", f); 690 if (f == NULL) 691 arp_packet_handler = dummy_handler; 692 else 693 arp_packet_handler = f; 694 } 695 696 #ifdef CONFIG_CMD_TFTPPUT 697 void net_set_icmp_handler(rxhand_icmp_f *f) 698 { 699 packet_icmp_handler = f; 700 } 701 #endif 702 703 void 704 NetSetTimeout(ulong iv, thand_f *f) 705 { 706 if (iv == 0) { 707 debug_cond(DEBUG_INT_STATE, 708 "--- NetLoop timeout handler cancelled\n"); 709 timeHandler = (thand_f *)0; 710 } else { 711 debug_cond(DEBUG_INT_STATE, 712 "--- NetLoop timeout handler set (%p)\n", f); 713 timeHandler = f; 714 timeStart = get_timer(0); 715 timeDelta = iv * CONFIG_SYS_HZ / 1000; 716 } 717 } 718 719 int NetSendUDPPacket(uchar *ether, struct in_addr dest, int dport, int sport, 720 int payload_len) 721 { 722 uchar *pkt; 723 int eth_hdr_size; 724 int pkt_hdr_size; 725 726 /* make sure the NetTxPacket is initialized (NetInit() was called) */ 727 assert(NetTxPacket != NULL); 728 if (NetTxPacket == NULL) 729 return -1; 730 731 /* convert to new style broadcast */ 732 if (dest.s_addr == 0) 733 dest.s_addr = 0xFFFFFFFF; 734 735 /* if broadcast, make the ether address a broadcast and don't do ARP */ 736 if (dest.s_addr == 0xFFFFFFFF) 737 ether = NetBcastAddr; 738 739 pkt = (uchar *)NetTxPacket; 740 741 eth_hdr_size = NetSetEther(pkt, ether, PROT_IP); 742 pkt += eth_hdr_size; 743 net_set_udp_header(pkt, dest, dport, sport, payload_len); 744 pkt_hdr_size = eth_hdr_size + IP_UDP_HDR_SIZE; 745 746 /* if MAC address was not discovered yet, do an ARP request */ 747 if (memcmp(ether, NetEtherNullAddr, 6) == 0) { 748 debug_cond(DEBUG_DEV_PKT, "sending ARP for %pI4\n", &dest); 749 750 /* save the ip and eth addr for the packet to send after arp */ 751 net_arp_wait_packet_ip = dest; 752 NetArpWaitPacketMAC = ether; 753 754 /* size of the waiting packet */ 755 NetArpWaitTxPacketSize = pkt_hdr_size + payload_len; 756 757 /* and do the ARP request */ 758 NetArpWaitTry = 1; 759 NetArpWaitTimerStart = get_timer(0); 760 ArpRequest(); 761 return 1; /* waiting */ 762 } else { 763 debug_cond(DEBUG_DEV_PKT, "sending UDP to %pI4/%pM\n", 764 &dest, ether); 765 NetSendPacket(NetTxPacket, pkt_hdr_size + payload_len); 766 return 0; /* transmitted */ 767 } 768 } 769 770 #ifdef CONFIG_IP_DEFRAG 771 /* 772 * This function collects fragments in a single packet, according 773 * to the algorithm in RFC815. It returns NULL or the pointer to 774 * a complete packet, in static storage 775 */ 776 #ifndef CONFIG_NET_MAXDEFRAG 777 #define CONFIG_NET_MAXDEFRAG 16384 778 #endif 779 /* 780 * MAXDEFRAG, above, is chosen in the config file and is real data 781 * so we need to add the NFS overhead, which is more than TFTP. 782 * To use sizeof in the internal unnamed structures, we need a real 783 * instance (can't do "sizeof(struct rpc_t.u.reply))", unfortunately). 784 * The compiler doesn't complain nor allocates the actual structure 785 */ 786 static struct rpc_t rpc_specimen; 787 #define IP_PKTSIZE (CONFIG_NET_MAXDEFRAG + sizeof(rpc_specimen.u.reply)) 788 789 #define IP_MAXUDP (IP_PKTSIZE - IP_HDR_SIZE) 790 791 /* 792 * this is the packet being assembled, either data or frag control. 793 * Fragments go by 8 bytes, so this union must be 8 bytes long 794 */ 795 struct hole { 796 /* first_byte is address of this structure */ 797 u16 last_byte; /* last byte in this hole + 1 (begin of next hole) */ 798 u16 next_hole; /* index of next (in 8-b blocks), 0 == none */ 799 u16 prev_hole; /* index of prev, 0 == none */ 800 u16 unused; 801 }; 802 803 static struct ip_udp_hdr *__NetDefragment(struct ip_udp_hdr *ip, int *lenp) 804 { 805 static uchar pkt_buff[IP_PKTSIZE] __aligned(PKTALIGN); 806 static u16 first_hole, total_len; 807 struct hole *payload, *thisfrag, *h, *newh; 808 struct ip_udp_hdr *localip = (struct ip_udp_hdr *)pkt_buff; 809 uchar *indata = (uchar *)ip; 810 int offset8, start, len, done = 0; 811 u16 ip_off = ntohs(ip->ip_off); 812 813 /* payload starts after IP header, this fragment is in there */ 814 payload = (struct hole *)(pkt_buff + IP_HDR_SIZE); 815 offset8 = (ip_off & IP_OFFS); 816 thisfrag = payload + offset8; 817 start = offset8 * 8; 818 len = ntohs(ip->ip_len) - IP_HDR_SIZE; 819 820 if (start + len > IP_MAXUDP) /* fragment extends too far */ 821 return NULL; 822 823 if (!total_len || localip->ip_id != ip->ip_id) { 824 /* new (or different) packet, reset structs */ 825 total_len = 0xffff; 826 payload[0].last_byte = ~0; 827 payload[0].next_hole = 0; 828 payload[0].prev_hole = 0; 829 first_hole = 0; 830 /* any IP header will work, copy the first we received */ 831 memcpy(localip, ip, IP_HDR_SIZE); 832 } 833 834 /* 835 * What follows is the reassembly algorithm. We use the payload 836 * array as a linked list of hole descriptors, as each hole starts 837 * at a multiple of 8 bytes. However, last byte can be whatever value, 838 * so it is represented as byte count, not as 8-byte blocks. 839 */ 840 841 h = payload + first_hole; 842 while (h->last_byte < start) { 843 if (!h->next_hole) { 844 /* no hole that far away */ 845 return NULL; 846 } 847 h = payload + h->next_hole; 848 } 849 850 /* last fragment may be 1..7 bytes, the "+7" forces acceptance */ 851 if (offset8 + ((len + 7) / 8) <= h - payload) { 852 /* no overlap with holes (dup fragment?) */ 853 return NULL; 854 } 855 856 if (!(ip_off & IP_FLAGS_MFRAG)) { 857 /* no more fragmentss: truncate this (last) hole */ 858 total_len = start + len; 859 h->last_byte = start + len; 860 } 861 862 /* 863 * There is some overlap: fix the hole list. This code doesn't 864 * deal with a fragment that overlaps with two different holes 865 * (thus being a superset of a previously-received fragment). 866 */ 867 868 if ((h >= thisfrag) && (h->last_byte <= start + len)) { 869 /* complete overlap with hole: remove hole */ 870 if (!h->prev_hole && !h->next_hole) { 871 /* last remaining hole */ 872 done = 1; 873 } else if (!h->prev_hole) { 874 /* first hole */ 875 first_hole = h->next_hole; 876 payload[h->next_hole].prev_hole = 0; 877 } else if (!h->next_hole) { 878 /* last hole */ 879 payload[h->prev_hole].next_hole = 0; 880 } else { 881 /* in the middle of the list */ 882 payload[h->next_hole].prev_hole = h->prev_hole; 883 payload[h->prev_hole].next_hole = h->next_hole; 884 } 885 886 } else if (h->last_byte <= start + len) { 887 /* overlaps with final part of the hole: shorten this hole */ 888 h->last_byte = start; 889 890 } else if (h >= thisfrag) { 891 /* overlaps with initial part of the hole: move this hole */ 892 newh = thisfrag + (len / 8); 893 *newh = *h; 894 h = newh; 895 if (h->next_hole) 896 payload[h->next_hole].prev_hole = (h - payload); 897 if (h->prev_hole) 898 payload[h->prev_hole].next_hole = (h - payload); 899 else 900 first_hole = (h - payload); 901 902 } else { 903 /* fragment sits in the middle: split the hole */ 904 newh = thisfrag + (len / 8); 905 *newh = *h; 906 h->last_byte = start; 907 h->next_hole = (newh - payload); 908 newh->prev_hole = (h - payload); 909 if (newh->next_hole) 910 payload[newh->next_hole].prev_hole = (newh - payload); 911 } 912 913 /* finally copy this fragment and possibly return whole packet */ 914 memcpy((uchar *)thisfrag, indata + IP_HDR_SIZE, len); 915 if (!done) 916 return NULL; 917 918 localip->ip_len = htons(total_len); 919 *lenp = total_len + IP_HDR_SIZE; 920 return localip; 921 } 922 923 static inline struct ip_udp_hdr *NetDefragment(struct ip_udp_hdr *ip, int *lenp) 924 { 925 u16 ip_off = ntohs(ip->ip_off); 926 if (!(ip_off & (IP_OFFS | IP_FLAGS_MFRAG))) 927 return ip; /* not a fragment */ 928 return __NetDefragment(ip, lenp); 929 } 930 931 #else /* !CONFIG_IP_DEFRAG */ 932 933 static inline struct ip_udp_hdr *NetDefragment(struct ip_udp_hdr *ip, int *lenp) 934 { 935 u16 ip_off = ntohs(ip->ip_off); 936 if (!(ip_off & (IP_OFFS | IP_FLAGS_MFRAG))) 937 return ip; /* not a fragment */ 938 return NULL; 939 } 940 #endif 941 942 /** 943 * Receive an ICMP packet. We deal with REDIRECT and PING here, and silently 944 * drop others. 945 * 946 * @parma ip IP packet containing the ICMP 947 */ 948 static void receive_icmp(struct ip_udp_hdr *ip, int len, 949 struct in_addr src_ip, struct ethernet_hdr *et) 950 { 951 struct icmp_hdr *icmph = (struct icmp_hdr *)&ip->udp_src; 952 953 switch (icmph->type) { 954 case ICMP_REDIRECT: 955 if (icmph->code != ICMP_REDIR_HOST) 956 return; 957 printf(" ICMP Host Redirect to %pI4 ", 958 &icmph->un.gateway); 959 break; 960 default: 961 #if defined(CONFIG_CMD_PING) 962 ping_receive(et, ip, len); 963 #endif 964 #ifdef CONFIG_CMD_TFTPPUT 965 if (packet_icmp_handler) 966 packet_icmp_handler(icmph->type, icmph->code, 967 ntohs(ip->udp_dst), src_ip, ntohs(ip->udp_src), 968 icmph->un.data, ntohs(ip->udp_len)); 969 #endif 970 break; 971 } 972 } 973 974 void net_process_received_packet(uchar *in_packet, int len) 975 { 976 struct ethernet_hdr *et; 977 struct ip_udp_hdr *ip; 978 struct in_addr dst_ip; 979 struct in_addr src_ip; 980 int eth_proto; 981 #if defined(CONFIG_CMD_CDP) 982 int iscdp; 983 #endif 984 ushort cti = 0, vlanid = VLAN_NONE, myvlanid, mynvlanid; 985 986 debug_cond(DEBUG_NET_PKT, "packet received\n"); 987 988 NetRxPacket = in_packet; 989 NetRxPacketLen = len; 990 et = (struct ethernet_hdr *)in_packet; 991 992 /* too small packet? */ 993 if (len < ETHER_HDR_SIZE) 994 return; 995 996 #ifdef CONFIG_API 997 if (push_packet) { 998 (*push_packet)(in_packet, len); 999 return; 1000 } 1001 #endif 1002 1003 #if defined(CONFIG_CMD_CDP) 1004 /* keep track if packet is CDP */ 1005 iscdp = is_cdp_packet(et->et_dest); 1006 #endif 1007 1008 myvlanid = ntohs(NetOurVLAN); 1009 if (myvlanid == (ushort)-1) 1010 myvlanid = VLAN_NONE; 1011 mynvlanid = ntohs(NetOurNativeVLAN); 1012 if (mynvlanid == (ushort)-1) 1013 mynvlanid = VLAN_NONE; 1014 1015 eth_proto = ntohs(et->et_protlen); 1016 1017 if (eth_proto < 1514) { 1018 struct e802_hdr *et802 = (struct e802_hdr *)et; 1019 /* 1020 * Got a 802.2 packet. Check the other protocol field. 1021 * XXX VLAN over 802.2+SNAP not implemented! 1022 */ 1023 eth_proto = ntohs(et802->et_prot); 1024 1025 ip = (struct ip_udp_hdr *)(in_packet + E802_HDR_SIZE); 1026 len -= E802_HDR_SIZE; 1027 1028 } else if (eth_proto != PROT_VLAN) { /* normal packet */ 1029 ip = (struct ip_udp_hdr *)(in_packet + ETHER_HDR_SIZE); 1030 len -= ETHER_HDR_SIZE; 1031 1032 } else { /* VLAN packet */ 1033 struct vlan_ethernet_hdr *vet = 1034 (struct vlan_ethernet_hdr *)et; 1035 1036 debug_cond(DEBUG_NET_PKT, "VLAN packet received\n"); 1037 1038 /* too small packet? */ 1039 if (len < VLAN_ETHER_HDR_SIZE) 1040 return; 1041 1042 /* if no VLAN active */ 1043 if ((ntohs(NetOurVLAN) & VLAN_IDMASK) == VLAN_NONE 1044 #if defined(CONFIG_CMD_CDP) 1045 && iscdp == 0 1046 #endif 1047 ) 1048 return; 1049 1050 cti = ntohs(vet->vet_tag); 1051 vlanid = cti & VLAN_IDMASK; 1052 eth_proto = ntohs(vet->vet_type); 1053 1054 ip = (struct ip_udp_hdr *)(in_packet + VLAN_ETHER_HDR_SIZE); 1055 len -= VLAN_ETHER_HDR_SIZE; 1056 } 1057 1058 debug_cond(DEBUG_NET_PKT, "Receive from protocol 0x%x\n", eth_proto); 1059 1060 #if defined(CONFIG_CMD_CDP) 1061 if (iscdp) { 1062 cdp_receive((uchar *)ip, len); 1063 return; 1064 } 1065 #endif 1066 1067 if ((myvlanid & VLAN_IDMASK) != VLAN_NONE) { 1068 if (vlanid == VLAN_NONE) 1069 vlanid = (mynvlanid & VLAN_IDMASK); 1070 /* not matched? */ 1071 if (vlanid != (myvlanid & VLAN_IDMASK)) 1072 return; 1073 } 1074 1075 switch (eth_proto) { 1076 1077 case PROT_ARP: 1078 ArpReceive(et, ip, len); 1079 break; 1080 1081 #ifdef CONFIG_CMD_RARP 1082 case PROT_RARP: 1083 rarp_receive(ip, len); 1084 break; 1085 #endif 1086 case PROT_IP: 1087 debug_cond(DEBUG_NET_PKT, "Got IP\n"); 1088 /* Before we start poking the header, make sure it is there */ 1089 if (len < IP_UDP_HDR_SIZE) { 1090 debug("len bad %d < %lu\n", len, 1091 (ulong)IP_UDP_HDR_SIZE); 1092 return; 1093 } 1094 /* Check the packet length */ 1095 if (len < ntohs(ip->ip_len)) { 1096 debug("len bad %d < %d\n", len, ntohs(ip->ip_len)); 1097 return; 1098 } 1099 len = ntohs(ip->ip_len); 1100 debug_cond(DEBUG_NET_PKT, "len=%d, v=%02x\n", 1101 len, ip->ip_hl_v & 0xff); 1102 1103 /* Can't deal with anything except IPv4 */ 1104 if ((ip->ip_hl_v & 0xf0) != 0x40) 1105 return; 1106 /* Can't deal with IP options (headers != 20 bytes) */ 1107 if ((ip->ip_hl_v & 0x0f) > 0x05) 1108 return; 1109 /* Check the Checksum of the header */ 1110 if (!ip_checksum_ok((uchar *)ip, IP_HDR_SIZE)) { 1111 debug("checksum bad\n"); 1112 return; 1113 } 1114 /* If it is not for us, ignore it */ 1115 dst_ip = net_read_ip(&ip->ip_dst); 1116 if (net_ip.s_addr && dst_ip.s_addr != net_ip.s_addr && 1117 dst_ip.s_addr != 0xFFFFFFFF) { 1118 #ifdef CONFIG_MCAST_TFTP 1119 if (net_mcast_addr != dst_ip) 1120 #endif 1121 return; 1122 } 1123 /* Read source IP address for later use */ 1124 src_ip = net_read_ip(&ip->ip_src); 1125 /* 1126 * The function returns the unchanged packet if it's not 1127 * a fragment, and either the complete packet or NULL if 1128 * it is a fragment (if !CONFIG_IP_DEFRAG, it returns NULL) 1129 */ 1130 ip = NetDefragment(ip, &len); 1131 if (!ip) 1132 return; 1133 /* 1134 * watch for ICMP host redirects 1135 * 1136 * There is no real handler code (yet). We just watch 1137 * for ICMP host redirect messages. In case anybody 1138 * sees these messages: please contact me 1139 * (wd@denx.de), or - even better - send me the 1140 * necessary fixes :-) 1141 * 1142 * Note: in all cases where I have seen this so far 1143 * it was a problem with the router configuration, 1144 * for instance when a router was configured in the 1145 * BOOTP reply, but the TFTP server was on the same 1146 * subnet. So this is probably a warning that your 1147 * configuration might be wrong. But I'm not really 1148 * sure if there aren't any other situations. 1149 * 1150 * Simon Glass <sjg@chromium.org>: We get an ICMP when 1151 * we send a tftp packet to a dead connection, or when 1152 * there is no server at the other end. 1153 */ 1154 if (ip->ip_p == IPPROTO_ICMP) { 1155 receive_icmp(ip, len, src_ip, et); 1156 return; 1157 } else if (ip->ip_p != IPPROTO_UDP) { /* Only UDP packets */ 1158 return; 1159 } 1160 1161 debug_cond(DEBUG_DEV_PKT, 1162 "received UDP (to=%pI4, from=%pI4, len=%d)\n", 1163 &dst_ip, &src_ip, len); 1164 1165 #ifdef CONFIG_UDP_CHECKSUM 1166 if (ip->udp_xsum != 0) { 1167 ulong xsum; 1168 ushort *sumptr; 1169 ushort sumlen; 1170 1171 xsum = ip->ip_p; 1172 xsum += (ntohs(ip->udp_len)); 1173 xsum += (ntohl(ip->ip_src.s_addr) >> 16) & 0x0000ffff; 1174 xsum += (ntohl(ip->ip_src.s_addr) >> 0) & 0x0000ffff; 1175 xsum += (ntohl(ip->ip_dst.s_addr) >> 16) & 0x0000ffff; 1176 xsum += (ntohl(ip->ip_dst.s_addr) >> 0) & 0x0000ffff; 1177 1178 sumlen = ntohs(ip->udp_len); 1179 sumptr = (ushort *) &(ip->udp_src); 1180 1181 while (sumlen > 1) { 1182 ushort sumdata; 1183 1184 sumdata = *sumptr++; 1185 xsum += ntohs(sumdata); 1186 sumlen -= 2; 1187 } 1188 if (sumlen > 0) { 1189 ushort sumdata; 1190 1191 sumdata = *(unsigned char *) sumptr; 1192 sumdata = (sumdata << 8) & 0xff00; 1193 xsum += sumdata; 1194 } 1195 while ((xsum >> 16) != 0) { 1196 xsum = (xsum & 0x0000ffff) + 1197 ((xsum >> 16) & 0x0000ffff); 1198 } 1199 if ((xsum != 0x00000000) && (xsum != 0x0000ffff)) { 1200 printf(" UDP wrong checksum %08lx %08x\n", 1201 xsum, ntohs(ip->udp_xsum)); 1202 return; 1203 } 1204 } 1205 #endif 1206 1207 1208 #if defined (CONFIG_NETCONSOLE) && !(CONFIG_SPL_BUILD) 1209 nc_input_packet((uchar *)ip + IP_UDP_HDR_SIZE, 1210 src_ip, 1211 ntohs(ip->udp_dst), 1212 ntohs(ip->udp_src), 1213 ntohs(ip->udp_len) - UDP_HDR_SIZE); 1214 #endif 1215 /* 1216 * IP header OK. Pass the packet to the current handler. 1217 */ 1218 (*udp_packet_handler)((uchar *)ip + IP_UDP_HDR_SIZE, 1219 ntohs(ip->udp_dst), 1220 src_ip, 1221 ntohs(ip->udp_src), 1222 ntohs(ip->udp_len) - UDP_HDR_SIZE); 1223 break; 1224 } 1225 } 1226 1227 1228 /**********************************************************************/ 1229 1230 static int net_check_prereq(enum proto_t protocol) 1231 { 1232 switch (protocol) { 1233 /* Fall through */ 1234 #if defined(CONFIG_CMD_PING) 1235 case PING: 1236 if (net_ping_ip.s_addr == 0) { 1237 puts("*** ERROR: ping address not given\n"); 1238 return 1; 1239 } 1240 goto common; 1241 #endif 1242 #if defined(CONFIG_CMD_SNTP) 1243 case SNTP: 1244 if (net_ntp_server.s_addr == 0) { 1245 puts("*** ERROR: NTP server address not given\n"); 1246 return 1; 1247 } 1248 goto common; 1249 #endif 1250 #if defined(CONFIG_CMD_DNS) 1251 case DNS: 1252 if (net_dns_server.s_addr == 0) { 1253 puts("*** ERROR: DNS server address not given\n"); 1254 return 1; 1255 } 1256 goto common; 1257 #endif 1258 #if defined(CONFIG_CMD_NFS) 1259 case NFS: 1260 #endif 1261 case TFTPGET: 1262 case TFTPPUT: 1263 if (net_server_ip.s_addr == 0) { 1264 puts("*** ERROR: `serverip' not set\n"); 1265 return 1; 1266 } 1267 #if defined(CONFIG_CMD_PING) || defined(CONFIG_CMD_SNTP) || \ 1268 defined(CONFIG_CMD_DNS) 1269 common: 1270 #endif 1271 /* Fall through */ 1272 1273 case NETCONS: 1274 case TFTPSRV: 1275 if (net_ip.s_addr == 0) { 1276 puts("*** ERROR: `ipaddr' not set\n"); 1277 return 1; 1278 } 1279 /* Fall through */ 1280 1281 #ifdef CONFIG_CMD_RARP 1282 case RARP: 1283 #endif 1284 case BOOTP: 1285 case CDP: 1286 case DHCP: 1287 case LINKLOCAL: 1288 if (memcmp(NetOurEther, "\0\0\0\0\0\0", 6) == 0) { 1289 int num = eth_get_dev_index(); 1290 1291 switch (num) { 1292 case -1: 1293 puts("*** ERROR: No ethernet found.\n"); 1294 return 1; 1295 case 0: 1296 puts("*** ERROR: `ethaddr' not set\n"); 1297 break; 1298 default: 1299 printf("*** ERROR: `eth%daddr' not set\n", 1300 num); 1301 break; 1302 } 1303 1304 NetStartAgain(); 1305 return 2; 1306 } 1307 /* Fall through */ 1308 default: 1309 return 0; 1310 } 1311 return 0; /* OK */ 1312 } 1313 /**********************************************************************/ 1314 1315 int 1316 NetEthHdrSize(void) 1317 { 1318 ushort myvlanid; 1319 1320 myvlanid = ntohs(NetOurVLAN); 1321 if (myvlanid == (ushort)-1) 1322 myvlanid = VLAN_NONE; 1323 1324 return ((myvlanid & VLAN_IDMASK) == VLAN_NONE) ? ETHER_HDR_SIZE : 1325 VLAN_ETHER_HDR_SIZE; 1326 } 1327 1328 int 1329 NetSetEther(uchar *xet, uchar * addr, uint prot) 1330 { 1331 struct ethernet_hdr *et = (struct ethernet_hdr *)xet; 1332 ushort myvlanid; 1333 1334 myvlanid = ntohs(NetOurVLAN); 1335 if (myvlanid == (ushort)-1) 1336 myvlanid = VLAN_NONE; 1337 1338 memcpy(et->et_dest, addr, 6); 1339 memcpy(et->et_src, NetOurEther, 6); 1340 if ((myvlanid & VLAN_IDMASK) == VLAN_NONE) { 1341 et->et_protlen = htons(prot); 1342 return ETHER_HDR_SIZE; 1343 } else { 1344 struct vlan_ethernet_hdr *vet = 1345 (struct vlan_ethernet_hdr *)xet; 1346 1347 vet->vet_vlan_type = htons(PROT_VLAN); 1348 vet->vet_tag = htons((0 << 5) | (myvlanid & VLAN_IDMASK)); 1349 vet->vet_type = htons(prot); 1350 return VLAN_ETHER_HDR_SIZE; 1351 } 1352 } 1353 1354 int net_update_ether(struct ethernet_hdr *et, uchar *addr, uint prot) 1355 { 1356 ushort protlen; 1357 1358 memcpy(et->et_dest, addr, 6); 1359 memcpy(et->et_src, NetOurEther, 6); 1360 protlen = ntohs(et->et_protlen); 1361 if (protlen == PROT_VLAN) { 1362 struct vlan_ethernet_hdr *vet = 1363 (struct vlan_ethernet_hdr *)et; 1364 vet->vet_type = htons(prot); 1365 return VLAN_ETHER_HDR_SIZE; 1366 } else if (protlen > 1514) { 1367 et->et_protlen = htons(prot); 1368 return ETHER_HDR_SIZE; 1369 } else { 1370 /* 802.2 + SNAP */ 1371 struct e802_hdr *et802 = (struct e802_hdr *)et; 1372 et802->et_prot = htons(prot); 1373 return E802_HDR_SIZE; 1374 } 1375 } 1376 1377 void net_set_ip_header(uchar *pkt, struct in_addr dest, struct in_addr source) 1378 { 1379 struct ip_udp_hdr *ip = (struct ip_udp_hdr *)pkt; 1380 1381 /* 1382 * Construct an IP header. 1383 */ 1384 /* IP_HDR_SIZE / 4 (not including UDP) */ 1385 ip->ip_hl_v = 0x45; 1386 ip->ip_tos = 0; 1387 ip->ip_len = htons(IP_HDR_SIZE); 1388 ip->ip_id = htons(NetIPID++); 1389 ip->ip_off = htons(IP_FLAGS_DFRAG); /* Don't fragment */ 1390 ip->ip_ttl = 255; 1391 ip->ip_sum = 0; 1392 /* already in network byte order */ 1393 net_copy_ip((void *)&ip->ip_src, &source); 1394 /* already in network byte order */ 1395 net_copy_ip((void *)&ip->ip_dst, &dest); 1396 } 1397 1398 void net_set_udp_header(uchar *pkt, struct in_addr dest, int dport, int sport, 1399 int len) 1400 { 1401 struct ip_udp_hdr *ip = (struct ip_udp_hdr *)pkt; 1402 1403 /* 1404 * If the data is an odd number of bytes, zero the 1405 * byte after the last byte so that the checksum 1406 * will work. 1407 */ 1408 if (len & 1) 1409 pkt[IP_UDP_HDR_SIZE + len] = 0; 1410 1411 net_set_ip_header(pkt, dest, net_ip); 1412 ip->ip_len = htons(IP_UDP_HDR_SIZE + len); 1413 ip->ip_p = IPPROTO_UDP; 1414 ip->ip_sum = compute_ip_checksum(ip, IP_HDR_SIZE); 1415 1416 ip->udp_src = htons(sport); 1417 ip->udp_dst = htons(dport); 1418 ip->udp_len = htons(UDP_HDR_SIZE + len); 1419 ip->udp_xsum = 0; 1420 } 1421 1422 void copy_filename(char *dst, const char *src, int size) 1423 { 1424 if (*src && (*src == '"')) { 1425 ++src; 1426 --size; 1427 } 1428 1429 while ((--size > 0) && *src && (*src != '"')) 1430 *dst++ = *src++; 1431 *dst = '\0'; 1432 } 1433 1434 #if defined(CONFIG_CMD_NFS) || \ 1435 defined(CONFIG_CMD_SNTP) || \ 1436 defined(CONFIG_CMD_DNS) 1437 /* 1438 * make port a little random (1024-17407) 1439 * This keeps the math somewhat trivial to compute, and seems to work with 1440 * all supported protocols/clients/servers 1441 */ 1442 unsigned int random_port(void) 1443 { 1444 return 1024 + (get_timer(0) % 0x4000); 1445 } 1446 #endif 1447 1448 void ip_to_string(struct in_addr x, char *s) 1449 { 1450 x.s_addr = ntohl(x.s_addr); 1451 sprintf(s, "%d.%d.%d.%d", 1452 (int) ((x.s_addr >> 24) & 0xff), 1453 (int) ((x.s_addr >> 16) & 0xff), 1454 (int) ((x.s_addr >> 8) & 0xff), 1455 (int) ((x.s_addr >> 0) & 0xff) 1456 ); 1457 } 1458 1459 void VLAN_to_string(ushort x, char *s) 1460 { 1461 x = ntohs(x); 1462 1463 if (x == (ushort)-1) 1464 x = VLAN_NONE; 1465 1466 if (x == VLAN_NONE) 1467 strcpy(s, "none"); 1468 else 1469 sprintf(s, "%d", x & VLAN_IDMASK); 1470 } 1471 1472 ushort string_to_VLAN(const char *s) 1473 { 1474 ushort id; 1475 1476 if (s == NULL) 1477 return htons(VLAN_NONE); 1478 1479 if (*s < '0' || *s > '9') 1480 id = VLAN_NONE; 1481 else 1482 id = (ushort)simple_strtoul(s, NULL, 10); 1483 1484 return htons(id); 1485 } 1486 1487 ushort getenv_VLAN(char *var) 1488 { 1489 return string_to_VLAN(getenv(var)); 1490 } 1491