![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to nfs_boot.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / nfs|
Return to nfs_boot.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / nfs |
1.1 ! root 1: /* ! 2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights ! 7: * Reserved. This file contains Original Code and/or Modifications of ! 8: * Original Code as defined in and that are subject to the Apple Public ! 9: * Source License Version 1.1 (the "License"). You may not use this file ! 10: * except in compliance with the License. Please obtain a copy of the ! 11: * License at http://www.apple.com/publicsource and read it before using ! 12: * this file. ! 13: * ! 14: * The Original Code and all software distributed under the License are ! 15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 19: * License for the specific language governing rights and limitations ! 20: * under the License. ! 21: * ! 22: * @APPLE_LICENSE_HEADER_END@ ! 23: */ ! 24: ! 25: /* Copyright (c) 1995, 1997 NeXT Computer, Inc. All Rights Reserved */ ! 26: /* ! 27: * Copyright (c) 1994 Adam Glass, Gordon Ross ! 28: * All rights reserved. ! 29: * ! 30: * The NEXTSTEP Software License Agreement specifies the terms ! 31: * and conditions for redistribution. ! 32: * ! 33: * History: ! 34: * ! 35: * 14-March-97 Dieter Siegmund ([email protected]) ! 36: * Use BOOTP instead of RARP to get the IP address at boot time ! 37: * ! 38: * 23-May-97 Umesh Vaishampayan ([email protected]) ! 39: * Added the ability to mount "/private" separately. ! 40: * ! 41: * 30-May-97 Dieter Siegmund ([email protected]) ! 42: * - Clear out the ireq structure before using it to prevent ! 43: * our sending using a bogus source IP address, we should use ! 44: * an IP address of all zeroes ! 45: * - Right after BOOTP, get the correct netmask using AUTONETMASK ! 46: * 18-Jul-97 Dieter Siegmund ([email protected]) ! 47: * - we can't restrict the netmask until we have a default route, ! 48: * removed AUTONETMASK call (ifdef'd out) ! 49: * 5-Aug-97 Dieter Siegmund ([email protected]) ! 50: * - use the default route from the bpwhoami call, enabled autonetmask ! 51: * again ! 52: */ ! 53: ! 54: #include <sys/param.h> ! 55: #include <sys/systm.h> ! 56: #include <sys/kernel.h> ! 57: #include <sys/conf.h> ! 58: #include <sys/ioctl.h> ! 59: #include <sys/proc.h> ! 60: #include <sys/mount.h> ! 61: #include <sys/mbuf.h> ! 62: #include <sys/socket.h> ! 63: #include <sys/reboot.h> ! 64: ! 65: #include <net/if.h> ! 66: #include <net/route.h> ! 67: ! 68: #include <netinet/in.h> ! 69: #include <netinet/if_ether.h> ! 70: ! 71: #include <nfs/rpcv2.h> ! 72: #include <nfs/nfsproto.h> ! 73: #include <nfs/nfs.h> ! 74: #include <nfs/nfsdiskless.h> ! 75: #include <nfs/krpc.h> ! 76: ! 77: #include "ether.h" ! 78: ! 79: #if NETHER == 0 ! 80: ! 81: int nfs_boot_init(nd, procp) ! 82: struct nfs_diskless *nd; ! 83: struct proc *procp; ! 84: { ! 85: panic("nfs_boot_init: no ether"); ! 86: } ! 87: ! 88: #else /* NETHER */ ! 89: ! 90: /* ! 91: * Support for NFS diskless booting, specifically getting information ! 92: * about where to boot from, what pathnames, etc. ! 93: * ! 94: * This implememtation uses RARP and the bootparam RPC. ! 95: * We are forced to implement RPC anyway (to get file handles) ! 96: * so we might as well take advantage of it for bootparam too. ! 97: * ! 98: * The diskless boot sequence goes as follows: ! 99: * (1) Use RARP to get our interface address ! 100: * (2) Use RPC/bootparam/whoami to get our hostname, ! 101: * our IP address, and the server's IP address. ! 102: * (3) Use RPC/bootparam/getfile to get the root path ! 103: * (4) Use RPC/mountd to get the root file handle ! 104: * (5) Use RPC/bootparam/getfile to get the swap path ! 105: * (6) Use RPC/mountd to get the swap file handle ! 106: * ! 107: * (This happens to be the way Sun does it too.) ! 108: */ ! 109: ! 110: /* bootparam RPC */ ! 111: static int bp_whoami __P((struct sockaddr_in *bpsin, ! 112: struct in_addr *my_ip, struct in_addr *gw_ip)); ! 113: static int bp_getfile __P((struct sockaddr_in *bpsin, char *key, ! 114: struct sockaddr_in *mdsin, char *servname, char *path)); ! 115: ! 116: /* mountd RPC */ ! 117: static int md_mount __P((struct sockaddr_in *mdsin, char *path, ! 118: u_char *fh)); ! 119: ! 120: /* other helpers */ ! 121: static void get_path_and_handle __P((struct sockaddr_in *bpsin, ! 122: char *key, struct nfs_dlmount *ndmntp)); ! 123: ! 124: char *nfsbootdevname; ! 125: ! 126: /* ! 127: * Called with an empty nfs_diskless struct to be filled in. ! 128: */ ! 129: int ! 130: nfs_boot_init(nd, procp) ! 131: struct nfs_diskless *nd; ! 132: struct proc *procp; ! 133: { ! 134: struct ifreq ireq; ! 135: struct in_addr my_ip, gw_ip; ! 136: struct sockaddr_in bp_sin; ! 137: struct sockaddr_in *sin; ! 138: struct ifnet *ifp; ! 139: struct socket *so; ! 140: int error; ! 141: ! 142: /* clear out the request structure */ ! 143: bzero(&ireq, sizeof(ireq)); ! 144: ! 145: /* ! 146: * Find an interface, rarp for its ip address, stuff it, the ! 147: * implied broadcast addr, and netmask into a nfs_diskless struct. ! 148: * ! 149: * This was moved here from nfs_vfsops.c because this procedure ! 150: * would be quite different if someone decides to write (i.e.) a ! 151: * BOOTP version of this file (might not use RARP, etc.) ! 152: */ ! 153: ! 154: /* ! 155: * Find a network interface. ! 156: */ ! 157: if (nfsbootdevname) ! 158: ifp = ifunit(nfsbootdevname); ! 159: else ! 160: for (ifp = ifnet; ifp; ifp = ifp->if_next) ! 161: if ((ifp->if_flags & ! 162: (IFF_LOOPBACK|IFF_POINTOPOINT)) == 0) ! 163: break; ! 164: if (ifp == NULL) ! 165: panic("nfs_boot: no suitable interface"); ! 166: sprintf(ireq.ifr_name, "%s%d", ifp->if_name, ifp->if_unit); ! 167: printf("nfs_boot: using network interface '%s'\n", ireq.ifr_name); ! 168: ! 169: /* ! 170: * Bring up the interface. ! 171: */ ! 172: if ((error = socreate(AF_INET, &so, SOCK_DGRAM, 0)) != 0) ! 173: panic("nfs_boot: socreate, error=%d", error); ! 174: ireq.ifr_flags = IFF_UP; ! 175: error = ifioctl(so, SIOCSIFFLAGS, (caddr_t)&ireq, procp); ! 176: if (error) ! 177: panic("nfs_boot: SIFFLAGS, error=%d", error); ! 178: ! 179: #if NeXT ! 180: /* ! 181: * Do BOOTP to get the interface address ! 182: */ ! 183: { ! 184: int message = 0; ! 185: ! 186: ireq.ifr_addr.sa_family = AF_INET; ! 187: while ((error = ifioctl(so, SIOCAUTOADDR, (caddr_t)&ireq, procp))) { ! 188: if (error == ETIMEDOUT) { ! 189: if (!message) { ! 190: printf("nfs_boot: BOOTP timed out, still trying...\n"); ! 191: message++; ! 192: } ! 193: } ! 194: else { ! 195: printf("nfs_boot: autoaddr failed, error = %d\n", error); ! 196: panic("nfs_boot: SIOCAUTOADDR failed"); ! 197: } ! 198: } ! 199: ! 200: sin = (struct sockaddr_in *)&(ireq.ifr_addr); ! 201: my_ip = sin->sin_addr; ! 202: } ! 203: printf("nfs_boot: client_addr=0x%x\n", ntohl(my_ip.s_addr)); ! 204: ! 205: /* ! 206: * get the netmask ! 207: * XXX - if BOOTP returns a netmask, we should use that instead ! 208: * of icmp (DWS) ! 209: */ ! 210: if ((error = ifioctl(so, SIOCAUTONETMASK, (caddr_t)&ireq, procp))) { ! 211: printf("nfs_boot: autonetmask failed, error = %d\n", error); ! 212: } ! 213: ! 214: #else NeXT ! 215: /* ! 216: * Do RARP for the interface address. ! 217: */ ! 218: if ((error = revarpwhoami(&my_ip, ifp)) != 0) ! 219: panic("revarp failed, error=%d", error); ! 220: printf("nfs_boot: client_addr=0x%x\n", ntohl(my_ip.s_addr)); ! 221: ! 222: /* ! 223: * Do enough of ifconfig(8) so that the chosen interface ! 224: * can talk to the servers. (just set the address) ! 225: */ ! 226: sin = (struct sockaddr_in *)&ireq.ifr_addr; ! 227: bzero((caddr_t)sin, sizeof(*sin)); ! 228: sin->sin_len = sizeof(*sin); ! 229: sin->sin_family = AF_INET; ! 230: sin->sin_addr.s_addr = my_ip.s_addr; ! 231: error = ifioctl(so, SIOCSIFADDR, (caddr_t)&ireq, procp); ! 232: if (error) ! 233: panic("nfs_boot: set if addr, error=%d", error); ! 234: #endif NeXT ! 235: ! 236: soclose(so); ! 237: ! 238: /* ! 239: * Get client name and gateway address. ! 240: * RPC: bootparam/whoami ! 241: * Use the old broadcast address for the WHOAMI ! 242: * call because we do not yet know our netmask. ! 243: * The server address returned by the WHOAMI call ! 244: * is used for all subsequent booptaram RPCs. ! 245: */ ! 246: bzero((caddr_t)&bp_sin, sizeof(bp_sin)); ! 247: bp_sin.sin_len = sizeof(bp_sin); ! 248: bp_sin.sin_family = AF_INET; ! 249: bp_sin.sin_addr.s_addr = INADDR_BROADCAST; ! 250: hostnamelen = MAXHOSTNAMELEN; ! 251: ! 252: /* this returns gateway IP address */ ! 253: error = bp_whoami(&bp_sin, &my_ip, &gw_ip); ! 254: if (error) { ! 255: printf("nfs_boot: bootparam whoami, error=%d", error); ! 256: panic("nfs_boot: bootparam whoami\n"); ! 257: } ! 258: printf("nfs_boot: server_addr=0x%x\n", ! 259: ntohl(bp_sin.sin_addr.s_addr)); ! 260: printf("nfs_boot: hostname=%s\n", hostname); ! 261: #define NFS_BOOT_GATEWAY 1 ! 262: #ifdef NFS_BOOT_GATEWAY ! 263: /* ! 264: * XXX - This code is conditionally compiled only because ! 265: * many bootparam servers (in particular, SunOS 4.1.3) ! 266: * always set the gateway address to their own address. ! 267: * The bootparam server is not necessarily the gateway. ! 268: * We could just believe the server, and at worst you would ! 269: * need to delete the incorrect default route before adding ! 270: * the correct one, but for simplicity, ignore the gateway. ! 271: * If your server is OK, you can turn on this option. ! 272: * ! 273: * If the gateway address is set, add a default route. ! 274: * (The mountd RPCs may go across a gateway.) ! 275: */ ! 276: if (gw_ip.s_addr) { ! 277: struct sockaddr dst, gw, mask; ! 278: /* Destination: (default) */ ! 279: bzero((caddr_t)&dst, sizeof(dst)); ! 280: dst.sa_len = sizeof(dst); ! 281: dst.sa_family = AF_INET; ! 282: /* Gateway: */ ! 283: bzero((caddr_t)&gw, sizeof(gw)); ! 284: sin = (struct sockaddr_in *)&gw; ! 285: sin->sin_len = sizeof(gw); ! 286: sin->sin_family = AF_INET; ! 287: sin->sin_addr.s_addr = gw_ip.s_addr; ! 288: /* Mask: (zero length) */ ! 289: bzero(&mask, sizeof(mask)); ! 290: ! 291: printf("nfs_boot: gateway=0x%x\n", ntohl(gw_ip.s_addr)); ! 292: /* add, dest, gw, mask, flags, 0 */ ! 293: error = rtrequest(RTM_ADD, &dst, (struct sockaddr *)&gw, ! 294: &mask, (RTF_UP | RTF_GATEWAY | RTF_STATIC), NULL); ! 295: if (error) ! 296: printf("nfs_boot: add route, error=%d\n", error); ! 297: } ! 298: #endif ! 299: ! 300: get_path_and_handle(&bp_sin, "root", &nd->nd_root); ! 301: #if !defined(NO_MOUNT_PRIVATE) ! 302: get_path_and_handle(&bp_sin, "private", &nd->nd_private); ! 303: #endif /* NO_MOUNT_PRIVATE */ ! 304: ! 305: return (0); ! 306: } ! 307: ! 308: static void ! 309: get_path_and_handle(bpsin, key, ndmntp) ! 310: struct sockaddr_in *bpsin; /* bootparam server */ ! 311: char *key; /* root or swap */ ! 312: struct nfs_dlmount *ndmntp; /* output */ ! 313: { ! 314: char pathname[MAXPATHLEN]; ! 315: char *sp, *dp, *endp; ! 316: int error; ! 317: ! 318: /* ! 319: * Get server:pathname for "key" (root or swap) ! 320: * using RPC to bootparam/getfile ! 321: */ ! 322: error = bp_getfile(bpsin, key, &ndmntp->ndm_saddr, ! 323: ndmntp->ndm_host, pathname); ! 324: if (error) { ! 325: printf("nfs_boot: bootparam get %s: %d\n", key, error); ! 326: panic("nfs_boot: bootparam get %s: %d", key, error); ! 327: } ! 328: /* ! 329: * Get file handle for "key" (root or swap) ! 330: * using RPC to mountd/mount ! 331: */ ! 332: error = md_mount(&ndmntp->ndm_saddr, pathname, ndmntp->ndm_fh); ! 333: if (error) ! 334: panic("nfs_boot: mountd %s, error=%d", key, error); ! 335: ! 336: /* Construct remote path (for getmntinfo(3)) */ ! 337: dp = ndmntp->ndm_host; ! 338: endp = dp + MNAMELEN - 1; ! 339: dp += strlen(dp); ! 340: *dp++ = ':'; ! 341: for (sp = pathname; *sp && dp < endp;) ! 342: *dp++ = *sp++; ! 343: *dp = '\0'; ! 344: ! 345: } ! 346: ! 347: ! 348: /* ! 349: * Get an mbuf with the given length, and ! 350: * initialize the pkthdr length field. ! 351: */ ! 352: static struct mbuf * ! 353: m_get_len(int msg_len) ! 354: { ! 355: struct mbuf *m; ! 356: m = m_gethdr(M_WAIT, MT_DATA); ! 357: if (m == NULL) ! 358: return NULL; ! 359: if (msg_len > MHLEN) { ! 360: if (msg_len > MCLBYTES) ! 361: panic("nfs_boot: msg_len > MCLBYTES"); ! 362: MCLGET(m, M_WAIT); ! 363: if (m == NULL) ! 364: return NULL; ! 365: } ! 366: m->m_len = msg_len; ! 367: m->m_pkthdr.len = m->m_len; ! 368: return (m); ! 369: } ! 370: ! 371: ! 372: /* ! 373: * String representation for RPC. ! 374: */ ! 375: struct rpc_string { ! 376: u_long len; /* length without null or padding */ ! 377: u_char data[4]; /* data (longer, of course) */ ! 378: /* data is padded to a long-word boundary */ ! 379: }; ! 380: /* Compute space used given string length. */ ! 381: #define RPC_STR_SIZE(slen) (4 + ((slen + 3) & ~3)) ! 382: ! 383: /* ! 384: * Inet address in RPC messages ! 385: * (Note, really four longs, NOT chars. Blech.) ! 386: */ ! 387: struct bp_inaddr { ! 388: u_long atype; ! 389: long addr[4]; ! 390: }; ! 391: ! 392: ! 393: /* ! 394: * RPC: bootparam/whoami ! 395: * Given client IP address, get: ! 396: * client name (hostname) ! 397: * domain name (domainname) ! 398: * gateway address ! 399: * ! 400: * The hostname and domainname are set here for convenience. ! 401: * ! 402: * Note - bpsin is initialized to the broadcast address, ! 403: * and will be replaced with the bootparam server address ! 404: * after this call is complete. Have to use PMAP_PROC_CALL ! 405: * to make sure we get responses only from a servers that ! 406: * know about us (don't want to broadcast a getport call). ! 407: */ ! 408: static int ! 409: bp_whoami(bpsin, my_ip, gw_ip) ! 410: struct sockaddr_in *bpsin; ! 411: struct in_addr *my_ip; ! 412: struct in_addr *gw_ip; ! 413: { ! 414: /* RPC structures for PMAPPROC_CALLIT */ ! 415: struct whoami_call { ! 416: u_long call_prog; ! 417: u_long call_vers; ! 418: u_long call_proc; ! 419: u_long call_arglen; ! 420: struct bp_inaddr call_ia; ! 421: } *call; ! 422: ! 423: struct rpc_string *str; ! 424: struct bp_inaddr *bia; ! 425: struct mbuf *m, *from; ! 426: struct sockaddr_in *sin; ! 427: int error, msg_len; ! 428: int cn_len, dn_len; ! 429: u_char *p; ! 430: long *lp; ! 431: ! 432: /* ! 433: * Get message buffer of sufficient size. ! 434: */ ! 435: msg_len = sizeof(*call); ! 436: m = m_get_len(msg_len); ! 437: if (m == NULL) ! 438: return ENOBUFS; ! 439: ! 440: /* ! 441: * Build request message for PMAPPROC_CALLIT. ! 442: */ ! 443: call = mtod(m, struct whoami_call *); ! 444: call->call_prog = htonl(BOOTPARAM_PROG); ! 445: call->call_vers = htonl(BOOTPARAM_VERS); ! 446: call->call_proc = htonl(BOOTPARAM_WHOAMI); ! 447: call->call_arglen = htonl(sizeof(struct bp_inaddr)); ! 448: ! 449: /* client IP address */ ! 450: call->call_ia.atype = htonl(1); ! 451: p = (u_char*)my_ip; ! 452: lp = call->call_ia.addr; ! 453: *lp++ = htonl(*p); p++; ! 454: *lp++ = htonl(*p); p++; ! 455: *lp++ = htonl(*p); p++; ! 456: *lp++ = htonl(*p); p++; ! 457: ! 458: /* RPC: portmap/callit */ ! 459: bpsin->sin_port = htons(PMAPPORT); ! 460: from = NULL; ! 461: error = krpc_call(bpsin, PMAPPROG, PMAPVERS, ! 462: PMAPPROC_CALLIT, &m, &from); ! 463: if (error) ! 464: return error; ! 465: ! 466: /* ! 467: * Parse result message. ! 468: */ ! 469: msg_len = m->m_len; ! 470: lp = mtod(m, long *); ! 471: ! 472: /* bootparam server port (also grab from address). */ ! 473: if (msg_len < sizeof(*lp)) ! 474: goto bad; ! 475: msg_len -= sizeof(*lp); ! 476: bpsin->sin_port = htons((short)ntohl(*lp++)); ! 477: sin = mtod(from, struct sockaddr_in *); ! 478: bpsin->sin_addr.s_addr = sin->sin_addr.s_addr; ! 479: ! 480: /* length of encapsulated results */ ! 481: if (msg_len < (ntohl(*lp) + sizeof(*lp))) ! 482: goto bad; ! 483: msg_len = ntohl(*lp++); ! 484: p = (char*)lp; ! 485: ! 486: /* client name */ ! 487: if (msg_len < sizeof(*str)) ! 488: goto bad; ! 489: str = (struct rpc_string *)p; ! 490: cn_len = ntohl(str->len); ! 491: if (msg_len < cn_len) ! 492: goto bad; ! 493: if (cn_len >= MAXHOSTNAMELEN) ! 494: goto bad; ! 495: bcopy(str->data, hostname, cn_len); ! 496: hostname[cn_len] = '\0'; ! 497: hostnamelen = cn_len; ! 498: p += RPC_STR_SIZE(cn_len); ! 499: msg_len -= RPC_STR_SIZE(cn_len); ! 500: ! 501: /* domain name */ ! 502: if (msg_len < sizeof(*str)) ! 503: goto bad; ! 504: str = (struct rpc_string *)p; ! 505: dn_len = ntohl(str->len); ! 506: if (msg_len < dn_len) ! 507: goto bad; ! 508: if (dn_len >= MAXHOSTNAMELEN) ! 509: goto bad; ! 510: bcopy(str->data, domainname, dn_len); ! 511: domainname[dn_len] = '\0'; ! 512: domainnamelen = dn_len; ! 513: p += RPC_STR_SIZE(dn_len); ! 514: msg_len -= RPC_STR_SIZE(dn_len); ! 515: ! 516: /* gateway address */ ! 517: if (msg_len < sizeof(*bia)) ! 518: goto bad; ! 519: bia = (struct bp_inaddr *)p; ! 520: if (bia->atype != htonl(1)) ! 521: goto bad; ! 522: p = (u_char*)gw_ip; ! 523: *p++ = ntohl(bia->addr[0]); ! 524: *p++ = ntohl(bia->addr[1]); ! 525: *p++ = ntohl(bia->addr[2]); ! 526: *p++ = ntohl(bia->addr[3]); ! 527: goto out; ! 528: ! 529: bad: ! 530: printf("nfs_boot: bootparam_whoami: bad reply\n"); ! 531: error = EBADRPC; ! 532: ! 533: out: ! 534: if (from) ! 535: m_freem(from); ! 536: m_freem(m); ! 537: return(error); ! 538: } ! 539: ! 540: ! 541: /* ! 542: * RPC: bootparam/getfile ! 543: * Given client name and file "key", get: ! 544: * server name ! 545: * server IP address ! 546: * server pathname ! 547: */ ! 548: static int ! 549: bp_getfile(bpsin, key, md_sin, serv_name, pathname) ! 550: struct sockaddr_in *bpsin; ! 551: char *key; ! 552: struct sockaddr_in *md_sin; ! 553: char *serv_name; ! 554: char *pathname; ! 555: { ! 556: struct rpc_string *str; ! 557: struct mbuf *m; ! 558: struct bp_inaddr *bia; ! 559: struct sockaddr_in *sin; ! 560: u_char *p, *q; ! 561: int error, msg_len; ! 562: int cn_len, key_len, sn_len, path_len; ! 563: ! 564: /* ! 565: * Get message buffer of sufficient size. ! 566: */ ! 567: cn_len = hostnamelen; ! 568: key_len = strlen(key); ! 569: msg_len = 0; ! 570: msg_len += RPC_STR_SIZE(cn_len); ! 571: msg_len += RPC_STR_SIZE(key_len); ! 572: m = m_get_len(msg_len); ! 573: if (m == NULL) ! 574: return ENOBUFS; ! 575: ! 576: /* ! 577: * Build request message. ! 578: */ ! 579: p = mtod(m, u_char *); ! 580: bzero(p, msg_len); ! 581: /* client name (hostname) */ ! 582: str = (struct rpc_string *)p; ! 583: str->len = htonl(cn_len); ! 584: bcopy(hostname, str->data, cn_len); ! 585: p += RPC_STR_SIZE(cn_len); ! 586: /* key name (root or swap) */ ! 587: str = (struct rpc_string *)p; ! 588: str->len = htonl(key_len); ! 589: bcopy(key, str->data, key_len); ! 590: ! 591: /* RPC: bootparam/getfile */ ! 592: error = krpc_call(bpsin, BOOTPARAM_PROG, BOOTPARAM_VERS, ! 593: BOOTPARAM_GETFILE, &m, NULL); ! 594: if (error) ! 595: return error; ! 596: ! 597: /* ! 598: * Parse result message. ! 599: */ ! 600: p = mtod(m, u_char *); ! 601: msg_len = m->m_len; ! 602: ! 603: /* server name */ ! 604: if (msg_len < sizeof(*str)) ! 605: goto bad; ! 606: str = (struct rpc_string *)p; ! 607: sn_len = ntohl(str->len); ! 608: if (msg_len < sn_len) ! 609: goto bad; ! 610: if (sn_len >= MNAMELEN) ! 611: goto bad; ! 612: bcopy(str->data, serv_name, sn_len); ! 613: serv_name[sn_len] = '\0'; ! 614: p += RPC_STR_SIZE(sn_len); ! 615: msg_len -= RPC_STR_SIZE(sn_len); ! 616: ! 617: /* server IP address (mountd) */ ! 618: if (msg_len < sizeof(*bia)) ! 619: goto bad; ! 620: bia = (struct bp_inaddr *)p; ! 621: if (bia->atype != htonl(1)) ! 622: goto bad; ! 623: sin = md_sin; ! 624: bzero((caddr_t)sin, sizeof(*sin)); ! 625: sin->sin_len = sizeof(*sin); ! 626: sin->sin_family = AF_INET; ! 627: q = (u_char*) &sin->sin_addr; ! 628: *q++ = ntohl(bia->addr[0]); ! 629: *q++ = ntohl(bia->addr[1]); ! 630: *q++ = ntohl(bia->addr[2]); ! 631: *q++ = ntohl(bia->addr[3]); ! 632: p += sizeof(*bia); ! 633: msg_len -= sizeof(*bia); ! 634: ! 635: /* server pathname */ ! 636: if (msg_len < sizeof(*str)) ! 637: goto bad; ! 638: str = (struct rpc_string *)p; ! 639: path_len = ntohl(str->len); ! 640: if (msg_len < path_len) ! 641: goto bad; ! 642: if (path_len >= MAXPATHLEN) ! 643: goto bad; ! 644: bcopy(str->data, pathname, path_len); ! 645: pathname[path_len] = '\0'; ! 646: goto out; ! 647: ! 648: bad: ! 649: printf("nfs_boot: bootparam_getfile: bad reply\n"); ! 650: error = EBADRPC; ! 651: ! 652: out: ! 653: m_freem(m); ! 654: return(0); ! 655: } ! 656: ! 657: ! 658: /* ! 659: * RPC: mountd/mount ! 660: * Given a server pathname, get an NFS file handle. ! 661: * Also, sets sin->sin_port to the NFS service port. ! 662: */ ! 663: static int ! 664: md_mount(mdsin, path, fhp) ! 665: struct sockaddr_in *mdsin; /* mountd server address */ ! 666: char *path; ! 667: u_char *fhp; ! 668: { ! 669: /* The RPC structures */ ! 670: struct rpc_string *str; ! 671: struct rdata { ! 672: u_long errno; ! 673: u_char fh[NFSX_V2FH]; ! 674: } *rdata; ! 675: struct mbuf *m; ! 676: int error, mlen, slen; ! 677: ! 678: /* Get port number for MOUNTD. */ ! 679: error = krpc_portmap(mdsin, RPCPROG_MNT, RPCMNT_VER1, ! 680: &mdsin->sin_port); ! 681: if (error) return error; ! 682: ! 683: slen = strlen(path); ! 684: mlen = RPC_STR_SIZE(slen); ! 685: ! 686: m = m_get_len(mlen); ! 687: if (m == NULL) ! 688: return ENOBUFS; ! 689: str = mtod(m, struct rpc_string *); ! 690: str->len = htonl(slen); ! 691: bcopy(path, str->data, slen); ! 692: ! 693: /* Do RPC to mountd. */ ! 694: error = krpc_call(mdsin, RPCPROG_MNT, RPCMNT_VER1, ! 695: RPCMNT_MOUNT, &m, NULL); ! 696: if (error) ! 697: return error; /* message already freed */ ! 698: ! 699: mlen = m->m_len; ! 700: if (mlen < sizeof(*rdata)) ! 701: goto bad; ! 702: rdata = mtod(m, struct rdata *); ! 703: error = ntohl(rdata->errno); ! 704: if (error) ! 705: goto bad; ! 706: bcopy(rdata->fh, fhp, NFSX_V2FH); ! 707: ! 708: /* Set port number for NFS use. */ ! 709: error = krpc_portmap(mdsin, NFS_PROG, NFS_VER2, ! 710: &mdsin->sin_port); ! 711: goto out; ! 712: ! 713: bad: ! 714: error = EBADRPC; ! 715: ! 716: out: ! 717: m_freem(m); ! 718: return error; ! 719: } ! 720: ! 721: #endif /* NETHER */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.