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;
469 void xheader_xattr_free (struct xattr_array
*xattr_map
, size_t xattr_map_size
)
473 while (scan
< xattr_map_size
)
475 free (xattr_map
[scan
].xkey
);
476 free (xattr_map
[scan
].xval_ptr
);
483 static void xheader_xattr__add (struct xattr_array
**xattr_map
,
484 size_t *xattr_map_size
,
485 const char *key
, const char *val
, size_t len
)
487 size_t pos
= (*xattr_map_size
)++;
489 *xattr_map
= xrealloc (*xattr_map
,
490 *xattr_map_size
* sizeof(struct xattr_array
));
491 (*xattr_map
)[pos
].xkey
= xstrdup (key
);
492 (*xattr_map
)[pos
].xval_ptr
= xmemdup (val
, len
+ 1);
493 (*xattr_map
)[pos
].xval_len
= len
;
496 void xheader_xattr_add(struct tar_stat_info
*st
,
497 const char *key
, const char *val
, size_t len
)
499 size_t klen
= strlen (key
);
500 char *xkey
= xmalloc (strlen("SCHILY.xattr.") + klen
+ 1);
503 tmp
= stpcpy (tmp
, "SCHILY.xattr.");
506 xheader_xattr__add (&st
->xattr_map
, &st
->xattr_map_size
, xkey
, val
, len
);
511 void xheader_xattr_copy(const struct tar_stat_info
*st
,
512 struct xattr_array
**xattr_map
, size_t *xattr_map_size
)
519 while (scan
< st
->xattr_map_size
)
521 char *key
= st
->xattr_map
[scan
].xkey
;
522 char *val
= st
->xattr_map
[scan
].xval_ptr
;
523 size_t len
= st
->xattr_map
[scan
].xval_len
;
525 xheader_xattr__add(xattr_map
, xattr_map_size
, key
, val
, len
);
532 /* General Interface */
534 #define XHDR_PROTECTED 0x01
535 #define XHDR_GLOBAL 0x02
540 void (*coder
) (struct tar_stat_info
const *, char const *,
541 struct xheader
*, void const *data
);
542 void (*decoder
) (struct tar_stat_info
*, char const *, char const *, size_t);
544 bool prefix
; /* select handler comparing prefix only */
547 /* This declaration must be extern, because ISO C99 section 6.9.2
548 prohibits a tentative definition that has both internal linkage and
549 incomplete type. If we made it static, we'd have to declare its
550 size which would be a maintenance pain; if we put its initializer
551 here, we'd need a boatload of forward declarations, which would be
552 even more of a pain. */
553 extern struct xhdr_tab
const xhdr_tab
[];
555 static struct xhdr_tab
const *
556 locate_handler (char const *keyword
)
558 struct xhdr_tab
const *p
;
560 for (p
= xhdr_tab
; p
->keyword
; p
++)
563 if (strncmp (p
->keyword
, keyword
, strlen(p
->keyword
)) == 0)
568 if (strcmp (p
->keyword
, keyword
) == 0)
576 xheader_protected_pattern_p (const char *pattern
)
578 struct xhdr_tab
const *p
;
580 for (p
= xhdr_tab
; p
->keyword
; p
++)
581 if (!p
->prefix
&& (p
->flags
& XHDR_PROTECTED
)
582 && fnmatch (pattern
, p
->keyword
, 0) == 0)
588 xheader_protected_keyword_p (const char *keyword
)
590 struct xhdr_tab
const *p
;
592 for (p
= xhdr_tab
; p
->keyword
; p
++)
593 if (!p
->prefix
&& (p
->flags
& XHDR_PROTECTED
)
594 && strcmp (p
->keyword
, keyword
) == 0)
599 /* Decode a single extended header record, advancing *PTR to the next record.
600 Return true on success, false otherwise. */
602 decode_record (struct xheader
*xhdr
,
604 void (*handler
) (void *, char const *, char const *, size_t),
614 size_t len_max
= xhdr
->buffer
+ xhdr
->size
- start
;
616 while (*p
== ' ' || *p
== '\t')
622 ERROR ((0, 0, _("Malformed extended header: missing length")));
627 len
= u
= strtoumax (p
, &len_lim
, 10);
628 if (len
!= u
|| errno
== ERANGE
)
630 ERROR ((0, 0, _("Extended header length is out of allowed range")));
636 int len_len
= len_lim
- p
;
637 ERROR ((0, 0, _("Extended header length %*s is out of range"),
644 for (p
= len_lim
; *p
== ' ' || *p
== '\t'; p
++)
649 _("Malformed extended header: missing blank after length")));
655 if (! (p
&& p
< nextp
))
657 ERROR ((0, 0, _("Malformed extended header: missing equal sign")));
661 if (nextp
[-1] != '\n')
663 ERROR ((0, 0, _("Malformed extended header: missing newline")));
667 *p
= nextp
[-1] = '\0';
668 handler (data
, keyword
, p
+ 1, nextp
- p
- 2); /* '=' + trailing '\n' */
676 run_override_list (struct keyword_list
*kp
, struct tar_stat_info
*st
)
678 for (; kp
; kp
= kp
->next
)
680 struct xhdr_tab
const *t
= locate_handler (kp
->pattern
);
682 t
->decoder (st
, t
->keyword
, kp
->value
, strlen (kp
->value
));
687 decx (void *data
, char const *keyword
, char const *value
, size_t size
)
689 struct xhdr_tab
const *t
;
690 struct tar_stat_info
*st
= data
;
692 if (xheader_keyword_deleted_p (keyword
)
693 || xheader_keyword_override_p (keyword
))
696 t
= locate_handler (keyword
);
698 t
->decoder (st
, keyword
, value
, size
);
700 WARNOPT (WARN_UNKNOWN_KEYWORD
,
701 (0, 0, _("Ignoring unknown extended header keyword '%s'"),
706 xheader_decode (struct tar_stat_info
*st
)
708 run_override_list (keyword_global_override_list
, st
);
709 run_override_list (global_header_override_list
, st
);
713 char *p
= st
->xhdr
.buffer
+ BLOCKSIZE
;
714 while (decode_record (&st
->xhdr
, &p
, decx
, st
))
717 run_override_list (keyword_override_list
, st
);
721 decg (void *data
, char const *keyword
, char const *value
,
722 size_t size
__attribute__((unused
)))
724 struct keyword_list
**kwl
= data
;
725 struct xhdr_tab
const *tab
= locate_handler (keyword
);
726 if (tab
&& (tab
->flags
& XHDR_GLOBAL
))
727 tab
->decoder (data
, keyword
, value
, size
);
729 xheader_list_append (kwl
, keyword
, value
);
733 xheader_decode_global (struct xheader
*xhdr
)
737 char *p
= xhdr
->buffer
+ BLOCKSIZE
;
739 xheader_list_destroy (&global_header_override_list
);
740 while (decode_record (xhdr
, &p
, decg
, &global_header_override_list
))
746 xheader_init (struct xheader
*xhdr
)
750 xhdr
->stk
= xmalloc (sizeof *xhdr
->stk
);
751 obstack_init (xhdr
->stk
);
756 xheader_store (char const *keyword
, struct tar_stat_info
*st
,
759 struct xhdr_tab
const *t
;
763 t
= locate_handler (keyword
);
766 if (xheader_keyword_deleted_p (keyword
)
767 || xheader_keyword_override_p (keyword
))
769 xheader_init (&st
->xhdr
);
770 t
->coder (st
, keyword
, &st
->xhdr
, data
);
774 xheader_read (struct xheader
*xhdr
, union block
*p
, size_t size
)
780 xhdr
->buffer
= xmalloc (size
+ 1);
781 xhdr
->buffer
[size
] = '\0';
791 FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
793 memcpy (&xhdr
->buffer
[j
], p
->buffer
, len
);
794 set_next_block_after (p
);
796 p
= find_next_block ();
805 xheader_print_n (struct xheader
*xhdr
, char const *keyword
,
806 char const *value
, size_t vsize
)
808 size_t len
= strlen (keyword
) + vsize
+ 3; /* ' ' + '=' + '\n' */
811 char nbuf
[UINTMAX_STRSIZE_BOUND
];
817 np
= umaxtostr (len
+ p
, nbuf
);
818 n
= nbuf
+ sizeof nbuf
- 1 - np
;
822 x_obstack_grow (xhdr
, np
, n
);
823 x_obstack_1grow (xhdr
, ' ');
824 x_obstack_grow (xhdr
, keyword
, strlen (keyword
));
825 x_obstack_1grow (xhdr
, '=');
826 x_obstack_grow (xhdr
, value
, vsize
);
827 x_obstack_1grow (xhdr
, '\n');
831 xheader_print (struct xheader
*xhdr
, char const *keyword
, char const *value
)
833 xheader_print_n (xhdr
, keyword
, value
, strlen (value
));
837 xheader_finish (struct xheader
*xhdr
)
839 struct keyword_list
*kp
;
841 for (kp
= keyword_override_list
; kp
; kp
= kp
->next
)
842 code_string (kp
->value
, kp
->pattern
, xhdr
);
844 xhdr
->buffer
= obstack_finish (xhdr
->stk
);
848 xheader_destroy (struct xheader
*xhdr
)
852 obstack_free (xhdr
->stk
, NULL
);
863 /* Buildable strings */
866 xheader_string_begin (struct xheader
*xhdr
)
868 xhdr
->string_length
= 0;
872 xheader_string_add (struct xheader
*xhdr
, char const *s
)
877 xhdr
->string_length
+= strlen (s
);
878 x_obstack_grow (xhdr
, s
, strlen (s
));
882 xheader_string_end (struct xheader
*xhdr
, char const *keyword
)
888 char nbuf
[UINTMAX_STRSIZE_BOUND
];
896 len
= strlen (keyword
) + xhdr
->string_length
+ 3; /* ' ' + '=' + '\n' */
901 np
= umaxtostr (len
+ p
, nbuf
);
902 n
= nbuf
+ sizeof nbuf
- 1 - np
;
906 p
= strlen (keyword
) + n
+ 2;
911 _("Generated keyword/value pair is too long (keyword=%s, length=%s)"),
913 obstack_free (xhdr
->stk
, obstack_finish (xhdr
->stk
));
916 x_obstack_blank (xhdr
, p
);
917 x_obstack_1grow (xhdr
, '\n');
918 cp
= obstack_next_free (xhdr
->stk
) - xhdr
->string_length
- p
- 1;
919 memmove (cp
+ p
, cp
, xhdr
->string_length
);
920 cp
= stpcpy (cp
, np
);
922 cp
= stpcpy (cp
, keyword
);
928 /* Implementations */
931 out_of_range_header (char const *keyword
, char const *value
,
932 uintmax_t minus_minval
, uintmax_t maxval
)
934 char minval_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
935 char maxval_buf
[UINTMAX_STRSIZE_BOUND
];
936 char *minval_string
= umaxtostr (minus_minval
, minval_buf
+ 1);
937 char *maxval_string
= umaxtostr (maxval
, maxval_buf
);
939 *--minval_string
= '-';
941 /* TRANSLATORS: The first %s is the pax extended header keyword
942 (atime, gid, etc.). */
943 ERROR ((0, 0, _("Extended header %s=%s is out of range %s..%s"),
944 keyword
, value
, minval_string
, maxval_string
));
948 code_string (char const *string
, char const *keyword
, struct xheader
*xhdr
)
951 if (!utf8_convert (true, string
, &outstr
))
953 /* FIXME: report error */
954 outstr
= xstrdup (string
);
956 xheader_print (xhdr
, keyword
, outstr
);
961 decode_string (char **string
, char const *arg
)
968 if (!utf8_convert (false, arg
, string
))
970 /* FIXME: report error and act accordingly to --pax invalid=UTF-8 */
971 assign_string (string
, arg
);
976 code_time (struct timespec t
, char const *keyword
, struct xheader
*xhdr
)
978 char buf
[TIMESPEC_STRSIZE_BOUND
];
979 xheader_print (xhdr
, keyword
, code_timespec (t
, buf
));
982 enum decode_time_status
986 decode_time_bad_header
989 static enum decode_time_status
990 _decode_time (struct timespec
*ts
, char const *arg
, char const *keyword
)
993 unsigned long int ns
= 0;
996 bool negative
= *arg
== '-';
1000 if (ISDIGIT (arg
[negative
]))
1004 intmax_t i
= strtoimax (arg
, &arg_lim
, 10);
1005 if (TYPE_SIGNED (time_t) ? i
< TYPE_MINIMUM (time_t) : i
< 0)
1006 return decode_time_range
;
1011 uintmax_t i
= strtoumax (arg
, &arg_lim
, 10);
1012 if (TYPE_MAXIMUM (time_t) < i
)
1013 return decode_time_range
;
1019 if (errno
== ERANGE
)
1020 return decode_time_range
;
1025 bool trailing_nonzero
= false;
1027 while (ISDIGIT (*++p
))
1028 if (digits
< LOG10_BILLION
)
1030 ns
= 10 * ns
+ (*p
- '0');
1034 trailing_nonzero
|= *p
!= '0';
1036 while (digits
++ < LOG10_BILLION
)
1041 /* Convert "-1.10000000000001" to s == -2, ns == 89999999.
1042 I.e., truncate time stamps towards minus infinity while
1043 converting them to internal form. */
1044 ns
+= trailing_nonzero
;
1047 if (s
== TYPE_MINIMUM (time_t))
1048 return decode_time_range
;
1059 return decode_time_success
;
1063 return decode_time_bad_header
;
1067 decode_time (struct timespec
*ts
, char const *arg
, char const *keyword
)
1069 switch (_decode_time (ts
, arg
, keyword
))
1071 case decode_time_success
:
1073 case decode_time_bad_header
:
1074 ERROR ((0, 0, _("Malformed extended header: invalid %s=%s"),
1077 case decode_time_range
:
1078 out_of_range_header (keyword
, arg
, - (uintmax_t) TYPE_MINIMUM (time_t),
1079 TYPE_MAXIMUM (time_t));
1088 code_num (uintmax_t value
, char const *keyword
, struct xheader
*xhdr
)
1090 char sbuf
[UINTMAX_STRSIZE_BOUND
];
1091 xheader_print (xhdr
, keyword
, umaxtostr (value
, sbuf
));
1095 decode_num (uintmax_t *num
, char const *arg
, uintmax_t maxval
,
1096 char const *keyword
)
1101 if (! (ISDIGIT (*arg
)
1102 && (errno
= 0, u
= strtoumax (arg
, &arg_lim
, 10), !*arg_lim
)))
1104 ERROR ((0, 0, _("Malformed extended header: invalid %s=%s"),
1109 if (! (u
<= maxval
&& errno
!= ERANGE
))
1111 out_of_range_header (keyword
, arg
, 0, maxval
);
1120 dummy_coder (struct tar_stat_info
const *st
__attribute__ ((unused
)),
1121 char const *keyword
__attribute__ ((unused
)),
1122 struct xheader
*xhdr
__attribute__ ((unused
)),
1123 void const *data
__attribute__ ((unused
)))
1128 dummy_decoder (struct tar_stat_info
*st
__attribute__ ((unused
)),
1129 char const *keyword
__attribute__ ((unused
)),
1130 char const *arg
__attribute__ ((unused
)),
1131 size_t size
__attribute__((unused
)))
1136 atime_coder (struct tar_stat_info
const *st
, char const *keyword
,
1137 struct xheader
*xhdr
, void const *data
__attribute__ ((unused
)))
1139 code_time (st
->atime
, keyword
, xhdr
);
1143 atime_decoder (struct tar_stat_info
*st
,
1144 char const *keyword
,
1146 size_t size
__attribute__((unused
)))
1149 if (decode_time (&ts
, arg
, keyword
))
1154 gid_coder (struct tar_stat_info
const *st
, char const *keyword
,
1155 struct xheader
*xhdr
, void const *data
__attribute__ ((unused
)))
1157 code_num (st
->stat
.st_gid
, keyword
, xhdr
);
1161 gid_decoder (struct tar_stat_info
*st
,
1162 char const *keyword
,
1164 size_t size
__attribute__((unused
)))
1167 if (decode_num (&u
, arg
, TYPE_MAXIMUM (gid_t
), keyword
))
1168 st
->stat
.st_gid
= u
;
1172 gname_coder (struct tar_stat_info
const *st
, char const *keyword
,
1173 struct xheader
*xhdr
, void const *data
__attribute__ ((unused
)))
1175 code_string (st
->gname
, keyword
, xhdr
);
1179 gname_decoder (struct tar_stat_info
*st
,
1180 char const *keyword
__attribute__((unused
)),
1182 size_t size
__attribute__((unused
)))
1184 decode_string (&st
->gname
, arg
);
1188 linkpath_coder (struct tar_stat_info
const *st
, char const *keyword
,
1189 struct xheader
*xhdr
, void const *data
__attribute__ ((unused
)))
1191 code_string (st
->link_name
, keyword
, xhdr
);
1195 linkpath_decoder (struct tar_stat_info
*st
,
1196 char const *keyword
__attribute__((unused
)),
1198 size_t size
__attribute__((unused
)))
1200 decode_string (&st
->link_name
, arg
);
1204 ctime_coder (struct tar_stat_info
const *st
, char const *keyword
,
1205 struct xheader
*xhdr
, void const *data
__attribute__ ((unused
)))
1207 code_time (st
->ctime
, keyword
, xhdr
);
1211 ctime_decoder (struct tar_stat_info
*st
,
1212 char const *keyword
,
1214 size_t size
__attribute__((unused
)))
1217 if (decode_time (&ts
, arg
, keyword
))
1222 mtime_coder (struct tar_stat_info
const *st
, char const *keyword
,
1223 struct xheader
*xhdr
, void const *data
)
1225 struct timespec
const *mtime
= data
;
1226 code_time (mtime
? *mtime
: st
->mtime
, keyword
, xhdr
);
1230 mtime_decoder (struct tar_stat_info
*st
,
1231 char const *keyword
,
1233 size_t size
__attribute__((unused
)))
1236 if (decode_time (&ts
, arg
, keyword
))
1241 path_coder (struct tar_stat_info
const *st
, char const *keyword
,
1242 struct xheader
*xhdr
, void const *data
__attribute__ ((unused
)))
1244 code_string (st
->file_name
, keyword
, xhdr
);
1248 path_decoder (struct tar_stat_info
*st
,
1249 char const *keyword
__attribute__((unused
)),
1251 size_t size
__attribute__((unused
)))
1253 decode_string (&st
->orig_file_name
, arg
);
1254 decode_string (&st
->file_name
, arg
);
1255 st
->had_trailing_slash
= strip_trailing_slashes (st
->file_name
);
1259 size_coder (struct tar_stat_info
const *st
, char const *keyword
,
1260 struct xheader
*xhdr
, void const *data
__attribute__ ((unused
)))
1262 code_num (st
->stat
.st_size
, keyword
, xhdr
);
1266 size_decoder (struct tar_stat_info
*st
,
1267 char const *keyword
,
1269 size_t size
__attribute__((unused
)))
1272 if (decode_num (&u
, arg
, TYPE_MAXIMUM (off_t
), keyword
))
1273 st
->stat
.st_size
= u
;
1277 uid_coder (struct tar_stat_info
const *st
, char const *keyword
,
1278 struct xheader
*xhdr
, void const *data
__attribute__ ((unused
)))
1280 code_num (st
->stat
.st_uid
, keyword
, xhdr
);
1284 uid_decoder (struct tar_stat_info
*st
,
1285 char const *keyword
,
1287 size_t size
__attribute__((unused
)))
1290 if (decode_num (&u
, arg
, TYPE_MAXIMUM (uid_t
), keyword
))
1291 st
->stat
.st_uid
= u
;
1295 uname_coder (struct tar_stat_info
const *st
, char const *keyword
,
1296 struct xheader
*xhdr
, void const *data
__attribute__ ((unused
)))
1298 code_string (st
->uname
, keyword
, xhdr
);
1302 uname_decoder (struct tar_stat_info
*st
,
1303 char const *keyword
__attribute__((unused
)),
1305 size_t size
__attribute__((unused
)))
1307 decode_string (&st
->uname
, arg
);
1311 sparse_size_coder (struct tar_stat_info
const *st
, char const *keyword
,
1312 struct xheader
*xhdr
, void const *data
)
1314 size_coder (st
, keyword
, xhdr
, data
);
1318 sparse_size_decoder (struct tar_stat_info
*st
,
1319 char const *keyword
,
1321 size_t size
__attribute__((unused
)))
1324 if (decode_num (&u
, arg
, TYPE_MAXIMUM (off_t
), keyword
))
1325 st
->stat
.st_size
= u
;
1329 sparse_numblocks_coder (struct tar_stat_info
const *st
, char const *keyword
,
1330 struct xheader
*xhdr
,
1331 void const *data
__attribute__ ((unused
)))
1333 code_num (st
->sparse_map_avail
, keyword
, xhdr
);
1337 sparse_numblocks_decoder (struct tar_stat_info
*st
,
1338 char const *keyword
,
1340 size_t size
__attribute__((unused
)))
1343 if (decode_num (&u
, arg
, SIZE_MAX
, keyword
))
1345 st
->sparse_map_size
= u
;
1346 st
->sparse_map
= xcalloc (u
, sizeof st
->sparse_map
[0]);
1347 st
->sparse_map_avail
= 0;
1352 sparse_offset_coder (struct tar_stat_info
const *st
, char const *keyword
,
1353 struct xheader
*xhdr
, void const *data
)
1355 size_t const *pi
= data
;
1356 code_num (st
->sparse_map
[*pi
].offset
, keyword
, xhdr
);
1360 sparse_offset_decoder (struct tar_stat_info
*st
,
1361 char const *keyword
,
1363 size_t size
__attribute__((unused
)))
1366 if (decode_num (&u
, arg
, TYPE_MAXIMUM (off_t
), keyword
))
1368 if (st
->sparse_map_avail
< st
->sparse_map_size
)
1369 st
->sparse_map
[st
->sparse_map_avail
].offset
= u
;
1371 ERROR ((0, 0, _("Malformed extended header: excess %s=%s"),
1372 "GNU.sparse.offset", arg
));
1377 sparse_numbytes_coder (struct tar_stat_info
const *st
, char const *keyword
,
1378 struct xheader
*xhdr
, void const *data
)
1380 size_t const *pi
= data
;
1381 code_num (st
->sparse_map
[*pi
].numbytes
, keyword
, xhdr
);
1385 sparse_numbytes_decoder (struct tar_stat_info
*st
,
1386 char const *keyword
,
1388 size_t size
__attribute__((unused
)))
1391 if (decode_num (&u
, arg
, TYPE_MAXIMUM (off_t
), keyword
))
1393 if (st
->sparse_map_avail
< st
->sparse_map_size
)
1394 st
->sparse_map
[st
->sparse_map_avail
++].numbytes
= u
;
1396 ERROR ((0, 0, _("Malformed extended header: excess %s=%s"),
1402 sparse_map_decoder (struct tar_stat_info
*st
,
1403 char const *keyword
,
1405 size_t size
__attribute__((unused
)))
1409 st
->sparse_map_avail
= 0;
1416 if (!ISDIGIT (*arg
))
1418 ERROR ((0, 0, _("Malformed extended header: invalid %s=%s"),
1424 u
= strtoumax (arg
, &delim
, 10);
1428 if (!(u
== e
.offset
&& errno
!= ERANGE
))
1430 out_of_range_header (keyword
, arg
, 0, TYPE_MAXIMUM (off_t
));
1437 if (!(u
== e
.numbytes
&& errno
!= ERANGE
))
1439 out_of_range_header (keyword
, arg
, 0, TYPE_MAXIMUM (off_t
));
1442 if (st
->sparse_map_avail
< st
->sparse_map_size
)
1443 st
->sparse_map
[st
->sparse_map_avail
++] = e
;
1446 ERROR ((0, 0, _("Malformed extended header: excess %s=%s"),
1456 else if (*delim
!= ',')
1459 _("Malformed extended header: invalid %s: unexpected delimiter %c"),
1469 _("Malformed extended header: invalid %s: odd number of values"),
1474 dumpdir_coder (struct tar_stat_info
const *st
, char const *keyword
,
1475 struct xheader
*xhdr
, void const *data
)
1477 xheader_print_n (xhdr
, keyword
, data
, dumpdir_size (data
));
1481 dumpdir_decoder (struct tar_stat_info
*st
,
1482 char const *keyword
__attribute__((unused
)),
1486 st
->dumpdir
= xmalloc (size
);
1487 memcpy (st
->dumpdir
, arg
, size
);
1491 volume_label_coder (struct tar_stat_info
const *st
, char const *keyword
,
1492 struct xheader
*xhdr
, void const *data
)
1494 code_string (data
, keyword
, xhdr
);
1498 volume_label_decoder (struct tar_stat_info
*st
,
1499 char const *keyword
__attribute__((unused
)),
1501 size_t size
__attribute__((unused
)))
1503 decode_string (&volume_label
, arg
);
1507 volume_size_coder (struct tar_stat_info
const *st
, char const *keyword
,
1508 struct xheader
*xhdr
, void const *data
)
1510 off_t
const *v
= data
;
1511 code_num (*v
, keyword
, xhdr
);
1515 volume_size_decoder (struct tar_stat_info
*st
,
1516 char const *keyword
,
1517 char const *arg
, size_t size
)
1520 if (decode_num (&u
, arg
, TYPE_MAXIMUM (uintmax_t), keyword
))
1521 continued_file_size
= u
;
1524 /* FIXME: Merge with volume_size_coder */
1526 volume_offset_coder (struct tar_stat_info
const *st
, char const *keyword
,
1527 struct xheader
*xhdr
, void const *data
)
1529 off_t
const *v
= data
;
1530 code_num (*v
, keyword
, xhdr
);
1534 volume_offset_decoder (struct tar_stat_info
*st
,
1535 char const *keyword
,
1536 char const *arg
, size_t size
)
1539 if (decode_num (&u
, arg
, TYPE_MAXIMUM (uintmax_t), keyword
))
1540 continued_file_offset
= u
;
1544 volume_filename_decoder (struct tar_stat_info
*st
,
1545 char const *keyword
__attribute__((unused
)),
1547 size_t size
__attribute__((unused
)))
1549 decode_string (&continued_file_name
, arg
);
1552 xattr_coder (struct tar_stat_info
const *st
, char const *keyword
,
1553 struct xheader
*xhdr
, void const *data
)
1555 struct xattr_array
*xattr_map
= st
->xattr_map
;
1556 const size_t *off
= data
;
1557 xheader_print_n (xhdr
, keyword
,
1558 xattr_map
[*off
].xval_ptr
, xattr_map
[*off
].xval_len
);
1562 xattr_decoder (struct tar_stat_info
*st
,
1563 char const *keyword
, char const *arg
, size_t size
)
1567 xstr
= xmemdup(arg
, size
+ 1);
1568 xheader_xattr_add(st
, keyword
+ strlen("SCHILY.xattr."), xstr
, size
);
1573 sparse_major_coder (struct tar_stat_info
const *st
, char const *keyword
,
1574 struct xheader
*xhdr
, void const *data
)
1576 code_num (st
->sparse_major
, keyword
, xhdr
);
1580 sparse_major_decoder (struct tar_stat_info
*st
,
1581 char const *keyword
,
1586 if (decode_num (&u
, arg
, TYPE_MAXIMUM (unsigned), keyword
))
1587 st
->sparse_major
= u
;
1591 sparse_minor_coder (struct tar_stat_info
const *st
, char const *keyword
,
1592 struct xheader
*xhdr
, void const *data
)
1594 code_num (st
->sparse_minor
, keyword
, xhdr
);
1598 sparse_minor_decoder (struct tar_stat_info
*st
,
1599 char const *keyword
,
1604 if (decode_num (&u
, arg
, TYPE_MAXIMUM (unsigned), keyword
))
1605 st
->sparse_minor
= u
;
1608 struct xhdr_tab
const xhdr_tab
[] = {
1609 { "atime", atime_coder
, atime_decoder
, 0, false },
1610 { "comment", dummy_coder
, dummy_decoder
, 0, false },
1611 { "charset", dummy_coder
, dummy_decoder
, 0, false },
1612 { "ctime", ctime_coder
, ctime_decoder
, 0, false },
1613 { "gid", gid_coder
, gid_decoder
, 0, false },
1614 { "gname", gname_coder
, gname_decoder
, 0, false },
1615 { "linkpath", linkpath_coder
, linkpath_decoder
, 0, false },
1616 { "mtime", mtime_coder
, mtime_decoder
, 0, false },
1617 { "path", path_coder
, path_decoder
, 0, false },
1618 { "size", size_coder
, size_decoder
, 0, false },
1619 { "uid", uid_coder
, uid_decoder
, 0, false },
1620 { "uname", uname_coder
, uname_decoder
, 0, false },
1622 /* Sparse file handling */
1623 { "GNU.sparse.name", path_coder
, path_decoder
,
1624 XHDR_PROTECTED
, false },
1625 { "GNU.sparse.major", sparse_major_coder
, sparse_major_decoder
,
1626 XHDR_PROTECTED
, false },
1627 { "GNU.sparse.minor", sparse_minor_coder
, sparse_minor_decoder
,
1628 XHDR_PROTECTED
, false },
1629 { "GNU.sparse.realsize", sparse_size_coder
, sparse_size_decoder
,
1630 XHDR_PROTECTED
, false },
1631 { "GNU.sparse.numblocks", sparse_numblocks_coder
, sparse_numblocks_decoder
,
1632 XHDR_PROTECTED
, false },
1634 /* tar 1.14 - 1.15.90 keywords. */
1635 { "GNU.sparse.size", sparse_size_coder
, sparse_size_decoder
,
1636 XHDR_PROTECTED
, false },
1637 /* tar 1.14 - 1.15.1 keywords. Multiple instances of these appeared in 'x'
1638 headers, and each of them was meaningful. It confilcted with POSIX specs,
1639 which requires that "when extended header records conflict, the last one
1640 given in the header shall take precedence." */
1641 { "GNU.sparse.offset", sparse_offset_coder
, sparse_offset_decoder
,
1642 XHDR_PROTECTED
, false },
1643 { "GNU.sparse.numbytes", sparse_numbytes_coder
, sparse_numbytes_decoder
,
1644 XHDR_PROTECTED
, false },
1645 /* tar 1.15.90 keyword, introduced to remove the above-mentioned conflict. */
1646 { "GNU.sparse.map", NULL
/* Unused, see pax_dump_header() */,
1647 sparse_map_decoder
, 0, false },
1649 { "GNU.dumpdir", dumpdir_coder
, dumpdir_decoder
,
1650 XHDR_PROTECTED
, false },
1652 /* Keeps the tape/volume label. May be present only in the global headers.
1653 Equivalent to GNUTYPE_VOLHDR. */
1654 { "GNU.volume.label", volume_label_coder
, volume_label_decoder
,
1655 XHDR_PROTECTED
| XHDR_GLOBAL
, false },
1657 /* These may be present in a first global header of the archive.
1658 They provide the same functionality as GNUTYPE_MULTIVOL header.
1659 The GNU.volume.size keeps the real_s_sizeleft value, which is
1660 otherwise kept in the size field of a multivolume header. The
1661 GNU.volume.offset keeps the offset of the start of this volume,
1662 otherwise kept in oldgnu_header.offset. */
1663 { "GNU.volume.filename", volume_label_coder
, volume_filename_decoder
,
1664 XHDR_PROTECTED
| XHDR_GLOBAL
, false },
1665 { "GNU.volume.size", volume_size_coder
, volume_size_decoder
,
1666 XHDR_PROTECTED
| XHDR_GLOBAL
, false },
1667 { "GNU.volume.offset", volume_offset_coder
, volume_offset_decoder
,
1668 XHDR_PROTECTED
| XHDR_GLOBAL
, false },
1670 /* We are storing all extended attributes using this rule even if some of them
1671 were stored by some previous rule (duplicates) -- we just have to make sure
1672 they are restored *only once* during extraction later on. */
1673 { "SCHILY.xattr", xattr_coder
, xattr_decoder
, 0, true },
1675 { NULL
, NULL
, NULL
, 0, false }