MFC r308493, r308619: Update amd from am-utils 6.1.5 to 6.2.

Used extensively on my network over the past ten weeks. Reviewed by: pfg, brooks Suggested by: pfg Obtained from: ftp://ftp.am-utils.org/pub/am-utils/ Relnotes: yes Differential Revision: D8405
author: cy <cy@FreeBSD.org> 2016-12-23 22:42:14 +0000
committer: cy <cy@FreeBSD.org> 2016-12-23 22:42:14 +0000
commit: 78047153f3f320f60a8264a8a33abb8636dbfc7c (patch)
tree: 53c2e7da97b30a23be5e4d8f0bb2a8b5e5670e1c /contrib/amd/libamu
parent: bff6b519ae43ad35a81ea361a71b814e97a51c7c (diff)
download: FreeBSD-src-78047153f3f320f60a8264a8a33abb8636dbfc7c.zip
FreeBSD-src-78047153f3f320f60a8264a8a33abb8636dbfc7c.tar.gz
11 files changed, 3026 insertions, 458 deletions
diff --git a/contrib/amd/libamu/amu.h b/contrib/amd/libamu/amu.h
index 1e7834a..9415fc4 100644
--- a/contrib/amd/libamu/amu.h
+++ b/contrib/amd/libamu/amu.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997-2006 Erez Zadok
+ * 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.
@@ -16,11 +16,7 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgment:
- *      This product includes software developed by the University of
- *      California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
+ * 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.
  *
@@ -47,11 +43,14 @@
 /*
  * Decide what maximum level of NFS server to try and mount with.
  */
-#ifdef HAVE_FS_NFS3
+#if defined(HAVE_FS_NFS4)
+# define NFS_VERS_MAX NFS_VERSION4
+#elif defined(HAVE_FS_NFS3)
 # define NFS_VERS_MAX NFS_VERSION3
 #else /* not HAVE_FS_NFS3 */
 # define NFS_VERS_MAX NFS_VERSION
 #endif /* not HAVE_FS_NFS3 */
+# define NFS_VERS_MIN NFS_VERSION
 
 /* some systems like ncr2 do not define this in <rpcsvc/mount.h> */
 #ifndef MNTPATHLEN
diff --git a/contrib/amd/libamu/hasmntopt.c b/contrib/amd/libamu/hasmntopt.c
index 14cceb5..e5a6f2e 100644
--- a/contrib/amd/libamu/hasmntopt.c
+++ b/contrib/amd/libamu/hasmntopt.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997-2006 Erez Zadok
+ * 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.
@@ -16,11 +16,7 @@ n * modification, are permitted provided that the following conditions
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgment:
- *      This product includes software developed by the University of
- *      California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
+ * 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.
  *
@@ -67,7 +63,7 @@ nextmntopt(char **p)
   /*
    * Skip past white space
    */
-  while (*cp && isspace((int) *cp))
+  while (*cp && isspace((unsigned char) *cp))
     cp++;
 
   /*
@@ -106,7 +102,7 @@ amu_hasmntopt(mntent_t *mnt, char *opt)
   char t[MNTMAXSTR];
   char *f;
   char *o = t;
-  int l = strlen(opt);
+  size_t l = strlen(opt);
 
   xstrlcpy(t, mnt->mnt_opts, sizeof(t));
 
diff --git a/contrib/amd/libamu/misc_rpc.c b/contrib/amd/libamu/misc_rpc.c
index de0a920..c6ad448 100644
--- a/contrib/amd/libamu/misc_rpc.c
+++ b/contrib/amd/libamu/misc_rpc.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997-2006 Erez Zadok
+ * 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.
@@ -16,11 +16,7 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgment:
- *      This product includes software developed by the University of
- *      California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
+ * 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.
  *
diff --git a/contrib/amd/libamu/mount_fs.c b/contrib/amd/libamu/mount_fs.c
index 74f064e..b5576bd 100644
--- a/contrib/amd/libamu/mount_fs.c
+++ b/contrib/amd/libamu/mount_fs.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997-2006 Erez Zadok
+ * 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.
@@ -16,11 +16,7 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgment:
- *      This product includes software developed by the University of
- *      California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
+ * 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.
  *
@@ -46,6 +42,7 @@
 #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 */
@@ -105,6 +102,30 @@ struct opt_tab mnt_flags[] =
   {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
@@ -158,6 +179,25 @@ compute_automounter_mount_flags(mntent_t *mntp)
 }
 
 
+#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)
 {
@@ -166,17 +206,17 @@ mount_fs(mntent_t *mnt, int flags, caddr_t mnt_data, int retry, MTYPE_TYPE type,
   char *zopts = NULL, *xopts = NULL;
   size_t l;
 #endif /* MOUNT_TABLE_ON_FILE */
-  char *mnt_dir = 0;
+  char *mnt_dir = NULL;
 
 #ifdef NEED_AUTOFS_SPACE_HACK
-  char *old_mnt_dir = 0;
+  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 = strdup(mnt->mnt_dir);
+    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);
@@ -256,19 +296,15 @@ again:
   }
 # 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)
-  /*
-   * add the extra vers={2,3} field to the mount table,
-   * unless already specified by user
-   */
-   if (nfs_version == NFS_VERSION3 &&
-       hasmntval(mnt, MNTTAB_OPT_VERS) != NFS_VERSION3) {
-     char optsbuf[48];
-     xsnprintf(optsbuf, sizeof(optsbuf),
-	       "%s=%d", MNTTAB_OPT_VERS, NFS_VERSION3);
-     append_opts(zopts, l, optsbuf);
-   }
+  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
   /*
@@ -333,7 +369,7 @@ again:
  * with caution.
  */
 static void
-compute_nfs_attrcache_flags(nfs_args_t *nap, mntent_t *mntp)
+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 */
@@ -365,7 +401,9 @@ compute_nfs_attrcache_flags(nfs_args_t *nap, mntent_t *mntp)
     nap->acregmin = acval;	/* min ac timeout for reg files (sec) */
   } else {
 # ifdef MNTTAB_OPT_ACREGMIN
-    err_acrdmm = hasmntvalerr(mntp, MNTTAB_OPT_ACREGMIN, (int *) &nap->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 */
@@ -384,7 +422,9 @@ compute_nfs_attrcache_flags(nfs_args_t *nap, mntent_t *mntp)
     nap->acregmax = acval;	/* max ac timeout for reg files (sec) */
   } else {
 # ifdef MNTTAB_OPT_ACREGMAX
-    err_acrdmm = hasmntvalerr(mntp, MNTTAB_OPT_ACREGMAX, (int *) &nap->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 */
@@ -403,7 +443,9 @@ compute_nfs_attrcache_flags(nfs_args_t *nap, mntent_t *mntp)
     nap->acdirmin = acval;	/* min ac timeout for dirs (sec) */
   } else {
 # ifdef MNTTAB_OPT_ACDIRMIN
-    err_acrdmm = hasmntvalerr(mntp, MNTTAB_OPT_ACDIRMIN, (int *) &nap->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 */
@@ -422,7 +464,9 @@ compute_nfs_attrcache_flags(nfs_args_t *nap, mntent_t *mntp)
     nap->acdirmax = acval;	/* max ac timeout for dirs (sec) */
   } else {
 # ifdef MNTTAB_OPT_ACDIRMAX
-    err_acrdmm = hasmntvalerr(mntp, MNTTAB_OPT_ACDIRMAX, (int *) &nap->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 */
@@ -443,148 +487,16 @@ compute_nfs_attrcache_flags(nfs_args_t *nap, mntent_t *mntp)
 }
 
 
-/*
- * 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, (4 in the future), 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
- */
-void
-compute_nfs_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)
-{
-  /* initialize just in case */
-  memset((voidp) nap, 0, sizeof(nfs_args_t));
-
-  /* compute all of the NFS attribute-cache flags */
-  compute_nfs_attrcache_flags(nap, mntp);
-
-  /************************************************************************/
-  /***	FILEHANDLE DATA AND LENGTH					***/
-  /************************************************************************/
-#ifdef HAVE_FS_NFS3
-  if (nfs_version == NFS_VERSION3) {
-# 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 */
-    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				***/
-  /************************************************************************/
+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 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			***/
-  /************************************************************************/
 #ifdef MNT2_NFS_OPT_NOCONN
   /* check if user specified to use unconnected or connected sockets */
   if (amu_hasmntopt(mntp, MNTTAB_OPT_NOCONN) != NULL)
@@ -624,28 +536,6 @@ compute_nfs_args(nfs_args_t *nap,
 # endif /* not MNTTAB_OPT_RESVPORT */
 #endif /* MNT2_NFS_OPT_RESVPORT */
 
-  /************************************************************************/
-  /***	OTHER FLAGS AND OPTIONS						***/
-  /************************************************************************/
-
-#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);
-  }
-  /* update the flags field for knconf */
-  nap->flags |= MNT2_NFS_OPT_KNCONF;
-#endif /* HAVE_TRANSPORT_TYPE_TLI */
-
-#ifdef MNT2_NFS_OPT_FSNAME
-  nap->fsname = fs_name;
-  nap->flags |= MNT2_NFS_OPT_FSNAME;
-#endif /* MNT2_NFS_OPT_FSNAME */
-
   nap->rsize = hasmntval(mntp, MNTTAB_OPT_RSIZE);
 #ifdef MNT2_NFS_OPT_RSIZE
   if (nap->rsize)
@@ -674,11 +564,6 @@ compute_nfs_args(nfs_args_t *nap,
     nap->flags |= MNT2_NFS_OPT_RETRANS;
 #endif /* MNT2_NFS_OPT_RETRANS */
 
-#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 MNT2_NFS_OPT_SOFT
   if (amu_hasmntopt(mntp, MNTTAB_OPT_SOFT) != NULL)
     nap->flags |= MNT2_NFS_OPT_SOFT;
@@ -687,7 +572,7 @@ compute_nfs_args(nfs_args_t *nap,
 #ifdef MNT2_NFS_OPT_SPONGY
   if (amu_hasmntopt(mntp, MNTTAB_OPT_SPONGY) != NULL) {
     nap->flags |= MNT2_NFS_OPT_SPONGY;
-    if (nap->flags & MNT2_NFS_OPT_SOFT) {
+    if (*flags & MNT2_NFS_OPT_SOFT) {
       plog(XLOG_USER, "Mount opts soft and spongy are incompatible - soft ignored");
       nap->flags &= ~MNT2_NFS_OPT_SOFT;
     }
@@ -720,6 +605,11 @@ compute_nfs_args(nfs_args_t *nap,
 # 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;
@@ -735,39 +625,17 @@ compute_nfs_args(nfs_args_t *nap,
     nap->flags |= MNT2_NFS_OPT_PRIVATE;
 #endif /* MNTTAB_OPT_PRIVATE */
 
-#ifdef MNTTAB_OPT_SYMTTL	/* symlink cache time-to-live */
-  if ((nap->symttl = hasmntval(mntp, MNTTAB_OPT_SYMTTL)))
-    nap->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->flags |= MNT2_NFS_OPT_PGTHRESH;
-#endif /* MNT2_NFS_OPT_PGTHRESH */
 
 #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_POSIX) && defined(MNTTAB_OPT_POSIX)
-  if (amu_hasmntopt(mntp, MNTTAB_OPT_POSIX) != NULL) {
-    nap->flags |= MNT2_NFS_OPT_POSIX;
-    nap->pathconf = NULL;
-  }
-#endif /* MNT2_NFS_OPT_POSIX && MNTTAB_OPT_POSIX */
-
 #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_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) */
-
 #if defined(MNT2_NFS_OPT_NONLM) && defined(MNTTAB_OPT_NOLOCK)
   if (amu_hasmntopt(mntp, MNTTAB_OPT_NOLOCK) != NULL)
     nap->flags |= MNT2_NFS_OPT_NONLM;
@@ -777,77 +645,35 @@ compute_nfs_args(nfs_args_t *nap,
   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 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 */
-
-  return;			/* end of compute_nfs_args() function */
 }
 
-
-/*
- * 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)
+static void
+print_nfs_common_args(const 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 */
+  plog(XLOG_DEBUG, "NA->flags = 0x%lx", a->flags);
 
-#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 */
-  compute_nfs_attrcache_flags(nap, mntp);
+  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);
 
-  /*
-   * 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 */
+#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 */
 }
 
+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 */
@@ -855,29 +681,48 @@ static char *
 get_hex_string(u_int len, const char *fhdata)
 {
   u_int i;
-  static char buf[128];		/* better not go over it! */
+  static u_int xlen;
+  static char *buf;
+  static u_short *arr;
   char str[16];
-  short int arr[64];
 
-  if (!fhdata)
+  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], 0, (64 * sizeof(short int)));
-  memcpy(&arr[0], &fhdata[0], len);
-  for (i=0; i<len/sizeof(unsigned short int); i++) {
+  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, sizeof(buf));
+    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.
  */
-void
-print_nfs_args(const nfs_args_t *nap, u_long nfs_version)
+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
@@ -886,6 +731,7 @@ print_nfs_args(const nfs_args_t *nap, u_long nfs_version)
 #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!");
@@ -919,17 +765,11 @@ print_nfs_args(const nfs_args_t *nap, u_long nfs_version)
 # else /* not NFS_ARGS_T_ADDR_IS_POINTER */
     sap = (struct sockaddr_in *) &nap->addr;
 # endif /* not NFS_ARGS_T_ADDR_IS_POINTER */
-  plog(XLOG_DEBUG, "NA->addr {sockaddr_in} (len=%d) = \"%s\"",
-       (int) sizeof(struct sockaddr_in),
-       get_hex_string(sizeof(struct sockaddr_in), (const char *)sap));
 #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 */
-  plog(XLOG_DEBUG, "NA->addr.sin_family = %d", sap->sin_family);
-  plog(XLOG_DEBUG, "NA->addr.sin_port = %d", sap->sin_port);
-  plog(XLOG_DEBUG, "NA->addr.sin_addr = \"%s\"",
-       get_hex_string(sizeof(struct in_addr), (const char *) &sap->sin_addr));
+  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);
@@ -972,22 +812,13 @@ print_nfs_args(const nfs_args_t *nap, u_long nfs_version)
   plog(XLOG_DEBUG, "NA->version = %d", nap->version);
 #endif /* HAVE_NFS_ARGS_T_VERSION */
 
-  plog(XLOG_DEBUG, "NA->flags = 0x%x", (int) nap->flags);
+  put_nfs_common_args(nap, a);
+  print_nfs_common_args(&a);
 
-  plog(XLOG_DEBUG, "NA->rsize = %d", (int) nap->rsize);
-  plog(XLOG_DEBUG, "NA->wsize = %d", (int) nap->wsize);
 #ifdef HAVE_NFS_ARGS_T_BSIZE
   plog(XLOG_DEBUG, "NA->bsize = %d", nap->bsize);
 #endif /* HAVE_NFS_ARGS_T_BSIZE */
-  plog(XLOG_DEBUG, "NA->timeo = %d", (int) nap->timeo);
-  plog(XLOG_DEBUG, "NA->retrans = %d", (int) nap->retrans);
 
-#ifdef HAVE_NFS_ARGS_T_ACREGMIN
-  plog(XLOG_DEBUG, "NA->acregmin = %d", (int) nap->acregmin);
-  plog(XLOG_DEBUG, "NA->acregmax = %d", (int) nap->acregmax);
-  plog(XLOG_DEBUG, "NA->acdirmin = %d", (int) nap->acdirmin);
-  plog(XLOG_DEBUG, "NA->acdirmax = %d", (int) nap->acdirmax);
-#endif /* HAVE_NFS_ARGS_T_ACREGMIN */
 #ifdef MNTTAB_OPT_SYMTTL
   plog(XLOG_DEBUG, "NA->symttl = %d", nap->symttl);
 #endif /* MNTTAB_OPT_SYMTTL */
@@ -1001,3 +832,665 @@ print_nfs_args(const nfs_args_t *nap, u_long nfs_version)
 
 }
 #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;
+}
diff --git a/contrib/amd/libamu/mtab.c b/contrib/amd/libamu/mtab.c
index 50ba994..ee603af 100644
--- a/contrib/amd/libamu/mtab.c
+++ b/contrib/amd/libamu/mtab.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997-2006 Erez Zadok
+ * Copyright (c) 1997-2014 Erez Zadok
  * Copyright (c) 1989 Jan-Simon Pendry
  * Copyright (c) 1989 Imperial College of Science, Technology & Medicine
  * Copyright (c) 1989 The Regents of the University of California.
@@ -16,11 +16,7 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgment:
- *      This product includes software developed by the University of
- *      California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
+ * 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.
  *
@@ -233,9 +229,9 @@ hasmntstr(mntent_t *mnt, char *opt)
 
       char *endptr = strchr(eq, ',');
 
-      /* if saw no comma, return strdup'd string */
+      /* if saw no comma, return xstrdup'd string */
       if (!endptr)
-	return strdup(eq);
+	return xstrdup(eq);
       else {
 	/* else we need to copy only the chars needed */
 	int len = endptr - eq;
diff --git a/contrib/amd/libamu/nfs_prot_xdr.c b/contrib/amd/libamu/nfs_prot_xdr.c
index df8a0b0..bfdc7b2 100644
--- a/contrib/amd/libamu/nfs_prot_xdr.c
+++ b/contrib/amd/libamu/nfs_prot_xdr.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997-2006 Erez Zadok
+ * Copyright (c) 1997-2014 Erez Zadok
  * Copyright (c) 1989 Jan-Simon Pendry
  * Copyright (c) 1989 Imperial College of Science, Technology & Medicine
  * Copyright (c) 1989 The Regents of the University of California.
@@ -16,11 +16,7 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgment:
- *      This product includes software developed by the University of
- *      California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
+ * 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.
  *
@@ -56,3 +52,14 @@ xdr_amq_string(XDR *xdrs, amq_string *objp)
   }
   return (TRUE);
 }
+
+
+bool_t
+xdr_amq_sync_umnt(XDR *xdrs, amq_sync_umnt *objp)
+{
+
+  if (!xdr_opaque(xdrs, (char *) objp, sizeof(*objp))) {
+    return (FALSE);
+  }
+  return (TRUE);
+}
diff --git a/contrib/amd/libamu/strerror.c b/contrib/amd/libamu/strerror.c
index 49dd2fc..faf2916 100644
--- a/contrib/amd/libamu/strerror.c
+++ b/contrib/amd/libamu/strerror.c
@@ -1,6 +1,6 @@
 /*
- * Copyright (c) 2002-2006 Ion Badulescu
- * Copyright (c) 1997-2006 Erez Zadok
+ * Copyright (c) 2002-2014 Ion Badulescu
+ * 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.
@@ -17,11 +17,7 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgment:
- *      This product includes software developed by the University of
- *      California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
+ * 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.
  *
diff --git a/contrib/amd/libamu/strutil.c b/contrib/amd/libamu/strutil.c
index 5a1e759..03a8e88 100644
--- a/contrib/amd/libamu/strutil.c
+++ b/contrib/amd/libamu/strutil.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997-2006 Erez Zadok
+ * 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.
@@ -16,11 +16,7 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgment:
- *      This product includes software developed by the University of
- *      California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
+ * 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.
  *
@@ -268,3 +264,37 @@ xvsnprintf(char *str, size_t size, const char *format, va_list ap)
 
   return ret;
 }
+
+static size_t
+vstrlen(const char *src, va_list ap)
+{
+  size_t len = strlen(src);
+  while ((src = va_arg(ap, const char *)) != NULL)
+    len += strlen(src);
+  return len;
+}
+
+static void
+vstrcpy(char *dst, const char *src, va_list ap)
+{
+  strcpy(dst, src);
+  while ((src = va_arg(ap, const char *)) != NULL)
+    strcat(dst, src);
+}
+
+char *
+strvcat(const char *src, ...)
+{
+  size_t len;
+  char *dst;
+  va_list ap;
+
+  va_start(ap, src);
+  len = vstrlen(src, ap);
+  va_end(ap);
+  dst = xmalloc(len + 1);
+  va_start(ap, src);
+  vstrcpy(dst, src, ap);
+  va_end(ap);
+  return dst;
+}
diff --git a/contrib/amd/libamu/wire.c b/contrib/amd/libamu/wire.c
index c1852cd..c9da0fe 100644
--- a/contrib/amd/libamu/wire.c
+++ b/contrib/amd/libamu/wire.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997-2006 Erez Zadok
+ * 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.
@@ -16,11 +16,7 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgment:
- *      This product includes software developed by the University of
- *      California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
+ * 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.
  *
@@ -226,7 +222,7 @@ getwire_lookup(u_long address, u_long netmask, int ishost)
   }
 
   /* fill in network number (string) */
-  al->ip_net_num = strdup(netNumberBuf);
+  al->ip_net_num = xstrdup(netNumberBuf);
 
   if (np != NULL)
     s = np->n_name;
@@ -242,7 +238,7 @@ getwire_lookup(u_long address, u_long netmask, int ishost)
   }
 
   /* fill in network name (string) */
-  al->ip_net_name = strdup(s);
+  al->ip_net_name = xstrdup(s);
   /* Let's be cautious here about buffer overflows -Ion */
   if (strlen(s) > MAXHOSTNAMELEN) {
     al->ip_net_name[MAXHOSTNAMELEN] = '\0';
@@ -318,9 +314,14 @@ is_network_member(const char *net)
       if (STREQ(net, al->ip_net_name) || STREQ(net, al->ip_net_num))
 	return TRUE;
   } else {
-    char *netstr = strdup(net), *maskstr;
+    char *netstr = xstrdup(net), *maskstr;
     u_long netnum, masknum = 0;
     maskstr = strchr(netstr, '/');
+    if (maskstr == NULL) {
+      plog(XLOG_ERROR, "%s: netstr %s does not have a `/'", __func__, netstr);
+      XFREE(netstr);
+      return FALSE;
+    }
     maskstr[0] = '\0';		/* null terminate netstr */
     maskstr++;
     if (*maskstr == '\0')	/* if empty string, make it NULL */
diff --git a/contrib/amd/libamu/xdr_func.c b/contrib/amd/libamu/xdr_func.c
index 6bd0254..e437dd4 100644
--- a/contrib/amd/libamu/xdr_func.c
+++ b/contrib/amd/libamu/xdr_func.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997-2006 Erez Zadok
+ * 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.
@@ -16,11 +16,7 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgment:
- *      This product includes software developed by the University of
- *      California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
+ * 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.
  *
@@ -951,7 +947,6 @@ xdr_am_mountres3_ok(XDR *xdrs, am_mountres3_ok *objp)
   return (TRUE);
 }
 
-
 bool_t
 xdr_am_mountres3(XDR *xdrs, am_mountres3 *objp)
 {
@@ -968,6 +963,78 @@ xdr_am_mountres3(XDR *xdrs, am_mountres3 *objp)
   return (TRUE);
 }
 
+bool_t
+xdr_am_cookieverf3(XDR *xdrs, am_cookieverf3 objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_cookieverf3:");
+
+  if (!xdr_opaque(xdrs, objp, AM_NFS3_COOKIEVERFSIZE))
+    return FALSE;
+  return TRUE;
+}
+
+#if 0
+/* In FreeBSD xdr_uint64() is defined in ../../../include/rpcsvc/nfs_prot.x */
+/*
+ * Not ideal, xdr_u_int64_t() is not defined in Linux glibc RPC
+ * but xdr_u_quad_t() is. But in libtirpc xdr_u_quad_t() is not
+ * defined and xdr_u_int64_t() is. So xdr_u_int64_t() is probably
+ * an expected standard xdr function so, if it isn't defined use
+ * an internal xdr_u_int64_t() that uses xdr_u_quad_t().
+ */
+#ifndef HAVE_XDR_U_INT64_T
+#define xdr_u_int64_t(xdrs, objp) xdr_u_quad_t(xdrs, objp)
+#endif /* HAVE_XDR_U_INT64_T */
+
+bool_t
+xdr_uint64(XDR *xdrs, uint64 *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_uint64:");
+
+  if (!xdr_u_int64_t(xdrs, objp))
+    return FALSE;
+  return TRUE;
+}
+#endif
+
+bool_t
+xdr_am_cookie3(XDR *xdrs, am_cookie3 *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_cookie3:");
+
+  if (!xdr_uint64(xdrs, objp))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_nfs_fh3(XDR *xdrs, am_nfs_fh3 *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_nfs_fh3:");
+
+  if (!xdr_u_int(xdrs, &objp->am_fh3_length))
+    return (FALSE);
+  if (objp->am_fh3_length > AM_FHSIZE3)
+    return (FALSE);
+  if (!xdr_opaque(xdrs, objp->am_fh3_data, objp->am_fh3_length))
+    return (FALSE);
+  return (TRUE);
+}
+
+bool_t
+xdr_am_nfsstat3(XDR *xdrs, am_nfsstat3 *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_nfsstat3:");
+
+  if (!xdr_enum(xdrs, (enum_t *)objp))
+    return (FALSE);
+  return (TRUE);
+}
 
 bool_t
 xdr_am_diropargs3(XDR *xdrs, am_diropargs3 *objp)
@@ -982,7 +1049,6 @@ xdr_am_diropargs3(XDR *xdrs, am_diropargs3 *objp)
   return (TRUE);
 }
 
-
 bool_t
 xdr_am_filename3(XDR *xdrs, am_filename3 *objp)
 {
@@ -994,6 +1060,315 @@ xdr_am_filename3(XDR *xdrs, am_filename3 *objp)
   return (TRUE);
 }
 
+bool_t
+xdr_am_ftype3(XDR *xdrs, am_ftype3 *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_ftype3:");
+
+  if (!xdr_enum(xdrs, (enum_t *) objp))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_mode3(XDR *xdrs, am_mode3 *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_mode3:");
+
+  if (!xdr_u_int(xdrs, objp))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_uid3(XDR *xdrs, am_uid3 *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_uid3:");
+
+  if (!xdr_u_int(xdrs, objp))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_gid3(XDR *xdrs, am_gid3 *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_gid3:");
+
+  if (!xdr_u_int(xdrs, objp))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_size3(XDR *xdrs, am_size3 *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_size3:");
+
+  if (!xdr_uint64(xdrs, objp))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_fileid3(XDR *xdrs, am_fileid3 *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_fileid3:");
+
+  if (!xdr_uint64(xdrs, objp))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_specdata3(XDR *xdrs, am_specdata3 *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_specdata3:");
+
+  if (!xdr_u_int(xdrs, &objp->specdata1))
+    return FALSE;
+  if (!xdr_u_int(xdrs, &objp->specdata2))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_nfstime3(XDR *xdrs, am_nfstime3 *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_nfstime3:");
+
+  if (!xdr_u_int(xdrs, &objp->seconds))
+    return FALSE;
+  if (!xdr_u_int(xdrs, &objp->nseconds))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_fattr3(XDR *xdrs, am_fattr3 *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_fattr3:");
+
+  if (!xdr_am_ftype3(xdrs, &objp->type))
+    return FALSE;
+  if (!xdr_am_mode3(xdrs, &objp->mode))
+    return FALSE;
+  if (!xdr_u_int(xdrs, &objp->nlink))
+    return FALSE;
+  if (!xdr_am_uid3(xdrs, &objp->uid))
+    return FALSE;
+  if (!xdr_am_gid3(xdrs, &objp->gid))
+    return FALSE;
+  if (!xdr_am_size3(xdrs, &objp->size))
+    return FALSE;
+  if (!xdr_am_size3(xdrs, &objp->used))
+    return FALSE;
+  if (!xdr_am_specdata3(xdrs, &objp->rdev))
+    return FALSE;
+  if (!xdr_uint64(xdrs, &objp->fsid))
+    return FALSE;
+  if (!xdr_am_fileid3(xdrs, &objp->fileid))
+    return FALSE;
+  if (!xdr_am_nfstime3(xdrs, &objp->atime))
+    return FALSE;
+  if (!xdr_am_nfstime3(xdrs, &objp->mtime))
+    return FALSE;
+  if (!xdr_am_nfstime3(xdrs, &objp->ctime))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_post_op_attr(XDR *xdrs, am_post_op_attr *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_post_op_attr:");
+
+  if (!xdr_bool(xdrs, &objp->attributes_follow))
+    return FALSE;
+  switch (objp->attributes_follow) {
+  case TRUE:
+    if (!xdr_am_fattr3(xdrs, &objp->am_post_op_attr_u.attributes))
+      return FALSE;
+    break;
+  case FALSE:
+    break;
+  default:
+    return FALSE;
+  }
+  return TRUE;
+}
+
+bool_t
+xdr_am_stable_how(XDR *xdrs, am_stable_how *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_stable_how:");
+
+  if (!xdr_enum(xdrs, (enum_t *) objp))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_offset3(XDR *xdrs, am_offset3 *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_offset3:");
+
+  if (!xdr_uint64(xdrs, objp))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_count3(XDR *xdrs, am_count3 *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_count3:");
+
+  if (!xdr_u_int(xdrs, objp))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_wcc_attr(XDR *xdrs, am_wcc_attr *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_wcc_attr:");
+
+  if (!xdr_am_size3(xdrs, &objp->size))
+    return FALSE;
+  if (!xdr_am_nfstime3(xdrs, &objp->mtime))
+    return FALSE;
+  if (!xdr_am_nfstime3(xdrs, &objp->ctime))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_pre_op_attr(XDR *xdrs, am_pre_op_attr *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, ":xdr_am_pre_op_attr");
+
+  if (!xdr_bool(xdrs, &objp->attributes_follow))
+    return FALSE;
+  switch (objp->attributes_follow) {
+  case TRUE:
+    if (!xdr_am_wcc_attr(xdrs, &objp->am_pre_op_attr_u.attributes))
+      return FALSE;
+    break;
+  case FALSE:
+    break;
+  default:
+    return FALSE;
+  }
+  return TRUE;
+}
+
+bool_t
+xdr_am_wcc_data(XDR *xdrs, am_wcc_data *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_wcc_data:");
+
+  if (!xdr_am_pre_op_attr(xdrs, &objp->before))
+    return FALSE;
+  if (!xdr_am_post_op_attr(xdrs, &objp->after))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_WRITE3args(XDR *xdrs, am_WRITE3args *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_WRITE3args:");
+
+  if (!xdr_am_nfs_fh3(xdrs, &objp->file))
+    return FALSE;
+  if (!xdr_am_offset3(xdrs, &objp->offset))
+    return FALSE;
+  if (!xdr_am_count3(xdrs, &objp->count))
+    return FALSE;
+  if (!xdr_am_stable_how(xdrs, &objp->stable))
+    return FALSE;
+  if (!xdr_bytes(xdrs, (char **)&objp->data.data_val,
+                (u_int *) &objp->data.data_len, ~0))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_writeverf3(XDR *xdrs, am_writeverf3 objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_writeverf3:");
+
+  if (!xdr_opaque(xdrs, objp, AM_NFS3_WRITEVERFSIZE))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_WRITE3resok(XDR *xdrs, am_WRITE3resok *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_WRITE3resok:");
+
+  if (!xdr_am_wcc_data(xdrs, &objp->file_wcc))
+    return FALSE;
+  if (!xdr_am_count3(xdrs, &objp->count))
+    return FALSE;
+  if (!xdr_am_stable_how(xdrs, &objp->committed))
+    return FALSE;
+  if (!xdr_am_writeverf3(xdrs, objp->verf))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_WRITE3resfail(XDR *xdrs, am_WRITE3resfail *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_WRITE3resfail:");
+
+  if (!xdr_am_wcc_data(xdrs, &objp->file_wcc))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_WRITE3res(XDR *xdrs, am_WRITE3res *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_WRITE3res:");
+
+  if (!xdr_am_nfsstat3(xdrs, &objp->status))
+    return FALSE;
+  switch (objp->status) {
+  case AM_NFS3_OK:
+    if (!xdr_am_WRITE3resok(xdrs, &objp->res_u.ok))
+      return FALSE;
+    break;
+  default:
+    if (!xdr_am_WRITE3resfail(xdrs, &objp->res_u.fail))
+      return FALSE;
+    break;
+  }
+  return TRUE;
+}
 
 bool_t
 xdr_am_LOOKUP3args(XDR *xdrs, am_LOOKUP3args *objp)
@@ -1006,7 +1381,6 @@ xdr_am_LOOKUP3args(XDR *xdrs, am_LOOKUP3args *objp)
   return (TRUE);
 }
 
-
 bool_t
 xdr_am_LOOKUP3res(XDR *xdrs, am_LOOKUP3res *objp)
 {
@@ -1028,25 +1402,17 @@ xdr_am_LOOKUP3res(XDR *xdrs, am_LOOKUP3res *objp)
   return (TRUE);
 }
 
-
 bool_t
 xdr_am_LOOKUP3resfail(XDR *xdrs, am_LOOKUP3resfail *objp)
 {
   if (amuDebug(D_XDRTRACE))
     plog(XLOG_DEBUG, "xdr_am_LOOKUP3resfail:");
 
-  /*
-   * Don't xdr post_op_attr: amd doesn't need them, but they require many
-   * additional xdr functions.
-   */
-#if 0
-  if (!xdr_post_op_attr(xdrs, &objp->dir_attributes))
+  if (!xdr_am_post_op_attr(xdrs, &objp->dir_attributes))
     return (FALSE);
-#endif
   return (TRUE);
 }
 
-
 bool_t
 xdr_am_LOOKUP3resok(XDR *xdrs, am_LOOKUP3resok *objp)
 {
@@ -1055,44 +1421,1656 @@ xdr_am_LOOKUP3resok(XDR *xdrs, am_LOOKUP3resok *objp)
 
   if (!xdr_am_nfs_fh3(xdrs, &objp->object))
     return (FALSE);
-  /*
-   * Don't xdr post_op_attr: amd doesn't need them, but they require many
-   * additional xdr functions.
-   */
-#if 0
-  if (!xdr_post_op_attr(xdrs, &objp->obj_attributes))
+  if (!xdr_am_post_op_attr(xdrs, &objp->obj_attributes))
     return (FALSE);
-  if (!xdr_post_op_attr(xdrs, &objp->dir_attributes))
+  if (!xdr_am_post_op_attr(xdrs, &objp->dir_attributes))
     return (FALSE);
-#endif
   return (TRUE);
 }
 
+bool_t
+xdr_am_COMMIT3args(XDR *xdrs, am_COMMIT3args *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_COMMIT3args:");
+
+  if (!xdr_am_nfs_fh3(xdrs, &objp->file))
+    return FALSE;
+  if (!xdr_am_offset3(xdrs, &objp->offset))
+    return FALSE;
+  if (!xdr_am_count3(xdrs, &objp->count))
+    return FALSE;
+  return TRUE;
+}
 
 bool_t
-xdr_am_nfs_fh3(XDR *xdrs, am_nfs_fh3 *objp)
+xdr_am_COMMIT3resok(XDR *xdrs, am_COMMIT3resok *objp)
 {
   if (amuDebug(D_XDRTRACE))
-    plog(XLOG_DEBUG, "xdr_am_nfs_fh3:");
+    plog(XLOG_DEBUG, "xdr_am_COMMIT3resok:");
 
-  if (!xdr_u_int(xdrs, &objp->am_fh3_length))
-    return (FALSE);
-  if (objp->am_fh3_length > AM_FHSIZE3)
-    return (FALSE);
-  if (!xdr_opaque(xdrs, objp->am_fh3_data, objp->am_fh3_length))
-    return (FALSE);
-  return (TRUE);
+  if (!xdr_am_wcc_data(xdrs, &objp->file_wcc))
+    return FALSE;
+  if (!xdr_am_writeverf3(xdrs, objp->verf))
+    return FALSE;
+  return TRUE;
 }
 
+bool_t
+xdr_am_COMMIT3resfail(XDR *xdrs, am_COMMIT3resfail *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_COMMIT3resfail:");
+
+  if (!xdr_am_wcc_data(xdrs, &objp->file_wcc))
+    return FALSE;
+  return TRUE;
+}
 
 bool_t
-xdr_am_nfsstat3(XDR *xdrs, am_nfsstat3 *objp)
+xdr_am_COMMIT3res(XDR *xdrs, am_COMMIT3res *objp)
 {
   if (amuDebug(D_XDRTRACE))
-    plog(XLOG_DEBUG, "xdr_am_nfsstat3:");
+    plog(XLOG_DEBUG, "xdr_am_COMMIT3res:");
 
-  if (!xdr_enum(xdrs, (enum_t *)objp))
-    return (FALSE);
-  return (TRUE);
+  if (!xdr_am_nfsstat3(xdrs, &objp->status))
+    return FALSE;
+  switch (objp->status) {
+  case AM_NFS3_OK:
+    if (!xdr_am_COMMIT3resok(xdrs, &objp->res_u.ok))
+      return FALSE;
+    break;
+  default:
+    if (!xdr_am_COMMIT3resfail(xdrs, &objp->res_u.fail))
+      return FALSE;
+    break;
+  }
+  return TRUE;
+}
+
+bool_t
+xdr_am_ACCESS3args(XDR *xdrs, am_ACCESS3args *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_ACCESS3args:");
+
+  if (!xdr_am_nfs_fh3(xdrs, &objp->object))
+    return FALSE;
+  if (!xdr_u_int(xdrs, &objp->access))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_ACCESS3resok(XDR *xdrs, am_ACCESS3resok *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_ACCESS3resok:");
+
+  if (!xdr_am_post_op_attr(xdrs, &objp->obj_attributes))
+    return FALSE;
+  if (!xdr_u_int(xdrs, &objp->access))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_ACCESS3resfail(XDR *xdrs, am_ACCESS3resfail *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_ACCESS3resfail:");
+
+  if (!xdr_am_post_op_attr(xdrs, &objp->obj_attributes))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_ACCESS3res(XDR *xdrs, am_ACCESS3res *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_ACCESS3res:");
+
+  if (!xdr_am_nfsstat3(xdrs, &objp->status))
+    return FALSE;
+  switch (objp->status) {
+  case AM_NFS3_OK:
+    if (!xdr_am_ACCESS3resok(xdrs, &objp->res_u.ok))
+      return FALSE;
+    break;
+  default:
+    if (!xdr_am_ACCESS3resfail(xdrs, &objp->res_u.fail))
+      return FALSE;
+    break;
+  }
+  return TRUE;
+}
+
+bool_t
+xdr_am_GETATTR3args(XDR *xdrs, am_GETATTR3args *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_GETATTR3args:");
+
+  if (!xdr_am_nfs_fh3(xdrs, &objp->object))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_GETATTR3resok(XDR *xdrs, am_GETATTR3resok *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_GETATTR3resok:");
+
+  if (!xdr_am_fattr3(xdrs, &objp->obj_attributes))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_GETATTR3res(XDR *xdrs, am_GETATTR3res *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_GETATTR3res:");
+
+  if (!xdr_am_nfsstat3(xdrs, &objp->status))
+    return FALSE;
+  switch (objp->status) {
+  case AM_NFS3_OK:
+    if (!xdr_am_GETATTR3resok(xdrs, &objp->res_u.ok))
+      return FALSE;
+    break;
+  default:
+    break;
+  }
+  return TRUE;
+}
+
+bool_t
+xdr_am_time_how(XDR *xdrs, am_time_how *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_time_how:");
+
+  if (!xdr_enum(xdrs, (enum_t *) objp))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_set_mode3(XDR *xdrs, am_set_mode3 *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_set_mode3:");
+
+  if (!xdr_bool(xdrs, &objp->set_it))
+    return FALSE;
+  switch (objp->set_it) {
+  case TRUE:
+    if (!xdr_am_mode3(xdrs, &objp->am_set_mode3_u.mode))
+      return FALSE;
+    break;
+  default:
+    break;
+  }
+  return TRUE;
+}
+
+bool_t
+xdr_am_set_uid3(XDR *xdrs, am_set_uid3 *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_set_uid3:");
+
+  if (!xdr_bool(xdrs, &objp->set_it))
+    return FALSE;
+  switch (objp->set_it) {
+  case TRUE:
+    if (!xdr_am_uid3(xdrs, &objp->am_set_uid3_u.uid))
+      return FALSE;
+    break;
+  default:
+    break;
+  }
+  return TRUE;
+}
+
+bool_t
+xdr_am_set_gid3(XDR *xdrs, am_set_gid3 *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_set_gid3:");
+
+  if (!xdr_bool(xdrs, &objp->set_it))
+    return FALSE;
+  switch (objp->set_it) {
+  case TRUE:
+    if (!xdr_am_gid3(xdrs, &objp->am_set_gid3_u.gid))
+      return FALSE;
+    break;
+  default:
+    break;
+  }
+  return TRUE;
+}
+
+bool_t
+xdr_am_set_size3(XDR *xdrs, am_set_size3 *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_set_size3:");
+
+  if (!xdr_bool(xdrs, &objp->set_it))
+    return FALSE;
+  switch (objp->set_it) {
+  case TRUE:
+    if (!xdr_am_size3(xdrs, &objp->am_set_size3_u.size))
+      return FALSE;
+    break;
+  default:
+    break;
+  }
+  return TRUE;
+}
+
+bool_t
+xdr_am_set_atime(XDR *xdrs, am_set_atime *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_set_atime:");
+
+  if (!xdr_am_time_how(xdrs, &objp->set_it))
+    return FALSE;
+  switch (objp->set_it) {
+  case AM_SET_TO_CLIENT_TIME:
+    if (!xdr_am_nfstime3(xdrs, &objp->am_set_atime_u.atime))
+      return FALSE;
+    break;
+  default:
+    break;
+  }
+  return TRUE;
+}
+
+bool_t
+xdr_am_set_mtime(XDR *xdrs, am_set_mtime *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_set_mtime:");
+
+  if (!xdr_am_time_how(xdrs, &objp->set_it))
+    return FALSE;
+  switch (objp->set_it) {
+  case AM_SET_TO_CLIENT_TIME:
+    if (!xdr_am_nfstime3(xdrs, &objp->am_set_mtime_u.mtime))
+      return FALSE;
+    break;
+  default:
+    break;
+  }
+  return TRUE;
+}
+
+bool_t
+xdr_am_sattr3(XDR *xdrs, am_sattr3 *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_sattr3:");
+
+  if (!xdr_am_set_mode3(xdrs, &objp->mode))
+    return FALSE;
+  if (!xdr_am_set_uid3(xdrs, &objp->uid))
+    return FALSE;
+  if (!xdr_am_set_gid3(xdrs, &objp->gid))
+    return FALSE;
+  if (!xdr_am_set_size3(xdrs, &objp->size))
+     return FALSE;
+  if (!xdr_am_set_atime(xdrs, &objp->atime))
+    return FALSE;
+  if (!xdr_am_set_mtime(xdrs, &objp->mtime))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_createmode3(XDR *xdrs, am_createmode3 *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_createmode3:");
+
+  if (!xdr_enum(xdrs, (enum_t *) objp))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_createverf3(XDR *xdrs, am_createverf3 objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_createverf3:");
+
+  if (!xdr_opaque(xdrs, objp, AM_NFS3_CREATEVERFSIZE))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_createhow3(XDR *xdrs, am_createhow3 *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_createhow3:");
+
+   if (!xdr_am_createmode3(xdrs, &objp->mode))
+     return FALSE;
+  switch (objp->mode) {
+  case AM_UNCHECKED:
+    if (!xdr_am_sattr3(xdrs, &objp->am_createhow3_u.obj_attributes))
+      return FALSE;
+    break;
+  case AM_GUARDED:
+    if (!xdr_am_sattr3(xdrs, &objp->am_createhow3_u.g_obj_attributes))
+      return FALSE;
+    break;
+  case AM_EXCLUSIVE:
+    if (!xdr_am_createverf3(xdrs, objp->am_createhow3_u.verf))
+      return FALSE;
+    break;
+  default:
+    return FALSE;
+  }
+  return TRUE;
+}
+
+bool_t
+xdr_am_CREATE3args(XDR *xdrs, am_CREATE3args *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_CREATE3args:");
+
+  if (!xdr_am_diropargs3(xdrs, &objp->where))
+    return FALSE;
+  if (!xdr_am_createhow3(xdrs, &objp->how))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_post_op_fh3(XDR *xdrs, am_post_op_fh3 *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_post_op_fh3:");
+
+  if (!xdr_bool(xdrs, &objp->handle_follows))
+    return FALSE;
+  switch (objp->handle_follows) {
+  case TRUE:
+    if (!xdr_am_nfs_fh3(xdrs, &objp->am_post_op_fh3_u.handle))
+      return FALSE;
+    break;
+  case FALSE:
+    break;
+  default:
+    return FALSE;
+  }
+  return TRUE;
+}
+
+bool_t
+xdr_am_CREATE3resok(XDR *xdrs, am_CREATE3resok *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_CREATE3resok:");
+
+  if (!xdr_am_post_op_fh3(xdrs, &objp->obj))
+    return FALSE;
+  if (!xdr_am_post_op_attr(xdrs, &objp->obj_attributes))
+    return FALSE;
+  if (!xdr_am_wcc_data(xdrs, &objp->dir_wcc))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_CREATE3resfail(XDR *xdrs, am_CREATE3resfail *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_CREATE3resfail:");
+
+  if (!xdr_am_wcc_data(xdrs, &objp->dir_wcc))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_CREATE3res(XDR *xdrs, am_CREATE3res *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_CREATE3res:");
+
+  if (!xdr_am_nfsstat3(xdrs, &objp->status))
+    return FALSE;
+  switch (objp->status) {
+  case AM_NFS3_OK:
+    if (!xdr_am_CREATE3resok(xdrs, &objp->res_u.ok))
+      return FALSE;
+    break;
+  default:
+    if (!xdr_am_CREATE3resfail(xdrs, &objp->res_u.fail))
+      return FALSE;
+    break;
+  }
+  return TRUE;
+}
+
+bool_t
+xdr_am_REMOVE3args(XDR *xdrs, am_REMOVE3args *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_REMOVE3args:");
+
+  if (!xdr_am_diropargs3(xdrs, &objp->object))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_REMOVE3resok(XDR *xdrs, am_REMOVE3resok *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_REMOVE3resok:");
+
+  if (!xdr_am_wcc_data(xdrs, &objp->dir_wcc))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_REMOVE3resfail(XDR *xdrs, am_REMOVE3resfail *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_REMOVE3resfail:");
+
+  if (!xdr_am_wcc_data(xdrs, &objp->dir_wcc))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_REMOVE3res(XDR *xdrs, am_REMOVE3res *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_REMOVE3res:");
+
+  if (!xdr_am_nfsstat3(xdrs, &objp->status))
+    return FALSE;
+  switch (objp->status) {
+  case AM_NFS3_OK:
+    if (!xdr_am_REMOVE3resok(xdrs, &objp->res_u.ok))
+      return FALSE;
+    break;
+  default:
+    if (!xdr_am_REMOVE3resfail(xdrs, &objp->res_u.fail))
+      return FALSE;
+    break;
+  }
+  return TRUE;
+}
+
+bool_t
+xdr_am_READ3args(XDR *xdrs, am_READ3args *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_READ3args:");
+
+  if (!xdr_am_nfs_fh3(xdrs, &objp->file))
+    return FALSE;
+  if (!xdr_am_offset3(xdrs, &objp->offset))
+    return FALSE;
+  if (!xdr_am_count3(xdrs, &objp->count))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_READ3resok(XDR *xdrs, am_READ3resok *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_READ3resok:");
+
+  if (!xdr_am_post_op_attr(xdrs, &objp->file_attributes))
+    return FALSE;
+  if (!xdr_am_count3(xdrs, &objp->count))
+    return FALSE;
+  if (!xdr_bool(xdrs, &objp->eof))
+    return FALSE;
+  if (!xdr_bytes(xdrs, (char **)&objp->data.data_val, (u_int *) &objp->data.data_len, ~0))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_READ3resfail(XDR *xdrs, am_READ3resfail *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_READ3resfail:");
+
+  if (!xdr_am_post_op_attr(xdrs, &objp->file_attributes))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_READ3res(XDR *xdrs, am_READ3res *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_READ3res:");
+
+  if (!xdr_am_nfsstat3(xdrs, &objp->status))
+    return FALSE;
+  switch (objp->status) {
+  case AM_NFS3_OK:
+    if (!xdr_am_READ3resok(xdrs, &objp->res_u.ok))
+      return FALSE;
+    break;
+  default:
+    if (!xdr_am_READ3resfail(xdrs, &objp->res_u.fail))
+      return FALSE;
+    break;
+  }
+  return TRUE;
+}
+
+bool_t
+xdr_am_FSINFO3args(XDR *xdrs, am_FSINFO3args *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_FSINFO3args:");
+
+  if (!xdr_am_nfs_fh3(xdrs, &objp->fsroot))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_FSINFO3resok(XDR *xdrs, am_FSINFO3resok *objp)
+{
+  register int32_t *buf;
+
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_FSINFO3resok:");
+
+  if (xdrs->x_op == XDR_ENCODE) {
+    if (!xdr_am_post_op_attr(xdrs, &objp->obj_attributes))
+      return FALSE;
+    buf = XDR_INLINE(xdrs, 7 * BYTES_PER_XDR_UNIT);
+    if (buf == NULL) {
+      if (!xdr_u_int(xdrs, &objp->rtmax))
+        return FALSE;
+      if (!xdr_u_int(xdrs, &objp->rtpref))
+        return FALSE;
+      if (!xdr_u_int(xdrs, &objp->rtmult))
+        return FALSE;
+      if (!xdr_u_int(xdrs, &objp->wtmax))
+        return FALSE;
+      if (!xdr_u_int(xdrs, &objp->wtpref))
+        return FALSE;
+      if (!xdr_u_int(xdrs, &objp->wtmult))
+        return FALSE;
+      if (!xdr_u_int(xdrs, &objp->dtpref))
+        return FALSE;
+    } else {
+      IXDR_PUT_U_LONG(buf, objp->rtmax);
+      IXDR_PUT_U_LONG(buf, objp->rtpref);
+      IXDR_PUT_U_LONG(buf, objp->rtmult);
+      IXDR_PUT_U_LONG(buf, objp->wtmax);
+      IXDR_PUT_U_LONG(buf, objp->wtpref);
+      IXDR_PUT_U_LONG(buf, objp->wtmult);
+      IXDR_PUT_U_LONG(buf, objp->dtpref);
+    }
+    if (!xdr_am_size3(xdrs, &objp->maxfilesize))
+      return FALSE;
+    if (!xdr_am_nfstime3(xdrs, &objp->time_delta))
+      return FALSE;
+    if (!xdr_u_int(xdrs, &objp->properties))
+      return FALSE;
+    return TRUE;
+  } else if (xdrs->x_op == XDR_DECODE) {
+    if (!xdr_am_post_op_attr(xdrs, &objp->obj_attributes))
+      return FALSE;
+    buf = XDR_INLINE(xdrs, 7 * BYTES_PER_XDR_UNIT);
+    if (buf == NULL) {
+      if (!xdr_u_int (xdrs, &objp->rtmax))
+        return FALSE;
+      if (!xdr_u_int (xdrs, &objp->rtpref))
+        return FALSE;
+      if (!xdr_u_int (xdrs, &objp->rtmult))
+        return FALSE;
+      if (!xdr_u_int (xdrs, &objp->wtmax))
+        return FALSE;
+      if (!xdr_u_int(xdrs, &objp->wtpref))
+        return FALSE;
+      if (!xdr_u_int(xdrs, &objp->wtmult))
+        return FALSE;
+      if (!xdr_u_int(xdrs, &objp->dtpref))
+        return FALSE;
+    } else {
+      objp->rtmax = IXDR_GET_U_LONG(buf);
+      objp->rtpref = IXDR_GET_U_LONG(buf);
+      objp->rtmult = IXDR_GET_U_LONG(buf);
+      objp->wtmax = IXDR_GET_U_LONG(buf);
+      objp->wtpref = IXDR_GET_U_LONG(buf);
+      objp->wtmult = IXDR_GET_U_LONG(buf);
+      objp->dtpref = IXDR_GET_U_LONG(buf);
+    }
+    if (!xdr_am_size3(xdrs, &objp->maxfilesize))
+      return FALSE;
+    if (!xdr_am_nfstime3(xdrs, &objp->time_delta))
+      return FALSE;
+    if (!xdr_u_int(xdrs, &objp->properties))
+      return FALSE;
+    return TRUE;
+  }
+
+  if (!xdr_am_post_op_attr(xdrs, &objp->obj_attributes))
+    return FALSE;
+  if (!xdr_u_int(xdrs, &objp->rtmax))
+    return FALSE;
+  if (!xdr_u_int(xdrs, &objp->rtpref))
+    return FALSE;
+  if (!xdr_u_int(xdrs, &objp->rtmult))
+    return FALSE;
+  if (!xdr_u_int(xdrs, &objp->wtmax))
+    return FALSE;
+  if (!xdr_u_int(xdrs, &objp->wtpref))
+    return FALSE;
+  if (!xdr_u_int(xdrs, &objp->wtmult))
+    return FALSE;
+  if (!xdr_u_int(xdrs, &objp->dtpref))
+   return FALSE;
+  if (!xdr_am_size3(xdrs, &objp->maxfilesize))
+    return FALSE;
+  if (!xdr_am_nfstime3(xdrs, &objp->time_delta))
+    return FALSE;
+  if (!xdr_u_int(xdrs, &objp->properties))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_FSINFO3resfail(XDR *xdrs, am_FSINFO3resfail *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_FSINFO3resfail:");
+
+  if (!xdr_am_post_op_attr(xdrs, &objp->obj_attributes))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_FSINFO3res(XDR *xdrs, am_FSINFO3res *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_FSINFO3res:");
+
+  if (!xdr_am_nfsstat3(xdrs, &objp->status))
+    return FALSE;
+  switch (objp->status) {
+  case AM_NFS3_OK:
+    if (!xdr_am_FSINFO3resok(xdrs, &objp->res_u.ok))
+      return FALSE;
+    break;
+  default:
+    if (!xdr_am_FSINFO3resfail(xdrs, &objp->res_u.fail))
+      return FALSE;
+    break;
+  }
+  return TRUE;
+}
+
+bool_t
+xdr_am_FSSTAT3args(XDR *xdrs, am_FSSTAT3args *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_FSSTAT3args:");
+
+  if (!xdr_am_nfs_fh3(xdrs, &objp->fsroot))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_FSSTAT3resok(XDR *xdrs, am_FSSTAT3resok *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_FSSTAT3resok:");
+
+  if (!xdr_am_post_op_attr(xdrs, &objp->obj_attributes))
+    return FALSE;
+  if (!xdr_am_size3(xdrs, &objp->tbytes))
+    return FALSE;
+  if (!xdr_am_size3(xdrs, &objp->fbytes))
+    return FALSE;
+  if (!xdr_am_size3(xdrs, &objp->abytes))
+    return FALSE;
+  if (!xdr_am_size3(xdrs, &objp->tfiles))
+    return FALSE;
+  if (!xdr_am_size3(xdrs, &objp->ffiles))
+    return FALSE;
+  if (!xdr_am_size3(xdrs, &objp->afiles))
+    return FALSE;
+  if (!xdr_u_int(xdrs, &objp->invarsec))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_FSSTAT3resfail(XDR *xdrs, am_FSSTAT3resfail *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_FSSTAT3resfail:");
+
+  if (!xdr_am_post_op_attr(xdrs, &objp->obj_attributes))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_FSSTAT3res(XDR *xdrs, am_FSSTAT3res *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_FSSTAT3res:");
+
+  if (!xdr_am_nfsstat3(xdrs, &objp->status))
+    return FALSE;
+  switch (objp->status) {
+  case AM_NFS3_OK:
+    if (!xdr_am_FSSTAT3resok(xdrs, &objp->res_u.ok))
+      return FALSE;
+    break;
+  default:
+    if (!xdr_am_FSSTAT3resfail(xdrs, &objp->res_u.fail))
+      return FALSE;
+    break;
+  }
+  return TRUE;
+}
+
+bool_t
+xdr_am_PATHCONF3args(XDR *xdrs, am_PATHCONF3args *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_PATHCONF3args:");
+
+  if (!xdr_am_nfs_fh3(xdrs, &objp->object))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_PATHCONF3resok(XDR *xdrs, am_PATHCONF3resok *objp)
+{
+  register int32_t *buf;
+
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_PATHCONF3resok:");
+
+  if (xdrs->x_op == XDR_ENCODE) {
+    if (!xdr_am_post_op_attr(xdrs, &objp->obj_attributes))
+      return FALSE;
+    buf = XDR_INLINE(xdrs, 6 * BYTES_PER_XDR_UNIT);
+    if (buf == NULL) {
+      if (!xdr_u_int(xdrs, &objp->linkmax))
+        return FALSE;
+      if (!xdr_u_int(xdrs, &objp->name_max))
+        return FALSE;
+      if (!xdr_bool(xdrs, &objp->no_trunc))
+        return FALSE;
+      if (!xdr_bool(xdrs, &objp->chown_restricted))
+        return FALSE;
+      if (!xdr_bool(xdrs, &objp->case_insensitive))
+        return FALSE;
+      if (!xdr_bool(xdrs, &objp->case_preserving))
+        return FALSE;
+    } else {
+      IXDR_PUT_U_LONG(buf, objp->linkmax);
+      IXDR_PUT_U_LONG(buf, objp->name_max);
+      IXDR_PUT_BOOL(buf, objp->no_trunc);
+      IXDR_PUT_BOOL(buf, objp->chown_restricted);
+      IXDR_PUT_BOOL(buf, objp->case_insensitive);
+      IXDR_PUT_BOOL(buf, objp->case_preserving);
+    }
+    return TRUE;
+  } else if (xdrs->x_op == XDR_DECODE) {
+    if (!xdr_am_post_op_attr(xdrs, &objp->obj_attributes))
+      return FALSE;
+    buf = XDR_INLINE(xdrs, 6 * BYTES_PER_XDR_UNIT);
+    if (buf == NULL) {
+      if (!xdr_u_int(xdrs, &objp->linkmax))
+        return FALSE;
+      if (!xdr_u_int(xdrs, &objp->name_max))
+        return FALSE;
+      if (!xdr_bool(xdrs, &objp->no_trunc))
+        return FALSE;
+      if (!xdr_bool(xdrs, &objp->chown_restricted))
+        return FALSE;
+      if (!xdr_bool(xdrs, &objp->case_insensitive))
+        return FALSE;
+      if (!xdr_bool(xdrs, &objp->case_preserving))
+        return FALSE;
+    } else {
+      objp->linkmax = IXDR_GET_U_LONG(buf);
+      objp->name_max = IXDR_GET_U_LONG(buf);
+      objp->no_trunc = IXDR_GET_BOOL(buf);
+      objp->chown_restricted = IXDR_GET_BOOL(buf);
+      objp->case_insensitive = IXDR_GET_BOOL(buf);
+      objp->case_preserving = IXDR_GET_BOOL(buf);
+    }
+    return TRUE;
+  }
+
+  if (!xdr_am_post_op_attr(xdrs, &objp->obj_attributes))
+    return FALSE;
+  if (!xdr_u_int(xdrs, &objp->linkmax))
+    return FALSE;
+  if (!xdr_u_int(xdrs, &objp->name_max))
+    return FALSE;
+  if (!xdr_bool(xdrs, &objp->no_trunc))
+    return FALSE;
+  if (!xdr_bool(xdrs, &objp->chown_restricted))
+    return FALSE;
+  if (!xdr_bool(xdrs, &objp->case_insensitive))
+    return FALSE;
+  if (!xdr_bool(xdrs, &objp->case_preserving))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_PATHCONF3resfail(XDR *xdrs, am_PATHCONF3resfail *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_PATHCONF3resfail:");
+
+  if (!xdr_am_post_op_attr(xdrs, &objp->obj_attributes))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_PATHCONF3res(XDR *xdrs, am_PATHCONF3res *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_PATHCONF3res:");
+
+  if (!xdr_am_nfsstat3(xdrs, &objp->status))
+    return FALSE;
+  switch (objp->status) {
+  case AM_NFS3_OK:
+    if (!xdr_am_PATHCONF3resok(xdrs, &objp->res_u.ok))
+      return FALSE;
+    break;
+  default:
+    if (!xdr_am_PATHCONF3resfail(xdrs, &objp->res_u.fail))
+      return FALSE;
+    break;
+  }
+  return TRUE;
+}
+
+bool_t
+xdr_am_nfspath3(XDR *xdrs, am_nfspath3 *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_nfspath3:");
+
+  if (!xdr_string(xdrs, objp, ~0))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_symlinkdata3(XDR *xdrs, am_symlinkdata3 *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_symlinkdata3:");
+
+  if (!xdr_am_sattr3(xdrs, &objp->symlink_attributes))
+    return FALSE;
+  if (!xdr_am_nfspath3(xdrs, &objp->symlink_data))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_SYMLINK3args(XDR *xdrs, am_SYMLINK3args *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_SYMLINK3args:");
+
+  if (!xdr_am_diropargs3(xdrs, &objp->where))
+    return FALSE;
+  if (!xdr_am_symlinkdata3(xdrs, &objp->symlink))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_SYMLINK3resok(XDR *xdrs, am_SYMLINK3resok *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_SYMLINK3resok:");
+
+  if (!xdr_am_post_op_fh3(xdrs, &objp->obj))
+    return FALSE;
+  if (!xdr_am_post_op_attr(xdrs, &objp->obj_attributes))
+    return FALSE;
+  if (!xdr_am_wcc_data(xdrs, &objp->dir_wcc))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_SYMLINK3resfail(XDR *xdrs, am_SYMLINK3resfail *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_SYMLINK3resfail:");
+
+  if (!xdr_am_wcc_data(xdrs, &objp->dir_wcc))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_SYMLINK3res(XDR *xdrs, am_SYMLINK3res *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_SYMLINK3res:");
+
+  if (!xdr_am_nfsstat3(xdrs, &objp->status))
+    return FALSE;
+  switch (objp->status) {
+  case AM_NFS3_OK:
+    if (!xdr_am_SYMLINK3resok(xdrs, &objp->res_u.ok))
+      return FALSE;
+    break;
+  default:
+    if (!xdr_am_SYMLINK3resfail(xdrs, &objp->res_u.fail))
+      return FALSE;
+    break;
+  }
+  return TRUE;
+}
+
+bool_t
+xdr_am_READLINK3args(XDR *xdrs, am_READLINK3args *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_READLINK3args:");
+
+  if (!xdr_am_nfs_fh3(xdrs, &objp->symlink))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_READLINK3resok(XDR *xdrs, am_READLINK3resok *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_READLINK3resok:");
+
+  if (!xdr_am_post_op_attr(xdrs, &objp->symlink_attributes))
+    return FALSE;
+  if (!xdr_am_nfspath3(xdrs, &objp->data))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_READLINK3resfail(XDR *xdrs, am_READLINK3resfail *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_READLINK3resfail:");
+
+  if (!xdr_am_post_op_attr(xdrs, &objp->symlink_attributes))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_READLINK3res(XDR *xdrs, am_READLINK3res *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_READLINK3res:");
+
+  if (!xdr_am_nfsstat3(xdrs, &objp->status))
+    return FALSE;
+  switch (objp->status) {
+  case AM_NFS3_OK:
+    if (!xdr_am_READLINK3resok(xdrs, &objp->res_u.ok))
+      return FALSE;
+    break;
+  default:
+    if (!xdr_am_READLINK3resfail(xdrs, &objp->res_u.fail))
+      return FALSE;
+    break;
+  }
+  return TRUE;
+}
+
+bool_t
+xdr_am_devicedata3(XDR *xdrs, am_devicedata3 *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_devicedata3:");
+
+  if (!xdr_am_sattr3(xdrs, &objp->dev_attributes))
+    return FALSE;
+  if (!xdr_am_specdata3(xdrs, &objp->spec))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_mknoddata3(XDR *xdrs, am_mknoddata3 *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_mknoddata3:");
+
+  if (!xdr_am_ftype3(xdrs, &objp->type))
+    return FALSE;
+  switch (objp->type) {
+  case AM_NF3CHR:
+    if (!xdr_am_devicedata3(xdrs, &objp->am_mknoddata3_u.chr_device))
+      return FALSE;
+    break;
+  case AM_NF3BLK:
+    if (!xdr_am_devicedata3(xdrs, &objp->am_mknoddata3_u.blk_device))
+      return FALSE;
+    break;
+  case AM_NF3SOCK:
+    if (!xdr_am_sattr3(xdrs, &objp->am_mknoddata3_u.sock_attributes))
+      return FALSE;
+    break;
+  case AM_NF3FIFO:
+    if (!xdr_am_sattr3(xdrs, &objp->am_mknoddata3_u.pipe_attributes))
+      return FALSE;
+    break;
+  default:
+    break;
+  }
+  return TRUE;
+}
+
+bool_t
+xdr_am_MKNOD3args(XDR *xdrs, am_MKNOD3args *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_MKNOD3args:");
+
+  if (!xdr_am_diropargs3(xdrs, &objp->where))
+    return FALSE;
+  if (!xdr_am_mknoddata3(xdrs, &objp->what))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_MKNOD3resok(XDR *xdrs, am_MKNOD3resok *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_MKNOD3resok:");
+
+  if (!xdr_am_post_op_fh3(xdrs, &objp->obj))
+    return FALSE;
+  if (!xdr_am_post_op_attr(xdrs, &objp->obj_attributes))
+    return FALSE;
+  if (!xdr_am_wcc_data(xdrs, &objp->dir_wcc))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_MKNOD3resfail(XDR *xdrs, am_MKNOD3resfail *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_MKNOD3resfail:");
+
+  if (!xdr_am_wcc_data(xdrs, &objp->dir_wcc))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_MKNOD3res(XDR *xdrs, am_MKNOD3res *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, ":");
+
+  if (!xdr_am_nfsstat3(xdrs, &objp->status))
+    return FALSE;
+  switch (objp->status) {
+  case AM_NFS3_OK:
+    if (!xdr_am_MKNOD3resok(xdrs, &objp->res_u.ok))
+      return FALSE;
+    break;
+  default:
+    if (!xdr_am_MKNOD3resfail(xdrs, &objp->res_u.fail))
+      return FALSE;
+    break;
+  }
+  return TRUE;
+}
+
+bool_t
+xdr_am_MKDIR3args(XDR *xdrs, am_MKDIR3args *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, ":");
+
+  if (!xdr_am_diropargs3(xdrs, &objp->where))
+    return FALSE;
+  if (!xdr_am_sattr3(xdrs, &objp->attributes))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_MKDIR3resok(XDR *xdrs, am_MKDIR3resok *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_MKDIR3resok:");
+
+  if (!xdr_am_post_op_fh3(xdrs, &objp->obj))
+    return FALSE;
+  if (!xdr_am_post_op_attr(xdrs, &objp->obj_attributes))
+    return FALSE;
+  if (!xdr_am_wcc_data(xdrs, &objp->dir_wcc))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_MKDIR3resfail(XDR *xdrs, am_MKDIR3resfail *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_MKDIR3resfail:");
+
+  if (!xdr_am_wcc_data(xdrs, &objp->dir_wcc))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_MKDIR3res(XDR *xdrs, am_MKDIR3res *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_MKDIR3res:");
+
+  if (!xdr_am_nfsstat3(xdrs, &objp->status))
+    return FALSE;
+  switch (objp->status) {
+  case AM_NFS3_OK:
+    if (!xdr_am_MKDIR3resok(xdrs, &objp->res_u.ok))
+      return FALSE;
+    break;
+  default:
+    if (!xdr_am_MKDIR3resfail(xdrs, &objp->res_u.fail))
+      return FALSE;
+    break;
+  }
+  return TRUE;
+}
+
+bool_t
+xdr_am_RMDIR3args(XDR *xdrs, am_RMDIR3args *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_RMDIR3args:");
+
+  if (!xdr_am_diropargs3(xdrs, &objp->object))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_RMDIR3resok(XDR *xdrs, am_RMDIR3resok *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_RMDIR3resok:");
+
+  if (!xdr_am_wcc_data(xdrs, &objp->dir_wcc))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_RMDIR3resfail(XDR *xdrs, am_RMDIR3resfail *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_RMDIR3resfail:");
+
+  if (!xdr_am_wcc_data(xdrs, &objp->dir_wcc))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_RMDIR3res(XDR *xdrs, am_RMDIR3res *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_RMDIR3res:");
+
+  if (!xdr_am_nfsstat3(xdrs, &objp->status))
+    return FALSE;
+  switch (objp->status) {
+  case AM_NFS3_OK:
+    if (!xdr_am_RMDIR3resok(xdrs, &objp->res_u.ok))
+      return FALSE;
+    break;
+  default:
+    if (!xdr_am_RMDIR3resfail(xdrs, &objp->res_u.fail))
+      return FALSE;
+    break;
+  }
+  return TRUE;
+}
+
+bool_t
+xdr_am_RENAME3args(XDR *xdrs, am_RENAME3args *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_RENAME3args:");
+
+  if (!xdr_am_diropargs3(xdrs, &objp->from))
+    return FALSE;
+  if (!xdr_am_diropargs3(xdrs, &objp->to))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_RENAME3resok(XDR *xdrs, am_RENAME3resok *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_RENAME3resok:");
+
+  if (!xdr_am_wcc_data(xdrs, &objp->fromdir_wcc))
+    return FALSE;
+  if (!xdr_am_wcc_data(xdrs, &objp->todir_wcc))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_RENAME3resfail(XDR *xdrs, am_RENAME3resfail *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_RENAME3resfail:");
+
+  if (!xdr_am_wcc_data(xdrs, &objp->fromdir_wcc))
+    return FALSE;
+  if (!xdr_am_wcc_data(xdrs, &objp->todir_wcc))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_RENAME3res(XDR *xdrs, am_RENAME3res *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_RENAME3res:");
+
+  if (!xdr_am_nfsstat3(xdrs, &objp->status))
+    return FALSE;
+  switch (objp->status) {
+  case AM_NFS3_OK:
+    if (!xdr_am_RENAME3resok(xdrs, &objp->res_u.ok))
+      return FALSE;
+    break;
+  default:
+    if (!xdr_am_RENAME3resfail(xdrs, &objp->res_u.fail))
+      return FALSE;
+    break;
+  }
+  return TRUE;
+}
+
+bool_t
+xdr_am_READDIRPLUS3args(XDR *xdrs, am_READDIRPLUS3args *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_READDIRPLUS3args:");
+
+  if (!xdr_am_nfs_fh3(xdrs, &objp->dir))
+    return FALSE;
+  if (!xdr_am_cookie3(xdrs, &objp->cookie))
+    return FALSE;
+  if (!xdr_am_cookieverf3(xdrs, objp->cookieverf))
+    return FALSE;
+  if (!xdr_am_count3(xdrs, &objp->dircount))
+    return FALSE;
+  if (!xdr_am_count3(xdrs, &objp->maxcount))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_entryplus3(XDR *xdrs, am_entryplus3 *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_entryplus3:");
+
+   if (!xdr_am_fileid3(xdrs, &objp->fileid))
+     return FALSE;
+   if (!xdr_am_filename3(xdrs, &objp->name))
+     return FALSE;
+   if (!xdr_am_cookie3(xdrs, &objp->cookie))
+     return FALSE;
+   if (!xdr_am_post_op_attr(xdrs, &objp->name_attributes))
+     return FALSE;
+   if (!xdr_am_post_op_fh3(xdrs, &objp->name_handle))
+     return FALSE;
+   if (!xdr_pointer(xdrs, (char **)&objp->nextentry,
+                   sizeof(am_entryplus3), (xdrproc_t) xdr_am_entryplus3))
+     return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_dirlistplus3(XDR *xdrs, am_dirlistplus3 *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_dirlistplus3:");
+
+  if (!xdr_pointer(xdrs, (char **)&objp->entries,
+                   sizeof(am_entryplus3), (xdrproc_t) xdr_am_entryplus3))
+    return FALSE;
+  if (!xdr_bool(xdrs, &objp->eof))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_READDIRPLUS3resok(XDR *xdrs, am_READDIRPLUS3resok *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_READDIRPLUS3resok:");
+
+  if (!xdr_am_post_op_attr(xdrs, &objp->dir_attributes))
+    return FALSE;
+  if (!xdr_am_cookieverf3(xdrs, objp->cookieverf))
+    return FALSE;
+  if (!xdr_am_dirlistplus3(xdrs, &objp->reply))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_READDIRPLUS3resfail(XDR *xdrs, am_READDIRPLUS3resfail *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_READDIRPLUS3resfail:");
+
+  if (!xdr_am_post_op_attr(xdrs, &objp->dir_attributes))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_READDIRPLUS3res(XDR *xdrs, am_READDIRPLUS3res *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_READDIRPLUS3res:");
+
+  if (!xdr_am_nfsstat3(xdrs, &objp->status))
+    return FALSE;
+  switch (objp->status) {
+  case AM_NFS3_OK:
+    if (!xdr_am_READDIRPLUS3resok(xdrs, &objp->res_u.ok))
+      return FALSE;
+    break;
+  default:
+    if (!xdr_am_READDIRPLUS3resfail(xdrs, &objp->res_u.fail))
+      return FALSE;
+    break;
+  }
+  return TRUE;
+}
+
+bool_t
+xdr_am_READDIR3args(XDR *xdrs, am_READDIR3args *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_READDIR3args:");
+
+  if (!xdr_am_nfs_fh3(xdrs, &objp->dir))
+    return FALSE;
+  if (!xdr_am_cookie3(xdrs, &objp->cookie))
+    return FALSE;
+  if (!xdr_am_cookieverf3(xdrs, objp->cookieverf))
+    return FALSE;
+  if (!xdr_am_count3(xdrs, &objp->count))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_entry3(XDR *xdrs, am_entry3 *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_entry3:");
+
+  if (!xdr_am_fileid3(xdrs, &objp->fileid))
+    return FALSE;
+  if (!xdr_am_filename3(xdrs, &objp->name))
+    return FALSE;
+  if (!xdr_am_cookie3(xdrs, &objp->cookie))
+    return FALSE;
+  if (!xdr_pointer(xdrs, (char **)&objp->nextentry,
+                   sizeof(am_entry3), (xdrproc_t) xdr_am_entry3))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_dirlist3(XDR *xdrs, am_dirlist3 *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_dirlist3:");
+
+  if (!xdr_pointer(xdrs, (char **)&objp->entries,
+                   sizeof(am_entry3), (xdrproc_t) xdr_am_entry3))
+    return FALSE;
+  if (!xdr_bool (xdrs, &objp->eof))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_READDIR3resok(XDR *xdrs, am_READDIR3resok *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_READDIR3resok:");
+
+  if (!xdr_am_post_op_attr(xdrs, &objp->dir_attributes))
+    return FALSE;
+  if (!xdr_am_cookieverf3(xdrs, objp->cookieverf))
+    return FALSE;
+  if (!xdr_am_dirlist3(xdrs, &objp->reply))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_READDIR3resfail(XDR *xdrs, am_READDIR3resfail *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_READDIR3resfail:");
+
+  if (!xdr_am_post_op_attr(xdrs, &objp->dir_attributes))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_READDIR3res(XDR *xdrs, am_READDIR3res *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_READDIR3res:");
+
+  if (!xdr_am_nfsstat3(xdrs, &objp->status))
+    return FALSE;
+  switch (objp->status) {
+  case AM_NFS3_OK:
+    if (!xdr_am_READDIR3resok(xdrs, &objp->res_u.ok))
+      return FALSE;
+    break;
+  default:
+    if (!xdr_am_READDIR3resfail(xdrs, &objp->res_u.fail))
+      return FALSE;
+    break;
+  }
+  return TRUE;
+}
+
+bool_t
+xdr_am_LINK3args(XDR *xdrs, am_LINK3args *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_LINK3args:");
+
+  if (!xdr_am_nfs_fh3(xdrs, &objp->file))
+    return FALSE;
+  if (!xdr_am_diropargs3(xdrs, &objp->link))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_LINK3resok(XDR *xdrs, am_LINK3resok *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_LINK3resok:");
+
+  if (!xdr_am_post_op_attr(xdrs, &objp->file_attributes))
+    return FALSE;
+  if (!xdr_am_wcc_data(xdrs, &objp->linkdir_wcc))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_LINK3resfail(XDR *xdrs, am_LINK3resfail *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_LINK3resfail:");
+
+  if (!xdr_am_post_op_attr(xdrs, &objp->file_attributes))
+    return FALSE;
+  if (!xdr_am_wcc_data(xdrs, &objp->linkdir_wcc))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_LINK3res(XDR *xdrs, am_LINK3res *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_LINK3res:");
+
+  if (!xdr_am_nfsstat3(xdrs, &objp->status))
+    return FALSE;
+  switch (objp->status) {
+  case AM_NFS3_OK:
+    if (!xdr_am_LINK3resok(xdrs, &objp->res_u.ok))
+      return FALSE;
+    break;
+  default:
+    if (!xdr_am_LINK3resfail(xdrs, &objp->res_u.fail))
+      return FALSE;
+    break;
+  }
+  return TRUE;
+}
+
+bool_t
+xdr_am_sattrguard3(XDR *xdrs, am_sattrguard3 *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_sattrguard3:");
+
+  if (!xdr_bool(xdrs, &objp->check))
+    return FALSE;
+  switch (objp->check) {
+  case TRUE:
+    if (!xdr_am_nfstime3(xdrs, &objp->am_sattrguard3_u.obj_ctime))
+      return FALSE;
+    break;
+  case FALSE:
+    break;
+  default:
+    return FALSE;
+  }
+  return TRUE;
+}
+
+bool_t
+xdr_am_SETATTR3args(XDR *xdrs, am_SETATTR3args *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_SETATTR3args:");
+
+  if (!xdr_am_nfs_fh3(xdrs, &objp->object))
+    return FALSE;
+  if (!xdr_am_sattr3(xdrs, &objp->new_attributes))
+    return FALSE;
+  if (!xdr_am_sattrguard3(xdrs, &objp->guard))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_SETATTR3resok(XDR *xdrs, am_SETATTR3resok *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_SETATTR3resok:");
+
+  if (!xdr_am_wcc_data(xdrs, &objp->obj_wcc))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_SETATTR3resfail(XDR *xdrs, am_SETATTR3resfail *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_SETATTR3resfail:");
+
+  if (!xdr_am_wcc_data(xdrs, &objp->obj_wcc))
+    return FALSE;
+  return TRUE;
+}
+
+bool_t
+xdr_am_SETATTR3res(XDR *xdrs, am_SETATTR3res *objp)
+{
+  if (amuDebug(D_XDRTRACE))
+    plog(XLOG_DEBUG, "xdr_am_SETATTR3res:");
+
+  if (!xdr_am_nfsstat3(xdrs, &objp->status))
+    return FALSE;
+  switch (objp->status) {
+  case AM_NFS3_OK:
+    if (!xdr_am_SETATTR3resok(xdrs, &objp->res_u.ok))
+      return FALSE;
+    break;
+  default:
+    if (!xdr_am_SETATTR3resfail(xdrs, &objp->res_u.fail))
+      return FALSE;
+    break;
+  }
+  return TRUE;
 }
-#endif /* not HAVE_FS_NFS3 */
+#endif /* HAVE_FS_NFS3 */
diff --git a/contrib/amd/libamu/xutil.c b/contrib/amd/libamu/xutil.c
index 3a33b9c..1159fe5 100644
--- a/contrib/amd/libamu/xutil.c
+++ b/contrib/amd/libamu/xutil.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997-2006 Erez Zadok
+ * 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.
@@ -16,11 +16,7 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgment:
- *      This product includes software developed by the University of
- *      California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
+ * 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.
  *
@@ -63,14 +59,13 @@ static char am_hostname[MAXHOSTNAMELEN] = "unknown"; /* Hostname */
 pid_t am_mypid = -1;		/* process ID */
 serv_state amd_state;		/* amd's state */
 int foreground = 1;		/* 1 == this is the top-level server */
-int debug_flags = 0;
+u_int debug_flags = D_CONTROL;	/* set regardless if compiled with debugging */
 
 #ifdef HAVE_SYSLOG
 int syslogging;
 #endif /* HAVE_SYSLOG */
-int xlog_level = XLOG_ALL & ~XLOG_MAP & ~XLOG_STATS;
-int xlog_level_init = ~0;
-static int amd_program_number = AMQ_PROGRAM;
+static u_int xlog_level = XLOG_DEFAULT;
+static u_long amd_program_number = AMQ_PROGRAM;
 
 #ifdef DEBUG_MEM
 # if defined(HAVE_MALLINFO) && defined(HAVE_MALLOC_VERIFY)
@@ -92,23 +87,23 @@ static void real_plog(int lvl, const char *fmt, va_list vargs)
 struct opt_tab dbg_opt[] =
 {
   {"all", D_ALL},		/* All non-disruptive options */
-  {"amq", D_AMQ},		/* Don't register for AMQ program */
-  {"daemon", D_DAEMON},		/* Don't enter daemon mode */
-  {"fork", D_FORK},		/* Don't fork server */
+  {"defaults", D_DEFAULT},	/* Default options */
+  {"test", D_TEST},		/* Full debug - no daemon, no fork, no amq, local mtab */
+  {"amq", D_AMQ},		/* Register for AMQ program */
+  {"daemon", D_DAEMON},		/* Enter daemon mode */
+  {"fork", D_FORK},		/* Fork server (hlfsd only) */
   {"full", D_FULL},		/* Program trace */
 #ifdef HAVE_CLOCK_GETTIME
   {"hrtime", D_HRTIME},		/* Print high resolution time stamps */
 #endif /* HAVE_CLOCK_GETTIME */
-  /* info service specific debugging (hesiod, nis, etc) */
-  {"info", D_INFO},
+  {"info", D_INFO},		/* info service specific debugging (hesiod, nis, etc) */
   {"mem", D_MEM},		/* Trace memory allocations */
   {"mtab", D_MTAB},		/* Use local mtab file */
   {"readdir", D_READDIR},	/* Check on browsable_dirs progress */
   {"str", D_STR},		/* Debug string munging */
-  {"test", D_TEST},		/* Full debug - no daemon, no amq, local mtab */
   {"trace", D_TRACE},		/* Protocol trace */
   {"xdrtrace", D_XDRTRACE},	/* Trace xdr routines */
-  {0, 0}
+  {NULL, 0}
 };
 #endif /* DEBUG */
 
@@ -118,6 +113,7 @@ struct opt_tab dbg_opt[] =
 struct opt_tab xlog_opt[] =
 {
   {"all", XLOG_ALL},		/* All messages */
+  {"defaults", XLOG_DEFAULT},	/* Default messages */
 #ifdef DEBUG
   {"debug", XLOG_DEBUG},	/* Debug messages */
 #endif /* DEBUG */		/* DEBUG */
@@ -129,7 +125,7 @@ struct opt_tab xlog_opt[] =
   {"user", XLOG_USER},		/* Non-fatal user errors */
   {"warn", XLOG_WARNING},	/* Warnings */
   {"warning", XLOG_WARNING},	/* Warnings */
-  {0, 0}
+  {NULL, 0}
 };
 
 
@@ -150,7 +146,7 @@ am_get_progname(void)
 void
 am_set_hostname(char *hn)
 {
-  xstrlcpy(am_hostname, hn, MAXHOSTNAMELEN);
+  xstrlcpy(am_hostname, hn, sizeof(am_hostname));
 }
 
 
@@ -295,17 +291,23 @@ expand_error(const char *f, char *e, size_t maxlen)
   const char *p;
   char *q;
   int error = errno;
-  int len = 0;
+  size_t len = 0, l;
 
-  for (p = f, q = e; (*q = *p) && (size_t) len < maxlen; len++, q++, p++) {
+  *e = '\0';
+  for (p = f, q = e; len < maxlen && (*q = *p); len++, q++, p++) {
     if (p[0] == '%' && p[1] == 'm') {
-      xstrlcpy(q, strerror(error), maxlen);
-      len += strlen(q) - 1;
-      q += strlen(q) - 1;
+      if (len >= maxlen)
+	break;
+      xstrlcpy(q, strerror(error), maxlen - len);
+      l = strlen(q);
+      if (l != 0)
+	  l--;
+      len += l;
+      q += l;
       p++;
     }
   }
-  e[maxlen-1] = '\0';		/* null terminate, to be sure */
+  e[maxlen - 1] = '\0';		/* null terminate, to be sure */
   return e;
 }
 
@@ -317,7 +319,7 @@ static void
 show_time_host_and_name(int lvl)
 {
   static time_t last_t = 0;
-  static char *last_ctime = 0;
+  static char *last_ctime = NULL;
   time_t t;
 #if defined(HAVE_CLOCK_GETTIME) && defined(DEBUG)
   struct timespec ts;
@@ -390,21 +392,63 @@ show_time_host_and_name(int lvl)
 int
 debug_option(char *opt)
 {
-  return cmdoption(opt, dbg_opt, &debug_flags);
+  u_int dl = debug_flags;
+  static int initialized_debug_flags = 0;
+  int rc = cmdoption(opt, dbg_opt, &dl);
+
+  if (rc)		    /* if got any error, don't update debug flags */
+    return EINVAL;
+
+  /*
+   * If we already initialized the debugging flags once (via amd.conf), then
+   * don't allow "immutable" flags to be changed again (via amq -D), because
+   * they could mess Amd's state and only make sense to be set once when Amd
+   * starts.
+   */
+  if (initialized_debug_flags &&
+      debug_flags != 0 &&
+      (dl & D_IMMUTABLE) != (debug_flags & D_IMMUTABLE)) {
+    plog(XLOG_ERROR, "cannot change immutable debug flags");
+    /* undo any attempted change to an immutable flag */
+    dl = (dl & ~D_IMMUTABLE) | (debug_flags & D_IMMUTABLE);
+  }
+  initialized_debug_flags = 1;
+  debug_flags = dl;
+
+  return rc;
 }
 
 
 void
 dplog(const char *fmt, ...)
 {
+#ifdef HAVE_SIGACTION
+  sigset_t old, chld;
+#else /* not HAVE_SIGACTION */
+  int mask;
+#endif /* not HAVE_SIGACTION */
   va_list ap;
 
+#ifdef HAVE_SIGACTION
+  sigemptyset(&chld);
+  sigaddset(&chld, SIGCHLD);
+#else /* not HAVE_SIGACTION */
+  mask = sigblock(sigmask(SIGCHLD));
+#endif /* not HAVE_SIGACTION */
+
+  sigprocmask(SIG_BLOCK, &chld, &old);
   if (!logfp)
     logfp = stderr;		/* initialize before possible first use */
 
   va_start(ap, fmt);
   real_plog(XLOG_DEBUG, fmt, ap);
   va_end(ap);
+
+#ifdef HAVE_SIGACTION
+  sigprocmask(SIG_SETMASK, &old, NULL);
+#else /* not HAVE_SIGACTION */
+  mask = sigblock(sigmask(SIGCHLD));
+#endif /* not HAVE_SIGACTION */
 }
 #endif /* DEBUG */
 
@@ -412,14 +456,33 @@ dplog(const char *fmt, ...)
 void
 plog(int lvl, const char *fmt, ...)
 {
+#ifdef HAVE_SIGACTION
+  sigset_t old, chld;
+#else /* not HAVE_SIGACTION */
+  int mask;
+#endif /* not HAVE_SIGACTION */
   va_list ap;
 
+#ifdef HAVE_SIGACTION
+  sigemptyset(&chld);
+  sigaddset(&chld, SIGCHLD);
+  sigprocmask(SIG_BLOCK, &chld, &old);
+#else /* not HAVE_SIGACTION */
+  mask = sigblock(sigmask(SIGCHLD));
+#endif /* not HAVE_SIGACTION */
+
   if (!logfp)
     logfp = stderr;		/* initialize before possible first use */
 
   va_start(ap, fmt);
   real_plog(lvl, fmt, ap);
   va_end(ap);
+
+#ifdef HAVE_SIGACTION
+  sigprocmask(SIG_SETMASK, &old, NULL);
+#else /* not HAVE_SIGACTION */
+  sigsetmask(mask);
+#endif /* not HAVE_SIGACTION */
 }
 
 
@@ -497,11 +560,11 @@ real_plog(int lvl, const char *fmt, va_list vargs)
   switch (last_count) {
   case 0:			/* never printed at all */
     last_count = 1;
-    if (strlcpy(last_msg, msg, 1024) >= 1024) /* don't use xstrlcpy here (recursive!) */
+    if (strlcpy(last_msg, msg, sizeof(last_msg)) >= sizeof(last_msg)) /* don't use xstrlcpy here (recursive!) */
       fprintf(stderr, "real_plog: string \"%s\" truncated to \"%s\"\n", last_msg, msg);
     last_lvl = lvl;
     show_time_host_and_name(lvl); /* mimic syslog header */
-    fwrite(msg, ptr - msg, 1, logfp);
+    __IGNORE(fwrite(msg, ptr - msg, 1, logfp));
     fflush(logfp);
     break;
 
@@ -510,11 +573,11 @@ real_plog(int lvl, const char *fmt, va_list vargs)
       last_count++;
     } else {			/* last msg printed once, new one differs */
       /* last_count remains at 1 */
-      if (strlcpy(last_msg, msg, 1024) >= 1024) /* don't use xstrlcpy here (recursive!) */
+      if (strlcpy(last_msg, msg, sizeof(last_msg)) >= sizeof(last_msg)) /* don't use xstrlcpy here (recursive!) */
 	fprintf(stderr, "real_plog: string \"%s\" truncated to \"%s\"\n", last_msg, msg);
       last_lvl = lvl;
       show_time_host_and_name(lvl); /* mimic syslog header */
-      fwrite(msg, ptr - msg, 1, logfp);
+      __IGNORE(fwrite(msg, ptr - msg, 1, logfp));
       fflush(logfp);
     }
     break;
@@ -527,7 +590,7 @@ real_plog(int lvl, const char *fmt, va_list vargs)
     show_time_host_and_name(last_lvl);
     xsnprintf(last_msg, sizeof(last_msg),
 	      "last message repeated %d times\n", last_count);
-    fwrite(last_msg, strlen(last_msg), 1, logfp);
+    __IGNORE(fwrite(last_msg, strlen(last_msg), 1, logfp));
     fflush(logfp);
     last_count = 0;		/* start from scratch */
     break;
@@ -539,13 +602,13 @@ real_plog(int lvl, const char *fmt, va_list vargs)
       show_time_host_and_name(last_lvl);
       xsnprintf(last_msg, sizeof(last_msg),
 		"last message repeated %d times\n", last_count);
-      fwrite(last_msg, strlen(last_msg), 1, logfp);
+      __IGNORE(fwrite(last_msg, strlen(last_msg), 1, logfp));
       if (strlcpy(last_msg, msg, 1024) >= 1024) /* don't use xstrlcpy here (recursive!) */
 	fprintf(stderr, "real_plog: string \"%s\" truncated to \"%s\"\n", last_msg, msg);
       last_count = 1;
       last_lvl = lvl;
       show_time_host_and_name(lvl); /* mimic syslog header */
-      fwrite(msg, ptr - msg, 1, logfp);
+      __IGNORE(fwrite(msg, ptr - msg, 1, logfp));
       fflush(logfp);
     }
     break;
@@ -573,7 +636,7 @@ show_opts(int ch, struct opt_tab *opts)
 
 
 int
-cmdoption(char *s, struct opt_tab *optb, int *flags)
+cmdoption(char *s, struct opt_tab *optb, u_int *flags)
 {
   char *p = s;
   int errs = 0;
@@ -581,7 +644,7 @@ cmdoption(char *s, struct opt_tab *optb, int *flags)
   while (p && *p) {
     int neg;
     char *opt;
-    struct opt_tab *dp, *dpn = 0;
+    struct opt_tab *dp, *dpn = NULL;
 
     s = p;
     p = strchr(p, ',');
@@ -624,7 +687,7 @@ cmdoption(char *s, struct opt_tab *optb, int *flags)
        * This will log to stderr when parsing the command line
        * since any -l option will not yet have taken effect.
        */
-      plog(XLOG_USER, "option \"%s\" not recognized", s);
+      plog(XLOG_ERROR, "option \"%s\" not recognized", s);
       errs++;
     }
 
@@ -645,22 +708,22 @@ cmdoption(char *s, struct opt_tab *optb, int *flags)
 int
 switch_option(char *opt)
 {
-  int xl = xlog_level;
+  u_int xl = xlog_level;
   int rc = cmdoption(opt, xlog_opt, &xl);
 
-  if (rc) {
-    rc = EINVAL;
-  } else {
-    /*
-     * Keep track of initial log level, and
-     * don't allow options to be turned off.
-     */
-    if (xlog_level_init == ~0)
-      xlog_level_init = xl;
-    else
-      xl |= xlog_level_init;
-    xlog_level = xl;
+  if (rc)			/* if got any error, don't update flags */
+    return EINVAL;
+
+  /*
+   * Don't allow "mandatory" flags to be turned off, because
+   * we must always be able to report on flag re/setting errors.
+   */
+  if ((xl & XLOG_MANDATORY) != XLOG_MANDATORY) {
+    plog(XLOG_ERROR, "cannot turn off mandatory logging options");
+    xl |= XLOG_MANDATORY;
   }
+  if (xlog_level != xl)
+    xlog_level = xl;		/* set new flags */
   return rc;
 }
 
@@ -801,7 +864,7 @@ switch_to_logfile(char *logfile, int old_umask, int truncate_log)
     } else {			/* regular log file */
       (void) umask(old_umask);
       if (truncate_log)
-	truncate(logfile, 0);
+	__IGNORE(truncate(logfile, 0));
       new_logfp = fopen(logfile, "a");
       umask(0);
     }
@@ -834,7 +897,8 @@ switch_to_logfile(char *logfile, int old_umask, int truncate_log)
 void
 unregister_amq(void)
 {
-  if (!amuDebug(D_AMQ)) {
+
+  if (amuDebug(D_AMQ)) {
     /* find which instance of amd to unregister */
     u_long amd_prognum = get_amd_program_number();
 
@@ -875,7 +939,7 @@ going_down(int rc)
 
 
 /* return the rpc program number under which amd was used */
-int
+u_long
 get_amd_program_number(void)
 {
   return amd_program_number;
@@ -884,7 +948,7 @@ get_amd_program_number(void)
 
 /* set the rpc program number used for amd */
 void
-set_amd_program_number(int program)
+set_amd_program_number(u_long program)
 {
   amd_program_number = program;
 }
@@ -955,9 +1019,9 @@ amu_release_controlling_tty(void)
     close(fd);
   }
   return;
-#endif /* not TIOCNOTTY */
-
+#else
   plog(XLOG_ERROR, "unable to release controlling tty");
+#endif /* not TIOCNOTTY */
 }
 
 
@@ -1012,7 +1076,7 @@ mkdirs(char *path, int mode)
   /*
    * take a copy in case path is in readonly store
    */
-  char *p2 = strdup(path);
+  char *p2 = xstrdup(path);
   char *sp = p2;
   struct stat stb;
   int error_so_far = 0;
@@ -1056,7 +1120,7 @@ mkdirs(char *path, int mode)
 void
 rmdirs(char *dir)
 {
-  char *xdp = strdup(dir);
+  char *xdp = xstrdup(dir);
   char *dp;
 
   do {
@@ -1089,3 +1153,15 @@ rmdirs(char *dir)
 
   XFREE(xdp);
 }
+
+/*
+ * Dup a string
+ */
+char *
+xstrdup(const char *s)
+{
+  size_t len = strlen(s);
+  char *sp = xmalloc(len + 1);
+  memcpy(sp, s, len + 1);
+  return sp;
+}
author	cy <cy@FreeBSD.org>	2016-12-23 22:42:14 +0000
committer	cy <cy@FreeBSD.org>	2016-12-23 22:42:14 +0000
commit	78047153f3f320f60a8264a8a33abb8636dbfc7c (patch)
tree	53c2e7da97b30a23be5e4d8f0bb2a8b5e5670e1c /contrib/amd/libamu
parent	bff6b519ae43ad35a81ea361a71b814e97a51c7c (diff)
download	FreeBSD-src-78047153f3f320f60a8264a8a33abb8636dbfc7c.zip FreeBSD-src-78047153f3f320f60a8264a8a33abb8636dbfc7c.tar.gz