diff -rup tar-1.15.91-orig/src/common.h tar-1.15.91/src/common.h --- tar-1.15.91-orig/src/common.h 2006-09-25 13:45:38.000000000 -0400 +++ tar-1.15.91/src/common.h 2006-09-25 15:52:40.000000000 -0400 @@ -249,6 +249,9 @@ GLOBAL int acls_option; /* If positive, save the user and root xattrs. */ GLOBAL int xattrs_option; +/* Use 1.15.1 incremental format. */ +GLOBAL int old_incr_format; + /* When set, strip the given number of file name components from the file name before extracting */ GLOBAL size_t strip_name_components; diff -rup tar-1.15.91-orig/src/create.c tar-1.15.91/src/create.c --- tar-1.15.91-orig/src/create.c 2006-09-25 13:45:38.000000000 -0400 +++ tar-1.15.91/src/create.c 2006-09-25 15:52:40.000000000 -0400 @@ -837,8 +837,13 @@ start_header (struct tar_stat_info *st) if (archive_format == POSIX_FORMAT) { if (acls_option > 0) - xheader_store ("SCHILY.xattr.system.posix_acl_access", st, NULL); - if (selinux_context_option > 0) + { + if (st->acls_a_ptr) + xheader_store ("SCHILY.xattr.system.posix_acl_access", st, NULL); + if (st->acls_d_ptr) + xheader_store ("SCHILY.xattr.system.posix_acl_default", st, NULL); + } + if ((selinux_context_option > 0) && st->cntx_name) xheader_store ("SCHILY.xattr.security.selinux", st, NULL); if (xattrs_option > 0) { @@ -1507,9 +1512,9 @@ dump_file0 (struct tar_stat_info *st, co return; } - xattrs_acls_get(st, p, fd); - xattrs_selinux_get(st, p, fd); - xattrs_xattrs_get(st, p, fd); + xattrs_acls_get(st, p, fd, is_dir); + xattrs_selinux_get(st, p, fd, is_dir); + xattrs_xattrs_get(st, p, fd, is_dir); } if (is_dir) diff -rup tar-1.15.91-orig/src/extract.c tar-1.15.91/src/extract.c --- tar-1.15.91-orig/src/extract.c 2006-09-25 13:45:38.000000000 -0400 +++ tar-1.15.91/src/extract.c 2006-09-25 15:52:40.000000000 -0400 @@ -69,8 +69,10 @@ struct delayed_set_stat enum permstatus permstatus; bool after_links; char *cntx_name; - char *acls_ptr; - size_t acls_len; + char *acls_a_ptr; + size_t acls_a_len; + char *acls_d_ptr; + size_t acls_d_len; size_t xattr_map_size; /* Size of the xattr map */ struct xattr_array *xattr_map; char file_name[1]; @@ -104,8 +106,10 @@ struct delayed_link char *cntx_name; /* ACLs */ - char *acls_ptr; - size_t acls_len; + char *acls_a_ptr; + size_t acls_a_len; + char *acls_d_ptr; + size_t acls_d_len; size_t xattr_map_size; /* Size of the xattr map */ struct xattr_array *xattr_map; @@ -362,12 +366,19 @@ delay_set_stat (char const *file_name, s data->after_links = 0; data->cntx_name = NULL; assign_string (&data->cntx_name, st->cntx_name); - if (st->acls_ptr) - data->acls_ptr = xmemdup(st->acls_ptr, st->acls_len); + if (st->acls_a_ptr) + data->acls_a_ptr = xmemdup(st->acls_a_ptr, st->acls_a_len + 1); else { - data->acls_ptr = NULL; - data->acls_len = 0; + data->acls_a_ptr = NULL; + data->acls_a_len = 0; + } + if (st->acls_d_ptr) + data->acls_d_ptr = xmemdup(st->acls_d_ptr, st->acls_d_len + 1); + else + { + data->acls_d_ptr = NULL; + data->acls_d_len = 0; } xheader_xattr_copy (st, &data->xattr_map, &data->xattr_map_size); strcpy (data->file_name, file_name); @@ -617,8 +628,10 @@ apply_nonancestor_delayed_set_stat (char st.atime = data->atime; st.mtime = data->mtime; st.cntx_name = data->cntx_name; - st.acls_ptr = data->acls_ptr; - st.acls_len = data->acls_len; + st.acls_a_ptr = data->acls_a_ptr; + st.acls_a_len = data->acls_a_len; + st.acls_d_ptr = data->acls_d_ptr; + st.acls_d_len = data->acls_d_len; st.xattr_map = data->xattr_map; st.xattr_map_size = data->xattr_map_size; set_stat (data->file_name, &st, cur_info, @@ -628,7 +641,8 @@ apply_nonancestor_delayed_set_stat (char delayed_set_stat_head = data->next; xheader_xattr_free (data->xattr_map, data->xattr_map_size); free (data->cntx_name); - free (data->acls_ptr); + free (data->acls_a_ptr); + free (data->acls_d_ptr); free (data); } } @@ -903,8 +917,10 @@ create_placeholder_file (char *file_name p->sources->next = 0; strcpy (p->sources->string, file_name); p->cntx_name = NULL; - p->acls_ptr = NULL; - p->acls_len = 0; + p->acls_a_ptr = NULL; + p->acls_a_len = 0; + p->acls_d_ptr = NULL; + p->acls_d_len = 0; p->xattr_map = NULL; p->xattr_map_size = 0; strcpy (p->target, current_stat_info.link_name); @@ -1078,6 +1094,7 @@ extract_volhdr (char *file_name, int typ if (verbose_option) fprintf (stdlis, _("Reading %s\n"), quote (current_stat_info.file_name)); skip_member (); + return 0; } static int @@ -1317,8 +1334,10 @@ apply_delayed_links (void) st1.stat.st_uid = ds->uid; st1.stat.st_gid = ds->gid; st1.cntx_name = ds->cntx_name; - st1.acls_ptr = ds->acls_ptr; - st1.acls_len = ds->acls_len; + st1.acls_a_ptr = ds->acls_a_ptr; + st1.acls_a_len = ds->acls_a_len; + st1.acls_d_ptr = ds->acls_d_ptr; + st1.acls_d_len = ds->acls_d_len; st1.xattr_map = ds->xattr_map; st1.xattr_map_size = ds->xattr_map_size; set_stat (source, &st1, NULL, 0, 0, SYMTYPE); diff -rup tar-1.15.91-orig/src/incremen.c tar-1.15.91/src/incremen.c --- tar-1.15.91-orig/src/incremen.c 2006-09-25 13:45:38.000000000 -0400 +++ tar-1.15.91/src/incremen.c 2006-09-25 15:52:40.000000000 -0400 @@ -1049,6 +1049,31 @@ write_directory_file_entry (void *entry, return ! ferror (fp); } +/* Output incremental data for the directory ENTRY to the file DATA. + Return nonzero if successful, preserving errno on write failure. */ +static bool +old_write_directory_file_entry (void *entry, void *data) +{ + struct directory const *directory = entry; + FILE *fp = data; + + if (DIR_IS_FOUND (directory)) + { + int e; + char *str = quote_copy_string (directory->name); + fprintf (fp, "+%lu %lu %s\n" + ! DIR_IS_NFS (directory), + (unsigned long) directory->device_number, + (unsigned long) directory->inode_number, + str ? str : directory->name); + e = errno; + if (str) + free (str); + errno = e; + } + + return ! ferror (fp); +} + void write_directory_file (void) { @@ -1064,17 +1089,27 @@ write_directory_file (void) if (sys_truncate (fileno (fp)) != 0) truncate_error (listed_incremental_option); - fprintf (fp, "%s-%s-%d\n", PACKAGE_NAME, PACKAGE_VERSION, - TAR_INCREMENTAL_VERSION); + if (old_incr_format) + { + fprintf (fp, "%lu\n", (unsigned long) start_time.tv_sec); - s = umaxtostr (start_time.tv_sec, buf); - fwrite (s, strlen (s) + 1, 1, fp); - s = umaxtostr (start_time.tv_nsec, buf); - fwrite (s, strlen (s) + 1, 1, fp); + if (! ferror (fp) && directory_table) + hash_do_for_each (directory_table, old_write_directory_file_entry, fp); + } + else + { + fprintf (fp, "%s-%s-%d\n", PACKAGE_NAME, PACKAGE_VERSION, + TAR_INCREMENTAL_VERSION); - if (! ferror (fp) && directory_table) - hash_do_for_each (directory_table, write_directory_file_entry, fp); + s = umaxtostr (start_time.tv_sec, buf); + fwrite (s, strlen (s) + 1, 1, fp); + s = umaxtostr (start_time.tv_nsec, buf); + fwrite (s, strlen (s) + 1, 1, fp); + if (! ferror (fp) && directory_table) + hash_do_for_each (directory_table, write_directory_file_entry, fp); + } + if (ferror (fp)) write_error (listed_incremental_option); if (fclose (fp) != 0) diff -rup tar-1.15.91-orig/src/list.c tar-1.15.91/src/list.c --- tar-1.15.91-orig/src/list.c 2006-09-25 13:45:38.000000000 -0400 +++ tar-1.15.91/src/list.c 2006-09-25 15:52:40.000000000 -0400 @@ -539,8 +539,10 @@ decode_header (union block *header, stru assign_string (&stat_info->gname, header->header.gname[0] ? header->header.gname : NULL); - stat_info->acls_ptr = NULL; - stat_info->acls_len = 0; + stat_info->acls_a_ptr = NULL; + stat_info->acls_a_len = 0; + stat_info->acls_d_ptr = NULL; + stat_info->acls_d_len = 0; stat_info->cntx_name = NULL; xheader_xattr_init(stat_info); diff -rup tar-1.15.91-orig/src/tar.c tar-1.15.91/src/tar.c --- tar-1.15.91-orig/src/tar.c 2006-09-25 13:45:38.000000000 -0400 +++ tar-1.15.91/src/tar.c 2006-09-25 15:54:34.000000000 -0400 @@ -284,6 +284,7 @@ enum NUMERIC_OWNER_OPTION, OCCURRENCE_OPTION, OLD_ARCHIVE_OPTION, + OLDER_INCRE_FORMAT, ONE_FILE_SYSTEM_OPTION, OVERWRITE_DIR_OPTION, OVERWRITE_OPTION, @@ -391,6 +392,8 @@ static struct argp_option options[] = { N_("handle old GNU-format incremental backup"), GRID+1 }, {"listed-incremental", 'g', N_("FILE"), 0, N_("handle new GNU-format incremental backup"), GRID+1 }, + {"old-listed-incremental", OLDER_INCRE_FORMAT, N_("FILE"), 0, + N_("handle older \"new GNU-format\" incremental backup"), GRID+1 }, {"ignore-failed-read", IGNORE_FAILED_READ_OPTION, 0, 0, N_("do not exit with nonzero on unreadable files"), GRID+1 }, {"occurrence", OCCURRENCE_OPTION, N_("NUMBER"), OPTION_ARG_OPTIONAL, @@ -1155,6 +1158,8 @@ parse_opt (int key, char *arg, struct ar multi_volume_option = true; break; + case OLDER_INCRE_FORMAT: + old_incr_format = true; /* for RH ... compat. hack */ case 'g': listed_incremental_option = arg; after_date_option = true; @@ -2353,7 +2358,8 @@ tar_stat_destroy (struct tar_stat_info * free (st->uname); free (st->gname); free (st->cntx_name); - free (st->acls_ptr); + free (st->acls_a_ptr); + free (st->acls_d_ptr); free (st->sparse_map); free (st->dumpdir); memset (st, 0, sizeof (*st)); diff -rup tar-1.15.91-orig/src/tar.h tar-1.15.91/src/tar.h --- tar-1.15.91-orig/src/tar.h 2006-09-25 13:45:38.000000000 -0400 +++ tar-1.15.91/src/tar.h 2006-09-25 15:52:40.000000000 -0400 @@ -292,8 +292,11 @@ struct tar_stat_info char *cntx_name; /* SELinux context for the current archive entry. */ - char *acls_ptr; /* ACLs for the current archive entry. */ - size_t acls_len; /* ACLs for the current archive entry. */ + char *acls_a_ptr; /* ACLs for the current archive entry. */ + size_t acls_a_len; /* ACLs for the current archive entry. */ + + char *acls_d_ptr; /* ACLs for the current archive entry. */ + size_t acls_d_len; /* ACLs for the current archive entry. */ struct stat stat; /* regular filesystem stat */ diff -rup tar-1.15.91-orig/src/xattrs.c tar-1.15.91/src/xattrs.c --- tar-1.15.91-orig/src/xattrs.c 2006-09-25 13:45:38.000000000 -0400 +++ tar-1.15.91/src/xattrs.c 2006-09-25 15:52:40.000000000 -0400 @@ -33,6 +33,10 @@ # undef HAVE_XATTRS #endif +#ifndef HAVE_SYS_ACL_H +# undef HAVE_LIBACL +#endif + #ifdef HAVE_SELINUX_SELINUX_H # include #endif @@ -41,47 +45,144 @@ # include #endif +#ifdef HAVE_SYS_ACL_H +# include +#endif + -void xattrs_acls_get(struct tar_stat_info *st, char const *file_name, int fd) +#if 0 /* unused by xattr's atm. */ +static void xattrs__fd_get(struct tar_stat_info *st, + char const *file_name, int fd, const char *attr, + char **ret_ptr, size_t *ret_len) { #ifdef HAVE_XATTRS - if (acls_option > 0) + static ssize_t asz = 1024; + ssize_t ret = 0; + static char *val = NULL; + + if (!val) val = xmalloc (asz); + + while (((ret = fgetxattr (fd, attr, val, asz)) == -1) && + (errno == ERANGE)) { - const char *attr = "system.posix_acl_access"; - static char *val = NULL; - static ssize_t asz = 1024; - ssize_t ret = 0; - - if (!val) val = xmalloc (asz); - - while (((ret = fgetxattr (fd, attr, val, asz)) == -1) && - (errno == ERANGE)) - { - asz <<= 1; - val = xrealloc (val, asz); - } - - if (ret != -1) - { - st->acls_ptr = xmemdup (val, ret); - st->acls_len = ret; - } - else if (errno != ENOATTR) - call_arg_warn ("fgetxattr", file_name); + asz <<= 1; + val = xrealloc (val, asz); + } + + if (ret != -1) + { + *ret_ptr = xmemdup (val, ret); + *ret_len = ret; } + else if (errno != ENOATTR) + call_arg_warn ("fgetxattr", file_name); #endif } +#endif -void xattrs_selinux_get(struct tar_stat_info *st, char const *file_name, int fd) +static void xattrs__acls_get_a(struct tar_stat_info *st, + char const *file_name, int fd, + char **ret_ptr, size_t *ret_len) +{ /* "system.posix_acl_access" */ +#ifdef HAVE_LIBACL + char *val = NULL; + acl_t acl; + + if (fd != -1) + { + if ((acl = acl_get_fd (fd)) == (acl_t)NULL) + { + if (errno != ENOTSUP) + call_arg_warn ("acl_get_fd", file_name); + return; + } + } + else if ((acl = acl_get_file (file_name, ACL_TYPE_ACCESS)) == (acl_t)NULL) + { + if (errno != ENOTSUP) + call_arg_warn ("acl_get_file", file_name); + return; + } + + + val = acl_to_text(acl, NULL); + acl_free (acl); + + if (val == NULL) + { + call_arg_warn ("acl_to_text", file_name); + return; + } + + *ret_ptr = xstrdup (val); + *ret_len = strlen (val); + + acl_free (val); +#endif +} + +static void xattrs__acls_get_d(struct tar_stat_info *st, + char const *file_name, + char **ret_ptr, size_t *ret_len) +{ /* "system.posix_acl_default" */ +#ifdef HAVE_LIBACL + char *val = NULL; + acl_t acl; + + /* stupid non-fd directories on other OSes */ + if ((acl = acl_get_file (file_name, ACL_TYPE_DEFAULT)) == (acl_t)NULL) + { + if (errno != ENOTSUP) + call_arg_warn ("acl_get_file", file_name); + return; + } + + val = acl_to_text(acl, NULL); + acl_free (acl); + + if (val == NULL) + { + call_arg_warn ("acl_to_text", file_name); + return; + } + + *ret_ptr = xstrdup (val); + *ret_len = strlen (val); + + acl_free (val); +#endif +} + +void xattrs_acls_get(struct tar_stat_info *st, char const *file_name, int fd, + int is_dir) +{ + if (acls_option > 0) + { + xattrs__acls_get_a (st, file_name, fd, + &st->acls_a_ptr, &st->acls_a_len); + if (is_dir) + xattrs__acls_get_d (st, file_name, + &st->acls_d_ptr, &st->acls_d_len); + } +} + +void xattrs_selinux_get(struct tar_stat_info *st, char const *file_name, + int fd, int is_dir) { #ifdef HAVE_LIBSELINUX if (selinux_context_option > 0) - if (fgetfilecon (fd, &st->cntx_name) == -1) + if (fd == -1) + { + if (getfilecon (file_name, &st->cntx_name) == -1) + call_arg_warn ("fgetfilecon", file_name); + } + else if (fgetfilecon (fd, &st->cntx_name) == -1) call_arg_warn ("fgetfilecon", file_name); #endif } -void xattrs_xattrs_get(struct tar_stat_info *st, char const *file_name, int fd) +void xattrs_xattrs_get(struct tar_stat_info *st, char const *file_name, + int fd, int is_dir) { #ifdef HAVE_XATTRS if (xattrs_option > 0) @@ -95,7 +196,9 @@ void xattrs_xattrs_get(struct tar_stat_i if (!xatrs) xatrs = xmalloc (xsz); - while (((xret = flistxattr (fd, xatrs, xsz)) == -1) && + while (((fd == -1) ? + ((xret = listxattr (file_name, xatrs, xsz)) == -1) : + ((xret = flistxattr (fd, xatrs, xsz)) == -1)) && (errno == ERANGE)) { xsz <<= 1; @@ -103,7 +206,7 @@ void xattrs_xattrs_get(struct tar_stat_i } if (xret == -1) - call_arg_warn ("flistxattrs", file_name); + call_arg_warn ((fd == -1) ? "listxattrs" : "flistxattrs", file_name); else { const char *attr = xatrs; @@ -121,7 +224,9 @@ void xattrs_xattrs_get(struct tar_stat_i strncmp (attr, "root.", strlen("root."))) goto next_attr; /* only store normal xattrs */ - while (((aret = fgetxattr (fd, attr, val, asz)) == -1) && + while (((fd == -1) ? + ((xret = getxattr (file_name, attr, val, asz)) == -1) : + ((aret = fgetxattr (fd, attr, val, asz)) == -1)) && (errno == ERANGE)) { asz <<= 1; @@ -142,22 +247,23 @@ void xattrs_xattrs_get(struct tar_stat_i #endif } -void xattrs_acls_set(struct tar_stat_info const *st, - char const *file_name, char typeflag) +static void xattrs__fd_set(struct tar_stat_info const *st, + char const *file_name, char typeflag, + const char *attr, + const char *ptr, size_t len) { #ifdef HAVE_XATTRS - if ((acls_option >= 0) && st->acls_ptr) + if (ptr) { const char *sysname = "setxattr"; - char *keyword = "system.posix_acl_access"; int ret = -1; if (typeflag != SYMTYPE) - ret = setxattr (file_name, keyword, st->acls_ptr, st->acls_len, 0); + ret = setxattr (file_name, attr, ptr, len, 0); else { sysname = "lsetxattr"; - ret = lsetxattr (file_name, keyword, st->acls_ptr, st->acls_len, 0); + ret = lsetxattr (file_name, attr, ptr, len, 0); } if ((ret == -1) && (errno == EPERM)) @@ -168,6 +274,81 @@ void xattrs_acls_set(struct tar_stat_inf #endif } +/* convert unix permissions into an ACL ... needed due to "default" ACLs */ +#ifdef HAVE_LIBACL +static acl_t perms2acl(int perms) +{ + char val[] = "user::---,group::---,other::---"; + /* 0123456789 123456789 123456789 123456789 */ + + /* user */ + if (perms & 0400) val[ 6] = 'r'; + if (perms & 0200) val[ 7] = 'w'; + if (perms & 0100) val[ 8] = 'x'; + + /* group */ + if (perms & 0040) val[17] = 'r'; + if (perms & 0020) val[18] = 'w'; + if (perms & 0010) val[19] = 'x'; + + /* other */ + if (perms & 0004) val[28] = 'r'; + if (perms & 0002) val[29] = 'w'; + if (perms & 0001) val[30] = 'x'; + + return (acl_from_text (val)); +} +#endif + +static void xattrs__acls_set(struct tar_stat_info const *st, + char const *file_name, int type, + const char *ptr, size_t len) +{ /* "system.posix_acl_access" */ +#ifdef HAVE_LIBACL + acl_t acl; + + if (ptr) + { + /* assert (strlen (ptr) == len); */ + acl = acl_from_text (ptr); + acls_option = 1; + } + else if (acls_option > 0) + acl = perms2acl (st->stat.st_mode); + else + return; /* don't call acl functions unless we first hit an ACL, or + --acls was passed explicitly */ + + if (acl == (acl_t)NULL) + { + call_arg_warn ("acl_from_text", file_name); + return; + } + + if (acl_set_file (file_name, type, acl) == -1) + { + if (errno != ENOTSUP) + call_arg_warn ("acl_set_file", file_name); + } + acl_free (acl); +#endif +} + +void xattrs_acls_set(struct tar_stat_info const *st, + char const *file_name, char typeflag) +{ + if ((acls_option >= 0) && (typeflag != SYMTYPE)) + { +#ifdef HAVE_LIBACL + xattrs__acls_set (st, file_name, ACL_TYPE_ACCESS, + st->acls_a_ptr, st->acls_a_len); + if (S_ISDIR (st->stat.st_mode)) + xattrs__acls_set (st, file_name, ACL_TYPE_DEFAULT, + st->acls_d_ptr, st->acls_d_len); +#endif + } +} + void xattrs_selinux_set(struct tar_stat_info const *st, char const *file_name, char typeflag) { @@ -199,38 +380,23 @@ void xattrs_xattrs_set(struct tar_stat_i #ifdef HAVE_XATTRS if ((xattrs_option >= 0) && st->xattr_map_size) { - const char *sysname = "setxattr"; size_t scan = 0; - int ret = -1; while (scan < st->xattr_map_size) { char *keyword = st->xattr_map[scan].xkey; - // assert (!memcpy (keyword, "SCHILY.xattr.", strlen("SCHILY.xattr."))); + /* assert (!memcpy (keyword, "SCHILY.xattr.", strlen("SCHILY.xattr."))); */ keyword += strlen("SCHILY.xattr."); if (strncmp (keyword, "user.", strlen("user.")) && strncmp (keyword, "root.", strlen("root."))) continue; /* don't try and set anything but normal xattrs */ - if (typeflag != SYMTYPE) - ret = setxattr (file_name, keyword, - st->xattr_map[scan].xval_ptr, - st->xattr_map[scan].xval_len, 0); - else - { - sysname = "lsetxattr"; - ret = lsetxattr (file_name, keyword, - st->xattr_map[scan].xval_ptr, - st->xattr_map[scan].xval_len, 0); - } - - /* should we ignore root.* xattrs when not root ? */ - if ((ret == -1) && (errno == EPERM)) - call_arg_warn(sysname, file_name); - else if ((ret == -1) && (errno != EOPNOTSUPP)) - call_arg_error(sysname, file_name); + /* should we ignore root.* EPERM errors when not root ? */ + xattrs__fd_set (st, file_name, typeflag, keyword, + st->xattr_map[scan].xval_ptr, + st->xattr_map[scan].xval_len); ++scan; } diff -rup tar-1.15.91-orig/src/xattrs.h tar-1.15.91/src/xattrs.h --- tar-1.15.91-orig/src/xattrs.h 2006-09-25 13:45:38.000000000 -0400 +++ tar-1.15.91/src/xattrs.h 2006-09-25 15:52:40.000000000 -0400 @@ -1,10 +1,10 @@ extern void xattrs_acls_get(struct tar_stat_info *st, - char const *file_name, int fd); + char const *file_name, int fd, int is_dir); extern void xattrs_selinux_get(struct tar_stat_info *st, - char const *file_name, int fd); + char const *file_name, int fd, int is_dir); extern void xattrs_xattrs_get(struct tar_stat_info *st, - char const *file_name, int fd); + char const *file_name, int fd, int is_dir); extern void xattrs_acls_set(struct tar_stat_info const *st, char const *file_name, char typeflag); diff -rup tar-1.15.91-orig/src/xheader.c tar-1.15.91/src/xheader.c --- tar-1.15.91-orig/src/xheader.c 2006-09-25 13:45:38.000000000 -0400 +++ tar-1.15.91/src/xheader.c 2006-09-25 15:52:40.000000000 -0400 @@ -1483,18 +1483,34 @@ xattr_selinux_decoder (struct tar_stat_i } static void -xattr_acls_coder (struct tar_stat_info const *st , char const *keyword, - struct xheader *xhdr, void const *data) +xattr_acls_a_coder (struct tar_stat_info const *st , char const *keyword, + struct xheader *xhdr, void const *data) { - xheader_print_n (xhdr, keyword, st->acls_ptr, st->acls_len); + xheader_print_n (xhdr, keyword, st->acls_a_ptr, st->acls_a_len); } static void -xattr_acls_decoder (struct tar_stat_info *st, +xattr_acls_a_decoder (struct tar_stat_info *st, char const *keyword, char const *arg, size_t size) { - st->acls_ptr = xmemdup (arg, size); - st->acls_len = size; + st->acls_a_ptr = xmemdup (arg, size); + st->acls_a_len = size; +} + + +static void +xattr_acls_d_coder (struct tar_stat_info const *st , char const *keyword, + struct xheader *xhdr, void const *data) +{ + xheader_print_n (xhdr, keyword, st->acls_d_ptr, st->acls_d_len); +} + +static void +xattr_acls_d_decoder (struct tar_stat_info *st, + char const *keyword, char const *arg, size_t size) +{ + st->acls_d_ptr = xmemdup (arg, size); + st->acls_d_len = size; } static void @@ -1575,7 +1591,9 @@ struct xhdr_tab const xhdr_tab[] = { /* ACLs, use the star format... */ { "SCHILY.xattr.system.posix_acl_access", - xattr_acls_coder, xattr_acls_decoder, false, false }, + xattr_acls_a_coder, xattr_acls_a_decoder, false, false }, + { "SCHILY.xattr.system.posix_acl_default", + xattr_acls_d_coder, xattr_acls_d_decoder, false, false }, /* xattr's, use the star format note we only save the user/root varients... */ { "SCHILY.xattr.user", xattr_coder, xattr_decoder, false, true },