Home | History | Annotate | Line # | Download | only in nfs
nfs_bootparam.c revision 1.18
      1 /*	$NetBSD: nfs_bootparam.c,v 1.18 2001/10/13 23:25:58 simonb 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  * 3. All advertising materials mentioning features or use of this software
     19  *    must display the following acknowledgement:
     20  *	This product includes software developed by the NetBSD
     21  *	Foundation, Inc. and its contributors.
     22  * 4. Neither the name of The NetBSD Foundation nor the names of its
     23  *    contributors may be used to endorse or promote products derived
     24  *    from this software without specific prior written permission.
     25  *
     26  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     27  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     28  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     29  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     30  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     31  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     32  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     33  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     34  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     35  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     36  * POSSIBILITY OF SUCH DAMAGE.
     37  */
     38 
     39 /*
     40  * Support for NFS diskless booting, Sun-style (RPC/bootparams)
     41  */
     42 
     43 #include "opt_nfs_boot.h"
     44 #include "opt_inet.h"
     45 
     46 #include <sys/param.h>
     47 #include <sys/systm.h>
     48 #include <sys/kernel.h>
     49 #include <sys/conf.h>
     50 #include <sys/device.h>
     51 #include <sys/ioctl.h>
     52 #include <sys/proc.h>
     53 #include <sys/mount.h>
     54 #include <sys/mbuf.h>
     55 #include <sys/reboot.h>
     56 #include <sys/socket.h>
     57 #include <sys/socketvar.h>
     58 
     59 #include <net/if.h>
     60 #include <net/if_types.h>
     61 #include <net/route.h>
     62 #include <net/if_ether.h>
     63 
     64 #include <netinet/in.h>
     65 #include <netinet/if_inarp.h>
     66 
     67 #include <nfs/rpcv2.h>
     68 #include <nfs/krpc.h>
     69 #include <nfs/xdr_subs.h>
     70 
     71 #include <nfs/nfsproto.h>
     72 #include <nfs/nfs.h>
     73 #include <nfs/nfsmount.h>
     74 #include <nfs/nfsdiskless.h>
     75 
     76 #include "arp.h"
     77 
     78 /*
     79  * There are two implementations of NFS diskless boot.
     80  * This implementation uses Sun RPC/bootparams, and the
     81  * the other uses BOOTP (RFC951 - see nfs_bootdhcp.c).
     82  *
     83  * The Sun-style boot sequence goes as follows:
     84  * (1) Use RARP to get our interface address
     85  * (2) Use RPC/bootparam/whoami to get our hostname,
     86  *     our IP address, and the server's IP address.
     87  * (3) Use RPC/bootparam/getfile to get the root path
     88  * (4) Use RPC/mountd to get the root file handle
     89  * (5) Use RPC/bootparam/getfile to get the swap path
     90  * (6) Use RPC/mountd to get the swap file handle
     91  */
     92 
     93 /* bootparam RPC */
     94 static int bp_whoami __P((struct sockaddr_in *bpsin,
     95 	struct in_addr *my_ip, struct in_addr *gw_ip));
     96 static int bp_getfile __P((struct sockaddr_in *bpsin, char *key,
     97 	struct nfs_dlmount *ndm));
     98 
     99 
    100 /*
    101  * Get client name, gateway address, then
    102  * get root and swap server:pathname info.
    103  * RPCs: bootparam/whoami, bootparam/getfile
    104  *
    105  * Use the old broadcast address for the WHOAMI
    106  * call because we do not yet know our netmask.
    107  * The server address returned by the WHOAMI call
    108  * is used for all subsequent booptaram RPCs.
    109  */
    110 int
    111 nfs_bootparam(nd, procp)
    112 	struct nfs_diskless *nd;
    113 	struct proc *procp;
    114 {
    115 	struct ifnet *ifp = nd->nd_ifp;
    116 	struct in_addr my_ip, arps_ip, gw_ip;
    117 	struct sockaddr_in bp_sin;
    118 	struct sockaddr_in *sin;
    119 #ifndef NFS_BOOTPARAM_NOGATEWAY
    120 	struct nfs_dlmount *gw_ndm = 0;
    121 	char *p;
    122 	u_int32_t mask;
    123 #endif
    124 	int error;
    125 
    126 	/*
    127 	 * Bring up the interface. (just set the "up" flag)
    128 	 */
    129 	error = nfs_boot_ifupdown(ifp, procp, 1);
    130 	if (error) {
    131 		printf("nfs_boot: SIFFLAGS, error=%d\n", error);
    132 		return (error);
    133 	}
    134 
    135 	error = EADDRNOTAVAIL;
    136 #ifdef INET
    137 #if NARP > 0
    138 	if (ifp->if_type == IFT_ETHER || ifp->if_type == IFT_FDDI) {
    139 		/*
    140 		 * Do RARP for the interface address.
    141 		 */
    142 		error = revarpwhoarewe(ifp, &arps_ip, &my_ip);
    143 	}
    144 #endif
    145 #endif
    146 	if (error) {
    147 		printf("revarp failed, error=%d\n", error);
    148 		goto out;
    149 	}
    150 
    151 	nd->nd_myip.s_addr = my_ip.s_addr;
    152 	printf("nfs_boot: client_addr=%s", inet_ntoa(my_ip));
    153 	printf(" (RARP from %s)\n", inet_ntoa(arps_ip));
    154 
    155 	/*
    156 	 * Do enough of ifconfig(8) so that the chosen interface
    157 	 * can talk to the servers.  (just set the address)
    158 	 */
    159 	error = nfs_boot_setaddress(ifp, procp, my_ip.s_addr,
    160 				    INADDR_ANY, INADDR_ANY);
    161 	if (error) {
    162 		printf("nfs_boot: set ifaddr, error=%d\n", error);
    163 		goto out;
    164 	}
    165 
    166 	/*
    167 	 * Get client name and gateway address.
    168 	 * RPC: bootparam/whoami
    169 	 * Use the old broadcast address for the WHOAMI
    170 	 * call because we do not yet know our netmask.
    171 	 * The server address returned by the WHOAMI call
    172 	 * is used for all subsequent booptaram RPCs.
    173 	 */
    174 	sin = &bp_sin;
    175 	memset((caddr_t)sin, 0, sizeof(*sin));
    176 	sin->sin_len = sizeof(*sin);
    177 	sin->sin_family = AF_INET;
    178 	sin->sin_addr.s_addr = INADDR_BROADCAST;
    179 
    180 	/* Do the RPC/bootparam/whoami. */
    181 	error = bp_whoami(sin, &my_ip, &gw_ip);
    182 	if (error) {
    183 		printf("nfs_boot: bootparam whoami, error=%d\n", error);
    184 		goto delout;
    185 	}
    186 	printf("nfs_boot: server_addr=%s\n", inet_ntoa(sin->sin_addr));
    187 	printf("nfs_boot: hostname=%s\n", hostname);
    188 
    189 	/*
    190 	 * Now fetch the server:pathname strings and server IP
    191 	 * for root and swap.  Missing swap is not fatal.
    192 	 */
    193 	error = bp_getfile(sin, "root", &nd->nd_root);
    194 	if (error) {
    195 		printf("nfs_boot: bootparam get root: %d\n", error);
    196 		goto delout;
    197 	}
    198 
    199 #ifndef NFS_BOOTPARAM_NOGATEWAY
    200 	gw_ndm = malloc(sizeof(*gw_ndm), M_NFSMNT, M_WAITOK);
    201 	memset((caddr_t)gw_ndm, 0, sizeof(*gw_ndm));
    202 	error = bp_getfile(sin, "gateway", gw_ndm);
    203 	if (error) {
    204 		/* No gateway supplied. No error, but try fallback. */
    205 		error = 0;
    206 		goto nogwrepl;
    207 	}
    208 	sin = (struct sockaddr_in *) &gw_ndm->ndm_saddr;
    209 	if (sin->sin_addr.s_addr == 0)
    210 		goto out;	/* no gateway */
    211 
    212 	/* OK, we have a gateway! */
    213 	printf("nfs_boot: gateway=%s\n", inet_ntoa(sin->sin_addr));
    214 	/* Just save it.  Caller adds the route. */
    215 	nd->nd_gwip = sin->sin_addr;
    216 
    217 	/* Look for a mask string after the colon. */
    218 	p = strchr(gw_ndm->ndm_host, ':');
    219 	if (p == 0)
    220 		goto out;	/* no netmask */
    221 	/* have pathname */
    222 	p++;	/* skip ':' */
    223 	mask = inet_addr(p);	/* libkern */
    224 	if (mask == 0)
    225 		goto out;	/* no netmask */
    226 
    227 	/* Have a netmask too!  Save it; update the I/F. */
    228 	nd->nd_mask.s_addr = mask;
    229 	printf("nfs_boot: my_mask=%s\n", inet_ntoa(nd->nd_mask));
    230 	(void)  nfs_boot_deladdress(ifp, procp, my_ip.s_addr);
    231 	error = nfs_boot_setaddress(ifp, procp, my_ip.s_addr,
    232 				    mask, INADDR_ANY);
    233 	if (error) {
    234 		printf("nfs_boot: set ifmask, error=%d\n", error);
    235 		goto out;
    236 	}
    237 	goto gwok;
    238 nogwrepl:
    239 #endif
    240 #ifdef NFS_BOOT_GATEWAY
    241 	/*
    242 	 * Note: we normally ignore the gateway address returned
    243 	 * by the "bootparam/whoami" RPC above, because many old
    244 	 * bootparam servers supply a bogus gateway value.
    245 	 *
    246 	 * These deficiencies in the bootparam RPC interface are
    247 	 * circumvented by using the bootparam/getfile RPC.  The
    248 	 * parameter "gateway" is requested, and if its returned,
    249 	 * we use the "server" part of the reply as the gateway,
    250 	 * and use the "pathname" part of the reply as the mask.
    251 	 * (The mask comes to us as a string.)
    252 	 */
    253 	if (gw_ip.s_addr) {
    254 		/* Our caller will add the route. */
    255 		nd->nd_gwip = gw_ip;
    256 	}
    257 #endif
    258 
    259 delout:
    260 	if (error)
    261 		(void) nfs_boot_deladdress(ifp, procp, my_ip.s_addr);
    262 out:
    263 	if (error) {
    264 		(void) nfs_boot_ifupdown(ifp, procp, 0);
    265 		nfs_boot_flushrt(ifp);
    266 	}
    267 #ifndef NFS_BOOTPARAM_NOGATEWAY
    268 gwok:
    269 	if (gw_ndm)
    270 		free(gw_ndm, M_NFSMNT);
    271 #endif
    272 	return (error);
    273 }
    274 
    275 
    276 /*
    277  * RPC: bootparam/whoami
    278  * Given client IP address, get:
    279  *	client name	(hostname)
    280  *	domain name (domainname)
    281  *	gateway address
    282  *
    283  * The hostname and domainname are set here for convenience.
    284  *
    285  * Note - bpsin is initialized to the broadcast address,
    286  * and will be replaced with the bootparam server address
    287  * after this call is complete.  Have to use PMAP_PROC_CALL
    288  * to make sure we get responses only from a servers that
    289  * know about us (don't want to broadcast a getport call).
    290  */
    291 static int
    292 bp_whoami(bpsin, my_ip, gw_ip)
    293 	struct sockaddr_in *bpsin;
    294 	struct in_addr *my_ip;
    295 	struct in_addr *gw_ip;
    296 {
    297 	/* RPC structures for PMAPPROC_CALLIT */
    298 	struct whoami_call {
    299 		u_int32_t call_prog;
    300 		u_int32_t call_vers;
    301 		u_int32_t call_proc;
    302 		u_int32_t call_arglen;
    303 	} *call;
    304 	struct callit_reply {
    305 		u_int32_t port;
    306 		u_int32_t encap_len;
    307 		/* encapsulated data here */
    308 	} *reply;
    309 
    310 	struct mbuf *m, *from;
    311 	struct sockaddr_in *sin;
    312 	int error;
    313 	int16_t port;
    314 
    315 	/*
    316 	 * Build request message for PMAPPROC_CALLIT.
    317 	 */
    318 	m = m_get(M_WAIT, MT_DATA);
    319 	call = mtod(m, struct whoami_call *);
    320 	m->m_len = sizeof(*call);
    321 	call->call_prog = txdr_unsigned(BOOTPARAM_PROG);
    322 	call->call_vers = txdr_unsigned(BOOTPARAM_VERS);
    323 	call->call_proc = txdr_unsigned(BOOTPARAM_WHOAMI);
    324 
    325 	/*
    326 	 * append encapsulated data (client IP address)
    327 	 */
    328 	m->m_next = xdr_inaddr_encode(my_ip);
    329 	call->call_arglen = txdr_unsigned(m->m_next->m_len);
    330 
    331 	/* RPC: portmap/callit */
    332 	bpsin->sin_port = htons(PMAPPORT);
    333 	from = NULL;
    334 	error = krpc_call(bpsin, PMAPPROG, PMAPVERS,
    335 			PMAPPROC_CALLIT, &m, &from);
    336 	if (error)
    337 		return error;
    338 
    339 	/*
    340 	 * Parse result message.
    341 	 */
    342 	if (m->m_len < sizeof(*reply)) {
    343 		m = m_pullup(m, sizeof(*reply));
    344 		if (m == NULL)
    345 			goto bad;
    346 	}
    347 	reply = mtod(m, struct callit_reply *);
    348 	port = fxdr_unsigned(u_int32_t, reply->port);
    349 	m_adj(m, sizeof(*reply));
    350 
    351 	/*
    352 	 * Save bootparam server address
    353 	 */
    354 	sin = mtod(from, struct sockaddr_in *);
    355 	bpsin->sin_port = htons(port);
    356 	bpsin->sin_addr.s_addr = sin->sin_addr.s_addr;
    357 
    358 	/* client name */
    359 	hostnamelen = MAXHOSTNAMELEN-1;
    360 	m = xdr_string_decode(m, hostname, &hostnamelen);
    361 	if (m == NULL)
    362 		goto bad;
    363 
    364 	/* domain name */
    365 	domainnamelen = MAXHOSTNAMELEN-1;
    366 	m = xdr_string_decode(m, domainname, &domainnamelen);
    367 	if (m == NULL)
    368 		goto bad;
    369 
    370 	/* gateway address */
    371 	m = xdr_inaddr_decode(m, gw_ip);
    372 	if (m == NULL)
    373 		goto bad;
    374 
    375 	/* success */
    376 	goto out;
    377 
    378 bad:
    379 	printf("nfs_boot: bootparam_whoami: bad reply\n");
    380 	error = EBADRPC;
    381 
    382 out:
    383 	if (from)
    384 		m_freem(from);
    385 	if (m)
    386 		m_freem(m);
    387 	return(error);
    388 }
    389 
    390 
    391 /*
    392  * RPC: bootparam/getfile
    393  * Given client name and file "key", get:
    394  *	server name
    395  *	server IP address
    396  *	server pathname
    397  */
    398 static int
    399 bp_getfile(bpsin, key, ndm)
    400 	struct sockaddr_in *bpsin;
    401 	char *key;
    402 	struct nfs_dlmount *ndm;
    403 {
    404 	char pathname[MNAMELEN];
    405 	struct in_addr inaddr;
    406 	struct sockaddr_in *sin;
    407 	struct mbuf *m;
    408 	char *serv_name;
    409 	int error, sn_len, path_len;
    410 
    411 	/*
    412 	 * Build request message.
    413 	 */
    414 
    415 	/* client name (hostname) */
    416 	m  = xdr_string_encode(hostname, hostnamelen);
    417 	if (m == NULL)
    418 		return (ENOMEM);
    419 
    420 	/* key name (root or swap) */
    421 	m->m_next = xdr_string_encode(key, strlen(key));
    422 	if (m->m_next == NULL)
    423 		return (ENOMEM);
    424 
    425 	/* RPC: bootparam/getfile */
    426 	error = krpc_call(bpsin, BOOTPARAM_PROG, BOOTPARAM_VERS,
    427 	                  BOOTPARAM_GETFILE, &m, NULL);
    428 	if (error)
    429 		return error;
    430 
    431 	/*
    432 	 * Parse result message.
    433 	 */
    434 
    435 	/* server name */
    436 	serv_name = &ndm->ndm_host[0];
    437 	sn_len = sizeof(ndm->ndm_host) - 1;
    438 	m = xdr_string_decode(m, serv_name, &sn_len);
    439 	if (m == NULL)
    440 		goto bad;
    441 
    442 	/* server IP address (mountd/NFS) */
    443 	m = xdr_inaddr_decode(m, &inaddr);
    444 	if (m == NULL)
    445 		goto bad;
    446 
    447 	/* server pathname */
    448 	path_len = sizeof(pathname) - 1;
    449 	m = xdr_string_decode(m, pathname, &path_len);
    450 	if (m == NULL)
    451 		goto bad;
    452 
    453 	/*
    454 	 * Store the results in the nfs_dlmount.
    455 	 * The strings become "server:pathname"
    456 	 */
    457 	sin = (struct sockaddr_in *) &ndm->ndm_saddr;
    458 	memset((caddr_t)sin, 0, sizeof(*sin));
    459 	sin->sin_len = sizeof(*sin);
    460 	sin->sin_family = AF_INET;
    461 	sin->sin_addr = inaddr;
    462 	if ((sn_len + 1 + path_len + 1) > sizeof(ndm->ndm_host)) {
    463 		printf("nfs_boot: getfile name too long\n");
    464 		error = EIO;
    465 		goto out;
    466 	}
    467 	ndm->ndm_host[sn_len] = ':';
    468 	memcpy(ndm->ndm_host + sn_len + 1, pathname, path_len + 1);
    469 
    470 	/* success */
    471 	goto out;
    472 
    473 bad:
    474 	printf("nfs_boot: bootparam_getfile: bad reply\n");
    475 	error = EBADRPC;
    476 
    477 out:
    478 	m_freem(m);
    479 	return(0);
    480 }
    481