Add unfinished gpgtar.

Collected changes and ports of bug fixes from stable.

7 files changed, 1744 insertions, 10 deletions

diff --git a/tools/ChangeLog b/tools/ChangeLog
index 76b42763a..c1206d591 100644
--- a/tools/ChangeLog
+++ b/tools/ChangeLog
@@ -1,3 +1,11 @@
+2010-06-07  Werner Koch  <[email protected]>
+
+	* gpgtar.c, gpgtar.h, gpgtar-list.c, gpgtar-create.c
+	* gpgtar-extract.c: New.
+	* Makefile.am (commonpth_libs): New.
+	(gpgtar_SOURCES, gpgtar_CFLAGS, gpgtar_LDADD): New.
+	(bin_PROGRAMS) [!W32CE]: Add gpgtar.
+
 2010-04-20  Marcus Brinkmann  <[email protected]>
 
 	* gpgconf-comp.c (option_check_validity): Use dummy variables to
@@ -1104,7 +1112,7 @@
 
 
  Copyright 2003, 2004, 2005, 2006, 2007, 2008,
-	   2009 Free Software Foundation, Inc.
+	   2009, 2010 Free Software Foundation, Inc.
 
  This file is free software; as a special exception the author gives
  unlimited permission to copy and/or distribute it, with or without
diff --git a/tools/Makefile.am b/tools/Makefile.am
index 5c3766bcd..fc9725a72 100644
--- a/tools/Makefile.am
+++ b/tools/Makefile.am
@@ -42,13 +42,19 @@ else
   symcryptrun =
 endif
 
+if BUILD_GPGTAR
+  gpgtar = gpgtar
+else
+  gpgtar =
+endif
+
 # Fixme: We should remove the gpgkey2ssh tool.
 bin_PROGRAMS = gpgconf gpg-connect-agent ${symcryptrun}
 if !HAVE_W32_SYSTEM
 bin_PROGRAMS += watchgnupg gpgparsemail
 endif
 if !HAVE_W32CE_SYSTEM
-bin_PROGRAMS += gpgkey2ssh
+bin_PROGRAMS += gpgkey2ssh ${gpgtar}
 endif
 
 if !DISABLE_REGEX
@@ -60,6 +66,7 @@ noinst_PROGRAMS = clean-sat mk-tdata make-dns-cert gpgsplit
 endif
 
 common_libs = $(libcommon) ../gl/libgnu.a
+commonpth_libs = $(libcommonpth) ../gl/libgnu.a
 if HAVE_W32CE_SYSTEM
 pwquery_libs = 
 else
@@ -114,14 +121,15 @@ gpg_check_pattern_LDADD = $(common_libs) $(LIBGCRYPT_LIBS) $(GPG_ERROR_LIBS) \
                           $(LIBINTL) $(LIBICONV) $(W32SOCKLIBS)
 endif
 
-#gpgtar_SOURCES = \
-#	gpgtar.c gpgtar.h \
-#	gpgtar-create.c \
-#	gpgtar-extract.c \
-#	gpgtar-list.c \
-#	no-libgcrypt.c
-#gpgtar_LDADD = $(common_libs)
-#
+gpgtar_SOURCES = \
+	gpgtar.c gpgtar.h \
+	gpgtar-create.c \
+	gpgtar-extract.c \
+	gpgtar-list.c \
+	no-libgcrypt.c
+gpgtar_CFLAGS = $(GPG_ERROR_CFLAGS) $(PTH_CFLAGS)
+gpgtar_LDADD = $(commonpth_libs) $(PTH_LIBS) $(GPG_ERROR_LIBS)
+
 
 # Make sure that all libs are build before we use them.  This is
 # important for things like make -j2.
diff --git a/tools/gpgtar-create.c b/tools/gpgtar-create.c
new file mode 100644
index 000000000..c7a75f90f
--- /dev/null
+++ b/tools/gpgtar-create.c
@@ -0,0 +1,643 @@
+/* gpgtar-create.c - Create a TAR archive
+ * Copyright (C) 2010 Free Software Foundation, Inc.
+ *
+ * This file is part of GnuPG.
+ *
+ * GnuPG is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * GnuPG is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <config.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <dirent.h>
+/* #ifdef HAVE_W32_SYSTEM */
+/* # define WIN32_LEAN_AND_MEAN */
+/* # include <windows.h> */
+/* #else /\*!HAVE_W32_SYSTEM*\/ */
+# include <unistd.h>
+# include <pwd.h>
+# include <grp.h>
+/* #endif /\*!HAVE_W32_SYSTEM*\/ */
+#include <assert.h>
+
+#include "i18n.h"
+#include "../common/sysutils.h"
+#include "gpgtar.h"
+
+#ifndef HAVE_LSTAT
+#define lstat(a,b) stat ((a), (b))
+#endif
+
+
+/* Object to control the file scanning.  */
+struct scanctrl_s;
+typedef struct scanctrl_s *scanctrl_t;
+struct scanctrl_s
+{
+  tar_header_t flist;
+  tar_header_t *flist_tail;
+  int nestlevel;
+};
+
+
+
+
+/* Given a fresh header object HDR with only the name field set, try
+   to gather all available info.  */
+static gpg_error_t
+fillup_entry (tar_header_t hdr)
+{
+  gpg_error_t err;
+  struct stat sbuf;
+
+  if (lstat (hdr->name, &sbuf))
+    {
+      err = gpg_error_from_syserror ();
+      log_error ("error stat-ing `%s': %s\n", hdr->name, gpg_strerror (err));
+      return err;
+    }
+  
+  if (S_ISREG (sbuf.st_mode))
+    hdr->typeflag = TF_REGULAR;
+  else if (S_ISDIR (sbuf.st_mode))
+    hdr->typeflag = TF_DIRECTORY;
+  else if (S_ISCHR (sbuf.st_mode))
+    hdr->typeflag = TF_CHARDEV;
+  else if (S_ISBLK (sbuf.st_mode))
+    hdr->typeflag = TF_BLOCKDEV;
+  else if (S_ISFIFO (sbuf.st_mode))
+    hdr->typeflag = TF_FIFO;
+  else if (S_ISLNK (sbuf.st_mode))
+    hdr->typeflag = TF_SYMLINK;
+  else 
+    hdr->typeflag = TF_NOTSUP;
+
+  /* FIXME: Save DEV and INO? */
+
+  /* Set the USTAR defined mode bits using the system macros.  */
+  if (sbuf.st_mode & S_IRUSR)
+    hdr->mode |= 0400;
+  if (sbuf.st_mode & S_IWUSR)
+    hdr->mode |= 0200;
+  if (sbuf.st_mode & S_IXUSR)
+    hdr->mode |= 0100;
+  if (sbuf.st_mode & S_IRGRP)
+    hdr->mode |= 0040;
+  if (sbuf.st_mode & S_IWGRP)
+    hdr->mode |= 0020;
+  if (sbuf.st_mode & S_IXGRP)
+    hdr->mode |= 0010;
+  if (sbuf.st_mode & S_IROTH)
+    hdr->mode |= 0004;
+  if (sbuf.st_mode & S_IWOTH)
+    hdr->mode |= 0002;
+  if (sbuf.st_mode & S_IXOTH)
+    hdr->mode |= 0001;
+#ifdef S_IXUID
+  if (sbuf.st_mode & S_IXUID)
+    hdr->mode |= 04000;
+#endif
+#ifdef S_IXGID
+  if (sbuf.st_mode & S_IXGID)
+    hdr->mode |= 02000;
+#endif
+#ifdef S_ISVTX
+  if (sbuf.st_mode & S_ISVTX)
+    hdr->mode |= 01000;
+#endif
+
+  hdr->nlink = sbuf.st_nlink;
+
+  hdr->uid = sbuf.st_uid;
+  hdr->gid = sbuf.st_gid;
+
+  /* Only set the size for a regular file.  */
+  if (hdr->typeflag == TF_REGULAR)
+    hdr->size = sbuf.st_size;
+
+  hdr->mtime = sbuf.st_mtime;
+  
+
+  return 0;
+}
+
+
+
+static gpg_error_t
+add_entry (const char *dname, size_t dnamelen, struct dirent *de,
+           scanctrl_t scanctrl)
+{
+  gpg_error_t err;
+  tar_header_t hdr;
+  char *p;
+
+  assert (dnamelen);
+
+  hdr = xtrycalloc (1, sizeof *hdr + dnamelen + 1
+                    + (de? strlen (de->d_name) : 0));
+  if (!hdr)
+    {
+      err = gpg_error_from_syserror ();
+      log_error (_("error reading directory `%s': %s\n"),
+                 dname, gpg_strerror (err));
+      return err;
+    }
+
+  p = stpcpy (hdr->name, dname);
+  if (de)
+    {
+      if (dname[dnamelen-1] != '/')
+        *p++ = '/';
+      strcpy (p, de->d_name);
+    }
+  else
+    {
+      if (hdr->name[dnamelen-1] == '/')
+        hdr->name[dnamelen-1] = 0;
+    }
+#ifdef HAVE_DOSISH_SYSTEM
+  for (p=hdr->name; *p; p++)
+    if (*p == '\\')
+      *p = '/';
+#endif
+  err = fillup_entry (hdr);
+  if (err)
+    xfree (hdr);
+  else
+    {
+      if (opt.verbose)
+        gpgtar_print_header (hdr, log_get_stream ());
+      *scanctrl->flist_tail = hdr;
+      scanctrl->flist_tail = &hdr->next;
+    }
+
+  return 0;
+}
+
+
+static gpg_error_t
+scan_directory (const char *dname, scanctrl_t scanctrl)
+{
+  gpg_error_t err = 0;
+  size_t dnamelen;
+  DIR *dir;
+  struct dirent *de;
+
+  dnamelen = strlen (dname);
+  if (!dnamelen)
+    return 0;  /* An empty directory name has no entries.  */
+
+  dir = opendir (dname);
+  if (!dir)
+    {
+      err = gpg_error_from_syserror ();
+      log_error (_("error reading directory `%s': %s\n"),
+                 dname, gpg_strerror (err));
+      return err;
+    }
+  
+  while ((de = readdir (dir)))
+    {
+      if (!strcmp (de->d_name, "." ) || !strcmp (de->d_name, ".."))
+        continue; /* Skip self and parent dir entry.  */
+      
+      err = add_entry (dname, dnamelen, de, scanctrl);
+      if (err)
+        goto leave;
+     }
+
+ leave:
+  closedir (dir);
+  return err;
+}
+
+
+static gpg_error_t
+scan_recursive (const char *dname, scanctrl_t scanctrl)
+{
+  gpg_error_t err = 0;
+  tar_header_t hdr, *start_tail, *stop_tail;
+
+  if (scanctrl->nestlevel > 200)
+    {
+      log_error ("directories too deeply nested\n");
+      return gpg_error (GPG_ERR_RESOURCE_LIMIT);
+    }
+  scanctrl->nestlevel++;
+
+  assert (scanctrl->flist_tail);
+  start_tail = scanctrl->flist_tail;
+  scan_directory (dname, scanctrl);
+  stop_tail = scanctrl->flist_tail;
+  hdr = *start_tail;
+  for (; hdr && hdr != *stop_tail; hdr = hdr->next)
+    if (hdr->typeflag == TF_DIRECTORY)
+      {
+        if (opt.verbose > 1)
+          log_info ("scanning directory `%s'\n", hdr->name);
+        scan_recursive (hdr->name, scanctrl);
+      }
+  
+  scanctrl->nestlevel--;
+  return err;
+}
+
+
+/* Returns true if PATTERN is acceptable.  */
+static int
+pattern_valid_p (const char *pattern)
+{
+  if (!*pattern)
+    return 0;
+  if (*pattern == '.' && pattern[1] == '.')
+    return 0;
+  if (*pattern == '/' || *pattern == DIRSEP_C)
+    return 0; /* Absolute filenames are not supported.  */
+#ifdef HAVE_DRIVE_LETTERS
+  if (((*pattern >= 'a' && *pattern <= 'z')
+       || (*pattern >= 'A' && *pattern <= 'Z'))
+      && pattern[1] == ':')
+    return 0; /* Drive letter are not allowed either.  */
+#endif /*HAVE_DRIVE_LETTERS*/ 
+
+  return 1; /* Okay.  */
+}
+
+
+
+static void
+store_xoctal (char *buffer, size_t length, unsigned long long value)
+{
+  char *p, *pend;
+  size_t n;
+  unsigned long long v;
+
+  assert (length > 1);
+
+  v = value;
+  n = length;
+  p = pend = buffer + length;
+  *--p = 0; /* Nul byte.  */
+  n--;
+  do
+    {
+      *--p = '0' + (v % 8);
+      v /= 8;
+      n--;
+    }
+  while (v && n);
+  if (!v)
+    {
+      /* Pad.  */
+      for ( ; n; n--)
+        *--p = '0';
+    }
+  else /* Does not fit into the field.  Store as binary number.  */
+    {
+      v = value;
+      n = length;
+      p = pend = buffer + length;
+      do
+        {
+          *--p = v;
+          v /= 256;
+          n--;
+        }
+      while (v && n);
+      if (!v)
+        {
+          /* Pad.  */
+          for ( ; n; n--)
+            *--p = 0;
+          if (*p & 0x80)
+            BUG ();
+          *p |= 0x80; /* Set binary flag.  */
+        }
+      else
+        BUG ();
+    }
+}
+
+
+static void
+store_uname (char *buffer, size_t length, unsigned long uid)
+{
+  static int initialized;
+  static unsigned long lastuid;
+  static char lastuname[32];
+
+  if (!initialized || uid != lastuid)
+    {
+      struct passwd *pw = getpwuid (uid);
+
+      lastuid = uid;
+      initialized = 1;
+      if (pw)
+        mem2str (lastuname, pw->pw_name, sizeof lastuname); 
+      else
+        {
+          log_info ("failed to get name for uid %lu\n", uid);
+          *lastuname = 0;
+        }
+    }
+  mem2str (buffer, lastuname, length);
+}
+
+
+static void
+store_gname (char *buffer, size_t length, unsigned long gid)
+{
+  static int initialized;
+  static unsigned long lastgid;
+  static char lastgname[32];
+
+  if (!initialized || gid != lastgid)
+    {
+      struct group *gr = getgrgid (gid);
+
+      lastgid = gid;
+      initialized = 1;
+      if (gr)
+        mem2str (lastgname, gr->gr_name, sizeof lastgname); 
+      else
+        {
+          log_info ("failed to get name for gid %lu\n", gid);
+          *lastgname = 0;
+        }
+    }
+  mem2str (buffer, lastgname, length);
+}
+
+
+static gpg_error_t
+build_header (void *record, tar_header_t hdr)
+{
+  gpg_error_t err;
+  struct ustar_raw_header *raw = record;
+  size_t namelen, n;
+  unsigned long chksum;
+  unsigned char *p;
+
+  memset (record, 0, RECORDSIZE);
+
+  /* Store name and prefix.  */
+  namelen = strlen (hdr->name);
+  if (namelen < sizeof raw->name)
+    memcpy (raw->name, hdr->name, namelen);
+  else 
+    {
+      n = (namelen < sizeof raw->prefix)? namelen : sizeof raw->prefix;
+      for (n--; n ; n--)
+        if (hdr->name[n] == '/')
+          break;
+      if (namelen - n < sizeof raw->name)
+        {
+          /* Note that the N is < sizeof prefix and that the
+             delimiting slash is not stored.  */
+          memcpy (raw->prefix, hdr->name, n);
+          memcpy (raw->name, hdr->name+n+1, namelen - n);
+        }
+      else
+        {
+          err = gpg_error (GPG_ERR_TOO_LARGE);
+          log_error ("error storing file `%s': %s\n", 
+                     hdr->name, gpg_strerror (err));
+          return err;
+        }
+    }
+  
+  store_xoctal (raw->mode,  sizeof raw->mode,  hdr->mode);
+  store_xoctal (raw->uid,   sizeof raw->uid,   hdr->uid);
+  store_xoctal (raw->gid,   sizeof raw->gid,   hdr->gid);
+  store_xoctal (raw->size,  sizeof raw->size,  hdr->size);
+  store_xoctal (raw->mtime, sizeof raw->mtime, hdr->mtime);
+
+  switch (hdr->typeflag)
+    {
+    case TF_REGULAR:   raw->typeflag[0] = '0'; break;
+    case TF_HARDLINK:  raw->typeflag[0] = '1'; break;
+    case TF_SYMLINK:   raw->typeflag[0] = '2'; break;
+    case TF_CHARDEV:   raw->typeflag[0] = '3'; break;
+    case TF_BLOCKDEV:  raw->typeflag[0] = '4'; break;
+    case TF_DIRECTORY: raw->typeflag[0] = '5'; break;
+    case TF_FIFO:      raw->typeflag[0] = '6'; break;
+    default: return gpg_error (GPG_ERR_NOT_SUPPORTED);
+    }
+
+  memcpy (raw->magic, "ustar", 6);
+  raw->version[0] = '0';
+  raw->version[1] = '0';
+
+  store_uname (raw->uname, sizeof raw->uname, hdr->uid);
+  store_gname (raw->gname, sizeof raw->gname, hdr->gid);
+
+  if (hdr->typeflag == TF_SYMLINK)
+    {
+      int nread;
+
+      nread = readlink (hdr->name, raw->linkname, sizeof raw->linkname -1);
+      if (nread < 0)
+        {
+          err = gpg_error_from_syserror ();
+          log_error ("error reading symlink `%s': %s\n", 
+                     hdr->name, gpg_strerror (err));
+          return err;
+        }
+      raw->linkname[nread] = 0;
+    }
+  
+
+  /* Compute the checksum.  */
+  memset (raw->checksum, ' ', sizeof raw->checksum);
+  chksum = 0;
+  p = record;
+  for (n=0; n < RECORDSIZE; n++)
+    chksum += *p++;
+  store_xoctal (raw->checksum, sizeof raw->checksum - 1, chksum);
+  raw->checksum[7] = ' ';
+
+  return 0;
+}
+
+
+static gpg_error_t
+write_file (estream_t stream, tar_header_t hdr)
+{
+  gpg_error_t err;
+  char record[RECORDSIZE];
+  estream_t infp;
+  size_t nread, nbytes;
+  int any;
+
+  err = build_header (record, hdr);
+  if (err)
+    {
+      if (gpg_err_code (err) == GPG_ERR_NOT_SUPPORTED)
+        {
+          log_info ("skipping unsupported file `%s'\n", hdr->name);
+          err = 0;
+        }
+      return err;
+    }
+
+  if (hdr->typeflag == TF_REGULAR)
+    {
+      infp = es_fopen (hdr->name, "rb");
+      if (!infp)
+        {
+          err = gpg_error_from_syserror ();
+          log_error ("can't open `%s': %s - skipped\n",
+                     hdr->name, gpg_strerror (err));
+          return err;
+        }
+    }
+  else
+    infp = NULL;
+
+  err = write_record (stream, record);
+  if (err)
+    goto leave;
+
+  if (hdr->typeflag == TF_REGULAR)
+    {
+      hdr->nrecords = (hdr->size + RECORDSIZE-1)/RECORDSIZE;
+      any = 0;
+      while (hdr->nrecords--)
+        {
+          nbytes = hdr->nrecords? RECORDSIZE : (hdr->size % RECORDSIZE);
+          nread = es_fread (record, 1, nbytes, infp);
+          if (nread != nbytes)
+            {
+              err = gpg_error_from_syserror ();
+              log_error ("error reading file `%s': %s%s\n",
+                         hdr->name, gpg_strerror (err),
+                         any? " (file shrunk?)":"");
+              goto leave;
+            }
+          any = 1;
+          err = write_record (stream, record);
+          if (err)
+            goto leave;
+        }
+      nread = es_fread (record, 1, 1, infp);
+      if (nread)
+        log_info ("note: file `%s' has grown\n", hdr->name);
+    }
+
+ leave:
+  if (err)
+    es_fclose (infp);
+  else if ((err = es_fclose (infp)))
+    log_error ("error closing file `%s': %s\n", hdr->name, gpg_strerror (err));
+      
+  return err;
+}
+
+
+static gpg_error_t
+write_eof_mark (estream_t stream)
+{
+  gpg_error_t err;
+  char record[RECORDSIZE];
+
+  memset (record, 0, sizeof record);
+  err = write_record (stream, record);
+  if (!err)
+    err = write_record (stream, record);
+  return err;
+}
+
+
+
+void
+gpgtar_create (char **inpattern)
+{
+  gpg_error_t err = 0;
+  const char *pattern;
+  struct scanctrl_s scanctrl_buffer;
+  scanctrl_t scanctrl = &scanctrl_buffer;
+  tar_header_t hdr, *start_tail;
+  estream_t outstream;
+
+  memset (scanctrl, 0, sizeof *scanctrl);
+  scanctrl->flist_tail = &scanctrl->flist;
+
+  for (; (pattern = *inpattern); inpattern++)
+    {
+      if (!*pattern)
+        continue;
+      if (opt.verbose > 1)
+        log_info ("scanning `%s'\n", pattern);
+
+      start_tail = scanctrl->flist_tail;
+      if (!pattern_valid_p (pattern))
+        log_error ("skipping invalid name `%s'\n", pattern);
+      else if (!add_entry (pattern, strlen (pattern), NULL, scanctrl)
+               && *start_tail && ((*start_tail)->typeflag & TF_DIRECTORY))
+        scan_recursive (pattern, scanctrl);
+    }
+
+  if (opt.outfile)
+    {
+      outstream = es_fopen (opt.outfile, "wb");
+      if (!outstream)
+        {
+          err = gpg_error_from_syserror ();
+          log_error (_("can't create `%s': %s\n"),
+                     opt.outfile, gpg_strerror (err));
+          goto leave;
+        }
+    }
+  else
+    {
+      outstream = es_stdout;
+    }
+
+  for (hdr = scanctrl->flist; hdr; hdr = hdr->next)
+    {
+      err = write_file (outstream, hdr);
+      if (err)
+        goto leave;
+    }
+  err = write_eof_mark (outstream);
+
+ leave:
+  if (!err)
+    {
+      if (outstream != es_stdout)
+        err = es_fclose (outstream);
+      else
+        err = es_fflush (outstream);
+      outstream = NULL;
+    }
+  if (err)
+    {
+      log_error ("creating tarball `%s' failed: %s\n",
+                 es_fname_get (outstream), gpg_strerror (err));
+      if (outstream && outstream != es_stdout)
+        es_fclose (outstream);
+      if (opt.outfile)
+        gnupg_remove (opt.outfile);
+    }
+  scanctrl->flist_tail = NULL;
+  while ( (hdr = scanctrl->flist) )
+    {
+      scanctrl->flist = hdr->next;
+      xfree (hdr);
+    }
+}
diff --git a/tools/gpgtar-extract.c b/tools/gpgtar-extract.c
new file mode 100644
index 000000000..002215c5d
--- /dev/null
+++ b/tools/gpgtar-extract.c
@@ -0,0 +1,266 @@
+/* gpgtar-extract.c - Extract from a TAR archive
+ * Copyright (C) 2010 Free Software Foundation, Inc.
+ *
+ * This file is part of GnuPG.
+ *
+ * GnuPG is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * GnuPG is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <config.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <assert.h>
+
+#include "i18n.h"
+#include "../common/sysutils.h"
+#include "gpgtar.h"
+
+
+
+static gpg_error_t
+extract_regular (estream_t stream, const char *dirname,
+                 tar_header_t hdr)
+{
+  gpg_error_t err;
+  char record[RECORDSIZE];
+  size_t n, nbytes, nwritten;
+  char *fname;
+  estream_t outfp = NULL;
+
+  fname = strconcat (dirname, "/", hdr->name, NULL);
+  if (!fname)
+    {
+      err = gpg_error_from_syserror ();
+      log_error ("error creating filename: %s\n", gpg_strerror (err));
+      goto leave;
+    }
+  else
+    err = 0;
+  
+  outfp = es_fopen (fname, "wb");
+  if (!outfp)
+    {
+      err = gpg_error_from_syserror ();
+      log_error ("error creating `%s': %s\n", fname, gpg_strerror (err));
+      goto leave;
+    }
+
+  for (n=0; n < hdr->nrecords;)
+    {
+      err = read_record (stream, record);
+      if (err)
+        goto leave;
+      n++;
+      nbytes = (n < hdr->nrecords)? RECORDSIZE : (hdr->size % RECORDSIZE);
+      nwritten = es_fwrite (record, 1, nbytes, outfp);
+      if (nwritten != nbytes)
+        {
+          err = gpg_error_from_syserror ();
+          log_error ("error writing `%s': %s\n", fname, gpg_strerror (err));
+          goto leave;
+        }
+    }
+  /* Fixme: Set permissions etc.  */
+
+ leave:
+  es_fclose (outfp);
+  if (err && fname && outfp)
+    {
+      if (gnupg_remove (fname))
+        log_error ("error removing incomplete file `%s': %s\n",
+                   fname, gpg_strerror (gpg_error_from_syserror ()));
+    }
+  xfree (fname);
+  return err;
+}
+
+
+static gpg_error_t
+extract_directory (const char *dirname, tar_header_t hdr)
+{
+  gpg_error_t err;
+  char *fname;
+
+  fname = strconcat (dirname, "/", hdr->name, NULL);
+  if (!fname)
+    {
+      err = gpg_error_from_syserror ();
+      log_error ("error creating filename: %s\n", gpg_strerror (err));
+      goto leave;
+    }
+  else
+    err = 0;
+
+  if (gnupg_mkdir (fname, "-rwx------"))
+    {
+      err = gpg_error_from_syserror ();
+      log_error ("error creating directory `%s': %s\n",
+                 fname, gpg_strerror (err));
+    }
+
+ leave:
+  xfree (fname);
+  return err;
+}
+
+
+static gpg_error_t
+extract (estream_t stream, const char *dirname, tar_header_t hdr)
+{
+  gpg_error_t err;
+  size_t n;
+
+  n = strlen (hdr->name);
+#ifdef HAVE_DOSISH_SYSTEM
+  if (strchr (hdr->name, '\\'))
+    {
+      log_error ("filename `%s' contains a backslash - "
+                 "can't extract on this system\n", hdr->name);
+      return gpg_error (GPG_ERR_INV_NAME);
+    }
+#endif /*HAVE_DOSISH_SYSTEM*/
+
+  if (!n
+      || strstr (hdr->name, "//") 
+      || strstr (hdr->name, "/../") 
+      || !strncmp (hdr->name, "../", 3)
+      || (n >= 3 && !strcmp (hdr->name+n-3, "/.." )))
+    {
+      log_error ("filename `%s' as suspicious parts - not extracting\n",
+                 hdr->name);
+      return gpg_error (GPG_ERR_INV_NAME);
+    }
+
+  if (hdr->typeflag == TF_REGULAR || hdr->typeflag == TF_UNKNOWN)
+    err = extract_regular (stream, dirname, hdr);
+  else if (hdr->typeflag == TF_DIRECTORY)
+    err = extract_directory (dirname, hdr);
+  else
+    {
+      char record[RECORDSIZE];
+
+      log_info ("unsupported file type for `%s' - skipped\n", hdr->name);
+      for (err = 0, n=0; !err && n < hdr->nrecords; n++)
+        err = read_record (stream, record);
+    }
+  return err;
+}
+
+
+/* Create a new directory to be used for extracting the tarball.
+   Returns the name of the directory which must be freed by the
+   caller.  In case of an error a diagnostic is printed and NULL
+   returned.  */
+static char *
+create_directory (const char *dirprefix)
+{
+  gpg_error_t err = 0;
+  char *dirname = NULL;
+  int idx;
+
+  for (idx=1; idx < 5000; idx++)
+    {
+      xfree (dirname);
+      dirname = xtryasprintf ("%s_%d_", dirprefix, idx);
+      if (!dirname)
+        {
+          err = gpg_error_from_syserror ();
+          goto leave;
+        }
+      if (!gnupg_mkdir (dirname, "-rwx------"))
+        goto leave;
+      if (errno != EEXIST && errno != ENOTDIR)
+        {
+          err = gpg_error_from_syserror ();
+          goto leave;
+        }
+    }
+  err = gpg_error_from_syserror ();
+
+ leave:
+  if (err)
+    {
+      log_error ("error creating an extract directory: %s\n",
+                 gpg_strerror (err));
+      xfree (dirname);
+      dirname = NULL;
+    }
+  return dirname;
+}
+
+
+
+void
+gpgtar_extract (const char *filename)
+{
+  gpg_error_t err;
+  estream_t stream;
+  tar_header_t header = NULL;
+  const char *dirprefix = NULL;
+  char *dirname = NULL;
+
+  if (filename)
+    {
+      dirprefix = strrchr (filename, '/');
+      if (dirprefix)
+        dirprefix++;
+      stream = es_fopen (filename, "rb");
+      if (!stream)
+        {
+          err = gpg_error_from_syserror ();
+          log_error ("error opening `%s': %s\n", filename, gpg_strerror (err));
+          return;
+        }
+    }
+  else
+    stream = es_stdin;  /* FIXME:  How can we enforce binary mode?  */
+
+  if (!dirprefix || !*dirprefix)
+    dirprefix = "GPGARCH";
+
+  dirname = create_directory (dirprefix);
+  if (!dirname)
+    {
+      err = gpg_error (GPG_ERR_GENERAL);
+      goto leave;
+    }
+
+  if (opt.verbose)
+    log_info ("extracting to `%s/'\n", dirname);
+
+  for (;;)
+    {
+      header = gpgtar_read_header (stream);
+      if (!header)
+        goto leave;
+     
+      if (extract (stream, dirname, header))
+        goto leave;
+      xfree (header);
+      header = NULL;
+    }
+
+
+ leave:
+  xfree (header);
+  xfree (dirname);
+  if (stream != es_stdin)
+    es_fclose (stream);
+  return;
+}
diff --git a/tools/gpgtar-list.c b/tools/gpgtar-list.c
new file mode 100644
index 000000000..82711c19e
--- /dev/null
+++ b/tools/gpgtar-list.c
@@ -0,0 +1,324 @@
+/* gpgtar-list.c - List a TAR archive
+ * Copyright (C) 2010 Free Software Foundation, Inc.
+ *
+ * This file is part of GnuPG.
+ *
+ * GnuPG is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * GnuPG is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <config.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#include "i18n.h"
+#include "gpgtar.h"
+
+
+
+static unsigned long long
+parse_xoctal (const void *data, size_t length, const char *filename)
+{
+  const unsigned char *p = data;
+  unsigned long long value;
+
+  if (!length)
+    value = 0;
+  else if ( (*p & 0x80))
+    {
+      /* Binary format.  */
+      value = (*p++ & 0x7f);
+      while (--length)
+        {
+          value <<= 8;
+          value |= *p++;
+        }
+    }
+  else
+    {
+      /* Octal format  */
+      value = 0;
+      /* Skip leading spaces and zeroes.  */
+      for (; length && (*p == ' ' || *p == '0'); length--, p++)
+        ;
+      for (; length && *p; length--, p++)
+        {
+          if (*p >= '0' && *p <= '7')
+            {
+              value <<= 3;
+              value += (*p - '0');
+            }
+          else
+            {
+              log_error ("%s: invalid octal number encountered - assuming 0\n", 
+                         filename);
+              value = 0;
+              break;
+            }
+        }
+    }
+  return value;
+}
+
+
+static tar_header_t
+parse_header (const void *record, const char *filename)
+{
+  const struct ustar_raw_header *raw = record;
+  size_t n, namelen, prefixlen;
+  tar_header_t header;
+  int use_prefix;
+
+  use_prefix = (!memcmp (raw->magic, "ustar", 5) 
+                && (raw->magic[5] == ' ' || !raw->magic[5]));
+
+
+  for (namelen=0; namelen < sizeof raw->name && raw->name[namelen]; namelen++)
+    ;
+  if (namelen == sizeof raw->name)
+    log_info ("%s: warning: name not terminated by a nul byte\n",
+              filename);
+  for (n=namelen+1; n < sizeof raw->name; n++)
+    if (raw->name[n])
+      {
+        log_info ("%s: warning: garbage after name\n", filename);
+        break;
+      }
+
+
+  if (use_prefix && raw->prefix[0])
+    {
+      for (prefixlen=0; (prefixlen < sizeof raw->prefix
+                         && raw->prefix[prefixlen]); prefixlen++)
+        ;
+      if (prefixlen == sizeof raw->prefix)
+        log_info ("%s: warning: prefix not terminated by a nul byte\n",
+                  filename);
+      for (n=prefixlen+1; n < sizeof raw->prefix; n++)
+        if (raw->prefix[n])
+          {
+            log_info ("%s: warning: garbage after prefix\n", filename);
+            break;
+          }
+    }
+  else
+    prefixlen = 0;
+
+  header = xtrycalloc (1, sizeof *header + prefixlen + 1 + namelen);
+  if (!header)
+    {
+      log_error ("%s: error allocating header: %s\n",
+                 filename, gpg_strerror (gpg_error_from_syserror ()));
+      return NULL;
+    }
+  if (prefixlen)
+    {
+      n = prefixlen;
+      memcpy (header->name, raw->prefix, n);
+      if (raw->prefix[n-1] != '/')
+        header->name[n++] = '/';
+    }
+  else
+    n = 0;
+  memcpy (header->name+n, raw->name, namelen);
+  header->name[n+namelen] = 0;
+  
+  header->mode  = parse_xoctal (raw->mode, sizeof raw->mode, filename);
+  header->uid   = parse_xoctal (raw->uid, sizeof raw->uid, filename);
+  header->gid   = parse_xoctal (raw->gid, sizeof raw->gid, filename);
+  header->size  = parse_xoctal (raw->size, sizeof raw->size, filename);
+  header->mtime = parse_xoctal (raw->mtime, sizeof raw->mtime, filename);
+  /* checksum = */
+  switch (raw->typeflag[0])
+    {
+    case '0': header->typeflag = TF_REGULAR; break;
+    case '1': header->typeflag = TF_HARDLINK; break;
+    case '2': header->typeflag = TF_SYMLINK; break;
+    case '3': header->typeflag = TF_CHARDEV; break;
+    case '4': header->typeflag = TF_BLOCKDEV; break;
+    case '5': header->typeflag = TF_DIRECTORY; break;
+    case '6': header->typeflag = TF_FIFO; break;
+    case '7': header->typeflag = TF_RESERVED; break;
+    default:  header->typeflag = TF_UNKNOWN; break;
+    }
+
+
+  /* Compute the number of data records following this header.  */
+  if (header->typeflag == TF_REGULAR || header->typeflag == TF_UNKNOWN)
+    header->nrecords = (header->size + RECORDSIZE-1)/RECORDSIZE;
+  else
+    header->nrecords = 0;
+  
+
+  return header;
+}
+
+
+
+/* Read the next block, assming it is a tar header.  Returns a header
+   object on success or NULL one error.  In case of an error an error
+   message has been printed.  */
+static tar_header_t
+read_header (estream_t stream)
+{
+  gpg_error_t err;
+  char record[RECORDSIZE];
+  int i;
+
+  err = read_record (stream, record);
+  if (err)
+    return NULL;
+
+  for (i=0; i < RECORDSIZE && !record[i]; i++)
+    ;
+  if (i == RECORDSIZE)
+    {
+      /* All zero header - check whether it is the first part of an
+         end of archive mark.  */
+      err = read_record (stream, record);
+      if (err)
+        return NULL;
+      
+      for (i=0; i < RECORDSIZE && !record[i]; i++)
+        ;
+      if (i != RECORDSIZE)
+        log_info ("%s: warning: skipping empty header\n",
+                  es_fname_get (stream));
+      else
+        {
+          /* End of archive - FIXME: we might want to check for garbage.  */
+          return NULL;
+        }
+    }
+
+  return parse_header (record, es_fname_get (stream));
+}
+
+
+/* Skip the data records according to HEADER.  Prints an error message
+   on error and return -1. */
+static int
+skip_data (estream_t stream, tar_header_t header)
+{
+  char record[RECORDSIZE];
+  unsigned long long n;
+
+  for (n=0; n < header->nrecords; n++)
+    {
+      if (read_record (stream, record))
+        return -1;
+    }
+
+  return 0;
+}
+
+
+
+static void
+print_header (tar_header_t header, estream_t out)
+{
+  unsigned long mask;
+  char modestr[10+1];
+  int i;
+
+  *modestr = '?';
+  switch (header->typeflag)
+    {
+    case TF_REGULAR:  *modestr = '-'; break;
+    case TF_HARDLINK: *modestr = 'h'; break;
+    case TF_SYMLINK:  *modestr = 'l'; break;
+    case TF_CHARDEV:  *modestr = 'c'; break;
+    case TF_BLOCKDEV: *modestr = 'b'; break;
+    case TF_DIRECTORY:*modestr = 'd'; break;
+    case TF_FIFO:     *modestr = 'f'; break;
+    case TF_RESERVED: *modestr = '='; break;
+    case TF_UNKNOWN:  break;
+    case TF_NOTSUP:   break;
+    }
+  for (mask = 0400, i = 0; i < 9; i++, mask >>= 1)
+    modestr[1+i] = (header->mode & mask)? "rwxrwxrwx"[i]:'-';
+  if ((header->typeflag & 04000))
+    modestr[3] = modestr[3] == 'x'? 's':'S';
+  if ((header->typeflag & 02000))
+    modestr[6] = modestr[6] == 'x'? 's':'S';
+  if ((header->typeflag & 01000))
+    modestr[9] = modestr[9] == 'x'? 't':'T';
+  modestr[10] = 0;
+
+  es_fprintf (out, "%s %lu %lu/%lu %12llu %s %s\n",
+              modestr, header->nlink, header->uid, header->gid, header->size,
+              isotimestamp (header->mtime), header->name);
+}
+
+
+
+/* List the tarball FILENAME or, if FILENAME is NULL, the tarball read
+   from stdin.  */
+void
+gpgtar_list (const char *filename)
+{
+  gpg_error_t err;
+  estream_t stream;
+  tar_header_t header;
+
+  if (filename)
+    {
+      stream = es_fopen (filename, "rb");
+      if (!stream)
+        {
+          err = gpg_error_from_syserror ();
+          log_error ("error opening `%s': %s\n", filename, gpg_strerror (err));
+          return;
+        }
+    }
+  else
+    stream = es_stdin;  /* FIXME:  How can we enforce binary mode?  */
+
+  for (;;)
+    {
+      header = read_header (stream);
+      if (!header)
+        goto leave;
+      
+      print_header (header, es_stdout);
+      
+      if (skip_data (stream, header))
+        goto leave;
+      xfree (header);
+      header = NULL;
+    }
+
+
+ leave:
+  xfree (header);
+  if (filename)
+    es_fclose (stream);
+  return;
+}
+
+tar_header_t
+gpgtar_read_header (estream_t stream)
+{
+  /*FIXME: Change to return an error code.  */
+  return read_header (stream);
+}
+
+void
+gpgtar_print_header (tar_header_t header, estream_t out)
+{
+  if (header && out)
+    print_header (header, out);
+}
diff --git a/tools/gpgtar.c b/tools/gpgtar.c
new file mode 100644
index 000000000..555fe39dc
--- /dev/null
+++ b/tools/gpgtar.c
@@ -0,0 +1,361 @@
+/* gpgtar.c - A simple TAR implementation mainly useful for Windows.
+ * Copyright (C) 2010 Free Software Foundation, Inc.
+ *
+ * This file is part of GnuPG.
+ *
+ * GnuPG is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * GnuPG is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+/* GnuPG comes with a shell script gpg-zip which creates archive files
+   in the same format as PGP Zip, which is actually a USTAR format.
+   That is fine and works nicely on all Unices but for Windows we
+   don't have a compatible shell and the supply of tar programs is
+   limited.  Given that we need just a few tar option and it is an
+   open question how many Unix concepts are to be mapped to Windows,
+   we might as well write our own little tar customized for use with
+   gpg.  So here we go.  */
+
+#include <config.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#include "util.h"
+#include "i18n.h"
+#include "sysutils.h"
+#include "../common/openpgpdefs.h"
+
+#include "gpgtar.h"
+
+
+/* Constants to identify the commands and options. */
+enum cmd_and_opt_values
+  {
+    aNull = 0,
+    aEncrypt    = 'e',
+    aDecrypt    = 'd',
+    aSign       = 's',
+
+    oSymmetric  = 'c',
+    oRecipient	= 'r',
+    oUser       = 'u',
+    oOutput	= 'o',
+    oQuiet      = 'q',
+    oVerbose	= 'v',
+    oNoVerbose	= 500,
+
+    aSignEncrypt,
+    oSkipCrypto,
+    aList
+  };
+
+
+/* The list of commands and options. */
+static ARGPARSE_OPTS opts[] = {
+  ARGPARSE_group (300, N_("@Commands:\n ")),
+    
+  ARGPARSE_c (aEncrypt,   "encrypt", N_("create an archive")),
+  ARGPARSE_c (aDecrypt,   "decrypt", N_("extract an archive")),
+  ARGPARSE_c (aSign,      "sign",    N_("create a signed archive")),
+  ARGPARSE_c (aList,      "list-archive", N_("list an archive")),
+
+  ARGPARSE_group (301, N_("@\nOptions:\n ")),
+
+  ARGPARSE_s_n (oSymmetric, "symmetric", N_("use symmetric encryption")),
+  ARGPARSE_s_s (oRecipient, "recipient", N_("|USER-ID|encrypt for USER-ID")),
+  ARGPARSE_s_s (oUser, "local-user",
+                N_("|USER-ID|use USER-ID to sign or decrypt")),
+  ARGPARSE_s_s (oOutput, "output", N_("|FILE|write output to FILE")),
+  ARGPARSE_s_n (oVerbose, "verbose", N_("verbose")),
+  ARGPARSE_s_n (oQuiet,	"quiet",  N_("be somewhat more quiet")),
+  ARGPARSE_s_n (oSkipCrypto, "skip-crypto", N_("skip the crypto processing")),
+
+  ARGPARSE_end ()
+};
+
+
+
+static void tar_and_encrypt (char **inpattern);
+static void decrypt_and_untar (const char *fname);
+static void decrypt_and_list (const char *fname);
+
+
+
+
+/* Print usage information and and provide strings for help. */
+static const char *
+my_strusage( int level )
+{
+  const char *p;
+
+  switch (level)
+    {
+    case 11: p = "gpgtar (GnuPG)";
+      break;
+    case 13: p = VERSION; break;
+    case 17: p = PRINTABLE_OS_NAME; break;
+    case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;
+
+    case 1:
+    case 40:
+      p = _("Usage: gpgtar [options] [files] [directories] (-h for help)");
+      break;
+    case 41:
+      p = _("Syntax: gpgtar [options] [files] [directories]\n"
+            "Encrypt or sign files into an archive\n");
+      break;
+
+    default: p = NULL; break;
+    }
+  return p;
+}
+
+
+static void
+set_cmd (enum cmd_and_opt_values *ret_cmd, enum cmd_and_opt_values new_cmd)
+{
+  enum cmd_and_opt_values cmd = *ret_cmd;
+
+  if (!cmd || cmd == new_cmd)
+    cmd = new_cmd;
+  else if (cmd == aSign && new_cmd == aEncrypt)
+    cmd = aSignEncrypt;
+  else if (cmd == aEncrypt && new_cmd == aSign)
+    cmd = aSignEncrypt;
+  else 
+    {
+      log_error (_("conflicting commands\n"));
+      exit (2);
+    }
+
+  *ret_cmd = cmd;
+}
+
+
+
+/* gpgtar main. */
+int
+main (int argc, char **argv)
+{
+  ARGPARSE_ARGS pargs;
+  const char *fname;
+  int no_more_options = 0;
+  enum cmd_and_opt_values cmd = 0;
+  int skip_crypto = 0;
+
+  assert (sizeof (struct ustar_raw_header) == 512);
+
+  gnupg_reopen_std ("gpgtar");
+  set_strusage (my_strusage);
+  log_set_prefix ("gpgtar", 1);
+
+  /* Make sure that our subsystems are ready.  */
+  i18n_init();
+  init_common_subsystems (&argc, &argv);
+
+  /* Parse the command line. */
+  pargs.argc  = &argc;
+  pargs.argv  = &argv;
+  pargs.flags = ARGPARSE_FLAG_KEEP;
+  while (!no_more_options && optfile_parse (NULL, NULL, NULL, &pargs, opts))
+    {
+      switch (pargs.r_opt)
+        {
+        case oOutput:    opt.outfile = pargs.r.ret_str; break;
+	case oQuiet:     opt.quiet = 1; break;
+        case oVerbose:   opt.verbose++; break;
+        case oNoVerbose: opt.verbose = 0; break;
+          
+	case aList:
+        case aDecrypt:
+        case aEncrypt:
+        case aSign:
+          set_cmd (&cmd, pargs.r_opt);
+	  break;
+
+        case oSymmetric:
+          set_cmd (&cmd, aEncrypt);
+          opt.symmetric = 1;
+          break;
+
+        case oSkipCrypto:
+          skip_crypto = 1;
+          break;
+
+        default: pargs.err = 2; break;
+	}
+    }
+  
+  if (log_get_errorcount (0))
+    exit (2);
+
+  switch (cmd)
+    {
+    case aList:
+      if (argc > 1)
+        usage (1);
+      fname = argc ? *argv : NULL;
+      if (skip_crypto)
+        gpgtar_list (fname);
+      else
+        decrypt_and_list (fname);
+      break;
+
+    case aEncrypt:
+      if (!argc)
+        usage (1);
+      if (skip_crypto)
+        gpgtar_create (argv);
+      else
+        tar_and_encrypt (argv);
+      break;
+
+    case aDecrypt:
+      if (argc != 1)
+        usage (1);
+      if (opt.outfile)
+        log_info ("note: ignoring option --output\n");
+      fname = argc ? *argv : NULL;
+      if (skip_crypto)
+        gpgtar_extract (fname);
+      else
+        decrypt_and_untar (fname);
+      break;
+
+    default:
+      log_error (_("invalid command (there is no implicit command)\n"));
+      break;
+    }
+
+  return log_get_errorcount (0)? 1:0;
+}
+
+
+/* Read the next record from STREAM.  RECORD is a buffer provided by
+   the caller and must be at leadt of size RECORDSIZE.  The function
+   return 0 on success and and error code on failure; a diagnostic
+   printed as well.  Note that there is no need for an EOF indicator
+   because a tarball has an explicit EOF record. */
+gpg_error_t
+read_record (estream_t stream, void *record)
+{
+  gpg_error_t err;
+  size_t nread;
+
+  nread = es_fread (record, 1, RECORDSIZE, stream);
+  if (nread != RECORDSIZE)
+    {
+      err = gpg_error_from_syserror ();
+      if (es_ferror (stream))
+        log_error ("error reading `%s': %s\n",
+                   es_fname_get (stream), gpg_strerror (err));
+      else
+        log_error ("error reading `%s': premature EOF "
+                   "(size of last record: %zu)\n",
+                   es_fname_get (stream), nread);
+    }
+  else
+    err = 0;
+
+  return err;
+}
+
+
+/* Write the RECORD of size RECORDSIZE to STREAM.  FILENAME is the
+   name of the file used for diagnostics.  */
+gpg_error_t
+write_record (estream_t stream, const void *record)
+{
+  gpg_error_t err;
+  size_t nwritten;
+
+  nwritten = es_fwrite (record, 1, RECORDSIZE, stream);
+  if (nwritten != RECORDSIZE)
+    {
+      err = gpg_error_from_syserror ();
+      log_error ("error writing `%s': %s\n",
+                 es_fname_get (stream), gpg_strerror (err));
+    }
+  else
+    err = 0;
+  
+  return err;
+}
+
+
+/* Return true if FP is an unarmored OpenPGP message.  Note that this
+   fucntion reads a few bytes from FP but pushes them back.  */
+static int
+openpgp_message_p (estream_t fp)
+{
+  int ctb;
+
+  ctb = es_getc (fp);
+  if (ctb != EOF)
+    {
+      if (es_ungetc (ctb, fp))
+        log_fatal ("error ungetting first byte: %s\n", 
+                   gpg_strerror (gpg_error_from_syserror ()));
+      
+      if ((ctb & 0x80))
+        {
+          switch ((ctb & 0x40) ? (ctb & 0x3f) : ((ctb>>2)&0xf))
+            {
+            case PKT_MARKER:
+            case PKT_SYMKEY_ENC:
+            case PKT_ONEPASS_SIG:
+            case PKT_PUBKEY_ENC:
+            case PKT_SIGNATURE:
+            case PKT_COMMENT:
+            case PKT_OLD_COMMENT:
+            case PKT_PLAINTEXT:
+            case PKT_COMPRESSED:
+            case PKT_ENCRYPTED:
+              return 1; /* Yes, this seems to be an OpenPGP message.  */
+            default:
+              break;
+            }
+        }
+    }
+  return 0;
+}
+
+
+
+
+
+static void
+tar_and_encrypt (char **inpattern)
+{
+   
+}
+
+
+
+static void
+decrypt_and_untar (const char *fname)
+{
+  
+  
+}
+
+
+
+static void
+decrypt_and_list (const char *fname)
+{
+
+}
diff --git a/tools/gpgtar.h b/tools/gpgtar.h
new file mode 100644
index 000000000..57fb34a48
--- /dev/null
+++ b/tools/gpgtar.h
@@ -0,0 +1,124 @@
+/* gpgtar.h - Global definitions for gpgtar
+ * Copyright (C) 2010 Free Software Foundation, Inc.
+ *
+ * This file is part of GnuPG.
+ *
+ * GnuPG is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * GnuPG is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef GPGTAR_H
+#define GPGTAR_H
+
+#include "../common/util.h"
+
+/* We keep all global options in the structure OPT.  */
+struct
+{
+  int verbose;
+  int quiet;
+  char *outfile;
+  int symmetric;
+} opt;
+
+
+/* The size of a tar record.  All IO is done in chunks of this size.
+   Note that we don't care about blocking because this version of tar
+   is not expected to be used directly on a tape drive in fact it is
+   used in a pipeline with GPG and thus any blocking would be
+   useless.  */
+#define RECORDSIZE 512 
+
+
+/* Description of the USTAR header format.  */
+struct ustar_raw_header
+{
+  char name[100];
+  char mode[8];
+  char uid[8];
+  char gid[8];
+  char size[12];
+  char mtime[12];
+  char checksum[8];
+  char typeflag[1];
+  char linkname[100];
+  char magic[6];
+  char version[2];
+  char uname[32];
+  char gname[32];   
+  char devmajor[8]; 
+  char devminor[8];
+  char prefix[155]; 
+  char pad[12];
+};
+
+
+/* Filetypes as defined by USTAR.  */
+typedef enum 
+  {
+    TF_REGULAR,
+    TF_HARDLINK,
+    TF_SYMLINK,
+    TF_CHARDEV,
+    TF_BLOCKDEV,
+    TF_DIRECTORY,
+    TF_FIFO,
+    TF_RESERVED,
+    TF_UNKNOWN,    /* Needs to be treated as regular file.  */
+    TF_NOTSUP      /* Not supported (used with --create).  */
+  } typeflag_t;
+
+
+/* The internal represenation of a TAR header.  */
+struct tar_header_s;
+typedef struct tar_header_s *tar_header_t;
+struct tar_header_s
+{
+  tar_header_t next;        /* Used to build a linked list iof entries.  */
+
+  unsigned long mode;       /* The file mode.  */
+  unsigned long nlink;      /* Number of hard links.  */
+  unsigned long uid;        /* The user id of the file.  */
+  unsigned long gid;        /* The group id of the file.  */
+  unsigned long long size;  /* The size of the file.  */
+  unsigned long long mtime; /* Modification time since Epoch.  Note
+                               that we don't use time_t here but a
+                               type which is more likely to be larger
+                               that 32 bit and thus allows to track
+                               times beyond 2106.  */
+  typeflag_t typeflag;      /* The type of the file.  */
+  
+
+  unsigned long long nrecords; /* Number of data records.  */
+
+  char name[1];             /* Filename (dynamically extended).  */
+};
+
+
+/*-- gpgtar.c --*/
+gpg_error_t read_record (estream_t stream, void *record);
+gpg_error_t write_record (estream_t stream, const void *record);
+
+/*-- gpgtar-create.c --*/
+void gpgtar_create (char **inpattern);
+
+/*-- gpgtar-extract.c --*/
+void gpgtar_extract (const char *filename);
+
+/*-- gpgtar-list.c --*/
+void gpgtar_list (const char *filename);
+tar_header_t gpgtar_read_header (estream_t stream);
+void gpgtar_print_header (tar_header_t header, estream_t out);
+
+
+#endif /*GPGTAR_H*/