with this program; if not, write to the Free Software Foundation, Inc.,
59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
-#include "system.h"
+#include <system.h>
+#include <fnmatch.h>
#include <hash.h>
#include <quotearg.h>
+#include <stpcpy.h>
#include <xstrtol.h>
#include "common.h"
-#define obstack_chunk_alloc xmalloc
-#define obstack_chunk_free free
-#include <obstack.h>
+#include <fnmatch.h>
-bool xheader_protected_pattern_p (const char *pattern);
-bool xheader_protected_keyword_p (const char *keyword);
+static bool xheader_protected_pattern_p (char const *pattern);
+static bool xheader_protected_keyword_p (char const *keyword);
+static void xheader_set_single_keyword (char *) __attribute__ ((noreturn));
/* Used by xheader_finish() */
static void code_string (char const *string, char const *keyword,
struct xheader *xhdr);
-static void extended_header_init ();
+static void extended_header_init (void);
/* Number of global headers written so far. */
static size_t global_header_count;
/* Template for the name field of a 'g' type header */
static char *globexthdr_name;
-bool
+static bool
xheader_keyword_deleted_p (const char *kw)
{
struct keyword_list *kp;
return false;
}
-bool
+static bool
xheader_keyword_override_p (const char *keyword)
{
struct keyword_list *kp;
return false;
}
-void
+static void
xheader_list_append (struct keyword_list **root, char const *kw,
char const *value)
{
*root = kp;
}
-void
+static void
xheader_list_destroy (struct keyword_list **root)
{
if (root)
*root = NULL;
}
}
-
-
-void
+
+static void
xheader_set_single_keyword (char *kw)
{
USAGE_ERROR ((0, 0, _("Keyword %s is unknown or not yet imlemented"), kw));
}
-void
+static void
xheader_set_keyword_equal (char *kw, char *eq)
{
bool global = true;
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));
+ USAGE_ERROR ((0, 0, _("Pattern %s cannot be used"), quote (p)));
xheader_list_append (&keyword_pattern_list, p, NULL);
}
else if (strcmp (kw, "exthdr.name") == 0)
%d The directory name of the file,
equivalent to the result of the
dirname utility on the translated
- pathname.
+ file name.
%f The filename of the file, equivalent
to the result of the basename
- utility on the translated pathname.
+ utility on the translated file name.
%p The process ID of the pax process.
%% A '%' character. */
size_t len = strlen (fmt);
char *q;
const char *p;
- char *dirname = NULL;
- char *basename = NULL;
+ char *dir = NULL;
+ char *base = NULL;
char pidbuf[64];
char nbuf[64];
-
+
for (p = fmt; *p && (p = strchr (p, '%')); )
{
switch (p[1])
case 'd':
if (st)
{
- dirname = safer_name_suffix (dir_name (st->orig_file_name),
- false);
- len += strlen (dirname) - 1;
+ dir = safer_name_suffix (dir_name (st->orig_file_name), false);
+ len += strlen (dir) - 1;
}
break;
-
+
case 'f':
if (st)
{
- basename = base_name (st->orig_file_name);
- len += strlen (basename) - 1;
+ base = base_name (st->orig_file_name);
+ len += strlen (base) - 1;
}
break;
-
+
case 'p':
to_decimal (getpid (), pidbuf, sizeof pidbuf);
len += strlen (pidbuf) - 1;
break;
-
+
case 'n':
if (allow_n)
{
}
p++;
}
-
+
buf = xmalloc (len + 1);
for (q = buf, p = fmt; *p; )
{
*q++ = *p++;
p++;
break;
-
+
case 'd':
- if (dirname)
- q = stpcpy (q, dirname);
+ if (dir)
+ q = stpcpy (q, dir);
p += 2;
break;
-
+
case 'f':
- if (basename)
- q = stpcpy (q, basename);
+ if (base)
+ q = stpcpy (q, base);
p += 2;
break;
-
+
case 'p':
q = stpcpy (q, pidbuf);
p += 2;
p += 2;
}
/* else fall through */
-
+
default:
*q++ = *p++;
if (*p)
#define GLOBAL_HEADER_TEMPLATE "/GlobalHead.%p.%n"
char *
-xheader_ghdr_name ()
+xheader_ghdr_name (void)
{
if (!globexthdr_name)
{
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)
}
while (size > 0);
xheader_destroy (xhdr);
-}
+}
void
-xheader_write_global ()
+xheader_write_global (void)
{
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);
return NULL;
}
-bool
+static bool
xheader_protected_pattern_p (const char *pattern)
{
struct xhdr_tab const *p;
return false;
}
-bool
+static bool
xheader_protected_keyword_p (const char *keyword)
{
struct xhdr_tab const *p;
if (xheader_keyword_deleted_p (keyword)
|| xheader_keyword_override_p (keyword))
return;
-
+
t = locate_handler (keyword);
if (t)
t->decoder (st, value);
{
run_override_list (keyword_global_override_list, st);
run_override_list (global_header_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, decx, st))
break;
}
void
-xheader_decode_global ()
+xheader_decode_global (void)
{
if (extended_header.size)
{
}
static void
-extended_header_init ()
+extended_header_init (void)
{
if (!extended_header.stk)
{
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 (len > BLOCKSIZE)
len = BLOCKSIZE;
-
+
memcpy (&extended_header.buffer[j], p->buffer, len);
set_next_block_after (p);
}
static void
-dummy_coder (struct tar_stat_info const *st, char const *keyword,
- struct xheader *xhdr, void *data)
+dummy_coder (struct tar_stat_info const *st __attribute__ ((unused)),
+ char const *keyword __attribute__ ((unused)),
+ struct xheader *xhdr __attribute__ ((unused)),
+ void *data __attribute__ ((unused)))
{
}
static void
-dummy_decoder (struct tar_stat_info *st, char const *arg)
+dummy_decoder (struct tar_stat_info *st __attribute__ ((unused)),
+ char const *arg __attribute__ ((unused)))
{
}
static void
atime_coder (struct tar_stat_info const *st, char const *keyword,
- struct xheader *xhdr, void *data)
+ struct xheader *xhdr, void *data __attribute__ ((unused)))
{
code_time (st->stat.st_atime, st->atime_nsec, keyword, xhdr);
}
static void
gid_coder (struct tar_stat_info const *st, char const *keyword,
- struct xheader *xhdr, void *data)
+ struct xheader *xhdr, void *data __attribute__ ((unused)))
{
code_num (st->stat.st_gid, keyword, xhdr);
}
static void
gname_coder (struct tar_stat_info const *st, char const *keyword,
- struct xheader *xhdr, void *data)
+ struct xheader *xhdr, void *data __attribute__ ((unused)))
{
code_string (st->gname, keyword, xhdr);
}
static void
linkpath_coder (struct tar_stat_info const *st, char const *keyword,
- struct xheader *xhdr, void *data)
+ struct xheader *xhdr, void *data __attribute__ ((unused)))
{
code_string (st->link_name, keyword, xhdr);
}
static void
ctime_coder (struct tar_stat_info const *st, char const *keyword,
- struct xheader *xhdr, void *data)
+ struct xheader *xhdr, void *data __attribute__ ((unused)))
{
code_time (st->stat.st_ctime, st->ctime_nsec, keyword, xhdr);
}
static void
mtime_coder (struct tar_stat_info const *st, char const *keyword,
- struct xheader *xhdr, void *data)
+ struct xheader *xhdr, void *data __attribute__ ((unused)))
{
code_time (st->stat.st_mtime, st->mtime_nsec, keyword, xhdr);
}
static void
path_coder (struct tar_stat_info const *st, char const *keyword,
- struct xheader *xhdr, void *data)
+ struct xheader *xhdr, void *data __attribute__ ((unused)))
{
code_string (st->file_name, keyword, xhdr);
}
static void
size_coder (struct tar_stat_info const *st, char const *keyword,
- struct xheader *xhdr, void *data)
+ struct xheader *xhdr, void *data __attribute__ ((unused)))
{
code_num (st->stat.st_size, keyword, xhdr);
}
{
uintmax_t u;
if (xstrtoumax (arg, NULL, 10, &u, "") == LONGINT_OK)
- st->stat.st_size = u;
+ st->archive_file_size = st->stat.st_size = u;
}
static void
uid_coder (struct tar_stat_info const *st, char const *keyword,
- struct xheader *xhdr, void *data)
+ struct xheader *xhdr, void *data __attribute__ ((unused)))
{
code_num (st->stat.st_uid, keyword, xhdr);
}
static void
uname_coder (struct tar_stat_info const *st, char const *keyword,
- struct xheader *xhdr, void *data)
+ struct xheader *xhdr, void *data __attribute__ ((unused)))
{
code_string (st->uname, keyword, xhdr);
}
{
uintmax_t u;
if (xstrtoumax (arg, NULL, 10, &u, "") == LONGINT_OK)
- st->archive_file_size = u;
+ st->stat.st_size = u;
}
static void
sparse_numblocks_coder (struct tar_stat_info const *st, char const *keyword,
- struct xheader *xhdr, void *data)
+ struct xheader *xhdr,
+ void *data __attribute__ ((unused)))
{
code_num (st->sparse_map_avail, keyword, xhdr);
}
{
if (st->sparse_map_avail == st->sparse_map_size)
{
- size_t newsize = st->sparse_map_size *= 2;
+ st->sparse_map_size *= 2;
st->sparse_map = xrealloc (st->sparse_map,
st->sparse_map_size
* sizeof st->sparse_map[0]);
}
struct xhdr_tab const xhdr_tab[] = {
- { "atime", atime_coder, atime_decoder },
- { "comment", dummy_coder, dummy_decoder },
- { "charset", dummy_coder, dummy_decoder },
- { "ctime", ctime_coder, ctime_decoder },
- { "gid", gid_coder, gid_decoder },
- { "gname", gname_coder, gname_decoder },
- { "linkpath", linkpath_coder, linkpath_decoder},
- { "mtime", mtime_coder, mtime_decoder },
- { "path", path_coder, path_decoder },
- { "size", size_coder, size_decoder },
- { "uid", uid_coder, uid_decoder },
- { "uname", uname_coder, uname_decoder },
+ { "atime", atime_coder, atime_decoder, false },
+ { "comment", dummy_coder, dummy_decoder, false },
+ { "charset", dummy_coder, dummy_decoder, false },
+ { "ctime", ctime_coder, ctime_decoder, false },
+ { "gid", gid_coder, gid_decoder, false },
+ { "gname", gname_coder, gname_decoder, false },
+ { "linkpath", linkpath_coder, linkpath_decoder, false },
+ { "mtime", mtime_coder, mtime_decoder, false },
+ { "path", path_coder, path_decoder, false },
+ { "size", size_coder, size_decoder, false },
+ { "uid", uid_coder, uid_decoder, false },
+ { "uname", uname_coder, uname_decoder, false },
/* Sparse file handling */
{ "GNU.sparse.size", sparse_size_coder, sparse_size_decoder, true },
/* The next directory entry actually contains the names of files
that were in the directory at the time the dump was made.
Supersedes GNUTYPE_DUMPDIR header type. */
- { "GNU.dump.name", dump_name_coder, dump_name_decoder },
- { "GNU.dump.status", dump_status_coder, dump_status_decoder },
+ { "GNU.dump.name", dump_name_coder, dump_name_decoder, false },
+ { "GNU.dump.status", dump_status_coder, dump_status_decoder, false },
/* Keeps the tape/volume header. May be present only in the global headers.
Equivalent to GNUTYPE_VOLHDR. */
- { "GNU.volume.header", volume_header_coder, volume_header_decoder },
+ { "GNU.volume.header", volume_header_coder, volume_header_decoder, false },
/* These may be present in a first global header of the archive.
They provide the same functionality as GNUTYPE_MULTIVOL header.
otherwise kept in the size field of a multivolume header. The
GNU.volume.offset keeps the offset of the start of this volume,
otherwise kept in oldgnu_header.offset. */
- { "GNU.volume.size", volume_size_coder, volume_size_decoder },
- { "GNU.volume.offset", volume_offset_coder, volume_offset_decoder },
+ { "GNU.volume.size", volume_size_coder, volume_size_decoder, false },
+ { "GNU.volume.offset", volume_offset_coder, volume_offset_decoder, false },
#endif
- { NULL, NULL, NULL }
+ { NULL, NULL, NULL, false }
};
projects / chaz / tar / blobdiff