1 /* POSIX extended headers for tar.
3 Copyright (C) 2003, 2004 Free Software Foundation, Inc.
5 This program is free software; you can redistribute it and/or modify it
6 under the terms of the GNU General Public License as published by the
7 Free Software Foundation; either version 2, or (at your option) any later
10 This program is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
13 Public License for more details.
15 You should have received a copy of the GNU General Public License along
16 with this program; if not, write to the Free Software Foundation, Inc.,
17 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
28 #define obstack_chunk_alloc xmalloc
29 #define obstack_chunk_free free
34 static bool xheader_protected_pattern_p (char const *pattern);
35 static bool xheader_protected_keyword_p (char const *keyword);
36 static void xheader_set_single_keyword (char *) __attribute__ ((noreturn));
38 /* Used by xheader_finish() */
39 static void code_string (char const *string, char const *keyword,
40 struct xheader *xhdr);
41 static void extended_header_init (void);
43 /* Number of global headers written so far. */
44 static size_t global_header_count;
45 /* FIXME: Possibly it should be reset after changing the volume.
46 POSIX %n specification says that it is expanded to the sequence
47 number of current global header in *the* archive. However, for
48 multi-volume archives this will yield duplicate header names
49 in different volumes, which I'd like to avoid. The best way
50 to solve this would be to use per-archive header count as required
51 by POSIX *and* set globexthdr.name to, say,
52 $TMPDIR/GlobalHead.%p.$NUMVOLUME.%n.
54 However it should wait until buffer.c is finally rewritten */
61 struct keyword_list *next;
67 /* List of keyword patterns set by delete= option */
68 static struct keyword_list *keyword_pattern_list;
70 /* List of keyword/value pairs set by `keyword=value' option */
71 static struct keyword_list *keyword_global_override_list;
73 /* List of keyword/value pairs set by `keyword:=value' option */
74 static struct keyword_list *keyword_override_list;
76 /* List of keyword/value pairs decoded from the last 'g' type header */
77 static struct keyword_list *global_header_override_list;
79 /* Template for the name field of an 'x' type header */
80 static char *exthdr_name;
82 /* Template for the name field of a 'g' type header */
83 static char *globexthdr_name;
86 xheader_keyword_deleted_p (const char *kw)
88 struct keyword_list *kp;
90 for (kp = keyword_pattern_list; kp; kp = kp->next)
91 if (fnmatch (kp->pattern, kw, 0) == 0)
97 xheader_keyword_override_p (const char *keyword)
99 struct keyword_list *kp;
101 for (kp = keyword_override_list; kp; kp = kp->next)
102 if (strcmp (kp->pattern, keyword) == 0)
108 xheader_list_append (struct keyword_list **root, char const *kw,
111 struct keyword_list *kp = xmalloc (sizeof *kp);
112 kp->pattern = xstrdup (kw);
113 kp->value = value ? xstrdup (value) : NULL;
119 xheader_list_destroy (struct keyword_list **root)
123 struct keyword_list *kw = *root;
126 struct keyword_list *next = kw->next;
137 xheader_set_single_keyword (char *kw)
139 USAGE_ERROR ((0, 0, _("Keyword %s is unknown or not yet imlemented"), kw));
143 xheader_set_keyword_equal (char *kw, char *eq)
154 while (p > kw && isspace (*p))
159 for (p = eq + 1; *p && isspace (*p); p++)
162 if (strcmp (kw, "delete") == 0)
164 if (xheader_protected_pattern_p (p))
165 USAGE_ERROR ((0, 0, _("Pattern %s cannot be used"), p));
166 xheader_list_append (&keyword_pattern_list, p, NULL);
168 else if (strcmp (kw, "exthdr.name") == 0)
169 assign_string (&exthdr_name, p);
170 else if (strcmp (kw, "globexthdr.name") == 0)
171 assign_string (&globexthdr_name, p);
174 if (xheader_protected_keyword_p (kw))
175 USAGE_ERROR ((0, 0, _("Keyword %s cannot be overridden"), kw));
177 xheader_list_append (&keyword_global_override_list, kw, p);
179 xheader_list_append (&keyword_override_list, kw, p);
184 xheader_set_option (char *string)
187 for (token = strtok (string, ","); token; token = strtok (NULL, ","))
189 char *p = strchr (token, '=');
191 xheader_set_single_keyword (token);
193 xheader_set_keyword_equal (token, p);
198 to_decimal (uintmax_t value, char *where, size_t size)
205 where[i++] = '0' + value % 10;
208 while (i < size && value);
209 for (j = 0, i--; j < i; j++, i--)
218 string Includes: Replaced By:
219 %d The directory name of the file,
220 equivalent to the result of the
221 dirname utility on the translated
223 %f The filename of the file, equivalent
224 to the result of the basename
225 utility on the translated pathname.
226 %p The process ID of the pax process.
227 %% A '%' character. */
230 xheader_format_name (struct tar_stat_info *st, const char *fmt, bool allow_n)
233 size_t len = strlen (fmt);
241 for (p = fmt; *p && (p = strchr (p, '%')); )
252 dir = safer_name_suffix (dir_name (st->orig_file_name), false);
253 len += strlen (dir) - 1;
260 base = base_name (st->orig_file_name);
261 len += strlen (base) - 1;
266 to_decimal (getpid (), pidbuf, sizeof pidbuf);
267 len += strlen (pidbuf) - 1;
273 to_decimal (global_header_count + 1, pidbuf, sizeof pidbuf);
274 len += strlen (nbuf) - 1;
281 buf = xmalloc (len + 1);
282 for (q = buf, p = fmt; *p; )
301 q = stpcpy (q, base);
306 q = stpcpy (q, pidbuf);
313 q = stpcpy (q, nbuf);
316 /* else fall through */
328 /* Do not allow it to end in a slash */
329 while (q > buf && ISSLASH (q[-1]))
336 xheader_xhdr_name (struct tar_stat_info *st)
339 assign_string (&exthdr_name, "%d/PaxHeaders.%p/%f");
340 return xheader_format_name (st, exthdr_name, false);
343 #define GLOBAL_HEADER_TEMPLATE "/GlobalHead.%p.%n"
346 xheader_ghdr_name (void)
348 if (!globexthdr_name)
351 const char *tmp = getenv ("TMPDIR");
354 len = strlen (tmp) + sizeof (GLOBAL_HEADER_TEMPLATE); /* Includes nul */
355 globexthdr_name = xmalloc (len);
356 strcpy(globexthdr_name, tmp);
357 strcat(globexthdr_name, GLOBAL_HEADER_TEMPLATE);
360 return xheader_format_name (NULL, globexthdr_name, true);
364 xheader_write (char type, char *name, struct xheader *xhdr)
371 header = start_private_header (name, size);
372 header->header.typeflag = type;
374 simple_finish_header (header);
382 header = find_next_block ();
386 memcpy (header->buffer, p, len);
388 memset (header->buffer + len, 0, BLOCKSIZE - len);
391 set_next_block_after (header);
394 xheader_destroy (xhdr);
398 xheader_write_global (void)
401 struct keyword_list *kp;
403 if (!keyword_global_override_list)
406 extended_header_init ();
407 for (kp = keyword_global_override_list; kp; kp = kp->next)
408 code_string (kp->value, kp->pattern, &extended_header);
409 xheader_finish (&extended_header);
410 xheader_write (XGLTYPE, name = xheader_ghdr_name (),
413 global_header_count++;
417 /* General Interface */
422 void (*coder) (struct tar_stat_info const *, char const *,
423 struct xheader *, void *data);
424 void (*decoder) (struct tar_stat_info *, char const *);
428 /* This declaration must be extern, because ISO C99 section 6.9.2
429 prohibits a tentative definition that has both internal linkage and
430 incomplete type. If we made it static, we'd have to declare its
431 size which would be a maintenance pain; if we put its initializer
432 here, we'd need a boatload of forward declarations, which would be
433 even more of a pain. */
434 extern struct xhdr_tab const xhdr_tab[];
436 static struct xhdr_tab const *
437 locate_handler (char const *keyword)
439 struct xhdr_tab const *p;
441 for (p = xhdr_tab; p->keyword; p++)
442 if (strcmp (p->keyword, keyword) == 0)
448 xheader_protected_pattern_p (const char *pattern)
450 struct xhdr_tab const *p;
452 for (p = xhdr_tab; p->keyword; p++)
453 if (p->protect && fnmatch (pattern, p->keyword, 0) == 0)
459 xheader_protected_keyword_p (const char *keyword)
461 struct xhdr_tab const *p;
463 for (p = xhdr_tab; p->keyword; p++)
464 if (p->protect && strcmp (p->keyword, keyword) == 0)
469 /* Decodes a single extended header record. Advances P to the next
471 Returns true on success, false otherwise. */
473 decode_record (char **p,
474 void (*handler) (void *, char const *, char const *),
485 len = strtoul (*p, p, 10);
489 _("Malformed extended header: missing whitespace after the length")));
494 for (;*p < start + len; ++*p)
500 ERROR ((0, 0, _("Malformed extended header: missing equal sign")));
509 handler (data, keyword, *p + 1);
518 run_override_list (struct keyword_list *kp, struct tar_stat_info *st)
520 for (; kp; kp = kp->next)
522 struct xhdr_tab const *t = locate_handler (kp->pattern);
524 t->decoder (st, kp->value);
529 decx (void *data, char const *keyword, char const *value)
531 struct xhdr_tab const *t;
532 struct tar_stat_info *st = data;
534 if (xheader_keyword_deleted_p (keyword)
535 || xheader_keyword_override_p (keyword))
538 t = locate_handler (keyword);
540 t->decoder (st, value);
544 xheader_decode (struct tar_stat_info *st)
546 run_override_list (keyword_global_override_list, st);
547 run_override_list (global_header_override_list, st);
549 if (extended_header.size)
551 char *p = extended_header.buffer + BLOCKSIZE;
552 char *endp = &extended_header.buffer[extended_header.size-1];
555 if (!decode_record (&p, decx, st))
558 run_override_list (keyword_override_list, st);
562 decg (void *data, char const *keyword, char const *value)
564 struct keyword_list **kwl = data;
565 xheader_list_append (kwl, keyword, value);
569 xheader_decode_global (void)
571 if (extended_header.size)
573 char *p = extended_header.buffer + BLOCKSIZE;
574 char *endp = &extended_header.buffer[extended_header.size-1];
576 xheader_list_destroy (&global_header_override_list);
578 if (!decode_record (&p, decg, &global_header_override_list))
584 extended_header_init (void)
586 if (!extended_header.stk)
588 extended_header.stk = xmalloc (sizeof *extended_header.stk);
589 obstack_init (extended_header.stk);
594 xheader_store (char const *keyword, struct tar_stat_info const *st, void *data)
596 struct xhdr_tab const *t;
598 if (extended_header.buffer)
600 t = locate_handler (keyword);
603 if (xheader_keyword_deleted_p (keyword)
604 || xheader_keyword_override_p (keyword))
606 extended_header_init ();
607 t->coder (st, keyword, &extended_header, data);
611 xheader_read (union block *p, size_t size)
616 free (extended_header.buffer);
618 extended_header.size = size;
619 nblocks = (size + BLOCKSIZE - 1) / BLOCKSIZE;
620 extended_header.buffer = xmalloc (size + 1);
629 memcpy (&extended_header.buffer[j], p->buffer, len);
630 set_next_block_after (p);
632 p = find_next_block ();
641 format_uintmax (uintmax_t val, char *buf, size_t s)
648 while ((val /= 10) != 0);
652 char *p = buf + s - 1;
656 *p-- = val % 10 + '0';
658 while ((val /= 10) != 0);
667 xheader_print (struct xheader *xhdr, char const *keyword, char const *value)
669 size_t len = strlen (keyword) + strlen (value) + 3; /* ' ' + '=' + '\n' */
676 n = format_uintmax (len + p, NULL, 0);
680 format_uintmax (len + n, nbuf, n);
681 obstack_grow (xhdr->stk, nbuf, n);
682 obstack_1grow (xhdr->stk, ' ');
683 obstack_grow (xhdr->stk, keyword, strlen (keyword));
684 obstack_1grow (xhdr->stk, '=');
685 obstack_grow (xhdr->stk, value, strlen (value));
686 obstack_1grow (xhdr->stk, '\n');
690 xheader_finish (struct xheader *xhdr)
692 struct keyword_list *kp;
694 for (kp = keyword_override_list; kp; kp = kp->next)
695 code_string (kp->value, kp->pattern, xhdr);
697 obstack_1grow (xhdr->stk, 0);
698 xhdr->buffer = obstack_finish (xhdr->stk);
699 xhdr->size = strlen (xhdr->buffer);
703 xheader_destroy (struct xheader *xhdr)
707 obstack_free (xhdr->stk, NULL);
718 /* Implementations */
720 code_string (char const *string, char const *keyword, struct xheader *xhdr)
723 if (!utf8_convert (true, string, &outstr))
725 /* FIXME: report error */
726 outstr = xstrdup (string);
728 xheader_print (xhdr, keyword, outstr);
733 decode_string (char **string, char const *arg)
740 if (!utf8_convert (false, arg, string))
742 /* FIXME: report error and act accordingly to --pax invalid=UTF-8 */
743 assign_string (string, arg);
748 code_time (time_t t, unsigned long nano,
749 char const *keyword, struct xheader *xhdr)
752 size_t s = format_uintmax (t, NULL, 0);
753 if (s + 11 >= sizeof sbuf)
755 format_uintmax (t, sbuf, s);
757 s += format_uintmax (nano, sbuf + s, 9);
759 xheader_print (xhdr, keyword, sbuf);
763 decode_time (char const *arg, time_t *secs, unsigned long *nsecs)
767 if (xstrtoumax (arg, &p, 10, &u, "") == LONGINT_OK)
770 if (*p == '.' && xstrtoumax (p+1, NULL, 10, &u, "") == LONGINT_OK)
776 code_num (uintmax_t value, char const *keyword, struct xheader *xhdr)
779 size_t s = format_uintmax (value, NULL, 0);
780 format_uintmax (value, sbuf, s);
782 xheader_print (xhdr, keyword, sbuf);
786 dummy_coder (struct tar_stat_info const *st __attribute__ ((unused)),
787 char const *keyword __attribute__ ((unused)),
788 struct xheader *xhdr __attribute__ ((unused)),
789 void *data __attribute__ ((unused)))
794 dummy_decoder (struct tar_stat_info *st __attribute__ ((unused)),
795 char const *arg __attribute__ ((unused)))
800 atime_coder (struct tar_stat_info const *st, char const *keyword,
801 struct xheader *xhdr, void *data __attribute__ ((unused)))
803 code_time (st->stat.st_atime, st->atime_nsec, keyword, xhdr);
807 atime_decoder (struct tar_stat_info *st, char const *arg)
809 decode_time (arg, &st->stat.st_atime, &st->atime_nsec);
813 gid_coder (struct tar_stat_info const *st, char const *keyword,
814 struct xheader *xhdr, void *data __attribute__ ((unused)))
816 code_num (st->stat.st_gid, keyword, xhdr);
820 gid_decoder (struct tar_stat_info *st, char const *arg)
823 if (xstrtoumax (arg, NULL, 10, &u, "") == LONGINT_OK)
828 gname_coder (struct tar_stat_info const *st, char const *keyword,
829 struct xheader *xhdr, void *data __attribute__ ((unused)))
831 code_string (st->gname, keyword, xhdr);
835 gname_decoder (struct tar_stat_info *st, char const *arg)
837 decode_string (&st->gname, arg);
841 linkpath_coder (struct tar_stat_info const *st, char const *keyword,
842 struct xheader *xhdr, void *data __attribute__ ((unused)))
844 code_string (st->link_name, keyword, xhdr);
848 linkpath_decoder (struct tar_stat_info *st, char const *arg)
850 decode_string (&st->link_name, arg);
854 ctime_coder (struct tar_stat_info const *st, char const *keyword,
855 struct xheader *xhdr, void *data __attribute__ ((unused)))
857 code_time (st->stat.st_ctime, st->ctime_nsec, keyword, xhdr);
861 ctime_decoder (struct tar_stat_info *st, char const *arg)
863 decode_time (arg, &st->stat.st_ctime, &st->ctime_nsec);
867 mtime_coder (struct tar_stat_info const *st, char const *keyword,
868 struct xheader *xhdr, void *data __attribute__ ((unused)))
870 code_time (st->stat.st_mtime, st->mtime_nsec, keyword, xhdr);
874 mtime_decoder (struct tar_stat_info *st, char const *arg)
876 decode_time (arg, &st->stat.st_mtime, &st->mtime_nsec);
880 path_coder (struct tar_stat_info const *st, char const *keyword,
881 struct xheader *xhdr, void *data __attribute__ ((unused)))
883 code_string (st->file_name, keyword, xhdr);
887 path_decoder (struct tar_stat_info *st, char const *arg)
889 decode_string (&st->orig_file_name, arg);
890 decode_string (&st->file_name, arg);
891 st->had_trailing_slash = strip_trailing_slashes (st->file_name);
895 size_coder (struct tar_stat_info const *st, char const *keyword,
896 struct xheader *xhdr, void *data __attribute__ ((unused)))
898 code_num (st->stat.st_size, keyword, xhdr);
902 size_decoder (struct tar_stat_info *st, char const *arg)
905 if (xstrtoumax (arg, NULL, 10, &u, "") == LONGINT_OK)
906 st->archive_file_size = st->stat.st_size = u;
910 uid_coder (struct tar_stat_info const *st, char const *keyword,
911 struct xheader *xhdr, void *data __attribute__ ((unused)))
913 code_num (st->stat.st_uid, keyword, xhdr);
917 uid_decoder (struct tar_stat_info *st, char const *arg)
920 if (xstrtoumax (arg, NULL, 10, &u, "") == LONGINT_OK)
925 uname_coder (struct tar_stat_info const *st, char const *keyword,
926 struct xheader *xhdr, void *data __attribute__ ((unused)))
928 code_string (st->uname, keyword, xhdr);
932 uname_decoder (struct tar_stat_info *st, char const *arg)
934 decode_string (&st->uname, arg);
938 sparse_size_coder (struct tar_stat_info const *st, char const *keyword,
939 struct xheader *xhdr, void *data)
941 size_coder (st, keyword, xhdr, data);
945 sparse_size_decoder (struct tar_stat_info *st, char const *arg)
948 if (xstrtoumax (arg, NULL, 10, &u, "") == LONGINT_OK)
949 st->stat.st_size = u;
953 sparse_numblocks_coder (struct tar_stat_info const *st, char const *keyword,
954 struct xheader *xhdr,
955 void *data __attribute__ ((unused)))
957 code_num (st->sparse_map_avail, keyword, xhdr);
961 sparse_numblocks_decoder (struct tar_stat_info *st, char const *arg)
964 if (xstrtoumax (arg, NULL, 10, &u, "") == LONGINT_OK)
966 st->sparse_map_size = u;
967 st->sparse_map = calloc(st->sparse_map_size, sizeof(st->sparse_map[0]));
968 st->sparse_map_avail = 0;
973 sparse_offset_coder (struct tar_stat_info const *st, char const *keyword,
974 struct xheader *xhdr, void *data)
976 size_t i = *(size_t*)data;
977 code_num (st->sparse_map[i].offset, keyword, xhdr);
981 sparse_offset_decoder (struct tar_stat_info *st, char const *arg)
984 if (xstrtoumax (arg, NULL, 10, &u, "") == LONGINT_OK)
985 st->sparse_map[st->sparse_map_avail].offset = u;
989 sparse_numbytes_coder (struct tar_stat_info const *st, char const *keyword,
990 struct xheader *xhdr, void *data)
992 size_t i = *(size_t*)data;
993 code_num (st->sparse_map[i].numbytes, keyword, xhdr);
997 sparse_numbytes_decoder (struct tar_stat_info *st, char const *arg)
1000 if (xstrtoumax (arg, NULL, 10, &u, "") == LONGINT_OK)
1002 if (st->sparse_map_avail == st->sparse_map_size)
1004 st->sparse_map_size *= 2;
1005 st->sparse_map = xrealloc (st->sparse_map,
1007 * sizeof st->sparse_map[0]);
1009 st->sparse_map[st->sparse_map_avail++].numbytes = u;
1013 struct xhdr_tab const xhdr_tab[] = {
1014 { "atime", atime_coder, atime_decoder, false },
1015 { "comment", dummy_coder, dummy_decoder, false },
1016 { "charset", dummy_coder, dummy_decoder, false },
1017 { "ctime", ctime_coder, ctime_decoder, false },
1018 { "gid", gid_coder, gid_decoder, false },
1019 { "gname", gname_coder, gname_decoder, false },
1020 { "linkpath", linkpath_coder, linkpath_decoder, false },
1021 { "mtime", mtime_coder, mtime_decoder, false },
1022 { "path", path_coder, path_decoder, false },
1023 { "size", size_coder, size_decoder, false },
1024 { "uid", uid_coder, uid_decoder, false },
1025 { "uname", uname_coder, uname_decoder, false },
1027 /* Sparse file handling */
1028 { "GNU.sparse.size", sparse_size_coder, sparse_size_decoder, true },
1029 { "GNU.sparse.numblocks", sparse_numblocks_coder, sparse_numblocks_decoder,
1031 { "GNU.sparse.offset", sparse_offset_coder, sparse_offset_decoder,
1033 { "GNU.sparse.numbytes", sparse_numbytes_coder, sparse_numbytes_decoder,
1036 #if 0 /* GNU private keywords (not yet implemented) */
1038 /* The next directory entry actually contains the names of files
1039 that were in the directory at the time the dump was made.
1040 Supersedes GNUTYPE_DUMPDIR header type. */
1041 { "GNU.dump.name", dump_name_coder, dump_name_decoder, false },
1042 { "GNU.dump.status", dump_status_coder, dump_status_decoder, false },
1044 /* Keeps the tape/volume header. May be present only in the global headers.
1045 Equivalent to GNUTYPE_VOLHDR. */
1046 { "GNU.volume.header", volume_header_coder, volume_header_decoder, false },
1048 /* These may be present in a first global header of the archive.
1049 They provide the same functionality as GNUTYPE_MULTIVOL header.
1050 The GNU.volume.size keeps the real_s_sizeleft value, which is
1051 otherwise kept in the size field of a multivolume header. The
1052 GNU.volume.offset keeps the offset of the start of this volume,
1053 otherwise kept in oldgnu_header.offset. */
1054 { "GNU.volume.size", volume_size_coder, volume_size_decoder, false },
1055 { "GNU.volume.offset", volume_offset_coder, volume_offset_decoder, false },
1058 { NULL, NULL, NULL, false }