/*      $NetBSD: mount_fs.c,v 1.3 2015/01/17 17:46:31 christos Exp $    */

/*
* Copyright (c) 1997-2014 Erez Zadok
* Copyright (c) 1990 Jan-Simon Pendry
* Copyright (c) 1990 Imperial College of Science, Technology & Medicine
* Copyright (c) 1990 The Regents of the University of California.
* All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* Jan-Simon Pendry at Imperial College, London.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
*
* File: am-utils/libamu/mount_fs.c
*
*/

#ifdef HAVE_CONFIG_H
# include <config.h>
#endif /* HAVE_CONFIG_H */
#include <am_defs.h>
#include <amu.h>
#include <nfs_common.h>


/* ensure that mount table options are delimited by a comma */
#define append_opts(old, l, new) { \
       if (*(old) != '\0') \
         xstrlcat(old, ",", l); \
       xstrlcat(old, new, l); }

/*
* Standard mount flags
*/
struct opt_tab mnt_flags[] =
{
#if defined(MNT2_GEN_OPT_RDONLY) && defined(MNTTAB_OPT_RO)
 {MNTTAB_OPT_RO, MNT2_GEN_OPT_RDONLY},
#endif /* defined(MNT2_GEN_OPT_RDONLY) && defined(MNTTAB_OPT_RO) */

#if defined(MNT2_GEN_OPT_NOCACHE) && defined(MNTTAB_OPT_NOCACHE)
 {MNTTAB_OPT_NOCACHE, MNT2_GEN_OPT_NOCACHE},
#endif /* defined(MNT2_GEN_OPT_NOCACHE) && defined(MNTTAB_OPT_NOCACHE) */

 /* the "grpid" mount option can be offered as generic of NFS */
#ifdef MNTTAB_OPT_GRPID
# ifdef MNT2_GEN_OPT_GRPID
 {MNTTAB_OPT_GRPID, MNT2_GEN_OPT_GRPID},
# endif /* MNT2_GEN_OPT_GRPID */
# ifdef MNT2_NFS_OPT_GRPID
 {MNTTAB_OPT_GRPID, MNT2_NFS_OPT_GRPID},
# endif /* MNT2_NFS_OPT_GRPID */
#endif /* MNTTAB_OPT_GRPID */

#if defined(MNT2_GEN_OPT_MULTI) && defined(MNTTAB_OPT_MULTI)
 {MNTTAB_OPT_MULTI, MNT2_GEN_OPT_MULTI},
#endif /* defined(MNT2_GEN_OPT_MULTI) && defined(MNTTAB_OPT_MULTI) */

#if defined(MNT2_GEN_OPT_NODEV) && defined(MNTTAB_OPT_NODEV)
 {MNTTAB_OPT_NODEV, MNT2_GEN_OPT_NODEV},
#endif /* defined(MNT2_GEN_OPT_NODEV) && defined(MNTTAB_OPT_NODEV) */

#if defined(MNT2_GEN_OPT_NOEXEC) && defined(MNTTAB_OPT_NOEXEC)
 {MNTTAB_OPT_NOEXEC, MNT2_GEN_OPT_NOEXEC},
#endif /* defined(MNT2_GEN_OPT_NOEXEC) && defined(MNTTAB_OPT_NOEXEC) */

#if defined(MNT2_GEN_OPT_NOSUB) && defined(MNTTAB_OPT_NOSUB)
 {MNTTAB_OPT_NOSUB, MNT2_GEN_OPT_NOSUB},
#endif /* defined(MNT2_GEN_OPT_NOSUB) && defined(MNTTAB_OPT_NOSUB) */

#if defined(MNT2_GEN_OPT_NOSUID) && defined(MNTTAB_OPT_NOSUID)
 {MNTTAB_OPT_NOSUID, MNT2_GEN_OPT_NOSUID},
#endif /* defined(MNT2_GEN_OPT_NOSUID) && defined(MNTTAB_OPT_NOSUID) */

#if defined(MNT2_GEN_OPT_SYNC) && defined(MNTTAB_OPT_SYNC)
 {MNTTAB_OPT_SYNC, MNT2_GEN_OPT_SYNC},
#endif /* defined(MNT2_GEN_OPT_SYNC) && defined(MNTTAB_OPT_SYNC) */

#if defined(MNT2_GEN_OPT_OVERLAY) && defined(MNTTAB_OPT_OVERLAY)
 {MNTTAB_OPT_OVERLAY, MNT2_GEN_OPT_OVERLAY},
#endif /* defined(MNT2_GEN_OPT_OVERLAY) && defined(MNTTAB_OPT_OVERLAY) */

#if defined(MNT2_GEN_OPT_LOG) && defined(MNTTAB_OPT_LOG)
 {MNTTAB_OPT_LOG, MNT2_GEN_OPT_LOG},
#endif /* defined(MNT2_GEN_OPT_LOG) && defined(MNTTAB_OPT_LOG) */

#if defined(MNT2_GEN_OPT_NOATIME) && defined(MNTTAB_OPT_NOATIME)
 {MNTTAB_OPT_NOATIME, MNT2_GEN_OPT_NOATIME},
#endif /* defined(MNT2_GEN_OPT_NOATIME) && defined(MNTTAB_OPT_NOATIME) */

#if defined(MNT2_GEN_OPT_NODEVMTIME) && defined(MNTTAB_OPT_NODEVMTIME)
 {MNTTAB_OPT_NODEVMTIME, MNT2_GEN_OPT_NODEVMTIME},
#endif /* defined(MNT2_GEN_OPT_NODEVMTIME) && defined(MNTTAB_OPT_NODEVMTIME) */

#if defined(MNT2_GEN_OPT_SOFTDEP) && defined(MNTTAB_OPT_SOFTDEP)
 {MNTTAB_OPT_SOFTDEP, MNT2_GEN_OPT_SOFTDEP},
#endif /* defined(MNT2_GEN_OPT_SOFTDEP) && defined(MNTTAB_OPT_SOFTDEP) */

#if defined(MNT2_GEN_OPT_SYMPERM) && defined(MNTTAB_OPT_SYMPERM)
 {MNTTAB_OPT_SYMPERM, MNT2_GEN_OPT_SYMPERM},
#endif /* defined(MNT2_GEN_OPT_SYMPERM) && defined(MNTTAB_OPT_SYMPERM) */

#if defined(MNT2_GEN_OPT_UNION) && defined(MNTTAB_OPT_UNION)
 {MNTTAB_OPT_UNION, MNT2_GEN_OPT_UNION},
#endif /* defined(MNT2_GEN_OPT_UNION) && defined(MNTTAB_OPT_UNION) */

 /*
  * Do not define MNT2_NFS_OPT_* entries here!  This is for generic
  * mount(2) options only, not for NFS mount options.  If you need to put
  * something here, it's probably not the right place: see
  * include/am_compat.h.
  */

 {0, 0}
};


/* compute generic mount flags */
int
compute_mount_flags(mntent_t *mntp)
{
 struct opt_tab *opt;
 int flags = 0;

#ifdef MNT2_GEN_OPT_NEWTYPE
 flags |= MNT2_GEN_OPT_NEWTYPE;
#endif /* MNT2_GEN_OPT_NEWTYPE */
#ifdef MNT2_GEN_OPT_AUTOMOUNTED
 flags |= MNT2_GEN_OPT_AUTOMOUNTED;
#endif /* not MNT2_GEN_OPT_AUTOMOUNTED */

 /*
  * Crack basic mount options
  */
 for (opt = mnt_flags; opt->opt; opt++) {
   flags |= amu_hasmntopt(mntp, opt->opt) ? opt->flag : 0;
 }

 return flags;
}


/* compute generic mount flags for automounter mounts */
int
compute_automounter_mount_flags(mntent_t *mntp)
{
 int flags = 0;

#ifdef MNT2_GEN_OPT_IGNORE
 flags |= MNT2_GEN_OPT_IGNORE;
#endif /* not MNT2_GEN_OPT_IGNORE */
#ifdef MNT2_GEN_OPT_AUTOMNTFS
 flags |= MNT2_GEN_OPT_AUTOMNTFS;
#endif /* not MNT2_GEN_OPT_AUTOMNTFS */

 return flags;
}


#if defined(MOUNT_TABLE_ON_FILE) && defined(MNTTAB_OPT_VERS)
/*
* add the extra vers={2,3} field to the mount table,
* unless already specified by user
*/
static void
addvers(char *zopts, size_t l, mntent_t *mnt, u_long have_vers,
 u_long want_vers)
{
 if (have_vers == want_vers &&
     hasmntval(mnt, MNTTAB_OPT_VERS) != want_vers) {
   char optsbuf[48];
   xsnprintf(optsbuf, sizeof(optsbuf),
             "%s=%d", MNTTAB_OPT_VERS, want_vers);
   append_opts(zopts, l, optsbuf);
 }
}
#endif /* MOUNT_TABLE_ON_FILE && MNTTAB_OPT_VERS */

int
mount_fs(mntent_t *mnt, int flags, caddr_t mnt_data, int retry, MTYPE_TYPE type, u_long nfs_version, const char *nfs_proto, const char *mnttabname, int on_autofs)
{
 int error = 0;
#ifdef MOUNT_TABLE_ON_FILE
 char *zopts = NULL, *xopts = NULL;
 size_t l;
#endif /* MOUNT_TABLE_ON_FILE */
 char *mnt_dir = NULL;

#ifdef NEED_AUTOFS_SPACE_HACK
 char *old_mnt_dir = NULL;
 /* perform space hack */
 if (on_autofs) {
   old_mnt_dir = mnt->mnt_dir;
   mnt->mnt_dir = mnt_dir = autofs_strdup_space_hack(old_mnt_dir);
 } else
#endif /* NEED_AUTOFS_SPACE_HACK */
   mnt_dir = xstrdup(mnt->mnt_dir);

 dlog("'%s' fstype " MTYPE_PRINTF_TYPE " (%s) flags %#x (%s)",
      mnt_dir, type, mnt->mnt_type, flags, mnt->mnt_opts);

again:
 error = MOUNT_TRAP(type, mnt, flags, mnt_data);

 if (error < 0) {
   plog(XLOG_ERROR, "'%s': mount: %m", mnt_dir);
   /*
    * The following code handles conditions which shouldn't
    * occur.  They are possible either because amd screws up
    * in preparing for the mount, or because some human
    * messed with the mount point.  Both have been known to
    * happen. -- stolcke 2/22/95
    */
   if (errno == EBUSY) {
     /*
      * Also, sometimes unmount isn't called, e.g., because
      * our mountlist is garbled.  This leaves old mount
      * points around which need to be removed before we
      * can mount something new in their place.
      */
     errno = umount_fs(mnt_dir, mnttabname, on_autofs);
     if (errno != 0)
       plog(XLOG_ERROR, "'%s': umount: %m", mnt_dir);
     else {
       plog(XLOG_WARNING, "extra umount required for '%s'", mnt_dir);
       error = MOUNT_TRAP(type, mnt, flags, mnt_data);
     }
   }
 }

 if (error < 0 && --retry > 0) {
   sleep(1);
   goto again;
 }

#ifdef NEED_AUTOFS_SPACE_HACK
 /* Undo space hack */
 if (on_autofs)
   mnt->mnt_dir = old_mnt_dir;
#endif /* NEED_AUTOFS_SPACE_HACK */

 if (error < 0) {
   error = errno;
   goto out;
 }

#ifdef MOUNT_TABLE_ON_FILE
 /*
  * Allocate memory for options:
  *        dev=..., vers={2,3}, proto={tcp,udp}
  */
 l = strlen(mnt->mnt_opts) + 48;
 zopts = (char *) xmalloc(l);

 /* copy standard options */
 xopts = mnt->mnt_opts;

 xstrlcpy(zopts, xopts, l);

# ifdef MNTTAB_OPT_DEV
 {
   /* add the extra dev= field to the mount table */
   struct stat stb;
   if (lstat(mnt_dir, &stb) == 0) {
     char optsbuf[48];
     if (sizeof(stb.st_dev) == 2) /* e.g. SunOS 4.1 */
       xsnprintf(optsbuf, sizeof(optsbuf), "%s=%04lx",
                 MNTTAB_OPT_DEV, (u_long) stb.st_dev & 0xffff);
     else                      /* e.g. System Vr4 */
       xsnprintf(optsbuf, sizeof(optsbuf), "%s=%08lx",
                 MNTTAB_OPT_DEV, (u_long) stb.st_dev);
     append_opts(zopts, l, optsbuf);
   }
 }
# endif /* MNTTAB_OPT_DEV */

# if defined(HAVE_FS_NFS4) && defined(MNTTAB_OPT_VERS)
 addvers(zopts, l, mnt, nfs_version, NFS_VERSION4);
# endif /* defined(HAVE_FS_NFS4) && defined(MNTTAB_OPT_VERS) */
# if defined(HAVE_FS_NFS3) && defined(MNTTAB_OPT_VERS)
 addvers(zopts, l, mnt, nfs_version, NFS_VERSION3);
# endif /* defined(HAVE_FS_NFS3) && defined(MNTTAB_OPT_VERS) */
# ifdef MNTTAB_OPT_VERS
 addvers(zopts, l, mnt, nfs_version, NFS_VERSION2);
# endif /* MNTTAB_OPT_VERS */

# ifdef MNTTAB_OPT_PROTO
 /*
  * add the extra proto={tcp,udp} field to the mount table,
  * unless already specified by user.
  */
 if (nfs_proto && !amu_hasmntopt(mnt, MNTTAB_OPT_PROTO)) {
   char optsbuf[48];
   xsnprintf(optsbuf, sizeof(optsbuf), "%s=%s", MNTTAB_OPT_PROTO, nfs_proto);
   append_opts(zopts, l, optsbuf);
 }
# endif /* MNTTAB_OPT_PROTO */

 /* finally, store the options into the mount table structure */
 mnt->mnt_opts = zopts;

 /*
  * Additional fields in mntent_t
  * are fixed up here
  */
# ifdef HAVE_MNTENT_T_MNT_CNODE
 mnt->mnt_cnode = 0;
# endif /* HAVE_MNTENT_T_MNT_CNODE */

# ifdef HAVE_MNTENT_T_MNT_RO
 mnt->mnt_ro = (amu_hasmntopt(mnt, MNTTAB_OPT_RO) != NULL);
# endif /* HAVE_MNTENT_T_MNT_RO */

# ifdef HAVE_MNTENT_T_MNT_TIME
#  ifdef HAVE_MNTENT_T_MNT_TIME_STRING
 {                             /* allocate enough space for a long */
   size_t l = 13 * sizeof(char);
   char *str = (char *) xmalloc(l);
   xsnprintf(str, l, "%ld", time((time_t *) NULL));
   mnt->mnt_time = str;
 }
#  else /* not HAVE_MNTENT_T_MNT_TIME_STRING */
 mnt->mnt_time = time((time_t *) NULL);
#  endif /* not HAVE_MNTENT_T_MNT_TIME_STRING */
# endif /* HAVE_MNTENT_T_MNT_TIME */

 write_mntent(mnt, mnttabname);

# ifdef MNTTAB_OPT_DEV
 if (xopts) {
   XFREE(mnt->mnt_opts);
   mnt->mnt_opts = xopts;
 }
# endif /* MNTTAB_OPT_DEV */
#endif /* MOUNT_TABLE_ON_FILE */

out:
 XFREE(mnt_dir);
 return error;
}


/*
* Compute all NFS attribute cache related flags separately.  Note that this
* function now computes attribute-cache flags for both Amd's automount
* points (NFS) as well as any normal NFS mount that Amd performs.  Edit
* with caution.
*/
static void
compute_nfs_attrcache_flags(struct nfs_common_args *nap, mntent_t *mntp)
{
 int acval = 0;
 int err_acval = 1;            /* 1 means we found no 'actimeo' value */
#if defined(HAVE_NFS_ARGS_T_ACREGMIN) || defined(HAVE_NFS_ARGS_T_ACREGMAX) || defined(HAVE_NFS_ARGS_T_ACDIRMIN) || defined(HAVE_NFS_ARGS_T_ACDIRMAX)
 int err_acrdmm;               /* for ac{reg,dir}{min,max} */
#endif /* HAVE_NFS_ARGS_T_AC{REG,DIR}{MIN,MAX} */

 /************************************************************************/
 /***  ATTRIBUTE CACHES                                                ***/
 /************************************************************************/
 /*
  * acval is set to 0 at the top of the function.  If actimeo mount option
  * exists and defined in mntopts, then its acval is set to it.
  * If the value is non-zero, then we set all attribute cache fields to it.
  * If acval is zero, it means it was never defined in mntopts or the
  * actimeo mount option does not exist, in which case we check for
  * individual mount options per attribute cache.
  * Regardless of the value of acval, mount flags are set based directly
  * on the values of the attribute caches.
  */
#ifdef MNTTAB_OPT_ACTIMEO
 err_acval = hasmntvalerr(mntp, MNTTAB_OPT_ACTIMEO, &acval);   /* attr cache timeout (sec) */
#endif /* MNTTAB_OPT_ACTIMEO */

 /*** acregmin ***/
#ifdef HAVE_NFS_ARGS_T_ACREGMIN
 err_acrdmm = 1;               /* 1 means we found no acregmin value */
 if (!err_acval) {
   nap->acregmin = acval;      /* min ac timeout for reg files (sec) */
 } else {
# ifdef MNTTAB_OPT_ACREGMIN
   int tmp;
   err_acrdmm = hasmntvalerr(mntp, MNTTAB_OPT_ACREGMIN, &tmp);
   nap->acregmin = tmp;
# else /* not MNTTAB_OPT_ACREGMIN */
   nap->acregmin = 0;
# endif /* not MNTTAB_OPT_ACREGMIN */
 }
 /* set this flag iff we changed acregmin (possibly to zero) */
# ifdef MNT2_NFS_OPT_ACREGMIN
 if (!err_acval || !err_acrdmm)
   nap->flags |= MNT2_NFS_OPT_ACREGMIN;
# endif /* MNT2_NFS_OPT_ACREGMIN */
#endif /* HAVE_NFS_ARGS_T_ACREGMIN */

 /*** acregmax ***/
#ifdef HAVE_NFS_ARGS_T_ACREGMAX
 err_acrdmm = 1;               /* 1 means we found no acregmax value */
 if (!err_acval) {
   nap->acregmax = acval;      /* max ac timeout for reg files (sec) */
 } else {
# ifdef MNTTAB_OPT_ACREGMAX
   int tmp;
   err_acrdmm = hasmntvalerr(mntp, MNTTAB_OPT_ACREGMAX, &tmp);
   nap->acregmax = tmp;
# else /* not MNTTAB_OPT_ACREGMAX */
   nap->acregmax = 0;
# endif /* not MNTTAB_OPT_ACREGMAX */
 }
 /* set this flag iff we changed acregmax (possibly to zero) */
# ifdef MNT2_NFS_OPT_ACREGMAX
 if (!err_acval || !err_acrdmm)
   nap->flags |= MNT2_NFS_OPT_ACREGMAX;
# endif /* MNT2_NFS_OPT_ACREGMAX */
#endif /* HAVE_NFS_ARGS_T_ACREGMAX */

 /*** acdirmin ***/
#ifdef HAVE_NFS_ARGS_T_ACDIRMIN
 err_acrdmm = 1;               /* 1 means we found no acdirmin value */
 if (!err_acval) {
   nap->acdirmin = acval;      /* min ac timeout for dirs (sec) */
 } else {
# ifdef MNTTAB_OPT_ACDIRMIN
   int tmp;
   err_acrdmm = hasmntvalerr(mntp, MNTTAB_OPT_ACDIRMIN, &tmp);
   nap->acdirmin = tmp;
# else /* not MNTTAB_OPT_ACDIRMIN */
   nap->acdirmin = 0;
# endif /* not MNTTAB_OPT_ACDIRMIN */
 }
 /* set this flag iff we changed acdirmin (possibly to zero) */
# ifdef MNT2_NFS_OPT_ACDIRMIN
 if (!err_acval || !err_acrdmm)
   nap->flags |= MNT2_NFS_OPT_ACDIRMIN;
# endif /* MNT2_NFS_OPT_ACDIRMIN */
#endif /* HAVE_NFS_ARGS_T_ACDIRMIN */

 /*** acdirmax ***/
#ifdef HAVE_NFS_ARGS_T_ACDIRMAX
 err_acrdmm = 1;               /* 1 means we found no acdirmax value */
 if (!err_acval) {
   nap->acdirmax = acval;      /* max ac timeout for dirs (sec) */
 } else {
# ifdef MNTTAB_OPT_ACDIRMAX
   int tmp;
   err_acrdmm = hasmntvalerr(mntp, MNTTAB_OPT_ACDIRMAX, &tmp);
   nap->acdirmax = tmp;
# else /* not MNTTAB_OPT_ACDIRMAX */
   nap->acdirmax = 0;
# endif /* not MNTTAB_OPT_ACDIRMAX */
 }
 /* set this flag iff we changed acdirmax (possibly to zero) */
# ifdef MNT2_NFS_OPT_ACDIRMAX
 if (!err_acval || !err_acrdmm)
   nap->flags |= MNT2_NFS_OPT_ACDIRMAX;
# endif /* MNT2_NFS_OPT_ACDIRMAX */
#endif /* HAVE_NFS_ARGS_T_ACDIRMAX */


 /* don't cache attributes */
#if defined(MNTTAB_OPT_NOAC) && defined(MNT2_NFS_OPT_NOAC)
 if (amu_hasmntopt(mntp, MNTTAB_OPT_NOAC) != NULL)
   nap->flags |= MNT2_NFS_OPT_NOAC;
#endif /* defined(MNTTAB_OPT_NOAC) && defined(MNT2_NFS_OPT_NOAC) */
 (void)err_acval;
}



static void
compute_nfs_common_args(struct nfs_common_args *nap, mntent_t *mntp,
   const char *nfs_proto, u_long nfs_version)
{
#ifdef MNT2_NFS_OPT_TCP
 if (nfs_proto && STREQ(nfs_proto, "tcp"))
   nap->flags |= MNT2_NFS_OPT_TCP;
#endif /* MNT2_NFS_OPT_TCP */

#ifdef MNT2_NFS_OPT_NOCONN
 /* check if user specified to use unconnected or connected sockets */
 if (amu_hasmntopt(mntp, MNTTAB_OPT_NOCONN) != NULL)
   nap->flags |= MNT2_NFS_OPT_NOCONN;
 else if (amu_hasmntopt(mntp, MNTTAB_OPT_CONN) != NULL)
   nap->flags &= ~MNT2_NFS_OPT_NOCONN;
 else {
   /*
    * Some OSs want you to set noconn always.  Some want you to always turn
    * it off.  Others want you to turn it on/off only if NFS V.3 is used.
    * And all of that changes from revision to another.  This is
    * particularly true of OpenBSD, NetBSD, and FreeBSD.  So, rather than
    * attempt to auto-detect this, I'm forced to "fix" it in the individual
    * conf/nfs_prot/nfs_prot_*.h files.
    */
# ifdef USE_UNCONNECTED_NFS_SOCKETS
   if (!(nap->flags & MNT2_NFS_OPT_NOCONN)) {
     nap->flags |= MNT2_NFS_OPT_NOCONN;
     plog(XLOG_WARNING, "noconn option not specified, and was just turned ON (OS override)! (May cause NFS hangs on some systems...)");
   }
# endif /* USE_UNCONNECTED_NFS_SOCKETS */
# ifdef USE_CONNECTED_NFS_SOCKETS
   if (nap->flags & MNT2_NFS_OPT_NOCONN) {
     nap->flags &= ~MNT2_NFS_OPT_NOCONN;
     plog(XLOG_WARNING, "noconn option specified, and was just turned OFF (OS override)! (May cause NFS hangs on some systems...)");
   }
# endif /* USE_CONNECTED_NFS_SOCKETS */
 }
#endif /* MNT2_NFS_OPT_NOCONN */

#ifdef MNT2_NFS_OPT_RESVPORT
# ifdef MNTTAB_OPT_RESVPORT
 if (amu_hasmntopt(mntp, MNTTAB_OPT_RESVPORT) != NULL)
   nap->flags |= MNT2_NFS_OPT_RESVPORT;
# else /* not MNTTAB_OPT_RESVPORT */
 nap->flags |= MNT2_NFS_OPT_RESVPORT;
# endif /* not MNTTAB_OPT_RESVPORT */
#endif /* MNT2_NFS_OPT_RESVPORT */

 nap->rsize = hasmntval(mntp, MNTTAB_OPT_RSIZE);
#ifdef MNT2_NFS_OPT_RSIZE
 if (nap->rsize)
   nap->flags |= MNT2_NFS_OPT_RSIZE;
#endif /* MNT2_NFS_OPT_RSIZE */
 if (nfs_version == NFS_VERSION && nap->rsize > 8192)
   nap->rsize = 8192;

 nap->wsize = hasmntval(mntp, MNTTAB_OPT_WSIZE);
#ifdef MNT2_NFS_OPT_WSIZE
 if (nap->wsize)
   nap->flags |= MNT2_NFS_OPT_WSIZE;
#endif /* MNT2_NFS_OPT_WSIZE */
 if (nfs_version == NFS_VERSION && nap->wsize > 8192)
   nap->wsize = 8192;

 nap->timeo = hasmntval(mntp, MNTTAB_OPT_TIMEO);
#ifdef MNT2_NFS_OPT_TIMEO
 if (nap->timeo)
   nap->flags |= MNT2_NFS_OPT_TIMEO;
#endif /* MNT2_NFS_OPT_TIMEO */

 nap->retrans = hasmntval(mntp, MNTTAB_OPT_RETRANS);
#ifdef MNT2_NFS_OPT_RETRANS
 if (nap->retrans)
   nap->flags |= MNT2_NFS_OPT_RETRANS;
#endif /* MNT2_NFS_OPT_RETRANS */

#ifdef MNT2_NFS_OPT_SOFT
 if (amu_hasmntopt(mntp, MNTTAB_OPT_SOFT) != NULL)
   nap->flags |= MNT2_NFS_OPT_SOFT;
#endif /* MNT2_NFS_OPT_SOFT */

#ifdef MNT2_NFS_OPT_SPONGY
 if (amu_hasmntopt(mntp, MNTTAB_OPT_SPONGY) != NULL) {
   nap->flags |= MNT2_NFS_OPT_SPONGY;
   if (*flags & MNT2_NFS_OPT_SOFT) {
     plog(XLOG_USER, "Mount opts soft and spongy are incompatible - soft ignored");
     nap->flags &= ~MNT2_NFS_OPT_SOFT;
   }
 }
#endif /* MNT2_NFS_OPT_SPONGY */

#if defined(MNT2_GEN_OPT_RONLY) && defined(MNT2_NFS_OPT_RONLY)
 /* Ultrix has separate generic and NFS ro flags */
 if (genflags & MNT2_GEN_OPT_RONLY)
   nap->flags |= MNT2_NFS_OPT_RONLY;
#endif /* defined(MNT2_GEN_OPT_RONLY) && defined(MNT2_NFS_OPT_RONLY) */

#ifdef MNTTAB_OPT_INTR
 if (amu_hasmntopt(mntp, MNTTAB_OPT_INTR) != NULL)
   /*
    * Either turn on the "allow interrupts" option, or
    * turn off the "disallow interrupts" option"
    */
# ifdef MNT2_NFS_OPT_INTR
   nap->flags |= MNT2_NFS_OPT_INTR;
# endif /* MNT2_NFS_OPT_INTR */
# ifdef MNT2_NFS_OPT_NOINTR
   nap->flags &= ~MNT2_NFS_OPT_NOINTR;
# endif /* MNT2_NFS_OPT_NOINTR */
# ifdef MNT2_NFS_OPT_INT
   nap->flags |= MNT2_NFS_OPT_INT;
# endif /* MNT2_NFS_OPT_INT */
# ifdef MNT2_NFS_OPT_NOINT
   nap->flags &= ~MNT2_NFS_OPT_NOINT;
# endif /* MNT2_NFS_OPT_NOINT */
#endif /* MNTTAB_OPT_INTR */

#ifdef MNT2_NFS_OPT_NOACL
 if (amu_hasmntopt(mntp, MNTTAB_OPT_NOACL) != NULL)
   nap->flags |= MNT2_NFS_OPT_NOACL;
#endif /* MNT2_NFS_OPT_NOACL */

#ifdef MNTTAB_OPT_NODEVS
 if (amu_hasmntopt(mntp, MNTTAB_OPT_NODEVS) != NULL)
   nap->flags |= MNT2_NFS_OPT_NODEVS;
#endif /* MNTTAB_OPT_NODEVS */

#ifdef MNTTAB_OPT_COMPRESS
 if (amu_hasmntopt(mntp, MNTTAB_OPT_COMPRESS) != NULL)
   nap->flags |= MNT2_NFS_OPT_COMPRESS;
#endif /* MNTTAB_OPT_COMPRESS */

#ifdef MNTTAB_OPT_PRIVATE       /* mount private, single-client tree */
 if (amu_hasmntopt(mntp, MNTTAB_OPT_PRIVATE) != NULL)
   nap->flags |= MNT2_NFS_OPT_PRIVATE;
#endif /* MNTTAB_OPT_PRIVATE */


#if defined(MNT2_NFS_OPT_NOCTO) && defined(MNTTAB_OPT_NOCTO)
 if (amu_hasmntopt(mntp, MNTTAB_OPT_NOCTO) != NULL)
   nap->flags |= MNT2_NFS_OPT_NOCTO;
#endif /* defined(MNT2_NFS_OPT_NOCTO) && defined(MNTTAB_OPT_NOCTO) */

#if defined(MNT2_NFS_OPT_PROPLIST) && defined(MNTTAB_OPT_PROPLIST)
 if (amu_hasmntopt(mntp, MNTTAB_OPT_PROPLIST) != NULL)
   nap->flags |= MNT2_NFS_OPT_PROPLIST;
#endif /* defined(MNT2_NFS_OPT_PROPLIST) && defined(MNTTAB_OPT_PROPLIST) */

#if defined(MNT2_NFS_OPT_NONLM) && defined(MNTTAB_OPT_NOLOCK)
 if (amu_hasmntopt(mntp, MNTTAB_OPT_NOLOCK) != NULL)
   nap->flags |= MNT2_NFS_OPT_NONLM;
#endif /* defined(MNT2_NFS_OPT_NONLM) && defined(MNTTAB_OPT_NOLOCK) */

#if defined(MNT2_NFS_OPT_XLATECOOKIE) && defined(MNTTAB_OPT_XLATECOOKIE)
 if (amu_hasmntopt(mntp, MNTTAB_OPT_XLATECOOKIE) != NULL)
   nap->flags |= MNT2_NFS_OPT_XLATECOOKIE;
#endif /* defined(MNT2_NFS_OPT_XLATECOOKIE) && defined(MNTTAB_OPT_XLATECOOKIE) */
}

#ifdef DEBUG
static void
print_nfs_common_args(const struct nfs_common_args *a)
{
 plog(XLOG_DEBUG, "NA->flags = 0x%lx", a->flags);

 plog(XLOG_DEBUG, "NA->rsize = %lu", a->rsize);
 plog(XLOG_DEBUG, "NA->wsize = %lu", a->wsize);
 plog(XLOG_DEBUG, "NA->timeo = %lu", a->timeo);
 plog(XLOG_DEBUG, "NA->retrans = %lu", a->retrans);

#ifdef HAVE_NFS_ARGS_T_ACREGMIN
 plog(XLOG_DEBUG, "NA->acregmin = %lu", a->acregmin);
 plog(XLOG_DEBUG, "NA->acregmax = %lu", a->acregmax);
 plog(XLOG_DEBUG, "NA->acdirmin = %lu", a->acdirmin);
 plog(XLOG_DEBUG, "NA->acdirmax = %lu", a->acdirmax);
#endif /* HAVE_NFS_ARGS_T_ACREGMIN */
}
#endif

static void
discard_nfs23_args(nfs_args_t *nap)
{
#ifdef HAVE_TRANSPORT_TYPE_TLI
 free_knetconfig(nap->knconf);
 if (nap->addr)
   XFREE(nap->addr);   /* allocated in compute_nfs_args() */
#endif /* HAVE_TRANSPORT_TYPE_TLI */
}

#ifdef DEBUG
/* get string version (in hex) of identifier */
static char *
get_hex_string(u_int len, const char *fhdata)
{
 u_int i;
 static u_int xlen;
 static char *buf;
 static u_short *arr;
 char str[16];

 if (!fhdata || len == 0 || len > 10240)
   return NULL;
 i = len * 4 + 1;
 if (xlen < i) {
   buf = xrealloc(buf, i);
   arr = xrealloc(arr, len * sizeof(*arr));
   xlen = i;
 }

 buf[0] = '\0';
 memset(arr, 0, len * sizeof(*arr));
 memcpy(arr, fhdata, len);
 len /= sizeof(*arr);
 for (i = 0; i < len; i++) {
   xsnprintf(str, sizeof(str), "%04x", ntohs(arr[i]));
   xstrlcat(buf, str, xlen);
 }
 return buf;
}

static void
print_nfs_sockaddr_in(const char *tag, const struct sockaddr_in *sap)
{
 char name[64];
 plog(XLOG_DEBUG, "NA->%s.sin_family = %d", tag, sap->sin_family);
 plog(XLOG_DEBUG, "NA->%s.sin_port = %d", tag, ntohs(sap->sin_port));
 if (inet_ntop(AF_INET, &sap->sin_addr, name, sizeof(name)) == NULL)
   return;
 plog(XLOG_DEBUG, "NA->%s.sin_addr = \"%s\"", tag, name);
}

/*
* print a subset of fields from "struct nfs_args" that are otherwise
* not being provided anywhere else.
*/
static void
print_nfs23_args(const nfs_args_t *nap, u_long nfs_version)
{
 int fhlen = 32;       /* default: NFS V.2 file handle length is 32 */
#ifdef HAVE_TRANSPORT_TYPE_TLI
 struct netbuf *nbp;
 struct knetconfig *kncp;
#else /* not HAVE_TRANSPORT_TYPE_TLI */
 struct sockaddr_in *sap;
#endif /* not HAVE_TRANSPORT_TYPE_TLI */
 struct nfs_common_args a;

 if (!nap) {
   plog(XLOG_DEBUG, "NULL nfs_args!");
   return;
 }

 /* override default file handle size */
#ifdef FHSIZE
  fhlen = FHSIZE;
#endif /* FHSIZE */
#ifdef NFS_FHSIZE
  fhlen = NFS_FHSIZE;
#endif /* NFS_FHSIZE */

#ifdef HAVE_TRANSPORT_TYPE_TLI
 nbp = nap->addr;
 plog(XLOG_DEBUG, "NA->addr {netbuf} (maxlen=%d, len=%d) = \"%s\"",
      nbp->maxlen, nbp->len,
      get_hex_string(nbp->len, nbp->buf));
 nbp = nap->syncaddr;
 plog(XLOG_DEBUG, "NA->syncaddr {netbuf} %p", nbp);
 kncp = nap->knconf;
 plog(XLOG_DEBUG, "NA->knconf->semantics %lu", (u_long) kncp->knc_semantics);
 plog(XLOG_DEBUG, "NA->knconf->protofmly \"%s\"", kncp->knc_protofmly);
 plog(XLOG_DEBUG, "NA->knconf->proto \"%s\"", kncp->knc_proto);
 plog(XLOG_DEBUG, "NA->knconf->rdev %lu", (u_long) kncp->knc_rdev);
 /* don't print knconf->unused field */
#else /* not HAVE_TRANSPORT_TYPE_TLI */
# ifdef NFS_ARGS_T_ADDR_IS_POINTER
   sap = (struct sockaddr_in *) nap->addr;
# else /* not NFS_ARGS_T_ADDR_IS_POINTER */
   sap = (struct sockaddr_in *) &nap->addr;
# endif /* not NFS_ARGS_T_ADDR_IS_POINTER */
#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
 /* as per POSIX, sin_len need not be set (used internally by kernel) */
 plog(XLOG_DEBUG, "NA->addr.sin_len = %d", sap->sin_len);
#endif /* HAVE_STRUCT_SOCKADDR_SA_LEN */
 print_nfs_sockaddr_in("addr", sap);
#endif /* not HAVE_TRANSPORT_TYPE_TLI */
#ifdef HAVE_NFS_ARGS_T_ADDRLEN
 plog(XLOG_DEBUG, "NA->addrlen = %d", nap->addrlen);
#endif /* ifdef HAVE_NFS_ARGS_T_ADDRLEN */

 plog(XLOG_DEBUG, "NA->hostname = \"%s\"", nap->hostname ? nap->hostname : "null");
#ifdef HAVE_NFS_ARGS_T_NAMLEN
 plog(XLOG_DEBUG, "NA->namlen = %d", nap->namlen);
#endif /* HAVE_NFS_ARGS_T_NAMLEN */

#ifdef MNT2_NFS_OPT_FSNAME
 plog(XLOG_DEBUG, "NA->fsname = \"%s\"", nap->fsname ? nap->fsname : "null");
#endif /* MNT2_NFS_OPT_FSNAME */

#ifdef HAVE_NFS_ARGS_T_FHSIZE
 plog(XLOG_DEBUG, "NA->fhsize = %d", nap->fhsize);
 fhlen = nap->fhsize;
#endif /* HAVE_NFS_ARGS_T_FHSIZE */
#ifdef HAVE_NFS_ARGS_T_FH_LEN
 plog(XLOG_DEBUG, "NA->fh_len = %d", nap->fh_len);
 fhlen = nap->fh_len;
#endif /* HAVE_NFS_ARGS_T_FH_LEN */

 /*
  * XXX: need to figure out how to correctly print file handles,
  * since some times they are pointers, and sometimes the real structure
  * is stored in nfs_args.  Even if it is a pointer, it can be the actual
  * char[] array, or a structure containing multiple fields.
  */
 plog(XLOG_DEBUG, "NA->filehandle = \"%s\"",
      get_hex_string(fhlen, (const char *) &nap->NFS_FH_FIELD));

#ifdef HAVE_NFS_ARGS_T_SOTYPE
 plog(XLOG_DEBUG, "NA->sotype = %d", nap->sotype);
#endif /* HAVE_NFS_ARGS_T_SOTYPE */
#ifdef HAVE_NFS_ARGS_T_PROTO
 plog(XLOG_DEBUG, "NA->proto = %d", (int) nap->proto);
#endif /* HAVE_NFS_ARGS_T_PROTO */
#ifdef HAVE_NFS_ARGS_T_VERSION
 plog(XLOG_DEBUG, "NA->version = %d", nap->version);
#endif /* HAVE_NFS_ARGS_T_VERSION */

 put_nfs_common_args(nap, a);
 print_nfs_common_args(&a);

#ifdef HAVE_NFS_ARGS_T_BSIZE
 plog(XLOG_DEBUG, "NA->bsize = %d", nap->bsize);
#endif /* HAVE_NFS_ARGS_T_BSIZE */

#ifdef MNTTAB_OPT_SYMTTL
 plog(XLOG_DEBUG, "NA->symttl = %d", nap->symttl);
#endif /* MNTTAB_OPT_SYMTTL */
#ifdef MNTTAB_OPT_PG_THRESH
 plog(XLOG_DEBUG, "NA->pg_thresh = %d", nap->pg_thresh);
#endif /* MNTTAB_OPT_PG_THRESH */

#ifdef MNT2_NFS_OPT_BIODS
 plog(XLOG_DEBUG, "NA->biods = %d", nap->biods);
#endif /* MNT2_NFS_OPT_BIODS */

}
#endif /* DEBUG */

/*
* Fill in the many possible fields and flags of struct nfs_args.
*
* nap:         pre-allocated structure to fill in.
* mntp:        mount entry structure (includes options)
* genflags:    generic mount flags already determined
* nfsncp:      (TLI only) netconfig entry for this NFS mount
* ip_addr:     IP address of file server
* nfs_version: 2, 3, or 0 if unknown
* nfs_proto:   "udp", "tcp", or NULL.
* fhp:         file handle structure pointer
* host_name:   name of remote NFS host
* fs_name:     remote file system name to mount
*/
static void
compute_nfs23_args(nfs_args_t *nap,
                  mntent_t *mntp,
                  int genflags,
                  struct netconfig *nfsncp,
                  struct sockaddr_in *ip_addr,
                  u_long nfs_version,
                  char *nfs_proto,
                  am_nfs_handle_t *fhp,
                  char *host_name,
                  char *fs_name)
{
 struct nfs_common_args a;
 /* initialize just in case */
 memset((voidp) nap, 0, sizeof(nfs_args_t));

 /* compute all of the NFS attribute-cache flags */
 memset(&a, 0, sizeof(a));
 compute_nfs_attrcache_flags(&a, mntp);
 compute_nfs_common_args(&a, mntp, nfs_proto, nfs_version);
 get_nfs_common_args(nap, a);

 /************************************************************************/
 /***  FILEHANDLE DATA AND LENGTH                                      ***/
 /************************************************************************/
#ifdef HAVE_FS_NFS3
 if (nfs_version == NFS_VERSION3) {
   if (fhp == NULL) {
     plog(XLOG_FATAL, "cannot pass NULL fh for NFSv%lu", nfs_version);
     going_down(1);
     return;
   }

# if defined(HAVE_NFS_ARGS_T_FHSIZE) || defined(HAVE_NFS_ARGS_T_FH_LEN)
   /*
    * Some systems (Irix/bsdi3) have a separate field in nfs_args for
    * the length of the file handle for NFS V3.  They insist that
    * the file handle set in nfs_args be plain bytes, and not
    * include the length field.
    */
   NFS_FH_DREF(nap->NFS_FH_FIELD, &fhp->v3.am_fh3_data);
# else /* not defined(HAVE_NFS_ARGS_T_FHSIZE) || defined(HAVE_NFS_ARGS_T_FH_LEN) */
   NFS_FH_DREF(nap->NFS_FH_FIELD, &fhp->v3);
# endif /* not defined(HAVE_NFS_ARGS_T_FHSIZE) || defined(HAVE_NFS_ARGS_T_FH_LEN) */
# ifdef MNT2_NFS_OPT_NFSV3
   nap->flags |= MNT2_NFS_OPT_NFSV3;
# endif /* MNT2_NFS_OPT_NFSV3 */
# ifdef MNT2_NFS_OPT_VER3
   nap->flags |= MNT2_NFS_OPT_VER3;
# endif /* MNT2_NFS_OPT_VER3 */
 } else
#endif /* HAVE_FS_NFS3 */
 {
   if (fhp == NULL) {
     plog(XLOG_FATAL, "cannot pass NULL fh for NFSv%lu", nfs_version);
     going_down(1);
     return;
   }
   NFS_FH_DREF(nap->NFS_FH_FIELD, &fhp->v2);
 }

#ifdef HAVE_NFS_ARGS_T_FHSIZE
# ifdef HAVE_FS_NFS3
 if (nfs_version == NFS_VERSION3)
   nap->fhsize = fhp->v3.am_fh3_length;
 else
# endif /* HAVE_FS_NFS3 */
   nap->fhsize = FHSIZE;
#endif /* HAVE_NFS_ARGS_T_FHSIZE */

 /* this is the version of the nfs_args structure, not of NFS! */
#ifdef HAVE_NFS_ARGS_T_FH_LEN
# ifdef HAVE_FS_NFS3
 if (nfs_version == NFS_VERSION3)
   nap->fh_len = fhp->v3.am_fh3_length;
 else
# endif /* HAVE_FS_NFS3 */
   nap->fh_len = FHSIZE;
#endif /* HAVE_NFS_ARGS_T_FH_LEN */

 /************************************************************************/
 /***  HOST NAME                                                       ***/
 /************************************************************************/
 /*
  * XXX: warning, using xstrlcpy in NFS_HN_DREF, which may corrupt a
  * struct nfs_args, or truncate our concocted "hostname:/path"
  * string prematurely.
  */
 NFS_HN_DREF(nap->hostname, host_name);
#ifdef MNT2_NFS_OPT_HOSTNAME
 nap->flags |= MNT2_NFS_OPT_HOSTNAME;
#endif /* MNT2_NFS_OPT_HOSTNAME */

 /************************************************************************/
 /***  IP ADDRESS OF REMOTE HOST                                       ***/
 /************************************************************************/
 if (ip_addr) {
#ifdef HAVE_TRANSPORT_TYPE_TLI
   nap->addr = ALLOC(struct netbuf); /* free()'ed at end of mount_nfs_fh() */
#endif /* HAVE_TRANSPORT_TYPE_TLI */
   NFS_SA_DREF(nap, ip_addr);
 }

 /************************************************************************/
 /***  NFS PROTOCOL (UDP, TCP) AND VERSION                             ***/
 /************************************************************************/
#ifdef HAVE_NFS_ARGS_T_SOTYPE
 /* bsdi3 uses this */
 if (nfs_proto) {
   if (STREQ(nfs_proto, "tcp"))
     nap->sotype = SOCK_STREAM;
   else if (STREQ(nfs_proto, "udp"))
     nap->sotype = SOCK_DGRAM;
 }
#endif /* HAVE_NFS_ARGS_T_SOTYPE */

#ifdef HAVE_NFS_ARGS_T_PROTO
 nap->proto = 0;               /* bsdi3 sets this field to zero  */
# ifdef IPPROTO_TCP
 if (nfs_proto) {
   if (STREQ(nfs_proto, "tcp"))        /* AIX 4.2.x needs this */
     nap->proto = IPPROTO_TCP;
   else if (STREQ(nfs_proto, "udp"))
     nap->proto = IPPROTO_UDP;
 }
# endif /* IPPROTO_TCP */
#endif /* HAVE_NFS_ARGS_T_SOTYPE */

#ifdef HAVE_NFS_ARGS_T_VERSION
# ifdef NFS_ARGSVERSION
 nap->version = NFS_ARGSVERSION; /* BSDI 3.0 and OpenBSD 2.2 */
# endif /* NFS_ARGSVERSION */
# ifdef DG_MOUNT_NFS_VERSION
 nap->version = DG_MOUNT_NFS_VERSION; /* dg-ux */
# endif /* DG_MOUNT_NFS_VERSION */
#endif /* HAVE_NFS_ARGS_VERSION */

 /************************************************************************/
 /***  OTHER NFS SOCKET RELATED OPTIONS AND FLAGS                      ***/
 /************************************************************************/

 /************************************************************************/
 /***  OTHER FLAGS AND OPTIONS                                         ***/
 /************************************************************************/

#ifdef MNT2_NFS_OPT_BIODS
 if ((nap->biods = hasmntval(mntp, MNTTAB_OPT_BIODS)))
   nap->flags |= MNT2_NFS_OPT_BIODS;
#endif /* MNT2_NFS_OPT_BIODS */

#ifdef MNTTAB_OPT_SYMTTL        /* symlink cache time-to-live */
 if ((nap->symttl = hasmntval(mntp, MNTTAB_OPT_SYMTTL)))
   nap->args.flags |= MNT2_NFS_OPT_SYMTTL;
#endif /* MNTTAB_OPT_SYMTTL */

#ifdef MNT2_NFS_OPT_PGTHRESH    /* paging threshold */
 if ((nap->pg_thresh = hasmntval(mntp, MNTTAB_OPT_PGTHRESH)))
   nap->args.flags |= MNT2_NFS_OPT_PGTHRESH;
#endif /* MNT2_NFS_OPT_PGTHRESH */

#if defined(MNT2_NFS_OPT_POSIX) && defined(MNTTAB_OPT_POSIX)
 if (amu_hasmntopt(mntp, MNTTAB_OPT_POSIX) != NULL) {
   nap->flags |= MNT2_NFS_OPT_POSIX;
# ifdef HAVE_NFS_ARGS_T_PATHCONF
   nap->pathconf = NULL;
# endif /* HAVE_NFS_ARGS_T_PATHCONF */
 }
#endif /* MNT2_NFS_OPT_POSIX && MNTTAB_OPT_POSIX */

#ifdef HAVE_TRANSPORT_TYPE_TLI
 /* set up syncaddr field */
 nap->syncaddr = (struct netbuf *) NULL;

 /* set up knconf field */
 if (get_knetconfig(&nap->knconf, nfsncp, nfs_proto) < 0) {
   plog(XLOG_FATAL, "cannot fill knetconfig structure for nfs_args");
   going_down(1);
   return;
 }
 /* update the flags field for knconf */
 nap->args.flags |= MNT2_NFS_OPT_KNCONF;
#endif /* HAVE_TRANSPORT_TYPE_TLI */

#ifdef MNT2_NFS_OPT_FSNAME
 nap->fsname = fs_name;
 nap->args.flags |= MNT2_NFS_OPT_FSNAME;
#endif /* MNT2_NFS_OPT_FSNAME */


#ifdef HAVE_NFS_ARGS_T_OPTSTR
 nap->optstr = mntp->mnt_opts;
#endif /* HAVE_NFS_ARGS_T_OPTSTR */

#if defined(MNT2_NFS_OPT_MAXGRPS) && defined(MNTTAB_OPT_MAXGROUPS)
 nap->maxgrouplist = hasmntval(mntp, MNTTAB_OPT_MAXGROUPS);
 if (nap->maxgrouplist != 0)
   nap->flags |= MNT2_NFS_OPT_MAXGRPS;
#endif /* defined(MNT2_NFS_OPT_MAXGRPS) && defined(MNTTAB_OPT_MAXGROUPS) */

 /************************************************************************/
 /***  FINAL ACTIONS                                                   ***/
 /************************************************************************/

#ifdef HAVE_NFS_ARGS_T_GFS_FLAGS
 /* Ultrix stores generic flags in nfs_args.gfs_flags. */
 nap->gfs_flags = genflags;
#endif /* HAVE_NFS_ARGS_T_FLAGS */

 return;                       /* end of compute_nfs_args() function */
}

#ifdef HAVE_FS_NFS4

#define RPC_AUTH_GSS_KRB5       390003
#define RPC_AUTH_GSS_KRB5I      390004
#define RPC_AUTH_GSS_KRB5P      390005
#define RPC_AUTH_GSS_LKEY       390006
#define RPC_AUTH_GSS_LKEYI      390007
#define RPC_AUTH_GSS_LKEYP      390008
#define RPC_AUTH_GSS_SPKM       390009
#define RPC_AUTH_GSS_SPKMI      390010
#define RPC_AUTH_GSS_SPKMP      390011

struct {
 const char *name;
 int num;
} flavours[] = {
 { "unix",     AUTH_UNIX },
 { "krb5",     RPC_AUTH_GSS_KRB5 },
 { "krb5i",    RPC_AUTH_GSS_KRB5I },
 { "krb5p",    RPC_AUTH_GSS_KRB5P },
 { "lkey",     RPC_AUTH_GSS_LKEY },
 { "lkeyi",    RPC_AUTH_GSS_LKEYI },
 { "lkeyp",    RPC_AUTH_GSS_LKEYP },
 { "spkm",     RPC_AUTH_GSS_SPKM },
 { "spkmi",    RPC_AUTH_GSS_SPKMI },
 { "spkmp",    RPC_AUTH_GSS_SPKMP },
};

static char *
set_nfs4_security(nfs4_args_t *nap, mntent_t *mntp)
{
 const char *o = hasmnteq(mntp, MNTTAB_OPT_SEC);
 char *q, *s, *ss;
 size_t l, i;

 if (o == NULL)
   o = "unix";

 for (l = 1, q = strchr(o, ','); q; q = strchr(q + 1, ','))
   l++;

 nap->auth_flavours = xmalloc(l * sizeof(*nap->auth_flavours));

 s = ss = xstrdup(o);
 for (;;) {
   q = strchr(s, ',');
   if (q)
       *q = '\0';

   for (l = 0, i = 0; i < sizeof(flavours) / sizeof(flavours[0]); i++)
     if (strcmp(flavours[i].name, s) == 0) {
       nap->auth_flavours[l++] = flavours[i].num;
       break;
     }

   if (i == sizeof(flavours) / sizeof(flavours[0]))
     plog(XLOG_ERROR, "Unknown NFSv4 security mechanism %s\n", s);

   if (q == NULL)
     break;

   *q = ':';
   s = ++q;
 }

 nap->auth_flavourlen = l;
 return ss;
}

static int
get_my_ipv4addr(struct nfs_string *ns)
{
 struct hostent *hp;
 char myname[MAXHOSTNAMELEN];

 if (gethostname(myname, sizeof(myname)) == -1)
   return -1;
 if ((hp = gethostbyname(myname)) == NULL)
   return -1;
 if (inet_ntop(AF_INET, hp->h_addr, myname, sizeof(myname)) == NULL)
   return -1;
 ns->len = strlen(myname);
 ns->data = xmalloc(ns->len + 1);
 memcpy(ns->data, myname, ns->len + 1);
 return 0;
}

static void
add_nfs4_mntopts(const nfs4_args_t *nap, mntent_t *mntp, char *sec)
{
 char *opts = mntp->mnt_opts;
 char buf[1024], addr[128];
 size_t len = strlen(mntp->mnt_opts);

 if (inet_ntop(AF_INET,
     &((const struct sockaddr_in *)nap->host_addr)->sin_addr,
     addr, sizeof(addr)) == NULL)
   return;

 xsnprintf(buf, sizeof(buf), ",clientaddr=%s,addr=%s", nap->client_addr.data,
           addr);

 len += strlen(buf) + 1;

 if (sec && strcmp(sec, "unix") != 0) {
   len += strlen(sec) + strlen(MNTTAB_OPT_SEC) + 2; /* 2 = ",=" */
 } else
   sec = NULL;

 opts = xrealloc(mntp->mnt_opts, len);
 xstrlcat(opts, buf, len);

 if (sec) {
   xstrlcat(opts, ",", len);
   xstrlcat(opts, MNTTAB_OPT_SEC, len);
   xstrlcat(opts, "=", len);
   xstrlcat(opts, sec, len);
 }

 mntp->mnt_opts = opts;
}

static void
print_nfs4_security(const nfs4_args_t *nap)
{
 char buf[1024];
 char num[64];
 size_t i, j;

 buf[0] = '\0';

 for (i = 0; i < nap->auth_flavourlen; i++) {

   for (j = 0; j < sizeof(flavours) / sizeof(flavours[0]); j++)
     if (flavours[j].num == nap->auth_flavours[i]) {
       xstrlcpy(num, flavours[j].name, sizeof(num));
       break;
     }

   if (j == sizeof(flavours) / sizeof(flavours[0])) {
     plog(XLOG_ERROR, "Unknown NFSv4 security mechanism %d\n",
          nap->auth_flavours[i]);
     xsnprintf(num, sizeof(num), "*%d*", nap->auth_flavours[i]);
   }

   if (buf[0])
     xstrlcat(buf, ":", sizeof(buf));

   xstrlcat(buf, num, sizeof(buf));
 }

 plog(XLOG_DEBUG, "NA->auth_flavours \"%s\"\n", buf);
}

static void
discard_nfs4_args(nfs4_args_t *nap)
{
 if (nap->client_addr.data)
   free(nap->client_addr.data);
 if (nap->hostname.data)
   free(nap->hostname.data);
 if (nap->mnt_path.data)
   free(nap->mnt_path.data);
 if (nap->host_addr)
   free(nap->host_addr);
 if (nap->auth_flavours)
   free(nap->auth_flavours);
}

/*
* Fill in the many possible fields and flags of struct nfs4_args.
*
* nap:         pre-allocated structure to fill in.
* mntp:        mount entry structure (includes options)
* genflags:    generic mount flags already determined
* nfsncp:      (TLI only) netconfig entry for this NFS mount
* ip_addr:     IP address of file server
* nfs_version: 4, or 0 if unknown
* nfs_proto:   "udp", "tcp", or NULL.
* fhp:         file handle structure pointer
* host_name:   name of remote NFS host
* fs_name:     remote file system name to mount
*/
static void
compute_nfs4_args(nfs4_args_t *nap,
                 mntent_t *mntp,
                 int genflags,
                 struct netconfig *nfsncp,
                 struct sockaddr_in *ip_addr,
                 u_long nfs_version,
                 char *nfs_proto,
                 am_nfs_handle_t *fhp,
                 char *host_name,
                 char *fs_name)
{
 char *s;
 struct nfs_common_args a;
 uint16_t nfs_port;

 /* initialize just in case */
 memset((voidp) nap, 0, sizeof(nfs4_args_t));

 /* compute all of the NFS attribute-cache flags */
 memset(&a, 0, sizeof(a));
 compute_nfs_attrcache_flags(&a, mntp);
 compute_nfs_common_args(&a, mntp, nfs_proto, nfs_version);
 get_nfs_common_args(nap, a);

 get_my_ipv4addr(&nap->client_addr);

 /************************************************************************/
 /***  HOST NAME                                                       ***/
 /************************************************************************/
 nap->hostname.len = strlen(host_name);
 nap->hostname.data = xmalloc(nap->hostname.len + 1);
 memcpy(nap->hostname.data, host_name, nap->hostname.len + 1);

 if ((s = strchr(fs_name, ':')) != NULL)
   s++;
 else
   s = fs_name;

 nap->mnt_path.len = strlen(s);
 nap->mnt_path.data = xmalloc(nap->mnt_path.len + 1);
 memcpy(nap->mnt_path.data, s, nap->mnt_path.len + 1);
 plog(XLOG_DEBUG, "dir name %s\n", nap->mnt_path.data);

 /************************************************************************/
 /***  IP ADDRESS OF REMOTE HOST                                       ***/
 /************************************************************************/
 nap->host_addrlen = sizeof(*ip_addr);
 nap->host_addr = xmalloc(nap->host_addrlen);
 memcpy(nap->host_addr, ip_addr, nap->host_addrlen);

 nfs_port = hasmntval(mntp, MNTTAB_OPT_PORT);
 if (nfs_port == 0)
   nfs_port = htons(NFS_PORT);
 else
   nfs_port = htons(nfs_port);

 ((struct sockaddr_in *)nap->host_addr)->sin_port = nfs_port;

 nap->proto = 0;               /* bsdi3 sets this field to zero  */
 if (nfs_proto) {
   if (STREQ(nfs_proto, "tcp"))        /* AIX 4.2.x needs this */
     nap->proto = IPPROTO_TCP;
   else if (STREQ(nfs_proto, "udp"))
     nap->proto = IPPROTO_UDP;
 }

 nap->version = NFS4_MOUNT_VERSION; /* BSDI 3.0 and OpenBSD 2.2 */

 /************************************************************************/
 /***  OTHER NFS SOCKET RELATED OPTIONS AND FLAGS                      ***/
 /************************************************************************/


 /************************************************************************/
 /***  OTHER FLAGS AND OPTIONS                                         ***/
 /************************************************************************/

#if defined(MNT2_NFS_OPT_POSIX) && defined(MNTTAB_OPT_POSIX)
 if (amu_hasmntopt(mntp, MNTTAB_OPT_POSIX) != NULL) {
   nap->args.flags |= MNT2_NFS_OPT_POSIX;
# ifdef HAVE_NFS_ARGS_T_PATHCONF
   nap->pathconf = NULL;
# endif /* HAVE_NFS_ARGS_T_PATHCONF */
 }
#endif /* MNT2_NFS_OPT_POSIX && MNTTAB_OPT_POSIX */

#if defined(MNT2_NFS_OPT_MAXGRPS) && defined(MNTTAB_OPT_MAXGROUPS)
 nap->maxgrouplist = hasmntval(mntp, MNTTAB_OPT_MAXGROUPS);
 if (nap->maxgrouplist != 0)
   nap->args.flags |= MNT2_NFS_OPT_MAXGRPS;
#endif /* defined(MNT2_NFS_OPT_MAXGRPS) && defined(MNTTAB_OPT_MAXGROUPS) */

#ifdef HAVE_NFS_ARGS_T_OPTSTR
 nap->optstr = mntp->mnt_opts;
#endif /* HAVE_NFS_ARGS_T_OPTSTR */

 /************************************************************************/
 /***  FINAL ACTIONS                                                   ***/
 /************************************************************************/

#ifdef HAVE_NFS_ARGS_T_GFS_FLAGS
 /* Ultrix stores generic flags in nfs_args.gfs_flags. */
 nap->gfs_flags = genflags;
#endif /* HAVE_NFS_ARGS_T_FLAGS */

 s = set_nfs4_security(nap, mntp);

 /* Add addresses to the mount options */
 add_nfs4_mntopts(nap, mntp, s);

 return;                       /* end of compute_nfs4_args() function */
}

#ifdef DEBUG
static void
print_nfs4_args(const nfs4_args_t *nap, u_long nfs_version)
{
 struct sockaddr_in *sap;
 struct nfs_common_args a;

 if (!nap) {
   plog(XLOG_DEBUG, "NULL nfs_args!");
   return;
 }

 plog(XLOG_DEBUG, "NA->client_addr \"%s\"\n", nap->client_addr.data);
 plog(XLOG_DEBUG, "NA->mnt_path = \"%s\"", nap->mnt_path.data);
 plog(XLOG_DEBUG, "NA->hostname = \"%s\"", nap->hostname.data);
 sap = (struct sockaddr_in *) nap->host_addr;
 print_nfs_sockaddr_in("host_addr", sap);
 plog(XLOG_DEBUG, "NA->proto = %d", (int) nap->proto);
#ifdef HAVE_NFS_ARGS_T_VERSION
 plog(XLOG_DEBUG, "NA->version = %d", nap->version);
#endif /* HAVE_NFS_ARGS_T_VERSION */
 print_nfs4_security(nap);

 put_nfs_common_args(nap, a);
 print_nfs_common_args(&a);
}
#endif
#endif /* HAVE_FS_NFS4 */

void
compute_nfs_args(void *nap,
                mntent_t *mntp,
                int genflags,
                struct netconfig *nfsncp,
                struct sockaddr_in *ip_addr,
                u_long nfs_version,
                char *nfs_proto,
                am_nfs_handle_t *fhp,
                char *host_name,
                char *fs_name)
{
#ifdef HAVE_FS_NFS4
 if (nfs_version == NFS_VERSION4)
   compute_nfs4_args(nap, mntp, genflags, nfsncp, ip_addr, nfs_version,
                     nfs_proto, fhp, host_name, fs_name);
 else
#endif /* HAVE_FS_NFS4 */
   compute_nfs23_args(nap, mntp, genflags, nfsncp, ip_addr, nfs_version,
                      nfs_proto, fhp, host_name, fs_name);
}

void
discard_nfs_args(void *nap, u_long nfs_version)
{
#ifdef HAVE_FS_NFS4
 if (nfs_version == NFS_VERSION4)
   discard_nfs4_args(nap);
 else
#endif /* HAVE_FS_NFS4 */
   discard_nfs23_args(nap);
}

#ifdef DEBUG
void
print_nfs_args(const void *nap, u_long nfs_version)
{
#ifdef HAVE_FS_NFS4
 if (nfs_version == NFS_VERSION4)
   print_nfs4_args(nap, nfs_version);
 else
#endif /* HAVE_FS_NFS4 */
   print_nfs23_args(nap, nfs_version);
}
#endif


/*
* Fill in special values for flags and fields of nfs_args, for an
* automounter NFS mount.
*/
void
compute_automounter_nfs_args(nfs_args_t *nap, mntent_t *mntp)
{
 struct nfs_common_args a;

#ifdef MNT2_NFS_OPT_SYMTTL
 /*
  * Don't let the kernel cache symbolic links we generate, or else lookups
  * will bypass amd and fail to remount stuff as needed.
  */
 plog(XLOG_INFO, "turning on NFS option symttl and setting value to 0");
 nap->flags |= MNT2_NFS_OPT_SYMTTL;
 nap->symttl = 0;
#endif /* MNT2_NFS_OPT_SYMTTL */

 /*
  * This completes the flags for the HIDE_MOUNT_TYPE  code in the
  * mount_amfs_toplvl() function in amd/amfs_toplvl.c.
  * Some systems don't have a mount type, but a mount flag.
  */
#ifdef MNT2_NFS_OPT_AUTO
 nap->flags |= MNT2_NFS_OPT_AUTO;
#endif /* MNT2_NFS_OPT_AUTO */
#ifdef MNT2_NFS_OPT_IGNORE
 nap->flags |= MNT2_NFS_OPT_IGNORE;
#endif /* MNT2_NFS_OPT_IGNORE */
#ifdef MNT2_GEN_OPT_AUTOMNTFS
 nap->flags |= MNT2_GEN_OPT_AUTOMNTFS;
#endif /* not MNT2_GEN_OPT_AUTOMNTFS */

#ifdef MNT2_NFS_OPT_DUMBTIMR
 /*
  * Don't let the kernel start computing throughput of Amd.  The numbers
  * will be meaningless because of the way Amd does mount retries.
  */
 plog(XLOG_INFO, "%s: disabling nfs congestion window", mntp->mnt_dir);
 nap->flags |= MNT2_NFS_OPT_DUMBTIMR;
#endif /* MNT2_NFS_OPT_DUMBTIMR */

 /* compute all of the NFS attribute-cache flags */
 memset(&a, 0, sizeof(a));
 a.flags = nap->flags;
 compute_nfs_attrcache_flags(&a, mntp);
 get_nfs_common_args(nap, a);

 /*
  * Provide a slight bit more security by requiring the kernel to use
  * reserved ports.
  */
#ifdef MNT2_NFS_OPT_RESVPORT
 nap->flags |= MNT2_NFS_OPT_RESVPORT;
#endif /* MNT2_NFS_OPT_RESVPORT */
}

int
nfs_valid_version(u_long v)
{
 return v >= NFS_VERS_MIN && v <= NFS_VERS_MAX;
}