1 /* POSIX extended headers for tar.
3 Copyright (C) 2003-2007, 2009-2010, 2012-2014 Free Software
6 This file is part of GNU tar.
8 GNU tar is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 GNU tar is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
30 static void xheader_init (struct xheader *xhdr);
31 static bool xheader_protected_pattern_p (char const *pattern);
32 static bool xheader_protected_keyword_p (char const *keyword);
33 static void xheader_set_single_keyword (char *) __attribute__ ((noreturn));
35 /* Used by xheader_finish() */
36 static void code_string (char const *string, char const *keyword,
37 struct xheader *xhdr);
39 /* Number of global headers written so far. */
40 static size_t global_header_count;
41 /* FIXME: Possibly it should be reset after changing the volume.
42 POSIX %n specification says that it is expanded to the sequence
43 number of current global header in *the* archive. However, for
44 multi-volume archives this will yield duplicate header names
45 in different volumes, which I'd like to avoid. The best way
46 to solve this would be to use per-archive header count as required
47 by POSIX *and* set globexthdr.name to, say,
48 $TMPDIR/GlobalHead.%p.$NUMVOLUME.%n.
50 However it should wait until buffer.c is finally rewritten */
53 /* Interface functions to obstacks */
56 x_obstack_grow (struct xheader *xhdr, const char *ptr, size_t length)
58 obstack_grow (xhdr->stk, ptr, length);
63 x_obstack_1grow (struct xheader *xhdr, char c)
65 obstack_1grow (xhdr->stk, c);
70 x_obstack_blank (struct xheader *xhdr, size_t length)
72 obstack_blank (xhdr->stk, length);
81 struct keyword_list *next;
87 /* List of keyword patterns set by delete= option */
88 static struct keyword_list *keyword_pattern_list;
90 /* List of keyword/value pairs set by 'keyword=value' option */
91 static struct keyword_list *keyword_global_override_list;
93 /* List of keyword/value pairs set by 'keyword:=value' option */
94 static struct keyword_list *keyword_override_list;
96 /* List of keyword/value pairs decoded from the last 'g' type header */
97 static struct keyword_list *global_header_override_list;
99 /* Template for the name field of an 'x' type header */
100 static char *exthdr_name;
102 static char *exthdr_mtime_option;
103 static time_t exthdr_mtime;
105 /* Template for the name field of a 'g' type header */
106 static char *globexthdr_name;
108 static char *globexthdr_mtime_option;
109 static time_t globexthdr_mtime;
112 xheader_keyword_deleted_p (const char *kw)
114 struct keyword_list *kp;
116 for (kp = keyword_pattern_list; kp; kp = kp->next)
117 if (fnmatch (kp->pattern, kw, 0) == 0)
123 xheader_keyword_override_p (const char *keyword)
125 struct keyword_list *kp;
127 for (kp = keyword_override_list; kp; kp = kp->next)
128 if (strcmp (kp->pattern, keyword) == 0)
134 xheader_list_append (struct keyword_list **root, char const *kw,
137 struct keyword_list *kp = xmalloc (sizeof *kp);
138 kp->pattern = xstrdup (kw);
139 kp->value = value ? xstrdup (value) : NULL;
145 xheader_list_destroy (struct keyword_list **root)
149 struct keyword_list *kw = *root;
152 struct keyword_list *next = kw->next;
163 xheader_set_single_keyword (char *kw)
165 USAGE_ERROR ((0, 0, _("Keyword %s is unknown or not yet implemented"), kw));
169 assign_time_option (char **sval, time_t *tval, const char *input)
172 struct timespec t = decode_timespec (input, &p, false);
173 if (! valid_timespec (t) || *p)
174 ERROR ((0, 0, _("Time stamp is out of allowed range")));
178 assign_string (sval, input);
183 xheader_set_keyword_equal (char *kw, char *eq)
194 while (p > kw && isspace ((unsigned char) *p))
199 for (p = eq + 1; *p && isspace ((unsigned char) *p); p++)
202 if (strcmp (kw, "delete") == 0)
204 if (xheader_protected_pattern_p (p))
205 USAGE_ERROR ((0, 0, _("Pattern %s cannot be used"), quote (p)));
206 xheader_list_append (&keyword_pattern_list, p, NULL);
208 else if (strcmp (kw, "exthdr.name") == 0)
209 assign_string (&exthdr_name, p);
210 else if (strcmp (kw, "globexthdr.name") == 0)
211 assign_string (&globexthdr_name, p);
212 else if (strcmp (kw, "exthdr.mtime") == 0)
213 assign_time_option (&exthdr_mtime_option, &exthdr_mtime, p);
214 else if (strcmp (kw, "globexthdr.mtime") == 0)
215 assign_time_option (&globexthdr_mtime_option, &globexthdr_mtime, p);
218 if (xheader_protected_keyword_p (kw))
219 USAGE_ERROR ((0, 0, _("Keyword %s cannot be overridden"), kw));
221 xheader_list_append (&keyword_global_override_list, kw, p);
223 xheader_list_append (&keyword_override_list, kw, p);
228 xheader_set_option (char *string)
231 for (token = strtok (string, ","); token; token = strtok (NULL, ","))
233 char *p = strchr (token, '=');
235 xheader_set_single_keyword (token);
237 xheader_set_keyword_equal (token, p);
242 string Includes: Replaced By:
243 %d The directory name of the file,
244 equivalent to the result of the
245 dirname utility on the translated
247 %f The filename of the file, equivalent
248 to the result of the basename
249 utility on the translated file name.
250 %p The process ID of the pax process.
251 %n The value of the 3rd argument.
252 %% A '%' character. */
255 xheader_format_name (struct tar_stat_info *st, const char *fmt, size_t n)
258 size_t len = strlen (fmt);
264 char pidbuf[UINTMAX_STRSIZE_BOUND];
265 char const *pptr = NULL;
266 char nbuf[UINTMAX_STRSIZE_BOUND];
267 char const *nptr = NULL;
269 for (p = fmt; *p && (p = strchr (p, '%')); )
281 dirp = dir_name (st->orig_file_name);
282 dir = safer_name_suffix (dirp, false, absolute_names_option);
283 len += strlen (dir) - 2;
290 base = last_component (st->orig_file_name);
291 len += strlen (base) - 2;
296 pptr = umaxtostr (getpid (), pidbuf);
297 len += pidbuf + sizeof pidbuf - 1 - pptr - 2;
301 nptr = umaxtostr (n, nbuf);
302 len += nbuf + sizeof nbuf - 1 - nptr - 2;
308 buf = xmalloc (len + 1);
309 for (q = buf, p = fmt; *p; )
328 q = stpcpy (q, base);
333 q = stpcpy (q, pptr);
338 q = stpcpy (q, nptr);
355 /* Do not allow it to end in a slash */
356 while (q > buf && ISSLASH (q[-1]))
363 xheader_xhdr_name (struct tar_stat_info *st)
366 assign_string (&exthdr_name, "%d/PaxHeaders.%p/%f");
367 return xheader_format_name (st, exthdr_name, 0);
370 #define GLOBAL_HEADER_TEMPLATE "/GlobalHead.%p.%n"
373 xheader_ghdr_name (void)
375 if (!globexthdr_name)
378 const char *tmp = getenv ("TMPDIR");
381 len = strlen (tmp) + sizeof (GLOBAL_HEADER_TEMPLATE); /* Includes nul */
382 globexthdr_name = xmalloc (len);
383 strcpy(globexthdr_name, tmp);
384 strcat(globexthdr_name, GLOBAL_HEADER_TEMPLATE);
387 return xheader_format_name (NULL, globexthdr_name, global_header_count + 1);
391 xheader_write (char type, char *name, time_t t, struct xheader *xhdr)
401 if (globexthdr_mtime_option)
402 t = globexthdr_mtime;
406 if (exthdr_mtime_option)
410 header = start_private_header (name, size, t);
411 header->header.typeflag = type;
413 simple_finish_header (header);
421 header = find_next_block ();
425 memcpy (header->buffer, p, len);
427 memset (header->buffer + len, 0, BLOCKSIZE - len);
430 set_next_block_after (header);
433 xheader_destroy (xhdr);
436 global_header_count++;
440 xheader_write_global (struct xheader *xhdr)
442 if (keyword_global_override_list)
444 struct keyword_list *kp;
447 for (kp = keyword_global_override_list; kp; kp = kp->next)
448 code_string (kp->value, kp->pattern, xhdr);
454 xheader_finish (xhdr);
455 name = xheader_ghdr_name ();
456 xheader_write (XGLTYPE, name, start_time.tv_sec, xhdr);
462 xheader_xattr_init (struct tar_stat_info *st)
464 st->xattr_map = NULL;
465 st->xattr_map_size = 0;
467 st->acls_a_ptr = NULL;
469 st->acls_d_ptr = NULL;
471 st->cntx_name = NULL;
475 xheader_xattr_free (struct xattr_array *xattr_map, size_t xattr_map_size)
479 while (scan < xattr_map_size)
481 free (xattr_map[scan].xkey);
482 free (xattr_map[scan].xval_ptr);
490 xheader_xattr__add (struct xattr_array **xattr_map,
491 size_t *xattr_map_size,
492 const char *key, const char *val, size_t len)
494 size_t pos = (*xattr_map_size)++;
496 *xattr_map = xrealloc (*xattr_map,
497 *xattr_map_size * sizeof(struct xattr_array));
498 (*xattr_map)[pos].xkey = xstrdup (key);
499 (*xattr_map)[pos].xval_ptr = xmemdup (val, len + 1);
500 (*xattr_map)[pos].xval_len = len;
503 /* This is reversal function for xattr_encode_keyword. See comment for
504 xattr_encode_keyword() for more info. */
506 xattr_decode_keyword (char *keyword)
508 char *kpr, *kpl; /* keyword pointer left/right */
515 if (kpr[1] == '3' && kpr[2] == 'D')
522 else if (kpr[1] == '2' && kpr[2] == '5')
542 xheader_xattr_add (struct tar_stat_info *st,
543 const char *key, const char *val, size_t len)
545 size_t klen = strlen (key);
546 char *xkey = xmalloc (strlen("SCHILY.xattr.") + klen + 1);
549 tmp = stpcpy (tmp, "SCHILY.xattr.");
552 xheader_xattr__add (&st->xattr_map, &st->xattr_map_size, xkey, val, len);
558 xheader_xattr_copy (const struct tar_stat_info *st,
559 struct xattr_array **xattr_map, size_t *xattr_map_size)
566 while (scan < st->xattr_map_size)
568 char *key = st->xattr_map[scan].xkey;
569 char *val = st->xattr_map[scan].xval_ptr;
570 size_t len = st->xattr_map[scan].xval_len;
572 xheader_xattr__add(xattr_map, xattr_map_size, key, val, len);
579 /* General Interface */
581 #define XHDR_PROTECTED 0x01
582 #define XHDR_GLOBAL 0x02
587 void (*coder) (struct tar_stat_info const *, char const *,
588 struct xheader *, void const *data);
589 void (*decoder) (struct tar_stat_info *, char const *, char const *, size_t);
591 bool prefix; /* select handler comparing prefix only */
594 /* This declaration must be extern, because ISO C99 section 6.9.2
595 prohibits a tentative definition that has both internal linkage and
596 incomplete type. If we made it static, we'd have to declare its
597 size which would be a maintenance pain; if we put its initializer
598 here, we'd need a boatload of forward declarations, which would be
599 even more of a pain. */
600 extern struct xhdr_tab const xhdr_tab[];
602 static struct xhdr_tab const *
603 locate_handler (char const *keyword)
605 struct xhdr_tab const *p;
607 for (p = xhdr_tab; p->keyword; p++)
610 if (strncmp (p->keyword, keyword, strlen(p->keyword)) == 0)
615 if (strcmp (p->keyword, keyword) == 0)
623 xheader_protected_pattern_p (const char *pattern)
625 struct xhdr_tab const *p;
627 for (p = xhdr_tab; p->keyword; p++)
628 if (!p->prefix && (p->flags & XHDR_PROTECTED)
629 && fnmatch (pattern, p->keyword, 0) == 0)
635 xheader_protected_keyword_p (const char *keyword)
637 struct xhdr_tab const *p;
639 for (p = xhdr_tab; p->keyword; p++)
640 if (!p->prefix && (p->flags & XHDR_PROTECTED)
641 && strcmp (p->keyword, keyword) == 0)
646 /* Decode a single extended header record, advancing *PTR to the next record.
647 Return true on success, false otherwise. */
649 decode_record (struct xheader *xhdr,
651 void (*handler) (void *, char const *, char const *, size_t),
660 size_t len_max = xhdr->buffer + xhdr->size - start;
662 while (*p == ' ' || *p == '\t')
668 ERROR ((0, 0, _("Malformed extended header: missing length")));
672 len = strtoumax (p, &len_lim, 10);
676 int len_len = len_lim - p;
677 ERROR ((0, 0, _("Extended header length %*s is out of range"),
684 for (p = len_lim; *p == ' ' || *p == '\t'; p++)
689 _("Malformed extended header: missing blank after length")));
695 if (! (p && p < nextp))
697 ERROR ((0, 0, _("Malformed extended header: missing equal sign")));
701 if (nextp[-1] != '\n')
703 ERROR ((0, 0, _("Malformed extended header: missing newline")));
707 *p = nextp[-1] = '\0';
708 handler (data, keyword, p + 1, nextp - p - 2); /* '=' + trailing '\n' */
716 run_override_list (struct keyword_list *kp, struct tar_stat_info *st)
718 for (; kp; kp = kp->next)
720 struct xhdr_tab const *t = locate_handler (kp->pattern);
722 t->decoder (st, t->keyword, kp->value, strlen (kp->value));
727 decx (void *data, char const *keyword, char const *value, size_t size)
729 struct xhdr_tab const *t;
730 struct tar_stat_info *st = data;
732 if (xheader_keyword_deleted_p (keyword)
733 || xheader_keyword_override_p (keyword))
736 t = locate_handler (keyword);
738 t->decoder (st, keyword, value, size);
740 WARNOPT (WARN_UNKNOWN_KEYWORD,
741 (0, 0, _("Ignoring unknown extended header keyword '%s'"),
746 xheader_decode (struct tar_stat_info *st)
748 run_override_list (keyword_global_override_list, st);
749 run_override_list (global_header_override_list, st);
753 char *p = st->xhdr.buffer + BLOCKSIZE;
754 while (decode_record (&st->xhdr, &p, decx, st))
757 run_override_list (keyword_override_list, st);
761 decg (void *data, char const *keyword, char const *value,
762 size_t size __attribute__((unused)))
764 struct keyword_list **kwl = data;
765 struct xhdr_tab const *tab = locate_handler (keyword);
766 if (tab && (tab->flags & XHDR_GLOBAL))
767 tab->decoder (data, keyword, value, size);
769 xheader_list_append (kwl, keyword, value);
773 xheader_decode_global (struct xheader *xhdr)
777 char *p = xhdr->buffer + BLOCKSIZE;
779 xheader_list_destroy (&global_header_override_list);
780 while (decode_record (xhdr, &p, decg, &global_header_override_list))
786 xheader_init (struct xheader *xhdr)
790 xhdr->stk = xmalloc (sizeof *xhdr->stk);
791 obstack_init (xhdr->stk);
796 xheader_store (char const *keyword, struct tar_stat_info *st,
799 struct xhdr_tab const *t;
803 t = locate_handler (keyword);
806 if (xheader_keyword_deleted_p (keyword)
807 || xheader_keyword_override_p (keyword))
809 xheader_init (&st->xhdr);
810 t->coder (st, keyword, &st->xhdr, data);
814 xheader_read (struct xheader *xhdr, union block *p, off_t size)
819 size = 0; /* Already diagnosed. */
821 if (SIZE_MAX - BLOCKSIZE <= size)
826 xhdr->buffer = xmalloc (size + 1);
827 xhdr->buffer[size] = '\0';
837 FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
839 memcpy (&xhdr->buffer[j], p->buffer, len);
840 set_next_block_after (p);
842 p = find_next_block ();
850 /* xattr_encode_keyword() substitutes '=' ~~> '%3D' and '%' ~~> '%25'
851 in extended attribute keywords. This is needed because the '=' character
852 has special purpose in extended attribute header - it splits keyword and
853 value part of header. If there was the '=' occurrence allowed inside
854 keyword, there would be no unambiguous way how to decode this extended
857 (http://lists.gnu.org/archive/html/bug-tar/2012-10/msg00017.html)
860 xattr_encode_keyword(const char *keyword)
862 static char *encode_buffer = NULL;
863 static size_t encode_buffer_size = 0;
864 size_t bp; /* keyword/buffer pointers */
868 encode_buffer_size = 256;
869 encode_buffer = xmalloc (encode_buffer_size);
874 for (bp = 0; *keyword != 0; ++bp, ++keyword)
878 if (bp + 2 /* enough for URL encoding also.. */ >= encode_buffer_size)
880 encode_buffer = x2realloc (encode_buffer, &encode_buffer_size);
885 strcpy (encode_buffer + bp, "%25");
890 strcpy (encode_buffer + bp, "%3D");
894 encode_buffer[bp] = c;
897 encode_buffer[bp] = 0;
899 return encode_buffer;
903 xheader_print_n (struct xheader *xhdr, char const *keyword,
904 char const *value, size_t vsize)
908 char nbuf[UINTMAX_STRSIZE_BOUND];
912 keyword = xattr_encode_keyword (keyword);
913 klen = strlen (keyword);
914 len = klen + vsize + 3; /* ' ' + '=' + '\n' */
919 np = umaxtostr (len + p, nbuf);
920 n = nbuf + sizeof nbuf - 1 - np;
924 x_obstack_grow (xhdr, np, n);
925 x_obstack_1grow (xhdr, ' ');
926 x_obstack_grow (xhdr, keyword, klen);
927 x_obstack_1grow (xhdr, '=');
928 x_obstack_grow (xhdr, value, vsize);
929 x_obstack_1grow (xhdr, '\n');
933 xheader_print (struct xheader *xhdr, char const *keyword, char const *value)
935 xheader_print_n (xhdr, keyword, value, strlen (value));
939 xheader_finish (struct xheader *xhdr)
941 struct keyword_list *kp;
943 for (kp = keyword_override_list; kp; kp = kp->next)
944 code_string (kp->value, kp->pattern, xhdr);
946 xhdr->buffer = obstack_finish (xhdr->stk);
950 xheader_destroy (struct xheader *xhdr)
954 obstack_free (xhdr->stk, NULL);
965 /* Buildable strings */
968 xheader_string_begin (struct xheader *xhdr)
970 xhdr->string_length = 0;
974 xheader_string_add (struct xheader *xhdr, char const *s)
979 xhdr->string_length += strlen (s);
980 x_obstack_grow (xhdr, s, strlen (s));
984 xheader_string_end (struct xheader *xhdr, char const *keyword)
990 char nbuf[UINTMAX_STRSIZE_BOUND];
998 len = strlen (keyword) + xhdr->string_length + 3; /* ' ' + '=' + '\n' */
1003 np = umaxtostr (len + p, nbuf);
1004 n = nbuf + sizeof nbuf - 1 - np;
1008 p = strlen (keyword) + n + 2;
1013 _("Generated keyword/value pair is too long (keyword=%s, length=%s)"),
1015 obstack_free (xhdr->stk, obstack_finish (xhdr->stk));
1018 x_obstack_blank (xhdr, p);
1019 x_obstack_1grow (xhdr, '\n');
1020 cp = obstack_next_free (xhdr->stk) - xhdr->string_length - p - 1;
1021 memmove (cp + p, cp, xhdr->string_length);
1022 cp = stpcpy (cp, np);
1024 cp = stpcpy (cp, keyword);
1030 /* Implementations */
1033 out_of_range_header (char const *keyword, char const *value,
1034 intmax_t minval, uintmax_t maxval)
1036 char minval_buf[INT_BUFSIZE_BOUND (intmax_t)];
1037 char maxval_buf[UINTMAX_STRSIZE_BOUND];
1038 char *minval_string = imaxtostr (minval, minval_buf);
1039 char *maxval_string = umaxtostr (maxval, maxval_buf);
1041 /* TRANSLATORS: The first %s is the pax extended header keyword
1042 (atime, gid, etc.). */
1043 ERROR ((0, 0, _("Extended header %s=%s is out of range %s..%s"),
1044 keyword, value, minval_string, maxval_string));
1048 code_string (char const *string, char const *keyword, struct xheader *xhdr)
1051 if (!utf8_convert (true, string, &outstr))
1053 /* FIXME: report error */
1054 outstr = xstrdup (string);
1056 xheader_print (xhdr, keyword, outstr);
1061 decode_string (char **string, char const *arg)
1068 if (!utf8_convert (false, arg, string))
1070 /* FIXME: report error and act accordingly to --pax invalid=UTF-8 */
1071 assign_string (string, arg);
1076 code_time (struct timespec t, char const *keyword, struct xheader *xhdr)
1078 char buf[TIMESPEC_STRSIZE_BOUND];
1079 xheader_print (xhdr, keyword, code_timespec (t, buf));
1083 decode_time (struct timespec *ts, char const *arg, char const *keyword)
1086 struct timespec t = decode_timespec (arg, &arg_lim, true);
1088 if (! valid_timespec (t))
1090 if (arg < arg_lim && !*arg_lim)
1091 out_of_range_header (keyword, arg, TYPE_MINIMUM (time_t),
1092 TYPE_MAXIMUM (time_t));
1094 ERROR ((0, 0, _("Malformed extended header: invalid %s=%s"),
1104 code_signed_num (uintmax_t value, char const *keyword,
1105 intmax_t minval, uintmax_t maxval, struct xheader *xhdr)
1107 char sbuf[SYSINT_BUFSIZE];
1108 xheader_print (xhdr, keyword, sysinttostr (value, minval, maxval, sbuf));
1112 code_num (uintmax_t value, char const *keyword, struct xheader *xhdr)
1114 code_signed_num (value, keyword, 0, UINTMAX_MAX, xhdr);
1118 decode_signed_num (intmax_t *num, char const *arg,
1119 intmax_t minval, uintmax_t maxval,
1120 char const *keyword)
1123 intmax_t u = strtosysint (arg, &arg_lim, minval, maxval);
1125 if (errno == EINVAL || *arg_lim)
1127 ERROR ((0, 0, _("Malformed extended header: invalid %s=%s"),
1132 if (errno == ERANGE)
1134 out_of_range_header (keyword, arg, minval, maxval);
1143 decode_num (uintmax_t *num, char const *arg, uintmax_t maxval,
1144 char const *keyword)
1147 if (! decode_signed_num (&i, arg, 0, maxval, keyword))
1154 dummy_coder (struct tar_stat_info const *st __attribute__ ((unused)),
1155 char const *keyword __attribute__ ((unused)),
1156 struct xheader *xhdr __attribute__ ((unused)),
1157 void const *data __attribute__ ((unused)))
1162 dummy_decoder (struct tar_stat_info *st __attribute__ ((unused)),
1163 char const *keyword __attribute__ ((unused)),
1164 char const *arg __attribute__ ((unused)),
1165 size_t size __attribute__((unused)))
1170 atime_coder (struct tar_stat_info const *st, char const *keyword,
1171 struct xheader *xhdr, void const *data __attribute__ ((unused)))
1173 code_time (st->atime, keyword, xhdr);
1177 atime_decoder (struct tar_stat_info *st,
1178 char const *keyword,
1180 size_t size __attribute__((unused)))
1183 if (decode_time (&ts, arg, keyword))
1188 gid_coder (struct tar_stat_info const *st, char const *keyword,
1189 struct xheader *xhdr, void const *data __attribute__ ((unused)))
1191 code_signed_num (st->stat.st_gid, keyword,
1192 TYPE_MINIMUM (gid_t), TYPE_MAXIMUM (gid_t), xhdr);
1196 gid_decoder (struct tar_stat_info *st,
1197 char const *keyword,
1199 size_t size __attribute__((unused)))
1202 if (decode_signed_num (&u, arg, TYPE_MINIMUM (gid_t),
1203 TYPE_MAXIMUM (gid_t), keyword))
1204 st->stat.st_gid = u;
1208 gname_coder (struct tar_stat_info const *st, char const *keyword,
1209 struct xheader *xhdr, void const *data __attribute__ ((unused)))
1211 code_string (st->gname, keyword, xhdr);
1215 gname_decoder (struct tar_stat_info *st,
1216 char const *keyword __attribute__((unused)),
1218 size_t size __attribute__((unused)))
1220 decode_string (&st->gname, arg);
1224 linkpath_coder (struct tar_stat_info const *st, char const *keyword,
1225 struct xheader *xhdr, void const *data __attribute__ ((unused)))
1227 code_string (st->link_name, keyword, xhdr);
1231 linkpath_decoder (struct tar_stat_info *st,
1232 char const *keyword __attribute__((unused)),
1234 size_t size __attribute__((unused)))
1236 decode_string (&st->link_name, arg);
1240 ctime_coder (struct tar_stat_info const *st, char const *keyword,
1241 struct xheader *xhdr, void const *data __attribute__ ((unused)))
1243 code_time (st->ctime, keyword, xhdr);
1247 ctime_decoder (struct tar_stat_info *st,
1248 char const *keyword,
1250 size_t size __attribute__((unused)))
1253 if (decode_time (&ts, arg, keyword))
1258 mtime_coder (struct tar_stat_info const *st, char const *keyword,
1259 struct xheader *xhdr, void const *data)
1261 struct timespec const *mtime = data;
1262 code_time (mtime ? *mtime : st->mtime, keyword, xhdr);
1266 mtime_decoder (struct tar_stat_info *st,
1267 char const *keyword,
1269 size_t size __attribute__((unused)))
1272 if (decode_time (&ts, arg, keyword))
1277 path_coder (struct tar_stat_info const *st, char const *keyword,
1278 struct xheader *xhdr, void const *data __attribute__ ((unused)))
1280 code_string (st->file_name, keyword, xhdr);
1284 path_decoder (struct tar_stat_info *st,
1285 char const *keyword __attribute__((unused)),
1287 size_t size __attribute__((unused)))
1289 decode_string (&st->orig_file_name, arg);
1290 decode_string (&st->file_name, arg);
1291 st->had_trailing_slash = strip_trailing_slashes (st->file_name);
1295 size_coder (struct tar_stat_info const *st, char const *keyword,
1296 struct xheader *xhdr, void const *data __attribute__ ((unused)))
1298 code_num (st->stat.st_size, keyword, xhdr);
1302 size_decoder (struct tar_stat_info *st,
1303 char const *keyword,
1305 size_t size __attribute__((unused)))
1308 if (decode_num (&u, arg, TYPE_MAXIMUM (off_t), keyword))
1309 st->stat.st_size = u;
1313 uid_coder (struct tar_stat_info const *st, char const *keyword,
1314 struct xheader *xhdr, void const *data __attribute__ ((unused)))
1316 code_signed_num (st->stat.st_uid, keyword,
1317 TYPE_MINIMUM (uid_t), TYPE_MAXIMUM (uid_t), xhdr);
1321 uid_decoder (struct tar_stat_info *st,
1322 char const *keyword,
1324 size_t size __attribute__((unused)))
1327 if (decode_signed_num (&u, arg, TYPE_MINIMUM (uid_t),
1328 TYPE_MAXIMUM (uid_t), keyword))
1329 st->stat.st_uid = u;
1333 uname_coder (struct tar_stat_info const *st, char const *keyword,
1334 struct xheader *xhdr, void const *data __attribute__ ((unused)))
1336 code_string (st->uname, keyword, xhdr);
1340 uname_decoder (struct tar_stat_info *st,
1341 char const *keyword __attribute__((unused)),
1343 size_t size __attribute__((unused)))
1345 decode_string (&st->uname, arg);
1349 sparse_size_coder (struct tar_stat_info const *st, char const *keyword,
1350 struct xheader *xhdr, void const *data)
1352 size_coder (st, keyword, xhdr, data);
1356 sparse_size_decoder (struct tar_stat_info *st,
1357 char const *keyword,
1359 size_t size __attribute__((unused)))
1362 if (decode_num (&u, arg, TYPE_MAXIMUM (off_t), keyword))
1363 st->stat.st_size = u;
1367 sparse_numblocks_coder (struct tar_stat_info const *st, char const *keyword,
1368 struct xheader *xhdr,
1369 void const *data __attribute__ ((unused)))
1371 code_num (st->sparse_map_avail, keyword, xhdr);
1375 sparse_numblocks_decoder (struct tar_stat_info *st,
1376 char const *keyword,
1378 size_t size __attribute__((unused)))
1381 if (decode_num (&u, arg, SIZE_MAX, keyword))
1383 st->sparse_map_size = u;
1384 st->sparse_map = xcalloc (u, sizeof st->sparse_map[0]);
1385 st->sparse_map_avail = 0;
1390 sparse_offset_coder (struct tar_stat_info const *st, char const *keyword,
1391 struct xheader *xhdr, void const *data)
1393 size_t const *pi = data;
1394 code_num (st->sparse_map[*pi].offset, keyword, xhdr);
1398 sparse_offset_decoder (struct tar_stat_info *st,
1399 char const *keyword,
1401 size_t size __attribute__((unused)))
1404 if (decode_num (&u, arg, TYPE_MAXIMUM (off_t), keyword))
1406 if (st->sparse_map_avail < st->sparse_map_size)
1407 st->sparse_map[st->sparse_map_avail].offset = u;
1409 ERROR ((0, 0, _("Malformed extended header: excess %s=%s"),
1410 "GNU.sparse.offset", arg));
1415 sparse_numbytes_coder (struct tar_stat_info const *st, char const *keyword,
1416 struct xheader *xhdr, void const *data)
1418 size_t const *pi = data;
1419 code_num (st->sparse_map[*pi].numbytes, keyword, xhdr);
1423 sparse_numbytes_decoder (struct tar_stat_info *st,
1424 char const *keyword,
1426 size_t size __attribute__((unused)))
1429 if (decode_num (&u, arg, TYPE_MAXIMUM (off_t), keyword))
1431 if (st->sparse_map_avail < st->sparse_map_size)
1432 st->sparse_map[st->sparse_map_avail++].numbytes = u;
1434 ERROR ((0, 0, _("Malformed extended header: excess %s=%s"),
1440 sparse_map_decoder (struct tar_stat_info *st,
1441 char const *keyword,
1443 size_t size __attribute__((unused)))
1447 st->sparse_map_avail = 0;
1454 if (!ISDIGIT (*arg))
1456 ERROR ((0, 0, _("Malformed extended header: invalid %s=%s"),
1462 u = strtoimax (arg, &delim, 10);
1463 if (TYPE_MAXIMUM (off_t) < u)
1465 u = TYPE_MAXIMUM (off_t);
1471 if (errno == ERANGE)
1473 out_of_range_header (keyword, arg, 0, TYPE_MAXIMUM (off_t));
1480 if (errno == ERANGE)
1482 out_of_range_header (keyword, arg, 0, TYPE_MAXIMUM (off_t));
1485 if (st->sparse_map_avail < st->sparse_map_size)
1486 st->sparse_map[st->sparse_map_avail++] = e;
1489 ERROR ((0, 0, _("Malformed extended header: excess %s=%s"),
1499 else if (*delim != ',')
1502 _("Malformed extended header: invalid %s: unexpected delimiter %c"),
1512 _("Malformed extended header: invalid %s: odd number of values"),
1517 dumpdir_coder (struct tar_stat_info const *st, char const *keyword,
1518 struct xheader *xhdr, void const *data)
1520 xheader_print_n (xhdr, keyword, data, dumpdir_size (data));
1524 dumpdir_decoder (struct tar_stat_info *st,
1525 char const *keyword __attribute__((unused)),
1529 st->dumpdir = xmalloc (size);
1530 memcpy (st->dumpdir, arg, size);
1534 volume_label_coder (struct tar_stat_info const *st, char const *keyword,
1535 struct xheader *xhdr, void const *data)
1537 code_string (data, keyword, xhdr);
1541 volume_label_decoder (struct tar_stat_info *st,
1542 char const *keyword __attribute__((unused)),
1544 size_t size __attribute__((unused)))
1546 decode_string (&volume_label, arg);
1550 volume_size_coder (struct tar_stat_info const *st, char const *keyword,
1551 struct xheader *xhdr, void const *data)
1553 off_t const *v = data;
1554 code_num (*v, keyword, xhdr);
1558 volume_size_decoder (struct tar_stat_info *st,
1559 char const *keyword,
1560 char const *arg, size_t size)
1563 if (decode_num (&u, arg, TYPE_MAXIMUM (uintmax_t), keyword))
1564 continued_file_size = u;
1567 /* FIXME: Merge with volume_size_coder */
1569 volume_offset_coder (struct tar_stat_info const *st, char const *keyword,
1570 struct xheader *xhdr, void const *data)
1572 off_t const *v = data;
1573 code_num (*v, keyword, xhdr);
1577 volume_offset_decoder (struct tar_stat_info *st,
1578 char const *keyword,
1579 char const *arg, size_t size)
1582 if (decode_num (&u, arg, TYPE_MAXIMUM (uintmax_t), keyword))
1583 continued_file_offset = u;
1587 volume_filename_decoder (struct tar_stat_info *st,
1588 char const *keyword __attribute__((unused)),
1590 size_t size __attribute__((unused)))
1592 decode_string (&continued_file_name, arg);
1596 xattr_selinux_coder (struct tar_stat_info const *st, char const *keyword,
1597 struct xheader *xhdr, void const *data)
1599 code_string (st->cntx_name, keyword, xhdr);
1603 xattr_selinux_decoder (struct tar_stat_info *st,
1604 char const *keyword, char const *arg, size_t size)
1606 decode_string (&st->cntx_name, arg);
1610 xattr_acls_a_coder (struct tar_stat_info const *st , char const *keyword,
1611 struct xheader *xhdr, void const *data)
1613 xheader_print_n (xhdr, keyword, st->acls_a_ptr, st->acls_a_len);
1617 xattr_acls_a_decoder (struct tar_stat_info *st,
1618 char const *keyword, char const *arg, size_t size)
1620 st->acls_a_ptr = xmemdup (arg, size + 1);
1621 st->acls_a_len = size;
1625 xattr_acls_d_coder (struct tar_stat_info const *st , char const *keyword,
1626 struct xheader *xhdr, void const *data)
1628 xheader_print_n (xhdr, keyword, st->acls_d_ptr, st->acls_d_len);
1632 xattr_acls_d_decoder (struct tar_stat_info *st,
1633 char const *keyword, char const *arg, size_t size)
1635 st->acls_d_ptr = xmemdup (arg, size + 1);
1636 st->acls_d_len = size;
1640 xattr_coder (struct tar_stat_info const *st, char const *keyword,
1641 struct xheader *xhdr, void const *data)
1643 struct xattr_array *xattr_map = st->xattr_map;
1644 const size_t *off = data;
1645 xheader_print_n (xhdr, keyword,
1646 xattr_map[*off].xval_ptr, xattr_map[*off].xval_len);
1650 xattr_decoder (struct tar_stat_info *st,
1651 char const *keyword, char const *arg, size_t size)
1656 size_t klen_raw = strlen (keyword);
1657 xkey = alloca (klen_raw + 1);
1658 memcpy (xkey, keyword, klen_raw + 1) /* including null-terminating */;
1661 xstr = alloca (size + 1);
1662 memcpy (xstr, arg, size + 1); /* separator included, for GNU tar '\n' */;
1664 xattr_decode_keyword (xkey);
1666 xheader_xattr_add (st, xkey + strlen("SCHILY.xattr."), xstr, size);
1670 sparse_major_coder (struct tar_stat_info const *st, char const *keyword,
1671 struct xheader *xhdr, void const *data)
1673 code_num (st->sparse_major, keyword, xhdr);
1677 sparse_major_decoder (struct tar_stat_info *st,
1678 char const *keyword,
1683 if (decode_num (&u, arg, TYPE_MAXIMUM (unsigned), keyword))
1684 st->sparse_major = u;
1688 sparse_minor_coder (struct tar_stat_info const *st, char const *keyword,
1689 struct xheader *xhdr, void const *data)
1691 code_num (st->sparse_minor, keyword, xhdr);
1695 sparse_minor_decoder (struct tar_stat_info *st,
1696 char const *keyword,
1701 if (decode_num (&u, arg, TYPE_MAXIMUM (unsigned), keyword))
1702 st->sparse_minor = u;
1705 struct xhdr_tab const xhdr_tab[] = {
1706 { "atime", atime_coder, atime_decoder, 0, false },
1707 { "comment", dummy_coder, dummy_decoder, 0, false },
1708 { "charset", dummy_coder, dummy_decoder, 0, false },
1709 { "ctime", ctime_coder, ctime_decoder, 0, false },
1710 { "gid", gid_coder, gid_decoder, 0, false },
1711 { "gname", gname_coder, gname_decoder, 0, false },
1712 { "linkpath", linkpath_coder, linkpath_decoder, 0, false },
1713 { "mtime", mtime_coder, mtime_decoder, 0, false },
1714 { "path", path_coder, path_decoder, 0, false },
1715 { "size", size_coder, size_decoder, 0, false },
1716 { "uid", uid_coder, uid_decoder, 0, false },
1717 { "uname", uname_coder, uname_decoder, 0, false },
1719 /* Sparse file handling */
1720 { "GNU.sparse.name", path_coder, path_decoder,
1721 XHDR_PROTECTED, false },
1722 { "GNU.sparse.major", sparse_major_coder, sparse_major_decoder,
1723 XHDR_PROTECTED, false },
1724 { "GNU.sparse.minor", sparse_minor_coder, sparse_minor_decoder,
1725 XHDR_PROTECTED, false },
1726 { "GNU.sparse.realsize", sparse_size_coder, sparse_size_decoder,
1727 XHDR_PROTECTED, false },
1728 { "GNU.sparse.numblocks", sparse_numblocks_coder, sparse_numblocks_decoder,
1729 XHDR_PROTECTED, false },
1731 /* tar 1.14 - 1.15.90 keywords. */
1732 { "GNU.sparse.size", sparse_size_coder, sparse_size_decoder,
1733 XHDR_PROTECTED, false },
1734 /* tar 1.14 - 1.15.1 keywords. Multiple instances of these appeared in 'x'
1735 headers, and each of them was meaningful. It confilcted with POSIX specs,
1736 which requires that "when extended header records conflict, the last one
1737 given in the header shall take precedence." */
1738 { "GNU.sparse.offset", sparse_offset_coder, sparse_offset_decoder,
1739 XHDR_PROTECTED, false },
1740 { "GNU.sparse.numbytes", sparse_numbytes_coder, sparse_numbytes_decoder,
1741 XHDR_PROTECTED, false },
1742 /* tar 1.15.90 keyword, introduced to remove the above-mentioned conflict. */
1743 { "GNU.sparse.map", NULL /* Unused, see pax_dump_header() */,
1744 sparse_map_decoder, 0, false },
1746 { "GNU.dumpdir", dumpdir_coder, dumpdir_decoder,
1747 XHDR_PROTECTED, false },
1749 /* Keeps the tape/volume label. May be present only in the global headers.
1750 Equivalent to GNUTYPE_VOLHDR. */
1751 { "GNU.volume.label", volume_label_coder, volume_label_decoder,
1752 XHDR_PROTECTED | XHDR_GLOBAL, false },
1754 /* These may be present in a first global header of the archive.
1755 They provide the same functionality as GNUTYPE_MULTIVOL header.
1756 The GNU.volume.size keeps the real_s_sizeleft value, which is
1757 otherwise kept in the size field of a multivolume header. The
1758 GNU.volume.offset keeps the offset of the start of this volume,
1759 otherwise kept in oldgnu_header.offset. */
1760 { "GNU.volume.filename", volume_label_coder, volume_filename_decoder,
1761 XHDR_PROTECTED | XHDR_GLOBAL, false },
1762 { "GNU.volume.size", volume_size_coder, volume_size_decoder,
1763 XHDR_PROTECTED | XHDR_GLOBAL, false },
1764 { "GNU.volume.offset", volume_offset_coder, volume_offset_decoder,
1765 XHDR_PROTECTED | XHDR_GLOBAL, false },
1767 /* We get the SELinux value from filecon, so add a namespace for SELinux
1768 instead of storing it in SCHILY.xattr.* (which would be RAW). */
1769 { "RHT.security.selinux",
1770 xattr_selinux_coder, xattr_selinux_decoder, 0, false },
1772 /* ACLs, use the star format... */
1773 { "SCHILY.acl.access",
1774 xattr_acls_a_coder, xattr_acls_a_decoder, 0, false },
1776 { "SCHILY.acl.default",
1777 xattr_acls_d_coder, xattr_acls_d_decoder, 0, false },
1779 /* We are storing all extended attributes using this rule even if some of them
1780 were stored by some previous rule (duplicates) -- we just have to make sure
1781 they are restored *only once* during extraction later on. */
1782 { "SCHILY.xattr", xattr_coder, xattr_decoder, 0, true },
1784 { NULL, NULL, NULL, 0, false }