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