changeset 17381:915d2ad64b47

qacl: new module, broken out from the acl module This is for GNU Emacs, which wants the acl functions but does not want 'error' invoked when they fail. * lib/acl-internal.h: Do not include error.h, quote.h. (ENOSYS, ENOTSUP): Remove; no longer needed. (ACL_NOT_WELL_SUPPORTED): Remove; replaced by acl_errno_valid. * lib/acl.h: Include <stdbool.h>. (acl_errno_valid): New function. * lib/copy-acl.c, lib/set-acl.c: Include errno,h, not acl-internal.h. * lib/copy-acl.c (qcopy_acl): Move to lib/qcopy-acl.c. * lib/set-acl.c: Rename from lib/set-mode-acl.c. (chmod_or_fchmod, qset_acl): Move to lib/qset-acl.c. (ACL_INTERNAL_INLINE): Remove; no longer needed. * lib/file-has-acl.c (file_has_acl): * lib/qcopy-acl.c (qcopy_acl): * lib/qset-acl.c (qset_acl): Use acl_errno_valid instead of ACL_NOT_WELL_SUPPORTED. * modules/acl (Files): Move lib/acl.h, lib/acl-internal.h, lib/acl_entries.c, lib/set-mode-acl.c (renamed to lib/set-acl.c), lib/file-has-acl.c, m4/acl.m4 to qacl module. Add lib/set-acl.c. (Depends-on): Move extern-inline, fstat, sys_stat to qacl module. Add qacl. (configure.ac): Move gl_FUNC_ACL to qacl module. (lib_SOURCES): Remove file-has-acl.c (moved to qacl module). Rename set-mode-acl.c to set-acl.c. * lib/acl-errno-valid.c: New file. * lib/qcopy-acl.c: New file, moved from the old lib/copy-acl.c; the copy_acl function remains in copy-acl.c. * lib/qcopy-acl.c, lib/qset-acl.c: Do not include gettext.h. (_): Remove; not needed. * lib/qset-acl.c: New file, moved from the old lib/set-mode-acl.c; the set_acl function remains in set-acl.c (renamed from set-mode-acl.c). * modules/qacl: New file, moved from the old modules/acl. (Files, lib_SOURCES): Add acl-errno-valid.c, qcopy-acl.c, qset-acl.c. Remove set-mode-acl.c, copy-acl.c. (Depends-on): Remove error, gettext-h, quote. Add stdbool.
author Paul Eggert <eggert@cs.ucla.edu>
date Sat, 27 Apr 2013 17:39:07 -0700
parents 2278c530e565
children 8826dc2ee3ee
files ChangeLog lib/acl-errno-valid.c lib/acl-internal.h lib/acl.h lib/copy-acl.c lib/file-has-acl.c lib/qcopy-acl.c lib/qset-acl.c lib/set-acl.c lib/set-mode-acl.c modules/acl modules/qacl
diffstat 12 files changed, 1434 insertions(+), 1295 deletions(-) [+]
line wrap: on
line diff
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,43 @@
 2013-04-27  Paul Eggert  <eggert@cs.ucla.edu>
 
+	qacl: new module, broken out from the acl module
+	This is for GNU Emacs, which wants the acl functions but does
+	not want 'error' invoked when they fail.
+	* lib/acl-internal.h: Do not include error.h, quote.h.
+	(ENOSYS, ENOTSUP): Remove; no longer needed.
+	(ACL_NOT_WELL_SUPPORTED): Remove; replaced by acl_errno_valid.
+	* lib/acl.h: Include <stdbool.h>.
+	(acl_errno_valid): New function.
+	* lib/copy-acl.c, lib/set-acl.c: Include errno,h, not acl-internal.h.
+	* lib/copy-acl.c (qcopy_acl): Move to lib/qcopy-acl.c.
+	* lib/set-acl.c: Rename from lib/set-mode-acl.c.
+	(chmod_or_fchmod, qset_acl): Move to lib/qset-acl.c.
+	(ACL_INTERNAL_INLINE): Remove; no longer needed.
+	* lib/file-has-acl.c (file_has_acl):
+	* lib/qcopy-acl.c (qcopy_acl):
+	* lib/qset-acl.c (qset_acl):
+	Use acl_errno_valid instead of ACL_NOT_WELL_SUPPORTED.
+	* modules/acl (Files): Move lib/acl.h, lib/acl-internal.h,
+	lib/acl_entries.c, lib/set-mode-acl.c (renamed to lib/set-acl.c),
+	lib/file-has-acl.c, m4/acl.m4 to qacl module.
+	Add lib/set-acl.c.
+	(Depends-on): Move extern-inline, fstat, sys_stat to qacl module.
+	Add qacl.
+	(configure.ac): Move gl_FUNC_ACL to qacl module.
+	(lib_SOURCES): Remove file-has-acl.c (moved to qacl module).
+	Rename set-mode-acl.c to set-acl.c.
+	* lib/acl-errno-valid.c: New file.
+	* lib/qcopy-acl.c: New file, moved from the old lib/copy-acl.c; the
+	copy_acl function remains in copy-acl.c.
+	* lib/qcopy-acl.c, lib/qset-acl.c: Do not include gettext.h.
+	(_): Remove; not needed.
+	* lib/qset-acl.c: New file, moved from the old lib/set-mode-acl.c; the
+	set_acl function remains in set-acl.c (renamed from set-mode-acl.c).
+	* modules/qacl: New file, moved from the old modules/acl.
+	(Files, lib_SOURCES): Add acl-errno-valid.c, qcopy-acl.c, qset-acl.c.
+	Remove set-mode-acl.c, copy-acl.c.
+	(Depends-on): Remove error, gettext-h, quote.  Add stdbool.
+
 	alignof, intprops, malloca: port better to IBM's C compiler
 	* lib/alignof.h (alignof_type) [__IBM_ALIGNOF__]: Use __alignof__.
 	* lib/intprops.h (_GL_HAVE___TYPEOF__) [__IBM_TYPEOF__]: Now 1.
new file mode 100644
--- /dev/null
+++ b/lib/acl-errno-valid.c
@@ -0,0 +1,48 @@
+/* Test whether ACLs are well supported on this system.
+
+   Copyright 2013 Free Software Foundation, Inc.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   Written by Paul Eggert.  */
+
+#include <config.h>
+
+#include <acl.h>
+
+#include <errno.h>
+
+/* Return true if errno value ERRNUM indicates that ACLs are well
+   supported on this system.  ERRNUM should be an errno value obtained
+   after an ACL-related system call fails.  */
+bool
+acl_errno_valid (int errnum)
+{
+  /* Recognize some common errors such as from an NFS mount that does
+     not support ACLs, even when local drives do.  */
+  switch (errnum)
+    {
+    case EBUSY: return false;
+    case EINVAL: return false;
+#if defined __APPLE__ && defined __MACH__
+    case ENOENT: return false;
+#endif
+    case ENOSYS: return false;
+#if defined ENOTSUP && ENOTSUP != EOPNOTSUPP
+    case ENOTSUP: return false;
+#endif
+    case EOPNOTSUPP: return false;
+    default: return true;
+    }
+}
--- a/lib/acl-internal.h
+++ b/lib/acl-internal.h
@@ -44,16 +44,7 @@
 extern int aclsort (int, int, struct acl *);
 #endif
 
-#include "error.h"
-#include "quote.h"
-
 #include <errno.h>
-#ifndef ENOSYS
-# define ENOSYS (-1)
-#endif
-#ifndef ENOTSUP
-# define ENOTSUP (-1)
-#endif
 
 #include <limits.h>
 #ifndef MIN
@@ -69,19 +60,6 @@
 # define fchmod(fd, mode) (-1)
 #endif
 
-/* Recognize some common errors such as from an NFS mount that does
-   not support ACLs, even when local drives do.  */
-#if defined __APPLE__ && defined __MACH__ /* Mac OS X */
-# define ACL_NOT_WELL_SUPPORTED(Err) \
-     ((Err) == ENOTSUP || (Err) == ENOSYS || (Err) == EINVAL || (Err) == EBUSY || (Err) == ENOENT)
-#elif defined EOPNOTSUPP /* Tru64 NFS */
-# define ACL_NOT_WELL_SUPPORTED(Err) \
-     ((Err) == ENOTSUP || (Err) == ENOSYS || (Err) == EINVAL || (Err) == EBUSY || (Err) == EOPNOTSUPP)
-#else
-# define ACL_NOT_WELL_SUPPORTED(Err) \
-     ((Err) == ENOTSUP || (Err) == ENOSYS || (Err) == EINVAL || (Err) == EBUSY)
-#endif
-
 _GL_INLINE_HEADER_BEGIN
 #ifndef ACL_INTERNAL_INLINE
 # define ACL_INTERNAL_INLINE _GL_INLINE
--- a/lib/acl.h
+++ b/lib/acl.h
@@ -17,9 +17,11 @@
 
    Written by Paul Eggert.  */
 
+#include <stdbool.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 
+bool acl_errno_valid (int) _GL_ATTRIBUTE_CONST;
 int file_has_acl (char const *, struct stat const *);
 int qset_acl (char const *, int, mode_t);
 int set_acl (char const *, int, mode_t);
--- a/lib/copy-acl.c
+++ b/lib/copy-acl.c
@@ -21,8 +21,7 @@
 
 #include "acl.h"
 
-#include "acl-internal.h"
-
+#include "error.h"
 #include "gettext.h"
 #define _(msgid) gettext (msgid)
 
@@ -34,565 +33,6 @@
    If access control lists are not available, fchmod the target file to
    MODE.  Also sets the non-permission bits of the destination file
    (S_ISUID, S_ISGID, S_ISVTX) to those from MODE if any are set.
-   Return 0 if successful.
-   Return -2 and set errno for an error relating to the source file.
-   Return -1 and set errno for an error relating to the destination file.  */
-
-int
-qcopy_acl (const char *src_name, int source_desc, const char *dst_name,
-           int dest_desc, mode_t mode)
-{
-#if USE_ACL && HAVE_ACL_GET_FILE
-  /* POSIX 1003.1e (draft 17 -- abandoned) specific version.  */
-  /* Linux, FreeBSD, Mac OS X, IRIX, Tru64 */
-# if !HAVE_ACL_TYPE_EXTENDED
-  /* Linux, FreeBSD, IRIX, Tru64 */
-
-  acl_t acl;
-  int ret;
-
-  if (HAVE_ACL_GET_FD && source_desc != -1)
-    acl = acl_get_fd (source_desc);
-  else
-    acl = acl_get_file (src_name, ACL_TYPE_ACCESS);
-  if (acl == NULL)
-    {
-      if (ACL_NOT_WELL_SUPPORTED (errno))
-        return qset_acl (dst_name, dest_desc, mode);
-      else
-        return -2;
-    }
-
-  if (HAVE_ACL_SET_FD && dest_desc != -1)
-    ret = acl_set_fd (dest_desc, acl);
-  else
-    ret = acl_set_file (dst_name, ACL_TYPE_ACCESS, acl);
-  if (ret != 0)
-    {
-      int saved_errno = errno;
-
-      if (ACL_NOT_WELL_SUPPORTED (errno) && !acl_access_nontrivial (acl))
-        {
-          acl_free (acl);
-          return chmod_or_fchmod (dst_name, dest_desc, mode);
-        }
-      else
-        {
-          acl_free (acl);
-          chmod_or_fchmod (dst_name, dest_desc, mode);
-          errno = saved_errno;
-          return -1;
-        }
-    }
-  else
-    acl_free (acl);
-
-  if (!MODE_INSIDE_ACL || (mode & (S_ISUID | S_ISGID | S_ISVTX)))
-    {
-      /* We did not call chmod so far, and either the mode and the ACL are
-         separate or special bits are to be set which don't fit into ACLs.  */
-
-      if (chmod_or_fchmod (dst_name, dest_desc, mode) != 0)
-        return -1;
-    }
-
-  if (S_ISDIR (mode))
-    {
-      acl = acl_get_file (src_name, ACL_TYPE_DEFAULT);
-      if (acl == NULL)
-        return -2;
-
-      if (acl_set_file (dst_name, ACL_TYPE_DEFAULT, acl))
-        {
-          int saved_errno = errno;
-
-          acl_free (acl);
-          errno = saved_errno;
-          return -1;
-        }
-      else
-        acl_free (acl);
-    }
-  return 0;
-
-# else /* HAVE_ACL_TYPE_EXTENDED */
-  /* Mac OS X */
-
-  /* On Mac OS X,  acl_get_file (name, ACL_TYPE_ACCESS)
-     and           acl_get_file (name, ACL_TYPE_DEFAULT)
-     always return NULL / EINVAL.  You have to use
-                   acl_get_file (name, ACL_TYPE_EXTENDED)
-     or            acl_get_fd (open (name, ...))
-     to retrieve an ACL.
-     On the other hand,
-                   acl_set_file (name, ACL_TYPE_ACCESS, acl)
-     and           acl_set_file (name, ACL_TYPE_DEFAULT, acl)
-     have the same effect as
-                   acl_set_file (name, ACL_TYPE_EXTENDED, acl):
-     Each of these calls sets the file's ACL.  */
-
-  acl_t acl;
-  int ret;
-
-  if (HAVE_ACL_GET_FD && source_desc != -1)
-    acl = acl_get_fd (source_desc);
-  else
-    acl = acl_get_file (src_name, ACL_TYPE_EXTENDED);
-  if (acl == NULL)
-    {
-      if (ACL_NOT_WELL_SUPPORTED (errno))
-        return qset_acl (dst_name, dest_desc, mode);
-      else
-        return -2;
-    }
-
-  if (HAVE_ACL_SET_FD && dest_desc != -1)
-    ret = acl_set_fd (dest_desc, acl);
-  else
-    ret = acl_set_file (dst_name, ACL_TYPE_EXTENDED, acl);
-  if (ret != 0)
-    {
-      int saved_errno = errno;
-
-      if (ACL_NOT_WELL_SUPPORTED (errno) && !acl_extended_nontrivial (acl))
-        {
-          acl_free (acl);
-          return chmod_or_fchmod (dst_name, dest_desc, mode);
-        }
-      else
-        {
-          acl_free (acl);
-          chmod_or_fchmod (dst_name, dest_desc, mode);
-          errno = saved_errno;
-          return -1;
-        }
-    }
-  else
-    acl_free (acl);
-
-  /* Since !MODE_INSIDE_ACL, we have to call chmod explicitly.  */
-  return chmod_or_fchmod (dst_name, dest_desc, mode);
-
-# endif
-
-#elif USE_ACL && defined GETACL /* Solaris, Cygwin, not HP-UX */
-
-  /* Solaris 2.5 through Solaris 10, Cygwin, and contemporaneous versions
-     of Unixware.  The acl() call returns the access and default ACL both
-     at once.  */
-# ifdef ACE_GETACL
-  int ace_count;
-  ace_t *ace_entries;
-# endif
-  int count;
-  aclent_t *entries;
-  int did_chmod;
-  int saved_errno;
-  int ret;
-
-# ifdef ACE_GETACL
-  /* Solaris also has a different variant of ACLs, used in ZFS and NFSv4
-     file systems (whereas the other ones are used in UFS file systems).
-     There is an API
-       pathconf (name, _PC_ACL_ENABLED)
-       fpathconf (desc, _PC_ACL_ENABLED)
-     that allows to determine which of the two kinds of ACLs is supported
-     for the given file.  But some file systems may implement this call
-     incorrectly, so better not use it.
-     When fetching the source ACL, we simply fetch both ACL types.
-     When setting the destination ACL, we try either ACL types, assuming
-     that the kernel will translate the ACL from one form to the other.
-     (See in <http://docs.sun.com/app/docs/doc/819-2241/6n4huc7ia?l=en&a=view>
-     the description of ENOTSUP.)  */
-  for (;;)
-    {
-      ace_count = (source_desc != -1
-                   ? facl (source_desc, ACE_GETACLCNT, 0, NULL)
-                   : acl (src_name, ACE_GETACLCNT, 0, NULL));
-
-      if (ace_count < 0)
-        {
-          if (errno == ENOSYS || errno == EINVAL)
-            {
-              ace_count = 0;
-              ace_entries = NULL;
-              break;
-            }
-          else
-            return -2;
-        }
-
-      if (ace_count == 0)
-        {
-          ace_entries = NULL;
-          break;
-        }
-
-      ace_entries = (ace_t *) malloc (ace_count * sizeof (ace_t));
-      if (ace_entries == NULL)
-        {
-          errno = ENOMEM;
-          return -2;
-        }
-
-      ret = (source_desc != -1
-             ? facl (source_desc, ACE_GETACL, ace_count, ace_entries)
-             : acl (src_name, ACE_GETACL, ace_count, ace_entries));
-      if (ret < 0)
-        {
-          free (ace_entries);
-          if (errno == ENOSYS || errno == EINVAL)
-            {
-              ace_count = 0;
-              ace_entries = NULL;
-              break;
-            }
-          else
-            return -2;
-        }
-      if (ret == ace_count)
-        break;
-      /* Huh? The number of ACL entries changed since the last call.
-         Repeat.  */
-    }
-# endif
-
-  for (;;)
-    {
-      count = (source_desc != -1
-               ? facl (source_desc, GETACLCNT, 0, NULL)
-               : acl (src_name, GETACLCNT, 0, NULL));
-
-      if (count < 0)
-        {
-          if (errno == ENOSYS || errno == ENOTSUP || errno == EOPNOTSUPP)
-            {
-              count = 0;
-              entries = NULL;
-              break;
-            }
-          else
-            return -2;
-        }
-
-      if (count == 0)
-        {
-          entries = NULL;
-          break;
-        }
-
-      entries = (aclent_t *) malloc (count * sizeof (aclent_t));
-      if (entries == NULL)
-        {
-          errno = ENOMEM;
-          return -2;
-        }
-
-      if ((source_desc != -1
-           ? facl (source_desc, GETACL, count, entries)
-           : acl (src_name, GETACL, count, entries))
-          == count)
-        break;
-      /* Huh? The number of ACL entries changed since the last call.
-         Repeat.  */
-    }
-
-  /* Is there an ACL of either kind?  */
-# ifdef ACE_GETACL
-  if (ace_count == 0)
-# endif
-    if (count == 0)
-      return qset_acl (dst_name, dest_desc, mode);
-
-  did_chmod = 0; /* set to 1 once the mode bits in 0777 have been set */
-  saved_errno = 0; /* the first non-ignorable error code */
-
-  if (!MODE_INSIDE_ACL)
-    {
-      /* On Cygwin, it is necessary to call chmod before acl, because
-         chmod can change the contents of the ACL (in ways that don't
-         change the allowed accesses, but still visible).  */
-      if (chmod_or_fchmod (dst_name, dest_desc, mode) != 0)
-        saved_errno = errno;
-      did_chmod = 1;
-    }
-
-  /* If both ace_entries and entries are available, try SETACL before
-     ACE_SETACL, because SETACL cannot fail with ENOTSUP whereas ACE_SETACL
-     can.  */
-
-  if (count > 0)
-    {
-      ret = (dest_desc != -1
-             ? facl (dest_desc, SETACL, count, entries)
-             : acl (dst_name, SETACL, count, entries));
-      if (ret < 0 && saved_errno == 0)
-        {
-          saved_errno = errno;
-          if ((errno == ENOSYS || errno == EOPNOTSUPP || errno == EINVAL)
-              && !acl_nontrivial (count, entries))
-            saved_errno = 0;
-        }
-      else
-        did_chmod = 1;
-    }
-  free (entries);
-
-# ifdef ACE_GETACL
-  if (ace_count > 0)
-    {
-      ret = (dest_desc != -1
-             ? facl (dest_desc, ACE_SETACL, ace_count, ace_entries)
-             : acl (dst_name, ACE_SETACL, ace_count, ace_entries));
-      if (ret < 0 && saved_errno == 0)
-        {
-          saved_errno = errno;
-          if ((errno == ENOSYS || errno == EINVAL || errno == ENOTSUP)
-              && !acl_ace_nontrivial (ace_count, ace_entries))
-            saved_errno = 0;
-        }
-    }
-  free (ace_entries);
-# endif
-
-  if (MODE_INSIDE_ACL
-      && did_chmod <= ((mode & (S_ISUID | S_ISGID | S_ISVTX)) ? 1 : 0))
-    {
-      /* We did not call chmod so far, and either the mode and the ACL are
-         separate or special bits are to be set which don't fit into ACLs.  */
-
-      if (chmod_or_fchmod (dst_name, dest_desc, mode) != 0)
-        {
-          if (saved_errno == 0)
-            saved_errno = errno;
-        }
-    }
-
-  if (saved_errno)
-    {
-      errno = saved_errno;
-      return -1;
-    }
-  return 0;
-
-#elif USE_ACL && HAVE_GETACL /* HP-UX */
-
-  struct acl_entry entries[NACLENTRIES];
-  int count;
-# if HAVE_ACLV_H
-  struct acl aclv_entries[NACLVENTRIES];
-  int aclv_count;
-# endif
-  int did_chmod;
-  int saved_errno;
-  int ret;
-
-  count = (source_desc != -1
-           ? fgetacl (source_desc, NACLENTRIES, entries)
-           : getacl (src_name, NACLENTRIES, entries));
-
-  if (count < 0)
-    {
-      if (errno == ENOSYS || errno == EOPNOTSUPP || errno == ENOTSUP)
-        count = 0;
-      else
-        return -2;
-    }
-  else if (count > 0)
-    {
-      if (count > NACLENTRIES)
-        /* If NACLENTRIES cannot be trusted, use dynamic memory allocation.  */
-        abort ();
-    }
-
-# if HAVE_ACLV_H
-  aclv_count = acl ((char *) src_name, ACL_GET, NACLVENTRIES, aclv_entries);
-
-  if (aclv_count < 0)
-    {
-      if (errno == ENOSYS || errno == EOPNOTSUPP || errno == EINVAL)
-        count = 0;
-      else
-        return -2;
-    }
-  else if (aclv_count > 0)
-    {
-      if (aclv_count > NACLVENTRIES)
-        /* If NACLVENTRIES cannot be trusted, use dynamic memory allocation.  */
-        abort ();
-    }
-# endif
-
-  if (count == 0)
-# if HAVE_ACLV_H
-    if (aclv_count == 0)
-# endif
-      return qset_acl (dst_name, dest_desc, mode);
-
-  did_chmod = 0; /* set to 1 once the mode bits in 0777 have been set */
-  saved_errno = 0; /* the first non-ignorable error code */
-
-  if (count > 0)
-    {
-      ret = (dest_desc != -1
-             ? fsetacl (dest_desc, count, entries)
-             : setacl (dst_name, count, entries));
-      if (ret < 0 && saved_errno == 0)
-        {
-          saved_errno = errno;
-          if (errno == ENOSYS || errno == EOPNOTSUPP || errno == ENOTSUP)
-            {
-              struct stat source_statbuf;
-
-              if ((source_desc != -1
-                   ? fstat (source_desc, &source_statbuf)
-                   : stat (src_name, &source_statbuf)) == 0)
-                {
-                  if (!acl_nontrivial (count, entries, &source_statbuf))
-                    saved_errno = 0;
-                }
-              else
-                saved_errno = errno;
-            }
-        }
-      else
-        did_chmod = 1;
-    }
-
-# if HAVE_ACLV_H
-  if (aclv_count > 0)
-    {
-      ret = acl ((char *) dst_name, ACL_SET, aclv_count, aclv_entries);
-      if (ret < 0 && saved_errno == 0)
-        {
-          saved_errno = errno;
-          if (errno == ENOSYS || errno == EOPNOTSUPP || errno == EINVAL)
-            {
-              if (!aclv_nontrivial (aclv_count, aclv_entries))
-                saved_errno = 0;
-            }
-        }
-      else
-        did_chmod = 1;
-    }
-# endif
-
-  if (did_chmod <= ((mode & (S_ISUID | S_ISGID | S_ISVTX)) ? 1 : 0))
-    {
-      /* We did not call chmod so far, and special bits are to be set which
-         don't fit into ACLs.  */
-
-      if (chmod_or_fchmod (dst_name, dest_desc, mode) != 0)
-        {
-          if (saved_errno == 0)
-            saved_errno = errno;
-        }
-    }
-
-  if (saved_errno)
-    {
-      errno = saved_errno;
-      return -1;
-    }
-  return 0;
-
-#elif USE_ACL && HAVE_ACLX_GET && 0 /* AIX */
-
-  /* TODO */
-
-#elif USE_ACL && HAVE_STATACL /* older AIX */
-
-  union { struct acl a; char room[4096]; } u;
-  int ret;
-
-  if ((source_desc != -1
-       ? fstatacl (source_desc, STX_NORMAL, &u.a, sizeof (u))
-       : statacl (src_name, STX_NORMAL, &u.a, sizeof (u)))
-      < 0)
-    return -2;
-
-  ret = (dest_desc != -1
-         ? fchacl (dest_desc, &u.a, u.a.acl_len)
-         : chacl (dst_name, &u.a, u.a.acl_len));
-  if (ret < 0)
-    {
-      int saved_errno = errno;
-
-      chmod_or_fchmod (dst_name, dest_desc, mode);
-      errno = saved_errno;
-      return -1;
-    }
-
-  /* No need to call chmod_or_fchmod at this point, since the mode bits
-     S_ISUID, S_ISGID, S_ISVTX are also stored in the ACL.  */
-
-  return 0;
-
-#elif USE_ACL && HAVE_ACLSORT /* NonStop Kernel */
-
-  struct acl entries[NACLENTRIES];
-  int count;
-  int ret;
-
-  count = acl ((char *) src_name, ACL_GET, NACLENTRIES, entries);
-
-  if (count < 0)
-    {
-      if (0)
-        count = 0;
-      else
-        return -2;
-    }
-  else if (count > 0)
-    {
-      if (count > NACLENTRIES)
-        /* If NACLENTRIES cannot be trusted, use dynamic memory allocation.  */
-        abort ();
-    }
-
-  if (count == 0)
-    return qset_acl (dst_name, dest_desc, mode);
-
-  ret = acl ((char *) dst_name, ACL_SET, count, entries);
-  if (ret < 0)
-    {
-      int saved_errno = errno;
-
-      if (0)
-        {
-          if (!acl_nontrivial (count, entries))
-            return chmod_or_fchmod (dst_name, dest_desc, mode);
-        }
-
-      chmod_or_fchmod (dst_name, dest_desc, mode);
-      errno = saved_errno;
-      return -1;
-    }
-
-  if (mode & (S_ISUID | S_ISGID | S_ISVTX))
-    {
-      /* We did not call chmod so far, and either the mode and the ACL are
-         separate or special bits are to be set which don't fit into ACLs.  */
-
-      return chmod_or_fchmod (dst_name, dest_desc, mode);
-    }
-  return 0;
-
-#else
-
-  return qset_acl (dst_name, dest_desc, mode);
-
-#endif
-}
-
-
-/* Copy access control lists from one file to another. If SOURCE_DESC is
-   a valid file descriptor, use file descriptor operations, else use
-   filename based operations on SRC_NAME. Likewise for DEST_DESC and
-   DST_NAME.
-   If access control lists are not available, fchmod the target file to
-   MODE.  Also sets the non-permission bits of the destination file
-   (S_ISUID, S_ISGID, S_ISVTX) to those from MODE if any are set.
    Return 0 if successful, otherwise output a diagnostic and return a
    negative error code.  */
 
--- a/lib/file-has-acl.c
+++ b/lib/file-has-acl.c
@@ -553,7 +553,7 @@
 #  endif
         }
       if (ret < 0)
-        return ACL_NOT_WELL_SUPPORTED (errno) ? 0 : -1;
+        return - acl_errno_valid (errno);
       return ret;
 
 # elif HAVE_FACL && defined GETACL /* Solaris, Cygwin, not HP-UX */
new file mode 100644
--- /dev/null
+++ b/lib/qcopy-acl.c
@@ -0,0 +1,583 @@
+/* copy-acl.c - copy access control list from one file to another file
+
+   Copyright (C) 2002-2003, 2005-2013 Free Software Foundation, Inc.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   Written by Paul Eggert, Andreas Gr├╝nbacher, and Bruno Haible.  */
+
+#include <config.h>
+
+#include "acl.h"
+
+#include "acl-internal.h"
+
+
+/* Copy access control lists from one file to another. If SOURCE_DESC is
+   a valid file descriptor, use file descriptor operations, else use
+   filename based operations on SRC_NAME. Likewise for DEST_DESC and
+   DST_NAME.
+   If access control lists are not available, fchmod the target file to
+   MODE.  Also sets the non-permission bits of the destination file
+   (S_ISUID, S_ISGID, S_ISVTX) to those from MODE if any are set.
+   Return 0 if successful.
+   Return -2 and set errno for an error relating to the source file.
+   Return -1 and set errno for an error relating to the destination file.  */
+
+int
+qcopy_acl (const char *src_name, int source_desc, const char *dst_name,
+           int dest_desc, mode_t mode)
+{
+#if USE_ACL && HAVE_ACL_GET_FILE
+  /* POSIX 1003.1e (draft 17 -- abandoned) specific version.  */
+  /* Linux, FreeBSD, Mac OS X, IRIX, Tru64 */
+# if !HAVE_ACL_TYPE_EXTENDED
+  /* Linux, FreeBSD, IRIX, Tru64 */
+
+  acl_t acl;
+  int ret;
+
+  if (HAVE_ACL_GET_FD && source_desc != -1)
+    acl = acl_get_fd (source_desc);
+  else
+    acl = acl_get_file (src_name, ACL_TYPE_ACCESS);
+  if (acl == NULL)
+    {
+      if (! acl_errno_valid (errno))
+        return qset_acl (dst_name, dest_desc, mode);
+      else
+        return -2;
+    }
+
+  if (HAVE_ACL_SET_FD && dest_desc != -1)
+    ret = acl_set_fd (dest_desc, acl);
+  else
+    ret = acl_set_file (dst_name, ACL_TYPE_ACCESS, acl);
+  if (ret != 0)
+    {
+      int saved_errno = errno;
+
+      if (! acl_errno_valid (errno) && !acl_access_nontrivial (acl))
+        {
+          acl_free (acl);
+          return chmod_or_fchmod (dst_name, dest_desc, mode);
+        }
+      else
+        {
+          acl_free (acl);
+          chmod_or_fchmod (dst_name, dest_desc, mode);
+          errno = saved_errno;
+          return -1;
+        }
+    }
+  else
+    acl_free (acl);
+
+  if (!MODE_INSIDE_ACL || (mode & (S_ISUID | S_ISGID | S_ISVTX)))
+    {
+      /* We did not call chmod so far, and either the mode and the ACL are
+         separate or special bits are to be set which don't fit into ACLs.  */
+
+      if (chmod_or_fchmod (dst_name, dest_desc, mode) != 0)
+        return -1;
+    }
+
+  if (S_ISDIR (mode))
+    {
+      acl = acl_get_file (src_name, ACL_TYPE_DEFAULT);
+      if (acl == NULL)
+        return -2;
+
+      if (acl_set_file (dst_name, ACL_TYPE_DEFAULT, acl))
+        {
+          int saved_errno = errno;
+
+          acl_free (acl);
+          errno = saved_errno;
+          return -1;
+        }
+      else
+        acl_free (acl);
+    }
+  return 0;
+
+# else /* HAVE_ACL_TYPE_EXTENDED */
+  /* Mac OS X */
+
+  /* On Mac OS X,  acl_get_file (name, ACL_TYPE_ACCESS)
+     and           acl_get_file (name, ACL_TYPE_DEFAULT)
+     always return NULL / EINVAL.  You have to use
+                   acl_get_file (name, ACL_TYPE_EXTENDED)
+     or            acl_get_fd (open (name, ...))
+     to retrieve an ACL.
+     On the other hand,
+                   acl_set_file (name, ACL_TYPE_ACCESS, acl)
+     and           acl_set_file (name, ACL_TYPE_DEFAULT, acl)
+     have the same effect as
+                   acl_set_file (name, ACL_TYPE_EXTENDED, acl):
+     Each of these calls sets the file's ACL.  */
+
+  acl_t acl;
+  int ret;
+
+  if (HAVE_ACL_GET_FD && source_desc != -1)
+    acl = acl_get_fd (source_desc);
+  else
+    acl = acl_get_file (src_name, ACL_TYPE_EXTENDED);
+  if (acl == NULL)
+    {
+      if (!acl_errno_valid (errno))
+        return qset_acl (dst_name, dest_desc, mode);
+      else
+        return -2;
+    }
+
+  if (HAVE_ACL_SET_FD && dest_desc != -1)
+    ret = acl_set_fd (dest_desc, acl);
+  else
+    ret = acl_set_file (dst_name, ACL_TYPE_EXTENDED, acl);
+  if (ret != 0)
+    {
+      int saved_errno = errno;
+
+      if (!acl_errno_valid (saved_errno) && !acl_extended_nontrivial (acl))
+        {
+          acl_free (acl);
+          return chmod_or_fchmod (dst_name, dest_desc, mode);
+        }
+      else
+        {
+          acl_free (acl);
+          chmod_or_fchmod (dst_name, dest_desc, mode);
+          errno = saved_errno;
+          return -1;
+        }
+    }
+  else
+    acl_free (acl);
+
+  /* Since !MODE_INSIDE_ACL, we have to call chmod explicitly.  */
+  return chmod_or_fchmod (dst_name, dest_desc, mode);
+
+# endif
+
+#elif USE_ACL && defined GETACL /* Solaris, Cygwin, not HP-UX */
+
+  /* Solaris 2.5 through Solaris 10, Cygwin, and contemporaneous versions
+     of Unixware.  The acl() call returns the access and default ACL both
+     at once.  */
+# ifdef ACE_GETACL
+  int ace_count;
+  ace_t *ace_entries;
+# endif
+  int count;
+  aclent_t *entries;
+  int did_chmod;
+  int saved_errno;
+  int ret;
+
+# ifdef ACE_GETACL
+  /* Solaris also has a different variant of ACLs, used in ZFS and NFSv4
+     file systems (whereas the other ones are used in UFS file systems).
+     There is an API
+       pathconf (name, _PC_ACL_ENABLED)
+       fpathconf (desc, _PC_ACL_ENABLED)
+     that allows to determine which of the two kinds of ACLs is supported
+     for the given file.  But some file systems may implement this call
+     incorrectly, so better not use it.
+     When fetching the source ACL, we simply fetch both ACL types.
+     When setting the destination ACL, we try either ACL types, assuming
+     that the kernel will translate the ACL from one form to the other.
+     (See in <http://docs.sun.com/app/docs/doc/819-2241/6n4huc7ia?l=en&a=view>
+     the description of ENOTSUP.)  */
+  for (;;)
+    {
+      ace_count = (source_desc != -1
+                   ? facl (source_desc, ACE_GETACLCNT, 0, NULL)
+                   : acl (src_name, ACE_GETACLCNT, 0, NULL));
+
+      if (ace_count < 0)
+        {
+          if (errno == ENOSYS || errno == EINVAL)
+            {
+              ace_count = 0;
+              ace_entries = NULL;
+              break;
+            }
+          else
+            return -2;
+        }
+
+      if (ace_count == 0)
+        {
+          ace_entries = NULL;
+          break;
+        }
+
+      ace_entries = (ace_t *) malloc (ace_count * sizeof (ace_t));
+      if (ace_entries == NULL)
+        {
+          errno = ENOMEM;
+          return -2;
+        }
+
+      ret = (source_desc != -1
+             ? facl (source_desc, ACE_GETACL, ace_count, ace_entries)
+             : acl (src_name, ACE_GETACL, ace_count, ace_entries));
+      if (ret < 0)
+        {
+          free (ace_entries);
+          if (errno == ENOSYS || errno == EINVAL)
+            {
+              ace_count = 0;
+              ace_entries = NULL;
+              break;
+            }
+          else
+            return -2;
+        }
+      if (ret == ace_count)
+        break;
+      /* Huh? The number of ACL entries changed since the last call.
+         Repeat.  */
+    }
+# endif
+
+  for (;;)
+    {
+      count = (source_desc != -1
+               ? facl (source_desc, GETACLCNT, 0, NULL)
+               : acl (src_name, GETACLCNT, 0, NULL));
+
+      if (count < 0)
+        {
+          if (errno == ENOSYS || errno == ENOTSUP || errno == EOPNOTSUPP)
+            {
+              count = 0;
+              entries = NULL;
+              break;
+            }
+          else
+            return -2;
+        }
+
+      if (count == 0)
+        {
+          entries = NULL;
+          break;
+        }
+
+      entries = (aclent_t *) malloc (count * sizeof (aclent_t));
+      if (entries == NULL)
+        {
+          errno = ENOMEM;
+          return -2;
+        }
+
+      if ((source_desc != -1
+           ? facl (source_desc, GETACL, count, entries)
+           : acl (src_name, GETACL, count, entries))
+          == count)
+        break;
+      /* Huh? The number of ACL entries changed since the last call.
+         Repeat.  */
+    }
+
+  /* Is there an ACL of either kind?  */
+# ifdef ACE_GETACL
+  if (ace_count == 0)
+# endif
+    if (count == 0)
+      return qset_acl (dst_name, dest_desc, mode);
+
+  did_chmod = 0; /* set to 1 once the mode bits in 0777 have been set */
+  saved_errno = 0; /* the first non-ignorable error code */
+
+  if (!MODE_INSIDE_ACL)
+    {
+      /* On Cygwin, it is necessary to call chmod before acl, because
+         chmod can change the contents of the ACL (in ways that don't
+         change the allowed accesses, but still visible).  */
+      if (chmod_or_fchmod (dst_name, dest_desc, mode) != 0)
+        saved_errno = errno;
+      did_chmod = 1;
+    }
+
+  /* If both ace_entries and entries are available, try SETACL before
+     ACE_SETACL, because SETACL cannot fail with ENOTSUP whereas ACE_SETACL
+     can.  */
+
+  if (count > 0)
+    {
+      ret = (dest_desc != -1
+             ? facl (dest_desc, SETACL, count, entries)
+             : acl (dst_name, SETACL, count, entries));
+      if (ret < 0 && saved_errno == 0)
+        {
+          saved_errno = errno;
+          if ((errno == ENOSYS || errno == EOPNOTSUPP || errno == EINVAL)
+              && !acl_nontrivial (count, entries))
+            saved_errno = 0;
+        }
+      else
+        did_chmod = 1;
+    }
+  free (entries);
+
+# ifdef ACE_GETACL
+  if (ace_count > 0)
+    {
+      ret = (dest_desc != -1
+             ? facl (dest_desc, ACE_SETACL, ace_count, ace_entries)
+             : acl (dst_name, ACE_SETACL, ace_count, ace_entries));
+      if (ret < 0 && saved_errno == 0)
+        {
+          saved_errno = errno;
+          if ((errno == ENOSYS || errno == EINVAL || errno == ENOTSUP)
+              && !acl_ace_nontrivial (ace_count, ace_entries))
+            saved_errno = 0;
+        }
+    }
+  free (ace_entries);
+# endif
+
+  if (MODE_INSIDE_ACL
+      && did_chmod <= ((mode & (S_ISUID | S_ISGID | S_ISVTX)) ? 1 : 0))
+    {
+      /* We did not call chmod so far, and either the mode and the ACL are
+         separate or special bits are to be set which don't fit into ACLs.  */
+
+      if (chmod_or_fchmod (dst_name, dest_desc, mode) != 0)
+        {
+          if (saved_errno == 0)
+            saved_errno = errno;
+        }
+    }
+
+  if (saved_errno)
+    {
+      errno = saved_errno;
+      return -1;
+    }
+  return 0;
+
+#elif USE_ACL && HAVE_GETACL /* HP-UX */
+
+  struct acl_entry entries[NACLENTRIES];
+  int count;
+# if HAVE_ACLV_H
+  struct acl aclv_entries[NACLVENTRIES];
+  int aclv_count;
+# endif
+  int did_chmod;
+  int saved_errno;
+  int ret;
+
+  count = (source_desc != -1
+           ? fgetacl (source_desc, NACLENTRIES, entries)
+           : getacl (src_name, NACLENTRIES, entries));
+
+  if (count < 0)
+    {
+      if (errno == ENOSYS || errno == EOPNOTSUPP || errno == ENOTSUP)
+        count = 0;
+      else
+        return -2;
+    }
+  else if (count > 0)
+    {
+      if (count > NACLENTRIES)
+        /* If NACLENTRIES cannot be trusted, use dynamic memory allocation.  */
+        abort ();
+    }
+
+# if HAVE_ACLV_H
+  aclv_count = acl ((char *) src_name, ACL_GET, NACLVENTRIES, aclv_entries);
+
+  if (aclv_count < 0)
+    {
+      if (errno == ENOSYS || errno == EOPNOTSUPP || errno == EINVAL)
+        count = 0;
+      else
+        return -2;
+    }
+  else if (aclv_count > 0)
+    {
+      if (aclv_count > NACLVENTRIES)
+        /* If NACLVENTRIES cannot be trusted, use dynamic memory allocation.  */
+        abort ();
+    }
+# endif
+
+  if (count == 0)
+# if HAVE_ACLV_H
+    if (aclv_count == 0)
+# endif
+      return qset_acl (dst_name, dest_desc, mode);
+
+  did_chmod = 0; /* set to 1 once the mode bits in 0777 have been set */
+  saved_errno = 0; /* the first non-ignorable error code */
+
+  if (count > 0)
+    {
+      ret = (dest_desc != -1
+             ? fsetacl (dest_desc, count, entries)
+             : setacl (dst_name, count, entries));
+      if (ret < 0 && saved_errno == 0)
+        {
+          saved_errno = errno;
+          if (errno == ENOSYS || errno == EOPNOTSUPP || errno == ENOTSUP)
+            {
+              struct stat source_statbuf;
+
+              if ((source_desc != -1
+                   ? fstat (source_desc, &source_statbuf)
+                   : stat (src_name, &source_statbuf)) == 0)
+                {
+                  if (!acl_nontrivial (count, entries, &source_statbuf))
+                    saved_errno = 0;
+                }
+              else
+                saved_errno = errno;
+            }
+        }
+      else
+        did_chmod = 1;
+    }
+
+# if HAVE_ACLV_H
+  if (aclv_count > 0)
+    {
+      ret = acl ((char *) dst_name, ACL_SET, aclv_count, aclv_entries);
+      if (ret < 0 && saved_errno == 0)
+        {
+          saved_errno = errno;
+          if (errno == ENOSYS || errno == EOPNOTSUPP || errno == EINVAL)
+            {
+              if (!aclv_nontrivial (aclv_count, aclv_entries))
+                saved_errno = 0;
+            }
+        }
+      else
+        did_chmod = 1;
+    }
+# endif
+
+  if (did_chmod <= ((mode & (S_ISUID | S_ISGID | S_ISVTX)) ? 1 : 0))
+    {
+      /* We did not call chmod so far, and special bits are to be set which
+         don't fit into ACLs.  */
+
+      if (chmod_or_fchmod (dst_name, dest_desc, mode) != 0)
+        {
+          if (saved_errno == 0)
+            saved_errno = errno;
+        }
+    }
+
+  if (saved_errno)
+    {
+      errno = saved_errno;
+      return -1;
+    }
+  return 0;
+
+#elif USE_ACL && HAVE_ACLX_GET && 0 /* AIX */
+
+  /* TODO */
+
+#elif USE_ACL && HAVE_STATACL /* older AIX */
+
+  union { struct acl a; char room[4096]; } u;
+  int ret;
+
+  if ((source_desc != -1
+       ? fstatacl (source_desc, STX_NORMAL, &u.a, sizeof (u))
+       : statacl (src_name, STX_NORMAL, &u.a, sizeof (u)))
+      < 0)
+    return -2;
+
+  ret = (dest_desc != -1
+         ? fchacl (dest_desc, &u.a, u.a.acl_len)
+         : chacl (dst_name, &u.a, u.a.acl_len));
+  if (ret < 0)
+    {
+      int saved_errno = errno;
+
+      chmod_or_fchmod (dst_name, dest_desc, mode);
+      errno = saved_errno;
+      return -1;
+    }
+
+  /* No need to call chmod_or_fchmod at this point, since the mode bits
+     S_ISUID, S_ISGID, S_ISVTX are also stored in the ACL.  */
+
+  return 0;
+
+#elif USE_ACL && HAVE_ACLSORT /* NonStop Kernel */
+
+  struct acl entries[NACLENTRIES];
+  int count;
+  int ret;
+
+  count = acl ((char *) src_name, ACL_GET, NACLENTRIES, entries);
+
+  if (count < 0)
+    {
+      if (0)
+        count = 0;
+      else
+        return -2;
+    }
+  else if (count > 0)
+    {
+      if (count > NACLENTRIES)
+        /* If NACLENTRIES cannot be trusted, use dynamic memory allocation.  */
+        abort ();
+    }
+
+  if (count == 0)
+    return qset_acl (dst_name, dest_desc, mode);
+
+  ret = acl ((char *) dst_name, ACL_SET, count, entries);
+  if (ret < 0)
+    {
+      int saved_errno = errno;
+
+      if (0)
+        {
+          if (!acl_nontrivial (count, entries))
+            return chmod_or_fchmod (dst_name, dest_desc, mode);
+        }
+
+      chmod_or_fchmod (dst_name, dest_desc, mode);
+      errno = saved_errno;
+      return -1;
+    }
+
+  if (mode & (S_ISUID | S_ISGID | S_ISVTX))
+    {
+      /* We did not call chmod so far, and either the mode and the ACL are
+         separate or special bits are to be set which don't fit into ACLs.  */
+
+      return chmod_or_fchmod (dst_name, dest_desc, mode);
+    }
+  return 0;
+
+#else
+
+  return qset_acl (dst_name, dest_desc, mode);
+
+#endif
+}
new file mode 100644
--- /dev/null
+++ b/lib/qset-acl.c
@@ -0,0 +1,676 @@
+/* qset-acl.c - set access control list equivalent to a mode
+
+   Copyright (C) 2002-2003, 2005-2013 Free Software Foundation, Inc.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   Written by Paul Eggert and Andreas Gruenbacher, and Bruno Haible.  */
+
+#include <config.h>
+
+#define ACL_INTERNAL_INLINE _GL_EXTERN_INLINE
+
+#include "acl.h"
+
+#include "acl-internal.h"
+
+
+/* If DESC is a valid file descriptor use fchmod to change the
+   file's mode to MODE on systems that have fchmod. On systems
+   that don't have fchmod and if DESC is invalid, use chmod on
+   NAME instead.
+   Return 0 if successful.  Return -1 and set errno upon failure.  */
+
+int
+chmod_or_fchmod (const char *name, int desc, mode_t mode)
+{
+  if (HAVE_FCHMOD && desc != -1)
+    return fchmod (desc, mode);
+  else
+    return chmod (name, mode);
+}
+
+/* Set the access control lists of a file. If DESC is a valid file
+   descriptor, use file descriptor operations where available, else use
+   filename based operations on NAME.  If access control lists are not
+   available, fchmod the target file to MODE.  Also sets the
+   non-permission bits of the destination file (S_ISUID, S_ISGID, S_ISVTX)
+   to those from MODE if any are set.
+   Return 0 if successful.  Return -1 and set errno upon failure.  */
+
+int
+qset_acl (char const *name, int desc, mode_t mode)
+{
+#if USE_ACL
+# if HAVE_ACL_GET_FILE
+  /* POSIX 1003.1e draft 17 (abandoned) specific version.  */
+  /* Linux, FreeBSD, Mac OS X, IRIX, Tru64 */
+#  if !HAVE_ACL_TYPE_EXTENDED
+  /* Linux, FreeBSD, IRIX, Tru64 */
+
+  /* We must also have acl_from_text and acl_delete_def_file.
+     (acl_delete_def_file could be emulated with acl_init followed
+      by acl_set_file, but acl_set_file with an empty acl is
+      unspecified.)  */
+
+#   ifndef HAVE_ACL_FROM_TEXT
+#    error Must have acl_from_text (see POSIX 1003.1e draft 17).
+#   endif
+#   ifndef HAVE_ACL_DELETE_DEF_FILE
+#    error Must have acl_delete_def_file (see POSIX 1003.1e draft 17).
+#   endif
+
+  acl_t acl;
+  int ret;
+
+  if (HAVE_ACL_FROM_MODE) /* Linux */
+    {
+      acl = acl_from_mode (mode);
+      if (!acl)
+        return -1;
+    }
+  else /* FreeBSD, IRIX, Tru64 */
+    {
+      /* If we were to create the ACL using the functions acl_init(),
+         acl_create_entry(), acl_set_tag_type(), acl_set_qualifier(),
+         acl_get_permset(), acl_clear_perm[s](), acl_add_perm(), we
+         would need to create a qualifier.  I don't know how to do this.
+         So create it using acl_from_text().  */
+
+#   if HAVE_ACL_FREE_TEXT /* Tru64 */
+      char acl_text[] = "u::---,g::---,o::---,";
+#   else /* FreeBSD, IRIX */
+      char acl_text[] = "u::---,g::---,o::---";
+#   endif
+
+      if (mode & S_IRUSR) acl_text[ 3] = 'r';
+      if (mode & S_IWUSR) acl_text[ 4] = 'w';
+      if (mode & S_IXUSR) acl_text[ 5] = 'x';
+      if (mode & S_IRGRP) acl_text[10] = 'r';
+      if (mode & S_IWGRP) acl_text[11] = 'w';
+      if (mode & S_IXGRP) acl_text[12] = 'x';
+      if (mode & S_IROTH) acl_text[17] = 'r';
+      if (mode & S_IWOTH) acl_text[18] = 'w';
+      if (mode & S_IXOTH) acl_text[19] = 'x';
+
+      acl = acl_from_text (acl_text);
+      if (!acl)
+        return -1;
+    }
+  if (HAVE_ACL_SET_FD && desc != -1)
+    ret = acl_set_fd (desc, acl);
+  else
+    ret = acl_set_file (name, ACL_TYPE_ACCESS, acl);
+  if (ret != 0)
+    {
+      int saved_errno = errno;
+      acl_free (acl);
+      if (! acl_errno_valid (errno))
+        return chmod_or_fchmod (name, desc, mode);
+      errno = saved_errno;
+      return -1;
+    }
+  else
+    acl_free (acl);
+
+  if (S_ISDIR (mode) && acl_delete_def_file (name))
+    return -1;
+
+  if (!MODE_INSIDE_ACL || (mode & (S_ISUID | S_ISGID | S_ISVTX)))
+    {
+      /* We did not call chmod so far, and either the mode and the ACL are
+         separate or special bits are to be set which don't fit into ACLs.  */
+      return chmod_or_fchmod (name, desc, mode);
+    }
+  return 0;
+
+#  else /* HAVE_ACL_TYPE_EXTENDED */
+  /* Mac OS X */
+
+  /* On Mac OS X,  acl_get_file (name, ACL_TYPE_ACCESS)
+     and           acl_get_file (name, ACL_TYPE_DEFAULT)
+     always return NULL / EINVAL.  You have to use
+                   acl_get_file (name, ACL_TYPE_EXTENDED)
+     or            acl_get_fd (open (name, ...))
+     to retrieve an ACL.
+     On the other hand,
+                   acl_set_file (name, ACL_TYPE_ACCESS, acl)
+     and           acl_set_file (name, ACL_TYPE_DEFAULT, acl)
+     have the same effect as
+                   acl_set_file (name, ACL_TYPE_EXTENDED, acl):
+     Each of these calls sets the file's ACL.  */
+
+  acl_t acl;
+  int ret;
+
+  /* Remove the ACL if the file has ACLs.  */
+  if (HAVE_ACL_GET_FD && desc != -1)
+    acl = acl_get_fd (desc);
+  else
+    acl = acl_get_file (name, ACL_TYPE_EXTENDED);
+  if (acl)
+    {
+      acl_free (acl);
+
+      acl = acl_init (0);
+      if (acl)
+        {
+          if (HAVE_ACL_SET_FD && desc != -1)
+            ret = acl_set_fd (desc, acl);
+          else
+            ret = acl_set_file (name, ACL_TYPE_EXTENDED, acl);
+          if (ret != 0)
+            {
+              int saved_errno = errno;
+              acl_free (acl);
+              if (! acl_errno_valid (saved_errno))
+                return chmod_or_fchmod (name, desc, mode);
+              errno = saved_errno;
+              return -1;
+            }
+          acl_free (acl);
+        }
+    }
+
+  /* Since !MODE_INSIDE_ACL, we have to call chmod explicitly.  */
+  return chmod_or_fchmod (name, desc, mode);
+#  endif
+
+# elif HAVE_FACL && defined GETACL /* Solaris, Cygwin, not HP-UX */
+
+  int done_setacl = 0;
+
+#  ifdef ACE_GETACL
+  /* Solaris also has a different variant of ACLs, used in ZFS and NFSv4
+     file systems (whereas the other ones are used in UFS file systems).  */
+
+  /* The flags in the ace_t structure changed in a binary incompatible way
+     when ACL_NO_TRIVIAL etc. were introduced in <sys/acl.h> version 1.15.
+     How to distinguish the two conventions at runtime?
+     We fetch the existing ACL.  In the old convention, usually three ACEs have
+     a_flags = ACE_OWNER / ACE_GROUP / ACE_OTHER, in the range 0x0100..0x0400.
+     In the new convention, these values are not used.  */
+  int convention;
+
+  {
+    /* Initially, try to read the entries into a stack-allocated buffer.
+       Use malloc if it does not fit.  */
+    enum
+      {
+        alloc_init = 4000 / sizeof (ace_t), /* >= 3 */
+        alloc_max = MIN (INT_MAX, SIZE_MAX / sizeof (ace_t))
+      };
+    ace_t buf[alloc_init];
+    size_t alloc = alloc_init;
+    ace_t *entries = buf;
+    ace_t *malloced = NULL;
+    int count;
+
+    for (;;)
+      {
+        count = (desc != -1
+                 ? facl (desc, ACE_GETACL, alloc, entries)
+                 : acl (name, ACE_GETACL, alloc, entries));
+        if (count < 0 && errno == ENOSPC)
+          {
+            /* Increase the size of the buffer.  */
+            free (malloced);
+            if (alloc > alloc_max / 2)
+              {
+                errno = ENOMEM;
+                return -1;
+              }
+            alloc = 2 * alloc; /* <= alloc_max */
+            entries = malloced = (ace_t *) malloc (alloc * sizeof (ace_t));
+            if (entries == NULL)
+              {
+                errno = ENOMEM;
+                return -1;
+              }
+            continue;
+          }
+        break;
+      }
+
+    if (count <= 0)
+      convention = -1;
+    else
+      {
+        int i;
+
+        convention = 0;
+        for (i = 0; i < count; i++)
+          if (entries[i].a_flags & (OLD_ACE_OWNER | OLD_ACE_GROUP | OLD_ACE_OTHER))
+            {
+              convention = 1;
+              break;
+            }
+      }
+    free (malloced);
+  }
+
+  if (convention >= 0)
+    {
+      ace_t entries[6];
+      int count;
+      int ret;
+
+      if (convention)
+        {
+          /* Running on Solaris 10.  */
+          entries[0].a_type = OLD_ALLOW;
+          entries[0].a_flags = OLD_ACE_OWNER;
+          entries[0].a_who = 0; /* irrelevant */
+          entries[0].a_access_mask = (mode >> 6) & 7;
+          entries[1].a_type = OLD_ALLOW;
+          entries[1].a_flags = OLD_ACE_GROUP;
+          entries[1].a_who = 0; /* irrelevant */
+          entries[1].a_access_mask = (mode >> 3) & 7;
+          entries[2].a_type = OLD_ALLOW;
+          entries[2].a_flags = OLD_ACE_OTHER;
+          entries[2].a_who = 0;
+          entries[2].a_access_mask = mode & 7;
+          count = 3;
+        }
+      else
+        {
+          /* Running on Solaris 10 (newer version) or Solaris 11.
+             The details here were found through "/bin/ls -lvd somefiles".  */
+          entries[0].a_type = NEW_ACE_ACCESS_DENIED_ACE_TYPE;
+          entries[0].a_flags = NEW_ACE_OWNER;
+          entries[0].a_who = 0; /* irrelevant */
+          entries[0].a_access_mask = 0;
+          entries[1].a_type = NEW_ACE_ACCESS_ALLOWED_ACE_TYPE;
+          entries[1].a_flags = NEW_ACE_OWNER;
+          entries[1].a_who = 0; /* irrelevant */
+          entries[1].a_access_mask = NEW_ACE_WRITE_NAMED_ATTRS
+                                     | NEW_ACE_WRITE_ATTRIBUTES
+                                     | NEW_ACE_WRITE_ACL
+                                     | NEW_ACE_WRITE_OWNER;
+          if (mode & 0400)
+            entries[1].a_access_mask |= NEW_ACE_READ_DATA;
+          else
+            entries[0].a_access_mask |= NEW_ACE_READ_DATA;
+          if (mode & 0200)
+            entries[1].a_access_mask |= NEW_ACE_WRITE_DATA | NEW_ACE_APPEND_DATA;
+          else
+            entries[0].a_access_mask |= NEW_ACE_WRITE_DATA | NEW_ACE_APPEND_DATA;
+          if (mode & 0100)
+            entries[1].a_access_mask |= NEW_ACE_EXECUTE;
+          else
+            entries[0].a_access_mask |= NEW_ACE_EXECUTE;
+          entries[2].a_type = NEW_ACE_ACCESS_DENIED_ACE_TYPE;
+          entries[2].a_flags = NEW_ACE_GROUP | NEW_ACE_IDENTIFIER_GROUP;
+          entries[2].a_who = 0; /* irrelevant */
+          entries[2].a_access_mask = 0;
+          entries[3].a_type = NEW_ACE_ACCESS_ALLOWED_ACE_TYPE;
+          entries[3].a_flags = NEW_ACE_GROUP | NEW_ACE_IDENTIFIER_GROUP;
+          entries[3].a_who = 0; /* irrelevant */
+          entries[3].a_access_mask = 0;
+          if (mode & 0040)
+            entries[3].a_access_mask |= NEW_ACE_READ_DATA;
+          else
+            entries[2].a_access_mask |= NEW_ACE_READ_DATA;
+          if (mode & 0020)
+            entries[3].a_access_mask |= NEW_ACE_WRITE_DATA | NEW_ACE_APPEND_DATA;
+          else
+            entries[2].a_access_mask |= NEW_ACE_WRITE_DATA | NEW_ACE_APPEND_DATA;
+          if (mode & 0010)
+            entries[3].a_access_mask |= NEW_ACE_EXECUTE;
+          else
+            entries[2].a_access_mask |= NEW_ACE_EXECUTE;
+          entries[4].a_type = NEW_ACE_ACCESS_DENIED_ACE_TYPE;
+          entries[4].a_flags = NEW_ACE_EVERYONE;
+          entries[4].a_who = 0;
+          entries[4].a_access_mask = NEW_ACE_WRITE_NAMED_ATTRS
+                                     | NEW_ACE_WRITE_ATTRIBUTES
+                                     | NEW_ACE_WRITE_ACL
+                                     | NEW_ACE_WRITE_OWNER;
+          entries[5].a_type = NEW_ACE_ACCESS_ALLOWED_ACE_TYPE;
+          entries[5].a_flags = NEW_ACE_EVERYONE;
+          entries[5].a_who = 0;
+          entries[5].a_access_mask = NEW_ACE_READ_NAMED_ATTRS
+                                     | NEW_ACE_READ_ATTRIBUTES
+                                     | NEW_ACE_READ_ACL
+                                     | NEW_ACE_SYNCHRONIZE;
+          if (mode & 0004)
+            entries[5].a_access_mask |= NEW_ACE_READ_DATA;
+          else
+            entries[4].a_access_mask |= NEW_ACE_READ_DATA;
+          if (mode & 0002)
+            entries[5].a_access_mask |= NEW_ACE_WRITE_DATA | NEW_ACE_APPEND_DATA;
+          else
+            entries[4].a_access_mask |= NEW_ACE_WRITE_DATA | NEW_ACE_APPEND_DATA;
+          if (mode & 0001)
+            entries[5].a_access_mask |= NEW_ACE_EXECUTE;
+          else
+            entries[4].a_access_mask |= NEW_ACE_EXECUTE;
+          count = 6;
+        }
+      if (desc != -1)
+        ret = facl (desc, ACE_SETACL, count, entries);
+      else
+        ret = acl (name, ACE_SETACL, count, entries);
+      if (ret < 0 && errno != EINVAL && errno != ENOTSUP)
+        {
+          if (errno == ENOSYS)
+            return chmod_or_fchmod (name, desc, mode);
+          return -1;
+        }
+      if (ret == 0)
+        done_setacl = 1;
+    }
+#  endif
+
+  if (!done_setacl)
+    {
+      aclent_t entries[3];
+      int ret;
+
+      entries[0].a_type = USER_OBJ;
+      entries[0].a_id = 0; /* irrelevant */
+      entries[0].a_perm = (mode >> 6) & 7;
+      entries[1].a_type = GROUP_OBJ;
+      entries[1].a_id = 0; /* irrelevant */
+      entries[1].a_perm = (mode >> 3) & 7;
+      entries[2].a_type = OTHER_OBJ;
+      entries[2].a_id = 0;
+      entries[2].a_perm = mode & 7;
+
+      if (desc != -1)
+        ret = facl (desc, SETACL,
+                    sizeof (entries) / sizeof (aclent_t), entries);
+      else
+        ret = acl (name, SETACL,
+                   sizeof (entries) / sizeof (aclent_t), entries);
+      if (ret < 0)
+        {
+          if (errno == ENOSYS || errno == EOPNOTSUPP)
+            return chmod_or_fchmod (name, desc, mode);
+          return -1;
+        }
+    }
+
+  if (!MODE_INSIDE_ACL || (mode & (S_ISUID | S_ISGID | S_ISVTX)))
+    {
+      /* We did not call chmod so far, so the special bits have not yet
+         been set.  */
+      return chmod_or_fchmod (name, desc, mode);
+    }
+  return 0;
+
+# elif HAVE_GETACL /* HP-UX */
+
+  struct stat statbuf;
+  int ret;
+
+  if (desc != -1)
+    ret = fstat (desc, &statbuf);
+  else
+    ret = stat (name, &statbuf);
+  if (ret < 0)
+    return -1;
+
+  {
+    struct acl_entry entries[3];
+
+    entries[0].uid = statbuf.st_uid;
+    entries[0].gid = ACL_NSGROUP;
+    entries[0].mode = (mode >> 6) & 7;
+    entries[1].uid = ACL_NSUSER;
+    entries[1].gid = statbuf.st_gid;
+    entries[1].mode = (mode >> 3) & 7;
+    entries[2].uid = ACL_NSUSER;
+    entries[2].gid = ACL_NSGROUP;
+    entries[2].mode = mode & 7;
+
+    if (desc != -1)
+      ret = fsetacl (desc, sizeof (entries) / sizeof (struct acl_entry), entries);
+    else
+      ret = setacl (name, sizeof (entries) / sizeof (struct acl_entry), entries);
+  }
+  if (ret < 0)
+    {
+      if (!(errno == ENOSYS || errno == EOPNOTSUPP || errno == ENOTSUP))
+        return -1;
+
+#  if HAVE_ACLV_H /* HP-UX >= 11.11 */
+      {
+        struct acl entries[4];
+
+        entries[0].a_type = USER_OBJ;
+        entries[0].a_id = 0; /* irrelevant */
+        entries[0].a_perm = (mode >> 6) & 7;
+        entries[1].a_type = GROUP_OBJ;
+        entries[1].a_id = 0; /* irrelevant */
+        entries[1].a_perm = (mode >> 3) & 7;
+        entries[2].a_type = CLASS_OBJ;
+        entries[2].a_id = 0;
+        entries[2].a_perm = (mode >> 3) & 7;
+        entries[3].a_type = OTHER_OBJ;
+        entries[3].a_id = 0;
+        entries[3].a_perm = mode & 7;
+
+        ret = aclsort (sizeof (entries) / sizeof (struct acl), 1, entries);
+        if (ret > 0)
+          abort ();
+        if (ret < 0)
+          {
+            if (0)
+              return chmod_or_fchmod (name, desc, mode);
+            return -1;
+          }
+
+        ret = acl ((char *) name, ACL_SET,
+                   sizeof (entries) / sizeof (struct acl), entries);
+        if (ret < 0)
+          {
+            if (errno == ENOSYS || errno == EOPNOTSUPP || errno == EINVAL)
+              return chmod_or_fchmod (name, desc, mode);
+            return -1;
+          }
+      }
+#  else
+      return chmod_or_fchmod (name, desc, mode);
+#  endif
+    }
+
+  if (mode & (S_ISUID | S_ISGID | S_ISVTX))
+    {
+      /* We did not call chmod so far, so the special bits have not yet
+         been set.  */
+      return chmod_or_fchmod (name, desc, mode);
+    }
+  return 0;
+
+# elif HAVE_ACLX_GET && defined ACL_AIX_WIP /* AIX */
+
+  acl_type_list_t types;
+  size_t types_size = sizeof (types);
+  acl_type_t type;
+
+  if (aclx_gettypes (name, &types, &types_size) < 0
+      || types.num_entries == 0)
+    return chmod_or_fchmod (name, desc, mode);
+
+  /* XXX Do we need to clear all types of ACLs for the given file, or is it
+     sufficient to clear the first one?  */
+  type = types.entries[0];
+  if (type.u64 == ACL_AIXC)
+    {
+      union { struct acl a; char room[128]; } u;
+      int ret;
+
+      u.a.acl_len = (char *) &u.a.acl_ext[0] - (char *) &u.a; /* no entries */
+      u.a.acl_mode = mode & ~(S_IXACL | 0777);
+      u.a.u_access = (mode >> 6) & 7;
+      u.a.g_access = (mode >> 3) & 7;
+      u.a.o_access = mode & 7;
+
+      if (desc != -1)
+        ret = aclx_fput (desc, SET_ACL | SET_MODE_S_BITS,
+                         type, &u.a, u.a.acl_len, mode);
+      else
+        ret = aclx_put (name, SET_ACL | SET_MODE_S_BITS,
+                        type, &u.a, u.a.acl_len, mode);
+      if (!(ret < 0 && errno == ENOSYS))
+        return ret;
+    }
+  else if (type.u64 == ACL_NFS4)
+    {
+      union { nfs4_acl_int_t a; char room[128]; } u;
+      nfs4_ace_int_t *ace;
+      int ret;
+
+      u.a.aclVersion = NFS4_ACL_INT_STRUCT_VERSION;
+      u.a.aclEntryN = 0;
+      ace = &u.a.aclEntry[0];
+      {
+        ace->flags = ACE4_ID_SPECIAL;
+        ace->aceWho.special_whoid = ACE4_WHO_OWNER;
+        ace->aceType = ACE4_ACCESS_ALLOWED_ACE_TYPE;
+        ace->aceFlags = 0;
+        ace->aceMask =
+          (mode & 0400 ? ACE4_READ_DATA | ACE4_LIST_DIRECTORY : 0)
+          | (mode & 0200
+             ? ACE4_WRITE_DATA | ACE4_ADD_FILE | ACE4_APPEND_DATA
+               | ACE4_ADD_SUBDIRECTORY
+             : 0)
+          | (mode & 0100 ? ACE4_EXECUTE : 0);
+        ace->aceWhoString[0] = '\0';
+        ace->entryLen = (char *) &ace->aceWhoString[4] - (char *) ace;
+        ace = (nfs4_ace_int_t *) (char *) &ace->aceWhoString[4];
+        u.a.aclEntryN++;
+      }
+      {
+        ace->flags = ACE4_ID_SPECIAL;
+        ace->aceWho.special_whoid = ACE4_WHO_GROUP;
+        ace->aceType = ACE4_ACCESS_ALLOWED_ACE_TYPE;
+        ace->aceFlags = 0;
+        ace->aceMask =
+          (mode & 0040 ? ACE4_READ_DATA | ACE4_LIST_DIRECTORY : 0)
+          | (mode & 0020
+             ? ACE4_WRITE_DATA | ACE4_ADD_FILE | ACE4_APPEND_DATA
+               | ACE4_ADD_SUBDIRECTORY
+             : 0)
+          | (mode & 0010 ? ACE4_EXECUTE : 0);
+        ace->aceWhoString[0] = '\0';
+        ace->entryLen = (char *) &ace->aceWhoString[4] - (char *) ace;
+        ace = (nfs4_ace_int_t *) (char *) &ace->aceWhoString[4];
+        u.a.aclEntryN++;
+      }
+      {
+        ace->flags = ACE4_ID_SPECIAL;
+        ace->aceWho.special_whoid = ACE4_WHO_EVERYONE;
+        ace->aceType = ACE4_ACCESS_ALLOWED_ACE_TYPE;
+        ace->aceFlags = 0;
+        ace->aceMask =
+          (mode & 0004 ? ACE4_READ_DATA | ACE4_LIST_DIRECTORY : 0)
+          | (mode & 0002
+             ? ACE4_WRITE_DATA | ACE4_ADD_FILE | ACE4_APPEND_DATA
+               | ACE4_ADD_SUBDIRECTORY
+             : 0)
+          | (mode & 0001 ? ACE4_EXECUTE : 0);
+        ace->aceWhoString[0] = '\0';
+        ace->entryLen = (char *) &ace->aceWhoString[4] - (char *) ace;
+        ace = (nfs4_ace_int_t *) (char *) &ace->aceWhoString[4];
+        u.a.aclEntryN++;
+      }
+      u.a.aclLength = (char *) ace - (char *) &u.a;
+
+      if (desc != -1)
+        ret = aclx_fput (desc, SET_ACL | SET_MODE_S_BITS,
+                         type, &u.a, u.a.aclLength, mode);
+      else
+        ret = aclx_put (name, SET_ACL | SET_MODE_S_BITS,
+                        type, &u.a, u.a.aclLength, mode);
+      if (!(ret < 0 && errno == ENOSYS))
+        return ret;
+    }
+
+  return chmod_or_fchmod (name, desc, mode);
+
+# elif HAVE_STATACL /* older AIX */
+
+  union { struct acl a; char room[128]; } u;
+  int ret;
+
+  u.a.acl_len = (char *) &u.a.acl_ext[0] - (char *) &u.a; /* no entries */
+  u.a.acl_mode = mode & ~(S_IXACL | 0777);
+  u.a.u_access = (mode >> 6) & 7;
+  u.a.g_access = (mode >> 3) & 7;
+  u.a.o_access = mode & 7;
+
+  if (desc != -1)
+    ret = fchacl (desc, &u.a, u.a.acl_len);
+  else
+    ret = chacl (name, &u.a, u.a.acl_len);
+
+  if (ret < 0 && errno == ENOSYS)
+    return chmod_or_fchmod (name, desc, mode);
+
+  return ret;
+
+# elif HAVE_ACLSORT /* NonStop Kernel */
+
+  struct acl entries[4];
+  int ret;
+
+  entries[0].a_type = USER_OBJ;
+  entries[0].a_id = 0; /* irrelevant */
+  entries[0].a_perm = (mode >> 6) & 7;
+  entries[1].a_type = GROUP_OBJ;
+  entries[1].a_id = 0; /* irrelevant */
+  entries[1].a_perm = (mode >> 3) & 7;
+  entries[2].a_type = CLASS_OBJ;
+  entries[2].a_id = 0;
+  entries[2].a_perm = (mode >> 3) & 7;
+  entries[3].a_type = OTHER_OBJ;
+  entries[3].a_id = 0;
+  entries[3].a_perm = mode & 7;
+
+  ret = aclsort (sizeof (entries) / sizeof (struct acl), 1, entries);
+  if (ret > 0)
+    abort ();
+  if (ret < 0)
+    {
+      if (0)
+        return chmod_or_fchmod (name, desc, mode);
+      return -1;
+    }
+
+  ret = acl ((char *) name, ACL_SET,
+             sizeof (entries) / sizeof (struct acl), entries);
+  if (ret < 0)
+    {
+      if (0)
+        return chmod_or_fchmod (name, desc, mode);
+      return -1;
+    }
+
+  if (mode & (S_ISUID | S_ISGID | S_ISVTX))
+    {
+      /* We did not call chmod so far, so the special bits have not yet
+         been set.  */
+      return chmod_or_fchmod (name, desc, mode);
+    }
+  return 0;
+
+# else /* Unknown flavor of ACLs */
+  return chmod_or_fchmod (name, desc, mode);
+# endif
+#else /* !USE_ACL */
+  return chmod_or_fchmod (name, desc, mode);
+#endif
+}
new file mode 100644
--- /dev/null
+++ b/lib/set-acl.c
@@ -0,0 +1,45 @@
+/* set-acl.c - set access control list equivalent to a mode
+
+   Copyright (C) 2002-2003, 2005-2013 Free Software Foundation, Inc.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   Written by Paul Eggert and Andreas Gruenbacher, and Bruno Haible.  */
+
+#include <config.h>
+
+#include "acl.h"
+
+#include "error.h"
+#include "gettext.h"
+#define _(msgid) gettext (msgid)
+
+
+/* Set the access control lists of a file. If DESC is a valid file
+   descriptor, use file descriptor operations where available, else use
+   filename based operations on NAME.  If access control lists are not
+   available, fchmod the target file to MODE.  Also sets the
+   non-permission bits of the destination file (S_ISUID, S_ISGID, S_ISVTX)
+   to those from MODE if any are set.
+   Return 0 if successful.  On failure, output a diagnostic, set errno and
+   return -1.  */
+
+int
+set_acl (char const *name, int desc, mode_t mode)
+{
+  int ret = qset_acl (name, desc, mode);
+  if (ret != 0)
+    error (0, errno, _("setting permissions for %s"), quote (name));
+  return ret;
+}
deleted file mode 100644
--- a/lib/set-mode-acl.c
+++ /dev/null
@@ -1,699 +0,0 @@
-/* set-mode-acl.c - set access control list equivalent to a mode
-
-   Copyright (C) 2002-2003, 2005-2013 Free Software Foundation, Inc.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 3 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-   Written by Paul Eggert and Andreas Gruenbacher, and Bruno Haible.  */
-
-#include <config.h>
-
-#define ACL_INTERNAL_INLINE _GL_EXTERN_INLINE
-
-#include "acl.h"
-
-#include "acl-internal.h"
-
-#include "gettext.h"
-#define _(msgid) gettext (msgid)
-
-
-/* If DESC is a valid file descriptor use fchmod to change the
-   file's mode to MODE on systems that have fchown. On systems
-   that don't have fchown and if DESC is invalid, use chown on
-   NAME instead.
-   Return 0 if successful.  Return -1 and set errno upon failure.  */
-
-int
-chmod_or_fchmod (const char *name, int desc, mode_t mode)
-{
-  if (HAVE_FCHMOD && desc != -1)
-    return fchmod (desc, mode);
-  else
-    return chmod (name, mode);
-}
-
-/* Set the access control lists of a file. If DESC is a valid file
-   descriptor, use file descriptor operations where available, else use
-   filename based operations on NAME.  If access control lists are not
-   available, fchmod the target file to MODE.  Also sets the
-   non-permission bits of the destination file (S_ISUID, S_ISGID, S_ISVTX)
-   to those from MODE if any are set.
-   Return 0 if successful.  Return -1 and set errno upon failure.  */
-
-int
-qset_acl (char const *name, int desc, mode_t mode)
-{
-#if USE_ACL
-# if HAVE_ACL_GET_FILE
-  /* POSIX 1003.1e draft 17 (abandoned) specific version.  */
-  /* Linux, FreeBSD, Mac OS X, IRIX, Tru64 */
-#  if !HAVE_ACL_TYPE_EXTENDED
-  /* Linux, FreeBSD, IRIX, Tru64 */
-
-  /* We must also have acl_from_text and acl_delete_def_file.
-     (acl_delete_def_file could be emulated with acl_init followed
-      by acl_set_file, but acl_set_file with an empty acl is
-      unspecified.)  */
-
-#   ifndef HAVE_ACL_FROM_TEXT
-#    error Must have acl_from_text (see POSIX 1003.1e draft 17).
-#   endif
-#   ifndef HAVE_ACL_DELETE_DEF_FILE
-#    error Must have acl_delete_def_file (see POSIX 1003.1e draft 17).
-#   endif
-
-  acl_t acl;
-  int ret;
-
-  if (HAVE_ACL_FROM_MODE) /* Linux */
-    {
-      acl = acl_from_mode (mode);
-      if (!acl)
-        return -1;
-    }
-  else /* FreeBSD, IRIX, Tru64 */
-    {
-      /* If we were to create the ACL using the functions acl_init(),
-         acl_create_entry(), acl_set_tag_type(), acl_set_qualifier(),
-         acl_get_permset(), acl_clear_perm[s](), acl_add_perm(), we
-         would need to create a qualifier.  I don't know how to do this.
-         So create it using acl_from_text().  */
-
-#   if HAVE_ACL_FREE_TEXT /* Tru64 */
-      char acl_text[] = "u::---,g::---,o::---,";
-#   else /* FreeBSD, IRIX */
-      char acl_text[] = "u::---,g::---,o::---";
-#   endif
-
-      if (mode & S_IRUSR) acl_text[ 3] = 'r';
-      if (mode & S_IWUSR) acl_text[ 4] = 'w';
-      if (mode & S_IXUSR) acl_text[ 5] = 'x';
-      if (mode & S_IRGRP) acl_text[10] = 'r';
-      if (mode & S_IWGRP) acl_text[11] = 'w';
-      if (mode & S_IXGRP) acl_text[12] = 'x';
-      if (mode & S_IROTH) acl_text[17] = 'r';
-      if (mode & S_IWOTH) acl_text[18] = 'w';
-      if (mode & S_IXOTH) acl_text[19] = 'x';
-
-      acl = acl_from_text (acl_text);
-      if (!acl)
-        return -1;
-    }
-  if (HAVE_ACL_SET_FD && desc != -1)
-    ret = acl_set_fd (desc, acl);
-  else
-    ret = acl_set_file (name, ACL_TYPE_ACCESS, acl);
-  if (ret != 0)
-    {
-      int saved_errno = errno;
-      acl_free (acl);
-
-      if (ACL_NOT_WELL_SUPPORTED (errno))
-        return chmod_or_fchmod (name, desc, mode);
-      else
-        {
-          errno = saved_errno;
-          return -1;
-        }
-    }
-  else
-    acl_free (acl);
-
-  if (S_ISDIR (mode) && acl_delete_def_file (name))
-    return -1;
-
-  if (!MODE_INSIDE_ACL || (mode & (S_ISUID | S_ISGID | S_ISVTX)))
-    {
-      /* We did not call chmod so far, and either the mode and the ACL are
-         separate or special bits are to be set which don't fit into ACLs.  */
-      return chmod_or_fchmod (name, desc, mode);
-    }
-  return 0;
-
-#  else /* HAVE_ACL_TYPE_EXTENDED */
-  /* Mac OS X */
-
-  /* On Mac OS X,  acl_get_file (name, ACL_TYPE_ACCESS)
-     and           acl_get_file (name, ACL_TYPE_DEFAULT)
-     always return NULL / EINVAL.  You have to use
-                   acl_get_file (name, ACL_TYPE_EXTENDED)
-     or            acl_get_fd (open (name, ...))
-     to retrieve an ACL.
-     On the other hand,
-                   acl_set_file (name, ACL_TYPE_ACCESS, acl)
-     and           acl_set_file (name, ACL_TYPE_DEFAULT, acl)
-     have the same effect as
-                   acl_set_file (name, ACL_TYPE_EXTENDED, acl):
-     Each of these calls sets the file's ACL.  */
-
-  acl_t acl;
-  int ret;
-
-  /* Remove the ACL if the file has ACLs.  */
-  if (HAVE_ACL_GET_FD && desc != -1)
-    acl = acl_get_fd (desc);
-  else
-    acl = acl_get_file (name, ACL_TYPE_EXTENDED);
-  if (acl)
-    {
-      acl_free (acl);
-
-      acl = acl_init (0);
-      if (acl)
-        {
-          if (HAVE_ACL_SET_FD && desc != -1)
-            ret = acl_set_fd (desc, acl);
-          else
-            ret = acl_set_file (name, ACL_TYPE_EXTENDED, acl);
-          if (ret != 0)
-            {
-              int saved_errno = errno;
-
-              acl_free (acl);
-
-              if (ACL_NOT_WELL_SUPPORTED (saved_errno))
-                return chmod_or_fchmod (name, desc, mode);
-              else
-                {
-                  errno = saved_errno;
-                  return -1;
-                }
-            }
-          acl_free (acl);
-        }
-    }
-
-  /* Since !MODE_INSIDE_ACL, we have to call chmod explicitly.  */
-  return chmod_or_fchmod (name, desc, mode);
-#  endif
-
-# elif HAVE_FACL && defined GETACL /* Solaris, Cygwin, not HP-UX */
-
-  int done_setacl = 0;
-
-#  ifdef ACE_GETACL
-  /* Solaris also has a different variant of ACLs, used in ZFS and NFSv4
-     file systems (whereas the other ones are used in UFS file systems).  */
-
-  /* The flags in the ace_t structure changed in a binary incompatible way
-     when ACL_NO_TRIVIAL etc. were introduced in <sys/acl.h> version 1.15.
-     How to distinguish the two conventions at runtime?
-     We fetch the existing ACL.  In the old convention, usually three ACEs have
-     a_flags = ACE_OWNER / ACE_GROUP / ACE_OTHER, in the range 0x0100..0x0400.
-     In the new convention, these values are not used.  */
-  int convention;
-
-  {
-    /* Initially, try to read the entries into a stack-allocated buffer.
-       Use malloc if it does not fit.  */
-    enum
-      {
-        alloc_init = 4000 / sizeof (ace_t), /* >= 3 */
-        alloc_max = MIN (INT_MAX, SIZE_MAX / sizeof (ace_t))
-      };
-    ace_t buf[alloc_init];
-    size_t alloc = alloc_init;
-    ace_t *entries = buf;
-    ace_t *malloced = NULL;
-    int count;
-
-    for (;;)
-      {
-        count = (desc != -1
-                 ? facl (desc, ACE_GETACL, alloc, entries)
-                 : acl (name, ACE_GETACL, alloc, entries));
-        if (count < 0 && errno == ENOSPC)
-          {
-            /* Increase the size of the buffer.  */
-            free (malloced);
-            if (alloc > alloc_max / 2)
-              {
-                errno = ENOMEM;
-                return -1;
-              }
-            alloc = 2 * alloc; /* <= alloc_max */
-            entries = malloced = (ace_t *) malloc (alloc * sizeof (ace_t));
-            if (entries == NULL)
-              {
-                errno = ENOMEM;
-                return -1;
-              }
-            continue;
-          }
-        break;
-      }
-
-    if (count <= 0)
-      convention = -1;
-    else
-      {
-        int i;
-
-        convention = 0;
-        for (i = 0; i < count; i++)
-          if (entries[i].a_flags & (OLD_ACE_OWNER | OLD_ACE_GROUP | OLD_ACE_OTHER))
-            {
-              convention = 1;
-              break;
-            }
-      }
-    free (malloced);
-  }
-
-  if (convention >= 0)
-    {
-      ace_t entries[6];
-      int count;
-      int ret;
-
-      if (convention)
-        {
-          /* Running on Solaris 10.  */
-          entries[0].a_type = OLD_ALLOW;
-          entries[0].a_flags = OLD_ACE_OWNER;
-          entries[0].a_who = 0; /* irrelevant */
-          entries[0].a_access_mask = (mode >> 6) & 7;
-          entries[1].a_type = OLD_ALLOW;
-          entries[1].a_flags = OLD_ACE_GROUP;
-          entries[1].a_who = 0; /* irrelevant */
-          entries[1].a_access_mask = (mode >> 3) & 7;
-          entries[2].a_type = OLD_ALLOW;
-          entries[2].a_flags = OLD_ACE_OTHER;
-          entries[2].a_who = 0;
-          entries[2].a_access_mask = mode & 7;
-          count = 3;
-        }
-      else
-        {
-          /* Running on Solaris 10 (newer version) or Solaris 11.
-             The details here were found through "/bin/ls -lvd somefiles".  */
-          entries[0].a_type = NEW_ACE_ACCESS_DENIED_ACE_TYPE;
-          entries[0].a_flags = NEW_ACE_OWNER;
-          entries[0].a_who = 0; /* irrelevant */
-          entries[0].a_access_mask = 0;
-          entries[1].a_type = NEW_ACE_ACCESS_ALLOWED_ACE_TYPE;
-          entries[1].a_flags = NEW_ACE_OWNER;
-          entries[1].a_who = 0; /* irrelevant */
-          entries[1].a_access_mask = NEW_ACE_WRITE_NAMED_ATTRS
-                                     | NEW_ACE_WRITE_ATTRIBUTES
-                                     | NEW_ACE_WRITE_ACL
-                                     | NEW_ACE_WRITE_OWNER;
-          if (mode & 0400)
-            entries[1].a_access_mask |= NEW_ACE_READ_DATA;
-          else
-            entries[0].a_access_mask |= NEW_ACE_READ_DATA;
-          if (mode & 0200)
-            entries[1].a_access_mask |= NEW_ACE_WRITE_DATA | NEW_ACE_APPEND_DATA;
-          else
-            entries[0].a_access_mask |= NEW_ACE_WRITE_DATA | NEW_ACE_APPEND_DATA;
-          if (mode & 0100)
-            entries[1].a_access_mask |= NEW_ACE_EXECUTE;
-          else
-            entries[0].a_access_mask |= NEW_ACE_EXECUTE;
-          entries[2].a_type = NEW_ACE_ACCESS_DENIED_ACE_TYPE;
-          entries[2].a_flags = NEW_ACE_GROUP | NEW_ACE_IDENTIFIER_GROUP;
-          entries[2].a_who = 0; /* irrelevant */
-          entries[2].a_access_mask = 0;
-          entries[3].a_type = NEW_ACE_ACCESS_ALLOWED_ACE_TYPE;
-          entries[3].a_flags = NEW_ACE_GROUP | NEW_ACE_IDENTIFIER_GROUP;
-          entries[3].a_who = 0; /* irrelevant */
-          entries[3].a_access_mask = 0;
-          if (mode & 0040)
-            entries[3].a_access_mask |= NEW_ACE_READ_DATA;
-          else
-            entries[2].a_access_mask |= NEW_ACE_READ_DATA;
-          if (mode & 0020)
-            entries[3].a_access_mask |= NEW_ACE_WRITE_DATA | NEW_ACE_APPEND_DATA;
-          else
-            entries[2].a_access_mask |= NEW_ACE_WRITE_DATA | NEW_ACE_APPEND_DATA;
-          if (mode & 0010)
-            entries[3].a_access_mask |= NEW_ACE_EXECUTE;
-          else
-            entries[2].a_access_mask |= NEW_ACE_EXECUTE;
-          entries[4].a_type = NEW_ACE_ACCESS_DENIED_ACE_TYPE;
-          entries[4].a_flags = NEW_ACE_EVERYONE;
-          entries[4].a_who = 0;
-          entries[4].a_access_mask = NEW_ACE_WRITE_NAMED_ATTRS
-                                     | NEW_ACE_WRITE_ATTRIBUTES
-                                     | NEW_ACE_WRITE_ACL
-                                     | NEW_ACE_WRITE_OWNER;
-          entries[5].a_type = NEW_ACE_ACCESS_ALLOWED_ACE_TYPE;
-          entries[5].a_flags = NEW_ACE_EVERYONE;
-          entries[5].a_who = 0;
-          entries[5].a_access_mask = NEW_ACE_READ_NAMED_ATTRS
-                                     | NEW_ACE_READ_ATTRIBUTES
-                                     | NEW_ACE_READ_ACL
-                                     | NEW_ACE_SYNCHRONIZE;
-          if (mode & 0004)
-            entries[5].a_access_mask |= NEW_ACE_READ_DATA;
-          else
-            entries[4].a_access_mask |= NEW_ACE_READ_DATA;
-          if (mode & 0002)
-            entries[5].a_access_mask |= NEW_ACE_WRITE_DATA | NEW_ACE_APPEND_DATA;
-          else
-            entries[4].a_access_mask |= NEW_ACE_WRITE_DATA | NEW_ACE_APPEND_DATA;
-          if (mode & 0001)
-            entries[5].a_access_mask |= NEW_ACE_EXECUTE;
-          else
-            entries[4].a_access_mask |= NEW_ACE_EXECUTE;
-          count = 6;
-        }
-      if (desc != -1)
-        ret = facl (desc, ACE_SETACL, count, entries);
-      else
-        ret = acl (name, ACE_SETACL, count, entries);
-      if (ret < 0 && errno != EINVAL && errno != ENOTSUP)
-        {
-          if (errno == ENOSYS)
-            return chmod_or_fchmod (name, desc, mode);
-          return -1;
-        }
-      if (ret == 0)
-        done_setacl = 1;
-    }
-#  endif
-
-  if (!done_setacl)
-    {
-      aclent_t entries[3];
-      int ret;
-
-      entries[0].a_type = USER_OBJ;
-      entries[0].a_id = 0; /* irrelevant */
-      entries[0].a_perm = (mode >> 6) & 7;
-      entries[1].a_type = GROUP_OBJ;
-      entries[1].a_id = 0; /* irrelevant */
-      entries[1].a_perm = (mode >> 3) & 7;
-      entries[2].a_type = OTHER_OBJ;
-      entries[2].a_id = 0;
-      entries[2].a_perm = mode & 7;
-
-      if (desc != -1)
-        ret = facl (desc, SETACL,
-                    sizeof (entries) / sizeof (aclent_t), entries);
-      else
-        ret = acl (name, SETACL,
-                   sizeof (entries) / sizeof (aclent_t), entries);
-      if (ret < 0)
-        {
-          if (errno == ENOSYS || errno == EOPNOTSUPP)
-            return chmod_or_fchmod (name, desc, mode);
-          return -1;
-        }
-    }
-
-  if (!MODE_INSIDE_ACL || (mode & (S_ISUID | S_ISGID | S_ISVTX)))
-    {
-      /* We did not call chmod so far, so the special bits have not yet
-         been set.  */
-      return chmod_or_fchmod (name, desc, mode);
-    }
-  return 0;
-
-# elif HAVE_GETACL /* HP-UX */
-
-  struct stat statbuf;
-  int ret;
-
-  if (desc != -1)
-    ret = fstat (desc, &statbuf);
-  else
-    ret = stat (name, &statbuf);
-  if (ret < 0)
-    return -1;
-
-  {
-    struct acl_entry entries[3];
-
-    entries[0].uid = statbuf.st_uid;
-    entries[0].gid = ACL_NSGROUP;
-    entries[0].mode = (mode >> 6) & 7;
-    entries[1].uid = ACL_NSUSER;
-    entries[1].gid = statbuf.st_gid;
-    entries[1].mode = (mode >> 3) & 7;
-    entries[2].uid = ACL_NSUSER;
-    entries[2].gid = ACL_NSGROUP;
-    entries[2].mode = mode & 7;
-
-    if (desc != -1)
-      ret = fsetacl (desc, sizeof (entries) / sizeof (struct acl_entry), entries);
-    else
-      ret = setacl (name, sizeof (entries) / sizeof (struct acl_entry), entries);
-  }
-  if (ret < 0)
-    {
-      if (!(errno == ENOSYS || errno == EOPNOTSUPP || errno == ENOTSUP))
-        return -1;
-
-#  if HAVE_ACLV_H /* HP-UX >= 11.11 */
-      {
-        struct acl entries[4];
-
-        entries[0].a_type = USER_OBJ;
-        entries[0].a_id = 0; /* irrelevant */
-        entries[0].a_perm = (mode >> 6) & 7;
-        entries[1].a_type = GROUP_OBJ;
-        entries[1].a_id = 0; /* irrelevant */
-        entries[1].a_perm = (mode >> 3) & 7;
-        entries[2].a_type = CLASS_OBJ;
-        entries[2].a_id = 0;
-        entries[2].a_perm = (mode >> 3) & 7;
-        entries[3].a_type = OTHER_OBJ;
-        entries[3].a_id = 0;
-        entries[3].a_perm = mode & 7;
-
-        ret = aclsort (sizeof (entries) / sizeof (struct acl), 1, entries);
-        if (ret > 0)
-          abort ();
-        if (ret < 0)
-          {
-            if (0)
-              return chmod_or_fchmod (name, desc, mode);
-            return -1;
-          }
-
-        ret = acl ((char *) name, ACL_SET,
-                   sizeof (entries) / sizeof (struct acl), entries);
-        if (ret < 0)
-          {
-            if (errno == ENOSYS || errno == EOPNOTSUPP || errno == EINVAL)
-              return chmod_or_fchmod (name, desc, mode);
-            return -1;
-          }
-      }
-#  else
-      return chmod_or_fchmod (name, desc, mode);
-#  endif
-    }
-
-  if (mode & (S_ISUID | S_ISGID | S_ISVTX))
-    {
-      /* We did not call chmod so far, so the special bits have not yet
-         been set.  */
-      return chmod_or_fchmod (name, desc, mode);
-    }
-  return 0;
-
-# elif HAVE_ACLX_GET && defined ACL_AIX_WIP /* AIX */
-
-  acl_type_list_t types;
-  size_t types_size = sizeof (types);
-  acl_type_t type;
-
-  if (aclx_gettypes (name, &types, &types_size) < 0
-      || types.num_entries == 0)
-    return chmod_or_fchmod (name, desc, mode);
-
-  /* XXX Do we need to clear all types of ACLs for the given file, or is it
-     sufficient to clear the first one?  */
-  type = types.entries[0];
-  if (type.u64 == ACL_AIXC)
-    {
-      union { struct acl a; char room[128]; } u;
-      int ret;
-
-      u.a.acl_len = (char *) &u.a.acl_ext[0] - (char *) &u.a; /* no entries */
-      u.a.acl_mode = mode & ~(S_IXACL | 0777);
-      u.a.u_access = (mode >> 6) & 7;
-      u.a.g_access = (mode >> 3) & 7;
-      u.a.o_access = mode & 7;
-
-      if (desc != -1)
-        ret = aclx_fput (desc, SET_ACL | SET_MODE_S_BITS,
-                         type, &u.a, u.a.acl_len, mode);
-      else
-        ret = aclx_put (name, SET_ACL | SET_MODE_S_BITS,
-                        type, &u.a, u.a.acl_len, mode);
-      if (!(ret < 0 && errno == ENOSYS))
-        return ret;
-    }
-  else if (type.u64 == ACL_NFS4)
-    {
-      union { nfs4_acl_int_t a; char room[128]; } u;
-      nfs4_ace_int_t *ace;
-      int ret;
-
-      u.a.aclVersion = NFS4_ACL_INT_STRUCT_VERSION;
-      u.a.aclEntryN = 0;
-      ace = &u.a.aclEntry[0];
-      {
-        ace->flags = ACE4_ID_SPECIAL;
-        ace->aceWho.special_whoid = ACE4_WHO_OWNER;
-        ace->aceType = ACE4_ACCESS_ALLOWED_ACE_TYPE;
-        ace->aceFlags = 0;
-        ace->aceMask =
-          (mode & 0400 ? ACE4_READ_DATA | ACE4_LIST_DIRECTORY : 0)
-          | (mode & 0200
-             ? ACE4_WRITE_DATA | ACE4_ADD_FILE | ACE4_APPEND_DATA
-               | ACE4_ADD_SUBDIRECTORY
-             : 0)
-          | (mode & 0100 ? ACE4_EXECUTE : 0);
-        ace->aceWhoString[0] = '\0';
-        ace->entryLen = (char *) &ace->aceWhoString[4] - (char *) ace;
-        ace = (nfs4_ace_int_t *) (char *) &ace->aceWhoString[4];
-        u.a.aclEntryN++;
-      }
-      {
-        ace->flags = ACE4_ID_SPECIAL;
-        ace->aceWho.special_whoid = ACE4_WHO_GROUP;
-        ace->aceType = ACE4_ACCESS_ALLOWED_ACE_TYPE;
-        ace->aceFlags = 0;
-        ace->aceMask =
-          (mode & 0040 ? ACE4_READ_DATA | ACE4_LIST_DIRECTORY : 0)
-          | (mode & 0020
-             ? ACE4_WRITE_DATA | ACE4_ADD_FILE | ACE4_APPEND_DATA
-               | ACE4_ADD_SUBDIRECTORY
-             : 0)
-          | (mode & 0010 ? ACE4_EXECUTE : 0);
-        ace->aceWhoString[0] = '\0';
-        ace->entryLen = (char *) &ace->aceWhoString[4] - (char *) ace;
-        ace = (nfs4_ace_int_t *) (char *) &ace->aceWhoString[4];
-        u.a.aclEntryN++;
-      }
-      {
-        ace->flags = ACE4_ID_SPECIAL;
-        ace->aceWho.special_whoid = ACE4_WHO_EVERYONE;
-        ace->aceType = ACE4_ACCESS_ALLOWED_ACE_TYPE;
-        ace->aceFlags = 0;
-        ace->aceMask =
-          (mode & 0004 ? ACE4_READ_DATA | ACE4_LIST_DIRECTORY : 0)
-          | (mode & 0002
-             ? ACE4_WRITE_DATA | ACE4_ADD_FILE | ACE4_APPEND_DATA
-               | ACE4_ADD_SUBDIRECTORY
-             : 0)
-          | (mode & 0001 ? ACE4_EXECUTE : 0);
-        ace->aceWhoString[0] = '\0';
-        ace->entryLen = (char *) &ace->aceWhoString[4] - (char *) ace;
-        ace = (nfs4_ace_int_t *) (char *) &ace->aceWhoString[4];
-        u.a.aclEntryN++;
-      }
-      u.a.aclLength = (char *) ace - (char *) &u.a;
-
-      if (desc != -1)
-        ret = aclx_fput (desc, SET_ACL | SET_MODE_S_BITS,
-                         type, &u.a, u.a.aclLength, mode);
-      else
-        ret = aclx_put (name, SET_ACL | SET_MODE_S_BITS,
-                        type, &u.a, u.a.aclLength, mode);
-      if (!(ret < 0 && errno == ENOSYS))
-        return ret;
-    }
-
-  return chmod_or_fchmod (name, desc, mode);
-
-# elif HAVE_STATACL /* older AIX */
-
-  union { struct acl a; char room[128]; } u;
-  int ret;
-
-  u.a.acl_len = (char *) &u.a.acl_ext[0] - (char *) &u.a; /* no entries */
-  u.a.acl_mode = mode & ~(S_IXACL | 0777);
-  u.a.u_access = (mode >> 6) & 7;
-  u.a.g_access = (mode >> 3) & 7;
-  u.a.o_access = mode & 7;
-
-  if (desc != -1)
-    ret = fchacl (desc, &u.a, u.a.acl_len);
-  else
-    ret = chacl (name, &u.a, u.a.acl_len);
-
-  if (ret < 0 && errno == ENOSYS)
-    return chmod_or_fchmod (name, desc, mode);
-
-  return ret;
-
-# elif HAVE_ACLSORT /* NonStop Kernel */
-
-  struct acl entries[4];
-  int ret;
-
-  entries[0].a_type = USER_OBJ;
-  entries[0].a_id = 0; /* irrelevant */
-  entries[0].a_perm = (mode >> 6) & 7;
-  entries[1].a_type = GROUP_OBJ;
-  entries[1].a_id = 0; /* irrelevant */
-  entries[1].a_perm = (mode >> 3) & 7;
-  entries[2].a_type = CLASS_OBJ;
-  entries[2].a_id = 0;
-  entries[2].a_perm = (mode >> 3) & 7;
-  entries[3].a_type = OTHER_OBJ;
-  entries[3].a_id = 0;
-  entries[3].a_perm = mode & 7;
-
-  ret = aclsort (sizeof (entries) / sizeof (struct acl), 1, entries);
-  if (ret > 0)
-    abort ();
-  if (ret < 0)
-    {
-      if (0)
-        return chmod_or_fchmod (name, desc, mode);
-      return -1;
-    }
-
-  ret = acl ((char *) name, ACL_SET,
-             sizeof (entries) / sizeof (struct acl), entries);
-  if (ret < 0)
-    {
-      if (0)
-        return chmod_or_fchmod (name, desc, mode);
-      return -1;
-    }
-
-  if (mode & (S_ISUID | S_ISGID | S_ISVTX))
-    {
-      /* We did not call chmod so far, so the special bits have not yet
-         been set.  */
-      return chmod_or_fchmod (name, desc, mode);
-    }
-  return 0;
-
-# else /* Unknown flavor of ACLs */
-  return chmod_or_fchmod (name, desc, mode);
-# endif
-#else /* !USE_ACL */
-  return chmod_or_fchmod (name, desc, mode);
-#endif
-}
-
-/* As with qset_acl, but also output a diagnostic on failure.  */
-
-int
-set_acl (char const *name, int desc, mode_t mode)
-{
-  int ret = qset_acl (name, desc, mode);
-  if (ret != 0)
-    error (0, errno, _("setting permissions for %s"), quote (name));
-  return ret;
-}
--- a/modules/acl
+++ b/modules/acl
@@ -1,28 +1,20 @@
 Description:
-Access control lists of files.  (Unportable.)
+Access control lists of files, with diagnostics.  (Unportable.)
 
 Files:
-lib/acl.h
-lib/acl-internal.h
-lib/acl_entries.c
-lib/set-mode-acl.c
 lib/copy-acl.c
-lib/file-has-acl.c
-m4/acl.m4
+lib/set-acl.c
 
 Depends-on:
 error
-extern-inline
-fstat
 gettext-h
+qacl
 quote
-sys_stat
 
 configure.ac:
-gl_FUNC_ACL
 
 Makefile.am:
-lib_SOURCES += set-mode-acl.c copy-acl.c file-has-acl.c
+lib_SOURCES += copy-acl.c set-acl.c
 
 Include:
 "acl.h"
new file mode 100644
--- /dev/null
+++ b/modules/qacl
@@ -0,0 +1,36 @@
+Description:
+Access control lists of files.  (Unportable.)
+
+Files:
+lib/acl.h
+lib/acl-internal.h
+lib/acl-errno-valid.c
+lib/acl_entries.c
+lib/file-has-acl.c
+lib/qcopy-acl.c
+lib/qset-acl.c
+m4/acl.m4
+
+Depends-on:
+extern-inline
+fstat
+stdbool
+sys_stat
+
+configure.ac:
+gl_FUNC_ACL
+
+Makefile.am:
+lib_SOURCES += acl-errno-valid.c file-has-acl.c qcopy-acl.c qset-acl.c
+
+Include:
+"acl.h"
+
+Link:
+$(LIB_ACL)
+
+License:
+GPL
+
+Maintainer:
+Paul Eggert, Jim Meyering, Bruno Haible