Author: mm
Date: Fri Mar 31 20:17:30 2017
New Revision: 316338
URL: https://svnweb.freebsd.org/changeset/base/316338

Log:
  MFC r315636,315876,316095:
  Sync libarchive with vendor
  
  Vendor changes/bugfixes (FreeBSD-related):
  r315636:
    PR 867 (bsdcpio): show numeric uid/gid when names are not found
    PR 870 (seekable zip): accept files with valid ZIP64 EOCD headers
    PR 880 (pax): Fix handling of "size" pax header keyword
    PR 887 (crypto): Discard 3072 bytes instead of 1024 of first keystream
    OSS-Fuzz issue 806 (mtree): rework mtree_atol10 integer parser
    Break ACL read/write code into platform-specific source files
  
  r315876:
    Store extended attributes with extattr_set_link() if no fd is provided
    Add extended attribute tests to libarchive and bsdtar
    Fix tar's test_option_acls
    Support the UF_HIDDEN file flag
  
  r316095:
    Constify variables in several places
    Unify platform ACL code in a single source file
    Fix unused variable if compiling on FreeBSD without NFSv4 ACL support

Added:
  stable/10/contrib/libarchive/libarchive/archive_disk_acl_freebsd.c
     - copied unchanged from r316095, 
head/contrib/libarchive/libarchive/archive_disk_acl_freebsd.c
  stable/10/contrib/libarchive/libarchive/archive_platform_acl.h
     - copied unchanged from r315636, 
head/contrib/libarchive/libarchive/archive_platform_acl.h
  stable/10/contrib/libarchive/libarchive/archive_platform_xattr.h
     - copied unchanged from r315876, 
head/contrib/libarchive/libarchive/archive_platform_xattr.h
  stable/10/contrib/libarchive/libarchive/archive_version_details.c
     - copied unchanged from r315636, 
head/contrib/libarchive/libarchive/archive_version_details.c
  stable/10/contrib/libarchive/libarchive/test/test_xattr_platform.c
     - copied unchanged from r315876, 
head/contrib/libarchive/libarchive/test/test_xattr_platform.c
  stable/10/contrib/libarchive/tar/test/test_option_xattrs.c
     - copied unchanged from r315876, 
head/contrib/libarchive/tar/test/test_option_xattrs.c
Deleted:
  stable/10/contrib/libarchive/libarchive/archive_write_disk_acl.c
Modified:
  stable/10/contrib/libarchive/FREEBSD-Xlist
  stable/10/contrib/libarchive/NEWS
  stable/10/contrib/libarchive/cpio/cpio.c
  stable/10/contrib/libarchive/libarchive/archive_entry.3
  stable/10/contrib/libarchive/libarchive/archive_entry.c
  stable/10/contrib/libarchive/libarchive/archive_entry_acl.3
  stable/10/contrib/libarchive/libarchive/archive_getdate.c
  stable/10/contrib/libarchive/libarchive/archive_pack_dev.c
  stable/10/contrib/libarchive/libarchive/archive_platform.h
  stable/10/contrib/libarchive/libarchive/archive_random.c
  stable/10/contrib/libarchive/libarchive/archive_read_disk_entry_from_file.c
  stable/10/contrib/libarchive/libarchive/archive_read_disk_private.h
  stable/10/contrib/libarchive/libarchive/archive_read_open.3
  stable/10/contrib/libarchive/libarchive/archive_read_support_format_cab.c
  stable/10/contrib/libarchive/libarchive/archive_read_support_format_lha.c
  stable/10/contrib/libarchive/libarchive/archive_read_support_format_mtree.c
  stable/10/contrib/libarchive/libarchive/archive_read_support_format_tar.c
  stable/10/contrib/libarchive/libarchive/archive_read_support_format_zip.c
  stable/10/contrib/libarchive/libarchive/archive_string_sprintf.c
  stable/10/contrib/libarchive/libarchive/archive_util.c
  stable/10/contrib/libarchive/libarchive/archive_write_add_filter.c
  stable/10/contrib/libarchive/libarchive/archive_write_add_filter_by_name.c
  stable/10/contrib/libarchive/libarchive/archive_write_add_filter_lz4.c
  stable/10/contrib/libarchive/libarchive/archive_write_add_filter_program.c
  stable/10/contrib/libarchive/libarchive/archive_write_disk_posix.c
  stable/10/contrib/libarchive/libarchive/archive_write_disk_private.h
  stable/10/contrib/libarchive/libarchive/archive_write_set_format.c
  stable/10/contrib/libarchive/libarchive/archive_write_set_format_by_name.c
  
stable/10/contrib/libarchive/libarchive/archive_write_set_format_filter_by_ext.c
  stable/10/contrib/libarchive/libarchive/archive_write_set_format_warc.c
  stable/10/contrib/libarchive/libarchive/test/test_acl_platform_nfs4.c
  stable/10/contrib/libarchive/libarchive/test/test_acl_platform_posix1e.c
  stable/10/contrib/libarchive/tar/bsdtar.1
  stable/10/contrib/libarchive/tar/test/test_option_acls.c
  stable/10/contrib/libarchive/test_utils/test_common.h
  stable/10/contrib/libarchive/test_utils/test_main.c
  stable/10/lib/libarchive/Makefile
  stable/10/lib/libarchive/config_freebsd.h
  stable/10/lib/libarchive/tests/Makefile
  stable/10/usr.bin/bsdcat/tests/Makefile
  stable/10/usr.bin/cpio/tests/Makefile
  stable/10/usr.bin/tar/tests/Makefile
Directory Properties:
  stable/10/   (props changed)

Modified: stable/10/contrib/libarchive/FREEBSD-Xlist
==============================================================================
--- stable/10/contrib/libarchive/FREEBSD-Xlist  Fri Mar 31 20:16:24 2017        
(r316337)
+++ stable/10/contrib/libarchive/FREEBSD-Xlist  Fri Mar 31 20:17:30 2017        
(r316338)
@@ -21,6 +21,9 @@ doc
 examples
 libarchive/CMakeLists.txt
 libarchive/archive_entry_copy_bhfi.c
+libarchive/archive_disk_acl_darwin.c
+libarchive/archive_disk_acl_linux.c
+libarchive/archive_disk_acl_sunos.c
 libarchive/archive_read_disk_windows.c
 libarchive/archive_windows.c
 libarchive/archive_windows.h

Modified: stable/10/contrib/libarchive/NEWS
==============================================================================
--- stable/10/contrib/libarchive/NEWS   Fri Mar 31 20:16:24 2017        
(r316337)
+++ stable/10/contrib/libarchive/NEWS   Fri Mar 31 20:17:30 2017        
(r316338)
@@ -1,3 +1,5 @@
+Mar 16, 2017: NFSv4 ACL support for Linux (librichacl)
+
 Feb 26, 2017: libarchive 3.3.1 released
     Security & Feature release
 
@@ -293,7 +295,7 @@ May 04, 2008: libarchive 2.5.3b released
        * libarchive: Mark which entry strings are set; be accurate about
          distinguishing empty strings ("") from unset ones (NULL)
        * tar: Don't crash reading entries with empty filenames
-       * libarchive_test, bsdtar_test, bsdcpio_test:  Better detaults:
+       * libarchive_test, bsdtar_test, bsdcpio_test:  Better defaults:
          run all tests, delete temp dirs, summarize repeated failures
        * -no-undefined to libtool for Cygwin
        * libarchive_test: Skip large file tests on systems with 32-bit off_t

Modified: stable/10/contrib/libarchive/cpio/cpio.c
==============================================================================
--- stable/10/contrib/libarchive/cpio/cpio.c    Fri Mar 31 20:16:24 2017        
(r316337)
+++ stable/10/contrib/libarchive/cpio/cpio.c    Fri Mar 31 20:17:30 2017        
(r316338)
@@ -1344,23 +1344,23 @@ lookup_name(struct cpio *cpio, struct na
                cache->cache[slot].name = NULL;
        }
 
-       if (lookup_fn(cpio, &name, id) == 0) {
-               if (name == NULL || name[0] == '\0') {
-                       /* If lookup failed, format it as a number. */
-                       snprintf(asnum, sizeof(asnum), "%u", (unsigned)id);
-                       name = asnum;
-               }
-               cache->cache[slot].name = strdup(name);
-               if (cache->cache[slot].name != NULL) {
-                       cache->cache[slot].id = id;
-                       return (cache->cache[slot].name);
-               }
-               /*
-                * Conveniently, NULL marks an empty slot, so
-                * if the strdup() fails, we've just failed to
-                * cache it.  No recovery necessary.
-                */
-       }
+       if (lookup_fn(cpio, &name, id)) {
+               /* If lookup failed, format it as a number. */
+               snprintf(asnum, sizeof(asnum), "%u", (unsigned)id);
+               name = asnum;
+       }
+
+       cache->cache[slot].name = strdup(name);
+       if (cache->cache[slot].name != NULL) {
+               cache->cache[slot].id = id;
+               return (cache->cache[slot].name);
+       }
+
+       /*
+        * Conveniently, NULL marks an empty slot, so
+        * if the strdup() fails, we've just failed to
+        * cache it.  No recovery necessary.
+        */
        return (NULL);
 }
 
@@ -1381,15 +1381,14 @@ lookup_uname_helper(struct cpio *cpio, c
        errno = 0;
        pwent = getpwuid((uid_t)id);
        if (pwent == NULL) {
-               *name = NULL;
-               if (errno != 0 && errno != ENOENT)
+               if (errno && errno != ENOENT)
                        lafe_warnc(errno, "getpwuid(%s) failed",
                            cpio_i64toa((int64_t)id));
-               return (errno);
+               return 1;
        }
 
        *name = pwent->pw_name;
-       return (0);
+       return 0;
 }
 
 static const char *
@@ -1409,15 +1408,14 @@ lookup_gname_helper(struct cpio *cpio, c
        errno = 0;
        grent = getgrgid((gid_t)id);
        if (grent == NULL) {
-               *name = NULL;
-               if (errno != 0)
+               if (errno && errno != ENOENT)
                        lafe_warnc(errno, "getgrgid(%s) failed",
                            cpio_i64toa((int64_t)id));
-               return (errno);
+               return 1;
        }
 
        *name = grent->gr_name;
-       return (0);
+       return 0;
 }
 
 /*

Copied: stable/10/contrib/libarchive/libarchive/archive_disk_acl_freebsd.c 
(from r316095, head/contrib/libarchive/libarchive/archive_disk_acl_freebsd.c)
==============================================================================
--- /dev/null   00:00:00 1970   (empty, because file is newly added)
+++ stable/10/contrib/libarchive/libarchive/archive_disk_acl_freebsd.c  Fri Mar 
31 20:17:30 2017        (r316338, copy of r316095, 
head/contrib/libarchive/libarchive/archive_disk_acl_freebsd.c)
@@ -0,0 +1,700 @@
+/*-
+ * Copyright (c) 2003-2009 Tim Kientzle
+ * Copyright (c) 2010-2012 Michihiro NAKAJIMA
+ * Copyright (c) 2017 Martin Matuska
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "archive_platform.h"
+
+#if ARCHIVE_ACL_FREEBSD
+
+#ifdef HAVE_ERRNO_H
+#include <errno.h>
+#endif
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_ACL_H
+#define _ACL_PRIVATE /* For debugging */
+#include <sys/acl.h>
+#endif
+
+#include "archive_entry.h"
+#include "archive_private.h"
+#include "archive_read_disk_private.h"
+#include "archive_write_disk_private.h"
+
+typedef struct {
+       const int a_perm;       /* Libarchive permission or flag */
+       const int p_perm;       /* Platform permission or flag */
+} acl_perm_map_t;
+
+static const acl_perm_map_t acl_posix_perm_map[] = {
+       {ARCHIVE_ENTRY_ACL_EXECUTE, ACL_EXECUTE},
+       {ARCHIVE_ENTRY_ACL_WRITE, ACL_WRITE},
+       {ARCHIVE_ENTRY_ACL_READ, ACL_READ},
+};
+
+static const int acl_posix_perm_map_size =
+    (int)(sizeof(acl_posix_perm_map)/sizeof(acl_posix_perm_map[0]));
+
+#if ARCHIVE_ACL_FREEBSD_NFS4
+static const acl_perm_map_t acl_nfs4_perm_map[] = {
+       {ARCHIVE_ENTRY_ACL_EXECUTE, ACL_EXECUTE},
+       {ARCHIVE_ENTRY_ACL_READ_DATA, ACL_READ_DATA},
+       {ARCHIVE_ENTRY_ACL_LIST_DIRECTORY, ACL_LIST_DIRECTORY},
+       {ARCHIVE_ENTRY_ACL_WRITE_DATA, ACL_WRITE_DATA},
+       {ARCHIVE_ENTRY_ACL_ADD_FILE, ACL_ADD_FILE},
+       {ARCHIVE_ENTRY_ACL_APPEND_DATA, ACL_APPEND_DATA},
+       {ARCHIVE_ENTRY_ACL_ADD_SUBDIRECTORY, ACL_ADD_SUBDIRECTORY},
+       {ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS, ACL_READ_NAMED_ATTRS},
+       {ARCHIVE_ENTRY_ACL_WRITE_NAMED_ATTRS, ACL_WRITE_NAMED_ATTRS},
+       {ARCHIVE_ENTRY_ACL_DELETE_CHILD, ACL_DELETE_CHILD},
+       {ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES, ACL_READ_ATTRIBUTES},
+       {ARCHIVE_ENTRY_ACL_WRITE_ATTRIBUTES, ACL_WRITE_ATTRIBUTES},
+       {ARCHIVE_ENTRY_ACL_DELETE, ACL_DELETE},
+       {ARCHIVE_ENTRY_ACL_READ_ACL, ACL_READ_ACL},
+       {ARCHIVE_ENTRY_ACL_WRITE_ACL, ACL_WRITE_ACL},
+       {ARCHIVE_ENTRY_ACL_WRITE_OWNER, ACL_WRITE_OWNER},
+       {ARCHIVE_ENTRY_ACL_SYNCHRONIZE, ACL_SYNCHRONIZE}
+};
+
+static const int acl_nfs4_perm_map_size =
+    (int)(sizeof(acl_nfs4_perm_map)/sizeof(acl_nfs4_perm_map[0]));
+
+static const acl_perm_map_t acl_nfs4_flag_map[] = {
+       {ARCHIVE_ENTRY_ACL_ENTRY_FILE_INHERIT, ACL_ENTRY_FILE_INHERIT},
+       {ARCHIVE_ENTRY_ACL_ENTRY_DIRECTORY_INHERIT, 
ACL_ENTRY_DIRECTORY_INHERIT},
+       {ARCHIVE_ENTRY_ACL_ENTRY_NO_PROPAGATE_INHERIT, 
ACL_ENTRY_NO_PROPAGATE_INHERIT},
+       {ARCHIVE_ENTRY_ACL_ENTRY_INHERIT_ONLY, ACL_ENTRY_INHERIT_ONLY},
+       {ARCHIVE_ENTRY_ACL_ENTRY_SUCCESSFUL_ACCESS, 
ACL_ENTRY_SUCCESSFUL_ACCESS},
+       {ARCHIVE_ENTRY_ACL_ENTRY_FAILED_ACCESS, ACL_ENTRY_FAILED_ACCESS},
+       {ARCHIVE_ENTRY_ACL_ENTRY_INHERITED, ACL_ENTRY_INHERITED}
+};
+
+static const int acl_nfs4_flag_map_size =
+    (int)(sizeof(acl_nfs4_flag_map)/sizeof(acl_nfs4_flag_map[0]));
+#endif /* ARCHIVE_ACL_FREEBSD_NFS4 */
+
+static int
+translate_acl(struct archive_read_disk *a,
+    struct archive_entry *entry, acl_t acl, int default_entry_acl_type)
+{
+#if ARCHIVE_ACL_FREEBSD_NFS4
+       int brand;
+       acl_flagset_t    acl_flagset;
+       acl_entry_type_t acl_type;
+#endif
+       acl_tag_t        acl_tag;
+       acl_entry_t      acl_entry;
+       acl_permset_t    acl_permset;
+       int              i, entry_acl_type, perm_map_size;
+       const acl_perm_map_t    *perm_map;
+       int              r, s, ae_id, ae_tag, ae_perm;
+       void            *q;
+       const char      *ae_name;
+
+#if ARCHIVE_ACL_FREEBSD_NFS4
+       // FreeBSD "brands" ACLs as POSIX.1e or NFSv4
+       // Make sure the "brand" on this ACL is consistent
+       // with the default_entry_acl_type bits provided.
+       if (acl_get_brand_np(acl, &brand) != 0) {
+               archive_set_error(&a->archive, errno,
+                   "Failed to read ACL brand");
+               return (ARCHIVE_WARN);
+       }
+       switch (brand) {
+       case ACL_BRAND_POSIX:
+               switch (default_entry_acl_type) {
+               case ARCHIVE_ENTRY_ACL_TYPE_ACCESS:
+               case ARCHIVE_ENTRY_ACL_TYPE_DEFAULT:
+                       break;
+               default:
+                       archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
+                           "Invalid ACL entry type for POSIX.1e ACL");
+                       return (ARCHIVE_WARN);
+               }
+               break;
+       case ACL_BRAND_NFS4:
+               if (default_entry_acl_type & ~ARCHIVE_ENTRY_ACL_TYPE_NFS4) {
+                       archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
+                           "Invalid ACL entry type for NFSv4 ACL");
+                       return (ARCHIVE_WARN);
+               }
+               break;
+       default:
+               archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
+                   "Unknown ACL brand");
+               return (ARCHIVE_WARN);
+       }
+#endif
+
+       s = acl_get_entry(acl, ACL_FIRST_ENTRY, &acl_entry);
+       if (s == -1) {
+               archive_set_error(&a->archive, errno,
+                   "Failed to get first ACL entry");
+               return (ARCHIVE_WARN);
+       }
+
+       while (s == 1) {
+               ae_id = -1;
+               ae_name = NULL;
+               ae_perm = 0;
+
+               if (acl_get_tag_type(acl_entry, &acl_tag) != 0) {
+                       archive_set_error(&a->archive, errno,
+                           "Failed to get ACL tag type");
+                       return (ARCHIVE_WARN);
+               }
+               switch (acl_tag) {
+               case ACL_USER:
+                       q = acl_get_qualifier(acl_entry);
+                       if (q != NULL) {
+                               ae_id = (int)*(uid_t *)q;
+                               acl_free(q);
+                               ae_name = archive_read_disk_uname(&a->archive,
+                                   ae_id);
+                       }
+                       ae_tag = ARCHIVE_ENTRY_ACL_USER;
+                       break;
+               case ACL_GROUP:
+                       q = acl_get_qualifier(acl_entry);
+                       if (q != NULL) {
+                               ae_id = (int)*(gid_t *)q;
+                               acl_free(q);
+                               ae_name = archive_read_disk_gname(&a->archive,
+                                   ae_id);
+                       }
+                       ae_tag = ARCHIVE_ENTRY_ACL_GROUP;
+                       break;
+               case ACL_MASK:
+                       ae_tag = ARCHIVE_ENTRY_ACL_MASK;
+                       break;
+               case ACL_USER_OBJ:
+                       ae_tag = ARCHIVE_ENTRY_ACL_USER_OBJ;
+                       break;
+               case ACL_GROUP_OBJ:
+                       ae_tag = ARCHIVE_ENTRY_ACL_GROUP_OBJ;
+                       break;
+               case ACL_OTHER:
+                       ae_tag = ARCHIVE_ENTRY_ACL_OTHER;
+                       break;
+#if ARCHIVE_ACL_FREEBSD_NFS4
+               case ACL_EVERYONE:
+                       ae_tag = ARCHIVE_ENTRY_ACL_EVERYONE;
+                       break;
+#endif
+               default:
+                       /* Skip types that libarchive can't support. */
+                       s = acl_get_entry(acl, ACL_NEXT_ENTRY, &acl_entry);
+                       continue;
+               }
+
+               // XXX acl_type maps to allow/deny/audit/YYYY bits
+               entry_acl_type = default_entry_acl_type;
+
+#if ARCHIVE_ACL_FREEBSD_NFS4
+               if (default_entry_acl_type & ARCHIVE_ENTRY_ACL_TYPE_NFS4) {
+                       /*
+                        * acl_get_entry_type_np() fails with non-NFSv4 ACLs
+                        */
+                       if (acl_get_entry_type_np(acl_entry, &acl_type) != 0) {
+                               archive_set_error(&a->archive, errno, "Failed "
+                                   "to get ACL type from a NFSv4 ACL entry");
+                               return (ARCHIVE_WARN);
+                       }
+                       switch (acl_type) {
+                       case ACL_ENTRY_TYPE_ALLOW:
+                               entry_acl_type = ARCHIVE_ENTRY_ACL_TYPE_ALLOW;
+                               break;
+                       case ACL_ENTRY_TYPE_DENY:
+                               entry_acl_type = ARCHIVE_ENTRY_ACL_TYPE_DENY;
+                               break;
+                       case ACL_ENTRY_TYPE_AUDIT:
+                               entry_acl_type = ARCHIVE_ENTRY_ACL_TYPE_AUDIT;
+                               break;
+                       case ACL_ENTRY_TYPE_ALARM:
+                               entry_acl_type = ARCHIVE_ENTRY_ACL_TYPE_ALARM;
+                               break;
+                       default:
+                               archive_set_error(&a->archive, errno,
+                                   "Invalid NFSv4 ACL entry type");
+                               return (ARCHIVE_WARN);
+                       }
+
+                       /*
+                        * Libarchive stores "flag" (NFSv4 inheritance bits)
+                        * in the ae_perm bitmap.
+                        *
+                        * acl_get_flagset_np() fails with non-NFSv4 ACLs
+                        */
+                       if (acl_get_flagset_np(acl_entry, &acl_flagset) != 0) {
+                               archive_set_error(&a->archive, errno,
+                                   "Failed to get flagset from a NFSv4 "
+                                   "ACL entry");
+                               return (ARCHIVE_WARN);
+                       }
+                       for (i = 0; i < acl_nfs4_flag_map_size; ++i) {
+                               r = acl_get_flag_np(acl_flagset,
+                                   acl_nfs4_flag_map[i].p_perm);
+                               if (r == -1) {
+                                       archive_set_error(&a->archive, errno,
+                                           "Failed to check flag in a NFSv4 "
+                                           "ACL flagset");
+                                       return (ARCHIVE_WARN);
+                               } else if (r)
+                                       ae_perm |= acl_nfs4_flag_map[i].a_perm;
+                       }
+               }
+#endif
+
+               if (acl_get_permset(acl_entry, &acl_permset) != 0) {
+                       archive_set_error(&a->archive, errno,
+                           "Failed to get ACL permission set");
+                       return (ARCHIVE_WARN);
+               }
+
+#if ARCHIVE_ACL_FREEBSD_NFS4
+               if (default_entry_acl_type & ARCHIVE_ENTRY_ACL_TYPE_NFS4) {
+                       perm_map_size = acl_nfs4_perm_map_size;
+                       perm_map = acl_nfs4_perm_map;
+               } else {
+#endif
+                       perm_map_size = acl_posix_perm_map_size;
+                       perm_map = acl_posix_perm_map;
+#if ARCHIVE_ACL_FREEBSD_NFS4
+               }
+#endif
+
+               for (i = 0; i < perm_map_size; ++i) {
+                       r = acl_get_perm_np(acl_permset, perm_map[i].p_perm);
+                       if (r == -1) {
+                               archive_set_error(&a->archive, errno,
+                                   "Failed to check permission in an ACL "
+                                   "permission set");
+                               return (ARCHIVE_WARN);
+                       } else if (r)
+                               ae_perm |= perm_map[i].a_perm;
+               }
+
+               archive_entry_acl_add_entry(entry, entry_acl_type,
+                                           ae_perm, ae_tag,
+                                           ae_id, ae_name);
+
+               s = acl_get_entry(acl, ACL_NEXT_ENTRY, &acl_entry);
+               if (s == -1) {
+                       archive_set_error(&a->archive, errno,
+                           "Failed to get next ACL entry");
+                       return (ARCHIVE_WARN);
+               }
+       }
+       return (ARCHIVE_OK);
+}
+
+static int
+set_acl(struct archive *a, int fd, const char *name,
+    struct archive_acl *abstract_acl,
+    int ae_requested_type, const char *tname)
+{
+       int              acl_type = 0;
+       acl_t            acl;
+       acl_entry_t      acl_entry;
+       acl_permset_t    acl_permset;
+#if ARCHIVE_ACL_FREEBSD_NFS4
+       acl_flagset_t    acl_flagset;
+       int              r;
+#endif
+       int              ret;
+       int              ae_type, ae_permset, ae_tag, ae_id;
+       int              perm_map_size;
+       const acl_perm_map_t    *perm_map;
+       uid_t            ae_uid;
+       gid_t            ae_gid;
+       const char      *ae_name;
+       int              entries;
+       int              i;
+
+       ret = ARCHIVE_OK;
+       entries = archive_acl_reset(abstract_acl, ae_requested_type);
+       if (entries == 0)
+               return (ARCHIVE_OK);
+
+
+       switch (ae_requested_type) {
+       case ARCHIVE_ENTRY_ACL_TYPE_ACCESS:
+               acl_type = ACL_TYPE_ACCESS;
+               break;
+       case ARCHIVE_ENTRY_ACL_TYPE_DEFAULT:
+               acl_type = ACL_TYPE_DEFAULT;
+               break;
+#if ARCHIVE_ACL_FREEBSD_NFS4
+       case ARCHIVE_ENTRY_ACL_TYPE_NFS4:
+               acl_type = ACL_TYPE_NFS4;
+               break;
+#endif
+       default:
+               errno = ENOENT;
+               archive_set_error(a, errno, "Unsupported ACL type");
+               return (ARCHIVE_FAILED);
+       }
+
+       acl = acl_init(entries);
+       if (acl == (acl_t)NULL) {
+               archive_set_error(a, errno,
+                   "Failed to initialize ACL working storage");
+               return (ARCHIVE_FAILED);
+       }
+
+       while (archive_acl_next(a, abstract_acl, ae_requested_type, &ae_type,
+                  &ae_permset, &ae_tag, &ae_id, &ae_name) == ARCHIVE_OK) {
+               if (acl_create_entry(&acl, &acl_entry) != 0) {
+                       archive_set_error(a, errno,
+                           "Failed to create a new ACL entry");
+                       ret = ARCHIVE_FAILED;
+                       goto exit_free;
+               }
+               switch (ae_tag) {
+               case ARCHIVE_ENTRY_ACL_USER:
+                       ae_uid = archive_write_disk_uid(a, ae_name, ae_id);
+                       acl_set_tag_type(acl_entry, ACL_USER);
+                       acl_set_qualifier(acl_entry, &ae_uid);
+                       break;
+               case ARCHIVE_ENTRY_ACL_GROUP:
+                       ae_gid = archive_write_disk_gid(a, ae_name, ae_id);
+                       acl_set_tag_type(acl_entry, ACL_GROUP);
+                       acl_set_qualifier(acl_entry, &ae_gid);
+                       break;
+               case ARCHIVE_ENTRY_ACL_USER_OBJ:
+                       acl_set_tag_type(acl_entry, ACL_USER_OBJ);
+                       break;
+               case ARCHIVE_ENTRY_ACL_GROUP_OBJ:
+                       acl_set_tag_type(acl_entry, ACL_GROUP_OBJ);
+                       break;
+               case ARCHIVE_ENTRY_ACL_MASK:
+                       acl_set_tag_type(acl_entry, ACL_MASK);
+                       break;
+               case ARCHIVE_ENTRY_ACL_OTHER:
+                       acl_set_tag_type(acl_entry, ACL_OTHER);
+                       break;
+#if ARCHIVE_ACL_FREEBSD_NFS4
+               case ARCHIVE_ENTRY_ACL_EVERYONE:
+                       acl_set_tag_type(acl_entry, ACL_EVERYONE);
+                       break;
+#endif
+               default:
+                       archive_set_error(a, ARCHIVE_ERRNO_MISC,
+                           "Unsupported ACL tag");
+                       ret = ARCHIVE_FAILED;
+                       goto exit_free;
+               }
+
+#if ARCHIVE_ACL_FREEBSD_NFS4
+               r = 0;
+               switch (ae_type) {
+               case ARCHIVE_ENTRY_ACL_TYPE_ALLOW:
+                       r = acl_set_entry_type_np(acl_entry,
+                           ACL_ENTRY_TYPE_ALLOW);
+                       break;
+               case ARCHIVE_ENTRY_ACL_TYPE_DENY:
+                       r = acl_set_entry_type_np(acl_entry,
+                           ACL_ENTRY_TYPE_DENY);
+                       break;
+               case ARCHIVE_ENTRY_ACL_TYPE_AUDIT:
+                       r = acl_set_entry_type_np(acl_entry,
+                           ACL_ENTRY_TYPE_AUDIT);
+                       break;
+               case ARCHIVE_ENTRY_ACL_TYPE_ALARM:
+                       r = acl_set_entry_type_np(acl_entry,
+                           ACL_ENTRY_TYPE_ALARM);
+                       break;
+               case ARCHIVE_ENTRY_ACL_TYPE_ACCESS:
+               case ARCHIVE_ENTRY_ACL_TYPE_DEFAULT:
+                       // These don't translate directly into the system ACL.
+                       break;
+               default:
+                       archive_set_error(a, ARCHIVE_ERRNO_MISC,
+                           "Unsupported ACL entry type");
+                       ret = ARCHIVE_FAILED;
+                       goto exit_free;
+               }
+
+               if (r != 0) {
+                       archive_set_error(a, errno,
+                           "Failed to set ACL entry type");
+                       ret = ARCHIVE_FAILED;
+                       goto exit_free;
+               }
+#endif
+
+               if (acl_get_permset(acl_entry, &acl_permset) != 0) {
+                       archive_set_error(a, errno,
+                           "Failed to get ACL permission set");
+                       ret = ARCHIVE_FAILED;
+                       goto exit_free;
+               }
+               if (acl_clear_perms(acl_permset) != 0) {
+                       archive_set_error(a, errno,
+                           "Failed to clear ACL permissions");
+                       ret = ARCHIVE_FAILED;
+                       goto exit_free;
+               }
+#if ARCHIVE_ACL_FREEBSD_NFS4
+               if (ae_requested_type == ARCHIVE_ENTRY_ACL_TYPE_NFS4) {
+                       perm_map_size = acl_nfs4_perm_map_size;
+                       perm_map = acl_nfs4_perm_map;
+               } else {
+#endif
+                       perm_map_size = acl_posix_perm_map_size;
+                       perm_map = acl_posix_perm_map;
+#if ARCHIVE_ACL_FREEBSD_NFS4
+               }
+#endif
+
+               for (i = 0; i < perm_map_size; ++i) {
+                       if (ae_permset & perm_map[i].a_perm) {
+                               if (acl_add_perm(acl_permset,
+                                   perm_map[i].p_perm) != 0) {
+                                       archive_set_error(a, errno,
+                                           "Failed to add ACL permission");
+                                       ret = ARCHIVE_FAILED;
+                                       goto exit_free;
+                               }
+                       }
+               }
+
+#if ARCHIVE_ACL_FREEBSD_NFS4
+               if (ae_requested_type == ARCHIVE_ENTRY_ACL_TYPE_NFS4) {
+                       /*
+                        * acl_get_flagset_np() fails with non-NFSv4 ACLs
+                        */
+                       if (acl_get_flagset_np(acl_entry, &acl_flagset) != 0) {
+                               archive_set_error(a, errno,
+                                   "Failed to get flagset from an NFSv4 "
+                                   "ACL entry");
+                               ret = ARCHIVE_FAILED;
+                               goto exit_free;
+                       }
+                       if (acl_clear_flags_np(acl_flagset) != 0) {
+                               archive_set_error(a, errno,
+                                   "Failed to clear flags from an NFSv4 "
+                                   "ACL flagset");
+                               ret = ARCHIVE_FAILED;
+                               goto exit_free;
+                       }
+                       for (i = 0; i < acl_nfs4_flag_map_size; ++i) {
+                               if (ae_permset & acl_nfs4_flag_map[i].a_perm) {
+                                       if (acl_add_flag_np(acl_flagset,
+                                           acl_nfs4_flag_map[i].p_perm) != 0) {
+                                               archive_set_error(a, errno,
+                                                   "Failed to add flag to "
+                                                   "NFSv4 ACL flagset");
+                                               ret = ARCHIVE_FAILED;
+                                               goto exit_free;
+                                       }
+                               }
+                       }
+               }
+#endif
+       }
+
+       /* Try restoring the ACL through 'fd' if we can. */
+       if (fd >= 0) {
+               if (acl_set_fd_np(fd, acl, acl_type) == 0)
+                       ret = ARCHIVE_OK;
+               else {
+                       if (errno == EOPNOTSUPP) {
+                               /* Filesystem doesn't support ACLs */
+                               ret = ARCHIVE_OK;
+                       } else {
+                               archive_set_error(a, errno,
+                                   "Failed to set acl on fd: %s", tname);
+                               ret = ARCHIVE_WARN;
+                       }
+               }
+       }
+#if HAVE_ACL_SET_LINK_NP
+       else if (acl_set_link_np(name, acl_type, acl) != 0)
+#else
+       /* FreeBSD older than 8.0 */
+       else if (acl_set_file(name, acl_type, acl) != 0)
+#endif
+       {
+               if (errno == EOPNOTSUPP) {
+                       /* Filesystem doesn't support ACLs */
+                       ret = ARCHIVE_OK;
+               } else {
+                       archive_set_error(a, errno, "Failed to set acl: %s",
+                           tname);
+                       ret = ARCHIVE_WARN;
+               }
+       }
+exit_free:
+       acl_free(acl);
+       return (ret);
+}
+
+int
+archive_read_disk_entry_setup_acls(struct archive_read_disk *a,
+    struct archive_entry *entry, int *fd)
+{
+       const char      *accpath;
+       acl_t           acl;
+       int             r;
+
+       accpath = NULL;
+
+       if (*fd < 0) {
+               accpath = archive_read_disk_entry_setup_path(a, entry, fd);
+               if (accpath == NULL)
+                       return (ARCHIVE_WARN);
+       }
+
+       archive_entry_acl_clear(entry);
+
+       acl = NULL;
+
+#if ARCHIVE_ACL_FREEBSD_NFS4
+       /* Try NFSv4 ACL first. */
+       if (*fd >= 0)
+               acl = acl_get_fd_np(*fd, ACL_TYPE_NFS4);
+       else if (!a->follow_symlinks)
+               acl = acl_get_link_np(accpath, ACL_TYPE_NFS4);
+       else
+               acl = acl_get_file(accpath, ACL_TYPE_NFS4);
+
+       /* Ignore "trivial" ACLs that just mirror the file mode. */
+       if (acl != NULL && acl_is_trivial_np(acl, &r) == 0 && r == 1) {
+               acl_free(acl);
+               acl = NULL;
+               return (ARCHIVE_OK);
+       }
+
+       if (acl != NULL) {
+               r = translate_acl(a, entry, acl, ARCHIVE_ENTRY_ACL_TYPE_NFS4);
+               acl_free(acl);
+               acl = NULL;
+
+               if (r != ARCHIVE_OK) {
+                       archive_set_error(&a->archive, errno,
+                           "Couldn't translate NFSv4 ACLs");
+               }
+
+               return (r);
+       }
+#endif
+
+       /* Retrieve access ACL from file. */
+       if (*fd >= 0)
+               acl = acl_get_fd_np(*fd, ACL_TYPE_ACCESS);
+#if HAVE_ACL_GET_LINK_NP
+       else if (!a->follow_symlinks)
+               acl = acl_get_link_np(accpath, ACL_TYPE_ACCESS);
+#else
+       else if ((!a->follow_symlinks)
+           && (archive_entry_filetype(entry) == AE_IFLNK))
+               /* We can't get the ACL of a symlink, so we assume it can't
+                  have one. */
+               acl = NULL;
+#endif
+       else
+               acl = acl_get_file(accpath, ACL_TYPE_ACCESS);
+
+#if HAVE_ACL_IS_TRIVIAL_NP
+       /* Ignore "trivial" ACLs that just mirror the file mode. */
+       if (acl != NULL && acl_is_trivial_np(acl, &r) == 0 && r == 1) {
+               acl_free(acl);
+               acl = NULL;
+       }
+#endif
+
+       if (acl != NULL) {
+               r = translate_acl(a, entry, acl, ARCHIVE_ENTRY_ACL_TYPE_ACCESS);
+               acl_free(acl);
+               acl = NULL;
+
+               if (r != ARCHIVE_OK) {
+                       archive_set_error(&a->archive, errno,
+                           "Couldn't translate access ACLs");
+                       return (r);
+               }
+       }
+
+       /* Only directories can have default ACLs. */
+       if (S_ISDIR(archive_entry_mode(entry))) {
+               if (*fd >= 0)
+                       acl = acl_get_fd_np(*fd, ACL_TYPE_DEFAULT);
+               else
+                       acl = acl_get_file(accpath, ACL_TYPE_DEFAULT);
+               if (acl != NULL) {
+                       r = translate_acl(a, entry, acl,
+                           ARCHIVE_ENTRY_ACL_TYPE_DEFAULT);
+                       acl_free(acl);
+                       if (r != ARCHIVE_OK) {
+                               archive_set_error(&a->archive, errno,
+                                   "Couldn't translate default ACLs");
+                               return (r);
+                       }
+               }
+       }
+       return (ARCHIVE_OK);
+}
+
+int
+archive_write_disk_set_acls(struct archive *a, int fd, const char *name,
+    struct archive_acl *abstract_acl, __LA_MODE_T mode)
+{
+       int             ret = ARCHIVE_OK;
+
+       (void)mode;     /* UNUSED */
+
+       if ((archive_acl_types(abstract_acl)
+           & ARCHIVE_ENTRY_ACL_TYPE_POSIX1E) != 0) {
+               if ((archive_acl_types(abstract_acl)
+                   & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0) {
+                       ret = set_acl(a, fd, name, abstract_acl,
+                           ARCHIVE_ENTRY_ACL_TYPE_ACCESS, "access");
+                       if (ret != ARCHIVE_OK)
+                               return (ret);
+               }
+               if ((archive_acl_types(abstract_acl)
+                   & ARCHIVE_ENTRY_ACL_TYPE_DEFAULT) != 0)
+                       ret = set_acl(a, fd, name, abstract_acl,
+                           ARCHIVE_ENTRY_ACL_TYPE_DEFAULT, "default");
+
+               /* Simultaneous POSIX.1e and NFSv4 is not supported */
+               return (ret);
+       }
+#if ARCHIVE_ACL_FREEBSD_NFS4
+       else if ((archive_acl_types(abstract_acl) &
+           ARCHIVE_ENTRY_ACL_TYPE_NFS4) != 0) {
+               ret = set_acl(a, fd, name, abstract_acl,
+                   ARCHIVE_ENTRY_ACL_TYPE_NFS4, "nfs4");
+       }
+#endif
+       return (ret);
+}
+#endif /* ARCHIVE_ACL_FREEBSD */

Modified: stable/10/contrib/libarchive/libarchive/archive_entry.3
==============================================================================
--- stable/10/contrib/libarchive/libarchive/archive_entry.3     Fri Mar 31 
20:16:24 2017        (r316337)
+++ stable/10/contrib/libarchive/libarchive/archive_entry.3     Fri Mar 31 
20:17:30 2017        (r316338)
@@ -25,7 +25,7 @@
 .\"
 .\" $FreeBSD$
 .\"
-.Dd Feburary 2, 2012
+.Dd February 2, 2012
 .Dt ARCHIVE_ENTRY 3
 .Os
 .Sh NAME

Modified: stable/10/contrib/libarchive/libarchive/archive_entry.c
==============================================================================
--- stable/10/contrib/libarchive/libarchive/archive_entry.c     Fri Mar 31 
20:16:24 2017        (r316337)
+++ stable/10/contrib/libarchive/libarchive/archive_entry.c     Fri Mar 31 
20:17:30 2017        (r316338)
@@ -1638,7 +1638,7 @@ _archive_entry_acl_text_l(struct archive
  * SUCH DAMAGE.
  */
 
-static struct flag {
+static const struct flag {
        const char      *name;
        const wchar_t   *wname;
        unsigned long    set;
@@ -1708,6 +1708,9 @@ static struct flag {
 #ifdef UF_COMPRESSED
        { "nocompressed",L"nocompressed",       UF_COMPRESSED,  0 },
 #endif
+#ifdef UF_HIDDEN
+       { "nohidden",   L"nohidden",            UF_HIDDEN,      0 },
+#endif
 #if defined(FS_UNRM_FL)
         { "nouunlink", L"nouunlink",           FS_UNRM_FL,     0},
 #elif defined(EXT2_UNRM_FL)
@@ -1840,7 +1843,7 @@ ae_fflagstostr(unsigned long bitset, uns
        char *string, *dp;
        const char *sp;
        unsigned long bits;
-       struct flag *flag;
+       const struct flag *flag;
        size_t  length;
 
        bits = bitset | bitclear;
@@ -1892,7 +1895,7 @@ static const char *
 ae_strtofflags(const char *s, unsigned long *setp, unsigned long *clrp)
 {
        const char *start, *end;
-       struct flag *flag;
+       const struct flag *flag;
        unsigned long set, clear;
        const char *failed;
 
@@ -1960,7 +1963,7 @@ static const wchar_t *
 ae_wcstofflags(const wchar_t *s, unsigned long *setp, unsigned long *clrp)
 {
        const wchar_t *start, *end;
-       struct flag *flag;
+       const struct flag *flag;
        unsigned long set, clear;
        const wchar_t *failed;
 

Modified: stable/10/contrib/libarchive/libarchive/archive_entry_acl.3
==============================================================================
--- stable/10/contrib/libarchive/libarchive/archive_entry_acl.3 Fri Mar 31 
20:16:24 2017        (r316337)
+++ stable/10/contrib/libarchive/libarchive/archive_entry_acl.3 Fri Mar 31 
20:17:30 2017        (r316338)
@@ -267,7 +267,7 @@ Only inherit, do not apply the permissio
 .It Dv ARCHIVE_ENTRY_ACL_ENTRY_NO_PROPAGATE_INHERIT ( Sy n )
 Do not propagate inherit flags. Only first-level entries inherit ACLs.
 .It Dv ARCHIVE_ENTRY_ACL_ENTRY_SUCCESSFUL_ACCESS ( Sy S )
-Trigger alarm or audit on succesful access.
+Trigger alarm or audit on successful access.
 .It Dv ARCHIVE_ENTRY_ACL_ENTRY_FAILED_ACCESS ( Sy F )
 Trigger alarm or audit on failed access.
 .It Dv ARCHIVE_ENTRY_ACL_ENTRY_INHERITED ( Sy I )
@@ -279,7 +279,7 @@ and
 .Fn archive_entry_acl_add_entry_w
 add a single ACL entry.
 For the access ACL and non-extended principals, the classic Unix permissions
-are updated. An archive enry cannot contain both POSIX.1e and NFSv4 ACL
+are updated. An archive entry cannot contain both POSIX.1e and NFSv4 ACL
 entries.
 .Pp
 .Fn archive_entry_acl_clear
@@ -303,7 +303,7 @@ for POSIX.1e ACLs and
 for NFSv4 ACLs. For POSIX.1e ACLs if
 .Dv ARCHIVE_ENTRY_ACL_TYPE_ACCESS
 is included and at least one extended ACL entry is found,
-the three non-extened ACLs are added.
+the three non-extended ACLs are added.
 .Pp
 .Fn archive_entry_acl_from_text
 and
@@ -367,7 +367,7 @@ and
 .Fn archive_entry_acl_to_text_w
 convert the ACL entries for the given type into a
 .Pq wide
-string of ACL entries separated by newline. If the the pointer
+string of ACL entries separated by newline. If the pointer
 .Fa len_p
 is not NULL, then the function shall return the length of the string
 .Pq not including the NULL terminator

Modified: stable/10/contrib/libarchive/libarchive/archive_getdate.c
==============================================================================
--- stable/10/contrib/libarchive/libarchive/archive_getdate.c   Fri Mar 31 
20:16:24 2017        (r316337)
+++ stable/10/contrib/libarchive/libarchive/archive_getdate.c   Fri Mar 31 
20:17:30 2017        (r316338)
@@ -691,7 +691,7 @@ Convert(time_t Month, time_t Day, time_t
        time_t Hours, time_t Minutes, time_t Seconds,
        time_t Timezone, enum DSTMODE DSTmode)
 {
-       static int DaysInMonth[12] = {
+       int DaysInMonth[12] = {
                31, 0, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
        };
        time_t  Julian;

Modified: stable/10/contrib/libarchive/libarchive/archive_pack_dev.c
==============================================================================
--- stable/10/contrib/libarchive/libarchive/archive_pack_dev.c  Fri Mar 31 
20:16:24 2017        (r316337)
+++ stable/10/contrib/libarchive/libarchive/archive_pack_dev.c  Fri Mar 31 
20:17:30 2017        (r316338)
@@ -280,7 +280,7 @@ pack_bsdos(int n, unsigned long numbers[
 
                /* list of formats and pack functions */
                /* this list must be sorted lexically */
-static struct format {
+static const struct format {
        const char      *name;
        pack_t          *pack;
 } formats[] = {

Modified: stable/10/contrib/libarchive/libarchive/archive_platform.h
==============================================================================
--- stable/10/contrib/libarchive/libarchive/archive_platform.h  Fri Mar 31 
20:16:24 2017        (r316337)
+++ stable/10/contrib/libarchive/libarchive/archive_platform.h  Fri Mar 31 
20:17:30 2017        (r316338)
@@ -143,40 +143,6 @@
 #endif
 
 /*
- * If this platform has <sys/acl.h>, acl_create(), acl_init(),
- * acl_set_file(), and ACL_USER, we assume it has the rest of the
- * POSIX.1e draft functions used in archive_read_extract.c.
- */
-#if HAVE_SYS_ACL_H && HAVE_ACL_CREATE_ENTRY && HAVE_ACL_INIT && 
HAVE_ACL_SET_FILE
-#if HAVE_DECL_ACL_USER
-#define        HAVE_POSIX_ACL  1
-#elif HAVE_DECL_ACL_TYPE_EXTENDED && HAVE_MEMBERSHIP_H
-#define HAVE_DARWIN_ACL 1
-#endif
-#if HAVE_DECL_ACL_TYPE_NFS4
-#define        HAVE_FREEBSD_NFS4_ACL 1
-#endif
-#endif
-
-/*
- * If this platform has <sys/acl.h>, acl(), facl() and ACLENT_T
- * facl_set() and types aclent_t and ace_t it uses Solaris-style ACL functions
- */
-#if HAVE_SYS_ACL_H && HAVE_ACL && HAVE_FACL && HAVE_ACLENT_T && \
-    HAVE_DECL_GETACL && HAVE_DECL_GETACLCNT && HAVE_DECL_SETACL
-#define        HAVE_SUN_ACL    1
-#if HAVE_ACE_T && HAVE_DECL_ACE_GETACL && HAVE_DECL_ACE_GETACLCNT && \
-    HAVE_DECL_ACE_SETACL
-#define HAVE_SUN_NFS4_ACL      1
-#endif
-#endif
-
-/* Define if platform supports NFSv4 ACLs */
-#if HAVE_FREEBSD_NFS4_ACL || HAVE_SUN_NFS4_ACL || HAVE_DARWIN_ACL
-#define HAVE_NFS4_ACL  1
-#endif
-
-/*
  * If we can't restore metadata using a file descriptor, then
  * for compatibility's sake, close files before trying to restore metadata.
  */

Copied: stable/10/contrib/libarchive/libarchive/archive_platform_acl.h (from 
r315636, head/contrib/libarchive/libarchive/archive_platform_acl.h)
==============================================================================
--- /dev/null   00:00:00 1970   (empty, because file is newly added)
+++ stable/10/contrib/libarchive/libarchive/archive_platform_acl.h      Fri Mar 
31 20:17:30 2017        (r316338, copy of r315636, 
head/contrib/libarchive/libarchive/archive_platform_acl.h)
@@ -0,0 +1,49 @@
+/*-
+ * Copyright (c) 2017 Martin Matuska
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

*** DIFF OUTPUT TRUNCATED AT 1000 LINES ***
_______________________________________________
svn-src-all@freebsd.org mailing list
https://lists.freebsd.org/mailman/listinfo/svn-src-all
To unsubscribe, send any mail to "svn-src-all-unsubscr...@freebsd.org"

Reply via email to