![[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 XNU] / XNU / bsd / nfs|
Return to nfs_boot.c CVS log | Up to [Apple XNU] / XNU / bsd / nfs |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /* Copyright (c) 1995, 1997 NeXT Computer, Inc. All Rights Reserved */
23: /*
24: * Copyright (c) 1994 Adam Glass, Gordon Ross
25: * All rights reserved.
26: *
27: * This software was developed by the Computer Systems Engineering group
28: * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
29: * contributed to Berkeley.
30: *
31: * Redistribution and use in source and binary forms, with or without
32: * modification, are permitted provided that the following conditions
33: * are met:
34: * 1. Redistributions of source code must retain the above copyright
35: * notice, this list of conditions and the following disclaimer.
36: * 2. Redistributions in binary form must reproduce the above copyright
37: * notice, this list of conditions and the following disclaimer in the
38: * documentation and/or other materials provided with the distribution.
39: * 3. All advertising materials mentioning features or use of this software
40: * must display the following acknowledgement:
41: * This product includes software developed by the University of
42: * California, Lawrence Berkeley Laboratory and its contributors.
43: * 4. Neither the name of the University nor the names of its contributors
44: * may be used to endorse or promote products derived from this software
45: * without specific prior written permission.
46: *
47: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
48: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
49: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
50: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
51: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
52: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
53: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
54: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
55: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
56: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
57: * SUCH DAMAGE.
58: *
59: * History:
60: * 14-March-97 Dieter Siegmund ([email protected])
61: * - Use BOOTP instead of RARP to get the IP address at boot time
62: *
63: * 23-May-97 Umesh Vaishampayan ([email protected])
64: * - Added the ability to mount "/private" separately.
65: *
66: * 30-May-97 Dieter Siegmund ([email protected])
67: * - Clear out the ireq structure before using it to prevent
68: * our sending using a bogus source IP address, we should use
69: * an IP address of all zeroes
70: * - Right after BOOTP, get the correct netmask using AUTONETMASK
71: * 18-Jul-97 Dieter Siegmund ([email protected])
72: * - we can't restrict the netmask until we have a default route,
73: * removed AUTONETMASK call (ifdef'd out)
74: * 5-Aug-97 Dieter Siegmund ([email protected])
75: * - use the default route from the bpwhoami call, enabled autonetmask
76: * again
77: * 19-Feb-1999 Dieter Siegmund ([email protected])
78: * - use new BOOTP routine to get the subnet mask and router
79: * and stop using SIOCAUTOADDR
80: * - don't bother mounting private separately if it's not
81: * specified or not required because they are substrings of
82: * one another ie. root=host:/A and private=host:/A/private
83: * - allow the root path to be specified in the boot variable
84: * "rp" (AKA "rootpath")
85: * 19-Jul-1999 Dieter Siegmund ([email protected])
86: * - replaced big automatic arrays with MALLOC'd data
87: */
88:
89: #include <sys/param.h>
90: #include <sys/systm.h>
91: #include <sys/kernel.h>
92: #include <sys/conf.h>
93: #include <sys/ioctl.h>
94: #include <sys/proc.h>
95: #include <sys/mount.h>
96: #include <sys/mbuf.h>
97:
98: #include <sys/malloc.h>
99: #include <sys/socket.h>
100: #include <sys/reboot.h>
101:
102: #include <net/if.h>
103: #include <net/if_dl.h>
104: #include <net/if_types.h>
105: #include <net/route.h>
106:
107: #include <netinet/in.h>
108: #include <netinet/if_ether.h>
109:
110: #include <nfs/rpcv2.h>
111: #include <nfs/nfsproto.h>
112: #include <nfs/nfs.h>
113: #include <nfs/nfsdiskless.h>
114: #include <nfs/krpc.h>
115:
116: #include <pexpert/pexpert.h>
117:
118: #include "ether.h"
119:
120: #include <libkern/libkern.h>
121:
122: extern char *strchr(const char *str, int ch);
123:
124: #if NETHER == 0
125:
126: int nfs_boot_init(nd, procp)
127: struct nfs_diskless *nd;
128: struct proc *procp;
129: {
130: panic("nfs_boot_init: no ether");
131: }
132:
133: #else /* NETHER */
134:
135: /*
136: * Support for NFS diskless booting, specifically getting information
137: * about where to boot from, what pathnames, etc.
138: *
139: * This implememtation uses RARP and the bootparam RPC.
140: * We are forced to implement RPC anyway (to get file handles)
141: * so we might as well take advantage of it for bootparam too.
142: *
143: * The diskless boot sequence goes as follows:
144: * (1) Use RARP to get our interface address
145: * (2) Use RPC/bootparam/whoami to get our hostname,
146: * our IP address, and the server's IP address.
147: * (3) Use RPC/bootparam/getfile to get the root path
148: * (4) Use RPC/mountd to get the root file handle
149: * (5) Use RPC/bootparam/getfile to get the swap path
150: * (6) Use RPC/mountd to get the swap file handle
151: *
152: * (This happens to be the way Sun does it too.)
153: */
154:
155: extern int bootp(struct ifnet * ifp, struct in_addr * iaddr_p, int max_retry,
156: struct in_addr * netmask_p, struct in_addr * router_p,
157: struct proc * procp);
158:
159: /* bootparam RPC */
160: static int bp_whoami __P((struct sockaddr_in *bpsin,
161: struct in_addr *my_ip, struct in_addr *gw_ip));
162: static int bp_getfile __P((struct sockaddr_in *bpsin, char *key,
163: struct sockaddr_in *mdsin, char *servname, char *path));
164:
165: static boolean_t path_getfile __P((char * image_path,
166: struct sockaddr_in * sin_p,
167: char * serv_name, char * pathname));
168:
169: static __inline__
170: u_long iptohl(struct in_addr ip)
171: {
172: return (ntohl(ip.s_addr));
173: }
174:
175: static __inline__ boolean_t
176: same_subnet(struct in_addr addr1, struct in_addr addr2, struct in_addr mask)
177: {
178: u_long m = iptohl(mask);
179: if ((iptohl(addr1) & m) != (iptohl(addr2) & m))
180: return (FALSE);
181: return (TRUE);
182: }
183:
184: /* mountd RPC */
185: static int md_mount __P((struct sockaddr_in *mdsin, char *path,
186: u_char *fh));
187:
188: /* other helpers */
189: static void get_file_handle __P((char *pathname, struct nfs_dlmount *ndmntp));
190:
191: #define IP_FORMAT "%d.%d.%d.%d"
192: #define IP_CH(ip) ((u_char *)ip)
193: #define IP_LIST(ip) IP_CH(ip)[0],IP_CH(ip)[1],IP_CH(ip)[2],IP_CH(ip)[3]
194: /*
195: * Called with an empty nfs_diskless struct to be filled in.
196: */
197: int
198: nfs_boot_init(nd, procp)
199: struct nfs_diskless *nd;
200: struct proc *procp;
201: {
202: char * booter_path = NULL;
203: boolean_t do_bpwhoami = TRUE;
204: boolean_t do_bpgetfile = TRUE;
205: struct ifreq ireq;
206: struct in_addr my_ip;
207: struct sockaddr_in bp_sin;
208: struct sockaddr_in *sin;
209: struct ifnet *ifp;
210: struct in_addr gw_ip;
211: struct socket *so;
212: struct in_addr my_netmask;
213: int error;
214: char * root_path = NULL;
215:
216: MALLOC(booter_path, char *, MAXPATHLEN, M_TEMP, M_WAITOK);
217: MALLOC(root_path, char *, MAXPATHLEN, M_TEMP, M_WAITOK);
218:
219: /* booter-supplied path */
220: if (!PE_parse_boot_arg("rp", booter_path)
221: && !PE_parse_boot_arg("rootpath", booter_path)) {
222: booter_path[0] = 0;
223: }
224:
225: root_path[0] = 0;
226:
227: gw_ip.s_addr = 0;
228:
229: /* clear out the request structure */
230: bzero(&ireq, sizeof(ireq));
231:
232: /*
233: * Find an interface, rarp for its ip address, stuff it, the
234: * implied broadcast addr, and netmask into a nfs_diskless struct.
235: *
236: * This was moved here from nfs_vfsops.c because this procedure
237: * would be quite different if someone decides to write (i.e.) a
238: * BOOTP version of this file (might not use RARP, etc.)
239: */
240:
241: /*
242: * Find a network interface.
243: */
244: ifp = NULL;
245: { /* if the root device is set, use it */
246: extern char rootdevice[];
247: if (rootdevice[0])
248: ifp = ifunit(rootdevice);
249: }
250: if (ifp == NULL) { /* search for network device */
251: /* for (ifp = ifnet; ifp; ifp = ifp->if_next)*/
252: TAILQ_FOREACH(ifp, &ifnet, if_link)
253: if ((ifp->if_flags &
254: (IFF_LOOPBACK|IFF_POINTOPOINT)) == 0)
255: break;
256: }
257: if (ifp == NULL)
258: panic("nfs_boot: no suitable interface");
259: sprintf(ireq.ifr_name, "%s%d", ifp->if_name, ifp->if_unit);
260: printf("nfs_boot: using network interface '%s'\n", ireq.ifr_name);
261:
262: /*
263: * Bring up the interface.
264: */
265: if ((error = socreate(AF_INET, &so, SOCK_DGRAM, 0)) != 0)
266: panic("nfs_boot: socreate, error=%d", error);
267: ireq.ifr_flags = ifp->if_flags | IFF_UP;
268: error = ifioctl(so, SIOCSIFFLAGS, (caddr_t)&ireq, procp);
269: if (error)
270: panic("nfs_boot: SIFFLAGS, error=%d", error);
271:
272: #define DO_BOOTP
273: #ifdef DO_BOOTP
274: { /* use BOOTP to retrieve IP address, netmask and router */
275: struct sockaddr_in sockin;
276: struct in_addr router;
277: struct in_addr netmask;
278:
279: my_ip.s_addr = 0;
280: netmask.s_addr = 0;
281: router.s_addr = 0;
282: sockin.sin_family = AF_INET;
283: sockin.sin_len = sizeof(sockin);
284: sockin.sin_addr.s_addr = 0;
285: #define RETRY_COUNT 32
286: while ((error = bootp(ifp, &my_ip, RETRY_COUNT,
287: &netmask, &router, procp))) {
288: if (error == ETIMEDOUT)
289: printf("nfs_boot: BOOTP timed out, retrying...\n");
290:
291: else {
292: printf("nfs_boot: bootp() failed, error = %d\n", error);
293: panic("nfs_boot");
294: }
295: }
296: /* clear the netmask */
297: ((struct sockaddr_in *)&ireq.ifr_addr)->sin_addr.s_addr = 0;
298: error = ifioctl(so, SIOCSIFNETMASK, (caddr_t)&ireq, procp);
299: if (error)
300: printf("nfs_boot: SIOCSIFNETMASK failed: %d\n", error);
301:
302: if (netmask.s_addr) {
303: /* set our new subnet mask */
304: sockin.sin_addr = netmask;
305: *((struct sockaddr_in *)&ireq.ifr_addr) = sockin;
306: error = ifioctl(so, SIOCSIFNETMASK, (caddr_t)&ireq, procp);
307: if (error)
308: printf("nfs_boot: SIOCSIFNETMASK failed: %d\n", error);
309: }
310:
311: /* set our address */
312: sockin.sin_addr = my_ip;
313: *((struct sockaddr_in *)&ireq.ifr_addr) = sockin;
314: error = ifioctl(so, SIOCSIFADDR, (caddr_t)&ireq, procp);
315: if (error) {
316: printf("SIOCSIFADDR failed: %d\n", error);
317: panic("nfs_boot.c");
318: }
319: printf("nfs_boot: IP address " IP_FORMAT, IP_LIST(&my_ip));
320: if (netmask.s_addr)
321: printf(" netmask " IP_FORMAT, IP_LIST(&netmask));
322: if (router.s_addr) {
323: gw_ip = router;
324: printf(" router " IP_FORMAT, IP_LIST(&router));
325: }
326: printf("\n");
327: }
328: #else
329: /*
330: * Do RARP for the interface address.
331: */
332: if ((error = revarpwhoami(&my_ip, ifp)) != 0)
333: panic("revarp failed, error=%d", error);
334: printf("nfs_boot: client_addr=0x%x\n", ntohl(my_ip.s_addr));
335:
336: /*
337: * Do enough of ifconfig(8) so that the chosen interface
338: * can talk to the servers. (just set the address)
339: */
340: sin = (struct sockaddr_in *)&ireq.ifr_addr;
341: bzero((caddr_t)sin, sizeof(*sin));
342: sin->sin_len = sizeof(*sin);
343: sin->sin_family = AF_INET;
344: sin->sin_addr.s_addr = my_ip.s_addr;
345: error = ifioctl(so, SIOCSIFADDR, (caddr_t)&ireq, procp);
346: if (error)
347: panic("nfs_boot: set if addr, error=%d", error);
348: #endif DO_BOOTP
349:
350: /* need netmask to determine whether NFS server local */
351: sin = (struct sockaddr_in *)&ireq.ifr_addr;
352: bzero((caddr_t)sin, sizeof(*sin));
353: sin->sin_len = sizeof(*sin);
354: sin->sin_family = AF_INET;
355: error = ifioctl(so, SIOCGIFNETMASK, (caddr_t)&ireq, procp);
356: if (error)
357: panic("nfs_boot: SIOCGIFNETMASK error=%d", error);
358: my_netmask = sin->sin_addr;
359:
360: soclose(so);
361:
362: /* check for a booter-specified path */
363: if (booter_path[0]) {
364: nd->nd_root.ndm_saddr.sin_addr.s_addr = 0;
365: nd->nd_private.ndm_saddr.sin_addr.s_addr = 0;
366: if (path_getfile(booter_path, &nd->nd_root.ndm_saddr,
367: nd->nd_root.ndm_host, root_path)) {
368: do_bpgetfile = FALSE;
369: printf("nfs_boot: using booter-supplied path '%s'\n",
370: booter_path);
371: if (same_subnet(nd->nd_root.ndm_saddr.sin_addr,
372: my_ip, my_netmask)
373: || gw_ip.s_addr) {
374: do_bpwhoami = FALSE;
375: }
376: else {
377: /* do bpwhoami to attempt to get the router */
378: }
379: }
380: else {
381: printf("nfs_boot: ignoring badly formed bootpath '%s'\n",
382: booter_path);
383: }
384: }
385:
386: if (do_bpwhoami) {
387: /*
388: * Get client name and gateway address.
389: * RPC: bootparam/whoami
390: * Use the old broadcast address for the WHOAMI
391: * call because we do not yet know our netmask.
392: * The server address returned by the WHOAMI call
393: * is used for all subsequent booptaram RPCs.
394: */
395: bzero((caddr_t)&bp_sin, sizeof(bp_sin));
396: bp_sin.sin_len = sizeof(bp_sin);
397: bp_sin.sin_family = AF_INET;
398: bp_sin.sin_addr.s_addr = INADDR_BROADCAST;
399: hostnamelen = MAXHOSTNAMELEN;
400:
401: { /* bpwhoami also returns gateway IP address */
402:
403: struct in_addr router;
404:
405: router.s_addr = 0;
406: error = bp_whoami(&bp_sin, &my_ip, &router);
407: if (error) {
408: printf("nfs_boot: bootparam whoami, error=%d", error);
409: panic("nfs_boot: bootparam whoami\n");
410: }
411: /* if not already set by BOOTP, use the one from BPWHOAMI */
412: if (gw_ip.s_addr == 0)
413: gw_ip = router;
414: }
415: printf("nfs_boot: BOOTPARAMS server " IP_FORMAT "\n",
416: IP_LIST(&bp_sin.sin_addr));
417: printf("nfs_boot: hostname %s\n", hostname);
418: }
419: #define NFS_BOOT_GATEWAY 1
420: #ifdef NFS_BOOT_GATEWAY
421: /*
422: * DWS 2/18/1999
423: * The comment below does not apply to gw_ip discovered
424: * via BOOTP (see DO_BOOTP loop above) since BOOTP servers
425: * are supposed to be more trustworthy.
426: */
427: /*
428: * XXX - This code is conditionally compiled only because
429: * many bootparam servers (in particular, SunOS 4.1.3)
430: * always set the gateway address to their own address.
431: * The bootparam server is not necessarily the gateway.
432: * We could just believe the server, and at worst you would
433: * need to delete the incorrect default route before adding
434: * the correct one, but for simplicity, ignore the gateway.
435: * If your server is OK, you can turn on this option.
436: *
437: * If the gateway address is set, add a default route.
438: * (The mountd RPCs may go across a gateway.)
439: */
440: if (gw_ip.s_addr) {
441: struct sockaddr dst, gw, mask;
442: /* Destination: (default) */
443: bzero((caddr_t)&dst, sizeof(dst));
444: dst.sa_len = sizeof(dst);
445: dst.sa_family = AF_INET;
446: /* Gateway: */
447: bzero((caddr_t)&gw, sizeof(gw));
448: sin = (struct sockaddr_in *)&gw;
449: sin->sin_len = sizeof(gw);
450: sin->sin_family = AF_INET;
451: sin->sin_addr.s_addr = gw_ip.s_addr;
452: /* Mask: (zero length) */
453: bzero(&mask, sizeof(mask));
454: printf("nfs_boot: adding default route " IP_FORMAT "\n",
455: IP_LIST(&gw_ip));
456: /* add, dest, gw, mask, flags, 0 */
457: error = rtrequest(RTM_ADD, &dst, (struct sockaddr *)&gw,
458: &mask, (RTF_UP | RTF_GATEWAY | RTF_STATIC), NULL);
459: if (error)
460: printf("nfs_boot: add route, error=%d\n", error);
461: }
462: #endif
463: if (do_bpgetfile) {
464: error = bp_getfile(&bp_sin, "root", &nd->nd_root.ndm_saddr,
465: nd->nd_root.ndm_host, root_path);
466: if (error) {
467: printf("nfs_boot: bootparam get root: %d\n", error);
468: panic("nfs_boot: bootparam get root");
469: }
470: }
471:
472: get_file_handle(root_path, &nd->nd_root);
473:
474: #if !defined(NO_MOUNT_PRIVATE)
475: if (do_bpgetfile) { /* get private path */
476: char * private_path = NULL;
477:
478: MALLOC(private_path, char *, MAXPATHLEN, M_TEMP, M_WAITOK);
479: error = bp_getfile(&bp_sin, "private",
480: &nd->nd_private.ndm_saddr,
481: nd->nd_private.ndm_host, private_path);
482: if (!error) {
483: char * check_path = NULL;
484:
485: MALLOC(check_path, char *, MAXPATHLEN, M_TEMP, M_WAITOK);
486: sprintf(check_path, "%s/private", root_path);
487: if ((nd->nd_root.ndm_saddr.sin_addr.s_addr
488: == nd->nd_private.ndm_saddr.sin_addr.s_addr)
489: && (strcmp(check_path, private_path) == 0)) {
490: /* private path is prefix of root path, don't mount */
491: nd->nd_private.ndm_saddr.sin_addr.s_addr = 0;
492: }
493: else {
494: get_file_handle(private_path, &nd->nd_private);
495: }
496: _FREE(check_path, M_TEMP);
497: }
498: else {
499: /* private key not defined, don't mount */
500: nd->nd_private.ndm_saddr.sin_addr.s_addr = 0;
501: }
502: _FREE(private_path, M_TEMP);
503: }
504: #endif NO_MOUNT_PRIVATE
505: _FREE(booter_path, M_TEMP);
506: _FREE(root_path, M_TEMP);
507: return (0);
508: }
509:
510: int
511: inet_aton(char * cp, struct in_addr * pin)
512: {
513: u_char * b = (char *)pin;
514: int i;
515: char * p;
516:
517: for (p = cp, i = 0; i < 4; i++) {
518: u_long l = strtoul(p, 0, 0);
519: if (l > 255)
520: return (FALSE);
521: b[i] = l;
522: p = strchr(p, '.');
523: if (i < 3 && p == NULL)
524: return (FALSE);
525: p++;
526: }
527: return (TRUE);
528: }
529:
530: /*
531: * Function: parse_image_path
532: * Purpose:
533: * Parse a string of the form "<IP>:<host>:<path>" into
534: * the given ip address and host and pathnames.
535: * Example:
536: * "17.202.16.17:seaport:/release/.images/Image9/CurrentHera"
537: */
538: static __inline__ boolean_t
539: parse_image_path(char * c, struct in_addr * iaddr_p, char * hostname,
540: char * pathname)
541: {
542: char * d;
543: char * p;
544: #define TMP_SIZE 128
545: char tmp[TMP_SIZE];
546:
547: p = strchr(c, ':');
548: if (p == NULL)
549: return (FALSE);
550: if ((p - c) >= TMP_SIZE)
551: return (FALSE);
552: strncpy(tmp, c, p - c);
553: tmp[p - c] = 0;
554: if (inet_aton(tmp, iaddr_p) != 1)
555: return (FALSE);
556: p++;
557: d = strchr(p, ':');
558: if (d == NULL)
559: return (FALSE);
560: strncpy(hostname, p, d - p);
561: hostname[d - p] = 0;
562: d++;
563: strcpy(pathname, d);
564: return (TRUE);
565: }
566:
567: static boolean_t
568: path_getfile(char * image_path, struct sockaddr_in * sin_p,
569: char * serv_name, char * pathname)
570: {
571: bzero((caddr_t)sin_p, sizeof(*sin_p));
572: sin_p->sin_len = sizeof(*sin_p);
573: sin_p->sin_family = AF_INET;
574: if (parse_image_path(image_path, &sin_p->sin_addr, serv_name, pathname)
575: == FALSE)
576: return (FALSE);
577: return (TRUE);
578: }
579:
580: static void
581: get_file_handle(pathname, ndmntp)
582: char *pathname; /* path on server */
583: struct nfs_dlmount *ndmntp; /* output */
584: {
585: char *sp, *dp, *endp;
586: int error;
587:
588: /*
589: * Get file handle for "key" (root or swap)
590: * using RPC to mountd/mount
591: */
592: error = md_mount(&ndmntp->ndm_saddr, pathname, ndmntp->ndm_fh);
593: if (error)
594: panic("nfs_boot: mountd, error=%d", error);
595:
596: /* Construct remote path (for getmntinfo(3)) */
597: dp = ndmntp->ndm_host;
598: endp = dp + MNAMELEN - 1;
599: dp += strlen(dp);
600: *dp++ = ':';
601: for (sp = pathname; *sp && dp < endp;)
602: *dp++ = *sp++;
603: *dp = '\0';
604:
605: }
606:
607:
608: /*
609: * Get an mbuf with the given length, and
610: * initialize the pkthdr length field.
611: */
612: static struct mbuf *
613: m_get_len(int msg_len)
614: {
615: struct mbuf *m;
616: m = m_gethdr(M_WAIT, MT_DATA);
617: if (m == NULL)
618: return NULL;
619: if (msg_len > MHLEN) {
620: if (msg_len > MCLBYTES)
621: panic("nfs_boot: msg_len > MCLBYTES");
622: MCLGET(m, M_WAIT);
623: if (m == NULL)
624: return NULL;
625: }
626: m->m_len = msg_len;
627: m->m_pkthdr.len = m->m_len;
628: return (m);
629: }
630:
631:
632: /*
633: * String representation for RPC.
634: */
635: struct rpc_string {
636: u_long len; /* length without null or padding */
637: u_char data[4]; /* data (longer, of course) */
638: /* data is padded to a long-word boundary */
639: };
640: /* Compute space used given string length. */
641: #define RPC_STR_SIZE(slen) (4 + ((slen + 3) & ~3))
642:
643: /*
644: * Inet address in RPC messages
645: * (Note, really four longs, NOT chars. Blech.)
646: */
647: struct bp_inaddr {
648: u_long atype;
649: long addr[4];
650: };
651:
652:
653: /*
654: * RPC: bootparam/whoami
655: * Given client IP address, get:
656: * client name (hostname)
657: * domain name (domainname)
658: * gateway address
659: *
660: * The hostname and domainname are set here for convenience.
661: *
662: * Note - bpsin is initialized to the broadcast address,
663: * and will be replaced with the bootparam server address
664: * after this call is complete. Have to use PMAP_PROC_CALL
665: * to make sure we get responses only from a servers that
666: * know about us (don't want to broadcast a getport call).
667: */
668: static int
669: bp_whoami(bpsin, my_ip, gw_ip)
670: struct sockaddr_in *bpsin;
671: struct in_addr *my_ip;
672: struct in_addr *gw_ip;
673: {
674: /* RPC structures for PMAPPROC_CALLIT */
675: struct whoami_call {
676: u_long call_prog;
677: u_long call_vers;
678: u_long call_proc;
679: u_long call_arglen;
680: struct bp_inaddr call_ia;
681: } *call;
682:
683: struct rpc_string *str;
684: struct bp_inaddr *bia;
685: struct mbuf *m;
686: struct sockaddr_in *sin;
687: int error, msg_len;
688: int cn_len, dn_len;
689: u_char *p;
690: long *lp;
691:
692: /*
693: * Get message buffer of sufficient size.
694: */
695: msg_len = sizeof(*call);
696: m = m_get_len(msg_len);
697: if (m == NULL)
698: return ENOBUFS;
699:
700: /*
701: * Build request message for PMAPPROC_CALLIT.
702: */
703: call = mtod(m, struct whoami_call *);
704: call->call_prog = htonl(BOOTPARAM_PROG);
705: call->call_vers = htonl(BOOTPARAM_VERS);
706: call->call_proc = htonl(BOOTPARAM_WHOAMI);
707: call->call_arglen = htonl(sizeof(struct bp_inaddr));
708:
709: /* client IP address */
710: call->call_ia.atype = htonl(1);
711: p = (u_char*)my_ip;
712: lp = call->call_ia.addr;
713: *lp++ = htonl(*p); p++;
714: *lp++ = htonl(*p); p++;
715: *lp++ = htonl(*p); p++;
716: *lp++ = htonl(*p); p++;
717:
718: /* RPC: portmap/callit */
719: bpsin->sin_port = htons(PMAPPORT);
720:
721: error = krpc_call(bpsin, PMAPPROG, PMAPVERS,
722: PMAPPROC_CALLIT, &m, &sin);
723: if (error)
724: return error;
725:
726: /*
727: * Parse result message.
728: */
729: msg_len = m->m_len;
730: lp = mtod(m, long *);
731:
732: /* bootparam server port (also grab from address). */
733: if (msg_len < sizeof(*lp))
734: goto bad;
735: msg_len -= sizeof(*lp);
736: bpsin->sin_port = htons((short)ntohl(*lp++));
737: bpsin->sin_addr.s_addr = sin->sin_addr.s_addr;
738:
739: /* length of encapsulated results */
740: if (msg_len < (ntohl(*lp) + sizeof(*lp)))
741: goto bad;
742: msg_len = ntohl(*lp++);
743: p = (char*)lp;
744:
745: /* client name */
746: if (msg_len < sizeof(*str))
747: goto bad;
748: str = (struct rpc_string *)p;
749: cn_len = ntohl(str->len);
750: if (msg_len < cn_len)
751: goto bad;
752: if (cn_len >= MAXHOSTNAMELEN)
753: goto bad;
754: bcopy(str->data, hostname, cn_len);
755: hostname[cn_len] = '\0';
756: hostnamelen = cn_len;
757: p += RPC_STR_SIZE(cn_len);
758: msg_len -= RPC_STR_SIZE(cn_len);
759:
760: /* domain name */
761: if (msg_len < sizeof(*str))
762: goto bad;
763: str = (struct rpc_string *)p;
764: dn_len = ntohl(str->len);
765: if (msg_len < dn_len)
766: goto bad;
767: if (dn_len >= MAXHOSTNAMELEN)
768: goto bad;
769: bcopy(str->data, domainname, dn_len);
770: domainname[dn_len] = '\0';
771: domainnamelen = dn_len;
772: p += RPC_STR_SIZE(dn_len);
773: msg_len -= RPC_STR_SIZE(dn_len);
774:
775: /* gateway address */
776: if (msg_len < sizeof(*bia))
777: goto bad;
778: bia = (struct bp_inaddr *)p;
779: if (bia->atype != htonl(1))
780: goto bad;
781: p = (u_char*)gw_ip;
782: *p++ = ntohl(bia->addr[0]);
783: *p++ = ntohl(bia->addr[1]);
784: *p++ = ntohl(bia->addr[2]);
785: *p++ = ntohl(bia->addr[3]);
786: goto out;
787:
788: bad:
789: printf("nfs_boot: bootparam_whoami: bad reply\n");
790: error = EBADRPC;
791:
792: out:
793: if (sin)
794: FREE(sin, M_SONAME);
795:
796: m_freem(m);
797: return(error);
798: }
799:
800:
801: /*
802: * RPC: bootparam/getfile
803: * Given client name and file "key", get:
804: * server name
805: * server IP address
806: * server pathname
807: */
808: static int
809: bp_getfile(bpsin, key, md_sin, serv_name, pathname)
810: struct sockaddr_in *bpsin;
811: char *key;
812: struct sockaddr_in *md_sin;
813: char *serv_name;
814: char *pathname;
815: {
816: struct rpc_string *str;
817: struct mbuf *m;
818: struct bp_inaddr *bia;
819: struct sockaddr_in *sin;
820: u_char *p, *q;
821: int error, msg_len;
822: int cn_len, key_len, sn_len, path_len;
823:
824: /*
825: * Get message buffer of sufficient size.
826: */
827: cn_len = hostnamelen;
828: key_len = strlen(key);
829: msg_len = 0;
830: msg_len += RPC_STR_SIZE(cn_len);
831: msg_len += RPC_STR_SIZE(key_len);
832: m = m_get_len(msg_len);
833: if (m == NULL)
834: return ENOBUFS;
835:
836: /*
837: * Build request message.
838: */
839: p = mtod(m, u_char *);
840: bzero(p, msg_len);
841: /* client name (hostname) */
842: str = (struct rpc_string *)p;
843: str->len = htonl(cn_len);
844: bcopy(hostname, str->data, cn_len);
845: p += RPC_STR_SIZE(cn_len);
846: /* key name (root or swap) */
847: str = (struct rpc_string *)p;
848: str->len = htonl(key_len);
849: bcopy(key, str->data, key_len);
850:
851: /* RPC: bootparam/getfile */
852: error = krpc_call(bpsin, BOOTPARAM_PROG, BOOTPARAM_VERS,
853: BOOTPARAM_GETFILE, &m, NULL);
854: if (error)
855: return error;
856:
857: /*
858: * Parse result message.
859: */
860: p = mtod(m, u_char *);
861: msg_len = m->m_len;
862:
863: /* server name */
864: if (msg_len < sizeof(*str))
865: goto bad;
866: str = (struct rpc_string *)p;
867: sn_len = ntohl(str->len);
868: if (msg_len < sn_len)
869: goto bad;
870: if (sn_len >= MNAMELEN)
871: goto bad;
872: bcopy(str->data, serv_name, sn_len);
873: serv_name[sn_len] = '\0';
874: p += RPC_STR_SIZE(sn_len);
875: msg_len -= RPC_STR_SIZE(sn_len);
876:
877: /* server IP address (mountd) */
878: if (msg_len < sizeof(*bia))
879: goto bad;
880: bia = (struct bp_inaddr *)p;
881: if (bia->atype != htonl(1))
882: goto bad;
883: sin = md_sin;
884: bzero((caddr_t)sin, sizeof(*sin));
885: sin->sin_len = sizeof(*sin);
886: sin->sin_family = AF_INET;
887: q = (u_char*) &sin->sin_addr;
888: *q++ = ntohl(bia->addr[0]);
889: *q++ = ntohl(bia->addr[1]);
890: *q++ = ntohl(bia->addr[2]);
891: *q++ = ntohl(bia->addr[3]);
892: p += sizeof(*bia);
893: msg_len -= sizeof(*bia);
894:
895: /* server pathname */
896: if (msg_len < sizeof(*str))
897: goto bad;
898: str = (struct rpc_string *)p;
899: path_len = ntohl(str->len);
900: if (msg_len < path_len)
901: goto bad;
902: if (path_len >= MAXPATHLEN)
903: goto bad;
904: bcopy(str->data, pathname, path_len);
905: pathname[path_len] = '\0';
906: goto out;
907:
908: bad:
909: printf("nfs_boot: bootparam_getfile: bad reply\n");
910: error = EBADRPC;
911:
912: out:
913: m_freem(m);
914: return(0);
915: }
916:
917:
918: /*
919: * RPC: mountd/mount
920: * Given a server pathname, get an NFS file handle.
921: * Also, sets sin->sin_port to the NFS service port.
922: */
923: static int
924: md_mount(mdsin, path, fhp)
925: struct sockaddr_in *mdsin; /* mountd server address */
926: char *path;
927: u_char *fhp;
928: {
929: /* The RPC structures */
930: struct rpc_string *str;
931: struct rdata {
932: u_long errno;
933: u_char fh[NFSX_V2FH];
934: } *rdata;
935: struct mbuf *m;
936: int error, mlen, slen;
937:
938: /* Get port number for MOUNTD. */
939: error = krpc_portmap(mdsin, RPCPROG_MNT, RPCMNT_VER1,
940: &mdsin->sin_port);
941: if (error) return error;
942:
943: slen = strlen(path);
944: mlen = RPC_STR_SIZE(slen);
945:
946: m = m_get_len(mlen);
947: if (m == NULL)
948: return ENOBUFS;
949: str = mtod(m, struct rpc_string *);
950: str->len = htonl(slen);
951: bcopy(path, str->data, slen);
952:
953: /* Do RPC to mountd. */
954: error = krpc_call(mdsin, RPCPROG_MNT, RPCMNT_VER1,
955: RPCMNT_MOUNT, &m, NULL);
956: if (error)
957: return error; /* message already freed */
958:
959: mlen = m->m_len;
960: if (mlen < sizeof(*rdata))
961: goto bad;
962: rdata = mtod(m, struct rdata *);
963: error = ntohl(rdata->errno);
964: if (error)
965: goto bad;
966: bcopy(rdata->fh, fhp, NFSX_V2FH);
967:
968: /* Set port number for NFS use. */
969: error = krpc_portmap(mdsin, NFS_PROG, NFS_VER2,
970: &mdsin->sin_port);
971: goto out;
972:
973: bad:
974: error = EBADRPC;
975:
976: out:
977: m_freem(m);
978: return error;
979: }
980:
981: #endif /* NETHER */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.