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