update for version 3 from Rick Macklem

[unix-history] / usr / src / sbin / mount_nfs / mount_nfs.c

diff --git a/usr/src/sbin/mount_nfs/mount_nfs.c b/usr/src/sbin/mount_nfs/mount_nfs.c
index f53e571..a0cfa43 100644 (file)
--- a/usr/src/sbin/mount_nfs/mount_nfs.c
+++ b/usr/src/sbin/mount_nfs/mount_nfs.c
@@ -1,6 +1,6 @@
 /*
 /*

- * Copyright (c) 1992 The Regents of the University of California.
- * All rights reserved.
+ * Copyright (c) 1992, 1993, 1994
+ *     The Regents of the University of California.  All rights reserved.

  *
  * This code is derived from software contributed to Berkeley by
  * Rick Macklem at The University of Guelph.
  *
  * This code is derived from software contributed to Berkeley by
  * Rick Macklem at The University of Guelph.


@@ -9,52 +9,107 @@
  */
 
 #ifndef lint
  */
 
 #ifndef lint

-char copyright[] =
-"@(#) Copyright (c) 1992 The Regents of the University of California.\n\
- All rights reserved.\n";
+static char copyright[] =
+"@(#) Copyright (c) 1992, 1993, 1994\n\
+       The Regents of the University of California.  All rights reserved.\n";

 #endif /* not lint */
 
 #ifndef lint
 #endif /* not lint */
 
 #ifndef lint

-static char sccsid[] = "@(#)mount_nfs.c        5.3 (Berkeley) %G%";
+static char sccsid[] = "@(#)mount_nfs.c        8.7 (Berkeley) %G%";

 #endif /* not lint */
 
 #endif /* not lint */
 

-#include <stdio.h>
-#include <signal.h>
-#include <strings.h>
-#include <sys/syslog.h>

 #include <sys/param.h>
 #include <sys/param.h>

-#include <sys/file.h>
-#include <sys/errno.h>
-#include <sys/ucred.h>

 #include <sys/mount.h>
 #include <sys/socket.h>
 #include <sys/socketvar.h>
 #include <sys/mount.h>
 #include <sys/socket.h>
 #include <sys/socketvar.h>

-#include <netdb.h>
+#include <sys/stat.h>
+#include <sys/syslog.h>
+

 #include <rpc/rpc.h>
 #include <rpc/pmap_clnt.h>
 #include <rpc/pmap_prot.h>
 #include <rpc/rpc.h>
 #include <rpc/pmap_clnt.h>
 #include <rpc/pmap_prot.h>

+

 #ifdef ISO
 #include <netiso/iso.h>
 #endif
 #ifdef ISO
 #include <netiso/iso.h>
 #endif

-#ifdef KERBEROS
+
+#ifdef NFSKERB
+#include <kerberosIV/des.h>

 #include <kerberosIV/krb.h>
 #endif
 #include <kerberosIV/krb.h>
 #endif

+

 #include <nfs/rpcv2.h>
 #include <nfs/rpcv2.h>

-#include <nfs/nfsv2.h>
+#include <nfs/nfsproto.h>
+#define KERNEL

 #include <nfs/nfs.h>
 #include <nfs/nfs.h>

+#undef KERNEL

 #include <nfs/nqnfs.h>
 
 #include <nfs/nqnfs.h>
 

-int xdr_dir(), xdr_fh();
+#include <arpa/inet.h>
+
+#include <ctype.h>
+#include <err.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <netdb.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <strings.h>
+#include <unistd.h>
+
+#include "mntopts.h"
+
+#define        ALTF_BG         0x1
+#define ALTF_NOCONN    0x2
+#define ALTF_DUMBTIMR  0x4
+#define ALTF_INTR      0x8
+#define ALTF_KERB      0x10
+#define ALTF_NFSV3     0x20
+#define ALTF_RDIRPLUS  0x40
+#define        ALTF_MNTUDP     0x80
+#define ALTF_RESVPORT  0x100
+#define ALTF_SEQPACKET 0x200
+#define ALTF_NQNFS     0x400
+#define ALTF_SOFT      0x800
+#define ALTF_TCP       0x1000
+
+struct mntopt mopts[] = {
+       MOPT_STDOPTS,
+       MOPT_FORCE,
+       MOPT_UPDATE,
+       { "bg", 0, ALTF_BG, 1 },
+       { "conn", 1, ALTF_NOCONN, 1 },
+       { "dumbtimer", 0, ALTF_DUMBTIMR, 1 },
+       { "intr", 0, ALTF_INTR, 1 },
+#ifdef NFSKERB
+       { "kerb", 0, ALTF_KERB, 1 },
+#endif
+       { "nfsv3", 0, ALTF_NFSV3, 1 },
+       { "rdirplus", 0, ALTF_RDIRPLUS, 1 },
+       { "mntudp", 0, ALTF_MNTUDP, 1 },
+       { "resvport", 0, ALTF_RESVPORT, 1 },
+#ifdef ISO
+       { "seqpacket", 0, ALTF_SEQPACKET, 1 },
+#endif
+       { "nqnfs", 0, ALTF_NQNFS, 1 },
+       { "soft", 0, ALTF_SOFT, 1 },
+       { "tcp", 0, ALTF_TCP, 1 },
+       { NULL }
+};
+

 struct nfs_args nfsdefargs = {
        (struct sockaddr *)0,
        sizeof (struct sockaddr_in),
        SOCK_DGRAM,
        0,
 struct nfs_args nfsdefargs = {
        (struct sockaddr *)0,
        sizeof (struct sockaddr_in),
        SOCK_DGRAM,
        0,

-       (nfsv2fh_t *)0,
+       (u_char *)0,
+       0,

        0,
        NFS_WSIZE,
        NFS_RSIZE,
        0,
        NFS_WSIZE,
        NFS_RSIZE,

-       NFS_TIMEO,
+       NFS_READDIRSIZE,
+       10,

        NFS_RETRANS,
        NFS_MAXGRPS,
        NFS_DEFRAHEAD,
        NFS_RETRANS,
        NFS_MAXGRPS,
        NFS_DEFRAHEAD,


@@ -64,224 +119,352 @@ struct nfs_args nfsdefargs = {
 };
 
 struct nfhret {
 };
 
 struct nfhret {

-       u_long  stat;
-       nfsv2fh_t nfh;
+       u_long          stat;
+       long            vers;
+       long            auth;
+       long            fhsize;
+       u_char          nfh[NFSX_V3FHMAX];

 };
 #define        DEF_RETRY       10000
 #define        BGRND   1
 #define        ISBGRND 2
 int retrycnt = DEF_RETRY;
 int opflags = 0;
 };
 #define        DEF_RETRY       10000
 #define        BGRND   1
 #define        ISBGRND 2
 int retrycnt = DEF_RETRY;
 int opflags = 0;

-extern int errno;
-
-#ifdef ISO
-struct iso_addr *iso_addr();
-#endif
+int nfsproto = IPPROTO_UDP;
+int mnttcp_ok = 1;

 
 

-#ifdef KERBEROS
+#ifdef NFSKERB

 char inst[INST_SZ];
 char realm[REALM_SZ];
 char inst[INST_SZ];
 char realm[REALM_SZ];

-KTEXT_ST kt;
+struct {
+       u_long          kind;
+       KTEXT_ST        kt;
+} ktick;
+struct nfsrpc_nickverf kverf;
+struct nfsrpc_fullblock kin, kout;
+NFSKERBKEY_T kivec;
+CREDENTIALS kcr;
+struct timeval ktv;
+NFSKERBKEYSCHED_T kerb_keysched;
+#endif
+
+int    getnfsargs __P((char *, struct nfs_args *));
+#ifdef ISO
+struct iso_addr *iso_addr __P((const char *));

 #endif
 #endif

+void   set_rpc_maxgrouplist __P((int));
+__dead void usage __P((void));
+int    xdr_dir __P((XDR *, char *));
+int    xdr_fh __P((XDR *, struct nfhret *));

 
 

-main(argc, argv, arge)
+int
+main(argc, argv)

        int argc;
        int argc;

-       char **argv;
-       char **arge;
+       char *argv[];

 {
 {

-       struct nfs_args nfsargs;

        register int c;
        register int c;

-       register struct nfs_args *nfsargsp = &nfsargs;
+       register struct nfs_args *nfsargsp;
+       struct nfs_args nfsargs;

        struct nfsd_cargs ncd;
        struct nfsd_cargs ncd;

-       int num, flags = 0, match = 1, i, nfssvc_flag;
-       char *spec, *name;
-       uid_t last_ruid = -1;
-       extern int optind;
-       extern char *optarg;
-
-#ifdef KERBEROS
-       strcpy(realm, KRB_REALM);
-#endif
-       nfsargs = nfsdefargs;
+       int mntflags, altflags, i, nfssvc_flag, num;
+       char *name, *p, *spec;
+       int error = 0;
+#ifdef NFSKERB
+       uid_t last_ruid;
+
+       last_ruid = -1;
+       (void)strcpy(realm, KRB_REALM);
+       if (sizeof (struct nfsrpc_nickverf) != RPCX_NICKVERF ||
+           sizeof (struct nfsrpc_fullblock) != RPCX_FULLBLOCK ||
+           ((char *)&ktick.kt) - ((char *)&ktick) != NFSX_UNSIGNED ||
+           ((char *)ktick.kt.dat) - ((char *)&ktick) != 2 * NFSX_UNSIGNED)
+               fprintf(stderr, "Yikes! NFSKERB structs not packed!!\n");
+#endif /* NFSKERB */

        retrycnt = DEF_RETRY;
        retrycnt = DEF_RETRY;

-       if (argc <= 1)
-               Usage(argc, argv);
-       while ((c = getopt(argc, argv, "bsiTpMlqdckPF:R:r:w:t:x:g:a:L:D:Km:"))
-               != EOF)
+
+       mntflags = 0;
+       altflags = 0;
+       nfsargs = nfsdefargs;
+       nfsargsp = &nfsargs;
+       while ((c = getopt(argc, argv,
+           "3a:bcdD:g:I:iKL:lm:o:PpqR:r:sTt:w:x:U")) != EOF)

                switch (c) {
                switch (c) {

+               case '3':
+                       nfsargsp->flags |= NFSMNT_NFSV3;
+                       break;
+               case 'a':
+                       num = strtol(optarg, &p, 10);
+                       if (*p || num < 0)
+                               errx(1, "illegal -a value -- %s", optarg);
+                       nfsargsp->readahead = num;
+                       nfsargsp->flags |= NFSMNT_READAHEAD;
+                       break;

                case 'b':
                        opflags |= BGRND;
                        break;
                case 'b':
                        opflags |= BGRND;
                        break;

-               case 's':
-                       nfsargsp->flags |= NFSMNT_SOFT;
+               case 'c':
+                       nfsargsp->flags |= NFSMNT_NOCONN;
+                       break;
+               case 'D':
+                       num = strtol(optarg, &p, 10);
+                       if (*p || num <= 0)
+                               errx(1, "illegal -D value -- %s", optarg);
+                       nfsargsp->deadthresh = num;
+                       nfsargsp->flags |= NFSMNT_DEADTHRESH;
+                       break;
+               case 'd':
+                       nfsargsp->flags |= NFSMNT_DUMBTIMR;
+                       break;
+               case 'g':
+                       num = strtol(optarg, &p, 10);
+                       if (*p || num <= 0)
+                               errx(1, "illegal -g value -- %s", optarg);
+                       set_rpc_maxgrouplist(num);
+                       nfsargsp->maxgrouplist = num;
+                       nfsargsp->flags |= NFSMNT_MAXGRPS;
+                       break;
+               case 'I':
+                       num = strtol(optarg, &p, 10);
+                       if (*p || num <= 0)
+                               errx(1, "illegal -I value -- %s", optarg);
+                       nfsargsp->readdirsize = num;
+                       nfsargsp->flags |= NFSMNT_READDIRSIZE;

                        break;
                case 'i':
                        nfsargsp->flags |= NFSMNT_INT;
                        break;
                        break;
                case 'i':
                        nfsargsp->flags |= NFSMNT_INT;
                        break;

-               case 'T':
-                       nfsargsp->sotype = SOCK_STREAM;
-                       break;
-#ifdef ISO
-               case 'p':
-                       nfsargsp->sotype = SOCK_SEQPACKET;
+#ifdef NFSKERB
+               case 'K':
+                       nfsargsp->flags |= NFSMNT_KERB;

                        break;
 #endif
                        break;
 #endif

-               case 'M':
-                       nfsargsp->flags |= NFSMNT_MYWRITE;
+               case 'L':
+                       num = strtol(optarg, &p, 10);
+                       if (*p || num < 2)
+                               errx(1, "illegal -L value -- %s", optarg);
+                       nfsargsp->leaseterm = num;
+                       nfsargsp->flags |= NFSMNT_LEASETERM;

                        break;
                case 'l':
                        break;
                case 'l':

-                       nfsargsp->flags |= NFSMNT_RDIRALOOK;
-                       break;
-               case 'q':
-                       nfsargsp->flags |= NFSMNT_NQNFS;
+                       nfsargsp->flags |= NFSMNT_RDIRPLUS;

                        break;
                        break;

-               case 'd':
-                       nfsargsp->flags |= NFSMNT_DUMBTIMR;
-                       break;
-               case 'c':
-                       nfsargsp->flags |= NFSMNT_NOCONN;
+#ifdef NFSKERB
+               case 'm':
+                       (void)strncpy(realm, optarg, REALM_SZ - 1);
+                       realm[REALM_SZ - 1] = '\0';

                        break;
                        break;

-               case 'k':
-                       nfsargsp->flags |= NFSMNT_NQLOOKLEASE;
+#endif
+               case 'o':
+                       getmntopts(optarg, mopts, &mntflags, &altflags);
+                       if(altflags & ALTF_BG)
+                               opflags |= BGRND;
+                       if(altflags & ALTF_NOCONN)
+                               nfsargsp->flags |= NFSMNT_NOCONN;
+                       if(altflags & ALTF_DUMBTIMR)
+                               nfsargsp->flags |= NFSMNT_DUMBTIMR;
+                       if(altflags & ALTF_INTR)
+                               nfsargsp->flags |= NFSMNT_INT;
+#ifdef NFSKERB
+                       if(altflags & ALTF_KERB)
+                               nfsargsp->flags |= NFSMNT_KERB;
+#endif
+                       if(altflags & ALTF_NFSV3)
+                               nfsargsp->flags |= NFSMNT_NFSV3;
+                       if(altflags & ALTF_RDIRPLUS)
+                               nfsargsp->flags |= NFSMNT_RDIRPLUS;
+                       if(altflags & ALTF_MNTUDP)
+                               mnttcp_ok = 0;
+                       if(altflags & ALTF_RESVPORT)
+                               nfsargsp->flags |= NFSMNT_RESVPORT;
+#ifdef ISO
+                       if(altflags & ALTF_SEQPACKET)
+                               nfsargsp->sotype = SOCK_SEQPACKET;
+#endif
+                       if(altflags & ALTF_NQNFS)
+                               nfsargsp->flags |= (NFSMNT_NQNFS|NFSMNT_NFSV3);
+                       if(altflags & ALTF_SOFT)
+                               nfsargsp->flags |= NFSMNT_SOFT;
+                       if(altflags & ALTF_TCP) {
+                               nfsargsp->sotype = SOCK_STREAM;
+                               nfsproto = IPPROTO_TCP;
+                       }
+                       altflags = 0;

                        break;
                case 'P':
                        nfsargsp->flags |= NFSMNT_RESVPORT;
                        break;
                        break;
                case 'P':
                        nfsargsp->flags |= NFSMNT_RESVPORT;
                        break;

-               case 'F':
-                       if ((num = atoi(optarg)) != 0)
-                               flags = num;
+#ifdef ISO
+               case 'p':
+                       nfsargsp->sotype = SOCK_SEQPACKET;
+                       break;
+#endif
+               case 'q':
+                       nfsargsp->flags |= (NFSMNT_NQNFS | NFSMNT_NFSV3);

                        break;
                case 'R':
                        break;
                case 'R':

-                       if ((num = atoi(optarg)) > 0)
-                               retrycnt = num;
+                       num = strtol(optarg, &p, 10);
+                       if (*p || num <= 0)
+                               errx(1, "illegal -R value -- %s", optarg);
+                       retrycnt = num;

                        break;
                case 'r':
                        break;
                case 'r':

-                       if ((num = atoi(optarg)) > 0) {
-                               nfsargsp->rsize = num;
-                               nfsargsp->flags |= NFSMNT_RSIZE;
-                       }
+                       num = strtol(optarg, &p, 10);
+                       if (*p || num <= 0)
+                               errx(1, "illegal -r value -- %s", optarg);
+                       nfsargsp->rsize = num;
+                       nfsargsp->flags |= NFSMNT_RSIZE;

                        break;
                        break;

-               case 'w':
-                       if ((num = atoi(optarg)) > 0) {
-                               nfsargsp->wsize = num;
-                               nfsargsp->flags |= NFSMNT_WSIZE;
-                       }
+               case 's':
+                       nfsargsp->flags |= NFSMNT_SOFT;
+                       break;
+               case 'T':
+                       nfsargsp->sotype = SOCK_STREAM;
+                       nfsproto = IPPROTO_TCP;

                        break;
                case 't':
                        break;
                case 't':

-                       if ((num = atoi(optarg)) > 0) {
-                               nfsargsp->timeo = num;
-                               nfsargsp->flags |= NFSMNT_TIMEO;
-                       }
+                       num = strtol(optarg, &p, 10);
+                       if (*p || num <= 0)
+                               errx(1, "illegal -t value -- %s", optarg);
+                       nfsargsp->timeo = num;
+                       nfsargsp->flags |= NFSMNT_TIMEO;
+                       break;
+               case 'w':
+                       num = strtol(optarg, &p, 10);
+                       if (*p || num <= 0)
+                               errx(1, "illegal -w value -- %s", optarg);
+                       nfsargsp->wsize = num;
+                       nfsargsp->flags |= NFSMNT_WSIZE;

                        break;
                case 'x':
                        break;
                case 'x':

-                       if ((num = atoi(optarg)) > 0) {
-                               nfsargsp->retrans = num;
-                               nfsargsp->flags |= NFSMNT_RETRANS;
-                       }
+                       num = strtol(optarg, &p, 10);
+                       if (*p || num <= 0)
+                               errx(1, "illegal -x value -- %s", optarg);
+                       nfsargsp->retrans = num;
+                       nfsargsp->flags |= NFSMNT_RETRANS;

                        break;
                        break;

-               case 'g':
-                       if ((num = atoi(optarg)) > 0) {
-                               set_rpc_maxgrouplist(num);
-                               nfsargsp->maxgrouplist = num;
-                               nfsargsp->flags |= NFSMNT_MAXGRPS;
-                       }
+               case 'U':
+                       mnttcp_ok = 0;

                        break;
                        break;

-               case 'a':
-                       if ((num = atoi(optarg)) >= 0) {
-                               nfsargsp->readahead = num;
-                               nfsargsp->flags |= NFSMNT_READAHEAD;
-                       }
+               default:
+                       usage();

                        break;
                        break;

-               case 'L':
-                       if ((num = atoi(optarg)) >= 2) {
-                               nfsargsp->leaseterm = num;
-                               nfsargsp->flags |= NFSMNT_LEASETERM;
+               }
+       argc -= optind;
+       argv += optind;
+
+       if (argc != 2)
+               usage();
+
+       spec = *argv++;
+       name = *argv;
+
+       if (!getnfsargs(spec, nfsargsp))
+               exit(1);
+
+       if (mount("nfs", name, mntflags, nfsargsp))
+               err(1, "%s", name);
+       if (nfsargsp->flags & (NFSMNT_NQNFS | NFSMNT_KERB)) {
+               if ((opflags & ISBGRND) == 0) {
+                       if (i = fork()) {
+                               if (i == -1)
+                                       err(1, "nqnfs 1");
+                               exit(0);

                        }
                        }

-                       break;
-               case 'D':
-                       if ((num = atoi(optarg)) > 0) {
-                               nfsargsp->deadthresh = num;
-                               nfsargsp->flags |= NFSMNT_DEADTHRESH;
+                       (void) setsid();
+                       (void) close(STDIN_FILENO);
+                       (void) close(STDOUT_FILENO);
+                       (void) close(STDERR_FILENO);
+                       (void) chdir("/");
+               }
+               openlog("mount_nfs:", LOG_PID, LOG_DAEMON);
+               nfssvc_flag = NFSSVC_MNTD;
+               ncd.ncd_dirp = name;
+               while (nfssvc(nfssvc_flag, (caddr_t)&ncd) < 0) {
+                       if (errno != ENEEDAUTH) {
+                               syslog(LOG_ERR, "nfssvc err %m");
+                               continue;

                        }
                        }

-                       break;
-#ifdef KERBEROS
-               case 'K':
-                       nfsargsp->flags |= NFSMNT_KERB;
-                       break;
-               case 'm':
-                       strncpy(realm, optarg, REALM_SZ - 1);
-                       realm[REALM_SZ - 1] = '\0';
-                       break;
-#endif /* KERBEROS */
-               default:
-                       Usage(argc, argv);
-               };
-       if ((argc - optind) == 2) {
-               spec = argv[optind];
-               name = argv[optind + 1];
-       } else
-               Usage(argc, argv);
-       if (getnfsargs(spec, nfsargsp)) {
-               if (mount(MOUNT_NFS, name, flags, nfsargsp))
-                       exit(1);
-               if (nfsargsp->flags & (NFSMNT_NQNFS | NFSMNT_KERB)) {
-                       if ((opflags & ISBGRND) == 0) {
-                               if (i = fork()) {
-                                       if (i == -1) {
-                                               perror("nqnfs");
-                                               exit(1);
-                                       }
-                                       exit();
-                               }
-                               (void) setsid();
-                               (void) close(0);
-                               (void) close(1);
-                               (void) close(2);
-                               (void) chdir("/");
+                       nfssvc_flag =
+                           NFSSVC_MNTD | NFSSVC_GOTAUTH | NFSSVC_AUTHINFAIL;
+#ifdef NFSKERB
+                       /*
+                        * Set up as ncd_authuid for the kerberos call.
+                        * Must set ruid to ncd_authuid and reset the
+                        * ticket name iff ncd_authuid is not the same
+                        * as last time, so that the right ticket file
+                        * is found.
+                        * Get the Kerberos credential structure so that
+                        * we have the seesion key and get a ticket for
+                        * this uid.
+                        * For more info see the IETF Draft "Authentication
+                        * in ONC RPC".
+                        */
+                       if (ncd.ncd_authuid != last_ruid) {
+                               krb_set_tkt_string("");
+                               last_ruid = ncd.ncd_authuid;

                        }
                        }

-                       openlog("mount_nfs:", LOG_PID, LOG_DAEMON);
-                       nfssvc_flag = NFSSVC_MNTD;
-                       ncd.ncd_dirp = name;
-                       while (nfssvc(nfssvc_flag, (caddr_t)&ncd) < 0) {
-                           if (errno == ENEEDAUTH) {
-syslog(LOG_ERR, "in eacces");
-                               nfssvc_flag = NFSSVC_MNTD | NFSSVC_GOTAUTH |
-                                       NFSSVC_AUTHINFAIL;
-#ifdef KERBEROS
-syslog(LOG_ERR,"Callin krb uid=%d inst=%s realm=%s",ncd.ncd_authuid,inst,realm);
-                               /*
-                                * Set up as ncd_authuid for the kerberos call.
-                                * Must set ruid to ncd_authuid and reset the
-                                * ticket name iff ncd_authuid is not the same
-                                * as last time, so that the right ticket file
-                                * is found.
-                                */
-                               if (ncd.ncd_authuid != last_ruid) {
-                                       krb_set_tkt_string("");
-                                       last_ruid = ncd.ncd_authuid;
-                               }
-                               setreuid(ncd.ncd_authuid, 0);
-                               if (krb_mk_req(&kt, "rcmd", inst, realm, 0) ==
-                                   KSUCCESS &&
-                                   kt.length <= (RPCAUTH_MAXSIZ - 2*NFSX_UNSIGNED)) {
-syslog(LOG_ERR,"Got it\n");
-                                   ncd.ncd_authtype = RPCAUTH_NQNFS;
-                                   ncd.ncd_authlen = kt.length;
-                                   ncd.ncd_authstr = (char *)kt.dat;
-                                   nfssvc_flag = NFSSVC_MNTD | NFSSVC_GOTAUTH;
-                               }
-                               setreuid(0, 0);
-syslog(LOG_ERR,"ktlen=%d\n", kt.length);
-#endif /* KERBEROS */
-                           } else
-                               syslog(LOG_ERR, "nfssvc err %m");
+                       setreuid(ncd.ncd_authuid, 0);
+                       kret = krb_get_cred(NFS_KERBSRV, inst, realm, &kcr);
+                       if (kret == RET_NOTKT) {
+                           kret = get_ad_tkt(NFS_KERBSRV, inst, realm,
+                               DEFAULT_TKT_LIFE);
+                           if (kret == KSUCCESS)
+                               kret = krb_get_cred(NFS_KERBSRV, inst, realm,
+                                   &kcr);
+                       }
+                       if (kret == KSUCCESS)
+                           kret = krb_mk_req(&ktick.kt, NFS_KERBSRV, inst,
+                               realm, 0);
+
+                       /*
+                        * Fill in the AKN_FULLNAME authenticator and verfier.
+                        * Along with the Kerberos ticket, we need to build
+                        * the timestamp verifier and encrypt it in CBC mode.
+                        */
+                       if (kret == KSUCCESS &&
+                           ktick.kt.length <= (RPCAUTH_MAXSIZ-3*NFSX_UNSIGNED)
+                           && gettimeofday(&ktv, (struct timezone *)0) == 0) {
+                           ncd.ncd_authtype = RPCAUTH_KERB4;
+                           ncd.ncd_authstr = (u_char *)&ktick;
+                           ncd.ncd_authlen = nfsm_rndup(ktick.kt.length) +
+                               3 * NFSX_UNSIGNED;
+                           ncd.ncd_verfstr = (u_char *)&kverf;
+                           ncd.ncd_verflen = sizeof (kverf);
+                           bcopy((caddr_t)kcr.session, (caddr_t)ncd.ncd_key,
+                               sizeof (kcr.session));
+                           kin.t1 = htonl(ktv.tv_sec);
+                           kin.t2 = htonl(ktv.tv_usec);
+                           kin.w1 = htonl(NFS_KERBTTL);
+                           kin.w2 = htonl(NFS_KERBTTL - 1);
+                           bzero((caddr_t)kivec, sizeof (kivec));
+
+                           /*
+                            * Encrypt kin in CBC mode using the session
+                            * key in kcr.
+                            */
+                           XXX
+
+                           /*
+                            * Finally, fill the timestamp verifier into the
+                            * authenticator and verifier.
+                            */
+                           ktick.kind = htonl(RPCAKN_FULLNAME);
+                           kverf.kind = htonl(RPCAKN_FULLNAME);
+                           NFS_KERBW1(ktick.kt) = kout.w1;
+                           ktick.kt.length = htonl(ktick.kt.length);
+                           kverf.verf.t1 = kout.t1;
+                           kverf.verf.t2 = kout.t2;
+                           kverf.verf.w2 = kout.w2;
+                           nfssvc_flag = NFSSVC_MNTD | NFSSVC_GOTAUTH;

                        }
                        }

+                       setreuid(0, 0);
+#endif /* NFSKERB */

                }
                }

-               exit();
-       } else
-               exit(1);
+       }
+       exit(0);

 }
 
 }
 

+int

 getnfsargs(spec, nfsargsp)
        char *spec;
        struct nfs_args *nfsargsp;
 getnfsargs(spec, nfsargsp)
        char *spec;
        struct nfs_args *nfsargsp;


@@ -292,25 +475,28 @@ getnfsargs(spec, nfsargsp)
 #ifdef ISO
        static struct sockaddr_iso isoaddr;
        struct iso_addr *isop;
 #ifdef ISO
        static struct sockaddr_iso isoaddr;
        struct iso_addr *isop;

+       int isoflag = 0;

 #endif
        struct timeval pertry, try;
        enum clnt_stat clnt_stat;
 #endif
        struct timeval pertry, try;
        enum clnt_stat clnt_stat;

-       int so = RPC_ANYSOCK, isoflag = 0, i;
-       char *hostp, *delimp, *cp;
+       int so = RPC_ANYSOCK, i, nfsvers, mntvers;
+       char *hostp, *delimp;
+#ifdef NFSKERB
+       char *cp;
+#endif

        u_short tport;
        static struct nfhret nfhret;
        static char nam[MNAMELEN + 1];
 
        strncpy(nam, spec, MNAMELEN);
        nam[MNAMELEN] = '\0';
        u_short tport;
        static struct nfhret nfhret;
        static char nam[MNAMELEN + 1];
 
        strncpy(nam, spec, MNAMELEN);
        nam[MNAMELEN] = '\0';

-       if ((delimp = index(spec, '@')) != NULL) {
+       if ((delimp = strchr(spec, '@')) != NULL) {

                hostp = delimp + 1;
                hostp = delimp + 1;

-       } else if ((delimp = index(spec, ':')) != NULL) {
+       } else if ((delimp = strchr(spec, ':')) != NULL) {

                hostp = spec;
                spec = delimp + 1;
        } else {
                hostp = spec;
                spec = delimp + 1;
        } else {

-               fprintf(stderr,
-                   "No <host>:<dirpath> or <dirpath>@<host> spec\n");
+               warnx("no <host>:<dirpath> or <dirpath>@<host> spec");

                return (0);
        }
        *delimp = '\0';
                return (0);
        }
        *delimp = '\0';


@@ -324,13 +510,13 @@ getnfsargs(spec, nfsargsp)
 
                hostp += 4;
                isoflag++;
 
                hostp += 4;
                isoflag++;

-               if ((delimp = index(hostp, '+')) == NULL) {
-                       fprintf(stderr, "No iso+inet address\n");
+               if ((delimp = strchr(hostp, '+')) == NULL) {
+                       warnx("no iso+inet address");

                        return (0);
                }
                *delimp = '\0';
                if ((isop = iso_addr(hostp)) == NULL) {
                        return (0);
                }
                *delimp = '\0';
                if ((isop = iso_addr(hostp)) == NULL) {

-                       fprintf(stderr, "Bad iso address\n");
+                       warnx("bad ISO address");

                        return (0);
                }
                bzero((caddr_t)&isoaddr, sizeof (isoaddr));
                        return (0);
                }
                bzero((caddr_t)&isoaddr, sizeof (isoaddr));


@@ -351,54 +537,73 @@ getnfsargs(spec, nfsargsp)
         */
        if (isdigit(*hostp)) {
                if ((saddr.sin_addr.s_addr = inet_addr(hostp)) == -1) {
         */
        if (isdigit(*hostp)) {
                if ((saddr.sin_addr.s_addr = inet_addr(hostp)) == -1) {

-                       fprintf(stderr, "Bad net addr %s\n", hostp);
+                       warnx("bad net address %s", hostp);

                        return (0);
                }
                        return (0);
                }

-               if ((nfsargsp->flags & NFSMNT_KERB) &&
-                   (hp = gethostbyaddr((char *)&saddr.sin_addr.s_addr,
-                       sizeof (u_long), AF_INET)) == (struct hostent *)0) {
-                       fprintf(stderr, "Can't reverse resolve net addr\n");
+       } else if ((hp = gethostbyname(hostp)) != NULL) {
+               bcopy(hp->h_addr, (caddr_t)&saddr.sin_addr, hp->h_length);
+       } else {
+               warnx("can't get net id for host");
+               return (0);
+        }
+#ifdef NFSKERB
+       if ((nfsargsp->flags & NFSMNT_KERB)) {
+               if ((hp = gethostbyaddr((char *)&saddr.sin_addr.s_addr,
+                   sizeof (u_long), AF_INET)) == (struct hostent *)0) {
+                       warnx("can't reverse resolve net address");

                        return (0);
                }
                        return (0);
                }

-       } else if ((hp = gethostbyname(hostp)) == NULL) {
-               fprintf(stderr, "Can't get net id for host\n");
-               return (0);
-       }
-#ifdef KERBEROS
-       if (nfsargsp->flags & NFSMNT_KERB) {
+               bcopy(hp->h_addr, (caddr_t)&saddr.sin_addr, hp->h_length);

                strncpy(inst, hp->h_name, INST_SZ);
                inst[INST_SZ - 1] = '\0';
                strncpy(inst, hp->h_name, INST_SZ);
                inst[INST_SZ - 1] = '\0';

-               if (cp = index(inst, '.'))
+               if (cp = strchr(inst, '.'))

                        *cp = '\0';
        }
                        *cp = '\0';
        }

-#endif /* KERBEROS */
+#endif /* NFSKERB */

 
 

-       bcopy(hp->h_addr, (caddr_t)&saddr.sin_addr, hp->h_length);
+       if (nfsargsp->flags & NFSMNT_NFSV3) {
+               nfsvers = 3;
+               mntvers = 3;
+       } else {
+               nfsvers = 2;
+               mntvers = 1;
+       }

        nfhret.stat = EACCES;   /* Mark not yet successful */
        while (retrycnt > 0) {
                saddr.sin_family = AF_INET;
                saddr.sin_port = htons(PMAPPORT);
                if ((tport = pmap_getport(&saddr, RPCPROG_NFS,
        nfhret.stat = EACCES;   /* Mark not yet successful */
        while (retrycnt > 0) {
                saddr.sin_family = AF_INET;
                saddr.sin_port = htons(PMAPPORT);
                if ((tport = pmap_getport(&saddr, RPCPROG_NFS,

-                   NFS_VER2, IPPROTO_UDP)) == 0) {
+                   nfsvers, nfsproto)) == 0) {

                        if ((opflags & ISBGRND) == 0)
                                clnt_pcreateerror("NFS Portmap");
                } else {
                        saddr.sin_port = 0;
                        pertry.tv_sec = 10;
                        pertry.tv_usec = 0;
                        if ((opflags & ISBGRND) == 0)
                                clnt_pcreateerror("NFS Portmap");
                } else {
                        saddr.sin_port = 0;
                        pertry.tv_sec = 10;
                        pertry.tv_usec = 0;

-                       if ((clp = clntudp_create(&saddr, RPCPROG_MNT,
-                           RPCMNT_VER1, pertry, &so)) == NULL) {
+                       if (mnttcp_ok && nfsargsp->sotype == SOCK_STREAM)
+                           clp = clnttcp_create(&saddr, RPCPROG_MNT, mntvers,
+                               &so, 0, 0);
+                       else
+                           clp = clntudp_create(&saddr, RPCPROG_MNT, mntvers,
+                               pertry, &so);
+                       if (clp == NULL) {

                                if ((opflags & ISBGRND) == 0)
                                        clnt_pcreateerror("Cannot MNT PRC");
                        } else {
                                clp->cl_auth = authunix_create_default();
                                try.tv_sec = 10;
                                try.tv_usec = 0;
                                if ((opflags & ISBGRND) == 0)
                                        clnt_pcreateerror("Cannot MNT PRC");
                        } else {
                                clp->cl_auth = authunix_create_default();
                                try.tv_sec = 10;
                                try.tv_usec = 0;

+                               if (nfsargsp->flags & NFSMNT_KERB)
+                                   nfhret.auth = RPCAUTH_KERB4;
+                               else
+                                   nfhret.auth = RPCAUTH_UNIX;
+                               nfhret.vers = mntvers;

                                clnt_stat = clnt_call(clp, RPCMNT_MOUNT,
                                    xdr_dir, spec, xdr_fh, &nfhret, try);
                                if (clnt_stat != RPC_SUCCESS) {
                                        if ((opflags & ISBGRND) == 0)
                                clnt_stat = clnt_call(clp, RPCMNT_MOUNT,
                                    xdr_dir, spec, xdr_fh, &nfhret, try);
                                if (clnt_stat != RPC_SUCCESS) {
                                        if ((opflags & ISBGRND) == 0)

-                                               clnt_perror(clp, "Bad MNT RPC");
+                                               warnx("%s", clnt_sperror(clp,
+                                                   "bad MNT RPC"));

                                } else {
                                        auth_destroy(clp->cl_auth);
                                        clnt_destroy(clp);
                                } else {
                                        auth_destroy(clp->cl_auth);
                                        clnt_destroy(clp);


@@ -410,28 +615,25 @@ getnfsargs(spec, nfsargsp)
                        if (opflags & BGRND) {
                                opflags &= ~BGRND;
                                if (i = fork()) {
                        if (opflags & BGRND) {
                                opflags &= ~BGRND;
                                if (i = fork()) {

-                                       if (i == -1) {
-                                               perror("nqnfs");
-                                               exit(1);
-                                       }
-                                       exit();
+                                       if (i == -1)
+                                               err(1, "nqnfs 2");
+                                       exit(0);

                                }
                                (void) setsid();
                                }
                                (void) setsid();

-                               (void) close(0);
-                               (void) close(1);
-                               (void) close(2);
+                               (void) close(STDIN_FILENO);
+                               (void) close(STDOUT_FILENO);
+                               (void) close(STDERR_FILENO);

                                (void) chdir("/");
                                opflags |= ISBGRND;
                                (void) chdir("/");
                                opflags |= ISBGRND;

-                       } 
+                       }

                        sleep(60);
                }
        }
        if (nfhret.stat) {
                if (opflags & ISBGRND)
                        exit(1);
                        sleep(60);
                }
        }
        if (nfhret.stat) {
                if (opflags & ISBGRND)
                        exit(1);

-               fprintf(stderr, "Can't access %s: ", spec);

                errno = nfhret.stat;
                errno = nfhret.stat;

-               perror(NULL);
+               warn("can't access %s", spec);

                return (0);
        }
        saddr.sin_port = htons(tport);
                return (0);
        }
        saddr.sin_port = htons(tport);


@@ -445,7 +647,8 @@ getnfsargs(spec, nfsargsp)
                nfsargsp->addr = (struct sockaddr *) &saddr;
                nfsargsp->addrlen = sizeof (saddr);
        }
                nfsargsp->addr = (struct sockaddr *) &saddr;
                nfsargsp->addrlen = sizeof (saddr);
        }

-       nfsargsp->fh = &nfhret.nfh;
+       nfsargsp->fh = nfhret.nfh;
+       nfsargsp->fhsize = nfhret.fhsize;

        nfsargsp->hostname = nam;
        return (1);
 }
        nfsargsp->hostname = nam;
        return (1);
 }


@@ -453,6 +656,7 @@ getnfsargs(spec, nfsargsp)
 /*
  * xdr routines for mount rpc's
  */
 /*
  * xdr routines for mount rpc's
  */

+int

 xdr_dir(xdrsp, dirp)
        XDR *xdrsp;
        char *dirp;
 xdr_dir(xdrsp, dirp)
        XDR *xdrsp;
        char *dirp;


@@ -460,25 +664,51 @@ xdr_dir(xdrsp, dirp)
        return (xdr_string(xdrsp, &dirp, RPCMNT_PATHLEN));
 }
 
        return (xdr_string(xdrsp, &dirp, RPCMNT_PATHLEN));
 }
 

+int

 xdr_fh(xdrsp, np)
        XDR *xdrsp;
 xdr_fh(xdrsp, np)
        XDR *xdrsp;

-       struct nfhret *np;
+       register struct nfhret *np;

 {
 {

-       if (!xdr_u_long(xdrsp, &(np->stat)))
+       register int i;
+       long auth, authcnt, authfnd = 0;
+
+       if (!xdr_u_long(xdrsp, &np->stat))

                return (0);
        if (np->stat)
                return (1);
                return (0);
        if (np->stat)
                return (1);

-       return (xdr_opaque(xdrsp, (caddr_t)&(np->nfh), NFSX_FH));
+       switch (np->vers) {
+       case 1:
+               np->fhsize = NFSX_V2FH;
+               return (xdr_opaque(xdrsp, (caddr_t)np->nfh, NFSX_V2FH));
+       case 3:
+               if (!xdr_long(xdrsp, &np->fhsize))
+                       return (0);
+               if (np->fhsize <= 0 || np->fhsize > NFSX_V3FHMAX)
+                       return (0);
+               if (!xdr_opaque(xdrsp, (caddr_t)np->nfh, np->fhsize))
+                       return (0);
+               if (!xdr_long(xdrsp, &authcnt))
+                       return (0);
+               for (i = 0; i < authcnt; i++) {
+                       if (!xdr_long(xdrsp, &auth))
+                               return (0);
+                       if (auth == np->auth)
+                               authfnd++;
+               }
+               if (!authfnd)
+                       np->stat = EAUTH;
+               return (1);
+       };
+       return (0);

 }
 
 }
 

-Usage(argc, argv)
-       int argc;
-       char *argv[];
+__dead void
+usage()

 {
 {

-       register int i;
-
-       for (i = 0; i < argc; i++)
-               fprintf(stderr, "%s ", argv[i]);
-       fprintf(stderr, "\nBad mount_nfs arg\n");
+       (void)fprintf(stderr, "usage: mount_nfs %s\n%s\n%s\n%s\n",
+"[-bcdiKklMPqsT] [-a maxreadahead] [-D deadthresh]",
+"\t[-g maxgroups] [-L leaseterm] [-m realm] [-o options] [-R retrycnt]",
+"\t[-r readsize] [-t timeout] [-w writesize] [-x retrans]",
+"\trhost:path node");

        exit(1);
 }
        exit(1);
 }