1 /* POSIX extended headers for tar.
3 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2009, 2010, 2012
4 Free Software Foundation, Inc.
6 This program is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by the
8 Free Software Foundation; either version 3, or (at your option) any later
11 This program is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
14 Public License for more details.
16 You should have received a copy of the GNU General Public License along
17 with this program; if not, write to the Free Software Foundation, Inc.,
18 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
29 static void xheader_init (struct xheader
*xhdr
);
30 static bool xheader_protected_pattern_p (char const *pattern
);
31 static bool xheader_protected_keyword_p (char const *keyword
);
32 static void xheader_set_single_keyword (char *) __attribute__ ((noreturn
));
34 /* Used by xheader_finish() */
35 static void code_string (char const *string
, char const *keyword
,
36 struct xheader
*xhdr
);
38 /* Number of global headers written so far. */
39 static size_t global_header_count
;
40 /* FIXME: Possibly it should be reset after changing the volume.
41 POSIX %n specification says that it is expanded to the sequence
42 number of current global header in *the* archive. However, for
43 multi-volume archives this will yield duplicate header names
44 in different volumes, which I'd like to avoid. The best way
45 to solve this would be to use per-archive header count as required
46 by POSIX *and* set globexthdr.name to, say,
47 $TMPDIR/GlobalHead.%p.$NUMVOLUME.%n.
49 However it should wait until buffer.c is finally rewritten */
52 /* Interface functions to obstacks */
55 x_obstack_grow (struct xheader
*xhdr
, const char *ptr
, size_t length
)
57 obstack_grow (xhdr
->stk
, ptr
, length
);
62 x_obstack_1grow (struct xheader
*xhdr
, char c
)
64 obstack_1grow (xhdr
->stk
, c
);
69 x_obstack_blank (struct xheader
*xhdr
, size_t length
)
71 obstack_blank (xhdr
->stk
, length
);
80 struct keyword_list
*next
;
86 /* List of keyword patterns set by delete= option */
87 static struct keyword_list
*keyword_pattern_list
;
89 /* List of keyword/value pairs set by 'keyword=value' option */
90 static struct keyword_list
*keyword_global_override_list
;
92 /* List of keyword/value pairs set by 'keyword:=value' option */
93 static struct keyword_list
*keyword_override_list
;
95 /* List of keyword/value pairs decoded from the last 'g' type header */
96 static struct keyword_list
*global_header_override_list
;
98 /* Template for the name field of an 'x' type header */
99 static char *exthdr_name
;
101 static char *exthdr_mtime_option
;
102 static time_t exthdr_mtime
;
104 /* Template for the name field of a 'g' type header */
105 static char *globexthdr_name
;
107 static char *globexthdr_mtime_option
;
108 static time_t globexthdr_mtime
;
111 xheader_keyword_deleted_p (const char *kw
)
113 struct keyword_list
*kp
;
115 for (kp
= keyword_pattern_list
; kp
; kp
= kp
->next
)
116 if (fnmatch (kp
->pattern
, kw
, 0) == 0)
122 xheader_keyword_override_p (const char *keyword
)
124 struct keyword_list
*kp
;
126 for (kp
= keyword_override_list
; kp
; kp
= kp
->next
)
127 if (strcmp (kp
->pattern
, keyword
) == 0)
133 xheader_list_append (struct keyword_list
**root
, char const *kw
,
136 struct keyword_list
*kp
= xmalloc (sizeof *kp
);
137 kp
->pattern
= xstrdup (kw
);
138 kp
->value
= value
? xstrdup (value
) : NULL
;
144 xheader_list_destroy (struct keyword_list
**root
)
148 struct keyword_list
*kw
= *root
;
151 struct keyword_list
*next
= kw
->next
;
162 xheader_set_single_keyword (char *kw
)
164 USAGE_ERROR ((0, 0, _("Keyword %s is unknown or not yet implemented"), kw
));
168 assign_time_option (char **sval
, time_t *tval
, const char *input
)
172 time_t t
= u
= strtoumax (input
, &p
, 10);
173 if (t
!= u
|| *p
|| errno
== ERANGE
)
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
];
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
);
340 q
= stpcpy (q
, nptr
);
344 /* else fall through */
358 /* Do not allow it to end in a slash */
359 while (q
> buf
&& ISSLASH (q
[-1]))
366 xheader_xhdr_name (struct tar_stat_info
*st
)
369 assign_string (&exthdr_name
, "%d/PaxHeaders.%p/%f");
370 return xheader_format_name (st
, exthdr_name
, 0);
373 #define GLOBAL_HEADER_TEMPLATE "/GlobalHead.%p.%n"
376 xheader_ghdr_name (void)
378 if (!globexthdr_name
)
381 const char *tmp
= getenv ("TMPDIR");
384 len
= strlen (tmp
) + sizeof (GLOBAL_HEADER_TEMPLATE
); /* Includes nul */
385 globexthdr_name
= xmalloc (len
);
386 strcpy(globexthdr_name
, tmp
);
387 strcat(globexthdr_name
, GLOBAL_HEADER_TEMPLATE
);
390 return xheader_format_name (NULL
, globexthdr_name
, global_header_count
+ 1);
394 xheader_write (char type
, char *name
, time_t t
, struct xheader
*xhdr
)
404 if (globexthdr_mtime_option
)
405 t
= globexthdr_mtime
;
409 if (exthdr_mtime_option
)
413 header
= start_private_header (name
, size
, t
);
414 header
->header
.typeflag
= type
;
416 simple_finish_header (header
);
424 header
= find_next_block ();
428 memcpy (header
->buffer
, p
, len
);
430 memset (header
->buffer
+ len
, 0, BLOCKSIZE
- len
);
433 set_next_block_after (header
);
436 xheader_destroy (xhdr
);
439 global_header_count
++;
443 xheader_write_global (struct xheader
*xhdr
)
445 if (keyword_global_override_list
)
447 struct keyword_list
*kp
;
450 for (kp
= keyword_global_override_list
; kp
; kp
= kp
->next
)
451 code_string (kp
->value
, kp
->pattern
, xhdr
);
457 xheader_finish (xhdr
);
458 xheader_write (XGLTYPE
, name
= xheader_ghdr_name (), time (NULL
), xhdr
);
463 void xheader_xattr_init (struct tar_stat_info
*st
)
465 st
->xattr_map
= NULL
;
466 st
->xattr_map_size
= 0;
468 st
->acls_a_ptr
= NULL
;
470 st
->acls_d_ptr
= NULL
;
472 st
->cntx_name
= NULL
;
475 void 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
);
489 static void xheader_xattr__add (struct xattr_array
**xattr_map
,
490 size_t *xattr_map_size
,
491 const char *key
, const char *val
, size_t len
)
493 size_t pos
= (*xattr_map_size
)++;
495 *xattr_map
= xrealloc (*xattr_map
,
496 *xattr_map_size
* sizeof(struct xattr_array
));
497 (*xattr_map
)[pos
].xkey
= xstrdup (key
);
498 (*xattr_map
)[pos
].xval_ptr
= xmemdup (val
, len
+ 1);
499 (*xattr_map
)[pos
].xval_len
= len
;
502 void xheader_xattr_add(struct tar_stat_info
*st
,
503 const char *key
, const char *val
, size_t len
)
505 size_t klen
= strlen (key
);
506 char *xkey
= xmalloc (strlen("SCHILY.xattr.") + klen
+ 1);
509 tmp
= stpcpy (tmp
, "SCHILY.xattr.");
512 xheader_xattr__add (&st
->xattr_map
, &st
->xattr_map_size
, xkey
, val
, len
);
517 void xheader_xattr_copy(const struct tar_stat_info
*st
,
518 struct xattr_array
**xattr_map
, size_t *xattr_map_size
)
525 while (scan
< st
->xattr_map_size
)
527 char *key
= st
->xattr_map
[scan
].xkey
;
528 char *val
= st
->xattr_map
[scan
].xval_ptr
;
529 size_t len
= st
->xattr_map
[scan
].xval_len
;
531 xheader_xattr__add(xattr_map
, xattr_map_size
, key
, val
, len
);
538 /* General Interface */
540 #define XHDR_PROTECTED 0x01
541 #define XHDR_GLOBAL 0x02
546 void (*coder
) (struct tar_stat_info
const *, char const *,
547 struct xheader
*, void const *data
);
548 void (*decoder
) (struct tar_stat_info
*, char const *, char const *, size_t);
550 bool prefix
; /* select handler comparing prefix only */
553 /* This declaration must be extern, because ISO C99 section 6.9.2
554 prohibits a tentative definition that has both internal linkage and
555 incomplete type. If we made it static, we'd have to declare its
556 size which would be a maintenance pain; if we put its initializer
557 here, we'd need a boatload of forward declarations, which would be
558 even more of a pain. */
559 extern struct xhdr_tab
const xhdr_tab
[];
561 static struct xhdr_tab
const *
562 locate_handler (char const *keyword
)
564 struct xhdr_tab
const *p
;
566 for (p
= xhdr_tab
; p
->keyword
; p
++)
569 if (strncmp (p
->keyword
, keyword
, strlen(p
->keyword
)) == 0)
574 if (strcmp (p
->keyword
, keyword
) == 0)
582 xheader_protected_pattern_p (const char *pattern
)
584 struct xhdr_tab
const *p
;
586 for (p
= xhdr_tab
; p
->keyword
; p
++)
587 if (!p
->prefix
&& (p
->flags
& XHDR_PROTECTED
)
588 && fnmatch (pattern
, p
->keyword
, 0) == 0)
594 xheader_protected_keyword_p (const char *keyword
)
596 struct xhdr_tab
const *p
;
598 for (p
= xhdr_tab
; p
->keyword
; p
++)
599 if (!p
->prefix
&& (p
->flags
& XHDR_PROTECTED
)
600 && strcmp (p
->keyword
, keyword
) == 0)
605 /* Decode a single extended header record, advancing *PTR to the next record.
606 Return true on success, false otherwise. */
608 decode_record (struct xheader
*xhdr
,
610 void (*handler
) (void *, char const *, char const *, size_t),
620 size_t len_max
= xhdr
->buffer
+ xhdr
->size
- start
;
622 while (*p
== ' ' || *p
== '\t')
628 ERROR ((0, 0, _("Malformed extended header: missing length")));
633 len
= u
= strtoumax (p
, &len_lim
, 10);
634 if (len
!= u
|| errno
== ERANGE
)
636 ERROR ((0, 0, _("Extended header length is out of allowed range")));
642 int len_len
= len_lim
- p
;
643 ERROR ((0, 0, _("Extended header length %*s is out of range"),
650 for (p
= len_lim
; *p
== ' ' || *p
== '\t'; p
++)
655 _("Malformed extended header: missing blank after length")));
661 if (! (p
&& p
< nextp
))
663 ERROR ((0, 0, _("Malformed extended header: missing equal sign")));
667 if (nextp
[-1] != '\n')
669 ERROR ((0, 0, _("Malformed extended header: missing newline")));
673 *p
= nextp
[-1] = '\0';
674 handler (data
, keyword
, p
+ 1, nextp
- p
- 2); /* '=' + trailing '\n' */
682 run_override_list (struct keyword_list
*kp
, struct tar_stat_info
*st
)
684 for (; kp
; kp
= kp
->next
)
686 struct xhdr_tab
const *t
= locate_handler (kp
->pattern
);
688 t
->decoder (st
, t
->keyword
, kp
->value
, strlen (kp
->value
));
693 decx (void *data
, char const *keyword
, char const *value
, size_t size
)
695 struct xhdr_tab
const *t
;
696 struct tar_stat_info
*st
= data
;
698 if (xheader_keyword_deleted_p (keyword
)
699 || xheader_keyword_override_p (keyword
))
702 t
= locate_handler (keyword
);
704 t
->decoder (st
, keyword
, value
, size
);
706 WARNOPT (WARN_UNKNOWN_KEYWORD
,
707 (0, 0, _("Ignoring unknown extended header keyword '%s'"),
712 xheader_decode (struct tar_stat_info
*st
)
714 run_override_list (keyword_global_override_list
, st
);
715 run_override_list (global_header_override_list
, st
);
719 char *p
= st
->xhdr
.buffer
+ BLOCKSIZE
;
720 while (decode_record (&st
->xhdr
, &p
, decx
, st
))
723 run_override_list (keyword_override_list
, st
);
727 decg (void *data
, char const *keyword
, char const *value
,
728 size_t size
__attribute__((unused
)))
730 struct keyword_list
**kwl
= data
;
731 struct xhdr_tab
const *tab
= locate_handler (keyword
);
732 if (tab
&& (tab
->flags
& XHDR_GLOBAL
))
733 tab
->decoder (data
, keyword
, value
, size
);
735 xheader_list_append (kwl
, keyword
, value
);
739 xheader_decode_global (struct xheader
*xhdr
)
743 char *p
= xhdr
->buffer
+ BLOCKSIZE
;
745 xheader_list_destroy (&global_header_override_list
);
746 while (decode_record (xhdr
, &p
, decg
, &global_header_override_list
))
752 xheader_init (struct xheader
*xhdr
)
756 xhdr
->stk
= xmalloc (sizeof *xhdr
->stk
);
757 obstack_init (xhdr
->stk
);
762 xheader_store (char const *keyword
, struct tar_stat_info
*st
,
765 struct xhdr_tab
const *t
;
769 t
= locate_handler (keyword
);
772 if (xheader_keyword_deleted_p (keyword
)
773 || xheader_keyword_override_p (keyword
))
775 xheader_init (&st
->xhdr
);
776 t
->coder (st
, keyword
, &st
->xhdr
, data
);
780 xheader_read (struct xheader
*xhdr
, union block
*p
, size_t size
)
786 xhdr
->buffer
= xmalloc (size
+ 1);
787 xhdr
->buffer
[size
] = '\0';
797 FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
799 memcpy (&xhdr
->buffer
[j
], p
->buffer
, len
);
800 set_next_block_after (p
);
802 p
= find_next_block ();
811 xheader_print_n (struct xheader
*xhdr
, char const *keyword
,
812 char const *value
, size_t vsize
)
814 size_t len
= strlen (keyword
) + vsize
+ 3; /* ' ' + '=' + '\n' */
817 char nbuf
[UINTMAX_STRSIZE_BOUND
];
823 np
= umaxtostr (len
+ p
, nbuf
);
824 n
= nbuf
+ sizeof nbuf
- 1 - np
;
828 x_obstack_grow (xhdr
, np
, n
);
829 x_obstack_1grow (xhdr
, ' ');
830 x_obstack_grow (xhdr
, keyword
, strlen (keyword
));
831 x_obstack_1grow (xhdr
, '=');
832 x_obstack_grow (xhdr
, value
, vsize
);
833 x_obstack_1grow (xhdr
, '\n');
837 xheader_print (struct xheader
*xhdr
, char const *keyword
, char const *value
)
839 xheader_print_n (xhdr
, keyword
, value
, strlen (value
));
843 xheader_finish (struct xheader
*xhdr
)
845 struct keyword_list
*kp
;
847 for (kp
= keyword_override_list
; kp
; kp
= kp
->next
)
848 code_string (kp
->value
, kp
->pattern
, xhdr
);
850 xhdr
->buffer
= obstack_finish (xhdr
->stk
);
854 xheader_destroy (struct xheader
*xhdr
)
858 obstack_free (xhdr
->stk
, NULL
);
869 /* Buildable strings */
872 xheader_string_begin (struct xheader
*xhdr
)
874 xhdr
->string_length
= 0;
878 xheader_string_add (struct xheader
*xhdr
, char const *s
)
883 xhdr
->string_length
+= strlen (s
);
884 x_obstack_grow (xhdr
, s
, strlen (s
));
888 xheader_string_end (struct xheader
*xhdr
, char const *keyword
)
894 char nbuf
[UINTMAX_STRSIZE_BOUND
];
902 len
= strlen (keyword
) + xhdr
->string_length
+ 3; /* ' ' + '=' + '\n' */
907 np
= umaxtostr (len
+ p
, nbuf
);
908 n
= nbuf
+ sizeof nbuf
- 1 - np
;
912 p
= strlen (keyword
) + n
+ 2;
917 _("Generated keyword/value pair is too long (keyword=%s, length=%s)"),
919 obstack_free (xhdr
->stk
, obstack_finish (xhdr
->stk
));
922 x_obstack_blank (xhdr
, p
);
923 x_obstack_1grow (xhdr
, '\n');
924 cp
= obstack_next_free (xhdr
->stk
) - xhdr
->string_length
- p
- 1;
925 memmove (cp
+ p
, cp
, xhdr
->string_length
);
926 cp
= stpcpy (cp
, np
);
928 cp
= stpcpy (cp
, keyword
);
934 /* Implementations */
937 out_of_range_header (char const *keyword
, char const *value
,
938 uintmax_t minus_minval
, uintmax_t maxval
)
940 char minval_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
941 char maxval_buf
[UINTMAX_STRSIZE_BOUND
];
942 char *minval_string
= umaxtostr (minus_minval
, minval_buf
+ 1);
943 char *maxval_string
= umaxtostr (maxval
, maxval_buf
);
945 *--minval_string
= '-';
947 /* TRANSLATORS: The first %s is the pax extended header keyword
948 (atime, gid, etc.). */
949 ERROR ((0, 0, _("Extended header %s=%s is out of range %s..%s"),
950 keyword
, value
, minval_string
, maxval_string
));
954 code_string (char const *string
, char const *keyword
, struct xheader
*xhdr
)
957 if (!utf8_convert (true, string
, &outstr
))
959 /* FIXME: report error */
960 outstr
= xstrdup (string
);
962 xheader_print (xhdr
, keyword
, outstr
);
967 decode_string (char **string
, char const *arg
)
974 if (!utf8_convert (false, arg
, string
))
976 /* FIXME: report error and act accordingly to --pax invalid=UTF-8 */
977 assign_string (string
, arg
);
982 code_time (struct timespec t
, char const *keyword
, struct xheader
*xhdr
)
984 char buf
[TIMESPEC_STRSIZE_BOUND
];
985 xheader_print (xhdr
, keyword
, code_timespec (t
, buf
));
988 enum decode_time_status
992 decode_time_bad_header
995 static enum decode_time_status
996 _decode_time (struct timespec
*ts
, char const *arg
, char const *keyword
)
999 unsigned long int ns
= 0;
1002 bool negative
= *arg
== '-';
1006 if (ISDIGIT (arg
[negative
]))
1010 intmax_t i
= strtoimax (arg
, &arg_lim
, 10);
1011 if (TYPE_SIGNED (time_t) ? i
< TYPE_MINIMUM (time_t) : i
< 0)
1012 return decode_time_range
;
1017 uintmax_t i
= strtoumax (arg
, &arg_lim
, 10);
1018 if (TYPE_MAXIMUM (time_t) < i
)
1019 return decode_time_range
;
1025 if (errno
== ERANGE
)
1026 return decode_time_range
;
1031 bool trailing_nonzero
= false;
1033 while (ISDIGIT (*++p
))
1034 if (digits
< LOG10_BILLION
)
1036 ns
= 10 * ns
+ (*p
- '0');
1040 trailing_nonzero
|= *p
!= '0';
1042 while (digits
++ < LOG10_BILLION
)
1047 /* Convert "-1.10000000000001" to s == -2, ns == 89999999.
1048 I.e., truncate time stamps towards minus infinity while
1049 converting them to internal form. */
1050 ns
+= trailing_nonzero
;
1053 if (s
== TYPE_MINIMUM (time_t))
1054 return decode_time_range
;
1065 return decode_time_success
;
1069 return decode_time_bad_header
;
1073 decode_time (struct timespec
*ts
, char const *arg
, char const *keyword
)
1075 switch (_decode_time (ts
, arg
, keyword
))
1077 case decode_time_success
:
1079 case decode_time_bad_header
:
1080 ERROR ((0, 0, _("Malformed extended header: invalid %s=%s"),
1083 case decode_time_range
:
1084 out_of_range_header (keyword
, arg
, - (uintmax_t) TYPE_MINIMUM (time_t),
1085 TYPE_MAXIMUM (time_t));
1094 code_num (uintmax_t value
, char const *keyword
, struct xheader
*xhdr
)
1096 char sbuf
[UINTMAX_STRSIZE_BOUND
];
1097 xheader_print (xhdr
, keyword
, umaxtostr (value
, sbuf
));
1101 decode_num (uintmax_t *num
, char const *arg
, uintmax_t maxval
,
1102 char const *keyword
)
1107 if (! (ISDIGIT (*arg
)
1108 && (errno
= 0, u
= strtoumax (arg
, &arg_lim
, 10), !*arg_lim
)))
1110 ERROR ((0, 0, _("Malformed extended header: invalid %s=%s"),
1115 if (! (u
<= maxval
&& errno
!= ERANGE
))
1117 out_of_range_header (keyword
, arg
, 0, maxval
);
1126 dummy_coder (struct tar_stat_info
const *st
__attribute__ ((unused
)),
1127 char const *keyword
__attribute__ ((unused
)),
1128 struct xheader
*xhdr
__attribute__ ((unused
)),
1129 void const *data
__attribute__ ((unused
)))
1134 dummy_decoder (struct tar_stat_info
*st
__attribute__ ((unused
)),
1135 char const *keyword
__attribute__ ((unused
)),
1136 char const *arg
__attribute__ ((unused
)),
1137 size_t size
__attribute__((unused
)))
1142 atime_coder (struct tar_stat_info
const *st
, char const *keyword
,
1143 struct xheader
*xhdr
, void const *data
__attribute__ ((unused
)))
1145 code_time (st
->atime
, keyword
, xhdr
);
1149 atime_decoder (struct tar_stat_info
*st
,
1150 char const *keyword
,
1152 size_t size
__attribute__((unused
)))
1155 if (decode_time (&ts
, arg
, keyword
))
1160 gid_coder (struct tar_stat_info
const *st
, char const *keyword
,
1161 struct xheader
*xhdr
, void const *data
__attribute__ ((unused
)))
1163 code_num (st
->stat
.st_gid
, keyword
, xhdr
);
1167 gid_decoder (struct tar_stat_info
*st
,
1168 char const *keyword
,
1170 size_t size
__attribute__((unused
)))
1173 if (decode_num (&u
, arg
, TYPE_MAXIMUM (gid_t
), keyword
))
1174 st
->stat
.st_gid
= u
;
1178 gname_coder (struct tar_stat_info
const *st
, char const *keyword
,
1179 struct xheader
*xhdr
, void const *data
__attribute__ ((unused
)))
1181 code_string (st
->gname
, keyword
, xhdr
);
1185 gname_decoder (struct tar_stat_info
*st
,
1186 char const *keyword
__attribute__((unused
)),
1188 size_t size
__attribute__((unused
)))
1190 decode_string (&st
->gname
, arg
);
1194 linkpath_coder (struct tar_stat_info
const *st
, char const *keyword
,
1195 struct xheader
*xhdr
, void const *data
__attribute__ ((unused
)))
1197 code_string (st
->link_name
, keyword
, xhdr
);
1201 linkpath_decoder (struct tar_stat_info
*st
,
1202 char const *keyword
__attribute__((unused
)),
1204 size_t size
__attribute__((unused
)))
1206 decode_string (&st
->link_name
, arg
);
1210 ctime_coder (struct tar_stat_info
const *st
, char const *keyword
,
1211 struct xheader
*xhdr
, void const *data
__attribute__ ((unused
)))
1213 code_time (st
->ctime
, keyword
, xhdr
);
1217 ctime_decoder (struct tar_stat_info
*st
,
1218 char const *keyword
,
1220 size_t size
__attribute__((unused
)))
1223 if (decode_time (&ts
, arg
, keyword
))
1228 mtime_coder (struct tar_stat_info
const *st
, char const *keyword
,
1229 struct xheader
*xhdr
, void const *data
)
1231 struct timespec
const *mtime
= data
;
1232 code_time (mtime
? *mtime
: st
->mtime
, keyword
, xhdr
);
1236 mtime_decoder (struct tar_stat_info
*st
,
1237 char const *keyword
,
1239 size_t size
__attribute__((unused
)))
1242 if (decode_time (&ts
, arg
, keyword
))
1247 path_coder (struct tar_stat_info
const *st
, char const *keyword
,
1248 struct xheader
*xhdr
, void const *data
__attribute__ ((unused
)))
1250 code_string (st
->file_name
, keyword
, xhdr
);
1254 path_decoder (struct tar_stat_info
*st
,
1255 char const *keyword
__attribute__((unused
)),
1257 size_t size
__attribute__((unused
)))
1259 decode_string (&st
->orig_file_name
, arg
);
1260 decode_string (&st
->file_name
, arg
);
1261 st
->had_trailing_slash
= strip_trailing_slashes (st
->file_name
);
1265 size_coder (struct tar_stat_info
const *st
, char const *keyword
,
1266 struct xheader
*xhdr
, void const *data
__attribute__ ((unused
)))
1268 code_num (st
->stat
.st_size
, keyword
, xhdr
);
1272 size_decoder (struct tar_stat_info
*st
,
1273 char const *keyword
,
1275 size_t size
__attribute__((unused
)))
1278 if (decode_num (&u
, arg
, TYPE_MAXIMUM (off_t
), keyword
))
1279 st
->stat
.st_size
= u
;
1283 uid_coder (struct tar_stat_info
const *st
, char const *keyword
,
1284 struct xheader
*xhdr
, void const *data
__attribute__ ((unused
)))
1286 code_num (st
->stat
.st_uid
, keyword
, xhdr
);
1290 uid_decoder (struct tar_stat_info
*st
,
1291 char const *keyword
,
1293 size_t size
__attribute__((unused
)))
1296 if (decode_num (&u
, arg
, TYPE_MAXIMUM (uid_t
), keyword
))
1297 st
->stat
.st_uid
= u
;
1301 uname_coder (struct tar_stat_info
const *st
, char const *keyword
,
1302 struct xheader
*xhdr
, void const *data
__attribute__ ((unused
)))
1304 code_string (st
->uname
, keyword
, xhdr
);
1308 uname_decoder (struct tar_stat_info
*st
,
1309 char const *keyword
__attribute__((unused
)),
1311 size_t size
__attribute__((unused
)))
1313 decode_string (&st
->uname
, arg
);
1317 sparse_size_coder (struct tar_stat_info
const *st
, char const *keyword
,
1318 struct xheader
*xhdr
, void const *data
)
1320 size_coder (st
, keyword
, xhdr
, data
);
1324 sparse_size_decoder (struct tar_stat_info
*st
,
1325 char const *keyword
,
1327 size_t size
__attribute__((unused
)))
1330 if (decode_num (&u
, arg
, TYPE_MAXIMUM (off_t
), keyword
))
1331 st
->stat
.st_size
= u
;
1335 sparse_numblocks_coder (struct tar_stat_info
const *st
, char const *keyword
,
1336 struct xheader
*xhdr
,
1337 void const *data
__attribute__ ((unused
)))
1339 code_num (st
->sparse_map_avail
, keyword
, xhdr
);
1343 sparse_numblocks_decoder (struct tar_stat_info
*st
,
1344 char const *keyword
,
1346 size_t size
__attribute__((unused
)))
1349 if (decode_num (&u
, arg
, SIZE_MAX
, keyword
))
1351 st
->sparse_map_size
= u
;
1352 st
->sparse_map
= xcalloc (u
, sizeof st
->sparse_map
[0]);
1353 st
->sparse_map_avail
= 0;
1358 sparse_offset_coder (struct tar_stat_info
const *st
, char const *keyword
,
1359 struct xheader
*xhdr
, void const *data
)
1361 size_t const *pi
= data
;
1362 code_num (st
->sparse_map
[*pi
].offset
, keyword
, xhdr
);
1366 sparse_offset_decoder (struct tar_stat_info
*st
,
1367 char const *keyword
,
1369 size_t size
__attribute__((unused
)))
1372 if (decode_num (&u
, arg
, TYPE_MAXIMUM (off_t
), keyword
))
1374 if (st
->sparse_map_avail
< st
->sparse_map_size
)
1375 st
->sparse_map
[st
->sparse_map_avail
].offset
= u
;
1377 ERROR ((0, 0, _("Malformed extended header: excess %s=%s"),
1378 "GNU.sparse.offset", arg
));
1383 sparse_numbytes_coder (struct tar_stat_info
const *st
, char const *keyword
,
1384 struct xheader
*xhdr
, void const *data
)
1386 size_t const *pi
= data
;
1387 code_num (st
->sparse_map
[*pi
].numbytes
, keyword
, xhdr
);
1391 sparse_numbytes_decoder (struct tar_stat_info
*st
,
1392 char const *keyword
,
1394 size_t size
__attribute__((unused
)))
1397 if (decode_num (&u
, arg
, TYPE_MAXIMUM (off_t
), keyword
))
1399 if (st
->sparse_map_avail
< st
->sparse_map_size
)
1400 st
->sparse_map
[st
->sparse_map_avail
++].numbytes
= u
;
1402 ERROR ((0, 0, _("Malformed extended header: excess %s=%s"),
1408 sparse_map_decoder (struct tar_stat_info
*st
,
1409 char const *keyword
,
1411 size_t size
__attribute__((unused
)))
1415 st
->sparse_map_avail
= 0;
1422 if (!ISDIGIT (*arg
))
1424 ERROR ((0, 0, _("Malformed extended header: invalid %s=%s"),
1430 u
= strtoumax (arg
, &delim
, 10);
1434 if (!(u
== e
.offset
&& errno
!= ERANGE
))
1436 out_of_range_header (keyword
, arg
, 0, TYPE_MAXIMUM (off_t
));
1443 if (!(u
== e
.numbytes
&& errno
!= ERANGE
))
1445 out_of_range_header (keyword
, arg
, 0, TYPE_MAXIMUM (off_t
));
1448 if (st
->sparse_map_avail
< st
->sparse_map_size
)
1449 st
->sparse_map
[st
->sparse_map_avail
++] = e
;
1452 ERROR ((0, 0, _("Malformed extended header: excess %s=%s"),
1462 else if (*delim
!= ',')
1465 _("Malformed extended header: invalid %s: unexpected delimiter %c"),
1475 _("Malformed extended header: invalid %s: odd number of values"),
1480 dumpdir_coder (struct tar_stat_info
const *st
, char const *keyword
,
1481 struct xheader
*xhdr
, void const *data
)
1483 xheader_print_n (xhdr
, keyword
, data
, dumpdir_size (data
));
1487 dumpdir_decoder (struct tar_stat_info
*st
,
1488 char const *keyword
__attribute__((unused
)),
1492 st
->dumpdir
= xmalloc (size
);
1493 memcpy (st
->dumpdir
, arg
, size
);
1497 volume_label_coder (struct tar_stat_info
const *st
, char const *keyword
,
1498 struct xheader
*xhdr
, void const *data
)
1500 code_string (data
, keyword
, xhdr
);
1504 volume_label_decoder (struct tar_stat_info
*st
,
1505 char const *keyword
__attribute__((unused
)),
1507 size_t size
__attribute__((unused
)))
1509 decode_string (&volume_label
, arg
);
1513 volume_size_coder (struct tar_stat_info
const *st
, char const *keyword
,
1514 struct xheader
*xhdr
, void const *data
)
1516 off_t
const *v
= data
;
1517 code_num (*v
, keyword
, xhdr
);
1521 volume_size_decoder (struct tar_stat_info
*st
,
1522 char const *keyword
,
1523 char const *arg
, size_t size
)
1526 if (decode_num (&u
, arg
, TYPE_MAXIMUM (uintmax_t), keyword
))
1527 continued_file_size
= u
;
1530 /* FIXME: Merge with volume_size_coder */
1532 volume_offset_coder (struct tar_stat_info
const *st
, char const *keyword
,
1533 struct xheader
*xhdr
, void const *data
)
1535 off_t
const *v
= data
;
1536 code_num (*v
, keyword
, xhdr
);
1540 volume_offset_decoder (struct tar_stat_info
*st
,
1541 char const *keyword
,
1542 char const *arg
, size_t size
)
1545 if (decode_num (&u
, arg
, TYPE_MAXIMUM (uintmax_t), keyword
))
1546 continued_file_offset
= u
;
1550 volume_filename_decoder (struct tar_stat_info
*st
,
1551 char const *keyword
__attribute__((unused
)),
1553 size_t size
__attribute__((unused
)))
1555 decode_string (&continued_file_name
, arg
);
1559 xattr_selinux_coder (struct tar_stat_info
const *st
, char const *keyword
,
1560 struct xheader
*xhdr
, void const *data
)
1562 code_string (st
->cntx_name
, keyword
, xhdr
);
1566 xattr_selinux_decoder (struct tar_stat_info
*st
,
1567 char const *keyword
, char const *arg
, size_t size
)
1569 decode_string (&st
->cntx_name
, arg
);
1573 xattr_acls_a_coder (struct tar_stat_info
const *st
, char const *keyword
,
1574 struct xheader
*xhdr
, void const *data
)
1576 xheader_print_n (xhdr
, keyword
, st
->acls_a_ptr
, st
->acls_a_len
);
1580 xattr_acls_a_decoder (struct tar_stat_info
*st
,
1581 char const *keyword
, char const *arg
, size_t size
)
1583 st
->acls_a_ptr
= xmemdup (arg
, size
+ 1);
1584 st
->acls_a_len
= size
;
1588 xattr_acls_d_coder (struct tar_stat_info
const *st
, char const *keyword
,
1589 struct xheader
*xhdr
, void const *data
)
1591 xheader_print_n (xhdr
, keyword
, st
->acls_d_ptr
, st
->acls_d_len
);
1595 xattr_acls_d_decoder (struct tar_stat_info
*st
,
1596 char const *keyword
, char const *arg
, size_t size
)
1598 st
->acls_d_ptr
= xmemdup (arg
, size
+ 1);
1599 st
->acls_d_len
= size
;
1603 xattr_coder (struct tar_stat_info
const *st
, char const *keyword
,
1604 struct xheader
*xhdr
, void const *data
)
1606 struct xattr_array
*xattr_map
= st
->xattr_map
;
1607 const size_t *off
= data
;
1608 xheader_print_n (xhdr
, keyword
,
1609 xattr_map
[*off
].xval_ptr
, xattr_map
[*off
].xval_len
);
1613 xattr_decoder (struct tar_stat_info
*st
,
1614 char const *keyword
, char const *arg
, size_t size
)
1618 xstr
= xmemdup(arg
, size
+ 1);
1619 xheader_xattr_add(st
, keyword
+ strlen("SCHILY.xattr."), xstr
, size
);
1624 sparse_major_coder (struct tar_stat_info
const *st
, char const *keyword
,
1625 struct xheader
*xhdr
, void const *data
)
1627 code_num (st
->sparse_major
, keyword
, xhdr
);
1631 sparse_major_decoder (struct tar_stat_info
*st
,
1632 char const *keyword
,
1637 if (decode_num (&u
, arg
, TYPE_MAXIMUM (unsigned), keyword
))
1638 st
->sparse_major
= u
;
1642 sparse_minor_coder (struct tar_stat_info
const *st
, char const *keyword
,
1643 struct xheader
*xhdr
, void const *data
)
1645 code_num (st
->sparse_minor
, keyword
, xhdr
);
1649 sparse_minor_decoder (struct tar_stat_info
*st
,
1650 char const *keyword
,
1655 if (decode_num (&u
, arg
, TYPE_MAXIMUM (unsigned), keyword
))
1656 st
->sparse_minor
= u
;
1659 struct xhdr_tab
const xhdr_tab
[] = {
1660 { "atime", atime_coder
, atime_decoder
, 0, false },
1661 { "comment", dummy_coder
, dummy_decoder
, 0, false },
1662 { "charset", dummy_coder
, dummy_decoder
, 0, false },
1663 { "ctime", ctime_coder
, ctime_decoder
, 0, false },
1664 { "gid", gid_coder
, gid_decoder
, 0, false },
1665 { "gname", gname_coder
, gname_decoder
, 0, false },
1666 { "linkpath", linkpath_coder
, linkpath_decoder
, 0, false },
1667 { "mtime", mtime_coder
, mtime_decoder
, 0, false },
1668 { "path", path_coder
, path_decoder
, 0, false },
1669 { "size", size_coder
, size_decoder
, 0, false },
1670 { "uid", uid_coder
, uid_decoder
, 0, false },
1671 { "uname", uname_coder
, uname_decoder
, 0, false },
1673 /* Sparse file handling */
1674 { "GNU.sparse.name", path_coder
, path_decoder
,
1675 XHDR_PROTECTED
, false },
1676 { "GNU.sparse.major", sparse_major_coder
, sparse_major_decoder
,
1677 XHDR_PROTECTED
, false },
1678 { "GNU.sparse.minor", sparse_minor_coder
, sparse_minor_decoder
,
1679 XHDR_PROTECTED
, false },
1680 { "GNU.sparse.realsize", sparse_size_coder
, sparse_size_decoder
,
1681 XHDR_PROTECTED
, false },
1682 { "GNU.sparse.numblocks", sparse_numblocks_coder
, sparse_numblocks_decoder
,
1683 XHDR_PROTECTED
, false },
1685 /* tar 1.14 - 1.15.90 keywords. */
1686 { "GNU.sparse.size", sparse_size_coder
, sparse_size_decoder
,
1687 XHDR_PROTECTED
, false },
1688 /* tar 1.14 - 1.15.1 keywords. Multiple instances of these appeared in 'x'
1689 headers, and each of them was meaningful. It confilcted with POSIX specs,
1690 which requires that "when extended header records conflict, the last one
1691 given in the header shall take precedence." */
1692 { "GNU.sparse.offset", sparse_offset_coder
, sparse_offset_decoder
,
1693 XHDR_PROTECTED
, false },
1694 { "GNU.sparse.numbytes", sparse_numbytes_coder
, sparse_numbytes_decoder
,
1695 XHDR_PROTECTED
, false },
1696 /* tar 1.15.90 keyword, introduced to remove the above-mentioned conflict. */
1697 { "GNU.sparse.map", NULL
/* Unused, see pax_dump_header() */,
1698 sparse_map_decoder
, 0, false },
1700 { "GNU.dumpdir", dumpdir_coder
, dumpdir_decoder
,
1701 XHDR_PROTECTED
, false },
1703 /* Keeps the tape/volume label. May be present only in the global headers.
1704 Equivalent to GNUTYPE_VOLHDR. */
1705 { "GNU.volume.label", volume_label_coder
, volume_label_decoder
,
1706 XHDR_PROTECTED
| XHDR_GLOBAL
, false },
1708 /* These may be present in a first global header of the archive.
1709 They provide the same functionality as GNUTYPE_MULTIVOL header.
1710 The GNU.volume.size keeps the real_s_sizeleft value, which is
1711 otherwise kept in the size field of a multivolume header. The
1712 GNU.volume.offset keeps the offset of the start of this volume,
1713 otherwise kept in oldgnu_header.offset. */
1714 { "GNU.volume.filename", volume_label_coder
, volume_filename_decoder
,
1715 XHDR_PROTECTED
| XHDR_GLOBAL
, false },
1716 { "GNU.volume.size", volume_size_coder
, volume_size_decoder
,
1717 XHDR_PROTECTED
| XHDR_GLOBAL
, false },
1718 { "GNU.volume.offset", volume_offset_coder
, volume_offset_decoder
,
1719 XHDR_PROTECTED
| XHDR_GLOBAL
, false },
1721 /* We get the SELinux value from filecon, so add a namespace for SELinux
1722 instead of storing it in SCHILY.xattr.* (which would be RAW). */
1723 { "RHT.security.selinux",
1724 xattr_selinux_coder
, xattr_selinux_decoder
, 0, false },
1726 /* ACLs, use the star format... */
1727 { "SCHILY.acl.access",
1728 xattr_acls_a_coder
, xattr_acls_a_decoder
, 0, false },
1730 { "SCHILY.acl.default",
1731 xattr_acls_d_coder
, xattr_acls_d_decoder
, 0, false },
1733 /* We are storing all extended attributes using this rule even if some of them
1734 were stored by some previous rule (duplicates) -- we just have to make sure
1735 they are restored *only once* during extraction later on. */
1736 { "SCHILY.xattr", xattr_coder
, xattr_decoder
, 0, true },
1738 { NULL
, NULL
, NULL
, 0, false }