X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=src%2Fxheader.c;h=129ce8456fc324cac1f77c6224b7a26bfa23cd3b;hb=d46025b23c5bbe31902ba4e902312ce8fe05ed63;hp=af2c4be0d4135e4f91d5208c36c390bc534d488e;hpb=3710b34c7e5a5b84a5018176f23484bf6a28a16c;p=chaz%2Ftar

diff --git a/src/xheader.c b/src/xheader.c
index af2c4be..129ce84 100644
--- a/src/xheader.c
+++ b/src/xheader.c
@@ -1,6 +1,6 @@
-/* POSIX extended and STAR headers.
+/* POSIX extended headers for tar.
 
-   Copyright (C) 2003 Free Software Foundation, Inc.
+   Copyright (C) 2003, 2004 Free Software Foundation, Inc.
 
    This program is free software; you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by the
@@ -28,6 +28,345 @@
 #define obstack_chunk_free free
 #include <obstack.h>
 
+bool xheader_protected_pattern_p (const char *pattern);
+bool xheader_protected_keyword_p (const char *keyword);
+
+/* Used by xheader_finish() */
+static void code_string (char const *string, char const *keyword,
+			 struct xheader *xhdr);
+static void extended_header_init ();
+
+/* Number of global headers written so far. */
+static size_t global_header_count;
+/* FIXME: Possibly it should be reset after changing the volume.
+   POSIX %n specification says that it is expanded to the sequence
+   number of current global header in *the* archive. However, for
+   multi-volume archives this will yield duplicate header names
+   in different volumes, which I'd like to avoid. The best way
+   to solve this would be to use per-archive header count as required
+   by POSIX *and* set globexthdr.name to, say,
+   $TMPDIR/GlobalHead.%p.$NUMVOLUME.%n.
+
+   However it should wait until buffer.c is finally rewritten */
+
+
+/* Keyword options */
+
+struct keyword_list
+{
+  struct keyword_list *next;
+  char *pattern;
+  char *value;
+};
+
+
+/* List of keyword patterns set by delete= option */
+static struct keyword_list *keyword_pattern_list;
+/* List of keyword/value pairs set by `keyword=value' option */
+static struct keyword_list *keyword_global_override_list;
+/* List of keyword/value pairs set by `keyword:=value' option */
+static struct keyword_list *keyword_override_list;
+/* Template for the name field of an 'x' type header */
+static char *exthdr_name;
+/* Template for the name field of a 'g' type header */
+static char *globexthdr_name;
+
+bool
+xheader_keyword_deleted_p (const char *kw)
+{
+  struct keyword_list *kp;
+
+  for (kp = keyword_pattern_list; kp; kp = kp->next)
+    if (fnmatch (kp->pattern, kw, 0) == 0)
+      return true;
+  return false;
+}
+
+bool
+xheader_keyword_override_p (const char *keyword)
+{
+  struct keyword_list *kp;
+
+  for (kp = keyword_override_list; kp; kp = kp->next)
+    if (strcmp (kp->pattern, keyword) == 0)
+      return true;
+  return false;
+}
+
+void
+xheader_list_append (struct keyword_list **root, char *kw, char *value)
+{
+  struct keyword_list *kp = xmalloc (sizeof *kp);
+  kp->pattern = xstrdup (kw);
+  kp->value = value ? xstrdup (value) : NULL;
+  kp->next = *root;
+  *root = kp;
+}
+
+void
+xheader_set_single_keyword (char *kw)
+{
+  USAGE_ERROR ((0, 0, "Keyword %s is unknown or not yet imlemented", kw));
+}
+
+void
+xheader_set_keyword_equal (char *kw, char *eq)
+{
+  bool global = true;
+  char *p = eq;
+
+  if (eq[-1] == ':')
+    {
+      p--;
+      global = false;
+    }
+
+  while (p > kw && isspace (*p))
+    p--;
+
+  *p = 0;
+
+  for (p = eq + 1; *p && isspace (*p); p++)
+    ;
+  
+  if (strcmp (kw, "delete") == 0)
+    {
+      if (xheader_protected_pattern_p (p))
+	USAGE_ERROR ((0, 0, "Pattern %s cannot be used", p));
+      xheader_list_append (&keyword_pattern_list, p, NULL);
+    }
+  else if (strcmp (kw, "exthdr.name") == 0)
+    assign_string (&exthdr_name, p);
+  else if (strcmp (kw, "globexthdr.name") == 0)
+    assign_string (&globexthdr_name, p);
+  else
+    {
+      if (xheader_protected_keyword_p (kw))
+	USAGE_ERROR ((0, 0, "Keyword %s cannot be overridden", kw));
+      if (global)
+	xheader_list_append (&keyword_global_override_list, kw, p);
+      else
+	xheader_list_append (&keyword_override_list, kw, p);
+    }
+}
+
+void
+xheader_set_option (char *string)
+{
+  char *token;
+  for (token = strtok (string, ","); token; token = strtok (NULL, ","))
+    {
+      char *p = strchr (token, '=');
+      if (!p)
+	xheader_set_single_keyword (token);
+      else
+	xheader_set_keyword_equal (token, p);
+    }
+}
+
+/*
+    string Includes:          Replaced By:
+     %d                       The directory name of the file,
+                              equivalent to the result of the
+                              dirname utility on the translated
+                              pathname.
+     %f                       The filename of the file, equivalent
+                              to the result of the basename
+                              utility on the translated pathname.
+     %p                       The process ID of the pax process.
+     %%                       A '%' character. */
+
+static char *
+xheader_format_name (struct tar_stat_info *st, const char *fmt, bool allow_n)
+{
+  char *buf;
+  size_t len = strlen (fmt);
+  char *q;
+  const char *p;
+  char *dirname = NULL;
+  char *basename = NULL;
+  char pidbuf[64];
+  char nbuf[64];
+  
+  for (p = fmt; *p && (p = strchr (p, '%')); )
+    {
+      switch (p[1])
+	{
+	case '%':
+	  len--;
+	  break;
+
+	case 'd':
+	  if (st)
+	    {
+	      dirname = safer_name_suffix (dir_name (st->orig_file_name),
+					   false);
+	      len += strlen (dirname) - 1;
+	    }
+	  break;
+	      
+	case 'f':
+	  if (st)
+	    {
+	      basename = base_name (st->orig_file_name);
+	      len += strlen (basename) - 1;
+	    }
+	  break;
+	      
+	case 'p':
+	  snprintf (pidbuf, sizeof pidbuf, "%lu",
+		    (unsigned long) getpid ());
+	  len += strlen (pidbuf) - 1;
+	  break;
+	  
+	case 'n':
+	  if (allow_n)
+	    {
+	      snprintf (nbuf, sizeof nbuf, "%lu",
+			(unsigned long) global_header_count + 1);
+	      len += strlen (nbuf) - 1;
+	    }
+	  break;
+	}
+      p++;
+    }
+  
+  buf = xmalloc (len + 1);
+  for (q = buf, p = fmt; *p; )
+    {
+      if (*p == '%')
+	{
+	  switch (p[1])
+	    {
+	    case '%':
+	      *q++ = *p++;
+	      p++;
+	      break;
+	      
+	    case 'd':
+	      if (dirname)
+		q = stpcpy (q, dirname);
+	      p += 2;
+	      break;
+	      
+	    case 'f':
+	      if (basename)
+		q = stpcpy (q, basename);
+	      p += 2;
+	      break;
+	      
+	    case 'p':
+	      q = stpcpy (q, pidbuf);
+	      p += 2;
+	      break;
+
+	    case 'n':
+	      if (allow_n)
+		{
+		  q = stpcpy (q, nbuf);
+		  p += 2;
+		}
+	      /* else fall through */
+	      
+	    default:
+	      *q++ = *p++;
+	      if (*p)
+		*q++ = *p++;
+	    }
+	}
+      else
+	*q++ = *p++;
+    }
+
+  /* Do not allow it to end in a slash */
+  while (q > buf && ISSLASH (q[-1]))
+    q--;
+  *q = 0;
+  return buf;
+}
+
+char *
+xheader_xhdr_name (struct tar_stat_info *st)
+{
+  if (!exthdr_name)
+    assign_string (&exthdr_name, "%d/PaxHeaders.%p/%f");
+  return xheader_format_name (st, exthdr_name, false);
+}
+
+#define GLOBAL_HEADER_TEMPLATE "/GlobalHead.%p.%n"
+
+char *
+xheader_ghdr_name ()
+{
+  if (!globexthdr_name)
+    {
+      size_t len;
+      const char *tmp = getenv ("TMPDIR");
+      if (!tmp)
+	tmp = "/tmp";
+      len = strlen (tmp) + sizeof (GLOBAL_HEADER_TEMPLATE); /* Includes nul */
+      globexthdr_name = xmalloc (len);
+      strcpy(globexthdr_name, tmp);
+      strcat(globexthdr_name, GLOBAL_HEADER_TEMPLATE);
+    }
+
+  return xheader_format_name (NULL, globexthdr_name, true);
+}
+
+void
+xheader_write (char type, char *name, struct xheader *xhdr)
+{
+  union block *header;
+  size_t size;
+  char *p;
+  
+  size = xhdr->size;
+  header = start_private_header (name, size);
+  header->header.typeflag = type;
+
+  simple_finish_header (header);
+
+  p = xhdr->buffer;
+  
+  do
+    {
+      size_t len;
+      
+      header = find_next_block ();
+      len = BLOCKSIZE;
+      if (len > size)
+	len = size;
+      memcpy (header->buffer, p, len);
+      if (len < BLOCKSIZE)
+	memset (header->buffer + len, 0, BLOCKSIZE - len);
+      p += len;
+      size -= len;
+      set_next_block_after (header);
+    }
+  while (size > 0);
+  xheader_destroy (xhdr);
+}  
+
+void
+xheader_write_global ()
+{
+  char *name;
+  struct keyword_list *kp;
+
+  if (!keyword_global_override_list)
+    return;
+  
+  extended_header_init ();
+  for (kp = keyword_global_override_list; kp; kp = kp->next)
+    code_string (kp->value, kp->pattern, &extended_header);
+  xheader_finish (&extended_header);
+  xheader_write (XGLTYPE, name = xheader_ghdr_name (),
+		 &extended_header);
+  free (name);
+  global_header_count++;
+}
+
+
 /* General Interface */
 
 struct xhdr_tab
@@ -36,6 +375,7 @@ struct xhdr_tab
   void (*coder) (struct tar_stat_info const *, char const *,
 		 struct xheader *, void *data);
   void (*decoder) (struct tar_stat_info *, char const *);
+  bool protect;
 };
 
 /* This declaration must be extern, because ISO C99 section 6.9.2
@@ -57,6 +397,28 @@ locate_handler (char const *keyword)
   return NULL;
 }
 
+bool
+xheader_protected_pattern_p (const char *pattern)
+{
+  struct xhdr_tab const *p;
+
+  for (p = xhdr_tab; p->keyword; p++)
+    if (p->protect && fnmatch (pattern, p->keyword, 0) == 0)
+      return true;
+  return false;
+}
+
+bool
+xheader_protected_keyword_p (const char *keyword)
+{
+  struct xhdr_tab const *p;
+
+  for (p = xhdr_tab; p->keyword; p++)
+    if (p->protect && strcmp (p->keyword, keyword) == 0)
+      return true;
+  return false;
+}
+
 /* Decodes a single extended header record. Advances P to the next
    record.
    Returns true on success, false otherwise. */
@@ -75,7 +437,8 @@ decode_record (char **p, struct tar_stat_info *st)
   len = strtoul (*p, p, 10);
   if (**p != ' ')
     {
-      ERROR ((0, 0, _("Malformed extended header: missing whitespace after the length")));
+      ERROR ((0, 0,
+       _("Malformed extended header: missing whitespace after the length")));
       return false;
     }
 
@@ -92,6 +455,10 @@ decode_record (char **p, struct tar_stat_info *st)
 
   eqp = *p;
   **p = 0;
+
+  if (xheader_keyword_deleted_p (keyword)
+      || xheader_keyword_override_p (keyword))
+    return true;
   t = locate_handler (keyword);
   if (t)
     {
@@ -110,32 +477,59 @@ decode_record (char **p, struct tar_stat_info *st)
   return true;
 }
 
+static void
+run_override_list (struct keyword_list *kp, struct tar_stat_info *st)
+{
+  for (; kp; kp = kp->next)
+    {
+      struct xhdr_tab const *t = locate_handler (kp->pattern);
+      if (t)
+	t->decoder (st, kp->value);
+    }
+}
+
 void
 xheader_decode (struct tar_stat_info *st)
 {
-  char *p = extended_header.buffer + BLOCKSIZE;
-  char *endp = &extended_header.buffer[extended_header.size-1];
+  run_override_list (keyword_global_override_list, st);
+  
+  if (extended_header.size)
+    {
+      char *p = extended_header.buffer + BLOCKSIZE;
+      char *endp = &extended_header.buffer[extended_header.size-1];
+      
+      while (p < endp)
+	if (!decode_record (&p, st))
+	  break;
+    }
+  run_override_list (keyword_override_list, st);
+}
 
-  while (p < endp)
-    if (!decode_record (&p, st))
-      break;
+static void
+extended_header_init ()
+{
+  if (!extended_header.stk)
+    {
+      extended_header.stk = xmalloc (sizeof *extended_header.stk);
+      obstack_init (extended_header.stk);
+    }
 }
 
 void
 xheader_store (char const *keyword, struct tar_stat_info const *st, void *data)
 {
   struct xhdr_tab const *t;
-
+  char *value;
+  
   if (extended_header.buffer)
     return;
   t = locate_handler (keyword);
   if (!t)
     return;
-  if (!extended_header.stk)
-    {
-      extended_header.stk = xmalloc (sizeof *extended_header.stk);
-      obstack_init (extended_header.stk);
-    }
+  if (xheader_keyword_deleted_p (keyword)
+      || xheader_keyword_override_p (keyword))
+    return;
+  extended_header_init ();
   t->coder (st, keyword, &extended_header, data);
 }
 
@@ -221,6 +615,11 @@ xheader_print (struct xheader *xhdr, char const *keyword, char const *value)
 void
 xheader_finish (struct xheader *xhdr)
 {
+  struct keyword_list *kp;
+
+  for (kp = keyword_override_list; kp; kp = kp->next)
+    code_string (kp->value, kp->pattern, xhdr);
+
   obstack_1grow (xhdr->stk, 0);
   xhdr->buffer = obstack_finish (xhdr->stk);
   xhdr->size = strlen (xhdr->buffer);
@@ -526,10 +925,13 @@ struct xhdr_tab const xhdr_tab[] = {
   { "uname",	uname_coder,	uname_decoder	},
 
   /* Sparse file handling */
-  { "GNU.sparse.size",       sparse_size_coder, sparse_size_decoder },
-  { "GNU.sparse.numblocks",  sparse_numblocks_coder, sparse_numblocks_decoder },
-  { "GNU.sparse.offset",     sparse_offset_coder, sparse_offset_decoder },
-  { "GNU.sparse.numbytes",   sparse_numbytes_coder, sparse_numbytes_decoder },
+  { "GNU.sparse.size",       sparse_size_coder, sparse_size_decoder, true },
+  { "GNU.sparse.numblocks",  sparse_numblocks_coder, sparse_numblocks_decoder,
+    true },
+  { "GNU.sparse.offset",     sparse_offset_coder, sparse_offset_decoder,
+    true },
+  { "GNU.sparse.numbytes",   sparse_numbytes_coder, sparse_numbytes_decoder,
+    true },
 
 #if 0 /* GNU private keywords (not yet implemented) */