Add new gnupg version and a patch with gpgtar.
authorWerner Koch <wk@gnupg.org>
Mon, 19 Jul 2010 09:37:57 +0000 (09:37 +0000)
committerWerner Koch <wk@gnupg.org>
Mon, 19 Jul 2010 09:37:57 +0000 (09:37 +0000)
ChangeLog
Makefile.am
NEWS
packages/packages.current
patches/gnupg2-2.0.16/01-estream.patch [new file with mode: 0755]
patches/gnupg2-2.0.16/02-gpgtar.patch [new file with mode: 0755]
src/uninst-gnupg2.nsi

index 1a654b8..707c9f4 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,13 @@
+2010-07-19  Werner Koch  <wk@g10code.com>
+
+       * src/uninst-gnupg2.nsi: Uninstall gpgtar.exe
+       * src/inst-gnupg2.nsi: Install gpgtar.exe
+
+       * patches/gnupg2-2.0.16/02-gpgtar.patch: New.
+       * patches/gnupg2-2.0.16/01-estream.patch: New.
+
+       * packages/packages.current: Update gnupg and dirmngr
+
 2010-07-15  Werner Koch  <wk@g10code.com>
 
        * packages/packages.current: Update libksba
index d24cdde..71f0516 100644 (file)
@@ -58,6 +58,8 @@ EXTRA_DIST = autogen.sh README.SVN ONEWS \
        patches/gnupg2-2.0.12/11-photoid-sk.patch \
        patches/gnupg2-2.0.14/01-encode-s2k.patch \
        patches/gnupg2-2.0.14/02-scd-no-service.patch \
+       patches/gnupg2-2.0.16/01-estream.patch \
+       patches/gnupg2-2.0.16/02-gpgtar.patch \
        patches/dirmngr-1.0.3/01-ldaphttp.patch \
        patches/gpgol-0.9.91/01-gpgme.patch \
         patches/gpa-0.9.0/01-title-prop.patch \
diff --git a/NEWS b/NEWS
index 76f0a97..d79d6de 100644 (file)
--- a/NEWS
+++ b/NEWS
@@ -13,7 +13,7 @@ Noteworthy changes in version 2.1.0 (unreleased)
 
 
 ~~~~~~~~~~~~~~~
-GnuPG:        2.0.15
+GnuPG:        2.0.16
 Kleopatra:    2.0.xxx
 GPA:          0.9.0
 GpgOL:        1.1.1
index 706776c..156e59b 100644 (file)
@@ -333,12 +333,12 @@ chk  445b9e158aaf91e24eae3d1040c6213e9d9f5ba6
 file libassuan/libassuan-2.0.0.tar.bz2
 chk  b03c586a4eefdfc0bb1ec65ecf958b9890d429f7
 
-name gnupg2-2.0.15.tar.bz2
-file gnupg/gnupg-2.0.15.tar.bz2
-chk  3596668fb9cc8ec0714463a5009f990fc23434b0
+name gnupg2-2.0.16.tar.bz2
+file gnupg/gnupg-2.0.16.tar.bz2
+chk  e7eb4f60026884bd90803b531472bc518804b95d
 
-file alpha/dirmngr/dirmngr-1.1.0rc1.tar.bz2
-chk  9c403f2e785df38253c6f8a3e9a1d697cbfacff8
+file dirmngr/dirmngr-1.1.0.tar.bz2
+chk  a7a7d1432db9edad2783ea1bce761a8106464165
 
 file pinentry/pinentry-0.8.0.tar.gz
 chk  381f9ee47b9f198e1be5d3ec4e043067a7e97912
diff --git a/patches/gnupg2-2.0.16/01-estream.patch b/patches/gnupg2-2.0.16/01-estream.patch
new file mode 100755 (executable)
index 0000000..8a15854
--- /dev/null
@@ -0,0 +1,1323 @@
+#! /bin/sh
+patch -p0 -f $* < $0
+exit $?
+
+2010-07-19  Werner Koch  <wk@g10code.com>
+
+        Estream changes as used by the current gnupg trunk.
+
+       * estream.c (es_fname_get, es_fname_set): New.
+       (fname_set_internal): New.
+       (struct estream_internal): Add fields printable_fname and
+       printable_fname_inuse.
+       (_es_get_std_stream): Set stream name.
+       (es_fopen, es_freopen, es_deinitialize): Set fname.
+
+
+
+--- common/estream.c   2009-12-21 15:31:38.000000000 +0100
++++ common/estream.c   2010-07-08 15:55:15.000000000 +0200
+@@ -1,5 +1,5 @@
+ /* estream.c - Extended Stream I/O Library
+- * Copyright (C) 2004, 2005, 2006, 2007, 2009 g10 Code GmbH
++ * Copyright (C) 2004, 2005, 2006, 2007, 2009, 2010 g10 Code GmbH
+  *
+  * This file is part of Libestream.
+  *
+@@ -15,6 +15,40 @@
+  *
+  * You should have received a copy of the GNU General Public License
+  * along with Libestream; if not, see <http://www.gnu.org/licenses/>.
++ *
++ * ALTERNATIVELY, Libestream may be distributed under the terms of the
++ * following license, in which case the provisions of this license are
++ * required INSTEAD OF the GNU General Public License. If you wish to
++ * allow use of your version of this file only under the terms of the
++ * GNU General Public License, and not to allow others to use your
++ * version of this file under the terms of the following license,
++ * indicate your decision by deleting this paragraph and the license
++ * below.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions
++ * are met:
++ * 1. Redistributions of source code must retain the above copyright
++ *    notice, and the entire permission notice in its entirety,
++ *    including the disclaimer of warranties.
++ * 2. Redistributions in binary form must reproduce the above copyright
++ *    notice, this list of conditions and the following disclaimer in the
++ *    documentation and/or other materials provided with the distribution.
++ * 3. The name of the author may not be used to endorse or promote
++ *    products derived from this software without specific prior
++ *    written permission.
++ *
++ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
++ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
++ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
++ * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
++ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
++ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
++ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
++ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
++ * OF THE POSSIBILITY OF SUCH DAMAGE.
+  */
+ #ifdef USE_ESTREAM_SUPPORT_H
+@@ -27,6 +61,9 @@
+ #if defined(_WIN32) && !defined(HAVE_W32_SYSTEM)
+ # define HAVE_W32_SYSTEM 1
++# if defined(__MINGW32CE__) && !defined (HAVE_W32CE_SYSTEM)
++#  define HAVE_W32CE_SYSTEM
++# endif
+ #endif
+ #include <sys/types.h>
+@@ -44,6 +81,9 @@
+ #ifdef HAVE_W32_SYSTEM
+ # include <windows.h>
+ #endif
++#ifdef HAVE_W32CE_SYSTEM
++# include <gpg-error.h> /* ERRNO replacement.  */
++#endif
+ #ifdef WITHOUT_GNU_PTH /* Give the Makefile a chance to build without Pth.  */
+ # undef HAVE_PTH
+@@ -76,6 +116,22 @@ void *memrchr (const void *block, int c,
+ #define O_BINARY 0
+ #endif
++#ifdef HAVE_W32CE_SYSTEM
++# define _set_errno(a)  gpg_err_set_errno ((a))
++/* Setmode is missing in cegcc but available since CE 5.0.  */
++int _setmode (int handle, int mode);
++# define setmode(a,b)   _setmode ((a),(b))
++#else
++# define _set_errno(a)  do { errno = (a); } while (0)
++#endif
++
++#ifdef HAVE_W32_SYSTEM
++# define IS_INVALID_FD(a) ((void*)(a) == (void*)(-1))
++#else
++# define IS_INVALID_FD(a) ((a) == -1)
++#endif
++
++
+ /* Generally used types.  */
+ typedef void *(*func_realloc_t) (void *mem, size_t size);
+@@ -134,9 +190,11 @@ dummy_mutex_call_int (estream_mutex_t mu
+ #ifdef HAVE_PTH
+ # define ESTREAM_SYS_READ  es_pth_read
+ # define ESTREAM_SYS_WRITE es_pth_write
++# define ESTREAM_SYS_YIELD() pth_yield (NULL)
+ #else
+ # define ESTREAM_SYS_READ  read
+ # define ESTREAM_SYS_WRITE write
++# define ESTREAM_SYS_YIELD() do { } while (0)
+ #endif
+ /* Misc definitions.  */
+@@ -153,6 +211,7 @@ struct estream_internal
+   void *cookie;                        /* Cookie.                */
+   void *opaque;                        /* Opaque data.           */
+   unsigned int modeflags;      /* Flags for the backend. */
++  char *printable_fname;         /* Malloced filename for es_fname_get.  */
+   off_t offset;
+   es_cookie_read_function_t func_read;
+   es_cookie_write_function_t func_write;
+@@ -166,7 +225,10 @@ struct estream_internal
+     unsigned int eof: 1;
+   } indicators;
+   unsigned int deallocate_buffer: 1;
++  unsigned int is_stdstream:1;   /* This is a standard stream.  */
++  unsigned int stdstream_fd:2;   /* 0, 1 or 2 for a standard stream.  */
+   unsigned int print_err: 1;     /* Error in print_fun_writer.  */
++  unsigned int printable_fname_inuse: 1;  /* es_fname_get has been used.  */
+   int print_errno;               /* Errno from print_fun_writer.  */
+   size_t print_ntotal;           /* Bytes written from in print_fun_writer. */
+   FILE *print_fp;                /* Stdio stream used by print_fun_writer.  */
+@@ -196,13 +258,22 @@ static estream_mutex_t estream_list_lock
+ #define ESTREAM_LIST_LOCK   ESTREAM_MUTEX_LOCK   (estream_list_lock)
+ #define ESTREAM_LIST_UNLOCK ESTREAM_MUTEX_UNLOCK (estream_list_lock)
++/* File descriptors registered to be used as the standard file handles. */
++static int custom_std_fds[3];
++static unsigned char custom_std_fds_valid[3];
++
++
+ #ifndef EOPNOTSUPP
+ # define EOPNOTSUPP ENOSYS
+ #endif
+-\f
++/* Local prototypes.  */
++static void fname_set_internal (estream_t stream, const char *fname, int quote);
++
++
++\f
+ /* Macros.  */
+ /* Calculate array dimension.  */
+@@ -255,9 +326,11 @@ mem_free (void *p)
+  * List manipulation.
+  */
+-/* Add STREAM to the list of registered stream objects.  */
++/* Add STREAM to the list of registered stream objects.  If
++   WITH_LOCKED_LIST is true we assumed that the list of streams is
++   already locked.  */
+ static int
+-es_list_add (estream_t stream)
++es_list_add (estream_t stream, int with_locked_list)
+ {
+   estream_list_t list_obj;
+   int ret;
+@@ -267,14 +340,16 @@ es_list_add (estream_t stream)
+     ret = -1;
+   else
+     {
+-      ESTREAM_LIST_LOCK;
++      if (!with_locked_list)
++        ESTREAM_LIST_LOCK;
+       list_obj->car = stream;
+       list_obj->cdr = estream_list;
+       list_obj->prev_cdr = &estream_list;
+       if (estream_list)
+       estream_list->prev_cdr = &list_obj->cdr;
+       estream_list = list_obj;
+-      ESTREAM_LIST_UNLOCK;
++      if (!with_locked_list)
++        ESTREAM_LIST_UNLOCK;
+       ret = 0;
+     }
+@@ -283,11 +358,12 @@ es_list_add (estream_t stream)
+ /* Remove STREAM from the list of registered stream objects.  */
+ static void
+-es_list_remove (estream_t stream)
++es_list_remove (estream_t stream, int with_locked_list)
+ {
+   estream_list_t list_obj;
+   
+-  ESTREAM_LIST_LOCK;
++  if (!with_locked_list)
++    ESTREAM_LIST_LOCK;
+   for (list_obj = estream_list; list_obj; list_obj = list_obj->cdr)
+     if (list_obj->car == stream)
+       {
+@@ -297,7 +373,8 @@ es_list_remove (estream_t stream)
+       mem_free (list_obj);
+       break;
+       }
+-  ESTREAM_LIST_UNLOCK;
++  if (!with_locked_list)
++    ESTREAM_LIST_UNLOCK;
+ }
+ /* Type of an stream-iterator-function.  */
+@@ -360,6 +437,14 @@ es_pth_write (int fd, const void *buffer
\f
++static void
++es_deinit (void)
++{
++  /* Flush all streams. */
++  es_fflush (NULL);
++}
++
++
+ /*
+  * Initialization.
+  */
+@@ -367,17 +452,20 @@ es_pth_write (int fd, const void *buffer
+ static int
+ es_init_do (void)
+ {
+-#ifdef HAVE_PTH
+   static int initialized;
+   if (!initialized)
+     {
++#ifdef HAVE_PTH
+       if (!pth_init () && errno != EPERM )
+         return -1;
+       if (pth_mutex_init (&estream_list_lock))
+         initialized = 1;
+-    }
++#else
++      initialized = 1;
+ #endif
++      atexit (es_deinit);  
++    }
+   return 0;
+ }
+@@ -427,7 +515,7 @@ es_func_mem_create (void *ES__RESTRICT *
+   if (!data && (data_n || data_len))
+     {
+-      errno = EINVAL;
++      _set_errno (EINVAL);
+       return -1;
+     }
+@@ -511,7 +599,7 @@ es_func_mem_write (void *cookie, const v
+         newsize = mem_cookie->memory_size + (nleft - size);
+       if (newsize < mem_cookie->offset)
+         {
+-          errno = EINVAL;
++          _set_errno (EINVAL);
+           return -1;
+         }
+@@ -522,7 +610,7 @@ es_func_mem_write (void *cookie, const v
+           newsize += mem_cookie->block_size - 1;
+           if (newsize < mem_cookie->offset)
+             {
+-              errno = EINVAL;
++              _set_errno (EINVAL);
+               return -1;
+             }
+           newsize /= mem_cookie->block_size;
+@@ -532,7 +620,7 @@ es_func_mem_write (void *cookie, const v
+       /* Check for a total limit.  */
+       if (mem_cookie->memory_limit && newsize > mem_cookie->memory_limit)
+         {
+-          errno = ENOSPC;
++          _set_errno (ENOSPC);
+           return -1;
+         }
+       
+@@ -581,7 +669,7 @@ es_func_mem_seek (void *cookie, off_t *o
+       break;
+     default:
+-      errno = EINVAL;
++      _set_errno (EINVAL);
+       return -1;
+     }
+@@ -592,14 +680,14 @@ es_func_mem_seek (void *cookie, off_t *o
+       if (!mem_cookie->flags.grow)
+       {
+-        errno = ENOSPC;
++        _set_errno (ENOSPC);
+         return -1;
+         }
+       newsize = pos_new + mem_cookie->block_size - 1;
+       if (newsize < pos_new)
+         {
+-          errno = EINVAL;
++          _set_errno (EINVAL);
+           return -1;
+         }
+       newsize /= mem_cookie->block_size;
+@@ -607,7 +695,7 @@ es_func_mem_seek (void *cookie, off_t *o
+       if (mem_cookie->memory_limit && newsize > mem_cookie->memory_limit)
+         {
+-          errno = ENOSPC;
++          _set_errno (ENOSPC);
+           return -1;
+         }
+       
+@@ -703,10 +791,18 @@ es_func_fd_read (void *cookie, void *buf
+ {
+   estream_cookie_fd_t file_cookie = cookie;
+   ssize_t bytes_read;
+-
+-  do 
+-    bytes_read = ESTREAM_SYS_READ (file_cookie->fd, buffer, size);
+-  while (bytes_read == -1 && errno == EINTR);
++  
++  if (IS_INVALID_FD (file_cookie->fd))
++    {
++      ESTREAM_SYS_YIELD ();
++      bytes_read = 0;
++    }
++  else
++    {
++      do 
++        bytes_read = ESTREAM_SYS_READ (file_cookie->fd, buffer, size);
++      while (bytes_read == -1 && errno == EINTR);
++    }
+   return bytes_read;
+ }
+@@ -714,14 +810,21 @@ es_func_fd_read (void *cookie, void *buf
+ /* Write function for fd objects.  */
+ static ssize_t
+ es_func_fd_write (void *cookie, const void *buffer, size_t size)
+-                         
+ {
+   estream_cookie_fd_t file_cookie = cookie;
+   ssize_t bytes_written;
+-  do
+-    bytes_written = ESTREAM_SYS_WRITE (file_cookie->fd, buffer, size);
+-  while (bytes_written == -1 && errno == EINTR);
++  if (IS_INVALID_FD (file_cookie->fd))
++    {
++      ESTREAM_SYS_YIELD ();
++      bytes_written = size; /* Yeah:  Success writing to the bit bucket.  */
++    }
++  else
++    {
++      do
++        bytes_written = ESTREAM_SYS_WRITE (file_cookie->fd, buffer, size);
++      while (bytes_written == -1 && errno == EINTR);
++    }
+   return bytes_written;
+ }
+@@ -734,13 +837,21 @@ es_func_fd_seek (void *cookie, off_t *of
+   off_t offset_new;
+   int err;
+-  offset_new = lseek (file_cookie->fd, *offset, whence);
+-  if (offset_new == -1)
+-    err = -1;
++  if (IS_INVALID_FD (file_cookie->fd))
++    {
++      _set_errno (ESPIPE);
++      err = -1;
++    }
+   else
+     {
+-      *offset = offset_new;
+-      err = 0;
++      offset_new = lseek (file_cookie->fd, *offset, whence);
++      if (offset_new == -1)
++        err = -1;
++      else
++        {
++          *offset = offset_new;
++          err = 0;
++        }
+     }
+   return err;
+@@ -755,7 +866,10 @@ es_func_fd_destroy (void *cookie)
+   if (fd_cookie)
+     {
+-      err = fd_cookie->no_close? 0 : close (fd_cookie->fd);
++      if (IS_INVALID_FD (fd_cookie->fd))
++        err = 0;
++      else
++        err = fd_cookie->no_close? 0 : close (fd_cookie->fd);
+       mem_free (fd_cookie);
+     }
+   else
+@@ -822,7 +936,10 @@ es_func_fp_read (void *cookie, void *buf
+   estream_cookie_fp_t file_cookie = cookie;
+   ssize_t bytes_read;
+-  bytes_read = fread (buffer, 1, size, file_cookie->fp);
++  if (file_cookie->fp)
++    bytes_read = fread (buffer, 1, size, file_cookie->fp);
++  else
++    bytes_read = 0;
+   if (!bytes_read && ferror (file_cookie->fp))
+     return -1;
+   return bytes_read;
+@@ -836,7 +953,11 @@ es_func_fp_write (void *cookie, const vo
+   estream_cookie_fp_t file_cookie = cookie;
+   size_t bytes_written;
+-  bytes_written = fwrite (buffer, 1, size, file_cookie->fp);
++
++  if (file_cookie->fp)
++    bytes_written = fwrite (buffer, 1, size, file_cookie->fp);
++  else
++    bytes_written = size; /* Successfully written to the bit bucket.  */
+   if (bytes_written != size)
+     return -1;
+   return bytes_written;
+@@ -849,23 +970,31 @@ es_func_fp_seek (void *cookie, off_t *of
+   estream_cookie_fp_t file_cookie = cookie;
+   long int offset_new;
++  if (!file_cookie->fp)
++    {
++      _set_errno (ESPIPE);
++      return -1; 
++    }
++
+   if ( fseek (file_cookie->fp, (long int)*offset, whence) )
+     {
+-      fprintf (stderr, "\nfseek failed: errno=%d (%s)\n", errno,strerror (errno));
+-    return -1;
++      /* fprintf (stderr, "\nfseek failed: errno=%d (%s)\n", */
++      /*          errno,strerror (errno)); */
++      return -1;
+     }
+   offset_new = ftell (file_cookie->fp);
+   if (offset_new == -1)
+     {
+-      fprintf (stderr, "\nftell failed: errno=%d (%s)\n", errno,strerror (errno));
+-    return -1;
++      /* fprintf (stderr, "\nftell failed: errno=%d (%s)\n",  */
++      /*          errno,strerror (errno)); */
++      return -1;
+     }
+   *offset = offset_new;
+   return 0;
+ }
+-/* Destroy function for fd objects.  */
++/* Destroy function for FILE* objects.  */
+ static int
+ es_func_fp_destroy (void *cookie)
+ {
+@@ -874,8 +1003,13 @@ es_func_fp_destroy (void *cookie)
+   if (fp_cookie)
+     {
+-      fflush (fp_cookie->fp);
+-      err = fp_cookie->no_close? 0 : fclose (fp_cookie->fp);
++      if (fp_cookie->fp)
++        {
++          fflush (fp_cookie->fp);
++          err = fp_cookie->no_close? 0 : fclose (fp_cookie->fp);
++        }
++      else
++        err = 0;
+       mem_free (fp_cookie);
+     }
+   else
+@@ -942,14 +1076,6 @@ es_func_file_create (void **cookie, int 
+   return err;
+ }
+-static es_cookie_io_functions_t estream_functions_file =
+-  {
+-    es_func_fd_read,
+-    es_func_fd_write,
+-    es_func_fd_seek,
+-    es_func_fd_destroy
+-  };
+-
\f
+ static int
+ es_convert_mode (const char *mode, unsigned int *modeflags)
+@@ -971,7 +1097,7 @@ es_convert_mode (const char *mode, unsig
+       oflags = O_APPEND | O_CREAT;
+       break;
+     default:
+-      errno = EINVAL;
++      _set_errno (EINVAL);
+       return -1;
+     }
+   for (mode++; *mode; mode++)
+@@ -1010,7 +1136,7 @@ es_fill (estream_t stream)
+   if (!stream->intern->func_read)
+     {
+-      errno = EOPNOTSUPP;
++      _set_errno (EOPNOTSUPP);
+       err = -1;
+     }
+   else
+@@ -1144,7 +1270,11 @@ es_initialize (estream_t stream,
+   stream->intern->print_fp = NULL;
+   stream->intern->indicators.err = 0;
+   stream->intern->indicators.eof = 0;
++  stream->intern->is_stdstream = 0;
++  stream->intern->stdstream_fd = 0;
+   stream->intern->deallocate_buffer = 0;
++  stream->intern->printable_fname = NULL;
++  stream->intern->printable_fname_inuse = 0;
+   stream->data_len = 0;
+   stream->data_offset = 0;
+@@ -1152,7 +1282,7 @@ es_initialize (estream_t stream,
+   stream->unread_data_len = 0;
+   /* Depending on the modeflags we set whether we start in writing or
+      reading mode.  This is required in case we are working on a
+-     wronly stream which is not seeekable (like stdout).  Without this
++     stream which is not seeekable (like stdout).  Without this
+      pre-initialization we would do a seek at the first write call and
+      as this will fail no utput will be delivered. */
+   if ((modeflags & O_WRONLY) || (modeflags & O_RDWR) )
+@@ -1173,7 +1303,7 @@ es_deinitialize (estream_t stream)
+       int save_errno = errno;
+       fclose (stream->intern->print_fp);
+       stream->intern->print_fp = NULL;
+-      errno = save_errno;
++      _set_errno (save_errno);
+     }
+   func_close = stream->intern->func_close;
+@@ -1184,14 +1314,18 @@ es_deinitialize (estream_t stream)
+   if (func_close)
+     SET_UNLESS_NONZERO (err, tmp_err, (*func_close) (stream->intern->cookie));
+-  
++  mem_free (stream->intern->printable_fname);
++  stream->intern->printable_fname = NULL;
++  stream->intern->printable_fname_inuse = 0;
++
+   return err;
+ }
+ /* Create a new stream object, initialize it.  */
+ static int
+ es_create (estream_t *stream, void *cookie, int fd,
+-         es_cookie_io_functions_t functions, unsigned int modeflags)
++         es_cookie_io_functions_t functions, unsigned int modeflags,
++           int with_locked_list)
+ {
+   estream_internal_t stream_internal_new;
+   estream_t stream_new;
+@@ -1223,7 +1357,7 @@ es_create (estream_t *stream, void *cook
+   ESTREAM_MUTEX_INITIALIZE (stream_new->intern->lock);
+   es_initialize (stream_new, cookie, fd, functions, modeflags);
+-  err = es_list_add (stream_new);
++  err = es_list_add (stream_new, with_locked_list);
+   if (err)
+     goto out;
+@@ -1245,13 +1379,13 @@ es_create (estream_t *stream, void *cook
+ /* Deinitialize a stream object and destroy it.  */
+ static int
+-es_destroy (estream_t stream)
++es_destroy (estream_t stream, int with_locked_list)
+ {
+   int err = 0;
+   if (stream)
+     {
+-      es_list_remove (stream);
++      es_list_remove (stream, with_locked_list);
+       err = es_deinitialize (stream);
+       mem_free (stream->intern);
+       mem_free (stream);
+@@ -1460,7 +1594,7 @@ es_seek (estream_t ES__RESTRICT stream, 
+   if (! func_seek)
+     {
+-      errno = EOPNOTSUPP;
++      _set_errno (EOPNOTSUPP);
+       err = -1;
+       goto out;
+     }
+@@ -1730,7 +1864,7 @@ es_skip (estream_t stream, size_t size)
+   if (stream->data_offset + size > stream->data_len)
+     {
+-      errno = EINVAL;
++      _set_errno (EINVAL);
+       err = -1;
+     }
+   else
+@@ -1771,7 +1905,7 @@ doreadline (estream_t ES__RESTRICT strea
+     goto out;
+   err = es_create (&line_stream, line_stream_cookie, -1,
+-                 estream_functions_mem, O_RDWR);
++                 estream_functions_mem, O_RDWR, 0);
+   if (err)
+     goto out;
+@@ -1856,7 +1990,7 @@ doreadline (estream_t ES__RESTRICT strea
+  out:
+   if (line_stream)
+-    es_destroy (line_stream);
++    es_destroy (line_stream, 0);
+   else if (line_stream_cookie)
+     es_func_mem_destroy (line_stream_cookie);
+@@ -1961,6 +2095,8 @@ es_set_buffering (estream_t ES__RESTRICT
+       buffer_new = buffer;
+       else
+       {
++          if (!size)
++            size = BUFSIZ;
+         buffer_new = mem_alloc (size);
+         if (! buffer_new)
+           {
+@@ -2053,14 +2189,17 @@ es_fopen (const char *ES__RESTRICT path,
+     goto out;
+   create_called = 1;
+-  err = es_create (&stream, cookie, fd, estream_functions_file, modeflags);
++  err = es_create (&stream, cookie, fd, estream_functions_fd, modeflags, 0);
+   if (err)
+     goto out;
++  if (stream && path)
++    fname_set_internal (stream, path, 1);
++
+  out:
+   
+   if (err && create_called)
+-    (*estream_functions_file.func_close) (cookie);
++    (*estream_functions_fd.func_close) (cookie);
+   return stream;
+ }
+@@ -2093,7 +2232,7 @@ es_mopen (unsigned char *ES__RESTRICT da
+     goto out;
+   
+   create_called = 1;
+-  err = es_create (&stream, cookie, -1, estream_functions_mem, modeflags);
++  err = es_create (&stream, cookie, -1, estream_functions_mem, modeflags, 0);
+  out:
+@@ -2124,7 +2263,7 @@ es_fopenmem (size_t memlimit, const char
+                           memlimit))
+     return NULL;
+   
+-  if (es_create (&stream, cookie, -1, estream_functions_mem, modeflags))
++  if (es_create (&stream, cookie, -1, estream_functions_mem, modeflags, 0))
+     (*estream_functions_mem.func_close) (cookie);
+   return stream;
+@@ -2148,7 +2287,7 @@ es_fopencookie (void *ES__RESTRICT cooki
+   if (err)
+     goto out;
+-  err = es_create (&stream, cookie, -1, functions, modeflags);
++  err = es_create (&stream, cookie, -1, functions, modeflags, 0);
+   if (err)
+     goto out;
+@@ -2159,7 +2298,7 @@ es_fopencookie (void *ES__RESTRICT cooki
+ estream_t
+-do_fdopen (int filedes, const char *mode, int no_close)
++do_fdopen (int filedes, const char *mode, int no_close, int with_locked_list)
+ {
+   unsigned int modeflags;
+   int create_called;
+@@ -2180,7 +2319,8 @@ do_fdopen (int filedes, const char *mode
+     goto out;
+   create_called = 1;
+-  err = es_create (&stream, cookie, filedes, estream_functions_fd, modeflags);
++  err = es_create (&stream, cookie, filedes, estream_functions_fd,
++                   modeflags, with_locked_list);
+  out:
+@@ -2193,19 +2333,19 @@ do_fdopen (int filedes, const char *mode
+ estream_t
+ es_fdopen (int filedes, const char *mode)
+ {
+-  return do_fdopen (filedes, mode, 0);
++  return do_fdopen (filedes, mode, 0, 0);
+ }
+ /* A variant of es_fdopen which does not close FILEDES at the end.  */
+ estream_t
+ es_fdopen_nc (int filedes, const char *mode)
+ {
+-  return do_fdopen (filedes, mode, 1);
++  return do_fdopen (filedes, mode, 1, 0);
+ }
+ estream_t
+-do_fpopen (FILE *fp, const char *mode, int no_close)
++do_fpopen (FILE *fp, const char *mode, int no_close, int with_locked_list)
+ {
+   unsigned int modeflags;
+   int create_called;
+@@ -2221,14 +2361,15 @@ do_fpopen (FILE *fp, const char *mode, i
+   if (err)
+     goto out;
+-  fflush (fp);
++  if (fp)
++    fflush (fp);
+   err = es_func_fp_create (&cookie, fp, modeflags, no_close);
+   if (err)
+     goto out;
+-
++  
+   create_called = 1;
+-  err = es_create (&stream, cookie, fileno (fp), estream_functions_fp,
+-                   modeflags);
++  err = es_create (&stream, cookie, fp? fileno (fp):-1, estream_functions_fp,
++                   modeflags, with_locked_list);
+  out:
+@@ -2250,7 +2391,7 @@ do_fpopen (FILE *fp, const char *mode, i
+ estream_t
+ es_fpopen (FILE *fp, const char *mode)
+ {
+-  return do_fpopen (fp, mode, 0);
++  return do_fpopen (fp, mode, 0, 0);
+ }
+@@ -2258,7 +2399,86 @@ es_fpopen (FILE *fp, const char *mode)
+ estream_t
+ es_fpopen_nc (FILE *fp, const char *mode)
+ {
+-  return do_fpopen (fp, mode, 1);
++  return do_fpopen (fp, mode, 1, 0);
++}
++
++
++/* Set custom standard descriptors to be used for stdin, stdout and
++   stderr.  This function needs to be called before any of the
++   standard streams are accessed.  */
++void
++_es_set_std_fd (int no, int fd)
++{
++  ESTREAM_LIST_LOCK;
++  if (no >= 0 && no < 3 && !custom_std_fds_valid[no])
++    {
++      custom_std_fds[no] = fd;
++      custom_std_fds_valid[no] = 1;
++    }
++  ESTREAM_LIST_UNLOCK;
++}
++
++
++/* Return the stream used for stdin, stdout or stderr.  */
++estream_t
++_es_get_std_stream (int fd)
++{
++  estream_list_t list_obj;
++  estream_t stream = NULL;
++
++  fd %= 3; /* We only allow 0, 1 or 2 but we don't want to return an error. */
++  ESTREAM_LIST_LOCK;
++  for (list_obj = estream_list; list_obj; list_obj = list_obj->cdr)
++    if (list_obj->car->intern->is_stdstream
++        && list_obj->car->intern->stdstream_fd == fd)
++      {
++      stream = list_obj->car;
++      break;
++      }
++  if (!stream)
++    {
++      /* Standard stream not yet created.  We first try to create them
++         from registered file descriptors.  */
++      if (!fd && custom_std_fds_valid[0])
++        stream = do_fdopen (custom_std_fds[0], "r", 1, 1);
++      else if (fd == 1 && custom_std_fds_valid[1])
++        stream = do_fdopen (custom_std_fds[1], "a", 1, 1);
++      else if (custom_std_fds_valid[2])
++        stream = do_fdopen (custom_std_fds[2], "a", 1, 1);
++      
++      if (!stream)
++        {
++          /* Second try is to use the standard C streams.  */
++          if (!fd)
++            stream = do_fpopen (stdin, "r", 1, 1);
++          else if (fd == 1)
++            stream = do_fpopen (stdout, "a", 1, 1);
++          else
++            stream = do_fpopen (stderr, "a", 1, 1);
++        }
++      
++      if (!stream) 
++        {
++          /* Last try: Create a bit bucket.  */
++          stream = do_fpopen (NULL, fd? "a":"r", 0, 1);
++          if (!stream)
++            {
++              fprintf (stderr, "fatal: error creating a dummy estream"
++                       " for %d: %s\n", fd, strerror (errno));
++              abort();
++            }
++        }
++
++      stream->intern->is_stdstream = 1;
++      stream->intern->stdstream_fd = fd;
++      if (fd == 2)
++        es_set_buffering (stream, NULL, _IOLBF, 0);
++      fname_set_internal (stream, 
++                          fd == 0? "[stdin]" :
++                          fd == 1? "[stdout]" : "[stderr]", 0);
++    }
++  ESTREAM_LIST_UNLOCK;
++  return stream;
+ }
+@@ -2291,7 +2511,7 @@ es_freopen (const char *ES__RESTRICT pat
+       goto leave;
+       create_called = 1;
+-      es_initialize (stream, cookie, fd, estream_functions_file, modeflags);
++      es_initialize (stream, cookie, fd, estream_functions_fd, modeflags);
+     leave:
+@@ -2300,18 +2520,22 @@ es_freopen (const char *ES__RESTRICT pat
+         if (create_called)
+           es_func_fd_destroy (cookie);
+       
+-        es_destroy (stream);
++        es_destroy (stream, 0);
+         stream = NULL;
+       }
+       else
+-      ESTREAM_UNLOCK (stream);
++        {
++          if (stream && path)
++            fname_set_internal (stream, path, 1);
++          ESTREAM_UNLOCK (stream);
++        }
+     }
+   else
+     {
+       /* FIXME?  We don't support re-opening at the moment.  */
+-      errno = EINVAL;
++      _set_errno (EINVAL);
+       es_deinitialize (stream);
+-      es_destroy (stream);
++      es_destroy (stream, 0);
+       stream = NULL;
+     }
+@@ -2324,7 +2548,7 @@ es_fclose (estream_t stream)
+ {
+   int err;
+-  err = es_destroy (stream);
++  err = es_destroy (stream, 0);
+   return err;
+ }
+@@ -2426,6 +2650,23 @@ es_clearerr (estream_t stream)
+ }
++static int
++do_fflush (estream_t stream)
++{
++  int err;
++  
++  if (stream->flags.writing)
++    err = es_flush (stream);
++  else
++    {
++      es_empty (stream);
++      err = 0;
++    }
++
++  return err;
++}
++
++
+ int
+ es_fflush (estream_t stream)
+ {
+@@ -2434,17 +2675,11 @@ es_fflush (estream_t stream)
+   if (stream)
+     {
+       ESTREAM_LOCK (stream);
+-      if (stream->flags.writing)
+-      err = es_flush (stream);
+-      else
+-      {
+-        es_empty (stream);
+-        err = 0;
+-      }
++      err = do_fflush (stream);
+       ESTREAM_UNLOCK (stream);
+     }
+   else
+-    err = es_list_iterate (es_fflush);
++    err = es_list_iterate (do_fflush);
+   return err ? EOF : 0;
+ }
+@@ -2691,6 +2926,17 @@ es_fgets (char *ES__RESTRICT buffer, int
+ int
++es_fputs_unlocked (const char *ES__RESTRICT s, estream_t ES__RESTRICT stream)
++{
++  size_t length;
++  int err;
++
++  length = strlen (s);
++  err = es_writen (stream, s, length, NULL);
++  return err ? EOF : 0;
++}
++
++int
+ es_fputs (const char *ES__RESTRICT s, estream_t ES__RESTRICT stream)
+ {
+   size_t length;
+@@ -2821,7 +3067,7 @@ es_read_line (estream_t stream, 
+     {
+       /* This should never happen. If it does, the function has been
+          called with wrong arguments. */
+-      errno = EINVAL;
++      _set_errno (EINVAL);
+       return -1;
+     }
+   length -= 3; /* Reserve 3 bytes for CR,LF,EOL. */
+@@ -2855,7 +3101,7 @@ es_read_line (estream_t stream, 
+               if (max_length)
+                 *max_length = 0;
+               ESTREAM_UNLOCK (stream);
+-              errno = save_errno;
++              _set_errno (save_errno);
+               return -1;
+             }
+           buffer = *addr_of_buffer;
+@@ -2885,6 +3131,15 @@ es_free (void *a)
+ int
++es_vfprintf_unlocked (estream_t ES__RESTRICT stream,
++                      const char *ES__RESTRICT format,
++                      va_list ap)
++{
++  return es_print (stream, format, ap);
++}
++
++
++int
+ es_vfprintf (estream_t ES__RESTRICT stream, const char *ES__RESTRICT format,
+            va_list ap)
+ {
+@@ -2898,9 +3153,9 @@ es_vfprintf (estream_t ES__RESTRICT stre
+ }
+-static int
++int
+ es_fprintf_unlocked (estream_t ES__RESTRICT stream,
+-           const char *ES__RESTRICT format, ...)
++                     const char *ES__RESTRICT format, ...)
+ {
+   int ret;
+   
+@@ -2973,21 +3228,32 @@ tmpfd (void)
+ {
+ #ifdef HAVE_W32_SYSTEM
+   int attempts, n;
++#ifdef HAVE_W32CE_SYSTEM
++  wchar_t buffer[MAX_PATH+9+12+1];
++# define mystrlen(a) wcslen (a)
++  wchar_t *name, *p;
++#else
+   char buffer[MAX_PATH+9+12+1];
++# define mystrlen(a) strlen (a)
+   char *name, *p;
++#endif
+   HANDLE file;
+   int pid = GetCurrentProcessId ();
+   unsigned int value;
+   int i;
+   
+   n = GetTempPath (MAX_PATH+1, buffer);
+-  if (!n || n > MAX_PATH || strlen (buffer) > MAX_PATH)
++  if (!n || n > MAX_PATH || mystrlen (buffer) > MAX_PATH)
+     {
+-      errno = ENOENT;
++      _set_errno (ENOENT);
+       return -1;
+     }
+-  p = buffer + strlen (buffer);
++  p = buffer + mystrlen (buffer);
++#ifdef HAVE_W32CE_SYSTEM
++  wcscpy (p, L"_estream");
++#else
+   strcpy (p, "_estream");
++#endif
+   p += 8;
+   /* We try to create the directory but don't care about an error as
+      it may already exist and the CreateFile would throw an error
+@@ -3004,7 +3270,11 @@ tmpfd (void)
+           *p++ = tohex (((value >> 28) & 0x0f));
+           value <<= 4;
+         }
++#ifdef HAVE_W32CE_SYSTEM
++      wcscpy (p, L".tmp");
++#else
+       strcpy (p, ".tmp");
++#endif
+       file = CreateFile (buffer,
+                          GENERIC_READ | GENERIC_WRITE,
+                          0,
+@@ -3014,17 +3284,21 @@ tmpfd (void)
+                          NULL);
+       if (file != INVALID_HANDLE_VALUE)
+         {
++#ifdef HAVE_W32CE_SYSTEM
++          int fd = (int)file;
++#else
+           int fd = _open_osfhandle ((long)file, 0);
+           if (fd == -1)
+             {
+               CloseHandle (file);
+               return -1;
+             }
++#endif
+           return fd;
+         }
+       Sleep (1); /* One ms as this is the granularity of GetTickCount.  */
+     }
+-  errno = ENOENT;
++  _set_errno (ENOENT);
+   return -1;
+ #else /*!HAVE_W32_SYSTEM*/
+   FILE *fp;
+@@ -3077,7 +3351,7 @@ es_tmpfile (void)
+     goto out;
+   create_called = 1;
+-  err = es_create (&stream, cookie, fd, estream_functions_fd, modeflags);
++  err = es_create (&stream, cookie, fd, estream_functions_fd, modeflags, 0);
+  out:
+@@ -3100,8 +3374,8 @@ es_setvbuf (estream_t ES__RESTRICT strea
+ {
+   int err;
+   
+-  if (((type == _IOFBF) || (type == _IOLBF) || (type == _IONBF))
+-      && (! ((! size) && (type != _IONBF))))
++  if ((type == _IOFBF || type == _IOLBF || type == _IONBF)
++      && (!buf || size || type == _IONBF))
+     {
+       ESTREAM_LOCK (stream);
+       err = es_set_buffering (stream, buf, type, size);
+@@ -3109,7 +3383,7 @@ es_setvbuf (estream_t ES__RESTRICT strea
+     }
+   else
+     {
+-      errno = EINVAL;
++      _set_errno (EINVAL);
+       err = -1;
+     }
+@@ -3146,6 +3420,68 @@ es_opaque_get (estream_t stream)
+   return opaque;
+ }
++
++static void
++fname_set_internal (estream_t stream, const char *fname, int quote)
++{
++  if (stream->intern->printable_fname
++      && !stream->intern->printable_fname_inuse)
++    {
++      mem_free (stream->intern->printable_fname);
++      stream->intern->printable_fname = NULL;
++    }
++  if (stream->intern->printable_fname)
++    return; /* Can't change because it is in use.  */
++
++  if (*fname != '[')
++    quote = 0;
++  else
++    quote = !!quote;
++
++  stream->intern->printable_fname = mem_alloc (strlen (fname) + quote + 1);
++  if (fname)
++    {
++      if (quote)
++        stream->intern->printable_fname[0] = '\\';
++      strcpy (stream->intern->printable_fname+quote, fname);
++    }
++}
++
++
++/* Set the filename attribute of STREAM.  There is no error return.
++   as long as STREAM is valid.  This function is called internally by
++   functions which open a filename.  */
++void
++es_fname_set (estream_t stream, const char *fname)
++{
++  if (fname)
++    {
++      ESTREAM_LOCK (stream);
++      fname_set_internal (stream, fname, 1);
++      ESTREAM_UNLOCK (stream);
++    }
++}
++
++
++/* Return the filename attribute of STREAM.  In case no filename has
++   been set, "[?]" will be returned.  The returned file name is valid
++   as long as STREAM is valid.  */
++const char *
++es_fname_get (estream_t stream)
++{
++  const char *fname;
++
++  ESTREAM_LOCK (stream);
++  fname = stream->intern->printable_fname;
++  if (fname)
++    stream->intern->printable_fname_inuse = 1;
++  ESTREAM_UNLOCK (stream);
++  if (!fname)
++    fname = "[?]";
++  return fname;
++}
++
++
+ /* Print a BUFFER to STREAM while replacing all control characters and
+    the characters in DELIMITERS by standard C escape sequences.
+    Returns 0 on success or -1 on error.  If BYTES_WRITTEN is not NULL
+--- common/estream.h   2009-09-21 18:53:51.000000000 +0200
++++ common/estream.h   2010-06-07 11:59:23.000000000 +0200
+@@ -1,5 +1,5 @@
+ /* estream.h - Extended stream I/O Library
+- * Copyright (C) 2004, 2005, 2006, 2007 g10 Code GmbH
++ * Copyright (C) 2004, 2005, 2006, 2007, 2010 g10 Code GmbH
+  *
+  * This file is part of Libestream.
+  *
+@@ -15,6 +15,40 @@
+  *
+  * You should have received a copy of the GNU General Public License
+  * along with Libestream; if not, see <http://www.gnu.org/licenses/>.
++ *
++ * ALTERNATIVELY, Libestream may be distributed under the terms of the
++ * following license, in which case the provisions of this license are
++ * required INSTEAD OF the GNU General Public License. If you wish to
++ * allow use of your version of this file only under the terms of the
++ * GNU General Public License, and not to allow others to use your
++ * version of this file under the terms of the following license,
++ * indicate your decision by deleting this paragraph and the license
++ * below.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions
++ * are met:
++ * 1. Redistributions of source code must retain the above copyright
++ *    notice, and the entire permission notice in its entirety,
++ *    including the disclaimer of warranties.
++ * 2. Redistributions in binary form must reproduce the above copyright
++ *    notice, this list of conditions and the following disclaimer in the
++ *    documentation and/or other materials provided with the distribution.
++ * 3. The name of the author may not be used to endorse or promote
++ *    products derived from this software without specific prior
++ *    written permission.
++ *
++ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
++ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
++ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
++ * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
++ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
++ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
++ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
++ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
++ * OF THE POSSIBILITY OF SUCH DAMAGE.
+  */
+ #ifndef ESTREAM_H
+@@ -46,6 +80,8 @@
+ #define es_fdopen_nc          _ESTREAM_PREFIX(es_fdopen_nc)
+ #define es_fpopen             _ESTREAM_PREFIX(es_fpopen)
+ #define es_fpopen_nc          _ESTREAM_PREFIX(es_fpopen_nc)
++#define _es_set_std_fd        _ESTREAM_PREFIX(_es_set_std_fd)
++#define _es_get_std_stream    _ESTREAM_PREFIX(_es_get_std_stream)
+ #define es_freopen            _ESTREAM_PREFIX(es_freopen)
+ #define es_fopencookie        _ESTREAM_PREFIX(es_fopencookie)
+ #define es_fclose             _ESTREAM_PREFIX(es_fclose)
+@@ -79,16 +115,21 @@
+ #define es_fwrite             _ESTREAM_PREFIX(es_fwrite)
+ #define es_fgets              _ESTREAM_PREFIX(es_fgets)
+ #define es_fputs              _ESTREAM_PREFIX(es_fputs)
++#define es_fputs_unlocked     _ESTREAM_PREFIX(es_fputs_unlocked)
+ #define es_getline            _ESTREAM_PREFIX(es_getline)
+ #define es_read_line          _ESTREAM_PREFIX(es_read_line)
+ #define es_free               _ESTREAM_PREFIX(es_free)
+-#define es_fprf               _ESTREAM_PREFIX(es_fprf)
+-#define es_vfprf              _ESTREAM_PREFIX(es_vfprf)
++#define es_fprintf            _ESTREAM_PREFIX(es_fprintf)
++#define es_fprintf_unlocked   _ESTREAM_PREFIX(es_fprintf_unlocked)
++#define es_vfprintf           _ESTREAM_PREFIX(es_vfprint)
++#define es_vfprintf_unlocked  _ESTREAM_PREFIX(es_vfprint_unlocked)
+ #define es_setvbuf            _ESTREAM_PREFIX(es_setvbuf)
+ #define es_setbuf             _ESTREAM_PREFIX(es_setbuf)
+ #define es_tmpfile            _ESTREAM_PREFIX(es_tmpfile)
+ #define es_opaque_set         _ESTREAM_PREFIX(es_opaque_set)
+ #define es_opaque_get         _ESTREAM_PREFIX(es_opaque_get)
++#define es_fname_set          _ESTREAM_PREFIX(es_fname_set)
++#define es_fname_get          _ESTREAM_PREFIX(es_fname_get)
+ #define es_write_sanitized_utf8_buffer  \
+               _ESTREAM_PREFIX(es_write_sanitized_utf8_buffer)
+ #endif /*_ESTREAM_EXT_SYM_PREFIX*/
+@@ -213,6 +254,14 @@ int es_fclose (estream_t stream);
+ int es_fileno (estream_t stream);
+ int es_fileno_unlocked (estream_t stream);
++void _es_set_std_fd (int no, int fd);
++estream_t _es_get_std_stream (int fd);
++
++#define es_stdin  _es_get_std_stream (0)
++#define es_stdout _es_get_std_stream (1)
++#define es_stderr _es_get_std_stream (2)
++
++
+ void es_flockfile (estream_t stream);
+ int es_ftrylockfile (estream_t stream);
+ void es_funlockfile (estream_t stream);
+@@ -277,6 +326,8 @@ size_t es_fwrite (const void *ES__RESTRI
+ char *es_fgets (char *ES__RESTRICT s, int n, estream_t ES__RESTRICT stream);
+ int es_fputs (const char *ES__RESTRICT s, estream_t ES__RESTRICT stream);
++int es_fputs_unlocked (const char *ES__RESTRICT s,
++                       estream_t ES__RESTRICT stream);
+ ssize_t es_getline (char *ES__RESTRICT *ES__RESTRICT lineptr,
+                   size_t *ES__RESTRICT n,
+@@ -289,9 +340,17 @@ void es_free (void *a);
+ int es_fprintf (estream_t ES__RESTRICT stream,
+               const char *ES__RESTRICT format, ...)
+      _ESTREAM_GCC_A_PRINTF(2,3);
++int es_fprintf_unlocked (estream_t ES__RESTRICT stream,
++                         const char *ES__RESTRICT format, ...)
++     _ESTREAM_GCC_A_PRINTF(2,3);
++
+ int es_vfprintf (estream_t ES__RESTRICT stream,
+                const char *ES__RESTRICT format, va_list ap)
+      _ESTREAM_GCC_A_PRINTF(2,0);
++int es_vfprintf_unlocked (estream_t ES__RESTRICT stream,
++                          const char *ES__RESTRICT format, va_list ap)
++     _ESTREAM_GCC_A_PRINTF(2,0);
++
+ int es_setvbuf (estream_t ES__RESTRICT stream,
+               char *ES__RESTRICT buf, int mode, size_t size);
+ void es_setbuf (estream_t ES__RESTRICT stream, char *ES__RESTRICT buf);
+@@ -301,6 +360,9 @@ estream_t es_tmpfile (void);
+ void es_opaque_set (estream_t ES__RESTRICT stream, void *ES__RESTRICT opaque);
+ void *es_opaque_get (estream_t stream);
++void es_fname_set (estream_t stream, const char *fname);
++const char *es_fname_get (estream_t stream);
++
+ #ifdef GNUPG_MAJOR_VERSION
+ int es_write_sanitized_utf8_buffer (estream_t stream,
+@@ -309,7 +371,6 @@ int es_write_sanitized_utf8_buffer (estr
+                                     size_t *bytes_written);
+ #endif /*GNUPG_MAJOR_VERSION*/
+-
+ #ifdef __cplusplus
+ }
+ #endif
diff --git a/patches/gnupg2-2.0.16/02-gpgtar.patch b/patches/gnupg2-2.0.16/02-gpgtar.patch
new file mode 100755 (executable)
index 0000000..712a131
--- /dev/null
@@ -0,0 +1,2351 @@
+#! /bin/sh
+patch -p1 -f $* < $0
+exit $?
+
+2010-07-19  Werner Koch  <wk@g10code.com>
+
+       * Makefile.am (bin_PROGRAMS): Add gpgtar.
+       (gpgtar_SOURCES, gpgtar_CFLAGS, gpgtar_LDADD): New.
+
+        * gpgtar.c, gpgtar.h, gpgtar-create.c, gpgtar-extract.c
+        * gpgtar-list.c: New.  Take from GnuPG trunk and add missing
+         functions.
+
+diff -urNp orig/gnupg-2.0.16/tools/Makefile.am gnupg-2.0.16/tools/Makefile.am
+--- orig/gnupg-2.0.16/tools/Makefile.am        2009-09-21 18:53:44.000000000 +0200
++++ gnupg-2.0.16/tools/Makefile.am     2010-07-19 10:51:22.000000000 +0200
+@@ -42,7 +42,7 @@ else
+   symcryptrun =
+ endif
+-bin_PROGRAMS = gpgconf gpg-connect-agent gpgkey2ssh ${symcryptrun}
++bin_PROGRAMS = gpgconf gpg-connect-agent gpgkey2ssh ${symcryptrun} gpgtar
+ if !HAVE_W32_SYSTEM
+ bin_PROGRAMS += watchgnupg gpgparsemail
+ endif
+@@ -99,6 +99,15 @@ gpg_check_pattern_LDADD = $(common_libs)
+                           $(LIBINTL) $(LIBICONV) $(W32SOCKLIBS)
+ endif
++gpgtar_SOURCES = \
++      gpgtar.c gpgtar.h \
++      gpgtar-create.c \
++      gpgtar-extract.c \
++      gpgtar-list.c \
++      no-libgcrypt.c
++gpgtar_CFLAGS = $(GPG_ERROR_CFLAGS)
++gpgtar_LDADD = $(common_libs) $(GPG_ERROR_LIBS) $(W32SOCKLIBS)
++
+ # Make sure that all libs are build before we use them.  This is
+ # important for things like make -j2.
+ $(PROGRAMS): $(common_libs) $(pwquery_libs) ../common/libgpgrl.a
+diff -urNp orig/gnupg-2.0.16/tools/Makefile.in gnupg-2.0.16/tools/Makefile.in
+--- orig/gnupg-2.0.16/tools/Makefile.in        2010-07-19 09:05:41.000000000 +0200
++++ gnupg-2.0.16/tools/Makefile.in     2010-07-19 10:53:02.000000000 +0200
+@@ -87,7 +87,8 @@ DIST_COMMON = $(srcdir)/Makefile.am $(sr
+ @GNUPG_DIRMNGR_PGM_TRUE@am__append_5 = -DGNUPG_DEFAULT_DIRMNGR="\"@GNUPG_DIRMNGR_PGM@\""
+ @GNUPG_PROTECT_TOOL_PGM_TRUE@am__append_6 = -DGNUPG_DEFAULT_PROTECT_TOOL="\"@GNUPG_PROTECT_TOOL_PGM@\""
+ bin_PROGRAMS = gpgconf$(EXEEXT) gpg-connect-agent$(EXEEXT) \
+-      gpgkey2ssh$(EXEEXT) $(am__EXEEXT_1) $(am__EXEEXT_2)
++      gpgkey2ssh$(EXEEXT) $(am__EXEEXT_1) gpgtar$(EXEEXT) \
++      $(am__EXEEXT_2)
+ @HAVE_W32_SYSTEM_FALSE@am__append_7 = watchgnupg gpgparsemail
+ @DISABLE_REGEX_FALSE@libexec_PROGRAMS = gpg-check-pattern$(EXEEXT)
+ noinst_PROGRAMS = clean-sat$(EXEEXT) mk-tdata$(EXEEXT) \
+@@ -173,6 +174,14 @@ gpgsplit_OBJECTS = gpgsplit.$(OBJEXT)
+ gpgsplit_DEPENDENCIES = $(common_libs) $(am__DEPENDENCIES_1) \
+       $(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) \
+       $(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1)
++am_gpgtar_OBJECTS = gpgtar-gpgtar.$(OBJEXT) \
++      gpgtar-gpgtar-create.$(OBJEXT) gpgtar-gpgtar-extract.$(OBJEXT) \
++      gpgtar-gpgtar-list.$(OBJEXT) gpgtar-no-libgcrypt.$(OBJEXT)
++gpgtar_OBJECTS = $(am_gpgtar_OBJECTS)
++gpgtar_DEPENDENCIES = $(common_libs) $(am__DEPENDENCIES_1) \
++      $(am__DEPENDENCIES_1)
++gpgtar_LINK = $(CCLD) $(gpgtar_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) \
++      $(LDFLAGS) -o $@
+ make_dns_cert_SOURCES = make-dns-cert.c
+ make_dns_cert_OBJECTS = make-dns-cert.$(OBJEXT)
+ make_dns_cert_LDADD = $(LDADD)
+@@ -201,13 +210,13 @@ LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(
+ SOURCES = clean-sat.c $(gpg_check_pattern_SOURCES) \
+       $(gpg_connect_agent_SOURCES) $(gpgconf_SOURCES) \
+       $(gpgkey2ssh_SOURCES) $(gpgparsemail_SOURCES) gpgsplit.c \
+-      make-dns-cert.c mk-tdata.c $(symcryptrun_SOURCES) \
+-      $(watchgnupg_SOURCES)
++      $(gpgtar_SOURCES) make-dns-cert.c mk-tdata.c \
++      $(symcryptrun_SOURCES) $(watchgnupg_SOURCES)
+ DIST_SOURCES = clean-sat.c $(am__gpg_check_pattern_SOURCES_DIST) \
+       $(gpg_connect_agent_SOURCES) $(gpgconf_SOURCES) \
+       $(gpgkey2ssh_SOURCES) $(gpgparsemail_SOURCES) gpgsplit.c \
+-      make-dns-cert.c mk-tdata.c $(symcryptrun_SOURCES) \
+-      $(watchgnupg_SOURCES)
++      $(gpgtar_SOURCES) make-dns-cert.c mk-tdata.c \
++      $(symcryptrun_SOURCES) $(watchgnupg_SOURCES)
+ ETAGS = etags
+ CTAGS = ctags
+ DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+@@ -466,6 +475,15 @@ gpgkey2ssh_LDADD = $(common_libs) \
+ @DISABLE_REGEX_FALSE@gpg_check_pattern_LDADD = $(common_libs) $(LIBGCRYPT_LIBS) $(GPG_ERROR_LIBS) \
+ @DISABLE_REGEX_FALSE@                          $(LIBINTL) $(LIBICONV) $(W32SOCKLIBS)
++gpgtar_SOURCES = \
++      gpgtar.c gpgtar.h \
++      gpgtar-create.c \
++      gpgtar-extract.c \
++      gpgtar-list.c \
++      no-libgcrypt.c
++
++gpgtar_CFLAGS = $(GPG_ERROR_CFLAGS)
++gpgtar_LDADD = $(common_libs) $(GPG_ERROR_LIBS) $(W32SOCKLIBS)
+ all: all-am
+ .SUFFIXES:
+@@ -571,6 +589,9 @@ gpgparsemail$(EXEEXT): $(gpgparsemail_OB
+ gpgsplit$(EXEEXT): $(gpgsplit_OBJECTS) $(gpgsplit_DEPENDENCIES) 
+       @rm -f gpgsplit$(EXEEXT)
+       $(LINK) $(gpgsplit_OBJECTS) $(gpgsplit_LDADD) $(LIBS)
++gpgtar$(EXEEXT): $(gpgtar_OBJECTS) $(gpgtar_DEPENDENCIES) 
++      @rm -f gpgtar$(EXEEXT)
++      $(gpgtar_LINK) $(gpgtar_OBJECTS) $(gpgtar_LDADD) $(LIBS)
+ make-dns-cert$(EXEEXT): $(make_dns_cert_OBJECTS) $(make_dns_cert_DEPENDENCIES) 
+       @rm -f make-dns-cert$(EXEEXT)
+       $(LINK) $(make_dns_cert_OBJECTS) $(make_dns_cert_LDADD) $(LIBS)
+@@ -636,6 +657,11 @@ distclean-compile:
+ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gpgkey2ssh-gpgkey2ssh.Po@am__quote@
+ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gpgparsemail.Po@am__quote@
+ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gpgsplit.Po@am__quote@
++@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gpgtar-gpgtar-create.Po@am__quote@
++@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gpgtar-gpgtar-extract.Po@am__quote@
++@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gpgtar-gpgtar-list.Po@am__quote@
++@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gpgtar-gpgtar.Po@am__quote@
++@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gpgtar-no-libgcrypt.Po@am__quote@
+ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/make-dns-cert.Po@am__quote@
+ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mk-tdata.Po@am__quote@
+ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/no-libgcrypt.Po@am__quote@
+@@ -685,6 +711,76 @@ gpgkey2ssh-gpgkey2ssh.obj: gpgkey2ssh.c
+ @AMDEP_TRUE@@am__fastdepCC_FALSE@     DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+ @am__fastdepCC_FALSE@ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(gpgkey2ssh_CFLAGS) $(CFLAGS) -c -o gpgkey2ssh-gpgkey2ssh.obj `if test -f 'gpgkey2ssh.c'; then $(CYGPATH_W) 'gpgkey2ssh.c'; else $(CYGPATH_W) '$(srcdir)/gpgkey2ssh.c'; fi`
++gpgtar-gpgtar.o: gpgtar.c
++@am__fastdepCC_TRUE@  $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(gpgtar_CFLAGS) $(CFLAGS) -MT gpgtar-gpgtar.o -MD -MP -MF $(DEPDIR)/gpgtar-gpgtar.Tpo -c -o gpgtar-gpgtar.o `test -f 'gpgtar.c' || echo '$(srcdir)/'`gpgtar.c
++@am__fastdepCC_TRUE@  mv -f $(DEPDIR)/gpgtar-gpgtar.Tpo $(DEPDIR)/gpgtar-gpgtar.Po
++@AMDEP_TRUE@@am__fastdepCC_FALSE@     source='gpgtar.c' object='gpgtar-gpgtar.o' libtool=no @AMDEPBACKSLASH@
++@AMDEP_TRUE@@am__fastdepCC_FALSE@     DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
++@am__fastdepCC_FALSE@ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(gpgtar_CFLAGS) $(CFLAGS) -c -o gpgtar-gpgtar.o `test -f 'gpgtar.c' || echo '$(srcdir)/'`gpgtar.c
++
++gpgtar-gpgtar.obj: gpgtar.c
++@am__fastdepCC_TRUE@  $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(gpgtar_CFLAGS) $(CFLAGS) -MT gpgtar-gpgtar.obj -MD -MP -MF $(DEPDIR)/gpgtar-gpgtar.Tpo -c -o gpgtar-gpgtar.obj `if test -f 'gpgtar.c'; then $(CYGPATH_W) 'gpgtar.c'; else $(CYGPATH_W) '$(srcdir)/gpgtar.c'; fi`
++@am__fastdepCC_TRUE@  mv -f $(DEPDIR)/gpgtar-gpgtar.Tpo $(DEPDIR)/gpgtar-gpgtar.Po
++@AMDEP_TRUE@@am__fastdepCC_FALSE@     source='gpgtar.c' object='gpgtar-gpgtar.obj' libtool=no @AMDEPBACKSLASH@
++@AMDEP_TRUE@@am__fastdepCC_FALSE@     DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
++@am__fastdepCC_FALSE@ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(gpgtar_CFLAGS) $(CFLAGS) -c -o gpgtar-gpgtar.obj `if test -f 'gpgtar.c'; then $(CYGPATH_W) 'gpgtar.c'; else $(CYGPATH_W) '$(srcdir)/gpgtar.c'; fi`
++
++gpgtar-gpgtar-create.o: gpgtar-create.c
++@am__fastdepCC_TRUE@  $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(gpgtar_CFLAGS) $(CFLAGS) -MT gpgtar-gpgtar-create.o -MD -MP -MF $(DEPDIR)/gpgtar-gpgtar-create.Tpo -c -o gpgtar-gpgtar-create.o `test -f 'gpgtar-create.c' || echo '$(srcdir)/'`gpgtar-create.c
++@am__fastdepCC_TRUE@  mv -f $(DEPDIR)/gpgtar-gpgtar-create.Tpo $(DEPDIR)/gpgtar-gpgtar-create.Po
++@AMDEP_TRUE@@am__fastdepCC_FALSE@     source='gpgtar-create.c' object='gpgtar-gpgtar-create.o' libtool=no @AMDEPBACKSLASH@
++@AMDEP_TRUE@@am__fastdepCC_FALSE@     DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
++@am__fastdepCC_FALSE@ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(gpgtar_CFLAGS) $(CFLAGS) -c -o gpgtar-gpgtar-create.o `test -f 'gpgtar-create.c' || echo '$(srcdir)/'`gpgtar-create.c
++
++gpgtar-gpgtar-create.obj: gpgtar-create.c
++@am__fastdepCC_TRUE@  $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(gpgtar_CFLAGS) $(CFLAGS) -MT gpgtar-gpgtar-create.obj -MD -MP -MF $(DEPDIR)/gpgtar-gpgtar-create.Tpo -c -o gpgtar-gpgtar-create.obj `if test -f 'gpgtar-create.c'; then $(CYGPATH_W) 'gpgtar-create.c'; else $(CYGPATH_W) '$(srcdir)/gpgtar-create.c'; fi`
++@am__fastdepCC_TRUE@  mv -f $(DEPDIR)/gpgtar-gpgtar-create.Tpo $(DEPDIR)/gpgtar-gpgtar-create.Po
++@AMDEP_TRUE@@am__fastdepCC_FALSE@     source='gpgtar-create.c' object='gpgtar-gpgtar-create.obj' libtool=no @AMDEPBACKSLASH@
++@AMDEP_TRUE@@am__fastdepCC_FALSE@     DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
++@am__fastdepCC_FALSE@ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(gpgtar_CFLAGS) $(CFLAGS) -c -o gpgtar-gpgtar-create.obj `if test -f 'gpgtar-create.c'; then $(CYGPATH_W) 'gpgtar-create.c'; else $(CYGPATH_W) '$(srcdir)/gpgtar-create.c'; fi`
++
++gpgtar-gpgtar-extract.o: gpgtar-extract.c
++@am__fastdepCC_TRUE@  $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(gpgtar_CFLAGS) $(CFLAGS) -MT gpgtar-gpgtar-extract.o -MD -MP -MF $(DEPDIR)/gpgtar-gpgtar-extract.Tpo -c -o gpgtar-gpgtar-extract.o `test -f 'gpgtar-extract.c' || echo '$(srcdir)/'`gpgtar-extract.c
++@am__fastdepCC_TRUE@  mv -f $(DEPDIR)/gpgtar-gpgtar-extract.Tpo $(DEPDIR)/gpgtar-gpgtar-extract.Po
++@AMDEP_TRUE@@am__fastdepCC_FALSE@     source='gpgtar-extract.c' object='gpgtar-gpgtar-extract.o' libtool=no @AMDEPBACKSLASH@
++@AMDEP_TRUE@@am__fastdepCC_FALSE@     DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
++@am__fastdepCC_FALSE@ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(gpgtar_CFLAGS) $(CFLAGS) -c -o gpgtar-gpgtar-extract.o `test -f 'gpgtar-extract.c' || echo '$(srcdir)/'`gpgtar-extract.c
++
++gpgtar-gpgtar-extract.obj: gpgtar-extract.c
++@am__fastdepCC_TRUE@  $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(gpgtar_CFLAGS) $(CFLAGS) -MT gpgtar-gpgtar-extract.obj -MD -MP -MF $(DEPDIR)/gpgtar-gpgtar-extract.Tpo -c -o gpgtar-gpgtar-extract.obj `if test -f 'gpgtar-extract.c'; then $(CYGPATH_W) 'gpgtar-extract.c'; else $(CYGPATH_W) '$(srcdir)/gpgtar-extract.c'; fi`
++@am__fastdepCC_TRUE@  mv -f $(DEPDIR)/gpgtar-gpgtar-extract.Tpo $(DEPDIR)/gpgtar-gpgtar-extract.Po
++@AMDEP_TRUE@@am__fastdepCC_FALSE@     source='gpgtar-extract.c' object='gpgtar-gpgtar-extract.obj' libtool=no @AMDEPBACKSLASH@
++@AMDEP_TRUE@@am__fastdepCC_FALSE@     DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
++@am__fastdepCC_FALSE@ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(gpgtar_CFLAGS) $(CFLAGS) -c -o gpgtar-gpgtar-extract.obj `if test -f 'gpgtar-extract.c'; then $(CYGPATH_W) 'gpgtar-extract.c'; else $(CYGPATH_W) '$(srcdir)/gpgtar-extract.c'; fi`
++
++gpgtar-gpgtar-list.o: gpgtar-list.c
++@am__fastdepCC_TRUE@  $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(gpgtar_CFLAGS) $(CFLAGS) -MT gpgtar-gpgtar-list.o -MD -MP -MF $(DEPDIR)/gpgtar-gpgtar-list.Tpo -c -o gpgtar-gpgtar-list.o `test -f 'gpgtar-list.c' || echo '$(srcdir)/'`gpgtar-list.c
++@am__fastdepCC_TRUE@  mv -f $(DEPDIR)/gpgtar-gpgtar-list.Tpo $(DEPDIR)/gpgtar-gpgtar-list.Po
++@AMDEP_TRUE@@am__fastdepCC_FALSE@     source='gpgtar-list.c' object='gpgtar-gpgtar-list.o' libtool=no @AMDEPBACKSLASH@
++@AMDEP_TRUE@@am__fastdepCC_FALSE@     DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
++@am__fastdepCC_FALSE@ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(gpgtar_CFLAGS) $(CFLAGS) -c -o gpgtar-gpgtar-list.o `test -f 'gpgtar-list.c' || echo '$(srcdir)/'`gpgtar-list.c
++
++gpgtar-gpgtar-list.obj: gpgtar-list.c
++@am__fastdepCC_TRUE@  $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(gpgtar_CFLAGS) $(CFLAGS) -MT gpgtar-gpgtar-list.obj -MD -MP -MF $(DEPDIR)/gpgtar-gpgtar-list.Tpo -c -o gpgtar-gpgtar-list.obj `if test -f 'gpgtar-list.c'; then $(CYGPATH_W) 'gpgtar-list.c'; else $(CYGPATH_W) '$(srcdir)/gpgtar-list.c'; fi`
++@am__fastdepCC_TRUE@  mv -f $(DEPDIR)/gpgtar-gpgtar-list.Tpo $(DEPDIR)/gpgtar-gpgtar-list.Po
++@AMDEP_TRUE@@am__fastdepCC_FALSE@     source='gpgtar-list.c' object='gpgtar-gpgtar-list.obj' libtool=no @AMDEPBACKSLASH@
++@AMDEP_TRUE@@am__fastdepCC_FALSE@     DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
++@am__fastdepCC_FALSE@ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(gpgtar_CFLAGS) $(CFLAGS) -c -o gpgtar-gpgtar-list.obj `if test -f 'gpgtar-list.c'; then $(CYGPATH_W) 'gpgtar-list.c'; else $(CYGPATH_W) '$(srcdir)/gpgtar-list.c'; fi`
++
++gpgtar-no-libgcrypt.o: no-libgcrypt.c
++@am__fastdepCC_TRUE@  $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(gpgtar_CFLAGS) $(CFLAGS) -MT gpgtar-no-libgcrypt.o -MD -MP -MF $(DEPDIR)/gpgtar-no-libgcrypt.Tpo -c -o gpgtar-no-libgcrypt.o `test -f 'no-libgcrypt.c' || echo '$(srcdir)/'`no-libgcrypt.c
++@am__fastdepCC_TRUE@  mv -f $(DEPDIR)/gpgtar-no-libgcrypt.Tpo $(DEPDIR)/gpgtar-no-libgcrypt.Po
++@AMDEP_TRUE@@am__fastdepCC_FALSE@     source='no-libgcrypt.c' object='gpgtar-no-libgcrypt.o' libtool=no @AMDEPBACKSLASH@
++@AMDEP_TRUE@@am__fastdepCC_FALSE@     DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
++@am__fastdepCC_FALSE@ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(gpgtar_CFLAGS) $(CFLAGS) -c -o gpgtar-no-libgcrypt.o `test -f 'no-libgcrypt.c' || echo '$(srcdir)/'`no-libgcrypt.c
++
++gpgtar-no-libgcrypt.obj: no-libgcrypt.c
++@am__fastdepCC_TRUE@  $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(gpgtar_CFLAGS) $(CFLAGS) -MT gpgtar-no-libgcrypt.obj -MD -MP -MF $(DEPDIR)/gpgtar-no-libgcrypt.Tpo -c -o gpgtar-no-libgcrypt.obj `if test -f 'no-libgcrypt.c'; then $(CYGPATH_W) 'no-libgcrypt.c'; else $(CYGPATH_W) '$(srcdir)/no-libgcrypt.c'; fi`
++@am__fastdepCC_TRUE@  mv -f $(DEPDIR)/gpgtar-no-libgcrypt.Tpo $(DEPDIR)/gpgtar-no-libgcrypt.Po
++@AMDEP_TRUE@@am__fastdepCC_FALSE@     source='no-libgcrypt.c' object='gpgtar-no-libgcrypt.obj' libtool=no @AMDEPBACKSLASH@
++@AMDEP_TRUE@@am__fastdepCC_FALSE@     DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
++@am__fastdepCC_FALSE@ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(gpgtar_CFLAGS) $(CFLAGS) -c -o gpgtar-no-libgcrypt.obj `if test -f 'no-libgcrypt.c'; then $(CYGPATH_W) 'no-libgcrypt.c'; else $(CYGPATH_W) '$(srcdir)/no-libgcrypt.c'; fi`
++
+ ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
+       list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
+       unique=`for i in $$list; do \
+diff -urNp orig/gnupg-2.0.16/tools/gpgtar-create.c gnupg-2.0.16/tools/gpgtar-create.c
+--- orig/gnupg-2.0.16/tools/gpgtar-create.c    1970-01-01 01:00:00.000000000 +0100
++++ gnupg-2.0.16/tools/gpgtar-create.c 2010-07-19 11:10:34.000000000 +0200
+@@ -0,0 +1,831 @@
++/* 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.  This is the W32 version.  */
++#ifdef HAVE_W32_SYSTEM
++static gpg_error_t
++fillup_entry_w32 (tar_header_t hdr)
++{
++  char *p;
++  wchar_t *wfname;
++  WIN32_FILE_ATTRIBUTE_DATA fad;
++  DWORD attr;
++
++  for (p=hdr->name; *p; p++)
++    if (*p == '/')
++      *p = '\\';
++  wfname = utf8_to_wchar (hdr->name);
++  for (p=hdr->name; *p; p++)
++    if (*p == '\\')
++      *p = '/';
++  if (!wfname)
++    {
++      log_error ("error utf8-ing `%s': %s\n", hdr->name, w32_strerror (-1));
++      return gpg_error_from_syserror ();
++    }
++  if (!GetFileAttributesExW (wfname, GetFileExInfoStandard, &fad))
++    {
++      log_error ("error stat-ing `%s': %s\n", hdr->name, w32_strerror (-1));
++      xfree (wfname);
++      return gpg_error_from_syserror ();
++    }
++  xfree (wfname);
++
++  attr = fad.dwFileAttributes;
++
++  if ((attr & FILE_ATTRIBUTE_NORMAL))
++    hdr->typeflag = TF_REGULAR;
++  else if ((attr & FILE_ATTRIBUTE_DIRECTORY))
++    hdr->typeflag = TF_DIRECTORY;
++  else if ((attr & FILE_ATTRIBUTE_DEVICE))
++    hdr->typeflag = TF_NOTSUP;
++  else if ((attr & (FILE_ATTRIBUTE_OFFLINE | FILE_ATTRIBUTE_TEMPORARY)))
++    hdr->typeflag = TF_NOTSUP;
++  else
++    hdr->typeflag = TF_REGULAR;
++
++  /* Map some attributes to  USTAR defined mode bits.  */
++  hdr->mode = 0640;      /* User may read and write, group only read.  */
++  if ((attr & FILE_ATTRIBUTE_DIRECTORY))
++    hdr->mode |= 0110;   /* Dirs are user and group executable.  */
++  if ((attr & FILE_ATTRIBUTE_READONLY))
++    hdr->mode &= ~0200;  /* Clear the user write bit.  */
++  if ((attr & FILE_ATTRIBUTE_HIDDEN))
++    hdr->mode &= ~0707;  /* Clear all user and other bits.  */ 
++  if ((attr & FILE_ATTRIBUTE_SYSTEM))
++    hdr->mode |= 0004;   /* Make it readable by other.  */ 
++
++  /* Only set the size for a regular file.  */
++  if (hdr->typeflag == TF_REGULAR)
++    hdr->size = (fad.nFileSizeHigh * (unsigned long long)(MAXDWORD+1)
++                 + fad.nFileSizeLow);
++
++  hdr->mtime = (((unsigned long long)fad.ftLastWriteTime.dwHighDateTime << 32)
++                | fad.ftLastWriteTime.dwLowDateTime);
++  if (!hdr->mtime)
++    hdr->mtime = (((unsigned long long)fad.ftCreationTime.dwHighDateTime << 32)
++                  | fad.ftCreationTime.dwLowDateTime);
++  hdr->mtime -= 116444736000000000ULL; /* The filetime epoch is 1601-01-01.  */
++  hdr->mtime /= 10000000;  /* Convert from 0.1us to seconds. */
++
++  return 0;
++}
++#endif /*HAVE_W32_SYSTEM*/
++
++
++/* Given a fresh header obje`<ct HDR with only the name field set, try
++   to gather all available info.  This is the POSIX version.  */
++#ifndef HAVE_W32_SYSTEM
++static gpg_error_t
++fillup_entry_posix (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;
++}
++#endif /*!HAVE_W32_SYSTEM*/
++
++
++/* Add a new entry.  The name of a director entry is ENTRYNAME; if
++   that is NULL, DNAME is the name of the directory itself.  Under
++   Windows ENTRYNAME shall have backslashes replaced by standard
++   slashes.  */
++static gpg_error_t
++add_entry (const char *dname, const char *entryname, scanctrl_t scanctrl)
++{
++  gpg_error_t err;
++  tar_header_t hdr;
++  char *p;
++  size_t dnamelen = strlen (dname);
++
++  assert (dnamelen);
++
++  hdr = xtrycalloc (1, sizeof *hdr + dnamelen + 1
++                    + (entryname? strlen (entryname) : 0) + 1);
++  if (!hdr)
++    return gpg_error_from_syserror ();
++
++  p = stpcpy (hdr->name, dname);
++  if (entryname)
++    {
++      if (dname[dnamelen-1] != '/')
++        *p++ = '/';
++      strcpy (p, entryname);
++    }
++  else
++    {
++      if (hdr->name[dnamelen-1] == '/')
++        hdr->name[dnamelen-1] = 0;
++    }
++#ifdef HAVE_DOSISH_SYSTEM
++  err = fillup_entry_w32 (hdr);
++#else
++  err = fillup_entry_posix (hdr);
++#endif
++  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;
++
++#ifdef HAVE_W32_SYSTEM
++  WIN32_FIND_DATAW fi;
++  HANDLE hd = INVALID_HANDLE_VALUE;
++  char *p;
++
++  if (!*dname)
++    return 0;  /* An empty directory name has no entries.  */
++
++  {
++    char *fname;
++    wchar_t *wfname;
++
++    fname = xtrymalloc (strlen (dname) + 2 + 2 + 1);
++    if (!fname)
++      {
++        err = gpg_error_from_syserror ();
++        goto leave;
++      }
++    if (!strcmp (dname, "/"))
++      strcpy (fname, "/*"); /* Trailing slash is not allowed.  */
++    else if (!strcmp (dname, "."))
++      strcpy (fname, "*");
++    else if (*dname && dname[strlen (dname)-1] == '/')
++      strcpy (stpcpy (fname, dname), "*");
++    else if (*dname && dname[strlen (dname)-1] != '*')
++      strcpy (stpcpy (fname, dname), "/*");
++    else
++      strcpy (fname, dname);
++
++    for (p=fname; *p; p++)
++      if (*p == '/')
++        *p = '\\';
++    wfname = utf8_to_wchar (fname);
++    xfree (fname);
++    if (!wfname)
++      {
++        err = gpg_error_from_syserror ();
++        log_error (_("error reading directory `%s': %s\n"),
++                   dname, gpg_strerror (err));
++        goto leave;
++      }
++    hd = FindFirstFileW (wfname, &fi);
++    if (hd == INVALID_HANDLE_VALUE)
++      {
++        err = gpg_error_from_syserror ();
++        log_error (_("error reading directory `%s': %s\n"),
++                   dname, w32_strerror (-1));
++        xfree (wfname);
++        goto leave;
++      }
++    xfree (wfname);
++  }
++
++  do 
++    {
++      char *fname = wchar_to_utf8 (fi.cFileName);
++      if (!fname)
++        {
++          err = gpg_error_from_syserror ();
++          log_error ("error utf8-ing filename: %s\n", w32_strerror (-1));
++          break;
++        }
++      for (p=fname; *p; p++)
++        if (*p == '\\')
++          *p = '/';
++      if (!strcmp (fname, "." ) || !strcmp (fname, ".."))
++        err = 0; /* Skip self and parent dir entry.  */
++      else if (!strncmp (dname, "./", 2) && dname[2])
++        err = add_entry (dname+2, fname, scanctrl);
++      else
++        err = add_entry (dname, fname, scanctrl);
++      xfree (fname);
++    }
++  while (!err && FindNextFileW (hd, &fi));
++  if (err)
++    ;
++  else if (GetLastError () == ERROR_NO_MORE_FILES)
++    err = 0;
++  else
++    {
++      err = gpg_error_from_syserror (); 
++      log_error (_("error reading directory `%s': %s\n"),
++                 dname, w32_strerror (-1));
++    }
++  
++ leave:
++  if (hd != INVALID_HANDLE_VALUE)
++    FindClose (hd);
++
++#else /*!HAVE_W32_SYSTEM*/
++  DIR *dir;
++  struct dirent *de;
++
++  if (!*dname)
++    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, de->d_name, scanctrl);
++      if (err)
++        goto leave;
++     }
++
++ leave:
++  closedir (dir);
++#endif /*!HAVE_W32_SYSTEM*/
++  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.  */
++}
++
++
++\f
++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)
++    {
++#ifdef HAVE_W32_SYSTEM
++      mem2str (lastuname, uid? "user":"root", sizeof lastuname); 
++#else
++      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;
++        }
++#endif
++    }
++  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)
++    {
++#ifdef HAVE_W32_SYSTEM
++      mem2str (lastgname, gid? "users":"root", sizeof lastgname); 
++#else
++      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;
++        }
++#endif
++    }
++  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);
++
++#ifndef HAVE_W32_SYSTEM
++  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;
++    }
++#endif /*HAVE_W32_SYSTEM*/
++
++  /* 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);
++          if (!nbytes)
++            nbytes = 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;
++}
++
++
++\f
++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 = NULL;
++
++  memset (scanctrl, 0, sizeof *scanctrl);
++  scanctrl->flist_tail = &scanctrl->flist;
++
++  for (; (pattern = *inpattern); inpattern++)
++    {
++      char *pat, *p;
++
++      if (!*pattern)
++        continue;
++
++      pat = xtrystrdup (pattern);
++      if (!pat)
++        {
++          err = gpg_error_from_syserror ();
++          log_error ("memory allocation problem: %s\n", gpg_strerror (err));
++          goto leave;
++        }
++      for (p=pat; *p; p++)
++        if (*p == '\\')
++          *p = '/';
++
++      if (opt.verbose > 1)
++        log_info ("scanning `%s'\n", pat);
++
++      start_tail = scanctrl->flist_tail;
++      if (!pattern_valid_p (pat))
++        log_error ("skipping invalid name `%s'\n", pat);
++      else if (!add_entry (pat, NULL, scanctrl)
++               && *start_tail && ((*start_tail)->typeflag & TF_DIRECTORY))
++        scan_recursive (pat, scanctrl);
++
++      xfree (pat);
++    }
++
++  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)
++        remove (opt.outfile);
++    }
++  scanctrl->flist_tail = NULL;
++  while ( (hdr = scanctrl->flist) )
++    {
++      scanctrl->flist = hdr->next;
++      xfree (hdr);
++    }
++}
+diff -urNp orig/gnupg-2.0.16/tools/gpgtar-extract.c gnupg-2.0.16/tools/gpgtar-extract.c
+--- orig/gnupg-2.0.16/tools/gpgtar-extract.c   1970-01-01 01:00:00.000000000 +0100
++++ gnupg-2.0.16/tools/gpgtar-extract.c        2010-07-19 11:10:27.000000000 +0200
+@@ -0,0 +1,334 @@
++/* 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"
++
++#ifndef GPG_ERR_LIMIT_REACHED
++#define GPG_ERR_LIMIT_REACHED 183
++#endif
++
++
++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:
++  if (!err && opt.verbose)
++    log_info ("extracted `%s/'\n", fname);
++  es_fclose (outfp);
++  if (err && fname && outfp)
++    {
++      if (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;
++  size_t prefixlen;
++  
++  prefixlen = strlen (dirname) + 1;
++  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 (fname[strlen (fname)-1] == '/')
++    fname[strlen (fname)-1] = 0;
++
++ /* Note that we don't need to care about EEXIST because we always
++     extract into a new hierarchy.  */
++  if (gnupg_mkdir (fname, "-rwx------"))
++    {
++      err = gpg_error_from_syserror ();
++      if (gpg_err_code (err) == GPG_ERR_ENOENT)
++        {
++          /* Try to create the directory with parents but keep the
++             original error code in case of a failure.  */
++          char *p;
++          int rc = 0;
++          
++          for (p = fname+prefixlen; (p = strchr (p, '/')); p++)
++            {
++              *p = 0;
++              rc = gnupg_mkdir (fname, "-rwx------");
++              *p = '/';
++              if (rc)
++                break;
++            }
++          if (!rc && !gnupg_mkdir (fname, "-rwx------"))
++            err = 0;
++        }
++      if (err)
++        log_error ("error creating directory `%s': %s\n",
++                   fname, gpg_strerror (err));
++    }
++
++ leave:
++  if (!err && opt.verbose)
++    log_info ("created   `%s/'\n", fname);
++  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 %d for `%s' - skipped\n",
++                (int)hdr->typeflag, 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 *prefix_buffer = NULL;
++  char *dirname = NULL;
++  size_t n;
++  int idx;
++
++  /* Remove common suffixes.  */
++  n = strlen (dirprefix);
++  if (n > 4 && (!compare_filenames    (dirprefix + n - 4, EXTSEP_S "gpg")
++                || !compare_filenames (dirprefix + n - 4, EXTSEP_S "pgp")
++                || !compare_filenames (dirprefix + n - 4, EXTSEP_S "asc")
++                || !compare_filenames (dirprefix + n - 4, EXTSEP_S "pem")
++                || !compare_filenames (dirprefix + n - 4, EXTSEP_S "p7e")))
++    {
++      prefix_buffer = xtrystrdup (dirprefix);
++      if (!prefix_buffer)
++        {
++          err = gpg_error_from_syserror ();
++          goto leave;
++        }
++      prefix_buffer[n-4] = 0;
++      dirprefix = prefix_buffer;
++    }
++
++
++
++  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; /* Ready.  */
++      if (errno != EEXIST && errno != ENOTDIR)
++        {
++          err = gpg_error_from_syserror ();
++          goto leave;
++        }
++    }
++  err = gpg_error (GPG_ERR_LIMIT_REACHED);
++
++ leave:
++  if (err)
++    {
++      log_error ("error creating an extract directory: %s\n",
++                 gpg_strerror (err));
++      xfree (dirname);
++      dirname = NULL;
++    }
++  xfree (prefix_buffer);
++  return dirname;
++}
++
++
++\f
++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)
++    {
++      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 (filename)
++    {
++      dirprefix = strrchr (filename, '/');
++      if (dirprefix)
++        dirprefix++;
++    }
++  else if (opt.filename)
++    {
++      dirprefix = strrchr (opt.filename, '/');
++      if (dirprefix)
++        dirprefix++;
++    }
++
++  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 -urNp orig/gnupg-2.0.16/tools/gpgtar-list.c gnupg-2.0.16/tools/gpgtar-list.c
+--- orig/gnupg-2.0.16/tools/gpgtar-list.c      1970-01-01 01:00:00.000000000 +0100
++++ gnupg-2.0.16/tools/gpgtar-list.c   2010-07-19 10:52:02.000000000 +0200
+@@ -0,0 +1,323 @@
++/* 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"
++
++
++\f
++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;
++}
++
++
++\f
++/* 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;
++}
++
++
++\f
++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);
++}
++
++
++\f
++/* 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 -urNp orig/gnupg-2.0.16/tools/gpgtar.c gnupg-2.0.16/tools/gpgtar.c
+--- orig/gnupg-2.0.16/tools/gpgtar.c   1970-01-01 01:00:00.000000000 +0100
++++ gnupg-2.0.16/tools/gpgtar.c        2010-07-19 11:17:08.000000000 +0200
+@@ -0,0 +1,509 @@
++/* 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,
++    oSetFilename,
++    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_s_s (oSetFilename, "set-filename", "@"),
++
++  ARGPARSE_end ()
++};
++
++
++\f
++static void tar_and_encrypt (char **inpattern);
++static void decrypt_and_untar (const char *fname);
++static void decrypt_and_list (const char *fname);
++
++
++
++\f
++/* 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;
++}
++
++
++\f
++/* 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 ();
++
++  /* 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 oSetFilename: opt.filename = 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 (opt.filename)
++        log_info ("note: ignoring option --set-filename\n");
++      if (skip_crypto)
++        gpgtar_list (fname);
++      else
++        decrypt_and_list (fname);
++      break;
++
++    case aEncrypt:
++      if (!argc)
++        usage (1);
++      if (opt.filename)
++        log_info ("note: ignoring option --set-filename\n");
++      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.  */
++#if 0
++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;
++}
++#endif
++
++
++
++\f
++static void
++tar_and_encrypt (char **inpattern)
++{
++  (void)inpattern;
++  log_error ("tar_and_encrypt has not yet been implemented\n");
++}
++
++
++\f
++static void
++decrypt_and_untar (const char *fname)
++{
++  (void)fname;
++  log_error ("decrypt_and_untar has not yet been implemented\n");
++}
++
++
++\f
++static void
++decrypt_and_list (const char *fname)
++{
++  (void)fname;
++  log_error ("decrypt_and_list has not yet been implemented\n");
++}
++
++
++
++
++/* A wrapper around mkdir which takes a string for the mode argument.
++   This makes it easier to handle the mode argument which is not
++   defined on all systems.  The format of the modestring is
++
++      "-rwxrwxrwx"
++      
++   '-' is a don't care or not set.  'r', 'w', 'x' are read allowed,
++   write allowed, execution allowed with the first group for the user,
++   the second for the group and the third for all others.  If the
++   string is shorter than above the missing mode characters are meant
++   to be not set.  */
++int
++gnupg_mkdir (const char *name, const char *modestr)
++{
++#ifdef HAVE_W32CE_SYSTEM
++  wchar_t *wname;
++  (void)modestr;
++  
++  wname = utf8_to_wchar (name);
++  if (!wname)
++    return -1;
++  if (!CreateDirectoryW (wname, NULL))
++    {
++      xfree (wname);
++      return -1;  /* ERRNO is automagically provided by gpg-error.h.  */
++    }
++  xfree (wname);
++  return 0;
++#elif MKDIR_TAKES_ONE_ARG
++  (void)modestr;
++  /* Note: In the case of W32 we better use CreateDirectory and try to
++     set appropriate permissions.  However using mkdir is easier
++     because this sets ERRNO.  */
++  return mkdir (name);
++#else
++  mode_t mode = 0;
++
++  if (modestr && *modestr)
++    {
++      modestr++;
++      if (*modestr && *modestr++ == 'r')
++        mode |= S_IRUSR;
++      if (*modestr && *modestr++ == 'w')
++        mode |= S_IWUSR;
++      if (*modestr && *modestr++ == 'x')
++        mode |= S_IXUSR;
++      if (*modestr && *modestr++ == 'r')
++        mode |= S_IRGRP;
++      if (*modestr && *modestr++ == 'w')
++        mode |= S_IWGRP;
++      if (*modestr && *modestr++ == 'x')
++        mode |= S_IXGRP;
++      if (*modestr && *modestr++ == 'r')
++        mode |= S_IROTH;
++      if (*modestr && *modestr++ == 'w')
++        mode |= S_IWOTH;
++      if (*modestr && *modestr++ == 'x')
++        mode |= S_IXOTH;
++    }
++  return mkdir (name, mode);
++#endif
++}
++
++#ifdef HAVE_W32_SYSTEM
++/* Return a malloced string encoded in UTF-8 from the wide char input
++   string STRING.  Caller must free this value.  Returns NULL and sets
++   ERRNO on failure.  Calling this function with STRING set to NULL is
++   not defined.  */
++char *
++wchar_to_utf8 (const wchar_t *string)
++{
++  int n;
++  char *result;
++
++  n = WideCharToMultiByte (CP_UTF8, 0, string, -1, NULL, 0, NULL, NULL);
++  if (n < 0)
++    {
++      errno = EINVAL;
++      return NULL;
++    }
++
++  result = xtrymalloc (n+1);
++  if (!result)
++    return NULL;
++
++  n = WideCharToMultiByte (CP_UTF8, 0, string, -1, result, n, NULL, NULL);
++  if (n < 0)
++    {
++      xfree (result);
++      errno = EINVAL;
++      result = NULL;
++    }
++  return result;
++}
++
++
++/* Return a malloced wide char string from an UTF-8 encoded input
++   string STRING.  Caller must free this value.  Returns NULL and sets
++   ERRNO on failure.  Calling this function with STRING set to NULL is
++   not defined.  */
++wchar_t *
++utf8_to_wchar (const char *string)
++{
++  int n;
++  size_t nbytes;
++  wchar_t *result;
++
++  n = MultiByteToWideChar (CP_UTF8, 0, string, -1, NULL, 0);
++  if (n < 0)
++    {
++      errno = EINVAL;
++      return NULL;
++    }
++
++  nbytes = (size_t)(n+1) * sizeof(*result);
++  if (nbytes / sizeof(*result) != (n+1)) 
++    {
++      errno = ENOMEM;
++      return NULL;
++    }
++  result = xtrymalloc (nbytes);
++  if (!result)
++    return NULL;
++
++  n = MultiByteToWideChar (CP_UTF8, 0, string, -1, result, n);
++  if (n < 0)
++    {
++      free (result);
++      errno = EINVAL;
++      result = NULL;
++    }
++  return result;
++}
++#endif /*HAVE_W32_SYSTEM*/
+diff -urNp orig/gnupg-2.0.16/tools/gpgtar.h gnupg-2.0.16/tools/gpgtar.h
+--- orig/gnupg-2.0.16/tools/gpgtar.h   1970-01-01 01:00:00.000000000 +0100
++++ gnupg-2.0.16/tools/gpgtar.h        2010-07-19 11:15:30.000000000 +0200
+@@ -0,0 +1,132 @@
++/* 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"
++#include "../common/estream.h"
++
++/* We keep all global options in the structure OPT.  */
++struct
++{
++  int verbose;
++  int quiet;
++  const char *outfile;
++  int symmetric;
++  const char *filename;
++} 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);
++
++int gnupg_mkdir (const char *name, const char *modestr);
++#ifdef HAVE_W32_SYSTEM
++char *wchar_to_utf8 (const wchar_t *string);
++wchar_t *utf8_to_wchar (const char *string);
++#endif
++
++/*-- 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*/
index d23f96a..4023f49 100644 (file)
@@ -47,6 +47,7 @@ Section "-un.gnupg"
   Delete "$INSTDIR\gpgconf.exe"
   Delete "$INSTDIR\gpg-connect-agent.exe"
   Delete "$INSTDIR\gpgsplit.exe"
+  Delete "$INSTDIR\gpgtar.exe"
 
   Delete "$INSTDIR\pub\gpg.exe"
   Delete "$INSTDIR\pub\gpg2.exe"