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
;
474 void xheader_xattr_free (struct xattr_array
*xattr_map
, size_t xattr_map_size
)
478 while (scan
< xattr_map_size
)
480 free (xattr_map
[scan
].xkey
);
481 free (xattr_map
[scan
].xval_ptr
);
488 static void xheader_xattr__add (struct xattr_array
**xattr_map
,
489 size_t *xattr_map_size
,
490 const char *key
, const char *val
, size_t len
)
492 size_t pos
= (*xattr_map_size
)++;
494 *xattr_map
= xrealloc (*xattr_map
,
495 *xattr_map_size
* sizeof(struct xattr_array
));
496 (*xattr_map
)[pos
].xkey
= xstrdup (key
);
497 (*xattr_map
)[pos
].xval_ptr
= xmemdup (val
, len
+ 1);
498 (*xattr_map
)[pos
].xval_len
= len
;
501 void xheader_xattr_add(struct tar_stat_info
*st
,
502 const char *key
, const char *val
, size_t len
)
504 size_t klen
= strlen (key
);
505 char *xkey
= xmalloc (strlen("SCHILY.xattr.") + klen
+ 1);
508 tmp
= stpcpy (tmp
, "SCHILY.xattr.");
511 xheader_xattr__add (&st
->xattr_map
, &st
->xattr_map_size
, xkey
, val
, len
);
516 void xheader_xattr_copy(const struct tar_stat_info
*st
,
517 struct xattr_array
**xattr_map
, size_t *xattr_map_size
)
524 while (scan
< st
->xattr_map_size
)
526 char *key
= st
->xattr_map
[scan
].xkey
;
527 char *val
= st
->xattr_map
[scan
].xval_ptr
;
528 size_t len
= st
->xattr_map
[scan
].xval_len
;
530 xheader_xattr__add(xattr_map
, xattr_map_size
, key
, val
, len
);
537 /* General Interface */
539 #define XHDR_PROTECTED 0x01
540 #define XHDR_GLOBAL 0x02
545 void (*coder
) (struct tar_stat_info
const *, char const *,
546 struct xheader
*, void const *data
);
547 void (*decoder
) (struct tar_stat_info
*, char const *, char const *, size_t);
549 bool prefix
; /* select handler comparing prefix only */
552 /* This declaration must be extern, because ISO C99 section 6.9.2
553 prohibits a tentative definition that has both internal linkage and
554 incomplete type. If we made it static, we'd have to declare its
555 size which would be a maintenance pain; if we put its initializer
556 here, we'd need a boatload of forward declarations, which would be
557 even more of a pain. */
558 extern struct xhdr_tab
const xhdr_tab
[];
560 static struct xhdr_tab
const *
561 locate_handler (char const *keyword
)
563 struct xhdr_tab
const *p
;
565 for (p
= xhdr_tab
; p
->keyword
; p
++)
568 if (strncmp (p
->keyword
, keyword
, strlen(p
->keyword
)) == 0)
573 if (strcmp (p
->keyword
, keyword
) == 0)
581 xheader_protected_pattern_p (const char *pattern
)
583 struct xhdr_tab
const *p
;
585 for (p
= xhdr_tab
; p
->keyword
; p
++)
586 if (!p
->prefix
&& (p
->flags
& XHDR_PROTECTED
)
587 && fnmatch (pattern
, p
->keyword
, 0) == 0)
593 xheader_protected_keyword_p (const char *keyword
)
595 struct xhdr_tab
const *p
;
597 for (p
= xhdr_tab
; p
->keyword
; p
++)
598 if (!p
->prefix
&& (p
->flags
& XHDR_PROTECTED
)
599 && strcmp (p
->keyword
, keyword
) == 0)
604 /* Decode a single extended header record, advancing *PTR to the next record.
605 Return true on success, false otherwise. */
607 decode_record (struct xheader
*xhdr
,
609 void (*handler
) (void *, char const *, char const *, size_t),
619 size_t len_max
= xhdr
->buffer
+ xhdr
->size
- start
;
621 while (*p
== ' ' || *p
== '\t')
627 ERROR ((0, 0, _("Malformed extended header: missing length")));
632 len
= u
= strtoumax (p
, &len_lim
, 10);
633 if (len
!= u
|| errno
== ERANGE
)
635 ERROR ((0, 0, _("Extended header length is out of allowed range")));
641 int len_len
= len_lim
- p
;
642 ERROR ((0, 0, _("Extended header length %*s is out of range"),
649 for (p
= len_lim
; *p
== ' ' || *p
== '\t'; p
++)
654 _("Malformed extended header: missing blank after length")));
660 if (! (p
&& p
< nextp
))
662 ERROR ((0, 0, _("Malformed extended header: missing equal sign")));
666 if (nextp
[-1] != '\n')
668 ERROR ((0, 0, _("Malformed extended header: missing newline")));
672 *p
= nextp
[-1] = '\0';
673 handler (data
, keyword
, p
+ 1, nextp
- p
- 2); /* '=' + trailing '\n' */
681 run_override_list (struct keyword_list
*kp
, struct tar_stat_info
*st
)
683 for (; kp
; kp
= kp
->next
)
685 struct xhdr_tab
const *t
= locate_handler (kp
->pattern
);
687 t
->decoder (st
, t
->keyword
, kp
->value
, strlen (kp
->value
));
692 decx (void *data
, char const *keyword
, char const *value
, size_t size
)
694 struct xhdr_tab
const *t
;
695 struct tar_stat_info
*st
= data
;
697 if (xheader_keyword_deleted_p (keyword
)
698 || xheader_keyword_override_p (keyword
))
701 t
= locate_handler (keyword
);
703 t
->decoder (st
, keyword
, value
, size
);
705 WARNOPT (WARN_UNKNOWN_KEYWORD
,
706 (0, 0, _("Ignoring unknown extended header keyword '%s'"),
711 xheader_decode (struct tar_stat_info
*st
)
713 run_override_list (keyword_global_override_list
, st
);
714 run_override_list (global_header_override_list
, st
);
718 char *p
= st
->xhdr
.buffer
+ BLOCKSIZE
;
719 while (decode_record (&st
->xhdr
, &p
, decx
, st
))
722 run_override_list (keyword_override_list
, st
);
726 decg (void *data
, char const *keyword
, char const *value
,
727 size_t size
__attribute__((unused
)))
729 struct keyword_list
**kwl
= data
;
730 struct xhdr_tab
const *tab
= locate_handler (keyword
);
731 if (tab
&& (tab
->flags
& XHDR_GLOBAL
))
732 tab
->decoder (data
, keyword
, value
, size
);
734 xheader_list_append (kwl
, keyword
, value
);
738 xheader_decode_global (struct xheader
*xhdr
)
742 char *p
= xhdr
->buffer
+ BLOCKSIZE
;
744 xheader_list_destroy (&global_header_override_list
);
745 while (decode_record (xhdr
, &p
, decg
, &global_header_override_list
))
751 xheader_init (struct xheader
*xhdr
)
755 xhdr
->stk
= xmalloc (sizeof *xhdr
->stk
);
756 obstack_init (xhdr
->stk
);
761 xheader_store (char const *keyword
, struct tar_stat_info
*st
,
764 struct xhdr_tab
const *t
;
768 t
= locate_handler (keyword
);
771 if (xheader_keyword_deleted_p (keyword
)
772 || xheader_keyword_override_p (keyword
))
774 xheader_init (&st
->xhdr
);
775 t
->coder (st
, keyword
, &st
->xhdr
, data
);
779 xheader_read (struct xheader
*xhdr
, union block
*p
, size_t size
)
785 xhdr
->buffer
= xmalloc (size
+ 1);
786 xhdr
->buffer
[size
] = '\0';
796 FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
798 memcpy (&xhdr
->buffer
[j
], p
->buffer
, len
);
799 set_next_block_after (p
);
801 p
= find_next_block ();
810 xheader_print_n (struct xheader
*xhdr
, char const *keyword
,
811 char const *value
, size_t vsize
)
813 size_t len
= strlen (keyword
) + vsize
+ 3; /* ' ' + '=' + '\n' */
816 char nbuf
[UINTMAX_STRSIZE_BOUND
];
822 np
= umaxtostr (len
+ p
, nbuf
);
823 n
= nbuf
+ sizeof nbuf
- 1 - np
;
827 x_obstack_grow (xhdr
, np
, n
);
828 x_obstack_1grow (xhdr
, ' ');
829 x_obstack_grow (xhdr
, keyword
, strlen (keyword
));
830 x_obstack_1grow (xhdr
, '=');
831 x_obstack_grow (xhdr
, value
, vsize
);
832 x_obstack_1grow (xhdr
, '\n');
836 xheader_print (struct xheader
*xhdr
, char const *keyword
, char const *value
)
838 xheader_print_n (xhdr
, keyword
, value
, strlen (value
));
842 xheader_finish (struct xheader
*xhdr
)
844 struct keyword_list
*kp
;
846 for (kp
= keyword_override_list
; kp
; kp
= kp
->next
)
847 code_string (kp
->value
, kp
->pattern
, xhdr
);
849 xhdr
->buffer
= obstack_finish (xhdr
->stk
);
853 xheader_destroy (struct xheader
*xhdr
)
857 obstack_free (xhdr
->stk
, NULL
);
868 /* Buildable strings */
871 xheader_string_begin (struct xheader
*xhdr
)
873 xhdr
->string_length
= 0;
877 xheader_string_add (struct xheader
*xhdr
, char const *s
)
882 xhdr
->string_length
+= strlen (s
);
883 x_obstack_grow (xhdr
, s
, strlen (s
));
887 xheader_string_end (struct xheader
*xhdr
, char const *keyword
)
893 char nbuf
[UINTMAX_STRSIZE_BOUND
];
901 len
= strlen (keyword
) + xhdr
->string_length
+ 3; /* ' ' + '=' + '\n' */
906 np
= umaxtostr (len
+ p
, nbuf
);
907 n
= nbuf
+ sizeof nbuf
- 1 - np
;
911 p
= strlen (keyword
) + n
+ 2;
916 _("Generated keyword/value pair is too long (keyword=%s, length=%s)"),
918 obstack_free (xhdr
->stk
, obstack_finish (xhdr
->stk
));
921 x_obstack_blank (xhdr
, p
);
922 x_obstack_1grow (xhdr
, '\n');
923 cp
= obstack_next_free (xhdr
->stk
) - xhdr
->string_length
- p
- 1;
924 memmove (cp
+ p
, cp
, xhdr
->string_length
);
925 cp
= stpcpy (cp
, np
);
927 cp
= stpcpy (cp
, keyword
);
933 /* Implementations */
936 out_of_range_header (char const *keyword
, char const *value
,
937 uintmax_t minus_minval
, uintmax_t maxval
)
939 char minval_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
940 char maxval_buf
[UINTMAX_STRSIZE_BOUND
];
941 char *minval_string
= umaxtostr (minus_minval
, minval_buf
+ 1);
942 char *maxval_string
= umaxtostr (maxval
, maxval_buf
);
944 *--minval_string
= '-';
946 /* TRANSLATORS: The first %s is the pax extended header keyword
947 (atime, gid, etc.). */
948 ERROR ((0, 0, _("Extended header %s=%s is out of range %s..%s"),
949 keyword
, value
, minval_string
, maxval_string
));
953 code_string (char const *string
, char const *keyword
, struct xheader
*xhdr
)
956 if (!utf8_convert (true, string
, &outstr
))
958 /* FIXME: report error */
959 outstr
= xstrdup (string
);
961 xheader_print (xhdr
, keyword
, outstr
);
966 decode_string (char **string
, char const *arg
)
973 if (!utf8_convert (false, arg
, string
))
975 /* FIXME: report error and act accordingly to --pax invalid=UTF-8 */
976 assign_string (string
, arg
);
981 code_time (struct timespec t
, char const *keyword
, struct xheader
*xhdr
)
983 char buf
[TIMESPEC_STRSIZE_BOUND
];
984 xheader_print (xhdr
, keyword
, code_timespec (t
, buf
));
987 enum decode_time_status
991 decode_time_bad_header
994 static enum decode_time_status
995 _decode_time (struct timespec
*ts
, char const *arg
, char const *keyword
)
998 unsigned long int ns
= 0;
1001 bool negative
= *arg
== '-';
1005 if (ISDIGIT (arg
[negative
]))
1009 intmax_t i
= strtoimax (arg
, &arg_lim
, 10);
1010 if (TYPE_SIGNED (time_t) ? i
< TYPE_MINIMUM (time_t) : i
< 0)
1011 return decode_time_range
;
1016 uintmax_t i
= strtoumax (arg
, &arg_lim
, 10);
1017 if (TYPE_MAXIMUM (time_t) < i
)
1018 return decode_time_range
;
1024 if (errno
== ERANGE
)
1025 return decode_time_range
;
1030 bool trailing_nonzero
= false;
1032 while (ISDIGIT (*++p
))
1033 if (digits
< LOG10_BILLION
)
1035 ns
= 10 * ns
+ (*p
- '0');
1039 trailing_nonzero
|= *p
!= '0';
1041 while (digits
++ < LOG10_BILLION
)
1046 /* Convert "-1.10000000000001" to s == -2, ns == 89999999.
1047 I.e., truncate time stamps towards minus infinity while
1048 converting them to internal form. */
1049 ns
+= trailing_nonzero
;
1052 if (s
== TYPE_MINIMUM (time_t))
1053 return decode_time_range
;
1064 return decode_time_success
;
1068 return decode_time_bad_header
;
1072 decode_time (struct timespec
*ts
, char const *arg
, char const *keyword
)
1074 switch (_decode_time (ts
, arg
, keyword
))
1076 case decode_time_success
:
1078 case decode_time_bad_header
:
1079 ERROR ((0, 0, _("Malformed extended header: invalid %s=%s"),
1082 case decode_time_range
:
1083 out_of_range_header (keyword
, arg
, - (uintmax_t) TYPE_MINIMUM (time_t),
1084 TYPE_MAXIMUM (time_t));
1093 code_num (uintmax_t value
, char const *keyword
, struct xheader
*xhdr
)
1095 char sbuf
[UINTMAX_STRSIZE_BOUND
];
1096 xheader_print (xhdr
, keyword
, umaxtostr (value
, sbuf
));
1100 decode_num (uintmax_t *num
, char const *arg
, uintmax_t maxval
,
1101 char const *keyword
)
1106 if (! (ISDIGIT (*arg
)
1107 && (errno
= 0, u
= strtoumax (arg
, &arg_lim
, 10), !*arg_lim
)))
1109 ERROR ((0, 0, _("Malformed extended header: invalid %s=%s"),
1114 if (! (u
<= maxval
&& errno
!= ERANGE
))
1116 out_of_range_header (keyword
, arg
, 0, maxval
);
1125 dummy_coder (struct tar_stat_info
const *st
__attribute__ ((unused
)),
1126 char const *keyword
__attribute__ ((unused
)),
1127 struct xheader
*xhdr
__attribute__ ((unused
)),
1128 void const *data
__attribute__ ((unused
)))
1133 dummy_decoder (struct tar_stat_info
*st
__attribute__ ((unused
)),
1134 char const *keyword
__attribute__ ((unused
)),
1135 char const *arg
__attribute__ ((unused
)),
1136 size_t size
__attribute__((unused
)))
1141 atime_coder (struct tar_stat_info
const *st
, char const *keyword
,
1142 struct xheader
*xhdr
, void const *data
__attribute__ ((unused
)))
1144 code_time (st
->atime
, keyword
, xhdr
);
1148 atime_decoder (struct tar_stat_info
*st
,
1149 char const *keyword
,
1151 size_t size
__attribute__((unused
)))
1154 if (decode_time (&ts
, arg
, keyword
))
1159 gid_coder (struct tar_stat_info
const *st
, char const *keyword
,
1160 struct xheader
*xhdr
, void const *data
__attribute__ ((unused
)))
1162 code_num (st
->stat
.st_gid
, keyword
, xhdr
);
1166 gid_decoder (struct tar_stat_info
*st
,
1167 char const *keyword
,
1169 size_t size
__attribute__((unused
)))
1172 if (decode_num (&u
, arg
, TYPE_MAXIMUM (gid_t
), keyword
))
1173 st
->stat
.st_gid
= u
;
1177 gname_coder (struct tar_stat_info
const *st
, char const *keyword
,
1178 struct xheader
*xhdr
, void const *data
__attribute__ ((unused
)))
1180 code_string (st
->gname
, keyword
, xhdr
);
1184 gname_decoder (struct tar_stat_info
*st
,
1185 char const *keyword
__attribute__((unused
)),
1187 size_t size
__attribute__((unused
)))
1189 decode_string (&st
->gname
, arg
);
1193 linkpath_coder (struct tar_stat_info
const *st
, char const *keyword
,
1194 struct xheader
*xhdr
, void const *data
__attribute__ ((unused
)))
1196 code_string (st
->link_name
, keyword
, xhdr
);
1200 linkpath_decoder (struct tar_stat_info
*st
,
1201 char const *keyword
__attribute__((unused
)),
1203 size_t size
__attribute__((unused
)))
1205 decode_string (&st
->link_name
, arg
);
1209 ctime_coder (struct tar_stat_info
const *st
, char const *keyword
,
1210 struct xheader
*xhdr
, void const *data
__attribute__ ((unused
)))
1212 code_time (st
->ctime
, keyword
, xhdr
);
1216 ctime_decoder (struct tar_stat_info
*st
,
1217 char const *keyword
,
1219 size_t size
__attribute__((unused
)))
1222 if (decode_time (&ts
, arg
, keyword
))
1227 mtime_coder (struct tar_stat_info
const *st
, char const *keyword
,
1228 struct xheader
*xhdr
, void const *data
)
1230 struct timespec
const *mtime
= data
;
1231 code_time (mtime
? *mtime
: st
->mtime
, keyword
, xhdr
);
1235 mtime_decoder (struct tar_stat_info
*st
,
1236 char const *keyword
,
1238 size_t size
__attribute__((unused
)))
1241 if (decode_time (&ts
, arg
, keyword
))
1246 path_coder (struct tar_stat_info
const *st
, char const *keyword
,
1247 struct xheader
*xhdr
, void const *data
__attribute__ ((unused
)))
1249 code_string (st
->file_name
, keyword
, xhdr
);
1253 path_decoder (struct tar_stat_info
*st
,
1254 char const *keyword
__attribute__((unused
)),
1256 size_t size
__attribute__((unused
)))
1258 decode_string (&st
->orig_file_name
, arg
);
1259 decode_string (&st
->file_name
, arg
);
1260 st
->had_trailing_slash
= strip_trailing_slashes (st
->file_name
);
1264 size_coder (struct tar_stat_info
const *st
, char const *keyword
,
1265 struct xheader
*xhdr
, void const *data
__attribute__ ((unused
)))
1267 code_num (st
->stat
.st_size
, keyword
, xhdr
);
1271 size_decoder (struct tar_stat_info
*st
,
1272 char const *keyword
,
1274 size_t size
__attribute__((unused
)))
1277 if (decode_num (&u
, arg
, TYPE_MAXIMUM (off_t
), keyword
))
1278 st
->stat
.st_size
= u
;
1282 uid_coder (struct tar_stat_info
const *st
, char const *keyword
,
1283 struct xheader
*xhdr
, void const *data
__attribute__ ((unused
)))
1285 code_num (st
->stat
.st_uid
, keyword
, xhdr
);
1289 uid_decoder (struct tar_stat_info
*st
,
1290 char const *keyword
,
1292 size_t size
__attribute__((unused
)))
1295 if (decode_num (&u
, arg
, TYPE_MAXIMUM (uid_t
), keyword
))
1296 st
->stat
.st_uid
= u
;
1300 uname_coder (struct tar_stat_info
const *st
, char const *keyword
,
1301 struct xheader
*xhdr
, void const *data
__attribute__ ((unused
)))
1303 code_string (st
->uname
, keyword
, xhdr
);
1307 uname_decoder (struct tar_stat_info
*st
,
1308 char const *keyword
__attribute__((unused
)),
1310 size_t size
__attribute__((unused
)))
1312 decode_string (&st
->uname
, arg
);
1316 sparse_size_coder (struct tar_stat_info
const *st
, char const *keyword
,
1317 struct xheader
*xhdr
, void const *data
)
1319 size_coder (st
, keyword
, xhdr
, data
);
1323 sparse_size_decoder (struct tar_stat_info
*st
,
1324 char const *keyword
,
1326 size_t size
__attribute__((unused
)))
1329 if (decode_num (&u
, arg
, TYPE_MAXIMUM (off_t
), keyword
))
1330 st
->stat
.st_size
= u
;
1334 sparse_numblocks_coder (struct tar_stat_info
const *st
, char const *keyword
,
1335 struct xheader
*xhdr
,
1336 void const *data
__attribute__ ((unused
)))
1338 code_num (st
->sparse_map_avail
, keyword
, xhdr
);
1342 sparse_numblocks_decoder (struct tar_stat_info
*st
,
1343 char const *keyword
,
1345 size_t size
__attribute__((unused
)))
1348 if (decode_num (&u
, arg
, SIZE_MAX
, keyword
))
1350 st
->sparse_map_size
= u
;
1351 st
->sparse_map
= xcalloc (u
, sizeof st
->sparse_map
[0]);
1352 st
->sparse_map_avail
= 0;
1357 sparse_offset_coder (struct tar_stat_info
const *st
, char const *keyword
,
1358 struct xheader
*xhdr
, void const *data
)
1360 size_t const *pi
= data
;
1361 code_num (st
->sparse_map
[*pi
].offset
, keyword
, xhdr
);
1365 sparse_offset_decoder (struct tar_stat_info
*st
,
1366 char const *keyword
,
1368 size_t size
__attribute__((unused
)))
1371 if (decode_num (&u
, arg
, TYPE_MAXIMUM (off_t
), keyword
))
1373 if (st
->sparse_map_avail
< st
->sparse_map_size
)
1374 st
->sparse_map
[st
->sparse_map_avail
].offset
= u
;
1376 ERROR ((0, 0, _("Malformed extended header: excess %s=%s"),
1377 "GNU.sparse.offset", arg
));
1382 sparse_numbytes_coder (struct tar_stat_info
const *st
, char const *keyword
,
1383 struct xheader
*xhdr
, void const *data
)
1385 size_t const *pi
= data
;
1386 code_num (st
->sparse_map
[*pi
].numbytes
, keyword
, xhdr
);
1390 sparse_numbytes_decoder (struct tar_stat_info
*st
,
1391 char const *keyword
,
1393 size_t size
__attribute__((unused
)))
1396 if (decode_num (&u
, arg
, TYPE_MAXIMUM (off_t
), keyword
))
1398 if (st
->sparse_map_avail
< st
->sparse_map_size
)
1399 st
->sparse_map
[st
->sparse_map_avail
++].numbytes
= u
;
1401 ERROR ((0, 0, _("Malformed extended header: excess %s=%s"),
1407 sparse_map_decoder (struct tar_stat_info
*st
,
1408 char const *keyword
,
1410 size_t size
__attribute__((unused
)))
1414 st
->sparse_map_avail
= 0;
1421 if (!ISDIGIT (*arg
))
1423 ERROR ((0, 0, _("Malformed extended header: invalid %s=%s"),
1429 u
= strtoumax (arg
, &delim
, 10);
1433 if (!(u
== e
.offset
&& errno
!= ERANGE
))
1435 out_of_range_header (keyword
, arg
, 0, TYPE_MAXIMUM (off_t
));
1442 if (!(u
== e
.numbytes
&& errno
!= ERANGE
))
1444 out_of_range_header (keyword
, arg
, 0, TYPE_MAXIMUM (off_t
));
1447 if (st
->sparse_map_avail
< st
->sparse_map_size
)
1448 st
->sparse_map
[st
->sparse_map_avail
++] = e
;
1451 ERROR ((0, 0, _("Malformed extended header: excess %s=%s"),
1461 else if (*delim
!= ',')
1464 _("Malformed extended header: invalid %s: unexpected delimiter %c"),
1474 _("Malformed extended header: invalid %s: odd number of values"),
1479 dumpdir_coder (struct tar_stat_info
const *st
, char const *keyword
,
1480 struct xheader
*xhdr
, void const *data
)
1482 xheader_print_n (xhdr
, keyword
, data
, dumpdir_size (data
));
1486 dumpdir_decoder (struct tar_stat_info
*st
,
1487 char const *keyword
__attribute__((unused
)),
1491 st
->dumpdir
= xmalloc (size
);
1492 memcpy (st
->dumpdir
, arg
, size
);
1496 volume_label_coder (struct tar_stat_info
const *st
, char const *keyword
,
1497 struct xheader
*xhdr
, void const *data
)
1499 code_string (data
, keyword
, xhdr
);
1503 volume_label_decoder (struct tar_stat_info
*st
,
1504 char const *keyword
__attribute__((unused
)),
1506 size_t size
__attribute__((unused
)))
1508 decode_string (&volume_label
, arg
);
1512 volume_size_coder (struct tar_stat_info
const *st
, char const *keyword
,
1513 struct xheader
*xhdr
, void const *data
)
1515 off_t
const *v
= data
;
1516 code_num (*v
, keyword
, xhdr
);
1520 volume_size_decoder (struct tar_stat_info
*st
,
1521 char const *keyword
,
1522 char const *arg
, size_t size
)
1525 if (decode_num (&u
, arg
, TYPE_MAXIMUM (uintmax_t), keyword
))
1526 continued_file_size
= u
;
1529 /* FIXME: Merge with volume_size_coder */
1531 volume_offset_coder (struct tar_stat_info
const *st
, char const *keyword
,
1532 struct xheader
*xhdr
, void const *data
)
1534 off_t
const *v
= data
;
1535 code_num (*v
, keyword
, xhdr
);
1539 volume_offset_decoder (struct tar_stat_info
*st
,
1540 char const *keyword
,
1541 char const *arg
, size_t size
)
1544 if (decode_num (&u
, arg
, TYPE_MAXIMUM (uintmax_t), keyword
))
1545 continued_file_offset
= u
;
1549 volume_filename_decoder (struct tar_stat_info
*st
,
1550 char const *keyword
__attribute__((unused
)),
1552 size_t size
__attribute__((unused
)))
1554 decode_string (&continued_file_name
, arg
);
1558 xattr_acls_a_coder (struct tar_stat_info
const *st
, char const *keyword
,
1559 struct xheader
*xhdr
, void const *data
)
1561 xheader_print_n (xhdr
, keyword
, st
->acls_a_ptr
, st
->acls_a_len
);
1565 xattr_acls_a_decoder (struct tar_stat_info
*st
,
1566 char const *keyword
, char const *arg
, size_t size
)
1568 st
->acls_a_ptr
= xmemdup (arg
, size
+ 1);
1569 st
->acls_a_len
= size
;
1573 xattr_acls_d_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_d_ptr
, st
->acls_d_len
);
1580 xattr_acls_d_decoder (struct tar_stat_info
*st
,
1581 char const *keyword
, char const *arg
, size_t size
)
1583 st
->acls_d_ptr
= xmemdup (arg
, size
+ 1);
1584 st
->acls_d_len
= size
;
1588 xattr_coder (struct tar_stat_info
const *st
, char const *keyword
,
1589 struct xheader
*xhdr
, void const *data
)
1591 struct xattr_array
*xattr_map
= st
->xattr_map
;
1592 const size_t *off
= data
;
1593 xheader_print_n (xhdr
, keyword
,
1594 xattr_map
[*off
].xval_ptr
, xattr_map
[*off
].xval_len
);
1598 xattr_decoder (struct tar_stat_info
*st
,
1599 char const *keyword
, char const *arg
, size_t size
)
1603 xstr
= xmemdup(arg
, size
+ 1);
1604 xheader_xattr_add(st
, keyword
+ strlen("SCHILY.xattr."), xstr
, size
);
1609 sparse_major_coder (struct tar_stat_info
const *st
, char const *keyword
,
1610 struct xheader
*xhdr
, void const *data
)
1612 code_num (st
->sparse_major
, keyword
, xhdr
);
1616 sparse_major_decoder (struct tar_stat_info
*st
,
1617 char const *keyword
,
1622 if (decode_num (&u
, arg
, TYPE_MAXIMUM (unsigned), keyword
))
1623 st
->sparse_major
= u
;
1627 sparse_minor_coder (struct tar_stat_info
const *st
, char const *keyword
,
1628 struct xheader
*xhdr
, void const *data
)
1630 code_num (st
->sparse_minor
, keyword
, xhdr
);
1634 sparse_minor_decoder (struct tar_stat_info
*st
,
1635 char const *keyword
,
1640 if (decode_num (&u
, arg
, TYPE_MAXIMUM (unsigned), keyword
))
1641 st
->sparse_minor
= u
;
1644 struct xhdr_tab
const xhdr_tab
[] = {
1645 { "atime", atime_coder
, atime_decoder
, 0, false },
1646 { "comment", dummy_coder
, dummy_decoder
, 0, false },
1647 { "charset", dummy_coder
, dummy_decoder
, 0, false },
1648 { "ctime", ctime_coder
, ctime_decoder
, 0, false },
1649 { "gid", gid_coder
, gid_decoder
, 0, false },
1650 { "gname", gname_coder
, gname_decoder
, 0, false },
1651 { "linkpath", linkpath_coder
, linkpath_decoder
, 0, false },
1652 { "mtime", mtime_coder
, mtime_decoder
, 0, false },
1653 { "path", path_coder
, path_decoder
, 0, false },
1654 { "size", size_coder
, size_decoder
, 0, false },
1655 { "uid", uid_coder
, uid_decoder
, 0, false },
1656 { "uname", uname_coder
, uname_decoder
, 0, false },
1658 /* Sparse file handling */
1659 { "GNU.sparse.name", path_coder
, path_decoder
,
1660 XHDR_PROTECTED
, false },
1661 { "GNU.sparse.major", sparse_major_coder
, sparse_major_decoder
,
1662 XHDR_PROTECTED
, false },
1663 { "GNU.sparse.minor", sparse_minor_coder
, sparse_minor_decoder
,
1664 XHDR_PROTECTED
, false },
1665 { "GNU.sparse.realsize", sparse_size_coder
, sparse_size_decoder
,
1666 XHDR_PROTECTED
, false },
1667 { "GNU.sparse.numblocks", sparse_numblocks_coder
, sparse_numblocks_decoder
,
1668 XHDR_PROTECTED
, false },
1670 /* tar 1.14 - 1.15.90 keywords. */
1671 { "GNU.sparse.size", sparse_size_coder
, sparse_size_decoder
,
1672 XHDR_PROTECTED
, false },
1673 /* tar 1.14 - 1.15.1 keywords. Multiple instances of these appeared in 'x'
1674 headers, and each of them was meaningful. It confilcted with POSIX specs,
1675 which requires that "when extended header records conflict, the last one
1676 given in the header shall take precedence." */
1677 { "GNU.sparse.offset", sparse_offset_coder
, sparse_offset_decoder
,
1678 XHDR_PROTECTED
, false },
1679 { "GNU.sparse.numbytes", sparse_numbytes_coder
, sparse_numbytes_decoder
,
1680 XHDR_PROTECTED
, false },
1681 /* tar 1.15.90 keyword, introduced to remove the above-mentioned conflict. */
1682 { "GNU.sparse.map", NULL
/* Unused, see pax_dump_header() */,
1683 sparse_map_decoder
, 0, false },
1685 { "GNU.dumpdir", dumpdir_coder
, dumpdir_decoder
,
1686 XHDR_PROTECTED
, false },
1688 /* Keeps the tape/volume label. May be present only in the global headers.
1689 Equivalent to GNUTYPE_VOLHDR. */
1690 { "GNU.volume.label", volume_label_coder
, volume_label_decoder
,
1691 XHDR_PROTECTED
| XHDR_GLOBAL
, false },
1693 /* These may be present in a first global header of the archive.
1694 They provide the same functionality as GNUTYPE_MULTIVOL header.
1695 The GNU.volume.size keeps the real_s_sizeleft value, which is
1696 otherwise kept in the size field of a multivolume header. The
1697 GNU.volume.offset keeps the offset of the start of this volume,
1698 otherwise kept in oldgnu_header.offset. */
1699 { "GNU.volume.filename", volume_label_coder
, volume_filename_decoder
,
1700 XHDR_PROTECTED
| XHDR_GLOBAL
, false },
1701 { "GNU.volume.size", volume_size_coder
, volume_size_decoder
,
1702 XHDR_PROTECTED
| XHDR_GLOBAL
, false },
1703 { "GNU.volume.offset", volume_offset_coder
, volume_offset_decoder
,
1704 XHDR_PROTECTED
| XHDR_GLOBAL
, false },
1706 /* ACLs, use the star format... */
1707 { "SCHILY.acl.access",
1708 xattr_acls_a_coder
, xattr_acls_a_decoder
, 0, false },
1710 { "SCHILY.acl.default",
1711 xattr_acls_d_coder
, xattr_acls_d_decoder
, 0, false },
1713 /* We are storing all extended attributes using this rule even if some of them
1714 were stored by some previous rule (duplicates) -- we just have to make sure
1715 they are restored *only once* during extraction later on. */
1716 { "SCHILY.xattr", xattr_coder
, xattr_decoder
, 0, true },
1718 { NULL
, NULL
, NULL
, 0, false }