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 /* This is reversal function for xattr_encode_keyword. See comment for
503 xattr_encode_keyword() for more info. */
505 xattr_decode_keyword (char *keyword
)
507 char *kpr
, *kpl
; /* keyword pointer left/right */
514 if (kpr
[1] == '3' && kpr
[2] == 'D')
521 else if (kpr
[1] == '2' && kpr
[2] == '5')
540 void xheader_xattr_add(struct tar_stat_info
*st
,
541 const char *key
, const char *val
, size_t len
)
543 size_t klen
= strlen (key
);
544 char *xkey
= xmalloc (strlen("SCHILY.xattr.") + klen
+ 1);
547 tmp
= stpcpy (tmp
, "SCHILY.xattr.");
550 xheader_xattr__add (&st
->xattr_map
, &st
->xattr_map_size
, xkey
, val
, len
);
555 void xheader_xattr_copy(const struct tar_stat_info
*st
,
556 struct xattr_array
**xattr_map
, size_t *xattr_map_size
)
563 while (scan
< st
->xattr_map_size
)
565 char *key
= st
->xattr_map
[scan
].xkey
;
566 char *val
= st
->xattr_map
[scan
].xval_ptr
;
567 size_t len
= st
->xattr_map
[scan
].xval_len
;
569 xheader_xattr__add(xattr_map
, xattr_map_size
, key
, val
, len
);
576 /* General Interface */
578 #define XHDR_PROTECTED 0x01
579 #define XHDR_GLOBAL 0x02
584 void (*coder
) (struct tar_stat_info
const *, char const *,
585 struct xheader
*, void const *data
);
586 void (*decoder
) (struct tar_stat_info
*, char const *, char const *, size_t);
588 bool prefix
; /* select handler comparing prefix only */
591 /* This declaration must be extern, because ISO C99 section 6.9.2
592 prohibits a tentative definition that has both internal linkage and
593 incomplete type. If we made it static, we'd have to declare its
594 size which would be a maintenance pain; if we put its initializer
595 here, we'd need a boatload of forward declarations, which would be
596 even more of a pain. */
597 extern struct xhdr_tab
const xhdr_tab
[];
599 static struct xhdr_tab
const *
600 locate_handler (char const *keyword
)
602 struct xhdr_tab
const *p
;
604 for (p
= xhdr_tab
; p
->keyword
; p
++)
607 if (strncmp (p
->keyword
, keyword
, strlen(p
->keyword
)) == 0)
612 if (strcmp (p
->keyword
, keyword
) == 0)
620 xheader_protected_pattern_p (const char *pattern
)
622 struct xhdr_tab
const *p
;
624 for (p
= xhdr_tab
; p
->keyword
; p
++)
625 if (!p
->prefix
&& (p
->flags
& XHDR_PROTECTED
)
626 && fnmatch (pattern
, p
->keyword
, 0) == 0)
632 xheader_protected_keyword_p (const char *keyword
)
634 struct xhdr_tab
const *p
;
636 for (p
= xhdr_tab
; p
->keyword
; p
++)
637 if (!p
->prefix
&& (p
->flags
& XHDR_PROTECTED
)
638 && strcmp (p
->keyword
, keyword
) == 0)
643 /* Decode a single extended header record, advancing *PTR to the next record.
644 Return true on success, false otherwise. */
646 decode_record (struct xheader
*xhdr
,
648 void (*handler
) (void *, char const *, char const *, size_t),
658 size_t len_max
= xhdr
->buffer
+ xhdr
->size
- start
;
660 while (*p
== ' ' || *p
== '\t')
666 ERROR ((0, 0, _("Malformed extended header: missing length")));
671 len
= u
= strtoumax (p
, &len_lim
, 10);
672 if (len
!= u
|| errno
== ERANGE
)
674 ERROR ((0, 0, _("Extended header length is out of allowed range")));
680 int len_len
= len_lim
- p
;
681 ERROR ((0, 0, _("Extended header length %*s is out of range"),
688 for (p
= len_lim
; *p
== ' ' || *p
== '\t'; p
++)
693 _("Malformed extended header: missing blank after length")));
699 if (! (p
&& p
< nextp
))
701 ERROR ((0, 0, _("Malformed extended header: missing equal sign")));
705 if (nextp
[-1] != '\n')
707 ERROR ((0, 0, _("Malformed extended header: missing newline")));
711 *p
= nextp
[-1] = '\0';
712 handler (data
, keyword
, p
+ 1, nextp
- p
- 2); /* '=' + trailing '\n' */
720 run_override_list (struct keyword_list
*kp
, struct tar_stat_info
*st
)
722 for (; kp
; kp
= kp
->next
)
724 struct xhdr_tab
const *t
= locate_handler (kp
->pattern
);
726 t
->decoder (st
, t
->keyword
, kp
->value
, strlen (kp
->value
));
731 decx (void *data
, char const *keyword
, char const *value
, size_t size
)
733 struct xhdr_tab
const *t
;
734 struct tar_stat_info
*st
= data
;
736 if (xheader_keyword_deleted_p (keyword
)
737 || xheader_keyword_override_p (keyword
))
740 t
= locate_handler (keyword
);
742 t
->decoder (st
, keyword
, value
, size
);
744 WARNOPT (WARN_UNKNOWN_KEYWORD
,
745 (0, 0, _("Ignoring unknown extended header keyword '%s'"),
750 xheader_decode (struct tar_stat_info
*st
)
752 run_override_list (keyword_global_override_list
, st
);
753 run_override_list (global_header_override_list
, st
);
757 char *p
= st
->xhdr
.buffer
+ BLOCKSIZE
;
758 while (decode_record (&st
->xhdr
, &p
, decx
, st
))
761 run_override_list (keyword_override_list
, st
);
765 decg (void *data
, char const *keyword
, char const *value
,
766 size_t size
__attribute__((unused
)))
768 struct keyword_list
**kwl
= data
;
769 struct xhdr_tab
const *tab
= locate_handler (keyword
);
770 if (tab
&& (tab
->flags
& XHDR_GLOBAL
))
771 tab
->decoder (data
, keyword
, value
, size
);
773 xheader_list_append (kwl
, keyword
, value
);
777 xheader_decode_global (struct xheader
*xhdr
)
781 char *p
= xhdr
->buffer
+ BLOCKSIZE
;
783 xheader_list_destroy (&global_header_override_list
);
784 while (decode_record (xhdr
, &p
, decg
, &global_header_override_list
))
790 xheader_init (struct xheader
*xhdr
)
794 xhdr
->stk
= xmalloc (sizeof *xhdr
->stk
);
795 obstack_init (xhdr
->stk
);
800 xheader_store (char const *keyword
, struct tar_stat_info
*st
,
803 struct xhdr_tab
const *t
;
807 t
= locate_handler (keyword
);
810 if (xheader_keyword_deleted_p (keyword
)
811 || xheader_keyword_override_p (keyword
))
813 xheader_init (&st
->xhdr
);
814 t
->coder (st
, keyword
, &st
->xhdr
, data
);
818 xheader_read (struct xheader
*xhdr
, union block
*p
, size_t size
)
824 xhdr
->buffer
= xmalloc (size
+ 1);
825 xhdr
->buffer
[size
] = '\0';
835 FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
837 memcpy (&xhdr
->buffer
[j
], p
->buffer
, len
);
838 set_next_block_after (p
);
840 p
= find_next_block ();
848 /* xattr_encode_keyword() substitutes '=' ~~> '%3D' and '%' ~~> '%25'
849 in extended attribute keywords. This is needed because the '=' character
850 has special purpose in extended attribute header - it splits keyword and
851 value part of header. If there was the '=' occurrence allowed inside
852 keyword, there would be no unambiguous way how to decode this extended
855 (http://lists.gnu.org/archive/html/bug-tar/2012-10/msg00017.html)
858 xattr_encode_keyword(const char *keyword
)
860 static char *encode_buffer
= NULL
;
861 static size_t encode_buffer_size
= 0;
862 size_t bp
; /* keyword/buffer pointers */
866 encode_buffer_size
= 256;
867 encode_buffer
= xmalloc (encode_buffer_size
);
872 for (bp
= 0; *keyword
!= 0; ++bp
, ++keyword
)
876 if (bp
+ 2 /* enough for URL encoding also.. */ >= encode_buffer_size
)
878 encode_buffer
= x2realloc (encode_buffer
, &encode_buffer_size
);
883 strcpy (encode_buffer
+ bp
, "%25");
888 strcpy (encode_buffer
+ bp
, "%3D");
892 encode_buffer
[bp
] = c
;
895 encode_buffer
[bp
] = 0;
897 return encode_buffer
;
901 xheader_print_n (struct xheader
*xhdr
, char const *keyword
,
902 char const *value
, size_t vsize
)
906 char nbuf
[UINTMAX_STRSIZE_BOUND
];
910 keyword
= xattr_encode_keyword (keyword
);
911 klen
= strlen (keyword
);
912 len
= klen
+ vsize
+ 3; /* ' ' + '=' + '\n' */
917 np
= umaxtostr (len
+ p
, nbuf
);
918 n
= nbuf
+ sizeof nbuf
- 1 - np
;
922 x_obstack_grow (xhdr
, np
, n
);
923 x_obstack_1grow (xhdr
, ' ');
924 x_obstack_grow (xhdr
, keyword
, klen
);
925 x_obstack_1grow (xhdr
, '=');
926 x_obstack_grow (xhdr
, value
, vsize
);
927 x_obstack_1grow (xhdr
, '\n');
931 xheader_print (struct xheader
*xhdr
, char const *keyword
, char const *value
)
933 xheader_print_n (xhdr
, keyword
, value
, strlen (value
));
937 xheader_finish (struct xheader
*xhdr
)
939 struct keyword_list
*kp
;
941 for (kp
= keyword_override_list
; kp
; kp
= kp
->next
)
942 code_string (kp
->value
, kp
->pattern
, xhdr
);
944 xhdr
->buffer
= obstack_finish (xhdr
->stk
);
948 xheader_destroy (struct xheader
*xhdr
)
952 obstack_free (xhdr
->stk
, NULL
);
963 /* Buildable strings */
966 xheader_string_begin (struct xheader
*xhdr
)
968 xhdr
->string_length
= 0;
972 xheader_string_add (struct xheader
*xhdr
, char const *s
)
977 xhdr
->string_length
+= strlen (s
);
978 x_obstack_grow (xhdr
, s
, strlen (s
));
982 xheader_string_end (struct xheader
*xhdr
, char const *keyword
)
988 char nbuf
[UINTMAX_STRSIZE_BOUND
];
996 len
= strlen (keyword
) + xhdr
->string_length
+ 3; /* ' ' + '=' + '\n' */
1001 np
= umaxtostr (len
+ p
, nbuf
);
1002 n
= nbuf
+ sizeof nbuf
- 1 - np
;
1006 p
= strlen (keyword
) + n
+ 2;
1011 _("Generated keyword/value pair is too long (keyword=%s, length=%s)"),
1013 obstack_free (xhdr
->stk
, obstack_finish (xhdr
->stk
));
1016 x_obstack_blank (xhdr
, p
);
1017 x_obstack_1grow (xhdr
, '\n');
1018 cp
= obstack_next_free (xhdr
->stk
) - xhdr
->string_length
- p
- 1;
1019 memmove (cp
+ p
, cp
, xhdr
->string_length
);
1020 cp
= stpcpy (cp
, np
);
1022 cp
= stpcpy (cp
, keyword
);
1028 /* Implementations */
1031 out_of_range_header (char const *keyword
, char const *value
,
1032 uintmax_t minus_minval
, uintmax_t maxval
)
1034 char minval_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
1035 char maxval_buf
[UINTMAX_STRSIZE_BOUND
];
1036 char *minval_string
= umaxtostr (minus_minval
, minval_buf
+ 1);
1037 char *maxval_string
= umaxtostr (maxval
, maxval_buf
);
1039 *--minval_string
= '-';
1041 /* TRANSLATORS: The first %s is the pax extended header keyword
1042 (atime, gid, etc.). */
1043 ERROR ((0, 0, _("Extended header %s=%s is out of range %s..%s"),
1044 keyword
, value
, minval_string
, maxval_string
));
1048 code_string (char const *string
, char const *keyword
, struct xheader
*xhdr
)
1051 if (!utf8_convert (true, string
, &outstr
))
1053 /* FIXME: report error */
1054 outstr
= xstrdup (string
);
1056 xheader_print (xhdr
, keyword
, outstr
);
1061 decode_string (char **string
, char const *arg
)
1068 if (!utf8_convert (false, arg
, string
))
1070 /* FIXME: report error and act accordingly to --pax invalid=UTF-8 */
1071 assign_string (string
, arg
);
1076 code_time (struct timespec t
, char const *keyword
, struct xheader
*xhdr
)
1078 char buf
[TIMESPEC_STRSIZE_BOUND
];
1079 xheader_print (xhdr
, keyword
, code_timespec (t
, buf
));
1082 enum decode_time_status
1084 decode_time_success
,
1086 decode_time_bad_header
1089 static enum decode_time_status
1090 _decode_time (struct timespec
*ts
, char const *arg
, char const *keyword
)
1093 unsigned long int ns
= 0;
1096 bool negative
= *arg
== '-';
1100 if (ISDIGIT (arg
[negative
]))
1104 intmax_t i
= strtoimax (arg
, &arg_lim
, 10);
1105 if (TYPE_SIGNED (time_t) ? i
< TYPE_MINIMUM (time_t) : i
< 0)
1106 return decode_time_range
;
1111 uintmax_t i
= strtoumax (arg
, &arg_lim
, 10);
1112 if (TYPE_MAXIMUM (time_t) < i
)
1113 return decode_time_range
;
1119 if (errno
== ERANGE
)
1120 return decode_time_range
;
1125 bool trailing_nonzero
= false;
1127 while (ISDIGIT (*++p
))
1128 if (digits
< LOG10_BILLION
)
1130 ns
= 10 * ns
+ (*p
- '0');
1134 trailing_nonzero
|= *p
!= '0';
1136 while (digits
++ < LOG10_BILLION
)
1141 /* Convert "-1.10000000000001" to s == -2, ns == 89999999.
1142 I.e., truncate time stamps towards minus infinity while
1143 converting them to internal form. */
1144 ns
+= trailing_nonzero
;
1147 if (s
== TYPE_MINIMUM (time_t))
1148 return decode_time_range
;
1159 return decode_time_success
;
1163 return decode_time_bad_header
;
1167 decode_time (struct timespec
*ts
, char const *arg
, char const *keyword
)
1169 switch (_decode_time (ts
, arg
, keyword
))
1171 case decode_time_success
:
1173 case decode_time_bad_header
:
1174 ERROR ((0, 0, _("Malformed extended header: invalid %s=%s"),
1177 case decode_time_range
:
1178 out_of_range_header (keyword
, arg
, - (uintmax_t) TYPE_MINIMUM (time_t),
1179 TYPE_MAXIMUM (time_t));
1188 code_num (uintmax_t value
, char const *keyword
, struct xheader
*xhdr
)
1190 char sbuf
[UINTMAX_STRSIZE_BOUND
];
1191 xheader_print (xhdr
, keyword
, umaxtostr (value
, sbuf
));
1195 decode_num (uintmax_t *num
, char const *arg
, uintmax_t maxval
,
1196 char const *keyword
)
1201 if (! (ISDIGIT (*arg
)
1202 && (errno
= 0, u
= strtoumax (arg
, &arg_lim
, 10), !*arg_lim
)))
1204 ERROR ((0, 0, _("Malformed extended header: invalid %s=%s"),
1209 if (! (u
<= maxval
&& errno
!= ERANGE
))
1211 out_of_range_header (keyword
, arg
, 0, maxval
);
1220 dummy_coder (struct tar_stat_info
const *st
__attribute__ ((unused
)),
1221 char const *keyword
__attribute__ ((unused
)),
1222 struct xheader
*xhdr
__attribute__ ((unused
)),
1223 void const *data
__attribute__ ((unused
)))
1228 dummy_decoder (struct tar_stat_info
*st
__attribute__ ((unused
)),
1229 char const *keyword
__attribute__ ((unused
)),
1230 char const *arg
__attribute__ ((unused
)),
1231 size_t size
__attribute__((unused
)))
1236 atime_coder (struct tar_stat_info
const *st
, char const *keyword
,
1237 struct xheader
*xhdr
, void const *data
__attribute__ ((unused
)))
1239 code_time (st
->atime
, keyword
, xhdr
);
1243 atime_decoder (struct tar_stat_info
*st
,
1244 char const *keyword
,
1246 size_t size
__attribute__((unused
)))
1249 if (decode_time (&ts
, arg
, keyword
))
1254 gid_coder (struct tar_stat_info
const *st
, char const *keyword
,
1255 struct xheader
*xhdr
, void const *data
__attribute__ ((unused
)))
1257 code_num (st
->stat
.st_gid
, keyword
, xhdr
);
1261 gid_decoder (struct tar_stat_info
*st
,
1262 char const *keyword
,
1264 size_t size
__attribute__((unused
)))
1267 if (decode_num (&u
, arg
, TYPE_MAXIMUM (gid_t
), keyword
))
1268 st
->stat
.st_gid
= u
;
1272 gname_coder (struct tar_stat_info
const *st
, char const *keyword
,
1273 struct xheader
*xhdr
, void const *data
__attribute__ ((unused
)))
1275 code_string (st
->gname
, keyword
, xhdr
);
1279 gname_decoder (struct tar_stat_info
*st
,
1280 char const *keyword
__attribute__((unused
)),
1282 size_t size
__attribute__((unused
)))
1284 decode_string (&st
->gname
, arg
);
1288 linkpath_coder (struct tar_stat_info
const *st
, char const *keyword
,
1289 struct xheader
*xhdr
, void const *data
__attribute__ ((unused
)))
1291 code_string (st
->link_name
, keyword
, xhdr
);
1295 linkpath_decoder (struct tar_stat_info
*st
,
1296 char const *keyword
__attribute__((unused
)),
1298 size_t size
__attribute__((unused
)))
1300 decode_string (&st
->link_name
, arg
);
1304 ctime_coder (struct tar_stat_info
const *st
, char const *keyword
,
1305 struct xheader
*xhdr
, void const *data
__attribute__ ((unused
)))
1307 code_time (st
->ctime
, keyword
, xhdr
);
1311 ctime_decoder (struct tar_stat_info
*st
,
1312 char const *keyword
,
1314 size_t size
__attribute__((unused
)))
1317 if (decode_time (&ts
, arg
, keyword
))
1322 mtime_coder (struct tar_stat_info
const *st
, char const *keyword
,
1323 struct xheader
*xhdr
, void const *data
)
1325 struct timespec
const *mtime
= data
;
1326 code_time (mtime
? *mtime
: st
->mtime
, keyword
, xhdr
);
1330 mtime_decoder (struct tar_stat_info
*st
,
1331 char const *keyword
,
1333 size_t size
__attribute__((unused
)))
1336 if (decode_time (&ts
, arg
, keyword
))
1341 path_coder (struct tar_stat_info
const *st
, char const *keyword
,
1342 struct xheader
*xhdr
, void const *data
__attribute__ ((unused
)))
1344 code_string (st
->file_name
, keyword
, xhdr
);
1348 path_decoder (struct tar_stat_info
*st
,
1349 char const *keyword
__attribute__((unused
)),
1351 size_t size
__attribute__((unused
)))
1353 decode_string (&st
->orig_file_name
, arg
);
1354 decode_string (&st
->file_name
, arg
);
1355 st
->had_trailing_slash
= strip_trailing_slashes (st
->file_name
);
1359 size_coder (struct tar_stat_info
const *st
, char const *keyword
,
1360 struct xheader
*xhdr
, void const *data
__attribute__ ((unused
)))
1362 code_num (st
->stat
.st_size
, keyword
, xhdr
);
1366 size_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
))
1373 st
->stat
.st_size
= u
;
1377 uid_coder (struct tar_stat_info
const *st
, char const *keyword
,
1378 struct xheader
*xhdr
, void const *data
__attribute__ ((unused
)))
1380 code_num (st
->stat
.st_uid
, keyword
, xhdr
);
1384 uid_decoder (struct tar_stat_info
*st
,
1385 char const *keyword
,
1387 size_t size
__attribute__((unused
)))
1390 if (decode_num (&u
, arg
, TYPE_MAXIMUM (uid_t
), keyword
))
1391 st
->stat
.st_uid
= u
;
1395 uname_coder (struct tar_stat_info
const *st
, char const *keyword
,
1396 struct xheader
*xhdr
, void const *data
__attribute__ ((unused
)))
1398 code_string (st
->uname
, keyword
, xhdr
);
1402 uname_decoder (struct tar_stat_info
*st
,
1403 char const *keyword
__attribute__((unused
)),
1405 size_t size
__attribute__((unused
)))
1407 decode_string (&st
->uname
, arg
);
1411 sparse_size_coder (struct tar_stat_info
const *st
, char const *keyword
,
1412 struct xheader
*xhdr
, void const *data
)
1414 size_coder (st
, keyword
, xhdr
, data
);
1418 sparse_size_decoder (struct tar_stat_info
*st
,
1419 char const *keyword
,
1421 size_t size
__attribute__((unused
)))
1424 if (decode_num (&u
, arg
, TYPE_MAXIMUM (off_t
), keyword
))
1425 st
->stat
.st_size
= u
;
1429 sparse_numblocks_coder (struct tar_stat_info
const *st
, char const *keyword
,
1430 struct xheader
*xhdr
,
1431 void const *data
__attribute__ ((unused
)))
1433 code_num (st
->sparse_map_avail
, keyword
, xhdr
);
1437 sparse_numblocks_decoder (struct tar_stat_info
*st
,
1438 char const *keyword
,
1440 size_t size
__attribute__((unused
)))
1443 if (decode_num (&u
, arg
, SIZE_MAX
, keyword
))
1445 st
->sparse_map_size
= u
;
1446 st
->sparse_map
= xcalloc (u
, sizeof st
->sparse_map
[0]);
1447 st
->sparse_map_avail
= 0;
1452 sparse_offset_coder (struct tar_stat_info
const *st
, char const *keyword
,
1453 struct xheader
*xhdr
, void const *data
)
1455 size_t const *pi
= data
;
1456 code_num (st
->sparse_map
[*pi
].offset
, keyword
, xhdr
);
1460 sparse_offset_decoder (struct tar_stat_info
*st
,
1461 char const *keyword
,
1463 size_t size
__attribute__((unused
)))
1466 if (decode_num (&u
, arg
, TYPE_MAXIMUM (off_t
), keyword
))
1468 if (st
->sparse_map_avail
< st
->sparse_map_size
)
1469 st
->sparse_map
[st
->sparse_map_avail
].offset
= u
;
1471 ERROR ((0, 0, _("Malformed extended header: excess %s=%s"),
1472 "GNU.sparse.offset", arg
));
1477 sparse_numbytes_coder (struct tar_stat_info
const *st
, char const *keyword
,
1478 struct xheader
*xhdr
, void const *data
)
1480 size_t const *pi
= data
;
1481 code_num (st
->sparse_map
[*pi
].numbytes
, keyword
, xhdr
);
1485 sparse_numbytes_decoder (struct tar_stat_info
*st
,
1486 char const *keyword
,
1488 size_t size
__attribute__((unused
)))
1491 if (decode_num (&u
, arg
, TYPE_MAXIMUM (off_t
), keyword
))
1493 if (st
->sparse_map_avail
< st
->sparse_map_size
)
1494 st
->sparse_map
[st
->sparse_map_avail
++].numbytes
= u
;
1496 ERROR ((0, 0, _("Malformed extended header: excess %s=%s"),
1502 sparse_map_decoder (struct tar_stat_info
*st
,
1503 char const *keyword
,
1505 size_t size
__attribute__((unused
)))
1509 st
->sparse_map_avail
= 0;
1516 if (!ISDIGIT (*arg
))
1518 ERROR ((0, 0, _("Malformed extended header: invalid %s=%s"),
1524 u
= strtoumax (arg
, &delim
, 10);
1528 if (!(u
== e
.offset
&& errno
!= ERANGE
))
1530 out_of_range_header (keyword
, arg
, 0, TYPE_MAXIMUM (off_t
));
1537 if (!(u
== e
.numbytes
&& errno
!= ERANGE
))
1539 out_of_range_header (keyword
, arg
, 0, TYPE_MAXIMUM (off_t
));
1542 if (st
->sparse_map_avail
< st
->sparse_map_size
)
1543 st
->sparse_map
[st
->sparse_map_avail
++] = e
;
1546 ERROR ((0, 0, _("Malformed extended header: excess %s=%s"),
1556 else if (*delim
!= ',')
1559 _("Malformed extended header: invalid %s: unexpected delimiter %c"),
1569 _("Malformed extended header: invalid %s: odd number of values"),
1574 dumpdir_coder (struct tar_stat_info
const *st
, char const *keyword
,
1575 struct xheader
*xhdr
, void const *data
)
1577 xheader_print_n (xhdr
, keyword
, data
, dumpdir_size (data
));
1581 dumpdir_decoder (struct tar_stat_info
*st
,
1582 char const *keyword
__attribute__((unused
)),
1586 st
->dumpdir
= xmalloc (size
);
1587 memcpy (st
->dumpdir
, arg
, size
);
1591 volume_label_coder (struct tar_stat_info
const *st
, char const *keyword
,
1592 struct xheader
*xhdr
, void const *data
)
1594 code_string (data
, keyword
, xhdr
);
1598 volume_label_decoder (struct tar_stat_info
*st
,
1599 char const *keyword
__attribute__((unused
)),
1601 size_t size
__attribute__((unused
)))
1603 decode_string (&volume_label
, arg
);
1607 volume_size_coder (struct tar_stat_info
const *st
, char const *keyword
,
1608 struct xheader
*xhdr
, void const *data
)
1610 off_t
const *v
= data
;
1611 code_num (*v
, keyword
, xhdr
);
1615 volume_size_decoder (struct tar_stat_info
*st
,
1616 char const *keyword
,
1617 char const *arg
, size_t size
)
1620 if (decode_num (&u
, arg
, TYPE_MAXIMUM (uintmax_t), keyword
))
1621 continued_file_size
= u
;
1624 /* FIXME: Merge with volume_size_coder */
1626 volume_offset_coder (struct tar_stat_info
const *st
, char const *keyword
,
1627 struct xheader
*xhdr
, void const *data
)
1629 off_t
const *v
= data
;
1630 code_num (*v
, keyword
, xhdr
);
1634 volume_offset_decoder (struct tar_stat_info
*st
,
1635 char const *keyword
,
1636 char const *arg
, size_t size
)
1639 if (decode_num (&u
, arg
, TYPE_MAXIMUM (uintmax_t), keyword
))
1640 continued_file_offset
= u
;
1644 volume_filename_decoder (struct tar_stat_info
*st
,
1645 char const *keyword
__attribute__((unused
)),
1647 size_t size
__attribute__((unused
)))
1649 decode_string (&continued_file_name
, arg
);
1653 xattr_selinux_coder (struct tar_stat_info
const *st
, char const *keyword
,
1654 struct xheader
*xhdr
, void const *data
)
1656 code_string (st
->cntx_name
, keyword
, xhdr
);
1660 xattr_selinux_decoder (struct tar_stat_info
*st
,
1661 char const *keyword
, char const *arg
, size_t size
)
1663 decode_string (&st
->cntx_name
, arg
);
1667 xattr_acls_a_coder (struct tar_stat_info
const *st
, char const *keyword
,
1668 struct xheader
*xhdr
, void const *data
)
1670 xheader_print_n (xhdr
, keyword
, st
->acls_a_ptr
, st
->acls_a_len
);
1674 xattr_acls_a_decoder (struct tar_stat_info
*st
,
1675 char const *keyword
, char const *arg
, size_t size
)
1677 st
->acls_a_ptr
= xmemdup (arg
, size
+ 1);
1678 st
->acls_a_len
= size
;
1682 xattr_acls_d_coder (struct tar_stat_info
const *st
, char const *keyword
,
1683 struct xheader
*xhdr
, void const *data
)
1685 xheader_print_n (xhdr
, keyword
, st
->acls_d_ptr
, st
->acls_d_len
);
1689 xattr_acls_d_decoder (struct tar_stat_info
*st
,
1690 char const *keyword
, char const *arg
, size_t size
)
1692 st
->acls_d_ptr
= xmemdup (arg
, size
+ 1);
1693 st
->acls_d_len
= size
;
1697 xattr_coder (struct tar_stat_info
const *st
, char const *keyword
,
1698 struct xheader
*xhdr
, void const *data
)
1700 struct xattr_array
*xattr_map
= st
->xattr_map
;
1701 const size_t *off
= data
;
1702 xheader_print_n (xhdr
, keyword
,
1703 xattr_map
[*off
].xval_ptr
, xattr_map
[*off
].xval_len
);
1707 xattr_decoder (struct tar_stat_info
*st
,
1708 char const *keyword
, char const *arg
, size_t size
)
1713 size_t klen_raw
= strlen (keyword
);
1714 xkey
= alloca (klen_raw
+ 1);
1715 memcpy (xkey
, keyword
, klen_raw
+ 1) /* including null-terminating */;
1718 xstr
= alloca (size
+ 1);
1719 memcpy (xstr
, arg
, size
+ 1); /* separator included, for GNU tar '\n' */;
1721 xattr_decode_keyword (xkey
);
1723 xheader_xattr_add (st
, xkey
+ strlen("SCHILY.xattr."), xstr
, size
);
1727 sparse_major_coder (struct tar_stat_info
const *st
, char const *keyword
,
1728 struct xheader
*xhdr
, void const *data
)
1730 code_num (st
->sparse_major
, keyword
, xhdr
);
1734 sparse_major_decoder (struct tar_stat_info
*st
,
1735 char const *keyword
,
1740 if (decode_num (&u
, arg
, TYPE_MAXIMUM (unsigned), keyword
))
1741 st
->sparse_major
= u
;
1745 sparse_minor_coder (struct tar_stat_info
const *st
, char const *keyword
,
1746 struct xheader
*xhdr
, void const *data
)
1748 code_num (st
->sparse_minor
, keyword
, xhdr
);
1752 sparse_minor_decoder (struct tar_stat_info
*st
,
1753 char const *keyword
,
1758 if (decode_num (&u
, arg
, TYPE_MAXIMUM (unsigned), keyword
))
1759 st
->sparse_minor
= u
;
1762 struct xhdr_tab
const xhdr_tab
[] = {
1763 { "atime", atime_coder
, atime_decoder
, 0, false },
1764 { "comment", dummy_coder
, dummy_decoder
, 0, false },
1765 { "charset", dummy_coder
, dummy_decoder
, 0, false },
1766 { "ctime", ctime_coder
, ctime_decoder
, 0, false },
1767 { "gid", gid_coder
, gid_decoder
, 0, false },
1768 { "gname", gname_coder
, gname_decoder
, 0, false },
1769 { "linkpath", linkpath_coder
, linkpath_decoder
, 0, false },
1770 { "mtime", mtime_coder
, mtime_decoder
, 0, false },
1771 { "path", path_coder
, path_decoder
, 0, false },
1772 { "size", size_coder
, size_decoder
, 0, false },
1773 { "uid", uid_coder
, uid_decoder
, 0, false },
1774 { "uname", uname_coder
, uname_decoder
, 0, false },
1776 /* Sparse file handling */
1777 { "GNU.sparse.name", path_coder
, path_decoder
,
1778 XHDR_PROTECTED
, false },
1779 { "GNU.sparse.major", sparse_major_coder
, sparse_major_decoder
,
1780 XHDR_PROTECTED
, false },
1781 { "GNU.sparse.minor", sparse_minor_coder
, sparse_minor_decoder
,
1782 XHDR_PROTECTED
, false },
1783 { "GNU.sparse.realsize", sparse_size_coder
, sparse_size_decoder
,
1784 XHDR_PROTECTED
, false },
1785 { "GNU.sparse.numblocks", sparse_numblocks_coder
, sparse_numblocks_decoder
,
1786 XHDR_PROTECTED
, false },
1788 /* tar 1.14 - 1.15.90 keywords. */
1789 { "GNU.sparse.size", sparse_size_coder
, sparse_size_decoder
,
1790 XHDR_PROTECTED
, false },
1791 /* tar 1.14 - 1.15.1 keywords. Multiple instances of these appeared in 'x'
1792 headers, and each of them was meaningful. It confilcted with POSIX specs,
1793 which requires that "when extended header records conflict, the last one
1794 given in the header shall take precedence." */
1795 { "GNU.sparse.offset", sparse_offset_coder
, sparse_offset_decoder
,
1796 XHDR_PROTECTED
, false },
1797 { "GNU.sparse.numbytes", sparse_numbytes_coder
, sparse_numbytes_decoder
,
1798 XHDR_PROTECTED
, false },
1799 /* tar 1.15.90 keyword, introduced to remove the above-mentioned conflict. */
1800 { "GNU.sparse.map", NULL
/* Unused, see pax_dump_header() */,
1801 sparse_map_decoder
, 0, false },
1803 { "GNU.dumpdir", dumpdir_coder
, dumpdir_decoder
,
1804 XHDR_PROTECTED
, false },
1806 /* Keeps the tape/volume label. May be present only in the global headers.
1807 Equivalent to GNUTYPE_VOLHDR. */
1808 { "GNU.volume.label", volume_label_coder
, volume_label_decoder
,
1809 XHDR_PROTECTED
| XHDR_GLOBAL
, false },
1811 /* These may be present in a first global header of the archive.
1812 They provide the same functionality as GNUTYPE_MULTIVOL header.
1813 The GNU.volume.size keeps the real_s_sizeleft value, which is
1814 otherwise kept in the size field of a multivolume header. The
1815 GNU.volume.offset keeps the offset of the start of this volume,
1816 otherwise kept in oldgnu_header.offset. */
1817 { "GNU.volume.filename", volume_label_coder
, volume_filename_decoder
,
1818 XHDR_PROTECTED
| XHDR_GLOBAL
, false },
1819 { "GNU.volume.size", volume_size_coder
, volume_size_decoder
,
1820 XHDR_PROTECTED
| XHDR_GLOBAL
, false },
1821 { "GNU.volume.offset", volume_offset_coder
, volume_offset_decoder
,
1822 XHDR_PROTECTED
| XHDR_GLOBAL
, false },
1824 /* We get the SELinux value from filecon, so add a namespace for SELinux
1825 instead of storing it in SCHILY.xattr.* (which would be RAW). */
1826 { "RHT.security.selinux",
1827 xattr_selinux_coder
, xattr_selinux_decoder
, 0, false },
1829 /* ACLs, use the star format... */
1830 { "SCHILY.acl.access",
1831 xattr_acls_a_coder
, xattr_acls_a_decoder
, 0, false },
1833 { "SCHILY.acl.default",
1834 xattr_acls_d_coder
, xattr_acls_d_decoder
, 0, false },
1836 /* We are storing all extended attributes using this rule even if some of them
1837 were stored by some previous rule (duplicates) -- we just have to make sure
1838 they are restored *only once* during extraction later on. */
1839 { "SCHILY.xattr", xattr_coder
, xattr_decoder
, 0, true },
1841 { NULL
, NULL
, NULL
, 0, false }