/* $OpenBSD: nfs_boot.c,v 1.47 2021/01/19 19:35:59 mvs Exp $ */ /* $NetBSD: nfs_boot.c,v 1.26 1996/05/07 02:51:25 thorpej Exp $ */ /* * Copyright (c) 1995 Adam Glass, Gordon Ross * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. The name of the authors may not be used to endorse or promote products * derived from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "ether.h" #if !defined(NFSCLIENT) || (NETHER == 0 && NFDDI == 0) int nfs_boot_init(struct nfs_diskless *nd, struct proc *procp) { panic("nfs_boot_init: NFSCLIENT not enabled in kernel"); } int nfs_boot_getfh(struct sockaddr_in *bpsin, char *key, struct nfs_dlmount *ndmntp, int retries) { /* can not get here */ return (EOPNOTSUPP); } #else /* * Support for NFS diskless booting, specifically getting information * about where to boot from, what pathnames, etc. * * This implementation uses RARP and the bootparam RPC. * We are forced to implement RPC anyway (to get file handles) * so we might as well take advantage of it for bootparam too. * * The diskless boot sequence goes as follows: * (1) Use RARP to get our interface address * (2) Use RPC/bootparam/whoami to get our hostname, * our IP address, and the server's IP address. * (3) Use RPC/bootparam/getfile to get the root path * (4) Use RPC/mountd to get the root file handle * (5) Use RPC/bootparam/getfile to get the swap path * (6) Use RPC/mountd to get the swap file handle * * (This happens to be the way Sun does it too.) */ /* bootparam RPC */ static int bp_whoami(struct sockaddr_in *bpsin, struct in_addr *my_ip, struct in_addr *gw_ip); static int bp_getfile(struct sockaddr_in *bpsin, char *key, struct sockaddr_in *mdsin, char *servname, char *path, int retries); /* mountd RPC */ static int md_mount(struct sockaddr_in *mdsin, char *path, struct nfs_args *argp); char *nfsbootdevname; /* * Called with an empty nfs_diskless struct to be filled in. */ int nfs_boot_init(struct nfs_diskless *nd, struct proc *procp) { struct ifreq ireq; struct in_aliasreq ifra; struct in_addr my_ip, gw_ip; struct sockaddr_in bp_sin; struct sockaddr_in *sin; struct ifnet *ifp; struct socket *so; struct ifaddr *ifa; char addr[INET_ADDRSTRLEN]; int error; /* * Find an interface, rarp for its ip address, stuff it, the * implied broadcast addr, and netmask into a nfs_diskless struct. * * This was moved here from nfs_vfsops.c because this procedure * would be quite different if someone decides to write (i.e.) a * BOOTP version of this file (might not use RARP, etc.) */ /* * Find a network interface. */ if (nfsbootdevname == NULL || (ifp = if_unit(nfsbootdevname)) == NULL) panic("nfs_boot: no suitable interface"); bcopy(ifp->if_xname, ireq.ifr_name, IFNAMSIZ); printf("nfs_boot: using interface %s, with revarp & bootparams\n", ireq.ifr_name); /* * Bring up the interface. * * Get the old interface flags and or IFF_UP into them; if * IFF_UP set blindly, interface selection can be clobbered. */ if ((error = socreate(AF_INET, &so, SOCK_DGRAM, 0)) != 0) panic("nfs_boot: socreate, error=%d", error); error = ifioctl(so, SIOCGIFFLAGS, (caddr_t)&ireq, procp); if (error) panic("nfs_boot: GIFFLAGS, error=%d", error); ireq.ifr_flags |= IFF_UP; error = ifioctl(so, SIOCSIFFLAGS, (caddr_t)&ireq, procp); if (error) panic("nfs_boot: SIFFLAGS, error=%d", error); /* * Do RARP for the interface address. */ if ((error = revarpwhoami(&my_ip, ifp)) != 0) panic("reverse arp not answered by rarpd(8) or dhcpd(8)"); inet_ntop(AF_INET, &my_ip, addr, sizeof(addr)); printf("nfs_boot: client_addr=%s\n", addr); /* * Do enough of ifconfig(8) so that the chosen interface * can talk to the servers. (just set the address) */ memset(&ifra, 0, sizeof(ifra)); bcopy(ifp->if_xname, ifra.ifra_name, sizeof(ifra.ifra_name)); sin = &ifra.ifra_addr; sin->sin_len = sizeof(*sin); sin->sin_family = AF_INET; sin->sin_addr.s_addr = my_ip.s_addr; error = ifioctl(so, SIOCAIFADDR, (caddr_t)&ifra, procp); if (error) panic("nfs_boot: set if addr, error=%d", error); soclose(so, 0); TAILQ_FOREACH(ifa, &ifp->if_addrlist, ifa_list) { if (ifa->ifa_addr->sa_family == AF_INET) break; } if (ifa == NULL) panic("nfs_boot: address not configured on %s", ifp->if_xname); if_put(ifp); /* * Get client name and gateway address. * RPC: bootparam/whoami * The server address returned by the WHOAMI call * is used for all subsequent bootparam RPCs. */ memset(&bp_sin, 0, sizeof(bp_sin)); bp_sin.sin_len = sizeof(bp_sin); bp_sin.sin_family = AF_INET; bp_sin.sin_addr.s_addr = ifatoia(ifa)->ia_broadaddr.sin_addr.s_addr; hostnamelen = MAXHOSTNAMELEN; /* this returns gateway IP address */ error = bp_whoami(&bp_sin, &my_ip, &gw_ip); if (error) panic("nfs_boot: bootparam whoami, error=%d", error); inet_ntop(AF_INET, &bp_sin.sin_addr, addr, sizeof(addr)); printf("nfs_boot: server_addr=%s hostname=%s\n", addr, hostname); bcopy(&bp_sin, &nd->nd_boot, sizeof(bp_sin)); return (0); } /* * bpsin: bootparam server * key: root or swap * ndmntp: output */ int nfs_boot_getfh(struct sockaddr_in *bpsin, char *key, struct nfs_dlmount *ndmntp, int retries) { struct nfs_args *args; char pathname[MAXPATHLEN]; char *sp, *dp, *endp; struct sockaddr_in *sin; int error; args = &ndmntp->ndm_args; /* Initialize mount args. */ memset(args, 0, sizeof(*args)); args->addr = sintosa(&ndmntp->ndm_saddr); args->addrlen = args->addr->sa_len; args->sotype = SOCK_DGRAM; args->fh = ndmntp->ndm_fh; args->hostname = ndmntp->ndm_host; args->flags = NFSMNT_NFSV3; #ifdef NFS_BOOT_OPTIONS args->flags |= NFS_BOOT_OPTIONS; #endif #ifdef NFS_BOOT_RWSIZE /* * Reduce rsize,wsize for interfaces that consistently * drop fragments of long UDP messages. (i.e. wd8003). * You can always change these later via remount. */ args->flags |= NFSMNT_WSIZE | NFSMNT_RSIZE; args->wsize = NFS_BOOT_RWSIZE; args->rsize = NFS_BOOT_RWSIZE; #endif sin = &ndmntp->ndm_saddr; /* * Get server:pathname for "key" (root or swap) * using RPC to bootparam/getfile */ error = bp_getfile(bpsin, key, sin, ndmntp->ndm_host, pathname, retries); if (error) { printf("nfs_boot: bootparam get %s: %d\n", key, error); return (error); } /* * Get file handle for "key" (root or swap) * using RPC to mountd/mount */ error = md_mount(sin, pathname, args); if (error) { printf("nfs_boot: mountd %s, error=%d\n", key, error); return (error); } /* Set port number for NFS use. */ /* XXX: NFS port is always 2049, right? */ error = krpc_portmap(sin, NFS_PROG, (args->flags & NFSMNT_NFSV3) ? NFS_VER3 : NFS_VER2, &sin->sin_port); if (error) { printf("nfs_boot: portmap NFS, error=%d\n", error); return (error); } /* Construct remote path (for getmntinfo(3)) */ dp = ndmntp->ndm_host; endp = dp + MNAMELEN - 1; dp += strlen(dp); *dp++ = ':'; for (sp = pathname; *sp && dp < endp;) *dp++ = *sp++; *dp = '\0'; return (0); } /* * RPC: bootparam/whoami * Given client IP address, get: * client name (hostname) * domain name (domainname) * gateway address * * The hostname and domainname are set here for convenience. * * Note - bpsin is initialized to the broadcast address, * and will be replaced with the bootparam server address * after this call is complete. Have to use PMAP_PROC_CALL * to make sure we get responses only from a servers that * know about us (don't want to broadcast a getport call). */ static int bp_whoami(struct sockaddr_in *bpsin, struct in_addr *my_ip, struct in_addr *gw_ip) { /* RPC structures for PMAPPROC_CALLIT */ struct whoami_call { u_int32_t call_prog; u_int32_t call_vers; u_int32_t call_proc; u_int32_t call_arglen; } *call; struct callit_reply { u_int32_t port; u_int32_t encap_len; /* encapsulated data here */ } *reply; struct mbuf *m, *from; struct sockaddr_in *sin; int error, msg_len; int16_t port; /* * Build request message for PMAPPROC_CALLIT. */ m = m_get(M_WAIT, MT_DATA); call = mtod(m, struct whoami_call *); m->m_len = sizeof(*call); call->call_prog = txdr_unsigned(BOOTPARAM_PROG); call->call_vers = txdr_unsigned(BOOTPARAM_VERS); call->call_proc = txdr_unsigned(BOOTPARAM_WHOAMI); /* * append encapsulated data (client IP address) */ m->m_next = xdr_inaddr_encode(my_ip); call->call_arglen = txdr_unsigned(m->m_next->m_len); /* RPC: portmap/callit */ bpsin->sin_port = htons(PMAPPORT); from = NULL; error = krpc_call(bpsin, PMAPPROG, PMAPVERS, PMAPPROC_CALLIT, &m, &from, -1); if (error) return error; /* * Parse result message. */ if (m->m_len < sizeof(*reply)) { m = m_pullup(m, sizeof(*reply)); if (m == NULL) goto bad; } reply = mtod(m, struct callit_reply *); port = fxdr_unsigned(u_int32_t, reply->port); msg_len = fxdr_unsigned(u_int32_t, reply->encap_len); m_adj(m, sizeof(*reply)); /* * Save bootparam server address */ sin = mtod(from, struct sockaddr_in *); bpsin->sin_port = htons(port); bpsin->sin_addr.s_addr = sin->sin_addr.s_addr; /* client name */ hostnamelen = MAXHOSTNAMELEN-1; m = xdr_string_decode(m, hostname, &hostnamelen); if (m == NULL) goto bad; /* domain name */ domainnamelen = MAXHOSTNAMELEN-1; m = xdr_string_decode(m, domainname, &domainnamelen); if (m == NULL) goto bad; /* gateway address */ m = xdr_inaddr_decode(m, gw_ip); if (m == NULL) goto bad; /* success */ goto out; bad: printf("nfs_boot: bootparam_whoami: bad reply\n"); error = EBADRPC; out: m_freem(from); m_freem(m); return(error); } /* * RPC: bootparam/getfile * Given client name and file "key", get: * server name * server IP address * server pathname */ static int bp_getfile(struct sockaddr_in *bpsin, char *key, struct sockaddr_in *md_sin, char *serv_name, char *pathname, int retries) { struct mbuf *m; struct sockaddr_in *sin; struct in_addr inaddr; int error, sn_len, path_len; /* * Build request message. */ /* client name (hostname) */ m = xdr_string_encode(hostname, hostnamelen); if (m == NULL) return (ENOMEM); /* key name (root or swap) */ m->m_next = xdr_string_encode(key, strlen(key)); if (m->m_next == NULL) { m_freem(m); return (ENOMEM); } /* RPC: bootparam/getfile */ error = krpc_call(bpsin, BOOTPARAM_PROG, BOOTPARAM_VERS, BOOTPARAM_GETFILE, &m, NULL, retries); if (error) return error; /* * Parse result message. */ /* server name */ sn_len = MNAMELEN-1; m = xdr_string_decode(m, serv_name, &sn_len); if (m == NULL) goto bad; /* server IP address (mountd/NFS) */ m = xdr_inaddr_decode(m, &inaddr); if (m == NULL) goto bad; /* server pathname */ path_len = MAXPATHLEN-1; m = xdr_string_decode(m, pathname, &path_len); if (m == NULL) goto bad; /* setup server socket address */ sin = md_sin; memset(sin, 0, sizeof(*sin)); sin->sin_len = sizeof(*sin); sin->sin_family = AF_INET; sin->sin_addr = inaddr; /* success */ goto out; bad: printf("nfs_boot: bootparam_getfile: bad reply\n"); error = EBADRPC; out: m_freem(m); return(error); } /* * RPC: mountd/mount * Given a server pathname, get an NFS file handle. * Also, sets sin->sin_port to the NFS service port. * mdsin: mountd server address */ static int md_mount(struct sockaddr_in *mdsin, char *path, struct nfs_args *argp) { /* The RPC structures */ struct rdata { u_int32_t errno; union { u_int8_t v2fh[NFSX_V2FH]; struct { u_int32_t fhlen; u_int8_t fh[1]; } v3fh; } fh; } *rdata; struct mbuf *m; u_int8_t *fh; int minlen, error; int mntver; mntver = (argp->flags & NFSMNT_NFSV3) ? 3 : 2; do { error = krpc_portmap(mdsin, RPCPROG_MNT, mntver, &mdsin->sin_port); if (error) continue; m = xdr_string_encode(path, strlen(path)); if (m == NULL) return ENOMEM; /* Do RPC to mountd. */ error = krpc_call(mdsin, RPCPROG_MNT, mntver, RPCMNT_MOUNT, &m, NULL, -1); if (error != EPROGMISMATCH) break; /* Try lower version of mountd. */ } while (--mntver >= 1); if (error) return error; /* message already freed */ if (mntver != 3) argp->flags &= ~NFSMNT_NFSV3; /* The reply might have only the errno. */ if (m->m_len < 4) goto bad; /* Have at least errno, so check that. */ rdata = mtod(m, struct rdata *); error = fxdr_unsigned(u_int32_t, rdata->errno); if (error) goto out; /* Have errno==0, so the fh must be there. */ if (mntver == 3) { argp->fhsize = fxdr_unsigned(u_int32_t, rdata->fh.v3fh.fhlen); if (argp->fhsize > NFSX_V3FHMAX) goto bad; minlen = 2 * sizeof(u_int32_t) + argp->fhsize; } else { argp->fhsize = NFSX_V2FH; minlen = sizeof(u_int32_t) + argp->fhsize; } if (m->m_len < minlen) { m = m_pullup(m, minlen); if (m == NULL) return (EBADRPC); rdata = mtod(m, struct rdata *); } fh = (mntver == 3) ? rdata->fh.v3fh.fh : rdata->fh.v2fh; bcopy(fh, argp->fh, argp->fhsize); goto out; bad: error = EBADRPC; out: m_freem(m); return error; } #endif /* ifdef NFSCLIENT */