1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #pragma ident "%Z%%M% %I% %E% SMI"
27
28 #include <sys/param.h>
29 #include <sys/types.h>
30 #include <sys/systm.h>
31 #include <sys/cred.h>
32 #include <sys/user.h>
33 #include <sys/file.h>
34 #include <sys/stream.h>
35 #include <sys/strsubr.h>
36 #include <sys/stropts.h>
37 #include <sys/strsun.h>
38 #include <sys/debug.h>
39 #include <sys/tiuser.h>
40 #include <sys/sockio.h>
41 #include <sys/socket.h>
42 #include <sys/t_kuser.h>
43 #include <sys/utsname.h>
44 #include <sys/systeminfo.h>
45 #include <sys/netconfig.h>
46 #include <sys/ethernet.h>
47 #include <sys/dlpi.h>
48 #include <sys/vfs.h>
49 #include <sys/sysmacros.h>
50 #include <sys/bootconf.h>
51 #include <sys/bootprops.h>
52 #include <sys/cmn_err.h>
53 #include <sys/promif.h>
54 #include <sys/mount.h>
55
56 #include <net/if.h>
57 #include <net/route.h>
58
59 #include <netinet/in.h>
60 #include <netinet/arp.h>
61 #include <netinet/dhcp.h>
62 #include <netinet/inetutil.h>
63 #include <dhcp_impl.h>
64 #include <sys/sunos_dhcp_class.h>
65
66 #include <rpc/types.h>
67 #include <rpc/rpc.h>
68 #include <rpc/xdr.h>
69 #include <rpc/auth.h>
70 #include <rpc/clnt.h>
71 #include <rpc/pmap_clnt.h>
72 #include <rpc/pmap_rmt.h>
73 #include <rpc/pmap_prot.h>
74 #include <rpc/bootparam.h>
75 #include <rpc/rpcb_prot.h>
76
77 #include <nfs/nfs.h>
78 #include <nfs/nfs4.h>
79 #include <nfs/nfs_clnt.h>
80 #include <nfs/mount.h>
81 #include <sys/mntent.h>
82
83 #include <sys/kstr.h>
84 #include <sys/sunddi.h>
85 #include <sys/sunldi.h>
86 #include <sys/esunddi.h>
87
88 #include <sys/errno.h>
89 #include <sys/modctl.h>
90
91 /*
92 * RPC timers and retries
93 */
94 #define PMAP_RETRIES 5
95 #define DEFAULT_RETRIES 3
96 #define GETFILE_RETRIES 2
97
98 #define DEFAULT_TIMEO 3
99 #define WHOAMI_TIMEO 20
100 #define REVARP_TIMEO 5
101 #define GETFILE_TIMEO 1
102
103 /*
104 * These are from the rpcgen'd version of mount.h XXX
105 */
106 #define MOUNTPROG 100005
107 #define MOUNTPROC_MNT 1
108 #define MOUNTVERS 1
109 #define MOUNTVERS_POSIX 2
110 #define MOUNTVERS3 3
111
112 struct fhstatus {
113 int fhs_status;
114 fhandle_t fhs_fh;
115 };
116
117 #define FHSIZE3 64
118
119 struct fhandle3 {
120 uint_t fhandle3_len;
121 char *fhandle3_val;
122 };
123
124 enum mountstat3 {
125 MNT_OK = 0,
126 MNT3ERR_PERM = 1,
127 MNT3ERR_NOENT = 2,
128 MNT3ERR_IO = 5,
129 MNT3ERR_ACCES = 13,
130 MNT3ERR_NOTDIR = 20,
131 MNT3ERR_INVAL = 22,
132 MNT3ERR_NAMETOOLONG = 63,
133 MNT3ERR_NOTSUPP = 10004,
134 MNT3ERR_SERVERFAULT = 10006
135 };
136
137 struct mountres3_ok {
138 struct fhandle3 fhandle;
139 struct {
140 uint_t auth_flavors_len;
141 int *auth_flavors_val;
142 } auth_flavors;
143 };
144
145 struct mountres3 {
146 enum mountstat3 fhs_status;
147 union {
148 struct mountres3_ok mountinfo;
149 } mountres3_u;
150 };
151
152 /*
153 * DLPI address format.
154 */
155 struct dladdr {
156 uchar_t dl_phys[6];
157 ushort_t dl_sap;
158 };
159
160 static struct modlmisc modlmisc = {
161 &mod_miscops, "Boot diskless"
162 };
163
164 static struct modlinkage modlinkage = {
165 MODREV_1, (void *)&modlmisc, NULL
166 };
167
168 static int dldebug;
169
170 int
171 _init(void)
172 {
173 return (mod_install(&modlinkage));
174 }
175
176 int
177 _fini(void)
178 {
179 return (mod_remove(&modlinkage));
180 }
181
182 int
183 _info(struct modinfo *modinfop)
184 {
185 return (mod_info(&modlinkage, modinfop));
186 }
187
188
189 static enum clnt_stat pmap_rmt_call(struct knetconfig *, struct netbuf *,
190 bool_t, rpcprog_t, rpcvers_t, rpcproc_t, xdrproc_t,
191 caddr_t, xdrproc_t, caddr_t, struct timeval,
192 struct netbuf *);
193 static bool_t myxdr_rmtcall_args(XDR *, struct rmtcallargs *);
194 static bool_t myxdr_rmtcallres(XDR *, struct rmtcallres *);
195 static bool_t myxdr_pmap(XDR *, struct pmap *);
196 static bool_t myxdr_fhstatus(XDR *xdrs, struct fhstatus *fhsp);
197 static bool_t myxdr_fhandle(XDR *xdrs, fhandle_t *fh);
198 static bool_t myxdr_mountres3(XDR *xdrs, struct mountres3 *objp);
199 static bool_t myxdr_mountstat3(XDR *xdrs, enum mountstat3 *objp);
200 static bool_t myxdr_mountres3_ok(XDR *xdrs,
201 struct mountres3_ok *objp);
202 static bool_t myxdr_fhandle3(XDR *xdrs, struct fhandle3 *objp);
203 static enum clnt_stat pmap_kgetport(struct knetconfig *, struct netbuf *,
204 rpcprog_t, rpcvers_t, rpcprot_t);
205 static enum clnt_stat mycallrpc(struct knetconfig *, struct netbuf *,
206 rpcprog_t, rpcvers_t, rpcproc_t, xdrproc_t,
207 char *, xdrproc_t, char *, int, int);
208 static int ifioctl(TIUSER *, int, struct netbuf *);
209 static int getfile(char *, char *, struct netbuf *, char *);
210 static int ping_prog(struct netbuf *, uint_t prog, uint_t vers,
211 int proto, enum clnt_stat *);
212 static int mountnfs(struct netbuf *, char *, char *,
213 fhandle_t *, int *);
214 static int mountnfs3(struct netbuf *, char *, char *,
215 nfs_fh3 *, int *);
216 static int init_mountopts(struct nfs_args *, int,
217 struct knetconfig **, int *);
218 static int revarp_myaddr(TIUSER *);
219 static void revarp_start(ldi_handle_t, struct netbuf *);
220 static void revarpinput(ldi_handle_t, struct netbuf *);
221 static void init_netbuf(struct netbuf *);
222 static void free_netbuf(struct netbuf *);
223 static int rtioctl(TIUSER *, int, struct rtentry *);
224 static void init_config(void);
225
226 static void cacheinit(void);
227 static int cacheinfo(char *, int, struct netbuf *, char *, int);
228 static int dlifconfig(TIUSER *, struct in_addr *, struct in_addr *,
229 struct in_addr *, uint_t);
230 static int setifflags(TIUSER *, uint_t);
231
232 static char *inet_ntoa(struct in_addr);
233 static int inet_aton(char *, uchar_t *);
234 static int isdigit(int);
235
236 /*
237 * Should be in some common
238 * ethernet source file.
239 */
240 static struct ether_addr etherbroadcastaddr = {
241 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
242 };
243
244 static struct ether_addr myether;
245
246 /*
247 * "ifname" is the interface name/unit as read from the boot
248 * arguments.
249 * "ndev" is the major device number of the network interface
250 * used to boot from.
251 * "ifunit" it the physical point of attachment for the network
252 * interface used to boot from.
253 *
254 * Both of these are initialized in "init_config()".
255 */
256
257 static char ifname[IFNAMSIZ];
258 static char ndev_path[MAXPATHLEN];
259 static int ifunit;
260
261 /*
262 * XXX these should be shared
263 */
264 static struct knetconfig dl_udp_netconf = {
265 NC_TPI_CLTS, /* semantics */
266 NC_INET, /* family */
267 NC_UDP, /* protocol */
268 0, /* device */
269 };
270
271 static struct knetconfig dl_tcp_netconf = {
272 NC_TPI_COTS, /* semantics */
273 NC_INET, /* family */
274 NC_TCP, /* protocol */
275 0, /* device */
276 };
277
278 /* parameters from DHCP or bootparamd */
279 static PKT_LIST *pl = NULL;
280 static uchar_t server_ip[4];
281 static uchar_t dhcp_server_ip[4];
282 static char *server_name_c, *server_path_c;
283 static char rootopts[256];
284
285 /*
286 * XXX Until we get the nfsmapid deadlocks all fixed, don't allow
287 * XXX a v4 root mount.
288 */
289 int nfs4_no_diskless_root_support = 1;
290
291 int
292 mount_root(char *name, char *path, int version, struct nfs_args *args,
293 int *vfsflags)
294 {
295 int rc;
296 int proto;
297 struct knetconfig *dl_cf;
298 static int init_done = 0;
299 enum clnt_stat stat;
300
301 if (dldebug)
302 printf("mount_root: name=%s\n", name);
303
304 if (init_done == 0) {
305 init_config();
306 init_done = 1;
307 }
308
309 init_netbuf(args->addr);
310
311 do {
312 rc = getfile(name, args->hostname, args->addr, path);
313 } while (rc == ETIMEDOUT);
314
315 if (rc) {
316 free_netbuf(args->addr);
317 return (rc);
318 }
319
320 ASSERT(args->knconf->knc_protofmly != NULL);
321 ASSERT(args->knconf->knc_proto != NULL);
322
323 switch (version) {
324 case NFS_VERSION:
325 rc = mountnfs(args->addr, args->hostname, path,
326 (fhandle_t *)args->fh, &proto);
327 break;
328 case NFS_V3:
329 rc = mountnfs3(args->addr, args->hostname, path,
330 (nfs_fh3 *)args->fh, &proto);
331 break;
332 case NFS_V4:
333 ((struct sockaddr_in *)args->addr->buf)->sin_port =
334 htons(NFS_PORT);
335 if (ping_prog(args->addr, NFS_PROGRAM, NFS_V4, IPPROTO_TCP,
336 &stat)) {
337 proto = IPPROTO_TCP;
338 rc = 0;
339 } else {
340 switch (stat) {
341 case RPC_PROGVERSMISMATCH:
342 case RPC_XPRTFAILED:
343 /*
344 * Common failures if v4 unsupported or no TCP
345 */
346 rc = EPROTONOSUPPORT;
347 break;
348 default:
349 rc = ENXIO;
350 }
351 }
352 if (nfs4_no_diskless_root_support)
353 rc = EPROTONOSUPPORT;
354 break;
355 default:
356 rc = EPROTONOSUPPORT;
357 break;
358 }
359
360 if (rc)
361 goto errout;
362
363 switch (proto) {
364 case IPPROTO_TCP:
365 dl_cf = &dl_tcp_netconf;
366 break;
367 case IPPROTO_UDP:
368 default:
369 dl_cf = &dl_udp_netconf;
370 break;
371 }
372
373 rc = init_mountopts(args, version, &dl_cf, vfsflags);
374
375 /*
376 * Copy knetconfig information from the template, note that the
377 * rdev field has been set by init_config above.
378 */
379 args->knconf->knc_semantics = dl_cf->knc_semantics;
380 args->knconf->knc_rdev = dl_cf->knc_rdev;
381 (void) strcpy(args->knconf->knc_protofmly, dl_cf->knc_protofmly);
382 (void) strcpy(args->knconf->knc_proto, dl_cf->knc_proto);
383
384 errout:
385 if (dldebug) {
386 if (rc)
387 nfs_perror(rc, "mount_root: mount %s:%s failed: %m\n",
388 args->hostname, path);
389 else
390 printf("mount_root: leaving\n");
391 }
392
393 return (rc);
394 }
395
396 /*
397 * Call mount daemon on server `sa' to mount path.
398 * `port' is set to nfs port and fh is the fhandle
399 * returned from the server.
400 */
401 static int
402 mountnfs(struct netbuf *sa, char *server,
403 char *path, fhandle_t *fh, int *proto)
404 {
405 struct fhstatus fhs;
406 enum clnt_stat stat;
407
408 if (dldebug)
409 printf("mountnfs: entered\n");
410
411 /*
412 * Get the port number for the mount program.
413 * pmap_kgetport first tries a SunOS portmapper
414 * and, if no reply is received, will try a
415 * SVR4 rpcbind. Either way, `sa' is set to
416 * the correct address.
417 */
418 do {
419 stat = pmap_kgetport(&dl_udp_netconf, sa, (rpcprog_t)MOUNTPROG,
420 (rpcvers_t)MOUNTVERS, (rpcprot_t)IPPROTO_UDP);
421
422 if (stat == RPC_TIMEDOUT) {
423 cmn_err(CE_WARN,
424 "mountnfs: %s:%s portmap not responding",
425 server, path);
426 } else if (stat != RPC_SUCCESS) {
427 cmn_err(CE_WARN,
428 "mountnfs: pmap_kgetport RPC error %d (%s).",
429 stat, clnt_sperrno(stat));
430 return (ENXIO); /* XXX */
431 }
432 } while (stat == RPC_TIMEDOUT);
433
434 /*
435 * The correct port number has been
436 * put into `sa' by pmap_kgetport().
437 */
438 do {
439 stat = mycallrpc(&dl_udp_netconf, sa, (rpcprog_t)MOUNTPROG,
440 (rpcvers_t)MOUNTVERS, (rpcproc_t)MOUNTPROC_MNT,
441 xdr_bp_path_t, (char *)&path,
442 myxdr_fhstatus, (char *)&fhs,
443 DEFAULT_TIMEO, DEFAULT_RETRIES);
444 if (stat == RPC_TIMEDOUT) {
445 cmn_err(CE_WARN,
446 "mountnfs: %s:%s mount server not responding",
447 server, path);
448 }
449 } while (stat == RPC_TIMEDOUT);
450
451 if (stat != RPC_SUCCESS) {
452 cmn_err(CE_WARN, "mountnfs: RPC failed: error %d (%s).",
453 stat, clnt_sperrno(stat));
454 return (ENXIO); /* XXX */
455 }
456
457 ((struct sockaddr_in *)sa->buf)->sin_port = htons(NFS_PORT);
458
459 *fh = fhs.fhs_fh;
460 if (fhs.fhs_status != 0) {
461 if (dldebug)
462 printf("mountnfs: fhs_status %d\n", fhs.fhs_status);
463 return (ENXIO); /* XXX */
464 }
465
466 *proto = IPPROTO_UDP;
467
468 if (ping_prog(sa, NFS_PROGRAM, NFS_VERSION, IPPROTO_TCP, NULL))
469 *proto = IPPROTO_TCP;
470
471 if (dldebug)
472 printf("mountnfs: leaving\n");
473 return (0);
474 }
475
476 /*
477 * Call mount daemon on server `sa' to mount path.
478 * `port' is set to nfs port and fh is the fhandle
479 * returned from the server.
480 */
481 static int
482 mountnfs3(struct netbuf *sa, char *server,
483 char *path, nfs_fh3 *fh, int *proto)
484 {
485 struct mountres3 mountres3;
486 enum clnt_stat stat;
487 int ret = 0;
488
489 if (dldebug)
490 printf("mountnfs3: entered\n");
491
492 /*
493 * Get the port number for the mount program.
494 * pmap_kgetport first tries a SunOS portmapper
495 * and, if no reply is received, will try a
496 * SVR4 rpcbind. Either way, `sa' is set to
497 * the correct address.
498 */
499 do {
500 stat = pmap_kgetport(&dl_udp_netconf, sa, (rpcprog_t)MOUNTPROG,
501 (rpcvers_t)MOUNTVERS3, (rpcprot_t)IPPROTO_UDP);
502
503 if (stat == RPC_PROGVERSMISMATCH) {
504 if (dldebug)
505 printf("mountnfs3: program/version mismatch\n");
506 return (EPROTONOSUPPORT); /* XXX */
507 } else if (stat == RPC_TIMEDOUT) {
508 cmn_err(CE_WARN,
509 "mountnfs3: %s:%s portmap not responding",
510 server, path);
511 } else if (stat != RPC_SUCCESS) {
512 cmn_err(CE_WARN,
513 "mountnfs3: pmap_kgetport RPC error %d (%s).",
514 stat, clnt_sperrno(stat));
515 return (ENXIO); /* XXX */
516 }
517 } while (stat == RPC_TIMEDOUT);
518
519 mountres3.mountres3_u.mountinfo.fhandle.fhandle3_val = NULL;
520 mountres3.mountres3_u.mountinfo.auth_flavors.auth_flavors_val = NULL;
521
522 /*
523 * The correct port number has been
524 * put into `sa' by pmap_kgetport().
525 */
526 do {
527 stat = mycallrpc(&dl_udp_netconf, sa, (rpcprog_t)MOUNTPROG,
528 (rpcvers_t)MOUNTVERS3, (rpcproc_t)MOUNTPROC_MNT,
529 xdr_bp_path_t, (char *)&path,
530 myxdr_mountres3, (char *)&mountres3,
531 DEFAULT_TIMEO, DEFAULT_RETRIES);
532 if (stat == RPC_TIMEDOUT) {
533 cmn_err(CE_WARN,
534 "mountnfs3: %s:%s mount server not responding",
535 server, path);
536 }
537 } while (stat == RPC_TIMEDOUT);
538
539 if (stat == RPC_PROGVERSMISMATCH) {
540 if (dldebug)
541 printf("mountnfs3: program/version mismatch\n");
542 ret = EPROTONOSUPPORT;
543 goto out;
544 }
545 if (stat != RPC_SUCCESS) {
546 cmn_err(CE_WARN, "mountnfs3: RPC failed: error %d (%s).",
547 stat, clnt_sperrno(stat));
548 ret = ENXIO; /* XXX */
549 goto out;
550 }
551
552 if (mountres3.fhs_status != MNT_OK) {
553 if (dldebug)
554 printf("mountnfs3: fhs_status %d\n",
555 mountres3.fhs_status);
556 ret = ENXIO; /* XXX */
557 goto out;
558 }
559
560 ((struct sockaddr_in *)sa->buf)->sin_port = htons(NFS_PORT);
561
562 *proto = IPPROTO_UDP;
563
564 if (ping_prog(sa, NFS_PROGRAM, NFS_V3, IPPROTO_TCP, NULL)) {
565 *proto = IPPROTO_TCP;
566 }
567
568 fh->fh3_length = mountres3.mountres3_u.mountinfo.fhandle.fhandle3_len;
569 bcopy(mountres3.mountres3_u.mountinfo.fhandle.fhandle3_val,
570 fh->fh3_u.data, fh->fh3_length);
571
572 out:
573 xdr_free(myxdr_mountres3, (caddr_t)&mountres3);
574
575 if (dldebug)
576 printf("mountnfs3: leaving\n");
577 return (ret);
578 }
579
580 static int
581 ping_prog(struct netbuf *call_addr, uint_t prog, uint_t vers, int proto,
582 enum clnt_stat *statp)
583 {
584 struct knetconfig *knconf;
585 enum clnt_stat stat;
586 int retries = DEFAULT_RETRIES;
587
588 switch (proto) {
589 case IPPROTO_TCP:
590 knconf = &dl_tcp_netconf;
591 break;
592 case IPPROTO_UDP:
593 knconf = &dl_udp_netconf;
594 break;
595 default:
596 return (0);
597 }
598
599 do {
600 stat = mycallrpc(knconf, call_addr, prog, vers, NULLPROC,
601 xdr_void, NULL, xdr_void, NULL,
602 DEFAULT_TIMEO, DEFAULT_RETRIES);
603
604 if (dldebug)
605 printf("ping_prog: %d return %d (%s)\n", proto, stat,
606 clnt_sperrno(stat));
607 /*
608 * Special case for TCP, it may "timeout" because it failed
609 * to establish an initial connection but it doesn't
610 * actually retry, so we do the retry.
611 * Persistence pays in diskless.
612 */
613 } while (stat == RPC_TIMEDOUT && proto == IPPROTO_TCP && retries--);
614
615 if (statp != NULL)
616 *statp = stat;
617
618 if (stat != RPC_SUCCESS)
619 return (0);
620 return (1);
621 }
622
623 static struct netbuf bootparam_addr;
624
625 /*
626 * Returns after filling in the following global variables:
627 * bootparam_addr,
628 * utsname.nodename,
629 * srpc_domain.
630 */
631 static int
632 whoami(void)
633 {
634 TIUSER *tiptr;
635 struct netbuf sa;
636 struct netbuf req;
637 struct bp_whoami_arg arg;
638 struct bp_whoami_res res;
639 struct timeval tv;
640 enum clnt_stat stat;
641 int rc;
642 size_t namelen;
643 int printed_waiting_msg;
644
645 if ((rc = t_kopen((file_t *)NULL, dl_udp_netconf.knc_rdev,
646 FREAD|FWRITE, &tiptr, CRED())) != 0) {
647 nfs_perror(rc, "whoami: t_kopen udp failed: %m.\n");
648 }
649
650 /*
651 * Find out our local (IP) address.
652 */
653 if (rc = revarp_myaddr(tiptr)) {
654 nfs_perror(rc, "whoami: revarp_myaddr failed: %m.\n");
655 (void) t_kclose(tiptr, 0);
656 return (rc);
657 }
658
659 /* explicitly use the limited broadcast address */
660 init_netbuf(&sa);
661 ((struct sockaddr_in *)sa.buf)->sin_family = AF_INET;
662 ((struct sockaddr_in *)sa.buf)->sin_addr.s_addr =
663 htonl(INADDR_BROADCAST);
664 sa.len = sizeof (struct sockaddr_in);
665
666 /*
667 * Pick up our local (IP) address.
668 */
669 init_netbuf(&req);
670 if (rc = ifioctl(tiptr, SIOCGIFADDR, &req)) {
671 nfs_perror(rc,
672 "whoami: couldn't get my IP address: %m.\n");
673 free_netbuf(&sa);
674 free_netbuf(&req);
675 (void) t_kclose(tiptr, 0);
676 return (rc);
677 }
678
679 /*
680 * Set up the arguments expected by bootparamd.
681 */
682 arg.client_address.address_type = IP_ADDR_TYPE;
683 bcopy(&((struct sockaddr_in *)req.buf)->sin_addr,
684 &arg.client_address.bp_address.ip_addr, sizeof (struct in_addr));
685
686 free_netbuf(&req);
687
688 init_netbuf(&bootparam_addr);
689
690 /*
691 * Initial retransmission interval
692 */
693 tv.tv_sec = DEFAULT_TIMEO;
694 tv.tv_usec = 0;
695 res.client_name = kmem_alloc(MAX_MACHINE_NAME + 1, KM_SLEEP);
696 res.domain_name = kmem_alloc(MAX_MACHINE_NAME + 1, KM_SLEEP);
697
698 /*
699 * Do a broadcast call to find a bootparam daemon that
700 * will tell us our hostname, domainname and any
701 * router that we have to use to talk to our NFS server.
702 */
703 printed_waiting_msg = 0;
704 do {
705 /*
706 * pmap_rmt_call will first try the SunOS portmapper
707 * and if no reply is received will then try the SVR4
708 * rpcbind.
709 * Either way, `bootparam_addr' will be set to the
710 * correct address for the bootparamd that responds.
711 */
712 stat = pmap_rmt_call(&dl_udp_netconf, &sa, TRUE, BOOTPARAMPROG,
713 BOOTPARAMVERS, BOOTPARAMPROC_WHOAMI,
714 xdr_bp_whoami_arg, (caddr_t)&arg,
715 xdr_bp_whoami_res, (caddr_t)&res,
716 tv, &bootparam_addr);
717 if (stat == RPC_TIMEDOUT && !printed_waiting_msg) {
718 cmn_err(CE_WARN,
719 "No bootparam server responding; still trying");
720 printed_waiting_msg = 1;
721 }
722 /*
723 * Retransmission interval for second and subsequent tries.
724 * We expect first pmap_rmt_call to retransmit and backoff to
725 * at least this value.
726 */
727 tv.tv_sec = WHOAMI_TIMEO;
728 tv.tv_usec = 0;
729 } while (stat == RPC_TIMEDOUT);
730
731 if (printed_waiting_msg)
732 printf("Bootparam response received\n");
733
734 if (stat != RPC_SUCCESS) {
735 /* XXX should get real error here */
736 rc = ENXIO;
737 cmn_err(CE_WARN,
738 "whoami: bootparam RPC failed: error %d (%s).",
739 stat, clnt_sperrno(stat));
740 goto done;
741 }
742
743 namelen = strlen(res.client_name);
744 if (namelen > sizeof (utsname.nodename)) {
745 printf("whoami: hostname too long");
746 rc = ENAMETOOLONG;
747 goto done;
748 }
749 if (namelen != 0) {
750 bcopy(res.client_name, &utsname.nodename, namelen);
751 cmn_err(CE_CONT, "?hostname: %s\n", utsname.nodename);
752 } else {
753 printf("whoami: no host name\n");
754 rc = ENXIO;
755 goto done;
756 }
757
758 namelen = strlen(res.domain_name);
759 if (namelen != 0) {
760 if (namelen > SYS_NMLN) {
761 printf("whoami: domainname too long");
762 rc = ENAMETOOLONG;
763 goto done;
764 }
765 bcopy(res.domain_name, &srpc_domain, namelen);
766 cmn_err(CE_CONT, "?domainname: %s\n", srpc_domain);
767 } else {
768 printf("whoami: no domain name\n");
769 }
770
771 if (res.router_address.address_type == IP_ADDR_TYPE) {
772 struct rtentry rtentry;
773 struct sockaddr_in *sin;
774 struct in_addr ipaddr;
775
776 bcopy(&res.router_address.bp_address.ip_addr, &ipaddr,
777 sizeof (struct in_addr));
778
779 if (ipaddr.s_addr != (uint32_t)0) {
780 sin = (struct sockaddr_in *)&rtentry.rt_dst;
781 bzero(sin, sizeof (*sin));
782 sin->sin_family = AF_INET;
783
784 sin = (struct sockaddr_in *)&rtentry.rt_gateway;
785 bzero(sin, sizeof (*sin));
786 sin->sin_family = AF_INET;
787 sin->sin_addr.s_addr = ipaddr.s_addr;
788
789 rtentry.rt_flags = RTF_GATEWAY | RTF_UP;
790
791 if (rc = rtioctl(tiptr, SIOCADDRT, &rtentry)) {
792 nfs_perror(rc,
793 "whoami: couldn't add route: %m.\n");
794 goto done;
795 }
796 }
797 } else {
798 printf("whoami: unknown gateway addr family %d\n",
799 res.router_address.address_type);
800 }
801 done:
802 kmem_free(res.client_name, MAX_MACHINE_NAME + 1);
803 kmem_free(res.domain_name, MAX_MACHINE_NAME + 1);
804 free_netbuf(&sa);
805 (void) t_kclose(tiptr, 0);
806 return (rc);
807 }
808
809 /*
810 * Returns:
811 * 1) The ascii form of our root servers name in `server_name'.
812 * 2) Actual network address of our root server in `server_address'.
813 * 3) Whatever BOOTPARAMPROC_GETFILE returns for the fileid key, in
814 * `server_path'. If fileid is "root", it is the pathname of our
815 * root on the server.
816 */
817 static int
818 getfile(char *fileid,
819 char *server_name, struct netbuf *server_address, char *server_path)
820 {
821 struct bp_getfile_arg arg;
822 struct bp_getfile_res res;
823 enum clnt_stat stat;
824 int root = FALSE;
825 static int using_cache = FALSE;
826 struct in_addr ipaddr;
827 int timeo = DEFAULT_TIMEO;
828 int retries = DEFAULT_RETRIES;
829
830 if (dldebug)
831 printf("getfile: entered\n");
832
833 /*
834 * Call cacheinfo() to see whether we can satisfy this request by using
835 * the information cached in memory by the boot program's DHCP
836 * implementation or boot properties rather than consult BOOTPARAMS,
837 * but while preserving the semantics of getfile(). We know that
838 * the server name is SYS_NMLN in length, and server_path is
839 * MAXPATHLEN (pn_alloc).
840 */
841 if (strcmp(fileid, "root") == 0) {
842 if (cacheinfo(server_name, SYS_NMLN, server_address,
843 server_path, MAXPATHLEN) == 0) {
844 using_cache = TRUE;
845 return (0);
846 }
847 root = TRUE;
848 }
849
850 /*
851 * If using cache, rootopts is already available.
852 */
853 if (strcmp(fileid, "rootopts") == 0 && using_cache == TRUE) {
854 return (rootopts[0] != 0 ? 0 : ENXIO);
855 }
856
857 if (bootparam_addr.len == 0) {
858 return (ENXIO);
859 }
860 arg.client_name = (caddr_t)&utsname.nodename;
861 arg.file_id = fileid;
862
863 bzero(&res, sizeof (res));
864 res.server_name = kmem_alloc(MAX_MACHINE_NAME + 1, KM_SLEEP);
865 res.server_path = kmem_alloc(MAX_MACHINE_NAME + 1, KM_SLEEP);
866
867 /*
868 * If we are not looking up the root file, we are looking
869 * up a non-critical option that should timeout quickly.
870 */
871 if (!root) {
872 timeo = GETFILE_TIMEO;
873 retries = GETFILE_RETRIES;
874 }
875
876 /*
877 * bootparam_addr was filled in by the call to
878 * whoami(), so now send an rpc message to the
879 * bootparam daemon requesting our server information.
880 * Use UDP to talk to bootparms.
881 */
882 stat = mycallrpc(&dl_udp_netconf, &bootparam_addr,
883 (rpcprog_t)BOOTPARAMPROG, (rpcvers_t)BOOTPARAMVERS,
884 (rpcproc_t)BOOTPARAMPROC_GETFILE,
885 xdr_bp_getfile_arg, (caddr_t)&arg,
886 xdr_bp_getfile_res, (caddr_t)&res,
887 timeo, retries);
888
889 if (stat == RPC_SUCCESS) {
890 (void) strcpy(server_name, res.server_name);
891 (void) strcpy(server_path, res.server_path);
892 }
893
894 kmem_free(res.server_name, MAX_MACHINE_NAME + 1);
895 kmem_free(res.server_path, MAX_MACHINE_NAME + 1);
896
897 if (stat != RPC_SUCCESS) {
898 if (root)
899 cmn_err(CE_WARN, "getfile: RPC failed: error %d (%s).",
900 stat, clnt_sperrno(stat));
901 return ((stat == RPC_TIMEDOUT) ? ETIMEDOUT : ENXIO); /* XXX */
902 }
903
904 if (*server_path == '\0')
905 return (EINVAL);
906
907 /*
908 * If the fileid is "root", we must get back a server name, for
909 * other parameters a server name is not required
910 */
911 if (!root) {
912 if (dldebug)
913 printf("getfile: leaving: non-root\n");
914 return (0);
915 }
916
917 if (*server_name == '\0')
918 return (EINVAL);
919
920 switch (res.server_address.address_type) {
921 case IP_ADDR_TYPE:
922 /*
923 * server_address is where we will get our root
924 * from.
925 */
926 ((struct sockaddr_in *)server_address->buf)->sin_family =
927 AF_INET;
928 bcopy(&res.server_address.bp_address.ip_addr,
929 &ipaddr, sizeof (ipaddr));
930 if (ipaddr.s_addr == 0)
931 return (EINVAL);
932
933 ((struct sockaddr_in *)server_address->buf)->sin_addr.s_addr =
934 ipaddr.s_addr;
935 server_address->len = sizeof (struct sockaddr_in);
936 break;
937
938 default:
939 printf("getfile: unknown address type %d\n",
940 res.server_address.address_type);
941 return (EPROTONOSUPPORT);
942 }
943 if (dldebug)
944 printf("getfile: leaving\n");
945 return (0);
946 }
947
948 /*
949 * If the boot property "bootp-response" exists, then OBP performed a
950 * successful DHCP lease acquisition for us and left the resultant ACK packet
951 * encoded at that location.
952 *
953 * If no such property exists (or the information is incomplete or garbled),
954 * the function returns -1.
955 */
956 int
957 dhcpinit(void)
958 {
959 int rc, i;
960 char *p;
961 struct in_addr braddr;
962 struct in_addr subnet;
963 DHCP_OPT *doptp;
964 TIUSER *tiptr;
965 struct sockaddr_in *sin;
966 static int once_only = 0;
967
968 if (once_only == 1) {
969 return (0);
970 }
971 once_only = 1;
972
973 if (dhcack == NULL) {
974 return (-1);
975 }
976
977 if (dldebug) {
978 printf("dhcp: dhcack %p, len %d\n", (void *)dhcack,
979 dhcacklen);
980 }
981
982 pl = kmem_alloc(sizeof (PKT_LIST), KM_SLEEP);
983 pl->len = dhcacklen;
984 pl->pkt = kmem_alloc(pl->len, KM_SLEEP);
985 bcopy(dhcack, pl->pkt, dhcacklen);
986
987 /*
988 * For x86, ifname is not initialized
989 * in the netinstall case and dhcack interface name is
990 * set in strplumb(). So we only copy the name if ifname
991 * is set properly.
992 */
993 if (ifname[0])
994 (void) strlcpy(dhcifname, ifname, sizeof (dhcifname));
995
996 /* remember the server_ip in dhcack */
997 bcopy((uchar_t *)pl->pkt + 20, dhcp_server_ip, 4);
998 bzero(pl->opts, (DHCP_LAST_OPT + 1) * sizeof (DHCP_OPT *));
999 bzero(pl->vs, (VS_OPTION_END - VS_OPTION_START + 1) *
1000 sizeof (DHCP_OPT *));
1001
1002 if (dhcp_options_scan(pl, B_TRUE) != 0) {
1003 /* garbled packet */
1004 cmn_err(CE_WARN, "dhcp: DHCP packet parsing failed");
1005 kmem_free(pl->pkt, pl->len);
1006 kmem_free(pl, sizeof (PKT_LIST));
1007 pl = NULL;
1008 return (-1);
1009 }
1010
1011 /* set node name */
1012 if (pl->opts[CD_HOSTNAME] != NULL) {
1013 doptp = pl->opts[CD_HOSTNAME];
1014 i = doptp->len;
1015 if (i >= SYS_NMLN) {
1016 cmn_err(CE_WARN, "dhcp: Hostname is too long");
1017 } else {
1018 bcopy(doptp->value, utsname.nodename, i);
1019 utsname.nodename[i] = '\0';
1020 if (dldebug) {
1021 printf("hostname is %s\n",
1022 utsname.nodename);
1023 }
1024 }
1025 }
1026
1027 /* Set NIS domain name. */
1028 p = NULL;
1029 if (pl->opts[CD_NIS_DOMAIN] != NULL) {
1030 doptp = pl->opts[CD_NIS_DOMAIN];
1031 i = doptp->len;
1032 p = (caddr_t)doptp->value;
1033 }
1034 if (p != NULL) {
1035 if (i > SYS_NMLN) {
1036 cmn_err(CE_WARN,
1037 "dhcp: NIS domainname too long.");
1038 } else {
1039 bcopy(p, srpc_domain, i);
1040 srpc_domain[i] = '\0';
1041 if (dldebug)
1042 printf("dhcp: NIS domain name is %s\n",
1043 srpc_domain);
1044 }
1045 }
1046
1047 /* fetch netmask */
1048 if (pl->opts[CD_SUBNETMASK] != NULL) {
1049 doptp = pl->opts[CD_SUBNETMASK];
1050 if (doptp->len != sizeof (struct in_addr)) {
1051 pl->opts[CD_SUBNETMASK] = NULL;
1052 cmn_err(CE_WARN, "dhcp: netmask option malformed");
1053 } else {
1054 bcopy(doptp->value, &subnet, sizeof (struct in_addr));
1055 if (dldebug)
1056 printf("dhcp: setting netmask to: %s\n",
1057 inet_ntoa(subnet));
1058 }
1059 } else {
1060 struct in_addr myIPaddr;
1061
1062 myIPaddr.s_addr = pl->pkt->yiaddr.s_addr;
1063 cmn_err(CE_WARN, "dhcp: no subnet mask supplied - inferring");
1064 if (IN_CLASSA(ntohl(myIPaddr.s_addr)))
1065 subnet.s_addr = htonl(IN_CLASSA_NET);
1066 else if (IN_CLASSB(ntohl(myIPaddr.s_addr)))
1067 subnet.s_addr = htonl(IN_CLASSB_NET);
1068 else if (IN_CLASSC(ntohl(myIPaddr.s_addr)))
1069 subnet.s_addr = htonl(IN_CLASSC_NET);
1070 else if (IN_CLASSD(ntohl(myIPaddr.s_addr)))
1071 cmn_err(CE_WARN, "dhcp: bad IP address (%s)",
1072 inet_ntoa(myIPaddr));
1073 else
1074 subnet.s_addr = htonl(IN_CLASSE_NET);
1075 }
1076 /* and broadcast address */
1077 if (pl->opts[CD_BROADCASTADDR] != NULL) {
1078 doptp = pl->opts[CD_BROADCASTADDR];
1079 if (doptp->len != sizeof (struct in_addr)) {
1080 pl->opts[CD_BROADCASTADDR] = NULL;
1081 if (dldebug)
1082 printf("dhcp: broadcast address len %d\n",
1083 doptp->len);
1084 } else {
1085 bcopy(doptp->value, &braddr, sizeof (struct in_addr));
1086 if (dldebug)
1087 printf("dhcp: setting broadcast addr to: %s\n",
1088 inet_ntoa(braddr));
1089 }
1090 } else {
1091 if (dldebug)
1092 printf("dhcp: no broadcast address supplied\n");
1093 braddr.s_addr = htonl(INADDR_BROADCAST);
1094 }
1095 /* and plumb and initialize interface */
1096 if ((rc = t_kopen((file_t *)NULL, dl_udp_netconf.knc_rdev,
1097 FREAD|FWRITE, &tiptr, CRED())) == 0) {
1098 if (rc = dlifconfig(tiptr, &pl->pkt->yiaddr, &subnet,
1099 &braddr, IFF_DHCPRUNNING)) {
1100 nfs_perror(rc, "dhcp: dlifconfig failed: %m\n");
1101 kmem_free(pl->pkt, pl->len);
1102 kmem_free(pl, sizeof (PKT_LIST));
1103 pl = NULL;
1104 (void) t_kclose(tiptr, 0);
1105 return (-1);
1106 }
1107
1108 /* add routes */
1109 if (pl->opts[CD_ROUTER] != NULL) {
1110 doptp = pl->opts[CD_ROUTER];
1111 if ((doptp->len % sizeof (struct in_addr)) != 0) {
1112 pl->opts[CD_ROUTER] = NULL;
1113 } else {
1114 int nrouters;
1115 uchar_t *tp;
1116
1117 nrouters = doptp->len / sizeof (struct in_addr);
1118 for (tp = doptp->value, i = 0; i < nrouters;
1119 i++) {
1120 struct in_addr defr;
1121 struct rtentry rtentry;
1122
1123 bcopy(tp, &defr,
1124 sizeof (struct in_addr));
1125 if (defr.s_addr == 0)
1126 continue;
1127
1128 sin = (struct
1129 sockaddr_in *)&rtentry.rt_dst;
1130
1131 bzero(sin, sizeof (*sin));
1132 sin->sin_family = AF_INET;
1133
1134 sin = (struct
1135 sockaddr_in *)&rtentry.rt_gateway;
1136 bzero(sin, sizeof (*sin));
1137 sin->sin_family = AF_INET;
1138 sin->sin_addr = defr;
1139
1140 rtentry.rt_flags = RTF_GATEWAY | RTF_UP;
1141
1142 if (rc = rtioctl(tiptr, SIOCADDRT,
1143 &rtentry)) {
1144 nfs_perror(rc,
1145 "dhcp: couldn't add route "
1146 "to %s: %m.\n",
1147 inet_ntoa(defr));
1148 continue;
1149 }
1150 if (dldebug) {
1151 printf("dhcp: added route %s\n",
1152 inet_ntoa(defr));
1153 }
1154 tp += sizeof (struct in_addr);
1155 }
1156 }
1157 }
1158
1159 (void) t_kclose(tiptr, 0);
1160 }
1161
1162 if (dldebug)
1163 printf("dhcpinit: leaving\n");
1164
1165 return (0);
1166 }
1167
1168 /*
1169 * Initialize nfs mount info from properties and dhcp response.
1170 */
1171 static void
1172 cacheinit(void)
1173 {
1174 char *str;
1175 DHCP_OPT *doptp;
1176
1177 (void) ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(),
1178 DDI_PROP_DONTPASS, BP_SERVER_PATH, &server_path_c);
1179 (void) ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(),
1180 DDI_PROP_DONTPASS, BP_SERVER_NAME, &server_name_c);
1181 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(),
1182 DDI_PROP_DONTPASS, BP_SERVER_ROOTOPTS, &str) == DDI_SUCCESS) {
1183 (void) strncpy(rootopts, str, 255);
1184 ddi_prop_free(str);
1185 }
1186 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(),
1187 DDI_PROP_DONTPASS, BP_SERVER_IP, &str) == DDI_SUCCESS) {
1188 if (inet_aton(str, server_ip) != 0)
1189 cmn_err(CE_NOTE, "server_ipaddr %s is invalid\n",
1190 str);
1191 ddi_prop_free(str);
1192 if (dldebug)
1193 printf("server ip is %s\n",
1194 inet_ntoa(*(struct in_addr *)server_ip));
1195 }
1196
1197 if (pl == NULL)
1198 return;
1199
1200 /* extract root path in server_path */
1201 if (server_path_c == NULL) {
1202 doptp = pl->vs[VS_NFSMNT_ROOTPATH];
1203 if (doptp != NULL) {
1204 server_path_c = kmem_alloc(doptp->len + 1, KM_SLEEP);
1205 bcopy(doptp->value, server_path_c, doptp->len);
1206 server_path_c[doptp->len] = '\0';
1207 if (dldebug)
1208 printf("dhcp: root path %s\n", server_path_c);
1209 } else {
1210 cmn_err(CE_WARN, "dhcp: root server path missing");
1211 }
1212 }
1213
1214 /* set server_name */
1215 if (server_name_c == NULL) {
1216 doptp = pl->vs[VS_NFSMNT_ROOTSRVR_NAME];
1217 if (doptp != NULL) {
1218 server_name_c = kmem_alloc(doptp->len + 1, KM_SLEEP);
1219 bcopy(doptp->value, server_name_c, doptp->len);
1220 server_name_c[doptp->len] = '\0';
1221 if (dldebug)
1222 printf("dhcp: root server name %s\n",
1223 server_name_c);
1224 } else {
1225 cmn_err(CE_WARN, "dhcp: root server name missing");
1226 }
1227 }
1228
1229 /* set root server_address */
1230 if ((*(uint_t *)server_ip) == 0) {
1231 doptp = pl->vs[VS_NFSMNT_ROOTSRVR_IP];
1232 if (doptp) {
1233 bcopy(doptp->value, server_ip, sizeof (server_ip));
1234 if (dldebug) {
1235 printf("dhcp: root server IP address %s\n",
1236 inet_ntoa(*(struct in_addr *)server_ip));
1237 }
1238 } else {
1239 if (dldebug)
1240 cmn_err(CE_CONT,
1241 "dhcp: file server ip address missing,"
1242 " fallback to dhcp server as file server");
1243 bcopy(dhcp_server_ip, server_ip, sizeof (server_ip));
1244 }
1245 }
1246
1247 /* set root file system mount options */
1248 if (rootopts[0] == 0) {
1249 doptp = pl->vs[VS_NFSMNT_ROOTOPTS];
1250 if (doptp != NULL && doptp->len < 255) {
1251 bcopy(doptp->value, rootopts, doptp->len);
1252 rootopts[doptp->len] = '\0';
1253 if (dldebug)
1254 printf("dhcp: rootopts %s\n", rootopts);
1255 } else if (dldebug) {
1256 printf("dhcp: no rootopts or too long\n");
1257 /* not an error */
1258 }
1259 }
1260
1261 /* now we are done with pl, just free it */
1262 kmem_free(pl->pkt, pl->len);
1263 kmem_free(pl, sizeof (PKT_LIST));
1264 pl = NULL;
1265 }
1266
1267 static int
1268 cacheinfo(char *name, int namelen,
1269 struct netbuf *server_address, char *rootpath, int pathlen)
1270 {
1271 static int init_done = 0;
1272 struct sockaddr_in *sin;
1273
1274 if (init_done == 0) {
1275 cacheinit();
1276 init_done = 1;
1277 }
1278
1279 /* server_path is a reliable indicator of cache availability */
1280 if (server_path_c == NULL)
1281 return (-1);
1282
1283 (void) strncpy(rootpath, server_path_c, pathlen);
1284 if (server_name_c) {
1285 (void) strncpy(name, server_name_c, namelen);
1286 } else {
1287 (void) strncpy(name, "unknown", namelen);
1288 }
1289
1290 sin = (struct sockaddr_in *)server_address->buf;
1291 sin->sin_family = AF_INET;
1292 server_address->len = sizeof (struct sockaddr_in);
1293 bcopy(server_ip, &sin->sin_addr, sizeof (struct in_addr));
1294 return (0);
1295 }
1296
1297 /*
1298 * Set this interface's IP address and netmask, and bring it up.
1299 */
1300 static int
1301 dlifconfig(TIUSER *tiptr, struct in_addr *myIPaddr, struct in_addr *mymask,
1302 struct in_addr *mybraddr, uint_t flags)
1303 {
1304 int rc;
1305 struct netbuf sbuf;
1306 struct sockaddr_in sin;
1307
1308 if (dldebug) {
1309 printf("dlifconfig: entered\n");
1310 printf("dlifconfig: addr %s\n", inet_ntoa(*myIPaddr));
1311 printf("dlifconfig: mask %s\n", inet_ntoa(*mymask));
1312 printf("dlifconfig: broadcast %s\n", inet_ntoa(*mybraddr));
1313 }
1314
1315 bcopy(myIPaddr, &sin.sin_addr, sizeof (struct in_addr));
1316 sin.sin_family = AF_INET;
1317 sbuf.buf = (caddr_t)&sin;
1318 sbuf.maxlen = sbuf.len = sizeof (sin);
1319 if (rc = ifioctl(tiptr, SIOCSIFADDR, &sbuf)) {
1320 nfs_perror(rc,
1321 "dlifconfig: couldn't set interface net address: %m\n");
1322 return (rc);
1323 }
1324
1325 if (mybraddr->s_addr != INADDR_BROADCAST) {
1326 bcopy(mybraddr, &sin.sin_addr, sizeof (struct in_addr));
1327 sin.sin_family = AF_INET;
1328 sbuf.buf = (caddr_t)&sin;
1329 sbuf.maxlen = sbuf.len = sizeof (sin);
1330 if (rc = ifioctl(tiptr, SIOCSIFBRDADDR, &sbuf)) {
1331 nfs_perror(rc,
1332 "dlifconfig: couldn't set interface broadcast addr: %m\n");
1333 return (rc);
1334 }
1335 }
1336
1337 bcopy(mymask, &sin.sin_addr, sizeof (struct in_addr));
1338 sin.sin_family = AF_INET;
1339 sbuf.buf = (caddr_t)&sin;
1340 sbuf.maxlen = sbuf.len = sizeof (sin);
1341 if (rc = ifioctl(tiptr, SIOCSIFNETMASK, &sbuf)) {
1342 nfs_perror(rc,
1343 "dlifconfig: couldn't set interface net address: %m\n");
1344 return (rc);
1345 }
1346
1347 /*
1348 * Now turn on the interface.
1349 */
1350 if (rc = setifflags(tiptr, IFF_UP | flags)) {
1351 nfs_perror(rc,
1352 "dlifconfig: couldn't enable network interface: %m\n");
1353 return (rc);
1354 }
1355
1356 if (dldebug)
1357 printf("dlifconfig: returned\n");
1358 return (0);
1359 }
1360
1361 static char *
1362 inet_ntoa(struct in_addr in)
1363 {
1364 static char b[18];
1365 unsigned char *p;
1366
1367 p = (unsigned char *)∈
1368 (void) sprintf(b, "%d.%d.%d.%d", p[0], p[1], p[2], p[3]);
1369 return (b);
1370 }
1371
1372 /* We only deal with a.b.c.d decimal format. ip points to 4 byte storage */
1373 static int
1374 inet_aton(char *ipstr, uchar_t *ip)
1375 {
1376 int i = 0;
1377 uchar_t val[4] = {0};
1378 char c = *ipstr;
1379
1380 for (;;) {
1381 if (!isdigit(c))
1382 return (-1);
1383 for (;;) {
1384 if (!isdigit(c))
1385 break;
1386 val[i] = val[i] * 10 + (c - '0');
1387 c = *++ipstr;
1388 }
1389 i++;
1390 if (i == 4)
1391 break;
1392 if (c != '.')
1393 return (-1);
1394 c = *++ipstr;
1395 }
1396 if (c != 0)
1397 return (-1);
1398 bcopy(val, ip, 4);
1399 return (0);
1400 }
1401
1402 #define MAX_ADDR_SIZE 128
1403
1404 /*
1405 * Initialize a netbuf suitable for
1406 * describing an address for the
1407 * transport defined by `tiptr'.
1408 */
1409 static void
1410 init_netbuf(struct netbuf *nbuf)
1411 {
1412 nbuf->buf = kmem_zalloc(MAX_ADDR_SIZE, KM_SLEEP);
1413 nbuf->maxlen = MAX_ADDR_SIZE;
1414 nbuf->len = 0;
1415 }
1416
1417 static void
1418 free_netbuf(struct netbuf *nbuf)
1419 {
1420 kmem_free(nbuf->buf, nbuf->maxlen);
1421 nbuf->buf = NULL;
1422 nbuf->maxlen = 0;
1423 nbuf->len = 0;
1424 }
1425
1426 static int
1427 rtioctl(TIUSER *tiptr, int cmd, struct rtentry *rtentry)
1428 {
1429 struct strioctl iocb;
1430 int rc;
1431 vnode_t *vp;
1432
1433 iocb.ic_cmd = cmd;
1434 iocb.ic_timout = 0;
1435 iocb.ic_len = sizeof (struct rtentry);
1436 iocb.ic_dp = (caddr_t)rtentry;
1437
1438 vp = tiptr->fp->f_vnode;
1439 rc = kstr_ioctl(vp, I_STR, (intptr_t)&iocb);
1440 if (rc)
1441 nfs_perror(rc, "rtioctl: kstr_ioctl failed: %m\n");
1442 return (rc);
1443 }
1444
1445 /*
1446 * Send an ioctl down the stream defined
1447 * by `tiptr'.
1448 *
1449 * We isolate the ifreq dependencies in here. The
1450 * ioctl really ought to take a netbuf and be of
1451 * type TRANSPARENT - one day.
1452 */
1453 static int
1454 ifioctl(TIUSER *tiptr, int cmd, struct netbuf *nbuf)
1455 {
1456 struct strioctl iocb;
1457 int rc;
1458 vnode_t *vp;
1459 struct ifreq ifr;
1460
1461 /*
1462 * Now do the one requested.
1463 */
1464 if (nbuf->len)
1465 ifr.ifr_addr = *(struct sockaddr *)nbuf->buf;
1466 (void) strncpy((caddr_t)&ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1467 iocb.ic_cmd = cmd;
1468 iocb.ic_timout = 0;
1469 iocb.ic_len = sizeof (ifr);
1470 iocb.ic_dp = (caddr_t)𝔦
1471
1472 vp = tiptr->fp->f_vnode;
1473 rc = kstr_ioctl(vp, I_STR, (intptr_t)&iocb);
1474 if (rc) {
1475 nfs_perror(rc, "ifioctl: kstr_ioctl failed: %m\n");
1476 return (rc);
1477 }
1478
1479 /*
1480 * Set reply length.
1481 */
1482 if (nbuf->len == 0) {
1483 /*
1484 * GET type.
1485 */
1486 nbuf->len = sizeof (struct sockaddr);
1487 *(struct sockaddr *)nbuf->buf = ifr.ifr_addr;
1488 }
1489
1490 return (0);
1491 }
1492
1493 static int
1494 setifflags(TIUSER *tiptr, uint_t value)
1495 {
1496 struct ifreq ifr;
1497 int rc;
1498 struct strioctl iocb;
1499
1500 (void) strncpy((caddr_t)&ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1501 iocb.ic_cmd = SIOCGIFFLAGS;
1502 iocb.ic_timout = 0;
1503 iocb.ic_len = sizeof (ifr);
1504 iocb.ic_dp = (caddr_t)𝔦
1505 if (rc = kstr_ioctl(tiptr->fp->f_vnode, I_STR, (intptr_t)&iocb))
1506 return (rc);
1507
1508 ifr.ifr_flags |= value;
1509 iocb.ic_cmd = SIOCSIFFLAGS;
1510 return (kstr_ioctl(tiptr->fp->f_vnode, I_STR, (intptr_t)&iocb));
1511 }
1512
1513 /*
1514 * REVerse Address Resolution Protocol (revarp)
1515 * is used by a diskless client to find out its
1516 * IP address when all it knows is its Ethernet address.
1517 *
1518 * Open the ethernet driver, attach and bind
1519 * (DL_BIND_REQ) it, and then format a broadcast RARP
1520 * message for it to send. We pick up the reply and
1521 * let the caller set the interface address using SIOCSIFADDR.
1522 */
1523 static int
1524 revarp_myaddr(TIUSER *tiptr)
1525 {
1526 int rc;
1527 dl_info_ack_t info;
1528 struct sockaddr_in sin;
1529 struct netbuf sbuf;
1530 ldi_handle_t lh;
1531 ldi_ident_t li;
1532 struct netbuf myaddr = {0, 0, NULL};
1533
1534 if (dldebug)
1535 printf("revarp_myaddr: entered\n");
1536
1537 if (rc = ldi_ident_from_mod(&modlinkage, &li)) {
1538 nfs_perror(rc,
1539 "revarp_myaddr: ldi_ident_from_mod failed: %m\n");
1540 return (rc);
1541 }
1542
1543 rc = ldi_open_by_name(ndev_path, FREAD|FWRITE, CRED(), &lh, li);
1544 ldi_ident_release(li);
1545 if (rc) {
1546 nfs_perror(rc,
1547 "revarp_myaddr: ldi_open_by_name failed: %m\n");
1548 return (rc);
1549 }
1550
1551 if (rc = dl_attach(lh, ifunit, NULL)) {
1552 nfs_perror(rc, "revarp_myaddr: dl_attach failed: %m\n");
1553 (void) ldi_close(lh, FREAD|FWRITE, CRED());
1554 return (rc);
1555 }
1556
1557 if (rc = dl_bind(lh, ETHERTYPE_REVARP, NULL)) {
1558 nfs_perror(rc, "revarp_myaddr: dl_bind failed: %m\n");
1559 (void) ldi_close(lh, FREAD|FWRITE, CRED());
1560 return (rc);
1561 }
1562
1563 if (rc = dl_info(lh, &info, NULL, NULL, NULL)) {
1564 nfs_perror(rc, "revarp_myaddr: dl_info failed: %m\n");
1565 (void) ldi_close(lh, FREAD|FWRITE, CRED());
1566 return (rc);
1567 }
1568
1569 /* Initialize myaddr */
1570 myaddr.maxlen = info.dl_addr_length;
1571 myaddr.buf = kmem_alloc(myaddr.maxlen, KM_SLEEP);
1572
1573 revarp_start(lh, &myaddr);
1574
1575 bcopy(myaddr.buf, &sin.sin_addr, myaddr.len);
1576 sin.sin_family = AF_INET;
1577
1578 sbuf.buf = (caddr_t)&sin;
1579 sbuf.maxlen = sbuf.len = sizeof (sin);
1580 if (rc = ifioctl(tiptr, SIOCSIFADDR, &sbuf)) {
1581 nfs_perror(rc,
1582 "revarp_myaddr: couldn't set interface net address: %m\n");
1583 (void) ldi_close(lh, FREAD|FWRITE, CRED());
1584 kmem_free(myaddr.buf, myaddr.maxlen);
1585 return (rc);
1586 }
1587
1588 /* Now turn on the interface */
1589 if (rc = setifflags(tiptr, IFF_UP)) {
1590 nfs_perror(rc,
1591 "revarp_myaddr: couldn't enable network interface: %m\n");
1592 }
1593
1594 (void) ldi_close(lh, FREAD|FWRITE, CRED());
1595 kmem_free(myaddr.buf, myaddr.maxlen);
1596 return (rc);
1597 }
1598
1599 static void
1600 revarp_start(ldi_handle_t lh, struct netbuf *myaddr)
1601 {
1602 struct ether_arp *ea;
1603 int rc;
1604 dl_unitdata_req_t *dl_udata;
1605 mblk_t *bp;
1606 mblk_t *mp;
1607 struct dladdr *dlsap;
1608 static int done = 0;
1609 size_t addrlen = ETHERADDRL;
1610
1611 if (dl_phys_addr(lh, (uchar_t *)&myether, &addrlen, NULL) != 0 ||
1612 addrlen != ETHERADDRL) {
1613 /* Fallback using per-node address */
1614 (void) localetheraddr((struct ether_addr *)NULL, &myether);
1615 cmn_err(CE_CONT, "?DLPI failed to get Ethernet address. Using "
1616 "system wide Ethernet address %s\n",
1617 ether_sprintf(&myether));
1618 }
1619
1620 getreply:
1621 if (myaddr->len != 0) {
1622 cmn_err(CE_CONT, "?Found my IP address: %x (%d.%d.%d.%d)\n",
1623 *(int *)myaddr->buf,
1624 (uchar_t)myaddr->buf[0], (uchar_t)myaddr->buf[1],
1625 (uchar_t)myaddr->buf[2], (uchar_t)myaddr->buf[3]);
1626 return;
1627 }
1628
1629 if (done++ == 0)
1630 cmn_err(CE_CONT, "?Requesting Internet address for %s\n",
1631 ether_sprintf(&myether));
1632
1633 /*
1634 * Send another RARP request.
1635 */
1636 if ((mp = allocb(sizeof (dl_unitdata_req_t) + sizeof (*dlsap),
1637 BPRI_HI)) == NULL) {
1638 cmn_err(CE_WARN, "revarp_myaddr: allocb no memory");
1639 return;
1640 }
1641 if ((bp = allocb(sizeof (struct ether_arp), BPRI_HI)) == NULL) {
1642 cmn_err(CE_WARN, "revarp_myaddr: allocb no memory");
1643 return;
1644 }
1645
1646 /*
1647 * Format the transmit request part.
1648 */
1649 mp->b_datap->db_type = M_PROTO;
1650 dl_udata = (dl_unitdata_req_t *)mp->b_wptr;
1651 mp->b_wptr += sizeof (dl_unitdata_req_t) + sizeof (*dlsap);
1652 dl_udata->dl_primitive = DL_UNITDATA_REQ;
1653 dl_udata->dl_dest_addr_length = sizeof (*dlsap);
1654 dl_udata->dl_dest_addr_offset = sizeof (*dl_udata);
1655 dl_udata->dl_priority.dl_min = 0;
1656 dl_udata->dl_priority.dl_max = 0;
1657
1658 dlsap = (struct dladdr *)(mp->b_rptr + sizeof (*dl_udata));
1659 bcopy(ðerbroadcastaddr, &dlsap->dl_phys,
1660 sizeof (etherbroadcastaddr));
1661 dlsap->dl_sap = ETHERTYPE_REVARP;
1662
1663 /*
1664 * Format the actual REVARP request.
1665 */
1666 bzero(bp->b_wptr, sizeof (struct ether_arp));
1667 ea = (struct ether_arp *)bp->b_wptr;
1668 bp->b_wptr += sizeof (struct ether_arp);
1669 ea->arp_hrd = htons(ARPHRD_ETHER);
1670 ea->arp_pro = htons(ETHERTYPE_IP);
1671 ea->arp_hln = sizeof (ea->arp_sha); /* hardware address length */
1672 ea->arp_pln = sizeof (ea->arp_spa); /* protocol address length */
1673 ea->arp_op = htons(REVARP_REQUEST);
1674 ether_copy(&myether, &ea->arp_sha);
1675 ether_copy(&myether, &ea->arp_tha);
1676
1677 mp->b_cont = bp;
1678
1679 if ((rc = ldi_putmsg(lh, mp)) != 0) {
1680 nfs_perror(rc, "revarp_start: ldi_putmsg failed: %m\n");
1681 return;
1682 }
1683 revarpinput(lh, myaddr);
1684
1685 goto getreply;
1686 }
1687
1688 /*
1689 * Client side Reverse-ARP input
1690 * Server side is handled by user level server
1691 */
1692 static void
1693 revarpinput(ldi_handle_t lh, struct netbuf *myaddr)
1694 {
1695 struct ether_arp *ea;
1696 mblk_t *bp;
1697 mblk_t *mp;
1698 int rc;
1699 timestruc_t tv, give_up, now;
1700
1701 /*
1702 * Choose the time at which we will give up, and resend our
1703 * request.
1704 */
1705 gethrestime(&give_up);
1706 give_up.tv_sec += REVARP_TIMEO;
1707 wait:
1708 /*
1709 * Compute new timeout value.
1710 */
1711 tv = give_up;
1712 gethrestime(&now);
1713 timespecsub(&tv, &now);
1714 /*
1715 * If we don't have at least one full second remaining, give up.
1716 * This means we might wait only just over 4.0 seconds, but that's
1717 * okay.
1718 */
1719 if (tv.tv_sec <= 0)
1720 return;
1721 rc = ldi_getmsg(lh, &mp, &tv);
1722 if (rc == ETIME) {
1723 goto out;
1724 } else if (rc != 0) {
1725 nfs_perror(rc, "revarpinput: ldi_getmsg failed: %m\n");
1726 return;
1727 }
1728
1729 if (mp->b_cont == NULL) {
1730 printf("revarpinput: b_cont == NULL\n");
1731 goto out;
1732 }
1733
1734 if (mp->b_datap->db_type != M_PROTO) {
1735 printf("revarpinput: bad header type %d\n",
1736 mp->b_datap->db_type);
1737 goto out;
1738 }
1739
1740 bp = mp->b_cont;
1741
1742 if (bp->b_wptr - bp->b_rptr < sizeof (*ea)) {
1743 printf("revarpinput: bad data len %d, expect %d\n",
1744 (int)(bp->b_wptr - bp->b_rptr), (int)sizeof (*ea));
1745 goto out;
1746 }
1747
1748 ea = (struct ether_arp *)bp->b_rptr;
1749
1750 if ((ushort_t)ntohs(ea->arp_pro) != ETHERTYPE_IP) {
1751 /* We could have received another broadcast arp packet. */
1752 if (dldebug)
1753 printf("revarpinput: bad type %x\n",
1754 (ushort_t)ntohs(ea->arp_pro));
1755 freemsg(mp);
1756 goto wait;
1757 }
1758 if ((ushort_t)ntohs(ea->arp_op) != REVARP_REPLY) {
1759 /* We could have received a broadcast arp request. */
1760 if (dldebug)
1761 printf("revarpinput: bad op %x\n",
1762 (ushort_t)ntohs(ea->arp_op));
1763 freemsg(mp);
1764 goto wait;
1765 }
1766
1767 if (!ether_cmp(&ea->arp_tha, &myether)) {
1768 bcopy(&ea->arp_tpa, myaddr->buf, sizeof (ea->arp_tpa));
1769 myaddr->len = sizeof (ea->arp_tpa);
1770 } else {
1771 /* We could have gotten a broadcast arp response. */
1772 if (dldebug)
1773 printf("revarpinput: got reply, but not my address\n");
1774 freemsg(mp);
1775 goto wait;
1776 }
1777 out:
1778 freemsg(mp);
1779 }
1780
1781 /*
1782 * From rpcsvc/mountxdr.c in SunOS. We can't
1783 * put this into the rpc directory because
1784 * it calls xdr_fhandle() which is in a
1785 * loadable module.
1786 */
1787 static bool_t
1788 myxdr_fhstatus(XDR *xdrs, struct fhstatus *fhsp)
1789 {
1790
1791 if (!xdr_int(xdrs, &fhsp->fhs_status))
1792 return (FALSE);
1793 if (fhsp->fhs_status == 0) {
1794 if (!myxdr_fhandle(xdrs, &fhsp->fhs_fh))
1795 return (FALSE);
1796 }
1797 return (TRUE);
1798 }
1799
1800 /*
1801 * From nfs_xdr.c.
1802 *
1803 * File access handle
1804 * The fhandle struct is treated a opaque data on the wire
1805 */
1806 static bool_t
1807 myxdr_fhandle(XDR *xdrs, fhandle_t *fh)
1808 {
1809 return (xdr_opaque(xdrs, (caddr_t)fh, NFS_FHSIZE));
1810 }
1811
1812 static bool_t
1813 myxdr_mountres3(XDR *xdrs, struct mountres3 *objp)
1814 {
1815 if (!myxdr_mountstat3(xdrs, &objp->fhs_status))
1816 return (FALSE);
1817 switch (objp->fhs_status) {
1818 case MNT_OK:
1819 if (!myxdr_mountres3_ok(xdrs, &objp->mountres3_u.mountinfo))
1820 return (FALSE);
1821 break;
1822 default:
1823 break;
1824 }
1825 return (TRUE);
1826 }
1827
1828 static bool_t
1829 myxdr_mountstat3(XDR *xdrs, enum mountstat3 *objp)
1830 {
1831 return (xdr_enum(xdrs, (enum_t *)objp));
1832 }
1833
1834 static bool_t
1835 myxdr_mountres3_ok(XDR *xdrs, struct mountres3_ok *objp)
1836 {
1837 if (!myxdr_fhandle3(xdrs, &objp->fhandle))
1838 return (FALSE);
1839 if (!xdr_array(xdrs, (char **)&objp->auth_flavors.auth_flavors_val,
1840 (uint_t *)&objp->auth_flavors.auth_flavors_len, ~0,
1841 sizeof (int), (xdrproc_t)xdr_int))
1842 return (FALSE);
1843 return (TRUE);
1844 }
1845
1846 static bool_t
1847 myxdr_fhandle3(XDR *xdrs, struct fhandle3 *objp)
1848 {
1849 return (xdr_bytes(xdrs, (char **)&objp->fhandle3_val,
1850 (uint_t *)&objp->fhandle3_len, FHSIZE3));
1851 }
1852
1853 /*
1854 * From SunOS pmap_clnt.c
1855 *
1856 * Port mapper routines:
1857 * pmap_kgetport() - get port number.
1858 * pmap_rmt_call() - indirect call via port mapper.
1859 *
1860 */
1861 static enum clnt_stat
1862 pmap_kgetport(struct knetconfig *knconf, struct netbuf *call_addr,
1863 rpcprog_t prog, rpcvers_t vers, rpcprot_t prot)
1864 {
1865 ushort_t port;
1866 int tries;
1867 enum clnt_stat stat;
1868 struct pmap pmap_parms;
1869 RPCB rpcb_parms;
1870 char *ua = NULL;
1871
1872 port = 0;
1873
1874 ((struct sockaddr_in *)call_addr->buf)->sin_port = htons(PMAPPORT);
1875
1876 pmap_parms.pm_prog = prog;
1877 pmap_parms.pm_vers = vers;
1878 pmap_parms.pm_prot = prot;
1879 pmap_parms.pm_port = 0;
1880 for (tries = 0; tries < 5; tries++) {
1881 stat = mycallrpc(knconf, call_addr,
1882 PMAPPROG, PMAPVERS, PMAPPROC_GETPORT,
1883 myxdr_pmap, (char *)&pmap_parms,
1884 xdr_u_short, (char *)&port,
1885 DEFAULT_TIMEO, DEFAULT_RETRIES);
1886
1887 if (stat != RPC_TIMEDOUT)
1888 break;
1889 cmn_err(CE_WARN,
1890 "pmap_kgetport: Portmapper not responding; still trying");
1891 }
1892
1893 if (stat == RPC_PROGUNAVAIL) {
1894 cmn_err(CE_WARN,
1895 "pmap_kgetport: Portmapper failed - trying rpcbind");
1896
1897 rpcb_parms.r_prog = prog;
1898 rpcb_parms.r_vers = vers;
1899 rpcb_parms.r_netid = knconf->knc_proto;
1900 rpcb_parms.r_addr = rpcb_parms.r_owner = "";
1901
1902 for (tries = 0; tries < 5; tries++) {
1903 stat = mycallrpc(knconf, call_addr,
1904 RPCBPROG, RPCBVERS, RPCBPROC_GETADDR,
1905 xdr_rpcb, (char *)&rpcb_parms,
1906 xdr_wrapstring, (char *)&ua,
1907 DEFAULT_TIMEO, DEFAULT_RETRIES);
1908
1909 if (stat != RPC_TIMEDOUT)
1910 break;
1911 cmn_err(CE_WARN,
1912 "pmap_kgetport: rpcbind not responding; still trying");
1913 }
1914
1915 if (stat == RPC_SUCCESS) {
1916 if ((ua != NULL) && (ua[0] != NULL)) {
1917 port = rpc_uaddr2port(AF_INET, ua);
1918 } else {
1919 /* Address unknown */
1920 stat = RPC_PROGUNAVAIL;
1921 }
1922 }
1923 }
1924
1925 if (stat == RPC_SUCCESS)
1926 ((struct sockaddr_in *)call_addr->buf)->sin_port = ntohs(port);
1927
1928 return (stat);
1929 }
1930
1931 /*
1932 * pmapper remote-call-service interface.
1933 * This routine is used to call the pmapper remote call service
1934 * which will look up a service program in the port maps, and then
1935 * remotely call that routine with the given parameters. This allows
1936 * programs to do a lookup and call in one step. In addition to the call_addr,
1937 * the caller provides a boolean hint about the destination address (TRUE if
1938 * address is a broadcast address, FALSE otherwise).
1939 *
1940 * On return, `call addr' contains the port number for the
1941 * service requested, and `resp_addr' contains its IP address.
1942 */
1943 static enum clnt_stat
1944 pmap_rmt_call(struct knetconfig *knconf, struct netbuf *call_addr,
1945 bool_t bcast, rpcprog_t progn, rpcvers_t versn, rpcproc_t procn,
1946 xdrproc_t xdrargs, caddr_t argsp, xdrproc_t xdrres, caddr_t resp,
1947 struct timeval tout, struct netbuf *resp_addr)
1948 {
1949 CLIENT *cl;
1950 enum clnt_stat stat;
1951 rpcport_t port;
1952 int rc;
1953 struct rmtcallargs pmap_args;
1954 struct rmtcallres pmap_res;
1955 struct rpcb_rmtcallargs rpcb_args;
1956 struct rpcb_rmtcallres rpcb_res;
1957 char ua[100]; /* XXX */
1958
1959 ((struct sockaddr_in *)call_addr->buf)->sin_port = htons(PMAPPORT);
1960
1961 rc = clnt_tli_kcreate(knconf, call_addr, PMAPPROG, PMAPVERS,
1962 0, PMAP_RETRIES, CRED(), &cl);
1963 if (rc != 0) {
1964 nfs_perror(rc,
1965 "pmap_rmt_call: clnt_tli_kcreate failed: %m\n");
1966 return (RPC_SYSTEMERROR); /* XXX */
1967 }
1968 if (cl == (CLIENT *)NULL) {
1969 panic("pmap_rmt_call: clnt_tli_kcreate failed");
1970 /* NOTREACHED */
1971 }
1972
1973 (void) CLNT_CONTROL(cl, CLSET_BCAST, (char *)&bcast);
1974
1975 pmap_args.prog = progn;
1976 pmap_args.vers = versn;
1977 pmap_args.proc = procn;
1978 pmap_args.args_ptr = argsp;
1979 pmap_args.xdr_args = xdrargs;
1980 pmap_res.port_ptr = &port;
1981 pmap_res.results_ptr = resp;
1982 pmap_res.xdr_results = xdrres;
1983 stat = clnt_clts_kcallit_addr(cl, PMAPPROC_CALLIT,
1984 myxdr_rmtcall_args, (caddr_t)&pmap_args,
1985 myxdr_rmtcallres, (caddr_t)&pmap_res,
1986 tout, resp_addr);
1987
1988 if (stat == RPC_SUCCESS) {
1989 ((struct sockaddr_in *)resp_addr->buf)->sin_port =
1990 htons((ushort_t)port);
1991 }
1992 CLNT_DESTROY(cl);
1993
1994 if (stat != RPC_PROGUNAVAIL)
1995 return (stat);
1996
1997 cmn_err(CE_WARN, "pmap_rmt_call: Portmapper failed - trying rpcbind");
1998
1999 rc = clnt_tli_kcreate(knconf, call_addr, RPCBPROG, RPCBVERS,
2000 0, PMAP_RETRIES, CRED(), &cl);
2001 if (rc != 0) {
2002 nfs_perror(rc, "pmap_rmt_call: clnt_tli_kcreate failed: %m\n");
2003 return (RPC_SYSTEMERROR); /* XXX */
2004 }
2005
2006 if (cl == NULL) {
2007 panic("pmap_rmt_call: clnt_tli_kcreate failed");
2008 /* NOTREACHED */
2009 }
2010
2011 rpcb_args.prog = progn;
2012 rpcb_args.vers = versn;
2013 rpcb_args.proc = procn;
2014 rpcb_args.args_ptr = argsp;
2015 rpcb_args.xdr_args = xdrargs;
2016 rpcb_res.addr_ptr = ua;
2017 rpcb_res.results_ptr = resp;
2018 rpcb_res.xdr_results = xdrres;
2019 stat = clnt_clts_kcallit_addr(cl, PMAPPROC_CALLIT,
2020 xdr_rpcb_rmtcallargs, (caddr_t)&rpcb_args,
2021 xdr_rpcb_rmtcallres, (caddr_t)&rpcb_res,
2022 tout, resp_addr);
2023
2024 if (stat == RPC_SUCCESS)
2025 ((struct sockaddr_in *)resp_addr->buf)->sin_port =
2026 rpc_uaddr2port(AF_INET, ua);
2027 CLNT_DESTROY(cl);
2028
2029 return (stat);
2030 }
2031
2032 /*
2033 * XDR remote call arguments
2034 * written for XDR_ENCODE direction only
2035 */
2036 static bool_t
2037 myxdr_rmtcall_args(XDR *xdrs, struct rmtcallargs *cap)
2038 {
2039 uint_t lenposition;
2040 uint_t argposition;
2041 uint_t position;
2042
2043 if (xdr_rpcprog(xdrs, &(cap->prog)) &&
2044 xdr_rpcvers(xdrs, &(cap->vers)) &&
2045 xdr_rpcproc(xdrs, &(cap->proc))) {
2046 lenposition = XDR_GETPOS(xdrs);
2047 if (!xdr_u_int(xdrs, &cap->arglen))
2048 return (FALSE);
2049 argposition = XDR_GETPOS(xdrs);
2050 if (!(*(cap->xdr_args))(xdrs, cap->args_ptr))
2051 return (FALSE);
2052 position = XDR_GETPOS(xdrs);
2053 cap->arglen = (uint_t)position - (uint_t)argposition;
2054 XDR_SETPOS(xdrs, lenposition);
2055 if (!xdr_u_int(xdrs, &cap->arglen))
2056 return (FALSE);
2057 XDR_SETPOS(xdrs, position);
2058 return (TRUE);
2059 }
2060 return (FALSE);
2061 }
2062
2063 /*
2064 * XDR remote call results
2065 * written for XDR_DECODE direction only
2066 */
2067 static bool_t
2068 myxdr_rmtcallres(XDR *xdrs, struct rmtcallres *crp)
2069 {
2070 caddr_t port_ptr;
2071
2072 port_ptr = (caddr_t)crp->port_ptr;
2073 if (xdr_reference(xdrs, &port_ptr, sizeof (uint_t), xdr_u_int) &&
2074 xdr_u_int(xdrs, &crp->resultslen)) {
2075 crp->port_ptr = (rpcport_t *)port_ptr;
2076 return ((*(crp->xdr_results))(xdrs, crp->results_ptr));
2077 }
2078 return (FALSE);
2079 }
2080
2081 static bool_t
2082 myxdr_pmap(XDR *xdrs, struct pmap *regs)
2083 {
2084 if (xdr_rpcprog(xdrs, ®s->pm_prog) &&
2085 xdr_rpcvers(xdrs, ®s->pm_vers) &&
2086 xdr_rpcprot(xdrs, ®s->pm_prot))
2087 return (xdr_rpcport(xdrs, ®s->pm_port));
2088
2089 return (FALSE);
2090 }
2091
2092 /*
2093 * From SunOS callrpc.c
2094 */
2095 static enum clnt_stat
2096 mycallrpc(struct knetconfig *knconf, struct netbuf *call_addr,
2097 rpcprog_t prognum, rpcvers_t versnum, rpcproc_t procnum,
2098 xdrproc_t inproc, char *in, xdrproc_t outproc, char *out,
2099 int timeo, int retries)
2100 {
2101 CLIENT *cl;
2102 struct timeval tv;
2103 enum clnt_stat cl_stat;
2104 int rc;
2105
2106 rc = clnt_tli_kcreate(knconf, call_addr, prognum, versnum,
2107 0, retries, CRED(), &cl);
2108 if (rc) {
2109 nfs_perror(rc, "mycallrpc: clnt_tli_kcreate failed: %m\n");
2110 return (RPC_SYSTEMERROR); /* XXX */
2111 }
2112 tv.tv_sec = timeo;
2113 tv.tv_usec = 0;
2114 cl_stat = CLNT_CALL(cl, procnum, inproc, in, outproc, out, tv);
2115 AUTH_DESTROY(cl->cl_auth);
2116 CLNT_DESTROY(cl);
2117 return (cl_stat);
2118 }
2119
2120 /*
2121 * Configure the 'default' interface based on existing boot properties.
2122 */
2123 static int
2124 bp_netconfig(void)
2125 {
2126 char *str;
2127 struct in_addr my_ip, my_netmask, my_router, my_broadcast;
2128 struct sockaddr_in *sin;
2129 TIUSER *tiptr;
2130 int rc;
2131 struct rtentry rtentry;
2132
2133 my_ip.s_addr = my_netmask.s_addr = my_router.s_addr = 0;
2134
2135 /*
2136 * No way of getting this right now. Collude with dlifconfig()
2137 * to let the protocol stack choose.
2138 */
2139 my_broadcast.s_addr = INADDR_BROADCAST;
2140
2141 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(),
2142 DDI_PROP_DONTPASS, BP_HOST_IP, &str) == DDI_SUCCESS) {
2143 if (inet_aton(str, (uchar_t *)&my_ip) != 0)
2144 cmn_err(CE_NOTE, "host-ip %s is invalid\n",
2145 str);
2146 ddi_prop_free(str);
2147 if (dldebug)
2148 printf("host ip is %s\n",
2149 inet_ntoa(my_ip));
2150 }
2151 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(),
2152 DDI_PROP_DONTPASS, BP_SUBNET_MASK, &str) == DDI_SUCCESS) {
2153 if (inet_aton(str, (uchar_t *)&my_netmask) != 0)
2154 cmn_err(CE_NOTE, "subnet-mask %s is invalid\n",
2155 str);
2156 ddi_prop_free(str);
2157 if (dldebug)
2158 printf("subnet mask is %s\n",
2159 inet_ntoa(my_netmask));
2160 }
2161 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(),
2162 DDI_PROP_DONTPASS, BP_ROUTER_IP, &str) == DDI_SUCCESS) {
2163 if (inet_aton(str, (uchar_t *)&my_router) != 0)
2164 cmn_err(CE_NOTE, "router-ip %s is invalid\n",
2165 str);
2166 ddi_prop_free(str);
2167 if (dldebug)
2168 printf("router ip is %s\n",
2169 inet_ntoa(my_router));
2170 }
2171 (void) ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(),
2172 DDI_PROP_DONTPASS, BP_SERVER_PATH, &server_path_c);
2173 (void) ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(),
2174 DDI_PROP_DONTPASS, BP_SERVER_NAME, &server_name_c);
2175 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(),
2176 DDI_PROP_DONTPASS, BP_SERVER_ROOTOPTS, &str) == DDI_SUCCESS) {
2177 (void) strlcpy(rootopts, str, sizeof (rootopts));
2178 ddi_prop_free(str);
2179 }
2180 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(),
2181 DDI_PROP_DONTPASS, BP_SERVER_IP, &str) == DDI_SUCCESS) {
2182 if (inet_aton(str, server_ip) != 0)
2183 cmn_err(CE_NOTE, "server-ip %s is invalid\n",
2184 str);
2185 ddi_prop_free(str);
2186 if (dldebug)
2187 printf("server ip is %s\n",
2188 inet_ntoa(*(struct in_addr *)server_ip));
2189 }
2190
2191 /*
2192 * We need all of these to configure based on properties.
2193 */
2194 if ((my_ip.s_addr == 0) ||
2195 (my_netmask.s_addr == 0) ||
2196 (server_path_c == NULL) ||
2197 (server_name_c == NULL) ||
2198 (*(uint_t *)server_ip == 0))
2199 return (-1);
2200
2201 cmn_err(CE_CONT, "?IP address: %s\n", inet_ntoa(my_ip));
2202 cmn_err(CE_CONT, "?IP netmask: %s\n", inet_ntoa(my_netmask));
2203 if (my_router.s_addr != 0)
2204 cmn_err(CE_CONT, "?IP router: %s\n", inet_ntoa(my_router));
2205 cmn_err(CE_CONT, "?NFS server: %s (%s)\n", server_name_c,
2206 inet_ntoa(*(struct in_addr *)server_ip));
2207 cmn_err(CE_CONT, "?NFS path: %s\n", server_path_c);
2208
2209 /*
2210 * Configure the interface.
2211 */
2212 if ((rc = t_kopen((file_t *)NULL, dl_udp_netconf.knc_rdev,
2213 FREAD|FWRITE, &tiptr, CRED())) != 0) {
2214 nfs_perror(rc, "bp_netconfig: t_kopen udp failed: %m.\n");
2215 return (rc);
2216 }
2217
2218 if ((rc = dlifconfig(tiptr, &my_ip, &my_netmask, &my_broadcast,
2219 0)) < 0) {
2220 nfs_perror(rc, "bp_netconfig: dlifconfig failed: %m.\n");
2221 (void) t_kclose(tiptr, 0);
2222 return (rc);
2223 }
2224
2225 if (my_router.s_addr != 0) {
2226 /*
2227 * Add a default route.
2228 */
2229 sin = (struct sockaddr_in *)&rtentry.rt_dst;
2230 bzero(sin, sizeof (*sin));
2231 sin->sin_family = AF_INET;
2232
2233 sin = (struct sockaddr_in *)&rtentry.rt_gateway;
2234 bzero(sin, sizeof (*sin));
2235 sin->sin_family = AF_INET;
2236 sin->sin_addr = my_router;
2237
2238 rtentry.rt_flags = RTF_GATEWAY | RTF_UP;
2239
2240 if ((rc = rtioctl(tiptr, SIOCADDRT, &rtentry)) != 0) {
2241 nfs_perror(rc,
2242 "bp_netconfig: couldn't add route: %m.\n");
2243 (void) t_kclose(tiptr, 0);
2244 return (rc);
2245 }
2246 }
2247
2248 (void) t_kclose(tiptr, 0);
2249
2250 return (0);
2251 }
2252
2253 /*
2254 * The network device we will use to boot from is plumbed. Extract the details
2255 * from rootfs.
2256 */
2257 static void
2258 init_config(void)
2259 {
2260 (void) strlcpy(ndev_path, rootfs.bo_devname, sizeof (ndev_path));
2261 (void) strlcpy(ifname, rootfs.bo_ifname, sizeof (ifname));
2262 ifunit = rootfs.bo_ppa;
2263
2264 /*
2265 * Assumes only one linkage array element.
2266 */
2267 dl_udp_netconf.knc_rdev =
2268 makedevice(clone_major, ddi_name_to_major("udp"));
2269 dl_tcp_netconf.knc_rdev =
2270 makedevice(clone_major, ddi_name_to_major("tcp"));
2271
2272 /*
2273 * Now we bringup the interface.
2274 * Try cached dhcp response first. If it fails, do rarp.
2275 */
2276 if ((bp_netconfig() != 0) &&
2277 (dhcpinit() != 0) &&
2278 (whoami() != 0))
2279 cmn_err(CE_WARN,
2280 "%s: no response from interface", ifname);
2281 else if (dldebug)
2282 printf("init_config: ifname %s is up\n", ifname);
2283 }
2284
2285 /*
2286 * These options are duplicated in cmd/fs.d/nfs/mount/mount.c
2287 * Changes must be made to both lists.
2288 */
2289 static char *optlist[] = {
2290 #define OPT_RO 0
2291 MNTOPT_RO,
2292 #define OPT_RW 1
2293 MNTOPT_RW,
2294 #define OPT_QUOTA 2
2295 MNTOPT_QUOTA,
2296 #define OPT_NOQUOTA 3
2297 MNTOPT_NOQUOTA,
2298 #define OPT_SOFT 4
2299 MNTOPT_SOFT,
2300 #define OPT_HARD 5
2301 MNTOPT_HARD,
2302 #define OPT_SUID 6
2303 MNTOPT_SUID,
2304 #define OPT_NOSUID 7
2305 MNTOPT_NOSUID,
2306 #define OPT_GRPID 8
2307 MNTOPT_GRPID,
2308 #define OPT_REMOUNT 9
2309 MNTOPT_REMOUNT,
2310 #define OPT_NOSUB 10
2311 MNTOPT_NOSUB,
2312 #define OPT_INTR 11
2313 MNTOPT_INTR,
2314 #define OPT_NOINTR 12
2315 MNTOPT_NOINTR,
2316 #define OPT_PORT 13
2317 MNTOPT_PORT,
2318 #define OPT_SECURE 14
2319 MNTOPT_SECURE,
2320 #define OPT_RSIZE 15
2321 MNTOPT_RSIZE,
2322 #define OPT_WSIZE 16
2323 MNTOPT_WSIZE,
2324 #define OPT_TIMEO 17
2325 MNTOPT_TIMEO,
2326 #define OPT_RETRANS 18
2327 MNTOPT_RETRANS,
2328 #define OPT_ACTIMEO 19
2329 MNTOPT_ACTIMEO,
2330 #define OPT_ACREGMIN 20
2331 MNTOPT_ACREGMIN,
2332 #define OPT_ACREGMAX 21
2333 MNTOPT_ACREGMAX,
2334 #define OPT_ACDIRMIN 22
2335 MNTOPT_ACDIRMIN,
2336 #define OPT_ACDIRMAX 23
2337 MNTOPT_ACDIRMAX,
2338 #define OPT_BG 24
2339 MNTOPT_BG,
2340 #define OPT_FG 25
2341 MNTOPT_FG,
2342 #define OPT_RETRY 26
2343 MNTOPT_RETRY,
2344 #define OPT_NOAC 27
2345 MNTOPT_NOAC,
2346 #define OPT_NOCTO 28
2347 MNTOPT_NOCTO,
2348 #define OPT_LLOCK 29
2349 MNTOPT_LLOCK,
2350 #define OPT_POSIX 30
2351 MNTOPT_POSIX,
2352 #define OPT_VERS 31
2353 MNTOPT_VERS,
2354 #define OPT_PROTO 32
2355 MNTOPT_PROTO,
2356 #define OPT_SEMISOFT 33
2357 MNTOPT_SEMISOFT,
2358 #define OPT_NOPRINT 34
2359 MNTOPT_NOPRINT,
2360 #define OPT_SEC 35
2361 MNTOPT_SEC,
2362 #define OPT_LARGEFILES 36
2363 MNTOPT_LARGEFILES,
2364 #define OPT_NOLARGEFILES 37
2365 MNTOPT_NOLARGEFILES,
2366 #define OPT_PUBLIC 38
2367 MNTOPT_PUBLIC,
2368 #define OPT_DIRECTIO 39
2369 MNTOPT_FORCEDIRECTIO,
2370 #define OPT_NODIRECTIO 40
2371 MNTOPT_NOFORCEDIRECTIO,
2372 #define OPT_XATTR 41
2373 MNTOPT_XATTR,
2374 #define OPT_NOXATTR 42
2375 MNTOPT_NOXATTR,
2376 #define OPT_DEVICES 43
2377 MNTOPT_DEVICES,
2378 #define OPT_NODEVICES 44
2379 MNTOPT_NODEVICES,
2380 #define OPT_SETUID 45
2381 MNTOPT_SETUID,
2382 #define OPT_NOSETUID 46
2383 MNTOPT_NOSETUID,
2384 #define OPT_EXEC 47
2385 MNTOPT_EXEC,
2386 #define OPT_NOEXEC 48
2387 MNTOPT_NOEXEC,
2388 NULL
2389 };
2390
2391 static int
2392 isdigit(int ch)
2393 {
2394 return (ch >= '0' && ch <= '9');
2395 }
2396
2397 #define isspace(c) ((c) == ' ' || (c) == '\t' || (c) == '\n')
2398 #define bad(val) (val == NULL || !isdigit(*val))
2399
2400 static int
2401 atoi(const char *p)
2402 {
2403 int n;
2404 int c, neg = 0;
2405
2406 if (!isdigit(c = *p)) {
2407 while (isspace(c))
2408 c = *++p;
2409 switch (c) {
2410 case '-':
2411 neg++;
2412 /* FALLTHROUGH */
2413 case '+':
2414 c = *++p;
2415 }
2416 if (!isdigit(c))
2417 return (0);
2418 }
2419 for (n = '0' - c; isdigit(c = *++p); ) {
2420 n *= 10; /* two steps to avoid unnecessary overflow */
2421 n += '0' - c; /* accum neg to avoid surprises at MAX */
2422 }
2423 return (neg ? n : -n);
2424 }
2425
2426 /*
2427 * Default root read tsize XXX
2428 */
2429 int nfs_root_rsize = 8 * 1024; /* conservative for dumb NICs */
2430 int nfs4_root_rsize = 32 * 1024; /* only runs on TCP be aggressive */
2431
2432 /*
2433 * Default flags: NFSMNT_NOCTO|NFSMNT_LLOCK|NFSMNT_INT
2434 */
2435 int nfs_rootopts = NFSMNT_NOCTO|NFSMNT_LLOCK|NFSMNT_INT;
2436
2437 static int
2438 init_mountopts(struct nfs_args *args, int version, struct knetconfig **dl_cf,
2439 int *vfsflags)
2440 {
2441 char servername[SYS_NMLN];
2442 static int first = 0;
2443 struct netbuf server_address;
2444 char *opts, *val;
2445 int vers;
2446 struct knetconfig *cf = *dl_cf;
2447 char rootoptsbuf[256];
2448
2449 /*
2450 * Set default mount options
2451 */
2452 args->flags = nfs_rootopts;
2453 args->rsize = 0;
2454 args->flags |= NFSMNT_ACREGMIN;
2455 args->acregmin = ACMINMAX;
2456 args->flags |= NFSMNT_ACREGMAX;
2457 args->acregmax = ACMAXMAX;
2458 args->flags |= NFSMNT_ACDIRMIN;
2459 args->acdirmin = ACMINMAX;
2460 args->flags |= NFSMNT_ACDIRMAX;
2461 args->acdirmax = ACMAXMAX;
2462
2463 *vfsflags = 0;
2464
2465 /*
2466 * Only look up the rootopts the first time, we store this in
2467 * a static buffer but we are guaranteed to be single threaded
2468 * and not reentrant.
2469 */
2470 if (first == 0) {
2471 first++;
2472
2473 init_netbuf(&server_address);
2474
2475 if (getfile("rootopts", servername, &server_address,
2476 rootopts)) {
2477 rootopts[0] = '\0';
2478 free_netbuf(&server_address);
2479 goto sanity;
2480 }
2481 free_netbuf(&server_address);
2482 }
2483
2484 if (dldebug)
2485 printf("rootopts = %s\n", rootopts);
2486
2487 /*
2488 * We have to preserve rootopts for second time.
2489 */
2490 (void) strncpy(rootoptsbuf, rootopts, sizeof (rootoptsbuf));
2491 rootoptsbuf[sizeof (rootoptsbuf) - 1] = '\0';
2492 opts = rootoptsbuf;
2493 while (*opts) {
2494 int opt;
2495
2496 switch (opt = getsubopt(&opts, optlist, &val)) {
2497 /*
2498 * Options that are defaults or meaningless so ignored
2499 */
2500 case OPT_QUOTA:
2501 case OPT_NOQUOTA:
2502 case OPT_SUID:
2503 case OPT_DEVICES:
2504 case OPT_SETUID:
2505 case OPT_BG:
2506 case OPT_FG:
2507 case OPT_RETRY:
2508 case OPT_POSIX:
2509 case OPT_LARGEFILES:
2510 case OPT_XATTR:
2511 case OPT_NOXATTR:
2512 case OPT_EXEC:
2513 break;
2514 case OPT_RO:
2515 *vfsflags |= MS_RDONLY;
2516 break;
2517 case OPT_RW:
2518 *vfsflags &= ~(MS_RDONLY);
2519 break;
2520 case OPT_SOFT:
2521 args->flags |= NFSMNT_SOFT;
2522 args->flags &= ~(NFSMNT_SEMISOFT);
2523 break;
2524 case OPT_SEMISOFT:
2525 args->flags |= NFSMNT_SOFT;
2526 args->flags |= NFSMNT_SEMISOFT;
2527 break;
2528 case OPT_HARD:
2529 args->flags &= ~(NFSMNT_SOFT);
2530 args->flags &= ~(NFSMNT_SEMISOFT);
2531 break;
2532 case OPT_NOSUID:
2533 case OPT_NODEVICES:
2534 case OPT_NOSETUID:
2535 case OPT_NOEXEC:
2536 cmn_err(CE_WARN,
2537 "nfs_dlboot: may not set root partition %s",
2538 optlist[opt]);
2539 break;
2540 case OPT_GRPID:
2541 args->flags |= NFSMNT_GRPID;
2542 break;
2543 case OPT_REMOUNT:
2544 cmn_err(CE_WARN,
2545 "nfs_dlboot: may not remount root partition");
2546 break;
2547 case OPT_INTR:
2548 args->flags |= NFSMNT_INT;
2549 break;
2550 case OPT_NOINTR:
2551 args->flags &= ~(NFSMNT_INT);
2552 break;
2553 case OPT_NOAC:
2554 args->flags |= NFSMNT_NOAC;
2555 break;
2556 case OPT_PORT:
2557 cmn_err(CE_WARN,
2558 "nfs_dlboot: may not change root port number");
2559 break;
2560 case OPT_SECURE:
2561 cmn_err(CE_WARN,
2562 "nfs_dlboot: root mounted auth_unix, secure ignored");
2563 break;
2564 case OPT_NOCTO:
2565 args->flags |= NFSMNT_NOCTO;
2566 break;
2567 case OPT_RSIZE:
2568 if (bad(val)) {
2569 cmn_err(CE_WARN,
2570 "nfs_dlboot: invalid option: rsize");
2571 break;
2572 }
2573 args->flags |= NFSMNT_RSIZE;
2574 args->rsize = atoi(val);
2575 break;
2576 case OPT_WSIZE:
2577 if (bad(val)) {
2578 cmn_err(CE_WARN,
2579 "nfs_dlboot: invalid option: wsize");
2580 break;
2581 }
2582 args->flags |= NFSMNT_WSIZE;
2583 args->wsize = atoi(val);
2584 break;
2585 case OPT_TIMEO:
2586 if (bad(val)) {
2587 cmn_err(CE_WARN,
2588 "nfs_dlboot: invalid option: timeo");
2589 break;
2590 }
2591 args->flags |= NFSMNT_TIMEO;
2592 args->timeo = atoi(val);
2593 break;
2594 case OPT_RETRANS:
2595 if (bad(val)) {
2596 cmn_err(CE_WARN,
2597 "nfs_dlboot: invalid option: retrans");
2598 break;
2599 }
2600 args->flags |= NFSMNT_RETRANS;
2601 args->retrans = atoi(val);
2602 break;
2603 case OPT_ACTIMEO:
2604 if (bad(val)) {
2605 cmn_err(CE_WARN,
2606 "nfs_dlboot: invalid option: actimeo");
2607 break;
2608 }
2609 args->flags |= NFSMNT_ACDIRMAX;
2610 args->flags |= NFSMNT_ACREGMAX;
2611 args->flags |= NFSMNT_ACDIRMIN;
2612 args->flags |= NFSMNT_ACREGMIN;
2613 args->acdirmin = args->acregmin = args->acdirmax =
2614 args->acregmax = atoi(val);
2615 break;
2616 case OPT_ACREGMIN:
2617 if (bad(val)) {
2618 cmn_err(CE_WARN,
2619 "nfs_dlboot: invalid option: acregmin");
2620 break;
2621 }
2622 args->flags |= NFSMNT_ACREGMIN;
2623 args->acregmin = atoi(val);
2624 break;
2625 case OPT_ACREGMAX:
2626 if (bad(val)) {
2627 cmn_err(CE_WARN,
2628 "nfs_dlboot: invalid option: acregmax");
2629 break;
2630 }
2631 args->flags |= NFSMNT_ACREGMAX;
2632 args->acregmax = atoi(val);
2633 break;
2634 case OPT_ACDIRMIN:
2635 if (bad(val)) {
2636 cmn_err(CE_WARN,
2637 "nfs_dlboot: invalid option: acdirmin");
2638 break;
2639 }
2640 args->flags |= NFSMNT_ACDIRMIN;
2641 args->acdirmin = atoi(val);
2642 break;
2643 case OPT_ACDIRMAX:
2644 if (bad(val)) {
2645 cmn_err(CE_WARN,
2646 "nfs_dlboot: invalid option: acdirmax");
2647 break;
2648 }
2649 args->flags |= NFSMNT_ACDIRMAX;
2650 args->acdirmax = atoi(val);
2651 break;
2652 case OPT_LLOCK:
2653 args->flags |= NFSMNT_LLOCK;
2654 break;
2655 case OPT_VERS:
2656 if (bad(val)) {
2657 cmn_err(CE_WARN,
2658 "nfs_dlboot: invalid option: vers");
2659 break;
2660 }
2661 vers = atoi(val);
2662 /*
2663 * If the requested version is less than what we
2664 * chose, pretend the chosen version doesn't exist
2665 */
2666 if (vers < version) {
2667 return (EPROTONOSUPPORT);
2668 }
2669 if (vers > version) {
2670 cmn_err(CE_WARN,
2671 "nfs_dlboot: version %d unavailable",
2672 vers);
2673 return (EINVAL);
2674 }
2675 break;
2676 case OPT_PROTO:
2677 /*
2678 * NFSv4 can only run over TCP, if they requested
2679 * UDP pretend v4 doesn't exist, they might not have
2680 * specified a version allowing a fallback to v2 or v3.
2681 */
2682 if (version == NFS_V4 && strcmp(val, NC_UDP) == 0)
2683 return (EPROTONOSUPPORT);
2684 /*
2685 * TCP is always chosen over UDP, so if the
2686 * requested is the same as the chosen either
2687 * they chose TCP when available or UDP on a UDP
2688 * only server.
2689 */
2690 if (strcmp(cf->knc_proto, val) == 0)
2691 break;
2692 /*
2693 * If we chose UDP, they must have requested TCP
2694 */
2695 if (strcmp(cf->knc_proto, NC_TCP) != 0) {
2696 cmn_err(CE_WARN,
2697 "nfs_dlboot: TCP protocol unavailable");
2698 return (EINVAL);
2699 }
2700 /*
2701 * They can only have requested UDP
2702 */
2703 if (strcmp(val, NC_UDP) != 0) {
2704 cmn_err(CE_WARN,
2705 "nfs_dlboot: unknown protocol");
2706 return (EINVAL);
2707 }
2708 *dl_cf = &dl_udp_netconf;
2709 break;
2710 case OPT_NOPRINT:
2711 args->flags |= NFSMNT_NOPRINT;
2712 break;
2713 case OPT_NOLARGEFILES:
2714 cmn_err(CE_WARN,
2715 "nfs_dlboot: NFS can't support nolargefiles");
2716 break;
2717 case OPT_SEC:
2718 cmn_err(CE_WARN,
2719 "nfs_dlboot: root mounted auth_unix, sec ignored");
2720 break;
2721
2722 case OPT_DIRECTIO:
2723 args->flags |= NFSMNT_DIRECTIO;
2724 break;
2725
2726 case OPT_NODIRECTIO:
2727 args->flags &= ~(NFSMNT_DIRECTIO);
2728 break;
2729
2730 default:
2731 cmn_err(CE_WARN,
2732 "nfs_dlboot: ignoring invalid option \"%s\"", val);
2733 break;
2734 }
2735 }
2736 sanity:
2737 /*
2738 * Set some sane limits on read size
2739 */
2740 if (!(args->flags & NFSMNT_RSIZE) || args->rsize == 0) {
2741 /*
2742 * Establish defaults
2743 */
2744 args->flags |= NFSMNT_RSIZE;
2745 if (version == NFS_V4)
2746 args->rsize = nfs4_root_rsize;
2747 else
2748 args->rsize = nfs_root_rsize;
2749 return (0);
2750 }
2751 /*
2752 * No less than 512 bytes, otherwise it will take forever to boot
2753 */
2754 if (args->rsize < 512)
2755 args->rsize = 512;
2756 /*
2757 * If we are running over UDP, we cannot exceed 64KB, trim
2758 * to 56KB to allow room for headers.
2759 */
2760 if (*dl_cf == &dl_udp_netconf && args->rsize > (56 * 1024))
2761 args->rsize = 56 * 1024;
2762 return (0);
2763 }