1 /* $NetBSD: nfs_bootdhcp.c,v 1.60 2024/10/20 14:01:52 mlelstv Exp $ */ 2 3 /*- 4 * Copyright (c) 1995, 1997 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Adam Glass and Gordon W. Ross. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 /* 33 * Support for NFS diskless booting with BOOTP (RFC951, RFC1048) 34 * 35 * History: 36 * 37 * Tor Egge developed the initial version of this code based on 38 * the Sun RPC/bootparam sources nfs_boot.c and krpc_subr.c and 39 * submitted that work to NetBSD as bugreport "kern/2351" on 40 * 29 Apr 1996. 41 * 42 * Gordon Ross reorganized Tor's version into this form and 43 * integrated it into the NetBSD sources during Aug 1997. 44 */ 45 46 #include <sys/cdefs.h> 47 __KERNEL_RCSID(0, "$NetBSD: nfs_bootdhcp.c,v 1.60 2024/10/20 14:01:52 mlelstv Exp $"); 48 49 #ifdef _KERNEL_OPT 50 #include "opt_nfs_boot.h" 51 #include "opt_tftproot.h" 52 #endif 53 54 #include <sys/param.h> 55 #include <sys/systm.h> 56 #include <sys/kernel.h> 57 #include <sys/device.h> 58 #include <sys/ioctl.h> 59 #include <sys/proc.h> 60 #include <sys/mount.h> 61 #include <sys/mbuf.h> 62 #include <sys/reboot.h> 63 #include <sys/socket.h> 64 #include <sys/socketvar.h> 65 66 #include <net/if.h> 67 #include <net/if_types.h> 68 #include <net/if_arp.h> /* ARPHRD_ETHER, etc. */ 69 #include <net/if_dl.h> 70 #include <net/if_ether.h> 71 #include <net/route.h> 72 73 #include <netinet/in.h> 74 #include <netinet/if_inarp.h> 75 76 #include <nfs/rpcv2.h> 77 78 #include <nfs/nfsproto.h> 79 #include <nfs/nfs.h> 80 #include <nfs/nfsmount.h> 81 #include <nfs/nfsdiskless.h> 82 83 /* 84 * There are two implementations of NFS diskless boot. 85 * This implementation uses BOOTP (RFC951, RFC1048), and 86 * the other uses Sun RPC/bootparams (nfs_bootparam.c). 87 * 88 * This method gets everything it needs with one BOOTP 89 * request and reply. Note that this actually uses only 90 * the old BOOTP functionality subset of DHCP. It is not 91 * clear that DHCP provides any advantage over BOOTP for 92 * diskless boot. DHCP allows the server to assign an IP 93 * address without any a-priori knowledge of the client, 94 * but we require that the server has a-priori knowledge 95 * of the client so it can export our (unique) NFS root. 96 * Given that the server needs a-priori knowledge about 97 * the client anyway, it might as well assign a fixed IP 98 * address for the client and support BOOTP. 99 * 100 * On the other hand, disk-FULL clients may use DHCP, but 101 * in that case the DHCP client should be user-mode code, 102 * and has no bearing on the code below. -gwr 103 */ 104 105 /* Begin stuff from bootp.h */ 106 /* Definitions from RFC951 */ 107 #define BP_CHADDR_LEN 16 108 #define BP_SNAME_LEN 64 109 #define BP_FILE_LEN 128 110 #define BP_VEND_LEN 64 111 struct bootp { 112 u_int8_t bp_op; /* packet opcode type */ 113 u_int8_t bp_htype; /* hardware addr type */ 114 u_int8_t bp_hlen; /* hardware addr length */ 115 u_int8_t bp_hops; /* gateway hops */ 116 u_int32_t bp_xid; /* transaction ID */ 117 u_int16_t bp_secs; /* seconds since boot began */ 118 u_int16_t bp_flags; /* RFC1532 broadcast, etc. */ 119 struct in_addr bp_ciaddr; /* client IP address */ 120 struct in_addr bp_yiaddr; /* 'your' IP address */ 121 struct in_addr bp_siaddr; /* server IP address */ 122 struct in_addr bp_giaddr; /* gateway IP address */ 123 u_int8_t bp_chaddr[BP_CHADDR_LEN]; /* client hardware address */ 124 char bp_sname[BP_SNAME_LEN]; /* server host name */ 125 char bp_file[BP_FILE_LEN]; /* boot file name */ 126 u_int8_t bp_vend[BP_VEND_LEN]; /* RFC1048 options */ 127 /* 128 * Note that BOOTP packets are allowed to be longer 129 * (see RFC 1532 sect. 2.1) and common practice is to 130 * allow the option data in bp_vend to extend into the 131 * additional space provided in longer packets. 132 */ 133 }; 134 135 #define IPPORT_BOOTPS 67 136 #define IPPORT_BOOTPC 68 137 138 #define BOOTREQUEST 1 139 #define BOOTREPLY 2 140 141 /* 142 * Is this available from the sockaddr_dl somehow? 143 * Perhaps (struct arphdr)->ar_hrd = ARPHRD_ETHER? 144 * The interface has ->if_type but not the ARP fmt. 145 */ 146 #define HTYPE_ETHERNET 1 147 #define HTYPE_IEEE802 6 148 149 /* 150 * Vendor magic cookie (v_magic) for RFC1048 151 */ 152 static const u_int8_t vm_rfc1048[4] = { 99, 130, 83, 99 }; 153 154 /* 155 * Tag values used to specify what information is being supplied in 156 * the vendor (options) data area of the packet. 157 */ 158 /* RFC 1048 */ 159 #define TAG_END ((unsigned char) 255) 160 #define TAG_PAD ((unsigned char) 0) 161 #define TAG_SUBNET_MASK ((unsigned char) 1) 162 #define TAG_TIME_OFFSET ((unsigned char) 2) 163 #define TAG_GATEWAY ((unsigned char) 3) 164 #define TAG_TIME_SERVER ((unsigned char) 4) 165 #define TAG_NAME_SERVER ((unsigned char) 5) 166 #define TAG_DOMAIN_SERVER ((unsigned char) 6) 167 #define TAG_LOG_SERVER ((unsigned char) 7) 168 #define TAG_COOKIE_SERVER ((unsigned char) 8) 169 #define TAG_LPR_SERVER ((unsigned char) 9) 170 #define TAG_IMPRESS_SERVER ((unsigned char) 10) 171 #define TAG_RLP_SERVER ((unsigned char) 11) 172 #define TAG_HOST_NAME ((unsigned char) 12) 173 #define TAG_BOOT_SIZE ((unsigned char) 13) 174 /* RFC 1395 */ 175 #define TAG_DUMP_FILE ((unsigned char) 14) 176 #define TAG_DOMAIN_NAME ((unsigned char) 15) 177 #define TAG_SWAP_SERVER ((unsigned char) 16) 178 #define TAG_ROOT_PATH ((unsigned char) 17) 179 /* RFC 2132 */ 180 #define TAG_INTERFACE_MTU ((unsigned char) 26) 181 /* End of stuff from bootp.h */ 182 183 #ifdef NFS_BOOT_DHCP 184 #define TAG_REQ_ADDR ((unsigned char) 50) 185 #define TAG_LEASETIME ((unsigned char) 51) 186 #define TAG_OVERLOAD ((unsigned char) 52) 187 #define TAG_DHCP_MSGTYPE ((unsigned char) 53) 188 #define TAG_SERVERID ((unsigned char) 54) 189 #define TAG_PARAM_REQ ((unsigned char) 55) 190 #define TAG_MSG ((unsigned char) 56) 191 #define TAG_MAXSIZE ((unsigned char) 57) 192 #define TAG_T1 ((unsigned char) 58) 193 #define TAG_T2 ((unsigned char) 59) 194 #define TAG_CLASSID ((unsigned char) 60) 195 #define TAG_CLIENTID ((unsigned char) 61) 196 #endif 197 198 #ifdef NFS_BOOT_DHCP 199 #define DHCPDISCOVER 1 200 #define DHCPOFFER 2 201 #define DHCPREQUEST 3 202 #define DHCPDECLINE 4 203 #define DHCPACK 5 204 #define DHCPNAK 6 205 #define DHCPRELEASE 7 206 #endif 207 208 #define IP_MIN_MTU 576 209 210 #ifdef NFS_BOOT_DHCP 211 #define BOOTP_SIZE_MAX (sizeof(struct bootp)+312-64) 212 #else 213 /* 214 * The "extended" size is somewhat arbitrary, but is 215 * constrained by the maximum message size specified 216 * by RFC1533 (567 total). This value increases the 217 * space for options from 64 bytes to 256 bytes. 218 */ 219 #define BOOTP_SIZE_MAX (sizeof(struct bootp)+256-64) 220 #endif 221 #define BOOTP_SIZE_MIN (sizeof(struct bootp)) 222 223 /* Convenience macro */ 224 #define INTOHL(ina) ((u_int32_t)ntohl((ina).s_addr)) 225 226 static int bootpc_call (struct nfs_diskless *, struct lwp *, int *); 227 static void bootp_extract (struct bootp *, int, struct nfs_diskless *, int *); 228 229 #ifdef DEBUG_NFS_BOOT_DHCP 230 #define DPRINTF(s) printf s 231 #else 232 #define DPRINTF(s) 233 #endif 234 235 236 /* 237 * Get our boot parameters using BOOTP. 238 */ 239 int 240 nfs_bootdhcp(struct nfs_diskless *nd, struct lwp *lwp, int *flags) 241 { 242 struct ifnet *ifp = nd->nd_ifp; 243 int error; 244 245 /* 246 * Do enough of ifconfig(8) so that the chosen interface 247 * can talk to the servers. Use address zero for now. 248 */ 249 error = nfs_boot_setaddress(ifp, lwp, 250 *flags & NFS_BOOT_HAS_MYIP ? nd->nd_myip.s_addr : INADDR_ANY, 251 *flags & NFS_BOOT_HAS_MASK ? nd->nd_mask.s_addr : INADDR_ANY, 252 INADDR_BROADCAST); 253 if (error) { 254 printf("nfs_boot: set ifaddr zero, error=%d\n", error); 255 return (error); 256 } 257 258 /* This function call does the real send/recv work. */ 259 error = bootpc_call(nd, lwp, flags); 260 261 /* Get rid of the temporary (zero) IP address. */ 262 (void) nfs_boot_deladdress(ifp, lwp, INADDR_ANY); 263 264 /* NOW we can test the error from bootpc_call. */ 265 if (error) 266 goto out; 267 268 /* 269 * Do ifconfig with our real IP address and mask. 270 */ 271 error = nfs_boot_setaddress(ifp, lwp, nd->nd_myip.s_addr, 272 nd->nd_mask.s_addr, INADDR_ANY); 273 if (error) { 274 printf("nfs_boot: set ifaddr real, error=%d\n", error); 275 goto out; 276 } 277 278 if ((*flags & NFS_BOOT_ALLINFO) != NFS_BOOT_ALLINFO) { 279 printf("nfs_boot: missing options (need IP, netmask, " 280 "gateway, next-server, root-path)\n"); 281 return EADDRNOTAVAIL; 282 } 283 284 out: 285 if (error) { 286 (void) nfs_boot_ifupdown(ifp, lwp, 0); 287 nfs_boot_flushrt(ifp); 288 } 289 return (error); 290 } 291 292 struct bootpcontext { 293 int xid; 294 const u_char *haddr; 295 u_char halen; 296 struct bootp *replybuf; 297 int replylen; 298 #ifdef NFS_BOOT_DHCP 299 char expected_dhcpmsgtype, dhcp_ok; 300 struct in_addr dhcp_serverip; 301 #endif 302 }; 303 304 static int bootpset (struct mbuf*, void*, int); 305 static int bootpcheck (struct mbuf**, void*); 306 307 static int 308 bootpset(struct mbuf *m, void *context, int waited) 309 { 310 struct bootp *bootp; 311 312 /* we know it's contiguous (in 1 mbuf cluster) */ 313 bootp = mtod(m, struct bootp*); 314 315 bootp->bp_secs = htons(waited); 316 317 return (0); 318 } 319 320 static int 321 bootpcheck(struct mbuf **mp, void *context) 322 { 323 struct bootp *bootp; 324 struct bootpcontext *bpc = context; 325 struct mbuf *m = *mp; 326 u_int tag, len; 327 u_char *p, *limit; 328 329 /* 330 * Is this a valid reply? 331 */ 332 if (m->m_pkthdr.len < BOOTP_SIZE_MIN) { 333 DPRINTF(("bootpcheck: short packet %d < %zu\n", 334 m->m_pkthdr.len, BOOTP_SIZE_MIN)); 335 return (-1); 336 } 337 if (m->m_pkthdr.len > BOOTP_SIZE_MAX) { 338 DPRINTF(("Bootpcheck: long packet %d > %zu\n", 339 m->m_pkthdr.len, BOOTP_SIZE_MAX)); 340 return (-1); 341 } 342 343 /* 344 * don't make first checks more expensive than necessary 345 */ 346 if (m->m_len < offsetof(struct bootp, bp_sname)) { 347 m = *mp = m_pullup(m, offsetof(struct bootp, bp_sname)); 348 if (m == NULL) { 349 DPRINTF(("bootpcheck: m_pullup failed\n")); 350 return (-1); 351 } 352 } 353 bootp = mtod(m, struct bootp*); 354 355 if (bootp->bp_op != BOOTREPLY) { 356 DPRINTF(("bootpcheck: op %d is not reply\n", bootp->bp_op)); 357 return (-1); 358 } 359 if (bootp->bp_hlen != bpc->halen) { 360 DPRINTF(("bootpcheck: hlen %d != %d\n", bootp->bp_hlen, 361 bpc->halen)); 362 return (-1); 363 } 364 if (memcmp(bootp->bp_chaddr, bpc->haddr, bpc->halen)) { 365 #ifdef DEBUG_NFS_BOOT_DHCP 366 char *bp_chaddr, *haddr; 367 368 bp_chaddr = malloc(3 * bpc->halen, M_TEMP, M_WAITOK); 369 haddr = malloc(3 * bpc->halen, M_TEMP, M_WAITOK); 370 371 DPRINTF(("bootpcheck: incorrect hwaddr %s != %s\n", 372 ether_snprintf(bp_chaddr, 3 * bpc->halen, 373 bootp->bp_chaddr), 374 ether_snprintf(haddr, 3 * bpc->halen, bpc->haddr))); 375 376 free(bp_chaddr, M_TEMP); 377 free(haddr, M_TEMP); 378 #endif 379 return (-1); 380 } 381 if (bootp->bp_xid != bpc->xid) { 382 DPRINTF(("bootpcheck: xid %d != %d\n", bootp->bp_xid, 383 bpc->xid)); 384 return (-1); 385 } 386 387 /* 388 * OK, it's worth to look deeper. 389 * We copy the mbuf into a flat buffer here because 390 * m_pullup() is a bit limited for this purpose 391 * (doesn't allocate a cluster if necessary). 392 */ 393 bpc->replylen = m->m_pkthdr.len; 394 m_copydata(m, 0, bpc->replylen, (void *)bpc->replybuf); 395 bootp = bpc->replybuf; 396 397 /* 398 * Check if the IP address we get looks correct. 399 * (DHCP servers can send junk to unknown clients.) 400 * XXX more checks might be needed 401 */ 402 if (bootp->bp_yiaddr.s_addr == INADDR_ANY || 403 bootp->bp_yiaddr.s_addr == INADDR_BROADCAST) { 404 printf("nfs_boot: wrong IP addr %s", 405 inet_ntoa(bootp->bp_yiaddr)); 406 goto warn; 407 } 408 409 /* 410 * Check the vendor data. 411 */ 412 if (memcmp(bootp->bp_vend, vm_rfc1048, 4)) { 413 printf("nfs_boot: reply missing options"); 414 goto warn; 415 } 416 p = &bootp->bp_vend[4]; 417 limit = ((u_char*)bootp) + bpc->replylen; 418 while (p < limit) { 419 tag = *p++; 420 if (tag == TAG_END) 421 break; 422 if (tag == TAG_PAD) 423 continue; 424 len = *p++; 425 if ((p + len) > limit) { 426 printf("nfs_boot: option %d too long", tag); 427 goto warn; 428 } 429 switch (tag) { 430 #ifdef NFS_BOOT_DHCP 431 case TAG_DHCP_MSGTYPE: 432 if (*p != bpc->expected_dhcpmsgtype) 433 return (-1); 434 bpc->dhcp_ok = 1; 435 break; 436 case TAG_SERVERID: 437 memcpy(&bpc->dhcp_serverip.s_addr, p, 438 sizeof(bpc->dhcp_serverip.s_addr)); 439 break; 440 #endif 441 default: 442 break; 443 } 444 p += len; 445 } 446 return (0); 447 448 warn: 449 printf(" (bad reply from %s)\n", inet_ntoa(bootp->bp_siaddr)); 450 return (-1); 451 } 452 453 static void 454 bootp_addvend(u_char *area) 455 { 456 #ifdef NFS_BOOT_DHCP 457 char vci[64]; 458 int vcilen; 459 460 *area++ = TAG_PARAM_REQ; 461 *area++ = 7; 462 *area++ = TAG_SUBNET_MASK; 463 *area++ = TAG_GATEWAY; 464 *area++ = TAG_HOST_NAME; 465 *area++ = TAG_DOMAIN_NAME; 466 *area++ = TAG_ROOT_PATH; 467 *area++ = TAG_SWAP_SERVER; 468 *area++ = TAG_INTERFACE_MTU; 469 470 /* Insert a NetBSD Vendor Class Identifier option. */ 471 snprintf(vci, sizeof(vci), "%s:%s:kernel:%s", ostype, MACHINE, 472 osrelease); 473 vcilen = strlen(vci); 474 *area++ = TAG_CLASSID; 475 *area++ = vcilen; 476 (void)memcpy(area, vci, vcilen); 477 area += vcilen; 478 #endif 479 *area = TAG_END; 480 } 481 482 static int 483 bootpc_call(struct nfs_diskless *nd, struct lwp *lwp, int *flags) 484 { 485 struct socket *so; 486 struct ifnet *ifp = nd->nd_ifp; 487 static u_int32_t xid = ~0xFF; 488 struct bootp *bootp; /* request */ 489 struct mbuf *m; 490 struct sockaddr_in sin; 491 int error; 492 const u_char *haddr; 493 u_char hafmt, halen; 494 struct bootpcontext bpc; 495 unsigned int index; 496 497 error = socreate(AF_INET, &so, SOCK_DGRAM, 0, lwp, NULL); 498 if (error) { 499 printf("bootp: socreate, error=%d\n", error); 500 return (error); 501 } 502 503 /* 504 * Initialize to NULL anything that will hold an allocation, 505 * and free each at the end if not null. 506 */ 507 bpc.replybuf = NULL; 508 m = NULL; 509 510 /* Record our H/W (Ethernet) address. */ 511 { const struct sockaddr_dl *sdl = ifp->if_sadl; 512 switch (sdl->sdl_type) { 513 case IFT_ISO88025: 514 hafmt = HTYPE_IEEE802; 515 break; 516 case IFT_ETHER: 517 case IFT_FDDI: 518 hafmt = HTYPE_ETHERNET; 519 break; 520 default: 521 printf("bootp: unsupported interface type %d\n", 522 sdl->sdl_type); 523 error = EINVAL; 524 goto out; 525 } 526 halen = sdl->sdl_alen; 527 haddr = (const unsigned char *)CLLADDR(sdl); 528 } 529 530 /* 531 * Skip the route table when sending on this socket. 532 * If this is not done, ip_output finds the loopback 533 * interface (why?) and then fails because broadcast 534 * is not supported on that interface... 535 */ 536 { int32_t opt; 537 538 opt = 1; 539 error = so_setsockopt(NULL, so, SOL_SOCKET, SO_DONTROUTE, &opt, 540 sizeof(opt)); 541 } 542 if (error) { 543 DPRINTF(("bootpc_call: SO_DONTROUTE failed %d\n", error)); 544 goto out; 545 } 546 547 /* Enable broadcast. */ 548 if ((error = nfs_boot_enbroadcast(so))) { 549 DPRINTF(("bootpc_call: SO_BROADCAST failed %d\n", error)); 550 goto out; 551 } 552 553 /* 554 * Set some TTL so we can boot through routers. 555 * Real BOOTP forwarding agents don't need this; they obey "bp_hops" 556 * and set "bp_giaddr", thus rewrite the packet anyway. 557 * The "helper-address" feature of some popular router vendor seems 558 * to do simple IP forwarding and drops packets with (ip_ttl == 1). 559 */ 560 { u_char opt; 561 562 opt = 7; 563 error = so_setsockopt(NULL, so, IPPROTO_IP, IP_MULTICAST_TTL, 564 &opt, sizeof(opt)); 565 } 566 if (error) { 567 DPRINTF(("bootpc_call: IP_MULTICAST_TTL failed %d\n", error)); 568 goto out; 569 } 570 571 /* Set the receive timeout for the socket. */ 572 if ((error = nfs_boot_setrecvtimo(so))) { 573 DPRINTF(("bootpc_call: SO_RCVTIMEO failed %d\n", error)); 574 goto out; 575 } 576 577 /* 578 * Bind the local endpoint to a bootp client port. 579 */ 580 if ((error = nfs_boot_sobind_ipport(so, IPPORT_BOOTPC, lwp))) { 581 DPRINTF(("bootpc_call: bind failed %d\n", error)); 582 goto out; 583 } 584 585 /* 586 * Setup socket address for the server. 587 */ 588 sin.sin_len = sizeof(sin); 589 sin.sin_family = AF_INET; 590 sin.sin_addr.s_addr = INADDR_BROADCAST; 591 sin.sin_port = htons(IPPORT_BOOTPS); 592 593 /* 594 * Allocate buffer used for request 595 */ 596 m = m_gethdr(M_WAIT, MT_DATA); 597 MCLAIM(m, &nfs_mowner); 598 m_clget(m, M_WAIT); 599 bootp = mtod(m, struct bootp*); 600 m->m_pkthdr.len = m->m_len = BOOTP_SIZE_MAX; 601 m_reset_rcvif(m); 602 603 /* 604 * Build the BOOTP request message. 605 * Note: xid is host order! (opaque to server) 606 */ 607 memset((void *)bootp, 0, BOOTP_SIZE_MAX); 608 bootp->bp_op = BOOTREQUEST; 609 bootp->bp_htype = hafmt; 610 bootp->bp_hlen = halen; /* Hardware address length */ 611 bootp->bp_xid = ++xid; 612 memcpy(bootp->bp_chaddr, haddr, halen); 613 #ifdef NFS_BOOT_BOOTP_REQFILE 614 strncpy(bootp->bp_file, NFS_BOOT_BOOTP_REQFILE, sizeof(bootp->bp_file)); 615 #endif 616 /* Fill-in the vendor data. */ 617 memcpy(bootp->bp_vend, vm_rfc1048, 4); 618 index = 4; 619 #ifdef NFS_BOOT_DHCP 620 bootp->bp_vend[index++] = TAG_DHCP_MSGTYPE; 621 bootp->bp_vend[index++] = 1; 622 bootp->bp_vend[index++] = DHCPDISCOVER; 623 #endif 624 bootp_addvend(&bootp->bp_vend[index]); 625 626 bpc.xid = xid; 627 bpc.haddr = haddr; 628 bpc.halen = halen; 629 bpc.replybuf = malloc(BOOTP_SIZE_MAX, M_DEVBUF, M_WAITOK); 630 if (bpc.replybuf == NULL) 631 panic("nfs_boot: malloc reply buf"); 632 #ifdef NFS_BOOT_DHCP 633 bpc.expected_dhcpmsgtype = DHCPOFFER; 634 bpc.dhcp_ok = 0; 635 #endif 636 637 error = nfs_boot_sendrecv(so, &sin, bootpset, m, 638 bootpcheck, NULL, NULL, &bpc, lwp); 639 if (error) 640 goto out; 641 642 #ifdef NFS_BOOT_DHCP 643 if (bpc.dhcp_ok) { 644 u_int32_t leasetime; 645 index = 6; 646 bootp->bp_vend[index++] = DHCPREQUEST; 647 bootp->bp_vend[index++] = TAG_REQ_ADDR; 648 bootp->bp_vend[index++] = 4; 649 memcpy(&bootp->bp_vend[index], &bpc.replybuf->bp_yiaddr, 4); 650 index += 4; 651 bootp->bp_vend[index++] = TAG_SERVERID; 652 bootp->bp_vend[index++] = 4; 653 memcpy(&bootp->bp_vend[index], &bpc.dhcp_serverip.s_addr, 4); 654 index += 4; 655 bootp->bp_vend[index++] = TAG_LEASETIME; 656 bootp->bp_vend[index++] = 4; 657 leasetime = htonl(300); 658 memcpy(&bootp->bp_vend[index], &leasetime, 4); 659 index += 4; 660 bootp_addvend(&bootp->bp_vend[index]); 661 662 bpc.expected_dhcpmsgtype = DHCPACK; 663 664 error = nfs_boot_sendrecv(so, &sin, bootpset, m, 665 bootpcheck, NULL, NULL, &bpc, lwp); 666 if (error) 667 goto out; 668 } 669 #endif 670 671 /* 672 * bootpcheck() has copied the receive mbuf into 673 * the buffer at bpc.replybuf. 674 */ 675 #ifdef NFS_BOOT_DHCP 676 printf("nfs_boot: %s next-server: %s\n", 677 (bpc.dhcp_ok ? "DHCP" : "BOOTP"), 678 #else 679 printf("nfs_boot: BOOTP next-server: %s\n", 680 #endif 681 inet_ntoa(bpc.replybuf->bp_siaddr)); 682 683 bootp_extract(bpc.replybuf, bpc.replylen, nd, flags); 684 685 out: 686 if (bpc.replybuf) 687 free(bpc.replybuf, M_DEVBUF); 688 m_freem(m); 689 soclose(so); 690 return (error); 691 } 692 693 static void 694 bootp_extract(struct bootp *bootp, int replylen, 695 struct nfs_diskless *nd, int *flags) 696 { 697 struct sockaddr_in *sin; 698 struct in_addr netmask; 699 struct in_addr gateway; 700 struct in_addr rootserver; 701 char *myname; /* my hostname */ 702 char *mydomain; /* my domainname */ 703 char *rootpath; 704 uint16_t myinterfacemtu; 705 int mynamelen; 706 int mydomainlen; 707 int rootpathlen; 708 int overloaded; 709 u_int tag, len; 710 u_char *p, *limit; 711 712 /* Default these to "unspecified". */ 713 netmask.s_addr = 0; 714 gateway.s_addr = 0; 715 mydomain = myname = rootpath = NULL; 716 mydomainlen = mynamelen = rootpathlen = 0; 717 718 /* default root server to bootp next-server */ 719 rootserver = bootp->bp_siaddr; 720 /* assume that server name field is not overloaded by default */ 721 overloaded = 0; 722 /* MTU can't be less than IP_MIN_MTU, set to 0 to indicate unset */ 723 myinterfacemtu = 0; 724 725 p = &bootp->bp_vend[4]; 726 limit = ((u_char*)bootp) + replylen; 727 while (p < limit) { 728 tag = *p++; 729 if (tag == TAG_END) 730 break; 731 if (tag == TAG_PAD) 732 continue; 733 len = *p++; 734 #if 0 /* already done in bootpcheck() */ 735 if ((p + len) > limit) { 736 printf("nfs_boot: option %d too long\n", tag); 737 break; 738 } 739 #endif 740 switch (tag) { 741 case TAG_SUBNET_MASK: 742 if (len < 4) { 743 printf("nfs_boot: subnet mask < 4 bytes\n"); 744 break; 745 } 746 memcpy(&netmask, p, 4); 747 break; 748 case TAG_GATEWAY: 749 /* Routers */ 750 if (len < 4) { 751 printf("nfs_boot: routers < 4 bytes\n"); 752 break; 753 } 754 memcpy(&gateway, p, 4); 755 break; 756 case TAG_HOST_NAME: 757 if (len >= sizeof(hostname)) { 758 printf("nfs_boot: host name >= %lu bytes\n", 759 (u_long)sizeof(hostname)); 760 break; 761 } 762 myname = p; 763 mynamelen = len; 764 break; 765 case TAG_DOMAIN_NAME: 766 if (len >= sizeof(domainname)) { 767 printf("nfs_boot: domain name >= %lu bytes\n", 768 (u_long)sizeof(domainname)); 769 break; 770 } 771 mydomain = p; 772 mydomainlen = len; 773 break; 774 case TAG_ROOT_PATH: 775 /* Leave some room for the server name. */ 776 if (len >= (MNAMELEN-10)) { 777 printf("nfs_boot: rootpath >= %d bytes\n", 778 (MNAMELEN-10)); 779 break; 780 } 781 rootpath = p; 782 rootpathlen = len; 783 break; 784 case TAG_INTERFACE_MTU: 785 if (len != 2) { 786 printf("nfs_boot: interface-mtu len != 2 (%d)", 787 len); 788 break; 789 } 790 memcpy(&myinterfacemtu, p, 2); 791 myinterfacemtu = ntohs(myinterfacemtu); 792 break; 793 case TAG_SWAP_SERVER: 794 /* override NFS server address */ 795 if (len < 4) { 796 printf("nfs_boot: swap server < 4 bytes\n"); 797 break; 798 } 799 memcpy(&rootserver, p, 4); 800 break; 801 #ifdef NFS_BOOT_DHCP 802 case TAG_OVERLOAD: 803 if (len > 0 && ((*p & 0x02) != 0)) 804 /* 805 * The server name field in the dhcp packet 806 * is overloaded and we can't find server 807 * name there. 808 */ 809 overloaded = 1; 810 break; 811 #endif 812 default: 813 break; 814 } 815 p += len; 816 } 817 818 /* 819 * Store and print network config info. 820 */ 821 if (myname) { 822 myname[mynamelen] = '\0'; 823 strncpy(hostname, myname, sizeof(hostname)); 824 hostnamelen = mynamelen; 825 printf("nfs_boot: my_name=%s\n", hostname); 826 } 827 if (mydomain) { 828 mydomain[mydomainlen] = '\0'; 829 strncpy(domainname, mydomain, sizeof(domainname)); 830 domainnamelen = mydomainlen; 831 printf("nfs_boot: my_domain=%s\n", domainname); 832 } 833 if (!(*flags & NFS_BOOT_HAS_MYIP)) { 834 nd->nd_myip = bootp->bp_yiaddr; 835 printf("nfs_boot: my_addr=%s\n", inet_ntoa(nd->nd_myip)); 836 *flags |= NFS_BOOT_HAS_MYIP; 837 } 838 if (!(*flags & NFS_BOOT_HAS_MASK)) { 839 nd->nd_mask = netmask; 840 printf("nfs_boot: my_mask=%s\n", inet_ntoa(nd->nd_mask)); 841 *flags |= NFS_BOOT_HAS_MASK; 842 } 843 if (!(*flags & NFS_BOOT_HAS_GWIP)) { 844 nd->nd_gwip = gateway; 845 printf("nfs_boot: gateway=%s\n", inet_ntoa(nd->nd_gwip)); 846 *flags |= NFS_BOOT_HAS_GWIP; 847 } 848 if (myinterfacemtu >= IP_MIN_MTU) { 849 nd->nd_mtu = myinterfacemtu; 850 printf("nfs_boot: mtu=%d\n", nd->nd_mtu); 851 } 852 853 /* 854 * Store the information about our NFS root mount. 855 * The caller will print it, so be silent here. 856 */ 857 do { 858 struct nfs_dlmount *ndm = &nd->nd_root; 859 860 861 if (!(*flags & NFS_BOOT_HAS_SERVADDR)) { 862 /* Server IP address. */ 863 sin = (struct sockaddr_in *) &ndm->ndm_saddr; 864 memset((void *)sin, 0, sizeof(*sin)); 865 sin->sin_len = sizeof(*sin); 866 sin->sin_family = AF_INET; 867 sin->sin_addr = rootserver; 868 *flags |= NFS_BOOT_HAS_SERVADDR; 869 } 870 871 if (!(*flags & NFS_BOOT_HAS_SERVER)) { 872 /* Server name. */ 873 if (!overloaded && bootp->bp_sname[0] != 0 && 874 !memcmp(&rootserver, &bootp->bp_siaddr, 875 sizeof(struct in_addr))) 876 { 877 /* standard root server, we have the name */ 878 strncpy(ndm->ndm_host, bootp->bp_sname, 879 BP_SNAME_LEN-1); 880 *flags |= NFS_BOOT_HAS_SERVER; 881 } else { 882 /* Show the server IP address numerically. */ 883 strncpy(ndm->ndm_host, inet_ntoa(rootserver), 884 BP_SNAME_LEN-1); 885 *flags |= NFS_BOOT_HAS_SERVER; 886 } 887 } 888 889 if (!(*flags & NFS_BOOT_HAS_ROOTPATH)) { 890 len = strlen(ndm->ndm_host); 891 if (rootpath && 892 len + 1 + rootpathlen + 1 <= sizeof(ndm->ndm_host)) 893 { 894 ndm->ndm_host[len++] = ':'; 895 strncpy(ndm->ndm_host + len, 896 rootpath, rootpathlen); 897 ndm->ndm_host[len + rootpathlen] = '\0'; 898 *flags |= NFS_BOOT_HAS_ROOTPATH; 899 } /* else: upper layer will handle error */ 900 } 901 } while(0); 902 903 #ifdef TFTPROOT 904 #if BP_FILE_LEN > MNAMELEN 905 #define BOOTFILELEN MNAMELEN 906 #else 907 #define BOOTFILELEN BP_FILE_LEN 908 #endif 909 strncpy(nd->nd_bootfile, bootp->bp_file, BOOTFILELEN); 910 nd->nd_bootfile[BOOTFILELEN - 1] = '\0'; 911 #undef BOOTFILELEN 912 #endif /* TFTPROOT */ 913 } 914
Indexes created Sat Sep 20 22:09:52 GMT 2025