1 /*- 2 * SPDX-License-Identifier: BSD-3-Clause 3 * 4 * Copyright (c) 1989, 1993, 1994 5 * The Regents of the University of California. All rights reserved. 6 * 7 * This code is derived from software contributed to Berkeley by 8 * Rick Macklem at The University of Guelph. 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. Neither the name of the University nor the names of its contributors 19 * may be used to endorse or promote products derived from this software 20 * without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 */ 34 35 #include <sys/param.h> 36 #include <sys/syslog.h> 37 #include <sys/wait.h> 38 #include <sys/mount.h> 39 #include <sys/fcntl.h> 40 #include <sys/linker.h> 41 #include <sys/module.h> 42 #include <sys/types.h> 43 #include <sys/stat.h> 44 #include <sys/sysctl.h> 45 #include <sys/ucred.h> 46 47 #include <rpc/rpc.h> 48 #include <rpc/pmap_clnt.h> 49 #include <rpcsvc/nfs_prot.h> 50 51 #include <netdb.h> 52 #include <arpa/inet.h> 53 #include <nfs/nfssvc.h> 54 55 #include <fs/nfs/nfsproto.h> 56 #include <fs/nfs/nfskpiport.h> 57 #include <fs/nfs/nfs.h> 58 59 #include <err.h> 60 #include <errno.h> 61 #include <signal.h> 62 #include <stdio.h> 63 #include <stdlib.h> 64 #include <string.h> 65 #include <unistd.h> 66 #include <sysexits.h> 67 68 #include <getopt.h> 69 70 static int debug = 0; 71 72 #define NFSD_STABLERESTART "/var/db/nfs-stablerestart" 73 #define NFSD_STABLEBACKUP "/var/db/nfs-stablerestart.bak" 74 #define MAXNFSDCNT 256 75 #define DEFNFSDCNT 4 76 #define NFS_VER2 2 77 #define NFS_VER3 3 78 #define NFS_VER4 4 79 static pid_t children[MAXNFSDCNT]; /* PIDs of children */ 80 static pid_t masterpid; /* PID of master/parent */ 81 static int nfsdcnt; /* number of children */ 82 static int nfsdcnt_set; 83 static int minthreads; 84 static int maxthreads; 85 static int nfssvc_nfsd; /* Set to correct NFSSVC_xxx flag */ 86 static int stablefd = -1; /* Fd for the stable restart file */ 87 static int backupfd; /* Fd for the backup stable restart file */ 88 static const char *getopt_shortopts; 89 static const char *getopt_usage; 90 static int nfs_minvers = NFS_VER2; 91 92 static int minthreads_set; 93 static int maxthreads_set; 94 95 static struct option longopts[] = { 96 { "debug", no_argument, &debug, 1 }, 97 { "minthreads", required_argument, &minthreads_set, 1 }, 98 { "maxthreads", required_argument, &maxthreads_set, 1 }, 99 { "pnfs", required_argument, NULL, 'p' }, 100 { "mirror", required_argument, NULL, 'm' }, 101 { NULL, 0, NULL, 0} 102 }; 103 104 static void cleanup(int); 105 static void child_cleanup(int); 106 static void killchildren(void); 107 static void nfsd_exit(int); 108 static void nonfs(int); 109 static void reapchild(int); 110 static int setbindhost(struct addrinfo **ia, const char *bindhost, 111 struct addrinfo hints); 112 static void start_server(int, struct nfsd_nfsd_args *, const char *vhost); 113 static void unregistration(void); 114 static void usage(void); 115 static void open_stable(int *, int *); 116 static void copy_stable(int, int); 117 static void backup_stable(int); 118 static void set_nfsdcnt(int); 119 static void parse_dsserver(const char *, struct nfsd_nfsd_args *); 120 121 /* 122 * Nfs server daemon mostly just a user context for nfssvc() 123 * 124 * 1 - do file descriptor and signal cleanup 125 * 2 - fork the nfsd(s) 126 * 3 - create server socket(s) 127 * 4 - register socket with rpcbind 128 * 129 * For connectionless protocols, just pass the socket into the kernel via. 130 * nfssvc(). 131 * For connection based sockets, loop doing accepts. When you get a new 132 * socket from accept, pass the msgsock into the kernel via. nfssvc(). 133 * The arguments are: 134 * -r - reregister with rpcbind 135 * -d - unregister with rpcbind 136 * -t - support tcp nfs clients 137 * -u - support udp nfs clients 138 * -e - forces it to run a server that supports nfsv4 139 * -p - enable a pNFS service 140 * -m - set the mirroring level for a pNFS service 141 * followed by "n" which is the number of nfsds' to fork off 142 */ 143 int 144 main(int argc, char **argv) 145 { 146 struct nfsd_addsock_args addsockargs; 147 struct addrinfo *ai_udp, *ai_tcp, *ai_udp6, *ai_tcp6, hints; 148 struct netconfig *nconf_udp, *nconf_tcp, *nconf_udp6, *nconf_tcp6; 149 struct netbuf nb_udp, nb_tcp, nb_udp6, nb_tcp6; 150 struct sockaddr_storage peer; 151 fd_set ready, sockbits; 152 int ch, connect_type_cnt, i, maxsock, msgsock; 153 socklen_t len; 154 int on = 1, unregister, reregister, sock; 155 int tcp6sock, ip6flag, tcpflag, tcpsock; 156 int udpflag, ecode, error, s; 157 int bindhostc, bindanyflag, rpcbreg, rpcbregcnt; 158 int nfssvc_addsock; 159 int jailed, longindex = 0; 160 size_t jailed_size, nfs_minvers_size; 161 const char *lopt; 162 char **bindhost = NULL; 163 pid_t pid; 164 struct nfsd_nfsd_args nfsdargs; 165 const char *vhostname = NULL; 166 167 nfsdargs.mirrorcnt = 1; 168 nfsdargs.addr = NULL; 169 nfsdargs.addrlen = 0; 170 nfsdcnt = DEFNFSDCNT; 171 unregister = reregister = tcpflag = maxsock = 0; 172 bindanyflag = udpflag = connect_type_cnt = bindhostc = 0; 173 getopt_shortopts = "ah:n:rdtuep:m:V:"; 174 getopt_usage = 175 "usage:\n" 176 " nfsd [-ardtue] [-h bindip]\n" 177 " [-n numservers] [--minthreads #] [--maxthreads #]\n" 178 " [-p/--pnfs dsserver0:/dsserver0-mounted-on-dir,...," 179 "dsserverN:/dsserverN-mounted-on-dir] [-m mirrorlevel]\n" 180 " [-V virtual_hostname]\n"; 181 while ((ch = getopt_long(argc, argv, getopt_shortopts, longopts, 182 &longindex)) != -1) 183 switch (ch) { 184 case 'V': 185 if (strlen(optarg) <= MAXHOSTNAMELEN) 186 vhostname = optarg; 187 else 188 warnx("Virtual host name (%s) is too long", 189 optarg); 190 break; 191 case 'a': 192 bindanyflag = 1; 193 break; 194 case 'n': 195 set_nfsdcnt(atoi(optarg)); 196 break; 197 case 'h': 198 bindhostc++; 199 bindhost = realloc(bindhost,sizeof(char *)*bindhostc); 200 if (bindhost == NULL) 201 errx(1, "Out of memory"); 202 bindhost[bindhostc-1] = strdup(optarg); 203 if (bindhost[bindhostc-1] == NULL) 204 errx(1, "Out of memory"); 205 break; 206 case 'r': 207 reregister = 1; 208 break; 209 case 'd': 210 unregister = 1; 211 break; 212 case 't': 213 tcpflag = 1; 214 break; 215 case 'u': 216 udpflag = 1; 217 break; 218 case 'e': 219 /* now a no-op, since this is the default */ 220 break; 221 case 'p': 222 /* Parse out the DS server host names and mount pts. */ 223 parse_dsserver(optarg, &nfsdargs); 224 break; 225 case 'm': 226 /* Set the mirror level for a pNFS service. */ 227 i = atoi(optarg); 228 if (i < 2 || i > NFSDEV_MAXMIRRORS) 229 errx(1, "Mirror level out of range 2<-->%d", 230 NFSDEV_MAXMIRRORS); 231 nfsdargs.mirrorcnt = i; 232 break; 233 case 0: 234 lopt = longopts[longindex].name; 235 if (!strcmp(lopt, "minthreads")) { 236 minthreads = atoi(optarg); 237 } else if (!strcmp(lopt, "maxthreads")) { 238 maxthreads = atoi(optarg); 239 } 240 break; 241 default: 242 case '?': 243 usage(); 244 } 245 if (!tcpflag && !udpflag) 246 udpflag = 1; 247 argv += optind; 248 argc -= optind; 249 if (minthreads_set && maxthreads_set && minthreads > maxthreads) 250 errx(EX_USAGE, 251 "error: minthreads(%d) can't be greater than " 252 "maxthreads(%d)", minthreads, maxthreads); 253 254 /* 255 * XXX 256 * Backward compatibility, trailing number is the count of daemons. 257 */ 258 if (argc > 1) 259 usage(); 260 if (argc == 1) 261 set_nfsdcnt(atoi(argv[0])); 262 263 /* 264 * Unless the "-o" option was specified, try and run "nfsd". 265 * If "-o" was specified, try and run "nfsserver". 266 */ 267 if (modfind("nfsd") < 0) { 268 /* Not present in kernel, try loading it */ 269 if (kldload("nfsd") < 0 || modfind("nfsd") < 0) 270 errx(1, "NFS server is not available"); 271 } 272 273 ip6flag = 1; 274 s = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP); 275 if (s == -1) { 276 if (errno != EPROTONOSUPPORT && errno != EAFNOSUPPORT) 277 err(1, "socket"); 278 ip6flag = 0; 279 } else if (getnetconfigent("udp6") == NULL || 280 getnetconfigent("tcp6") == NULL) { 281 ip6flag = 0; 282 } 283 if (s != -1) 284 close(s); 285 286 if (bindhostc == 0 || bindanyflag) { 287 bindhostc++; 288 bindhost = realloc(bindhost,sizeof(char *)*bindhostc); 289 if (bindhost == NULL) 290 errx(1, "Out of memory"); 291 bindhost[bindhostc-1] = strdup("*"); 292 if (bindhost[bindhostc-1] == NULL) 293 errx(1, "Out of memory"); 294 } 295 296 if (unregister) { 297 /* 298 * Unregister before setting nfs_minvers, in case the 299 * value of vfs.nfsd.server_min_nfsvers has changed 300 * since registering with rpcbind. 301 */ 302 unregistration(); 303 exit (0); 304 } 305 306 nfs_minvers_size = sizeof(nfs_minvers); 307 error = sysctlbyname("vfs.nfsd.server_min_nfsvers", &nfs_minvers, 308 &nfs_minvers_size, NULL, 0); 309 if (error != 0 || nfs_minvers < NFS_VER2 || nfs_minvers > NFS_VER4) { 310 warnx("sysctlbyname(vfs.nfsd.server_min_nfsvers) failed," 311 " defaulting to NFSv2"); 312 nfs_minvers = NFS_VER2; 313 } 314 315 if (reregister) { 316 if (udpflag) { 317 memset(&hints, 0, sizeof hints); 318 hints.ai_flags = AI_PASSIVE; 319 hints.ai_family = AF_INET; 320 hints.ai_socktype = SOCK_DGRAM; 321 hints.ai_protocol = IPPROTO_UDP; 322 ecode = getaddrinfo(NULL, "nfs", &hints, &ai_udp); 323 if (ecode != 0) 324 err(1, "getaddrinfo udp: %s", gai_strerror(ecode)); 325 nconf_udp = getnetconfigent("udp"); 326 if (nconf_udp == NULL) 327 err(1, "getnetconfigent udp failed"); 328 nb_udp.buf = ai_udp->ai_addr; 329 nb_udp.len = nb_udp.maxlen = ai_udp->ai_addrlen; 330 if (nfs_minvers == NFS_VER2) 331 if (!rpcb_set(NFS_PROGRAM, 2, nconf_udp, 332 &nb_udp)) 333 err(1, "rpcb_set udp failed"); 334 if (nfs_minvers <= NFS_VER3) 335 if (!rpcb_set(NFS_PROGRAM, 3, nconf_udp, 336 &nb_udp)) 337 err(1, "rpcb_set udp failed"); 338 freeaddrinfo(ai_udp); 339 } 340 if (udpflag && ip6flag) { 341 memset(&hints, 0, sizeof hints); 342 hints.ai_flags = AI_PASSIVE; 343 hints.ai_family = AF_INET6; 344 hints.ai_socktype = SOCK_DGRAM; 345 hints.ai_protocol = IPPROTO_UDP; 346 ecode = getaddrinfo(NULL, "nfs", &hints, &ai_udp6); 347 if (ecode != 0) 348 err(1, "getaddrinfo udp6: %s", gai_strerror(ecode)); 349 nconf_udp6 = getnetconfigent("udp6"); 350 if (nconf_udp6 == NULL) 351 err(1, "getnetconfigent udp6 failed"); 352 nb_udp6.buf = ai_udp6->ai_addr; 353 nb_udp6.len = nb_udp6.maxlen = ai_udp6->ai_addrlen; 354 if (nfs_minvers == NFS_VER2) 355 if (!rpcb_set(NFS_PROGRAM, 2, nconf_udp6, 356 &nb_udp6)) 357 err(1, "rpcb_set udp6 failed"); 358 if (nfs_minvers <= NFS_VER3) 359 if (!rpcb_set(NFS_PROGRAM, 3, nconf_udp6, 360 &nb_udp6)) 361 err(1, "rpcb_set udp6 failed"); 362 freeaddrinfo(ai_udp6); 363 } 364 if (tcpflag) { 365 memset(&hints, 0, sizeof hints); 366 hints.ai_flags = AI_PASSIVE; 367 hints.ai_family = AF_INET; 368 hints.ai_socktype = SOCK_STREAM; 369 hints.ai_protocol = IPPROTO_TCP; 370 ecode = getaddrinfo(NULL, "nfs", &hints, &ai_tcp); 371 if (ecode != 0) 372 err(1, "getaddrinfo tcp: %s", gai_strerror(ecode)); 373 nconf_tcp = getnetconfigent("tcp"); 374 if (nconf_tcp == NULL) 375 err(1, "getnetconfigent tcp failed"); 376 nb_tcp.buf = ai_tcp->ai_addr; 377 nb_tcp.len = nb_tcp.maxlen = ai_tcp->ai_addrlen; 378 if (nfs_minvers == NFS_VER2) 379 if (!rpcb_set(NFS_PROGRAM, 2, nconf_tcp, 380 &nb_tcp)) 381 err(1, "rpcb_set tcp failed"); 382 if (nfs_minvers <= NFS_VER3) 383 if (!rpcb_set(NFS_PROGRAM, 3, nconf_tcp, 384 &nb_tcp)) 385 err(1, "rpcb_set tcp failed"); 386 freeaddrinfo(ai_tcp); 387 } 388 if (tcpflag && ip6flag) { 389 memset(&hints, 0, sizeof hints); 390 hints.ai_flags = AI_PASSIVE; 391 hints.ai_family = AF_INET6; 392 hints.ai_socktype = SOCK_STREAM; 393 hints.ai_protocol = IPPROTO_TCP; 394 ecode = getaddrinfo(NULL, "nfs", &hints, &ai_tcp6); 395 if (ecode != 0) 396 err(1, "getaddrinfo tcp6: %s", gai_strerror(ecode)); 397 nconf_tcp6 = getnetconfigent("tcp6"); 398 if (nconf_tcp6 == NULL) 399 err(1, "getnetconfigent tcp6 failed"); 400 nb_tcp6.buf = ai_tcp6->ai_addr; 401 nb_tcp6.len = nb_tcp6.maxlen = ai_tcp6->ai_addrlen; 402 if (nfs_minvers == NFS_VER2) 403 if (!rpcb_set(NFS_PROGRAM, 2, nconf_tcp6, 404 &nb_tcp6)) 405 err(1, "rpcb_set tcp6 failed"); 406 if (nfs_minvers <= NFS_VER3) 407 if (!rpcb_set(NFS_PROGRAM, 3, nconf_tcp6, 408 &nb_tcp6)) 409 err(1, "rpcb_set tcp6 failed"); 410 freeaddrinfo(ai_tcp6); 411 } 412 exit (0); 413 } 414 if (debug == 0) { 415 daemon(0, 0); 416 (void)signal(SIGHUP, SIG_IGN); 417 (void)signal(SIGINT, SIG_IGN); 418 /* 419 * nfsd sits in the kernel most of the time. It needs 420 * to ignore SIGTERM/SIGQUIT in order to stay alive as long 421 * as possible during a shutdown, otherwise loopback 422 * mounts will not be able to unmount. 423 */ 424 (void)signal(SIGTERM, SIG_IGN); 425 (void)signal(SIGQUIT, SIG_IGN); 426 } 427 (void)signal(SIGSYS, nonfs); 428 (void)signal(SIGCHLD, reapchild); 429 (void)signal(SIGUSR2, backup_stable); 430 431 openlog("nfsd", LOG_PID | (debug ? LOG_PERROR : 0), LOG_DAEMON); 432 433 /* 434 * For V4, we open the stablerestart file and call nfssvc() 435 * to get it loaded. This is done before the daemons do the 436 * regular nfssvc() call to service NFS requests. 437 * (This way the file remains open until the last nfsd is killed 438 * off.) 439 * It and the backup copy will be created as empty files 440 * the first time this nfsd is started and should never be 441 * deleted/replaced if at all possible. It should live on a 442 * local, non-volatile storage device that does not do hardware 443 * level write-back caching. (See SCSI doc for more information 444 * on how to prevent write-back caching on SCSI disks.) 445 */ 446 open_stable(&stablefd, &backupfd); 447 if (stablefd < 0) { 448 syslog(LOG_ERR, "Can't open %s: %m\n", NFSD_STABLERESTART); 449 exit(1); 450 } 451 /* This system call will fail for old kernels, but that's ok. */ 452 nfssvc(NFSSVC_BACKUPSTABLE, NULL); 453 if (nfssvc(NFSSVC_STABLERESTART, (caddr_t)&stablefd) < 0) { 454 if (errno == EPERM) { 455 jailed = 0; 456 jailed_size = sizeof(jailed); 457 sysctlbyname("security.jail.jailed", &jailed, 458 &jailed_size, NULL, 0); 459 if (jailed != 0) 460 syslog(LOG_ERR, "nfssvc stablerestart failed: " 461 "allow.nfsd might not be configured"); 462 else 463 syslog(LOG_ERR, "nfssvc stablerestart failed"); 464 } else if (errno == ENXIO) 465 syslog(LOG_ERR, "nfssvc stablerestart failed: is nfsd " 466 "already running?"); 467 else 468 syslog(LOG_ERR, "Can't read stable storage file: %m\n"); 469 exit(1); 470 } 471 nfssvc_addsock = NFSSVC_NFSDADDSOCK; 472 nfssvc_nfsd = NFSSVC_NFSDNFSD | NFSSVC_NEWSTRUCT; 473 474 if (tcpflag) { 475 /* 476 * For TCP mode, we fork once to start the first 477 * kernel nfsd thread. The kernel will add more 478 * threads as needed. 479 */ 480 masterpid = getpid(); 481 pid = fork(); 482 if (pid == -1) { 483 syslog(LOG_ERR, "fork: %m"); 484 nfsd_exit(1); 485 } 486 if (pid) { 487 children[0] = pid; 488 } else { 489 (void)signal(SIGUSR1, child_cleanup); 490 setproctitle("server"); 491 start_server(0, &nfsdargs, vhostname); 492 } 493 } 494 495 (void)signal(SIGUSR1, cleanup); 496 FD_ZERO(&sockbits); 497 498 rpcbregcnt = 0; 499 /* Set up the socket for udp and rpcb register it. */ 500 if (udpflag) { 501 rpcbreg = 0; 502 for (i = 0; i < bindhostc; i++) { 503 memset(&hints, 0, sizeof hints); 504 hints.ai_flags = AI_PASSIVE; 505 hints.ai_family = AF_INET; 506 hints.ai_socktype = SOCK_DGRAM; 507 hints.ai_protocol = IPPROTO_UDP; 508 if (setbindhost(&ai_udp, bindhost[i], hints) == 0) { 509 rpcbreg = 1; 510 rpcbregcnt++; 511 if ((sock = socket(ai_udp->ai_family, 512 ai_udp->ai_socktype, 513 ai_udp->ai_protocol)) < 0) { 514 syslog(LOG_ERR, 515 "can't create udp socket"); 516 nfsd_exit(1); 517 } 518 if (bind(sock, ai_udp->ai_addr, 519 ai_udp->ai_addrlen) < 0) { 520 syslog(LOG_ERR, 521 "can't bind udp addr %s: %m", 522 bindhost[i]); 523 nfsd_exit(1); 524 } 525 freeaddrinfo(ai_udp); 526 addsockargs.sock = sock; 527 addsockargs.name = NULL; 528 addsockargs.namelen = 0; 529 if (nfssvc(nfssvc_addsock, &addsockargs) < 0) { 530 syslog(LOG_ERR, "can't Add UDP socket"); 531 nfsd_exit(1); 532 } 533 (void)close(sock); 534 } 535 } 536 if (rpcbreg == 1) { 537 memset(&hints, 0, sizeof hints); 538 hints.ai_flags = AI_PASSIVE; 539 hints.ai_family = AF_INET; 540 hints.ai_socktype = SOCK_DGRAM; 541 hints.ai_protocol = IPPROTO_UDP; 542 ecode = getaddrinfo(NULL, "nfs", &hints, &ai_udp); 543 if (ecode != 0) { 544 syslog(LOG_ERR, "getaddrinfo udp: %s", 545 gai_strerror(ecode)); 546 nfsd_exit(1); 547 } 548 nconf_udp = getnetconfigent("udp"); 549 if (nconf_udp == NULL) 550 err(1, "getnetconfigent udp failed"); 551 nb_udp.buf = ai_udp->ai_addr; 552 nb_udp.len = nb_udp.maxlen = ai_udp->ai_addrlen; 553 if (nfs_minvers == NFS_VER2) 554 if (!rpcb_set(NFS_PROGRAM, 2, nconf_udp, 555 &nb_udp)) 556 err(1, "rpcb_set udp failed"); 557 if (nfs_minvers <= NFS_VER3) 558 if (!rpcb_set(NFS_PROGRAM, 3, nconf_udp, 559 &nb_udp)) 560 err(1, "rpcb_set udp failed"); 561 freeaddrinfo(ai_udp); 562 } 563 } 564 565 /* Set up the socket for udp6 and rpcb register it. */ 566 if (udpflag && ip6flag) { 567 rpcbreg = 0; 568 for (i = 0; i < bindhostc; i++) { 569 memset(&hints, 0, sizeof hints); 570 hints.ai_flags = AI_PASSIVE; 571 hints.ai_family = AF_INET6; 572 hints.ai_socktype = SOCK_DGRAM; 573 hints.ai_protocol = IPPROTO_UDP; 574 if (setbindhost(&ai_udp6, bindhost[i], hints) == 0) { 575 rpcbreg = 1; 576 rpcbregcnt++; 577 if ((sock = socket(ai_udp6->ai_family, 578 ai_udp6->ai_socktype, 579 ai_udp6->ai_protocol)) < 0) { 580 syslog(LOG_ERR, 581 "can't create udp6 socket"); 582 nfsd_exit(1); 583 } 584 if (setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, 585 &on, sizeof on) < 0) { 586 syslog(LOG_ERR, 587 "can't set v6-only binding for " 588 "udp6 socket: %m"); 589 nfsd_exit(1); 590 } 591 if (bind(sock, ai_udp6->ai_addr, 592 ai_udp6->ai_addrlen) < 0) { 593 syslog(LOG_ERR, 594 "can't bind udp6 addr %s: %m", 595 bindhost[i]); 596 nfsd_exit(1); 597 } 598 freeaddrinfo(ai_udp6); 599 addsockargs.sock = sock; 600 addsockargs.name = NULL; 601 addsockargs.namelen = 0; 602 if (nfssvc(nfssvc_addsock, &addsockargs) < 0) { 603 syslog(LOG_ERR, 604 "can't add UDP6 socket"); 605 nfsd_exit(1); 606 } 607 (void)close(sock); 608 } 609 } 610 if (rpcbreg == 1) { 611 memset(&hints, 0, sizeof hints); 612 hints.ai_flags = AI_PASSIVE; 613 hints.ai_family = AF_INET6; 614 hints.ai_socktype = SOCK_DGRAM; 615 hints.ai_protocol = IPPROTO_UDP; 616 ecode = getaddrinfo(NULL, "nfs", &hints, &ai_udp6); 617 if (ecode != 0) { 618 syslog(LOG_ERR, "getaddrinfo udp6: %s", 619 gai_strerror(ecode)); 620 nfsd_exit(1); 621 } 622 nconf_udp6 = getnetconfigent("udp6"); 623 if (nconf_udp6 == NULL) 624 err(1, "getnetconfigent udp6 failed"); 625 nb_udp6.buf = ai_udp6->ai_addr; 626 nb_udp6.len = nb_udp6.maxlen = ai_udp6->ai_addrlen; 627 if (nfs_minvers == NFS_VER2) 628 if (!rpcb_set(NFS_PROGRAM, 2, nconf_udp6, 629 &nb_udp6)) 630 err(1, 631 "rpcb_set udp6 failed"); 632 if (nfs_minvers <= NFS_VER3) 633 if (!rpcb_set(NFS_PROGRAM, 3, nconf_udp6, 634 &nb_udp6)) 635 err(1, 636 "rpcb_set udp6 failed"); 637 freeaddrinfo(ai_udp6); 638 } 639 } 640 641 /* Set up the socket for tcp and rpcb register it. */ 642 if (tcpflag) { 643 rpcbreg = 0; 644 for (i = 0; i < bindhostc; i++) { 645 memset(&hints, 0, sizeof hints); 646 hints.ai_flags = AI_PASSIVE; 647 hints.ai_family = AF_INET; 648 hints.ai_socktype = SOCK_STREAM; 649 hints.ai_protocol = IPPROTO_TCP; 650 if (setbindhost(&ai_tcp, bindhost[i], hints) == 0) { 651 rpcbreg = 1; 652 rpcbregcnt++; 653 if ((tcpsock = socket(AF_INET, SOCK_STREAM, 654 0)) < 0) { 655 syslog(LOG_ERR, 656 "can't create tcp socket"); 657 nfsd_exit(1); 658 } 659 if (setsockopt(tcpsock, SOL_SOCKET, 660 SO_REUSEADDR, 661 (char *)&on, sizeof(on)) < 0) 662 syslog(LOG_ERR, 663 "setsockopt SO_REUSEADDR: %m"); 664 if (bind(tcpsock, ai_tcp->ai_addr, 665 ai_tcp->ai_addrlen) < 0) { 666 syslog(LOG_ERR, 667 "can't bind tcp addr %s: %m", 668 bindhost[i]); 669 nfsd_exit(1); 670 } 671 if (listen(tcpsock, -1) < 0) { 672 syslog(LOG_ERR, "listen failed"); 673 nfsd_exit(1); 674 } 675 freeaddrinfo(ai_tcp); 676 FD_SET(tcpsock, &sockbits); 677 maxsock = tcpsock; 678 connect_type_cnt++; 679 } 680 } 681 if (rpcbreg == 1) { 682 memset(&hints, 0, sizeof hints); 683 hints.ai_flags = AI_PASSIVE; 684 hints.ai_family = AF_INET; 685 hints.ai_socktype = SOCK_STREAM; 686 hints.ai_protocol = IPPROTO_TCP; 687 ecode = getaddrinfo(NULL, "nfs", &hints, 688 &ai_tcp); 689 if (ecode != 0) { 690 syslog(LOG_ERR, "getaddrinfo tcp: %s", 691 gai_strerror(ecode)); 692 nfsd_exit(1); 693 } 694 nconf_tcp = getnetconfigent("tcp"); 695 if (nconf_tcp == NULL) 696 err(1, "getnetconfigent tcp failed"); 697 nb_tcp.buf = ai_tcp->ai_addr; 698 nb_tcp.len = nb_tcp.maxlen = ai_tcp->ai_addrlen; 699 if (nfs_minvers == NFS_VER2) 700 if (!rpcb_set(NFS_PROGRAM, 2, nconf_tcp, 701 &nb_tcp)) 702 err(1, "rpcb_set tcp failed"); 703 if (nfs_minvers <= NFS_VER3) 704 if (!rpcb_set(NFS_PROGRAM, 3, nconf_tcp, 705 &nb_tcp)) 706 err(1, "rpcb_set tcp failed"); 707 freeaddrinfo(ai_tcp); 708 } 709 } 710 711 /* Set up the socket for tcp6 and rpcb register it. */ 712 if (tcpflag && ip6flag) { 713 rpcbreg = 0; 714 for (i = 0; i < bindhostc; i++) { 715 memset(&hints, 0, sizeof hints); 716 hints.ai_flags = AI_PASSIVE; 717 hints.ai_family = AF_INET6; 718 hints.ai_socktype = SOCK_STREAM; 719 hints.ai_protocol = IPPROTO_TCP; 720 if (setbindhost(&ai_tcp6, bindhost[i], hints) == 0) { 721 rpcbreg = 1; 722 rpcbregcnt++; 723 if ((tcp6sock = socket(ai_tcp6->ai_family, 724 ai_tcp6->ai_socktype, 725 ai_tcp6->ai_protocol)) < 0) { 726 syslog(LOG_ERR, 727 "can't create tcp6 socket"); 728 nfsd_exit(1); 729 } 730 if (setsockopt(tcp6sock, SOL_SOCKET, 731 SO_REUSEADDR, 732 (char *)&on, sizeof(on)) < 0) 733 syslog(LOG_ERR, 734 "setsockopt SO_REUSEADDR: %m"); 735 if (setsockopt(tcp6sock, IPPROTO_IPV6, 736 IPV6_V6ONLY, &on, sizeof on) < 0) { 737 syslog(LOG_ERR, 738 "can't set v6-only binding for tcp6 " 739 "socket: %m"); 740 nfsd_exit(1); 741 } 742 if (bind(tcp6sock, ai_tcp6->ai_addr, 743 ai_tcp6->ai_addrlen) < 0) { 744 syslog(LOG_ERR, 745 "can't bind tcp6 addr %s: %m", 746 bindhost[i]); 747 nfsd_exit(1); 748 } 749 if (listen(tcp6sock, -1) < 0) { 750 syslog(LOG_ERR, "listen failed"); 751 nfsd_exit(1); 752 } 753 freeaddrinfo(ai_tcp6); 754 FD_SET(tcp6sock, &sockbits); 755 if (maxsock < tcp6sock) 756 maxsock = tcp6sock; 757 connect_type_cnt++; 758 } 759 } 760 if (rpcbreg == 1) { 761 memset(&hints, 0, sizeof hints); 762 hints.ai_flags = AI_PASSIVE; 763 hints.ai_family = AF_INET6; 764 hints.ai_socktype = SOCK_STREAM; 765 hints.ai_protocol = IPPROTO_TCP; 766 ecode = getaddrinfo(NULL, "nfs", &hints, &ai_tcp6); 767 if (ecode != 0) { 768 syslog(LOG_ERR, "getaddrinfo tcp6: %s", 769 gai_strerror(ecode)); 770 nfsd_exit(1); 771 } 772 nconf_tcp6 = getnetconfigent("tcp6"); 773 if (nconf_tcp6 == NULL) 774 err(1, "getnetconfigent tcp6 failed"); 775 nb_tcp6.buf = ai_tcp6->ai_addr; 776 nb_tcp6.len = nb_tcp6.maxlen = ai_tcp6->ai_addrlen; 777 if (nfs_minvers == NFS_VER2) 778 if (!rpcb_set(NFS_PROGRAM, 2, nconf_tcp6, 779 &nb_tcp6)) 780 err(1, "rpcb_set tcp6 failed"); 781 if (nfs_minvers <= NFS_VER3) 782 if (!rpcb_set(NFS_PROGRAM, 3, nconf_tcp6, 783 &nb_tcp6)) 784 err(1, "rpcb_set tcp6 failed"); 785 freeaddrinfo(ai_tcp6); 786 } 787 } 788 789 if (rpcbregcnt == 0) { 790 syslog(LOG_ERR, "rpcb_set() failed, nothing to do: %m"); 791 nfsd_exit(1); 792 } 793 794 if (tcpflag && connect_type_cnt == 0) { 795 syslog(LOG_ERR, "tcp connects == 0, nothing to do: %m"); 796 nfsd_exit(1); 797 } 798 799 setproctitle("master"); 800 /* 801 * We always want a master to have a clean way to shut nfsd down 802 * (with unregistration): if the master is killed, it unregisters and 803 * kills all children. If we run for UDP only (and so do not have to 804 * loop waiting for accept), we instead make the parent 805 * a "server" too. start_server will not return. 806 */ 807 if (!tcpflag) 808 start_server(1, &nfsdargs, vhostname); 809 810 /* 811 * Loop forever accepting connections and passing the sockets 812 * into the kernel for the mounts. 813 */ 814 for (;;) { 815 ready = sockbits; 816 if (connect_type_cnt > 1) { 817 if (select(maxsock + 1, 818 &ready, NULL, NULL, NULL) < 1) { 819 error = errno; 820 if (error == EINTR) 821 continue; 822 syslog(LOG_ERR, "select failed: %m"); 823 nfsd_exit(1); 824 } 825 } 826 for (tcpsock = 0; tcpsock <= maxsock; tcpsock++) { 827 if (FD_ISSET(tcpsock, &ready)) { 828 len = sizeof(peer); 829 if ((msgsock = accept(tcpsock, 830 (struct sockaddr *)&peer, &len)) < 0) { 831 error = errno; 832 syslog(LOG_ERR, "accept failed: %m"); 833 if (error == ECONNABORTED || 834 error == EINTR) 835 continue; 836 nfsd_exit(1); 837 } 838 if (setsockopt(msgsock, SOL_SOCKET, 839 SO_KEEPALIVE, (char *)&on, sizeof(on)) < 0) 840 syslog(LOG_ERR, 841 "setsockopt SO_KEEPALIVE: %m"); 842 addsockargs.sock = msgsock; 843 addsockargs.name = (caddr_t)&peer; 844 addsockargs.namelen = len; 845 nfssvc(nfssvc_addsock, &addsockargs); 846 (void)close(msgsock); 847 } 848 } 849 } 850 } 851 852 static int 853 setbindhost(struct addrinfo **ai, const char *bindhost, struct addrinfo hints) 854 { 855 int ecode; 856 u_int32_t host_addr[4]; /* IPv4 or IPv6 */ 857 const char *hostptr; 858 859 if (bindhost == NULL || strcmp("*", bindhost) == 0) 860 hostptr = NULL; 861 else 862 hostptr = bindhost; 863 864 if (hostptr != NULL) { 865 switch (hints.ai_family) { 866 case AF_INET: 867 if (inet_pton(AF_INET, hostptr, host_addr) == 1) { 868 hints.ai_flags = AI_NUMERICHOST; 869 } else { 870 if (inet_pton(AF_INET6, hostptr, 871 host_addr) == 1) 872 return (1); 873 } 874 break; 875 case AF_INET6: 876 if (inet_pton(AF_INET6, hostptr, host_addr) == 1) { 877 hints.ai_flags = AI_NUMERICHOST; 878 } else { 879 if (inet_pton(AF_INET, hostptr, 880 host_addr) == 1) 881 return (1); 882 } 883 break; 884 default: 885 break; 886 } 887 } 888 889 ecode = getaddrinfo(hostptr, "nfs", &hints, ai); 890 if (ecode != 0) { 891 syslog(LOG_ERR, "getaddrinfo %s: %s", bindhost, 892 gai_strerror(ecode)); 893 return (1); 894 } 895 return (0); 896 } 897 898 static void 899 set_nfsdcnt(int proposed) 900 { 901 902 if (proposed < 1) { 903 warnx("nfsd count too low %d; reset to %d", proposed, 904 DEFNFSDCNT); 905 nfsdcnt = DEFNFSDCNT; 906 } else if (proposed > MAXNFSDCNT) { 907 warnx("nfsd count too high %d; truncated to %d", proposed, 908 MAXNFSDCNT); 909 nfsdcnt = MAXNFSDCNT; 910 } else 911 nfsdcnt = proposed; 912 nfsdcnt_set = 1; 913 } 914 915 static void 916 usage(void) 917 { 918 (void)fprintf(stderr, "%s", getopt_usage); 919 exit(1); 920 } 921 922 static void 923 nonfs(__unused int signo) 924 { 925 syslog(LOG_ERR, "missing system call: NFS not available"); 926 } 927 928 static void 929 reapchild(__unused int signo) 930 { 931 pid_t pid; 932 int i; 933 934 while ((pid = wait3(NULL, WNOHANG, NULL)) > 0) { 935 for (i = 0; i < nfsdcnt; i++) 936 if (pid == children[i]) 937 children[i] = -1; 938 } 939 } 940 941 static void 942 unregistration(void) 943 { 944 if ((nfs_minvers == NFS_VER2 && !rpcb_unset(NFS_PROGRAM, 2, NULL)) || 945 (nfs_minvers <= NFS_VER3 && !rpcb_unset(NFS_PROGRAM, 3, NULL))) 946 syslog(LOG_ERR, "rpcb_unset failed"); 947 } 948 949 static void 950 killchildren(void) 951 { 952 int i; 953 954 for (i = 0; i < nfsdcnt; i++) { 955 if (children[i] > 0) 956 kill(children[i], SIGKILL); 957 } 958 } 959 960 /* 961 * Cleanup master after SIGUSR1. 962 */ 963 static void 964 cleanup(__unused int signo) 965 { 966 nfsd_exit(0); 967 } 968 969 /* 970 * Cleanup child after SIGUSR1. 971 */ 972 static void 973 child_cleanup(__unused int signo) 974 { 975 exit(0); 976 } 977 978 static void 979 nfsd_exit(int status) 980 { 981 killchildren(); 982 unregistration(); 983 exit(status); 984 } 985 986 static int 987 get_tuned_nfsdcount(void) 988 { 989 int ncpu, error, tuned_nfsdcnt; 990 size_t ncpu_size; 991 992 ncpu_size = sizeof(ncpu); 993 error = sysctlbyname("hw.ncpu", &ncpu, &ncpu_size, NULL, 0); 994 if (error) { 995 warnx("sysctlbyname(hw.ncpu) failed defaulting to %d nfs servers", 996 DEFNFSDCNT); 997 tuned_nfsdcnt = DEFNFSDCNT; 998 } else { 999 tuned_nfsdcnt = ncpu * 8; 1000 } 1001 return tuned_nfsdcnt; 1002 } 1003 1004 static void 1005 start_server(int master, struct nfsd_nfsd_args *nfsdargp, const char *vhost) 1006 { 1007 char principal[MAXHOSTNAMELEN + 5]; 1008 int status, error; 1009 char hostname[MAXHOSTNAMELEN + 1], *cp; 1010 struct addrinfo *aip, hints; 1011 1012 status = 0; 1013 if (vhost == NULL) 1014 gethostname(hostname, sizeof (hostname)); 1015 else 1016 strlcpy(hostname, vhost, sizeof (hostname)); 1017 snprintf(principal, sizeof (principal), "nfs@%s", hostname); 1018 if ((cp = strchr(hostname, '.')) == NULL || 1019 *(cp + 1) == '\0') { 1020 /* If not fully qualified, try getaddrinfo() */ 1021 memset((void *)&hints, 0, sizeof (hints)); 1022 hints.ai_flags = AI_CANONNAME; 1023 error = getaddrinfo(hostname, NULL, &hints, &aip); 1024 if (error == 0) { 1025 if (aip->ai_canonname != NULL && 1026 (cp = strchr(aip->ai_canonname, '.')) != 1027 NULL && *(cp + 1) != '\0') 1028 snprintf(principal, sizeof (principal), 1029 "nfs@%s", aip->ai_canonname); 1030 freeaddrinfo(aip); 1031 } 1032 } 1033 nfsdargp->principal = principal; 1034 1035 if (nfsdcnt_set) 1036 nfsdargp->minthreads = nfsdargp->maxthreads = nfsdcnt; 1037 else { 1038 nfsdargp->minthreads = minthreads_set ? minthreads : get_tuned_nfsdcount(); 1039 nfsdargp->maxthreads = maxthreads_set ? maxthreads : nfsdargp->minthreads; 1040 if (nfsdargp->maxthreads < nfsdargp->minthreads) 1041 nfsdargp->maxthreads = nfsdargp->minthreads; 1042 } 1043 error = nfssvc(nfssvc_nfsd, nfsdargp); 1044 if (error < 0 && errno == EAUTH) { 1045 /* 1046 * This indicates that it could not register the 1047 * rpcsec_gss credentials, usually because the 1048 * gssd daemon isn't running. 1049 * (only the experimental server with nfsv4) 1050 */ 1051 syslog(LOG_ERR, "No gssd, using AUTH_SYS only"); 1052 principal[0] = '\0'; 1053 error = nfssvc(nfssvc_nfsd, nfsdargp); 1054 } 1055 if (error < 0) { 1056 if (errno == ENXIO) { 1057 syslog(LOG_ERR, "Bad -p option, cannot run"); 1058 if (masterpid != 0 && master == 0) 1059 kill(masterpid, SIGUSR1); 1060 } else 1061 syslog(LOG_ERR, "nfssvc: %m"); 1062 status = 1; 1063 } 1064 if (master) 1065 nfsd_exit(status); 1066 else 1067 exit(status); 1068 } 1069 1070 /* 1071 * Open the stable restart file and return the file descriptor for it. 1072 */ 1073 static void 1074 open_stable(int *stable_fdp, int *backup_fdp) 1075 { 1076 int stable_fd, backup_fd = -1, ret; 1077 struct stat st, backup_st; 1078 1079 /* Open and stat the stable restart file. */ 1080 stable_fd = open(NFSD_STABLERESTART, O_RDWR, 0); 1081 if (stable_fd < 0) 1082 stable_fd = open(NFSD_STABLERESTART, O_RDWR | O_CREAT, 0600); 1083 if (stable_fd >= 0) { 1084 ret = fstat(stable_fd, &st); 1085 if (ret < 0) { 1086 close(stable_fd); 1087 stable_fd = -1; 1088 } 1089 } 1090 1091 /* Open and stat the backup stable restart file. */ 1092 if (stable_fd >= 0) { 1093 backup_fd = open(NFSD_STABLEBACKUP, O_RDWR, 0); 1094 if (backup_fd < 0) 1095 backup_fd = open(NFSD_STABLEBACKUP, O_RDWR | O_CREAT, 1096 0600); 1097 if (backup_fd >= 0) { 1098 ret = fstat(backup_fd, &backup_st); 1099 if (ret < 0) { 1100 close(backup_fd); 1101 backup_fd = -1; 1102 } 1103 } 1104 if (backup_fd < 0) { 1105 close(stable_fd); 1106 stable_fd = -1; 1107 } 1108 } 1109 1110 *stable_fdp = stable_fd; 1111 *backup_fdp = backup_fd; 1112 if (stable_fd < 0) 1113 return; 1114 1115 /* Sync up the 2 files, as required. */ 1116 if (st.st_size > 0) 1117 copy_stable(stable_fd, backup_fd); 1118 else if (backup_st.st_size > 0) 1119 copy_stable(backup_fd, stable_fd); 1120 } 1121 1122 /* 1123 * Copy the stable restart file to the backup or vice versa. 1124 */ 1125 static void 1126 copy_stable(int from_fd, int to_fd) 1127 { 1128 int cnt, ret; 1129 static char buf[1024]; 1130 1131 ret = lseek(from_fd, (off_t)0, SEEK_SET); 1132 if (ret >= 0) 1133 ret = lseek(to_fd, (off_t)0, SEEK_SET); 1134 if (ret >= 0) 1135 ret = ftruncate(to_fd, (off_t)0); 1136 if (ret >= 0) 1137 do { 1138 cnt = read(from_fd, buf, 1024); 1139 if (cnt > 0) 1140 ret = write(to_fd, buf, cnt); 1141 else if (cnt < 0) 1142 ret = cnt; 1143 } while (cnt > 0 && ret >= 0); 1144 if (ret >= 0) 1145 ret = fsync(to_fd); 1146 if (ret < 0) 1147 syslog(LOG_ERR, "stable restart copy failure: %m"); 1148 } 1149 1150 /* 1151 * Back up the stable restart file when indicated by the kernel. 1152 */ 1153 static void 1154 backup_stable(__unused int signo) 1155 { 1156 1157 if (stablefd >= 0) 1158 copy_stable(stablefd, backupfd); 1159 } 1160 1161 /* 1162 * Parse the pNFS string and extract the DS servers and ports numbers. 1163 */ 1164 static void 1165 parse_dsserver(const char *optionarg, struct nfsd_nfsd_args *nfsdargp) 1166 { 1167 char *cp, *cp2, *dsaddr, *dshost, *dspath, *dsvol, nfsprt[9]; 1168 char *mdspath, *mdsp, ip6[INET6_ADDRSTRLEN]; 1169 const char *ad; 1170 int ecode; 1171 u_int adsiz, dsaddrcnt, dshostcnt, dspathcnt, hostsiz, pathsiz; 1172 u_int mdspathcnt; 1173 size_t dsaddrsiz, dshostsiz, dspathsiz, nfsprtsiz, mdspathsiz; 1174 struct addrinfo hints, *ai_tcp, *res; 1175 struct sockaddr_in sin; 1176 struct sockaddr_in6 sin6; 1177 1178 cp = strdup(optionarg); 1179 if (cp == NULL) 1180 errx(1, "Out of memory"); 1181 1182 /* Now, do the host names. */ 1183 dspathsiz = 1024; 1184 dspathcnt = 0; 1185 dspath = malloc(dspathsiz); 1186 if (dspath == NULL) 1187 errx(1, "Out of memory"); 1188 dshostsiz = 1024; 1189 dshostcnt = 0; 1190 dshost = malloc(dshostsiz); 1191 if (dshost == NULL) 1192 errx(1, "Out of memory"); 1193 dsaddrsiz = 1024; 1194 dsaddrcnt = 0; 1195 dsaddr = malloc(dsaddrsiz); 1196 if (dsaddr == NULL) 1197 errx(1, "Out of memory"); 1198 mdspathsiz = 1024; 1199 mdspathcnt = 0; 1200 mdspath = malloc(mdspathsiz); 1201 if (mdspath == NULL) 1202 errx(1, "Out of memory"); 1203 1204 /* Put the NFS port# in "." form. */ 1205 snprintf(nfsprt, 9, ".%d.%d", 2049 >> 8, 2049 & 0xff); 1206 nfsprtsiz = strlen(nfsprt); 1207 1208 ai_tcp = NULL; 1209 /* Loop around for each DS server name. */ 1210 do { 1211 cp2 = strchr(cp, ','); 1212 if (cp2 != NULL) { 1213 /* Not the last DS in the list. */ 1214 *cp2++ = '\0'; 1215 if (*cp2 == '\0') 1216 usage(); 1217 } 1218 1219 dsvol = strchr(cp, ':'); 1220 if (dsvol == NULL || *(dsvol + 1) == '\0') 1221 usage(); 1222 *dsvol++ = '\0'; 1223 1224 /* Optional path for MDS file system to be stored on DS. */ 1225 mdsp = strchr(dsvol, '#'); 1226 if (mdsp != NULL) { 1227 if (*(mdsp + 1) == '\0' || mdsp <= dsvol) 1228 usage(); 1229 *mdsp++ = '\0'; 1230 } 1231 1232 /* Append this pathname to dspath. */ 1233 pathsiz = strlen(dsvol); 1234 if (dspathcnt + pathsiz + 1 > dspathsiz) { 1235 dspathsiz *= 2; 1236 dspath = realloc(dspath, dspathsiz); 1237 if (dspath == NULL) 1238 errx(1, "Out of memory"); 1239 } 1240 strcpy(&dspath[dspathcnt], dsvol); 1241 dspathcnt += pathsiz + 1; 1242 1243 /* Append this pathname to mdspath. */ 1244 if (mdsp != NULL) 1245 pathsiz = strlen(mdsp); 1246 else 1247 pathsiz = 0; 1248 if (mdspathcnt + pathsiz + 1 > mdspathsiz) { 1249 mdspathsiz *= 2; 1250 mdspath = realloc(mdspath, mdspathsiz); 1251 if (mdspath == NULL) 1252 errx(1, "Out of memory"); 1253 } 1254 if (mdsp != NULL) 1255 strcpy(&mdspath[mdspathcnt], mdsp); 1256 else 1257 mdspath[mdspathcnt] = '\0'; 1258 mdspathcnt += pathsiz + 1; 1259 1260 if (ai_tcp != NULL) 1261 freeaddrinfo(ai_tcp); 1262 1263 /* Get the fully qualified domain name and IP address. */ 1264 memset(&hints, 0, sizeof(hints)); 1265 hints.ai_flags = AI_CANONNAME | AI_ADDRCONFIG; 1266 hints.ai_family = PF_UNSPEC; 1267 hints.ai_socktype = SOCK_STREAM; 1268 hints.ai_protocol = IPPROTO_TCP; 1269 ecode = getaddrinfo(cp, NULL, &hints, &ai_tcp); 1270 if (ecode != 0) 1271 err(1, "getaddrinfo pnfs: %s %s", cp, 1272 gai_strerror(ecode)); 1273 ad = NULL; 1274 for (res = ai_tcp; res != NULL; res = res->ai_next) { 1275 if (res->ai_addr->sa_family == AF_INET) { 1276 if (res->ai_addrlen < sizeof(sin)) 1277 err(1, "getaddrinfo() returned " 1278 "undersized IPv4 address"); 1279 /* 1280 * Mips cares about sockaddr_in alignment, 1281 * so copy the address. 1282 */ 1283 memcpy(&sin, res->ai_addr, sizeof(sin)); 1284 ad = inet_ntoa(sin.sin_addr); 1285 break; 1286 } else if (res->ai_family == AF_INET6) { 1287 if (res->ai_addrlen < sizeof(sin6)) 1288 err(1, "getaddrinfo() returned " 1289 "undersized IPv6 address"); 1290 /* 1291 * Mips cares about sockaddr_in6 alignment, 1292 * so copy the address. 1293 */ 1294 memcpy(&sin6, res->ai_addr, sizeof(sin6)); 1295 ad = inet_ntop(AF_INET6, &sin6.sin6_addr, ip6, 1296 sizeof(ip6)); 1297 1298 /* 1299 * XXX 1300 * Since a link local address will only 1301 * work if the client and DS are in the 1302 * same scope zone, only use it if it is 1303 * the only address. 1304 */ 1305 if (ad != NULL && 1306 !IN6_IS_ADDR_LINKLOCAL(&sin6.sin6_addr)) 1307 break; 1308 } 1309 } 1310 if (ad == NULL) 1311 err(1, "No IP address for %s", cp); 1312 1313 /* Append this address to dsaddr. */ 1314 adsiz = strlen(ad); 1315 if (dsaddrcnt + adsiz + nfsprtsiz + 1 > dsaddrsiz) { 1316 dsaddrsiz *= 2; 1317 dsaddr = realloc(dsaddr, dsaddrsiz); 1318 if (dsaddr == NULL) 1319 errx(1, "Out of memory"); 1320 } 1321 strcpy(&dsaddr[dsaddrcnt], ad); 1322 strcat(&dsaddr[dsaddrcnt], nfsprt); 1323 dsaddrcnt += adsiz + nfsprtsiz + 1; 1324 1325 /* Append this hostname to dshost. */ 1326 hostsiz = strlen(ai_tcp->ai_canonname); 1327 if (dshostcnt + hostsiz + 1 > dshostsiz) { 1328 dshostsiz *= 2; 1329 dshost = realloc(dshost, dshostsiz); 1330 if (dshost == NULL) 1331 errx(1, "Out of memory"); 1332 } 1333 strcpy(&dshost[dshostcnt], ai_tcp->ai_canonname); 1334 dshostcnt += hostsiz + 1; 1335 1336 cp = cp2; 1337 } while (cp != NULL); 1338 1339 nfsdargp->addr = dsaddr; 1340 nfsdargp->addrlen = dsaddrcnt; 1341 nfsdargp->dnshost = dshost; 1342 nfsdargp->dnshostlen = dshostcnt; 1343 nfsdargp->dspath = dspath; 1344 nfsdargp->dspathlen = dspathcnt; 1345 nfsdargp->mdspath = mdspath; 1346 nfsdargp->mdspathlen = mdspathcnt; 1347 freeaddrinfo(ai_tcp); 1348 } 1349 1350