usr.sbin/nfsd/nfsd.c

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