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 #ifndef lint 36 static const char copyright[] = 37 "@(#) Copyright (c) 1989, 1993, 1994\n\ 38 The Regents of the University of California. All rights reserved.\n"; 39 #endif /* not lint */ 40 41 #ifndef lint 42 #if 0 43 static char sccsid[] = "@(#)nfsd.c 8.9 (Berkeley) 3/29/95"; 44 #endif 45 static const char rcsid[] = 46 "$FreeBSD$"; 47 #endif /* not lint */ 48 49 #include <sys/param.h> 50 #include <sys/syslog.h> 51 #include <sys/wait.h> 52 #include <sys/mount.h> 53 #include <sys/fcntl.h> 54 #include <sys/linker.h> 55 #include <sys/module.h> 56 #include <sys/types.h> 57 #include <sys/stat.h> 58 #include <sys/sysctl.h> 59 #include <sys/ucred.h> 60 61 #include <rpc/rpc.h> 62 #include <rpc/pmap_clnt.h> 63 #include <rpcsvc/nfs_prot.h> 64 65 #include <netdb.h> 66 #include <arpa/inet.h> 67 #include <nfsserver/nfs.h> 68 #include <nfs/nfssvc.h> 69 70 #include <err.h> 71 #include <errno.h> 72 #include <signal.h> 73 #include <stdio.h> 74 #include <stdlib.h> 75 #include <string.h> 76 #include <unistd.h> 77 #include <sysexits.h> 78 79 #include <getopt.h> 80 81 static int debug = 0; 82 83 #define NFSD_STABLERESTART "/var/db/nfs-stablerestart" 84 #define NFSD_STABLEBACKUP "/var/db/nfs-stablerestart.bak" 85 #define MAXNFSDCNT 256 86 #define DEFNFSDCNT 4 87 #define NFS_VER2 2 88 #define NFS_VER3 3 89 #define NFS_VER4 4 90 static pid_t children[MAXNFSDCNT]; /* PIDs of children */ 91 static int nfsdcnt; /* number of children */ 92 static int nfsdcnt_set; 93 static int minthreads; 94 static int maxthreads; 95 static int nfssvc_nfsd; /* Set to correct NFSSVC_xxx flag */ 96 static int stablefd = -1; /* Fd for the stable restart file */ 97 static int backupfd; /* Fd for the backup stable restart file */ 98 static const char *getopt_shortopts; 99 static const char *getopt_usage; 100 101 static int minthreads_set; 102 static int maxthreads_set; 103 104 static struct option longopts[] = { 105 { "debug", no_argument, &debug, 1 }, 106 { "minthreads", required_argument, &minthreads_set, 1 }, 107 { "maxthreads", required_argument, &maxthreads_set, 1 }, 108 { NULL, 0, NULL, 0} 109 }; 110 111 static void cleanup(int); 112 static void child_cleanup(int); 113 static void killchildren(void); 114 static void nfsd_exit(int); 115 static void nonfs(int); 116 static void reapchild(int); 117 static int setbindhost(struct addrinfo **ia, const char *bindhost, 118 struct addrinfo hints); 119 static void start_server(int); 120 static void unregistration(void); 121 static void usage(void); 122 static void open_stable(int *, int *); 123 static void copy_stable(int, int); 124 static void backup_stable(int); 125 static void set_nfsdcnt(int); 126 127 /* 128 * Nfs server daemon mostly just a user context for nfssvc() 129 * 130 * 1 - do file descriptor and signal cleanup 131 * 2 - fork the nfsd(s) 132 * 3 - create server socket(s) 133 * 4 - register socket with rpcbind 134 * 135 * For connectionless protocols, just pass the socket into the kernel via. 136 * nfssvc(). 137 * For connection based sockets, loop doing accepts. When you get a new 138 * socket from accept, pass the msgsock into the kernel via. nfssvc(). 139 * The arguments are: 140 * -r - reregister with rpcbind 141 * -d - unregister with rpcbind 142 * -t - support tcp nfs clients 143 * -u - support udp nfs clients 144 * -e - forces it to run a server that supports nfsv4 145 * followed by "n" which is the number of nfsds' to fork off 146 */ 147 int 148 main(int argc, char **argv) 149 { 150 struct nfsd_addsock_args addsockargs; 151 struct addrinfo *ai_udp, *ai_tcp, *ai_udp6, *ai_tcp6, hints; 152 struct netconfig *nconf_udp, *nconf_tcp, *nconf_udp6, *nconf_tcp6; 153 struct netbuf nb_udp, nb_tcp, nb_udp6, nb_tcp6; 154 struct sockaddr_in inetpeer; 155 struct sockaddr_in6 inet6peer; 156 fd_set ready, sockbits; 157 fd_set v4bits, v6bits; 158 int ch, connect_type_cnt, i, maxsock, msgsock; 159 socklen_t len; 160 int on = 1, unregister, reregister, sock; 161 int tcp6sock, ip6flag, tcpflag, tcpsock; 162 int udpflag, ecode, error, s; 163 int bindhostc, bindanyflag, rpcbreg, rpcbregcnt; 164 int nfssvc_addsock; 165 int longindex = 0; 166 int nfs_minvers = NFS_VER2; 167 size_t nfs_minvers_size; 168 const char *lopt; 169 char **bindhost = NULL; 170 pid_t pid; 171 172 nfsdcnt = DEFNFSDCNT; 173 unregister = reregister = tcpflag = maxsock = 0; 174 bindanyflag = udpflag = connect_type_cnt = bindhostc = 0; 175 getopt_shortopts = "ah:n:rdtue"; 176 getopt_usage = 177 "usage:\n" 178 " nfsd [-ardtue] [-h bindip]\n" 179 " [-n numservers] [--minthreads #] [--maxthreads #]\n"; 180 while ((ch = getopt_long(argc, argv, getopt_shortopts, longopts, 181 &longindex)) != -1) 182 switch (ch) { 183 case 'a': 184 bindanyflag = 1; 185 break; 186 case 'n': 187 set_nfsdcnt(atoi(optarg)); 188 break; 189 case 'h': 190 bindhostc++; 191 bindhost = realloc(bindhost,sizeof(char *)*bindhostc); 192 if (bindhost == NULL) 193 errx(1, "Out of memory"); 194 bindhost[bindhostc-1] = strdup(optarg); 195 if (bindhost[bindhostc-1] == NULL) 196 errx(1, "Out of memory"); 197 break; 198 case 'r': 199 reregister = 1; 200 break; 201 case 'd': 202 unregister = 1; 203 break; 204 case 't': 205 tcpflag = 1; 206 break; 207 case 'u': 208 udpflag = 1; 209 break; 210 case 'e': 211 /* now a no-op, since this is the default */ 212 break; 213 case 0: 214 lopt = longopts[longindex].name; 215 if (!strcmp(lopt, "minthreads")) { 216 minthreads = atoi(optarg); 217 } else if (!strcmp(lopt, "maxthreads")) { 218 maxthreads = atoi(optarg); 219 } 220 break; 221 default: 222 case '?': 223 usage(); 224 } 225 if (!tcpflag && !udpflag) 226 udpflag = 1; 227 argv += optind; 228 argc -= optind; 229 if (minthreads_set && maxthreads_set && minthreads > maxthreads) 230 errx(EX_USAGE, 231 "error: minthreads(%d) can't be greater than " 232 "maxthreads(%d)", minthreads, maxthreads); 233 234 /* 235 * XXX 236 * Backward compatibility, trailing number is the count of daemons. 237 */ 238 if (argc > 1) 239 usage(); 240 if (argc == 1) 241 set_nfsdcnt(atoi(argv[0])); 242 243 /* 244 * Unless the "-o" option was specified, try and run "nfsd". 245 * If "-o" was specified, try and run "nfsserver". 246 */ 247 if (modfind("nfsd") < 0) { 248 /* Not present in kernel, try loading it */ 249 if (kldload("nfsd") < 0 || modfind("nfsd") < 0) 250 errx(1, "NFS server is not available"); 251 } 252 253 ip6flag = 1; 254 s = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP); 255 if (s == -1) { 256 if (errno != EPROTONOSUPPORT && errno != EAFNOSUPPORT) 257 err(1, "socket"); 258 ip6flag = 0; 259 } else if (getnetconfigent("udp6") == NULL || 260 getnetconfigent("tcp6") == NULL) { 261 ip6flag = 0; 262 } 263 if (s != -1) 264 close(s); 265 266 if (bindhostc == 0 || bindanyflag) { 267 bindhostc++; 268 bindhost = realloc(bindhost,sizeof(char *)*bindhostc); 269 if (bindhost == NULL) 270 errx(1, "Out of memory"); 271 bindhost[bindhostc-1] = strdup("*"); 272 if (bindhost[bindhostc-1] == NULL) 273 errx(1, "Out of memory"); 274 } 275 276 nfs_minvers_size = sizeof(nfs_minvers); 277 error = sysctlbyname("vfs.nfsd.server_min_nfsvers", &nfs_minvers, 278 &nfs_minvers_size, NULL, 0); 279 if (error != 0 || nfs_minvers < NFS_VER2 || nfs_minvers > NFS_VER4) { 280 warnx("sysctlbyname(vfs.nfsd.server_min_nfsvers) failed," 281 " defaulting to NFSv2"); 282 nfs_minvers = NFS_VER2; 283 } 284 285 if (unregister) { 286 unregistration(); 287 exit (0); 288 } 289 if (reregister) { 290 if (udpflag) { 291 memset(&hints, 0, sizeof hints); 292 hints.ai_flags = AI_PASSIVE; 293 hints.ai_family = AF_INET; 294 hints.ai_socktype = SOCK_DGRAM; 295 hints.ai_protocol = IPPROTO_UDP; 296 ecode = getaddrinfo(NULL, "nfs", &hints, &ai_udp); 297 if (ecode != 0) 298 err(1, "getaddrinfo udp: %s", gai_strerror(ecode)); 299 nconf_udp = getnetconfigent("udp"); 300 if (nconf_udp == NULL) 301 err(1, "getnetconfigent udp failed"); 302 nb_udp.buf = ai_udp->ai_addr; 303 nb_udp.len = nb_udp.maxlen = ai_udp->ai_addrlen; 304 if (nfs_minvers == NFS_VER2) 305 if (!rpcb_set(NFS_PROGRAM, 2, nconf_udp, 306 &nb_udp)) 307 err(1, "rpcb_set udp failed"); 308 if (nfs_minvers <= NFS_VER3) 309 if (!rpcb_set(NFS_PROGRAM, 3, nconf_udp, 310 &nb_udp)) 311 err(1, "rpcb_set udp failed"); 312 freeaddrinfo(ai_udp); 313 } 314 if (udpflag && ip6flag) { 315 memset(&hints, 0, sizeof hints); 316 hints.ai_flags = AI_PASSIVE; 317 hints.ai_family = AF_INET6; 318 hints.ai_socktype = SOCK_DGRAM; 319 hints.ai_protocol = IPPROTO_UDP; 320 ecode = getaddrinfo(NULL, "nfs", &hints, &ai_udp6); 321 if (ecode != 0) 322 err(1, "getaddrinfo udp6: %s", gai_strerror(ecode)); 323 nconf_udp6 = getnetconfigent("udp6"); 324 if (nconf_udp6 == NULL) 325 err(1, "getnetconfigent udp6 failed"); 326 nb_udp6.buf = ai_udp6->ai_addr; 327 nb_udp6.len = nb_udp6.maxlen = ai_udp6->ai_addrlen; 328 if (nfs_minvers == NFS_VER2) 329 if (!rpcb_set(NFS_PROGRAM, 2, nconf_udp6, 330 &nb_udp6)) 331 err(1, "rpcb_set udp6 failed"); 332 if (nfs_minvers <= NFS_VER3) 333 if (!rpcb_set(NFS_PROGRAM, 3, nconf_udp6, 334 &nb_udp6)) 335 err(1, "rpcb_set udp6 failed"); 336 freeaddrinfo(ai_udp6); 337 } 338 if (tcpflag) { 339 memset(&hints, 0, sizeof hints); 340 hints.ai_flags = AI_PASSIVE; 341 hints.ai_family = AF_INET; 342 hints.ai_socktype = SOCK_STREAM; 343 hints.ai_protocol = IPPROTO_TCP; 344 ecode = getaddrinfo(NULL, "nfs", &hints, &ai_tcp); 345 if (ecode != 0) 346 err(1, "getaddrinfo tcp: %s", gai_strerror(ecode)); 347 nconf_tcp = getnetconfigent("tcp"); 348 if (nconf_tcp == NULL) 349 err(1, "getnetconfigent tcp failed"); 350 nb_tcp.buf = ai_tcp->ai_addr; 351 nb_tcp.len = nb_tcp.maxlen = ai_tcp->ai_addrlen; 352 if (nfs_minvers == NFS_VER2) 353 if (!rpcb_set(NFS_PROGRAM, 2, nconf_tcp, 354 &nb_tcp)) 355 err(1, "rpcb_set tcp failed"); 356 if (nfs_minvers <= NFS_VER3) 357 if (!rpcb_set(NFS_PROGRAM, 3, nconf_tcp, 358 &nb_tcp)) 359 err(1, "rpcb_set tcp failed"); 360 freeaddrinfo(ai_tcp); 361 } 362 if (tcpflag && ip6flag) { 363 memset(&hints, 0, sizeof hints); 364 hints.ai_flags = AI_PASSIVE; 365 hints.ai_family = AF_INET6; 366 hints.ai_socktype = SOCK_STREAM; 367 hints.ai_protocol = IPPROTO_TCP; 368 ecode = getaddrinfo(NULL, "nfs", &hints, &ai_tcp6); 369 if (ecode != 0) 370 err(1, "getaddrinfo tcp6: %s", gai_strerror(ecode)); 371 nconf_tcp6 = getnetconfigent("tcp6"); 372 if (nconf_tcp6 == NULL) 373 err(1, "getnetconfigent tcp6 failed"); 374 nb_tcp6.buf = ai_tcp6->ai_addr; 375 nb_tcp6.len = nb_tcp6.maxlen = ai_tcp6->ai_addrlen; 376 if (nfs_minvers == NFS_VER2) 377 if (!rpcb_set(NFS_PROGRAM, 2, nconf_tcp6, 378 &nb_tcp6)) 379 err(1, "rpcb_set tcp6 failed"); 380 if (nfs_minvers <= NFS_VER3) 381 if (!rpcb_set(NFS_PROGRAM, 3, nconf_tcp6, 382 &nb_tcp6)) 383 err(1, "rpcb_set tcp6 failed"); 384 freeaddrinfo(ai_tcp6); 385 } 386 exit (0); 387 } 388 if (debug == 0) { 389 daemon(0, 0); 390 (void)signal(SIGHUP, SIG_IGN); 391 (void)signal(SIGINT, SIG_IGN); 392 /* 393 * nfsd sits in the kernel most of the time. It needs 394 * to ignore SIGTERM/SIGQUIT in order to stay alive as long 395 * as possible during a shutdown, otherwise loopback 396 * mounts will not be able to unmount. 397 */ 398 (void)signal(SIGTERM, SIG_IGN); 399 (void)signal(SIGQUIT, SIG_IGN); 400 } 401 (void)signal(SIGSYS, nonfs); 402 (void)signal(SIGCHLD, reapchild); 403 (void)signal(SIGUSR2, backup_stable); 404 405 openlog("nfsd", LOG_PID | (debug ? LOG_PERROR : 0), LOG_DAEMON); 406 407 /* 408 * For V4, we open the stablerestart file and call nfssvc() 409 * to get it loaded. This is done before the daemons do the 410 * regular nfssvc() call to service NFS requests. 411 * (This way the file remains open until the last nfsd is killed 412 * off.) 413 * It and the backup copy will be created as empty files 414 * the first time this nfsd is started and should never be 415 * deleted/replaced if at all possible. It should live on a 416 * local, non-volatile storage device that does not do hardware 417 * level write-back caching. (See SCSI doc for more information 418 * on how to prevent write-back caching on SCSI disks.) 419 */ 420 open_stable(&stablefd, &backupfd); 421 if (stablefd < 0) { 422 syslog(LOG_ERR, "Can't open %s: %m\n", NFSD_STABLERESTART); 423 exit(1); 424 } 425 /* This system call will fail for old kernels, but that's ok. */ 426 nfssvc(NFSSVC_BACKUPSTABLE, NULL); 427 if (nfssvc(NFSSVC_STABLERESTART, (caddr_t)&stablefd) < 0) { 428 syslog(LOG_ERR, "Can't read stable storage file: %m\n"); 429 exit(1); 430 } 431 nfssvc_addsock = NFSSVC_NFSDADDSOCK; 432 nfssvc_nfsd = NFSSVC_NFSDNFSD; 433 434 if (tcpflag) { 435 /* 436 * For TCP mode, we fork once to start the first 437 * kernel nfsd thread. The kernel will add more 438 * threads as needed. 439 */ 440 pid = fork(); 441 if (pid == -1) { 442 syslog(LOG_ERR, "fork: %m"); 443 nfsd_exit(1); 444 } 445 if (pid) { 446 children[0] = pid; 447 } else { 448 (void)signal(SIGUSR1, child_cleanup); 449 setproctitle("server"); 450 start_server(0); 451 } 452 } 453 454 (void)signal(SIGUSR1, cleanup); 455 FD_ZERO(&v4bits); 456 FD_ZERO(&v6bits); 457 FD_ZERO(&sockbits); 458 459 rpcbregcnt = 0; 460 /* Set up the socket for udp and rpcb register it. */ 461 if (udpflag) { 462 rpcbreg = 0; 463 for (i = 0; i < bindhostc; i++) { 464 memset(&hints, 0, sizeof hints); 465 hints.ai_flags = AI_PASSIVE; 466 hints.ai_family = AF_INET; 467 hints.ai_socktype = SOCK_DGRAM; 468 hints.ai_protocol = IPPROTO_UDP; 469 if (setbindhost(&ai_udp, bindhost[i], hints) == 0) { 470 rpcbreg = 1; 471 rpcbregcnt++; 472 if ((sock = socket(ai_udp->ai_family, 473 ai_udp->ai_socktype, 474 ai_udp->ai_protocol)) < 0) { 475 syslog(LOG_ERR, 476 "can't create udp socket"); 477 nfsd_exit(1); 478 } 479 if (bind(sock, ai_udp->ai_addr, 480 ai_udp->ai_addrlen) < 0) { 481 syslog(LOG_ERR, 482 "can't bind udp addr %s: %m", 483 bindhost[i]); 484 nfsd_exit(1); 485 } 486 freeaddrinfo(ai_udp); 487 addsockargs.sock = sock; 488 addsockargs.name = NULL; 489 addsockargs.namelen = 0; 490 if (nfssvc(nfssvc_addsock, &addsockargs) < 0) { 491 syslog(LOG_ERR, "can't Add UDP socket"); 492 nfsd_exit(1); 493 } 494 (void)close(sock); 495 } 496 } 497 if (rpcbreg == 1) { 498 memset(&hints, 0, sizeof hints); 499 hints.ai_flags = AI_PASSIVE; 500 hints.ai_family = AF_INET; 501 hints.ai_socktype = SOCK_DGRAM; 502 hints.ai_protocol = IPPROTO_UDP; 503 ecode = getaddrinfo(NULL, "nfs", &hints, &ai_udp); 504 if (ecode != 0) { 505 syslog(LOG_ERR, "getaddrinfo udp: %s", 506 gai_strerror(ecode)); 507 nfsd_exit(1); 508 } 509 nconf_udp = getnetconfigent("udp"); 510 if (nconf_udp == NULL) 511 err(1, "getnetconfigent udp failed"); 512 nb_udp.buf = ai_udp->ai_addr; 513 nb_udp.len = nb_udp.maxlen = ai_udp->ai_addrlen; 514 if (nfs_minvers == NFS_VER2) 515 if (!rpcb_set(NFS_PROGRAM, 2, nconf_udp, 516 &nb_udp)) 517 err(1, "rpcb_set udp failed"); 518 if (nfs_minvers <= NFS_VER3) 519 if (!rpcb_set(NFS_PROGRAM, 3, nconf_udp, 520 &nb_udp)) 521 err(1, "rpcb_set udp failed"); 522 freeaddrinfo(ai_udp); 523 } 524 } 525 526 /* Set up the socket for udp6 and rpcb register it. */ 527 if (udpflag && ip6flag) { 528 rpcbreg = 0; 529 for (i = 0; i < bindhostc; i++) { 530 memset(&hints, 0, sizeof hints); 531 hints.ai_flags = AI_PASSIVE; 532 hints.ai_family = AF_INET6; 533 hints.ai_socktype = SOCK_DGRAM; 534 hints.ai_protocol = IPPROTO_UDP; 535 if (setbindhost(&ai_udp6, bindhost[i], hints) == 0) { 536 rpcbreg = 1; 537 rpcbregcnt++; 538 if ((sock = socket(ai_udp6->ai_family, 539 ai_udp6->ai_socktype, 540 ai_udp6->ai_protocol)) < 0) { 541 syslog(LOG_ERR, 542 "can't create udp6 socket"); 543 nfsd_exit(1); 544 } 545 if (setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, 546 &on, sizeof on) < 0) { 547 syslog(LOG_ERR, 548 "can't set v6-only binding for " 549 "udp6 socket: %m"); 550 nfsd_exit(1); 551 } 552 if (bind(sock, ai_udp6->ai_addr, 553 ai_udp6->ai_addrlen) < 0) { 554 syslog(LOG_ERR, 555 "can't bind udp6 addr %s: %m", 556 bindhost[i]); 557 nfsd_exit(1); 558 } 559 freeaddrinfo(ai_udp6); 560 addsockargs.sock = sock; 561 addsockargs.name = NULL; 562 addsockargs.namelen = 0; 563 if (nfssvc(nfssvc_addsock, &addsockargs) < 0) { 564 syslog(LOG_ERR, 565 "can't add UDP6 socket"); 566 nfsd_exit(1); 567 } 568 (void)close(sock); 569 } 570 } 571 if (rpcbreg == 1) { 572 memset(&hints, 0, sizeof hints); 573 hints.ai_flags = AI_PASSIVE; 574 hints.ai_family = AF_INET6; 575 hints.ai_socktype = SOCK_DGRAM; 576 hints.ai_protocol = IPPROTO_UDP; 577 ecode = getaddrinfo(NULL, "nfs", &hints, &ai_udp6); 578 if (ecode != 0) { 579 syslog(LOG_ERR, "getaddrinfo udp6: %s", 580 gai_strerror(ecode)); 581 nfsd_exit(1); 582 } 583 nconf_udp6 = getnetconfigent("udp6"); 584 if (nconf_udp6 == NULL) 585 err(1, "getnetconfigent udp6 failed"); 586 nb_udp6.buf = ai_udp6->ai_addr; 587 nb_udp6.len = nb_udp6.maxlen = ai_udp6->ai_addrlen; 588 if (nfs_minvers == NFS_VER2) 589 if (!rpcb_set(NFS_PROGRAM, 2, nconf_udp6, 590 &nb_udp6)) 591 err(1, 592 "rpcb_set udp6 failed"); 593 if (nfs_minvers <= NFS_VER3) 594 if (!rpcb_set(NFS_PROGRAM, 3, nconf_udp6, 595 &nb_udp6)) 596 err(1, 597 "rpcb_set udp6 failed"); 598 freeaddrinfo(ai_udp6); 599 } 600 } 601 602 /* Set up the socket for tcp and rpcb register it. */ 603 if (tcpflag) { 604 rpcbreg = 0; 605 for (i = 0; i < bindhostc; i++) { 606 memset(&hints, 0, sizeof hints); 607 hints.ai_flags = AI_PASSIVE; 608 hints.ai_family = AF_INET; 609 hints.ai_socktype = SOCK_STREAM; 610 hints.ai_protocol = IPPROTO_TCP; 611 if (setbindhost(&ai_tcp, bindhost[i], hints) == 0) { 612 rpcbreg = 1; 613 rpcbregcnt++; 614 if ((tcpsock = socket(AF_INET, SOCK_STREAM, 615 0)) < 0) { 616 syslog(LOG_ERR, 617 "can't create tcp socket"); 618 nfsd_exit(1); 619 } 620 if (setsockopt(tcpsock, SOL_SOCKET, 621 SO_REUSEADDR, 622 (char *)&on, sizeof(on)) < 0) 623 syslog(LOG_ERR, 624 "setsockopt SO_REUSEADDR: %m"); 625 if (bind(tcpsock, ai_tcp->ai_addr, 626 ai_tcp->ai_addrlen) < 0) { 627 syslog(LOG_ERR, 628 "can't bind tcp addr %s: %m", 629 bindhost[i]); 630 nfsd_exit(1); 631 } 632 if (listen(tcpsock, -1) < 0) { 633 syslog(LOG_ERR, "listen failed"); 634 nfsd_exit(1); 635 } 636 freeaddrinfo(ai_tcp); 637 FD_SET(tcpsock, &sockbits); 638 FD_SET(tcpsock, &v4bits); 639 maxsock = tcpsock; 640 connect_type_cnt++; 641 } 642 } 643 if (rpcbreg == 1) { 644 memset(&hints, 0, sizeof hints); 645 hints.ai_flags = AI_PASSIVE; 646 hints.ai_family = AF_INET; 647 hints.ai_socktype = SOCK_STREAM; 648 hints.ai_protocol = IPPROTO_TCP; 649 ecode = getaddrinfo(NULL, "nfs", &hints, 650 &ai_tcp); 651 if (ecode != 0) { 652 syslog(LOG_ERR, "getaddrinfo tcp: %s", 653 gai_strerror(ecode)); 654 nfsd_exit(1); 655 } 656 nconf_tcp = getnetconfigent("tcp"); 657 if (nconf_tcp == NULL) 658 err(1, "getnetconfigent tcp failed"); 659 nb_tcp.buf = ai_tcp->ai_addr; 660 nb_tcp.len = nb_tcp.maxlen = ai_tcp->ai_addrlen; 661 if (nfs_minvers == NFS_VER2) 662 if (!rpcb_set(NFS_PROGRAM, 2, nconf_tcp, 663 &nb_tcp)) 664 err(1, "rpcb_set tcp failed"); 665 if (nfs_minvers <= NFS_VER3) 666 if (!rpcb_set(NFS_PROGRAM, 3, nconf_tcp, 667 &nb_tcp)) 668 err(1, "rpcb_set tcp failed"); 669 freeaddrinfo(ai_tcp); 670 } 671 } 672 673 /* Set up the socket for tcp6 and rpcb register it. */ 674 if (tcpflag && ip6flag) { 675 rpcbreg = 0; 676 for (i = 0; i < bindhostc; i++) { 677 memset(&hints, 0, sizeof hints); 678 hints.ai_flags = AI_PASSIVE; 679 hints.ai_family = AF_INET6; 680 hints.ai_socktype = SOCK_STREAM; 681 hints.ai_protocol = IPPROTO_TCP; 682 if (setbindhost(&ai_tcp6, bindhost[i], hints) == 0) { 683 rpcbreg = 1; 684 rpcbregcnt++; 685 if ((tcp6sock = socket(ai_tcp6->ai_family, 686 ai_tcp6->ai_socktype, 687 ai_tcp6->ai_protocol)) < 0) { 688 syslog(LOG_ERR, 689 "can't create tcp6 socket"); 690 nfsd_exit(1); 691 } 692 if (setsockopt(tcp6sock, SOL_SOCKET, 693 SO_REUSEADDR, 694 (char *)&on, sizeof(on)) < 0) 695 syslog(LOG_ERR, 696 "setsockopt SO_REUSEADDR: %m"); 697 if (setsockopt(tcp6sock, IPPROTO_IPV6, 698 IPV6_V6ONLY, &on, sizeof on) < 0) { 699 syslog(LOG_ERR, 700 "can't set v6-only binding for tcp6 " 701 "socket: %m"); 702 nfsd_exit(1); 703 } 704 if (bind(tcp6sock, ai_tcp6->ai_addr, 705 ai_tcp6->ai_addrlen) < 0) { 706 syslog(LOG_ERR, 707 "can't bind tcp6 addr %s: %m", 708 bindhost[i]); 709 nfsd_exit(1); 710 } 711 if (listen(tcp6sock, -1) < 0) { 712 syslog(LOG_ERR, "listen failed"); 713 nfsd_exit(1); 714 } 715 freeaddrinfo(ai_tcp6); 716 FD_SET(tcp6sock, &sockbits); 717 FD_SET(tcp6sock, &v6bits); 718 if (maxsock < tcp6sock) 719 maxsock = tcp6sock; 720 connect_type_cnt++; 721 } 722 } 723 if (rpcbreg == 1) { 724 memset(&hints, 0, sizeof hints); 725 hints.ai_flags = AI_PASSIVE; 726 hints.ai_family = AF_INET6; 727 hints.ai_socktype = SOCK_STREAM; 728 hints.ai_protocol = IPPROTO_TCP; 729 ecode = getaddrinfo(NULL, "nfs", &hints, &ai_tcp6); 730 if (ecode != 0) { 731 syslog(LOG_ERR, "getaddrinfo tcp6: %s", 732 gai_strerror(ecode)); 733 nfsd_exit(1); 734 } 735 nconf_tcp6 = getnetconfigent("tcp6"); 736 if (nconf_tcp6 == NULL) 737 err(1, "getnetconfigent tcp6 failed"); 738 nb_tcp6.buf = ai_tcp6->ai_addr; 739 nb_tcp6.len = nb_tcp6.maxlen = ai_tcp6->ai_addrlen; 740 if (nfs_minvers == NFS_VER2) 741 if (!rpcb_set(NFS_PROGRAM, 2, nconf_tcp6, 742 &nb_tcp6)) 743 err(1, "rpcb_set tcp6 failed"); 744 if (nfs_minvers <= NFS_VER3) 745 if (!rpcb_set(NFS_PROGRAM, 3, nconf_tcp6, 746 &nb_tcp6)) 747 err(1, "rpcb_set tcp6 failed"); 748 freeaddrinfo(ai_tcp6); 749 } 750 } 751 752 if (rpcbregcnt == 0) { 753 syslog(LOG_ERR, "rpcb_set() failed, nothing to do: %m"); 754 nfsd_exit(1); 755 } 756 757 if (tcpflag && connect_type_cnt == 0) { 758 syslog(LOG_ERR, "tcp connects == 0, nothing to do: %m"); 759 nfsd_exit(1); 760 } 761 762 setproctitle("master"); 763 /* 764 * We always want a master to have a clean way to shut nfsd down 765 * (with unregistration): if the master is killed, it unregisters and 766 * kills all children. If we run for UDP only (and so do not have to 767 * loop waiting for accept), we instead make the parent 768 * a "server" too. start_server will not return. 769 */ 770 if (!tcpflag) 771 start_server(1); 772 773 /* 774 * Loop forever accepting connections and passing the sockets 775 * into the kernel for the mounts. 776 */ 777 for (;;) { 778 ready = sockbits; 779 if (connect_type_cnt > 1) { 780 if (select(maxsock + 1, 781 &ready, NULL, NULL, NULL) < 1) { 782 error = errno; 783 if (error == EINTR) 784 continue; 785 syslog(LOG_ERR, "select failed: %m"); 786 nfsd_exit(1); 787 } 788 } 789 for (tcpsock = 0; tcpsock <= maxsock; tcpsock++) { 790 if (FD_ISSET(tcpsock, &ready)) { 791 if (FD_ISSET(tcpsock, &v4bits)) { 792 len = sizeof(inetpeer); 793 if ((msgsock = accept(tcpsock, 794 (struct sockaddr *)&inetpeer, &len)) < 0) { 795 error = errno; 796 syslog(LOG_ERR, "accept failed: %m"); 797 if (error == ECONNABORTED || 798 error == EINTR) 799 continue; 800 nfsd_exit(1); 801 } 802 memset(inetpeer.sin_zero, 0, 803 sizeof(inetpeer.sin_zero)); 804 if (setsockopt(msgsock, SOL_SOCKET, 805 SO_KEEPALIVE, (char *)&on, sizeof(on)) < 0) 806 syslog(LOG_ERR, 807 "setsockopt SO_KEEPALIVE: %m"); 808 addsockargs.sock = msgsock; 809 addsockargs.name = (caddr_t)&inetpeer; 810 addsockargs.namelen = len; 811 nfssvc(nfssvc_addsock, &addsockargs); 812 (void)close(msgsock); 813 } else if (FD_ISSET(tcpsock, &v6bits)) { 814 len = sizeof(inet6peer); 815 if ((msgsock = accept(tcpsock, 816 (struct sockaddr *)&inet6peer, 817 &len)) < 0) { 818 error = errno; 819 syslog(LOG_ERR, 820 "accept failed: %m"); 821 if (error == ECONNABORTED || 822 error == EINTR) 823 continue; 824 nfsd_exit(1); 825 } 826 if (setsockopt(msgsock, SOL_SOCKET, 827 SO_KEEPALIVE, (char *)&on, 828 sizeof(on)) < 0) 829 syslog(LOG_ERR, "setsockopt " 830 "SO_KEEPALIVE: %m"); 831 addsockargs.sock = msgsock; 832 addsockargs.name = (caddr_t)&inet6peer; 833 addsockargs.namelen = len; 834 nfssvc(nfssvc_addsock, &addsockargs); 835 (void)close(msgsock); 836 } 837 } 838 } 839 } 840 } 841 842 static int 843 setbindhost(struct addrinfo **ai, const char *bindhost, struct addrinfo hints) 844 { 845 int ecode; 846 u_int32_t host_addr[4]; /* IPv4 or IPv6 */ 847 const char *hostptr; 848 849 if (bindhost == NULL || strcmp("*", bindhost) == 0) 850 hostptr = NULL; 851 else 852 hostptr = bindhost; 853 854 if (hostptr != NULL) { 855 switch (hints.ai_family) { 856 case AF_INET: 857 if (inet_pton(AF_INET, hostptr, host_addr) == 1) { 858 hints.ai_flags = AI_NUMERICHOST; 859 } else { 860 if (inet_pton(AF_INET6, hostptr, 861 host_addr) == 1) 862 return (1); 863 } 864 break; 865 case AF_INET6: 866 if (inet_pton(AF_INET6, hostptr, host_addr) == 1) { 867 hints.ai_flags = AI_NUMERICHOST; 868 } else { 869 if (inet_pton(AF_INET, hostptr, 870 host_addr) == 1) 871 return (1); 872 } 873 break; 874 default: 875 break; 876 } 877 } 878 879 ecode = getaddrinfo(hostptr, "nfs", &hints, ai); 880 if (ecode != 0) { 881 syslog(LOG_ERR, "getaddrinfo %s: %s", bindhost, 882 gai_strerror(ecode)); 883 return (1); 884 } 885 return (0); 886 } 887 888 static void 889 set_nfsdcnt(int proposed) 890 { 891 892 if (proposed < 1) { 893 warnx("nfsd count too low %d; reset to %d", proposed, 894 DEFNFSDCNT); 895 nfsdcnt = DEFNFSDCNT; 896 } else if (proposed > MAXNFSDCNT) { 897 warnx("nfsd count too high %d; truncated to %d", proposed, 898 MAXNFSDCNT); 899 nfsdcnt = MAXNFSDCNT; 900 } else 901 nfsdcnt = proposed; 902 nfsdcnt_set = 1; 903 } 904 905 static void 906 usage(void) 907 { 908 (void)fprintf(stderr, "%s", getopt_usage); 909 exit(1); 910 } 911 912 static void 913 nonfs(__unused int signo) 914 { 915 syslog(LOG_ERR, "missing system call: NFS not available"); 916 } 917 918 static void 919 reapchild(__unused int signo) 920 { 921 pid_t pid; 922 int i; 923 924 while ((pid = wait3(NULL, WNOHANG, NULL)) > 0) { 925 for (i = 0; i < nfsdcnt; i++) 926 if (pid == children[i]) 927 children[i] = -1; 928 } 929 } 930 931 static void 932 unregistration(void) 933 { 934 if ((!rpcb_unset(NFS_PROGRAM, 2, NULL)) || 935 (!rpcb_unset(NFS_PROGRAM, 3, NULL))) 936 syslog(LOG_ERR, "rpcb_unset failed"); 937 } 938 939 static void 940 killchildren(void) 941 { 942 int i; 943 944 for (i = 0; i < nfsdcnt; i++) { 945 if (children[i] > 0) 946 kill(children[i], SIGKILL); 947 } 948 } 949 950 /* 951 * Cleanup master after SIGUSR1. 952 */ 953 static void 954 cleanup(__unused int signo) 955 { 956 nfsd_exit(0); 957 } 958 959 /* 960 * Cleanup child after SIGUSR1. 961 */ 962 static void 963 child_cleanup(__unused int signo) 964 { 965 exit(0); 966 } 967 968 static void 969 nfsd_exit(int status) 970 { 971 killchildren(); 972 unregistration(); 973 exit(status); 974 } 975 976 static int 977 get_tuned_nfsdcount(void) 978 { 979 int ncpu, error, tuned_nfsdcnt; 980 size_t ncpu_size; 981 982 ncpu_size = sizeof(ncpu); 983 error = sysctlbyname("hw.ncpu", &ncpu, &ncpu_size, NULL, 0); 984 if (error) { 985 warnx("sysctlbyname(hw.ncpu) failed defaulting to %d nfs servers", 986 DEFNFSDCNT); 987 tuned_nfsdcnt = DEFNFSDCNT; 988 } else { 989 tuned_nfsdcnt = ncpu * 8; 990 } 991 return tuned_nfsdcnt; 992 } 993 994 static void 995 start_server(int master) 996 { 997 char principal[MAXHOSTNAMELEN + 5]; 998 struct nfsd_nfsd_args nfsdargs; 999 int status, error; 1000 char hostname[MAXHOSTNAMELEN + 1], *cp; 1001 struct addrinfo *aip, hints; 1002 1003 status = 0; 1004 gethostname(hostname, sizeof (hostname)); 1005 snprintf(principal, sizeof (principal), "nfs@%s", hostname); 1006 if ((cp = strchr(hostname, '.')) == NULL || 1007 *(cp + 1) == '\0') { 1008 /* If not fully qualified, try getaddrinfo() */ 1009 memset((void *)&hints, 0, sizeof (hints)); 1010 hints.ai_flags = AI_CANONNAME; 1011 error = getaddrinfo(hostname, NULL, &hints, &aip); 1012 if (error == 0) { 1013 if (aip->ai_canonname != NULL && 1014 (cp = strchr(aip->ai_canonname, '.')) != 1015 NULL && *(cp + 1) != '\0') 1016 snprintf(principal, sizeof (principal), 1017 "nfs@%s", aip->ai_canonname); 1018 freeaddrinfo(aip); 1019 } 1020 } 1021 nfsdargs.principal = principal; 1022 1023 if (nfsdcnt_set) 1024 nfsdargs.minthreads = nfsdargs.maxthreads = nfsdcnt; 1025 else { 1026 nfsdargs.minthreads = minthreads_set ? minthreads : get_tuned_nfsdcount(); 1027 nfsdargs.maxthreads = maxthreads_set ? maxthreads : nfsdargs.minthreads; 1028 if (nfsdargs.maxthreads < nfsdargs.minthreads) 1029 nfsdargs.maxthreads = nfsdargs.minthreads; 1030 } 1031 error = nfssvc(nfssvc_nfsd, &nfsdargs); 1032 if (error < 0 && errno == EAUTH) { 1033 /* 1034 * This indicates that it could not register the 1035 * rpcsec_gss credentials, usually because the 1036 * gssd daemon isn't running. 1037 * (only the experimental server with nfsv4) 1038 */ 1039 syslog(LOG_ERR, "No gssd, using AUTH_SYS only"); 1040 principal[0] = '\0'; 1041 error = nfssvc(nfssvc_nfsd, &nfsdargs); 1042 } 1043 if (error < 0) { 1044 syslog(LOG_ERR, "nfssvc: %m"); 1045 status = 1; 1046 } 1047 if (master) 1048 nfsd_exit(status); 1049 else 1050 exit(status); 1051 } 1052 1053 /* 1054 * Open the stable restart file and return the file descriptor for it. 1055 */ 1056 static void 1057 open_stable(int *stable_fdp, int *backup_fdp) 1058 { 1059 int stable_fd, backup_fd = -1, ret; 1060 struct stat st, backup_st; 1061 1062 /* Open and stat the stable restart file. */ 1063 stable_fd = open(NFSD_STABLERESTART, O_RDWR, 0); 1064 if (stable_fd < 0) 1065 stable_fd = open(NFSD_STABLERESTART, O_RDWR | O_CREAT, 0600); 1066 if (stable_fd >= 0) { 1067 ret = fstat(stable_fd, &st); 1068 if (ret < 0) { 1069 close(stable_fd); 1070 stable_fd = -1; 1071 } 1072 } 1073 1074 /* Open and stat the backup stable restart file. */ 1075 if (stable_fd >= 0) { 1076 backup_fd = open(NFSD_STABLEBACKUP, O_RDWR, 0); 1077 if (backup_fd < 0) 1078 backup_fd = open(NFSD_STABLEBACKUP, O_RDWR | O_CREAT, 1079 0600); 1080 if (backup_fd >= 0) { 1081 ret = fstat(backup_fd, &backup_st); 1082 if (ret < 0) { 1083 close(backup_fd); 1084 backup_fd = -1; 1085 } 1086 } 1087 if (backup_fd < 0) { 1088 close(stable_fd); 1089 stable_fd = -1; 1090 } 1091 } 1092 1093 *stable_fdp = stable_fd; 1094 *backup_fdp = backup_fd; 1095 if (stable_fd < 0) 1096 return; 1097 1098 /* Sync up the 2 files, as required. */ 1099 if (st.st_size > 0) 1100 copy_stable(stable_fd, backup_fd); 1101 else if (backup_st.st_size > 0) 1102 copy_stable(backup_fd, stable_fd); 1103 } 1104 1105 /* 1106 * Copy the stable restart file to the backup or vice versa. 1107 */ 1108 static void 1109 copy_stable(int from_fd, int to_fd) 1110 { 1111 int cnt, ret; 1112 static char buf[1024]; 1113 1114 ret = lseek(from_fd, (off_t)0, SEEK_SET); 1115 if (ret >= 0) 1116 ret = lseek(to_fd, (off_t)0, SEEK_SET); 1117 if (ret >= 0) 1118 ret = ftruncate(to_fd, (off_t)0); 1119 if (ret >= 0) 1120 do { 1121 cnt = read(from_fd, buf, 1024); 1122 if (cnt > 0) 1123 ret = write(to_fd, buf, cnt); 1124 else if (cnt < 0) 1125 ret = cnt; 1126 } while (cnt > 0 && ret >= 0); 1127 if (ret >= 0) 1128 ret = fsync(to_fd); 1129 if (ret < 0) 1130 syslog(LOG_ERR, "stable restart copy failure: %m"); 1131 } 1132 1133 /* 1134 * Back up the stable restart file when indicated by the kernel. 1135 */ 1136 static void 1137 backup_stable(__unused int signo) 1138 { 1139 1140 if (stablefd >= 0) 1141 copy_stable(stablefd, backupfd); 1142 } 1143 1144