Finished the bulk of changes for gnupg 1.9. This included switching
authorWerner Koch <wk@gnupg.org>
Wed, 18 Jun 2003 19:56:13 +0000 (19:56 +0000)
committerWerner Koch <wk@gnupg.org>
Wed, 18 Jun 2003 19:56:13 +0000 (19:56 +0000)
to libgcrypt functions, using shared error codes from libgpg-error,
replacing the old functions we used to have in ../util by those in
../jnlib and ../common, renaming the malloc functions and a couple of
types.  Note, that not all changes are listed below becuause they are
too similar and done at far too many places.  As of today the code
builds using the current libgcrypt from CVS but it is very unlikely
that it actually works.

12 files changed:
common/ChangeLog
common/Makefile.am
common/gettime.c
common/iobuf.c [new file with mode: 0644]
common/iobuf.h [new file with mode: 0644]
common/miscellaneous.c [new file with mode: 0644]
common/ttyio.c [new file with mode: 0644]
common/ttyio.h [new file with mode: 0644]
common/util.h
common/yesno.c [new file with mode: 0644]
scd/card.c
scd/command.c

index 0301478..ff9762b 100644 (file)
@@ -1,5 +1,40 @@
-2003-06-04  Werner Koch  <wk@gnupg.org>
+2003-06-17  Werner Koch  <wk@gnupg.org>
+
+       * gettime.c (scan_isodatestr,add_days_to_timestamp,strtimevalue)
+       (strtimestamp,asctimestamp): New.  Code taken from gnupg 1.3.2
+       mischelp.c.
+
+       * yesno.c: New.  Code taken from gnupg 1.3.2 mischelp.c
+
+       * miscellaneous.c: New.
+
+       * util.h: Include utf8conf.h
+
+2003-06-16  Werner Koch  <wk@gnupg.org>
+
+       * gettime.c (make_timestamp): New.
+
+       * ttyio.c: New. Taken from gnupg 1.2.
+       * ttyio.h: Move from ../include.
 
+2003-06-13  Werner Koch  <wk@gnupg.org>
+
+       * util.h (seterr): Removed macro.
+       (xmalloc_secure,xcalloc_secure): New.
+
+2003-06-11  Werner Koch  <wk@gnupg.org>
+
+       * iobuf.c (iobuf_writebyte,iobuf_write): Return error code from
+       iobuf_flush.
+       (iobuf_writestr): Ditto.
+
+2003-06-10  Werner Koch  <wk@gnupg.org>
+
+       * iobuf.c, iobuf.h: New. Taken from current gnupg 1.3 CVS.  Run
+       indent on it and adjusted error handling to libgpg-error style.
+       Replaced IOBUF by iobuf_t. Renamed malloc functions.
+
+2003-06-04  Werner Koch  <wk@gnupg.org>
 
        * errors.h: Removed all error codes.  We keep the status codes for
        now.
index 8e3dc68..11dc79a 100644 (file)
@@ -34,7 +34,11 @@ libcommon_a_SOURCES = \
        sysutils.c sysutils.h \
        cryptmiss.c \
        gettime.c \
+       yesno.c \
+       miscellaneous.c \
        membuf.c membuf.h \
+       iobuf.c iobuf.h \
+       ttyio.c ttyio.h \
        signal.c
 
 
index 6f656c8..a7914d3 100644 (file)
@@ -1,5 +1,5 @@
 /* gettime.c - Wrapper for time functions
- *     Copyright (C) 2002 Free Software Foundation, Inc.
+ *     Copyright (C) 1998, 2002 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
@@ -21,6 +21,9 @@
 #include <config.h>
 #include <stdlib.h>
 #include <time.h>
+#ifdef HAVE_LANGINFO_H
+#include <langinfo.h>
+#endif
 
 #include "util.h"
 
@@ -83,5 +86,165 @@ gnupg_faked_time_p (void)
 }
 
 
+/* This function is used by gpg because OpenPGP defines the timestamp
+   as an unsigned 32 bit value. */
+u32 
+make_timestamp (void)
+{
+  time_t t = gnupg_get_time ();
+
+  if (t == (time_t)-1)
+    log_fatal ("gnupg_get_time() failed\n");
+  return (u32)t;
+}
+
+
+
+/****************
+ * Scan a date string and return a timestamp.
+ * The only supported format is "yyyy-mm-dd"
+ * Returns 0 for an invalid date.
+ */
+u32
+scan_isodatestr( const char *string )
+{
+    int year, month, day;
+    struct tm tmbuf;
+    time_t stamp;
+    int i;
+
+    if( strlen(string) != 10 || string[4] != '-' || string[7] != '-' )
+       return 0;
+    for( i=0; i < 4; i++ )
+       if( !digitp (string+i) )
+           return 0;
+    if( !digitp (string+5) || !digitp(string+6) )
+       return 0;
+    if( !digitp(string+8) || !digitp(string+9) )
+       return 0;
+    year = atoi(string);
+    month = atoi(string+5);
+    day = atoi(string+8);
+    /* some basic checks */
+    if( year < 1970 || month < 1 || month > 12 || day < 1 || day > 31 )
+       return 0;
+    memset( &tmbuf, 0, sizeof tmbuf );
+    tmbuf.tm_mday = day;
+    tmbuf.tm_mon = month-1;
+    tmbuf.tm_year = year - 1900;
+    tmbuf.tm_isdst = -1;
+    stamp = mktime( &tmbuf );
+    if( stamp == (time_t)-1 )
+       return 0;
+    return stamp;
+}
+
+
+u32
+add_days_to_timestamp( u32 stamp, u16 days )
+{
+    return stamp + days*86400L;
+}
+
+
+/****************
+ * Return a string with a time value in the form: x Y, n D, n H
+ */
+
+const char *
+strtimevalue( u32 value )
+{
+    static char buffer[30];
+    unsigned int years, days, hours, minutes;
+
+    value /= 60;
+    minutes = value % 60;
+    value /= 60;
+    hours = value % 24;
+    value /= 24;
+    days = value % 365;
+    value /= 365;
+    years = value;
+
+    sprintf(buffer,"%uy%ud%uh%um", years, days, hours, minutes );
+    if( years )
+       return buffer;
+    if( days )
+       return strchr( buffer, 'y' ) + 1;
+    return strchr( buffer, 'd' ) + 1;
+}
+
+
+/****************
+ * Note: this function returns GMT
+ */
+const char *
+strtimestamp( u32 stamp )
+{
+    static char buffer[11+5];
+    struct tm *tp;
+    time_t atime = stamp;
+    
+    if (atime < 0) {
+        strcpy (buffer, "????" "-??" "-??");
+    }
+    else {
+        tp = gmtime( &atime );
+        sprintf(buffer,"%04d-%02d-%02d",
+                1900+tp->tm_year, tp->tm_mon+1, tp->tm_mday );
+    }
+    return buffer;
+}
+
+/****************
+ * Note: this function returns local time
+ */
+const char *
+asctimestamp( u32 stamp )
+{
+    static char buffer[50];
+#if defined (HAVE_STRFTIME) && defined (HAVE_NL_LANGINFO)
+      static char fmt[50];
+#endif
+    struct tm *tp;
+    time_t atime = stamp;
+
+    if (atime < 0) {
+        strcpy (buffer, "????" "-??" "-??");
+        return buffer;
+    }
+
+    tp = localtime( &atime );
+#ifdef HAVE_STRFTIME
+#if defined(HAVE_NL_LANGINFO)
+      mem2str( fmt, nl_langinfo(D_T_FMT), DIM(fmt)-3 );
+      if( strstr( fmt, "%Z" ) == NULL )
+       strcat( fmt, " %Z");
+      strftime( buffer, DIM(buffer)-1, fmt, tp );
+#else
+      /* fixme: we should check whether the locale appends a " %Z"
+       * These locales from glibc don't put the " %Z":
+       * fi_FI hr_HR ja_JP lt_LT lv_LV POSIX ru_RU ru_SU sv_FI sv_SE zh_CN
+       */
+      strftime( buffer, DIM(buffer)-1, "%c %Z", tp );
+#endif
+    buffer[DIM(buffer)-1] = 0;
+#else
+    mem2str( buffer, asctime(tp), DIM(buffer) );
+#endif
+    return buffer;
+}
+
+
+
+
+
+
+
+
+
+
+
+
 
 
diff --git a/common/iobuf.c b/common/iobuf.c
new file mode 100644 (file)
index 0000000..773e299
--- /dev/null
@@ -0,0 +1,2415 @@
+/* iobuf.c  -  file handling
+ * Copyright (C) 1998, 1999, 2000, 2001, 2003 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 2 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, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+#include <config.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <ctype.h>
+#include <assert.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#ifdef HAVE_DOSISH_SYSTEM
+#include <windows.h>
+#endif
+#ifdef __riscos__
+#include <kernel.h>
+#include <swis.h>
+#endif /* __riscos__ */
+
+#include "memory.h"
+#include "util.h"
+#include "iobuf.h"
+
+#undef FILE_FILTER_USES_STDIO
+
+#ifdef HAVE_DOSISH_SYSTEM
+#define USE_SETMODE 1
+#endif
+
+#ifdef FILE_FILTER_USES_STDIO
+#define my_fileno(a)  fileno ((a))
+#define my_fopen_ro(a,b) fopen ((a),(b))
+#define my_fopen(a,b)    fopen ((a),(b))
+typedef FILE *FILEP_OR_FD;
+#define INVALID_FP    NULL
+#define FILEP_OR_FD_FOR_STDIN  (stdin)
+#define FILEP_OR_FD_FOR_STDOUT  (stdout)
+typedef struct
+{
+  FILE *fp;                    /* open file handle */
+  int keep_open;
+  int no_cache;
+  int print_only_name;         /* flags indicating that fname is not a real file */
+  char fname[1];               /* name of the file */
+}
+file_filter_ctx_t;
+#else
+#define my_fileno(a)  (a)
+#define my_fopen_ro(a,b) fd_cache_open ((a),(b))
+#define my_fopen(a,b) direct_open ((a),(b))
+#ifdef HAVE_DOSISH_SYSTEM
+typedef HANDLE FILEP_OR_FD;
+#define INVALID_FP  ((HANDLE)-1)
+#define FILEP_OR_FD_FOR_STDIN  (GetStdHandle (STD_INPUT_HANDLE))
+#define FILEP_OR_FD_FOR_STDOUT (GetStdHandle (STD_OUTPUT_HANDLE))
+#undef USE_SETMODE
+#else
+typedef int FILEP_OR_FD;
+#define INVALID_FP  (-1)
+#define FILEP_OR_FD_FOR_STDIN  (0)
+#define FILEP_OR_FD_FOR_STDOUT (1)
+#endif
+typedef struct
+{
+  FILEP_OR_FD fp;              /* open file handle */
+  int keep_open;
+  int no_cache;
+  int eof_seen;
+  int print_only_name;         /* flags indicating that fname is not a real file */
+  char fname[1];               /* name of the file */
+}
+file_filter_ctx_t;
+
+struct close_cache_s
+{
+  struct close_cache_s *next;
+  FILEP_OR_FD fp;
+  char fname[1];
+};
+typedef struct close_cache_s *CLOSE_CACHE;
+static CLOSE_CACHE close_cache;
+#endif
+
+#ifdef __MINGW32__
+typedef struct
+{
+  int sock;
+  int keep_open;
+  int no_cache;
+  int eof_seen;
+  int print_only_name;         /* flags indicating that fname is not a real file */
+  char fname[1];               /* name of the file */
+}
+sock_filter_ctx_t;
+#endif /*__MINGW32__*/
+
+/* The first partial length header block must be of size 512
+ * to make it easier (and efficienter) we use a min. block size of 512
+ * for all chunks (but the last one) */
+#define OP_MIN_PARTIAL_CHUNK     512
+#define OP_MIN_PARTIAL_CHUNK_2POW 9
+
+typedef struct
+{
+  int use;
+  size_t size;
+  size_t count;
+  int partial;                 /* 1 = partial header, 2 in last partial packet */
+  char *buffer;                        /* used for partial header */
+  size_t buflen;               /* used size of buffer */
+  int first_c;                 /* of partial header (which is > 0) */
+  int eof;
+}
+block_filter_ctx_t;
+
+static int special_names_enabled;
+
+static int underflow (iobuf_t a);
+static int translate_file_handle (int fd, int for_write);
+
+#ifndef FILE_FILTER_USES_STDIO
+
+/*
+ * Invalidate (i.e. close) a cached iobuf
+ */
+static void
+fd_cache_invalidate (const char *fname)
+{
+  CLOSE_CACHE cc;
+
+  assert (fname);
+  if (DBG_IOBUF)
+    log_debug ("fd_cache_invalidate (%s)\n", fname);
+
+  for (cc = close_cache; cc; cc = cc->next)
+    {
+      if (cc->fp != INVALID_FP && !strcmp (cc->fname, fname))
+       {
+         if (DBG_IOBUF)
+           log_debug ("                did (%s)\n", cc->fname);
+#ifdef HAVE_DOSISH_SYSTEM
+         CloseHandle (cc->fp);
+#else
+         close (cc->fp);
+#endif
+         cc->fp = INVALID_FP;
+       }
+    }
+}
+
+
+
+static FILEP_OR_FD
+direct_open (const char *fname, const char *mode)
+{
+#ifdef HAVE_DOSISH_SYSTEM
+  unsigned long da, cd, sm;
+  HANDLE hfile;
+
+  /* Note, that we do not handle all mode combinations */
+
+  /* According to the ReactOS source it seems that open() of the
+   * standard MSW32 crt does open the file in share mode which is
+   * something new for MS applications ;-)
+   */
+  if (strchr (mode, '+'))
+    {
+      fd_cache_invalidate (fname);
+      da = GENERIC_READ | GENERIC_WRITE;
+      cd = OPEN_EXISTING;
+      sm = FILE_SHARE_READ | FILE_SHARE_WRITE;
+    }
+  else if (strchr (mode, 'w'))
+    {
+      fd_cache_invalidate (fname);
+      da = GENERIC_WRITE;
+      cd = CREATE_ALWAYS;
+      sm = FILE_SHARE_WRITE;
+    }
+  else
+    {
+      da = GENERIC_READ;
+      cd = OPEN_EXISTING;
+      sm = FILE_SHARE_READ;
+    }
+
+  hfile = CreateFile (fname, da, sm, NULL, cd, FILE_ATTRIBUTE_NORMAL, NULL);
+  return hfile;
+#else
+  int oflag;
+  int cflag = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
+
+  /* Note, that we do not handle all mode combinations */
+  if (strchr (mode, '+'))
+    {
+      fd_cache_invalidate (fname);
+      oflag = O_RDWR;
+    }
+  else if (strchr (mode, 'w'))
+    {
+      fd_cache_invalidate (fname);
+      oflag = O_WRONLY | O_CREAT | O_TRUNC;
+    }
+  else
+    {
+      oflag = O_RDONLY;
+    }
+#ifdef O_BINARY
+  if (strchr (mode, 'b'))
+    oflag |= O_BINARY;
+#endif
+#ifndef __riscos__
+  return open (fname, oflag, cflag);
+#else
+  {
+    struct stat buf;
+    int rc = stat (fname, &buf);
+
+    /* Don't allow iobufs on directories */
+    if (!rc && S_ISDIR (buf.st_mode) && !S_ISREG (buf.st_mode))
+      return __set_errno (EISDIR);
+    else
+      return open (fname, oflag, cflag);
+  }
+#endif
+#endif
+}
+
+
+/*
+ * Instead of closing an FD we keep it open and cache it for later reuse 
+ * Note that this caching strategy only works if the process does not chdir.
+ */
+static void
+fd_cache_close (const char *fname, FILEP_OR_FD fp)
+{
+  CLOSE_CACHE cc;
+
+  assert (fp);
+  if (!fname || !*fname)
+    {
+#ifdef HAVE_DOSISH_SYSTEM
+      CloseHandle (fp);
+#else
+      close (fp);
+#endif
+      if (DBG_IOBUF)
+       log_debug ("fd_cache_close (%p) real\n", (void *) fp);
+      return;
+    }
+  /* try to reuse a slot */
+  for (cc = close_cache; cc; cc = cc->next)
+    {
+      if (cc->fp == INVALID_FP && !strcmp (cc->fname, fname))
+       {
+         cc->fp = fp;
+         if (DBG_IOBUF)
+           log_debug ("fd_cache_close (%s) used existing slot\n", fname);
+         return;
+       }
+    }
+  /* add a new one */
+  if (DBG_IOBUF)
+    log_debug ("fd_cache_close (%s) new slot created\n", fname);
+  cc = xcalloc (1, sizeof *cc + strlen (fname));
+  strcpy (cc->fname, fname);
+  cc->fp = fp;
+  cc->next = close_cache;
+  close_cache = cc;
+}
+
+/*
+ * Do an direct_open on FNAME but first try to reuse one from the fd_cache
+ */
+static FILEP_OR_FD
+fd_cache_open (const char *fname, const char *mode)
+{
+  CLOSE_CACHE cc;
+
+  assert (fname);
+  for (cc = close_cache; cc; cc = cc->next)
+    {
+      if (cc->fp != INVALID_FP && !strcmp (cc->fname, fname))
+       {
+         FILEP_OR_FD fp = cc->fp;
+         cc->fp = INVALID_FP;
+         if (DBG_IOBUF)
+           log_debug ("fd_cache_open (%s) using cached fp\n", fname);
+#ifdef HAVE_DOSISH_SYSTEM
+         if (SetFilePointer (fp, 0, NULL, FILE_BEGIN) == 0xffffffff)
+           {
+             log_error ("rewind file failed on handle %p: ec=%d\n",
+                        fp, (int) GetLastError ());
+             fp = INVALID_FP;
+           }
+#else
+         if (lseek (fp, 0, SEEK_SET) == (off_t) - 1)
+           {
+             log_error ("can't rewind fd %d: %s\n", fp, strerror (errno));
+             fp = INVALID_FP;
+           }
+#endif
+         return fp;
+       }
+    }
+  if (DBG_IOBUF)
+    log_debug ("fd_cache_open (%s) not cached\n", fname);
+  return direct_open (fname, mode);
+}
+
+
+#endif /*FILE_FILTER_USES_STDIO */
+
+
+/****************
+ * Read data from a file into buf which has an allocated length of *LEN.
+ * return the number of read bytes in *LEN. OPAQUE is the FILE * of
+ * the stream. A is not used.
+ * control may be:
+ * IOBUFCTRL_INIT: called just before the function is linked into the
+ *                list of function. This can be used to prepare internal
+ *                data structures of the function.
+ * IOBUFCTRL_FREE: called just before the function is removed from the
+ *                 list of functions and can be used to release internal
+ *                 data structures or close a file etc.
+ * IOBUFCTRL_UNDERFLOW: called by iobuf_underflow to fill the buffer
+ *                 with new stuff. *RET_LEN is the available size of the
+ *                 buffer, and should be set to the number of bytes
+ *                 which were put into the buffer. The function
+ *                 returns 0 to indicate success, -1 on EOF and
+ *                 GPG_ERR_xxxxx for other errors.
+ *
+ * IOBUFCTRL_FLUSH: called by iobuf_flush() to write out the collected stuff.
+ *                 *RET_LAN is the number of bytes in BUF.
+ *
+ * IOBUFCTRL_CANCEL: send to all filters on behalf of iobuf_cancel.  The
+ *                 filter may take appropriate action on this message.
+ */
+static int
+file_filter (void *opaque, int control, iobuf_t chain, byte * buf,
+            size_t * ret_len)
+{
+  file_filter_ctx_t *a = opaque;
+  FILEP_OR_FD f = a->fp;
+  size_t size = *ret_len;
+  size_t nbytes = 0;
+  int rc = 0;
+
+#ifdef FILE_FILTER_USES_STDIO
+  if (control == IOBUFCTRL_UNDERFLOW)
+    {
+      assert (size);           /* need a buffer */
+      if (feof (f))
+       {                       /* On terminals you could easiely read as many EOFs as you call         */
+         rc = -1;              /* fread() or fgetc() repeatly. Every call will block until you press   */
+         *ret_len = 0;         /* CTRL-D. So we catch this case before we call fread() again.          */
+       }
+      else
+       {
+         clearerr (f);
+         nbytes = fread (buf, 1, size, f);
+         if (feof (f) && !nbytes)
+           {
+             rc = -1;          /* okay: we can return EOF now. */
+           }
+         else if (ferror (f) && errno != EPIPE)
+           {
+             rc = gpg_error_from_errno (errno);
+             log_error ("%s: read error: %s\n", a->fname, strerror (errno));
+           }
+         *ret_len = nbytes;
+       }
+    }
+  else if (control == IOBUFCTRL_FLUSH)
+    {
+      if (size)
+       {
+         clearerr (f);
+         nbytes = fwrite (buf, 1, size, f);
+         if (ferror (f))
+           {
+             rc = gpg_error_from_errno (errno);
+             log_error ("%s: write error: %s\n", a->fname, strerror (errno));
+           }
+       }
+      *ret_len = nbytes;
+    }
+  else if (control == IOBUFCTRL_INIT)
+    {
+      a->keep_open = a->no_cache = 0;
+    }
+  else if (control == IOBUFCTRL_DESC)
+    {
+      *(char **) buf = "file_filter";
+    }
+  else if (control == IOBUFCTRL_FREE)
+    {
+      if (f != stdin && f != stdout)
+       {
+         if (DBG_IOBUF)
+           log_debug ("%s: close fd %d\n", a->fname, fileno (f));
+         if (!a->keep_open)
+           fclose (f);
+       }
+      f = NULL;
+      xfree (a);               /* we can free our context now */
+    }
+#else /* !stdio implementation */
+
+  if (control == IOBUFCTRL_UNDERFLOW)
+    {
+      assert (size);           /* need a buffer */
+      if (a->eof_seen)
+       {
+         rc = -1;
+         *ret_len = 0;
+       }
+      else
+       {
+#ifdef HAVE_DOSISH_SYSTEM
+         unsigned long nread;
+
+         nbytes = 0;
+         if (!ReadFile (f, buf, size, &nread, NULL))
+           {
+             int ec = (int) GetLastError ();
+             if (ec != ERROR_BROKEN_PIPE)
+               {
+                 rc = gpg_error_from_errno (ec);
+                 log_error ("%s: read error: ec=%d\n", a->fname, ec);
+               }
+           }
+         else if (!nread)
+           {
+             a->eof_seen = 1;
+             rc = -1;
+           }
+         else
+           {
+             nbytes = nread;
+           }
+
+#else
+
+         int n;
+
+         nbytes = 0;
+         do
+           {
+             n = read (f, buf, size);
+           }
+         while (n == -1 && errno == EINTR);
+         if (n == -1)
+           {                   /* error */
+             if (errno != EPIPE)
+               {
+                 rc = gpg_error_from_errno (errno);
+                 log_error ("%s: read error: %s\n",
+                            a->fname, strerror (errno));
+               }
+           }
+         else if (!n)
+           {                   /* eof */
+             a->eof_seen = 1;
+             rc = -1;
+           }
+         else
+           {
+             nbytes = n;
+           }
+#endif
+         *ret_len = nbytes;
+       }
+    }
+  else if (control == IOBUFCTRL_FLUSH)
+    {
+      if (size)
+       {
+#ifdef HAVE_DOSISH_SYSTEM
+         byte *p = buf;
+         unsigned long n;
+
+         nbytes = size;
+         do
+           {
+             if (size && !WriteFile (f, p, nbytes, &n, NULL))
+               {
+                 int ec = (int) GetLastError ();
+                 rc = gpg_error_from_errno (ec);
+                 log_error ("%s: write error: ec=%d\n", a->fname, ec);
+                 break;
+               }
+             p += n;
+             nbytes -= n;
+           }
+         while (nbytes);
+         nbytes = p - buf;
+#else
+         byte *p = buf;
+         int n;
+
+         nbytes = size;
+         do
+           {
+             do
+               {
+                 n = write (f, p, nbytes);
+               }
+             while (n == -1 && errno == EINTR);
+             if (n > 0)
+               {
+                 p += n;
+                 nbytes -= n;
+               }
+           }
+         while (n != -1 && nbytes);
+         if (n == -1)
+           {
+             rc = gpg_error_from_errno (errno);
+             log_error ("%s: write error: %s\n", a->fname, strerror (errno));
+           }
+         nbytes = p - buf;
+#endif
+       }
+      *ret_len = nbytes;
+    }
+  else if (control == IOBUFCTRL_INIT)
+    {
+      a->eof_seen = 0;
+      a->keep_open = 0;
+      a->no_cache = 0;
+    }
+  else if (control == IOBUFCTRL_DESC)
+    {
+      *(char **) buf = "file_filter(fd)";
+    }
+  else if (control == IOBUFCTRL_FREE)
+    {
+#ifdef HAVE_DOSISH_SYSTEM
+      if (f != FILEP_OR_FD_FOR_STDIN && f != FILEP_OR_FD_FOR_STDOUT)
+       {
+         if (DBG_IOBUF)
+           log_debug ("%s: close handle %p\n", a->fname, f);
+         if (!a->keep_open)
+           fd_cache_close (a->no_cache ? NULL : a->fname, f);
+       }
+#else
+      if ((int) f != 0 && (int) f != 1)
+       {
+         if (DBG_IOBUF)
+           log_debug ("%s: close fd %d\n", a->fname, f);
+         if (!a->keep_open)
+           fd_cache_close (a->no_cache ? NULL : a->fname, f);
+       }
+      f = INVALID_FP;
+#endif
+      xfree (a);               /* we can free our context now */
+    }
+#endif /* !stdio implementation */
+  return rc;
+}
+
+#ifdef __MINGW32__
+/* Becuase sockets are an special object under Lose32 we have to
+ * use a special filter */
+static int
+sock_filter (void *opaque, int control, iobuf_t chain, byte * buf,
+            size_t * ret_len)
+{
+  sock_filter_ctx_t *a = opaque;
+  size_t size = *ret_len;
+  size_t nbytes = 0;
+  int rc = 0;
+
+  if (control == IOBUFCTRL_UNDERFLOW)
+    {
+      assert (size);           /* need a buffer */
+      if (a->eof_seen)
+       {
+         rc = -1;
+         *ret_len = 0;
+       }
+      else
+       {
+         int nread;
+
+         nread = recv (a->sock, buf, size, 0);
+         if (nread == SOCKET_ERROR)
+           {
+             int ec = (int) WSAGetLastError ();
+             rc = gpg_error_from_errno (ec);
+             log_error ("socket read error: ec=%d\n", ec);
+           }
+         else if (!nread)
+           {
+             a->eof_seen = 1;
+             rc = -1;
+           }
+         else
+           {
+             nbytes = nread;
+           }
+         *ret_len = nbytes;
+       }
+    }
+  else if (control == IOBUFCTRL_FLUSH)
+    {
+      if (size)
+       {
+         byte *p = buf;
+         int n;
+
+         nbytes = size;
+         do
+           {
+             n = send (a->sock, p, nbytes, 0);
+             if (n == SOCKET_ERROR)
+               {
+                 int ec = (int) WSAGetLastError ();
+                 rc = gpg_error_from_errno (ec);
+                 log_error ("socket write error: ec=%d\n", ec);
+                 break;
+               }
+             p += n;
+             nbytes -= n;
+           }
+         while (nbytes);
+         nbytes = p - buf;
+       }
+      *ret_len = nbytes;
+    }
+  else if (control == IOBUFCTRL_INIT)
+    {
+      a->eof_seen = 0;
+      a->keep_open = 0;
+      a->no_cache = 0;
+    }
+  else if (control == IOBUFCTRL_DESC)
+    {
+      *(char **) buf = "sock_filter";
+    }
+  else if (control == IOBUFCTRL_FREE)
+    {
+      if (!a->keep_open)
+       closesocket (a->sock);
+      xfree (a);               /* we can free our context now */
+    }
+  return rc;
+}
+#endif /*__MINGW32__*/
+
+/****************
+ * This is used to implement the block write mode.
+ * Block reading is done on a byte by byte basis in readbyte(),
+ * without a filter
+ */
+static int
+block_filter (void *opaque, int control, iobuf_t chain, byte * buf,
+             size_t * ret_len)
+{
+  block_filter_ctx_t *a = opaque;
+  size_t size = *ret_len;
+  int c, needed, rc = 0;
+  char *p;
+
+  if (control == IOBUFCTRL_UNDERFLOW)
+    {
+      size_t n = 0;
+
+      p = buf;
+      assert (size);           /* need a buffer */
+      if (a->eof)              /* don't read any further */
+       rc = -1;
+      while (!rc && size)
+       {
+         if (!a->size)
+           {                   /* get the length bytes */
+             if (a->partial == 2)
+               {
+                 a->eof = 1;
+                 if (!n)
+                   rc = -1;
+                 break;
+               }
+             else if (a->partial)
+               {
+                 /* These OpenPGP introduced huffman like encoded length
+                  * bytes are really a mess :-( */
+                 if (a->first_c)
+                   {
+                     c = a->first_c;
+                     a->first_c = 0;
+                   }
+                 else if ((c = iobuf_get (chain)) == -1)
+                   {
+                     log_error ("block_filter: 1st length byte missing\n");
+                     rc = GPG_ERR_BAD_DATA;
+                     break;
+                   }
+                 if (c < 192)
+                   {
+                     a->size = c;
+                     a->partial = 2;
+                     if (!a->size)
+                       {
+                         a->eof = 1;
+                         if (!n)
+                           rc = -1;
+                         break;
+                       }
+                   }
+                 else if (c < 224)
+                   {
+                     a->size = (c - 192) * 256;
+                     if ((c = iobuf_get (chain)) == -1)
+                       {
+                         log_error
+                           ("block_filter: 2nd length byte missing\n");
+                         rc = GPG_ERR_BAD_DATA;
+                         break;
+                       }
+                     a->size += c + 192;
+                     a->partial = 2;
+                     if (!a->size)
+                       {
+                         a->eof = 1;
+                         if (!n)
+                           rc = -1;
+                         break;
+                       }
+                   }
+                 else if (c == 255)
+                   {
+                     a->size = iobuf_get (chain) << 24;
+                     a->size |= iobuf_get (chain) << 16;
+                     a->size |= iobuf_get (chain) << 8;
+                     if ((c = iobuf_get (chain)) == -1)
+                       {
+                         log_error ("block_filter: invalid 4 byte length\n");
+                         rc = GPG_ERR_BAD_DATA;
+                         break;
+                       }
+                     a->size |= c;
+                   }
+                 else
+                   {           /* next partial body length */
+                     a->size = 1 << (c & 0x1f);
+                   }
+                 /*  log_debug("partial: ctx=%p c=%02x size=%u\n", a, c, a->size); */
+               }
+             else
+               {               /* the gnupg partial length scheme - much better :-) */
+                 c = iobuf_get (chain);
+                 a->size = c << 8;
+                 c = iobuf_get (chain);
+                 a->size |= c;
+                 if (c == -1)
+                   {
+                     log_error ("block_filter: error reading length info\n");
+                     rc = GPG_ERR_BAD_DATA;
+                   }
+                 if (!a->size)
+                   {
+                     a->eof = 1;
+                     if (!n)
+                       rc = -1;
+                     break;
+                   }
+               }
+           }
+
+         while (!rc && size && a->size)
+           {
+             needed = size < a->size ? size : a->size;
+             c = iobuf_read (chain, p, needed);
+             if (c < needed)
+               {
+                 if (c == -1)
+                   c = 0;
+                 log_error
+                   ("block_filter %p: read error (size=%lu,a->size=%lu)\n",
+                    a, (ulong) size + c, (ulong) a->size + c);
+                 rc = GPG_ERR_BAD_DATA;
+               }
+             else
+               {
+                 size -= c;
+                 a->size -= c;
+                 p += c;
+                 n += c;
+               }
+           }
+       }
+      *ret_len = n;
+    }
+  else if (control == IOBUFCTRL_FLUSH)
+    {
+      if (a->partial)
+       {                       /* the complicated openpgp scheme */
+         size_t blen, n, nbytes = size + a->buflen;
+
+         assert (a->buflen <= OP_MIN_PARTIAL_CHUNK);
+         if (nbytes < OP_MIN_PARTIAL_CHUNK)
+           {
+             /* not enough to write a partial block out; so we store it */
+             if (!a->buffer)
+               a->buffer = xmalloc (OP_MIN_PARTIAL_CHUNK);
+             memcpy (a->buffer + a->buflen, buf, size);
+             a->buflen += size;
+           }
+         else
+           {                   /* okay, we can write out something */
+             /* do this in a loop to use the most efficient block lengths */
+             p = buf;
+             do
+               {
+                 /* find the best matching block length - this is limited
+                  * by the size of the internal buffering */
+                 for (blen = OP_MIN_PARTIAL_CHUNK * 2,
+                      c = OP_MIN_PARTIAL_CHUNK_2POW + 1; blen <= nbytes;
+                      blen *= 2, c++)
+                   ;
+                 blen /= 2;
+                 c--;
+                 /* write the partial length header */
+                 assert (c <= 0x1f);   /*;-) */
+                 c |= 0xe0;
+                 iobuf_put (chain, c);
+                 if ((n = a->buflen))
+                   {           /* write stuff from the buffer */
+                     assert (n == OP_MIN_PARTIAL_CHUNK);
+                     if (iobuf_write (chain, a->buffer, n))
+                       rc = gpg_error_from_errno (errno);
+                     a->buflen = 0;
+                     nbytes -= n;
+                   }
+                 if ((n = nbytes) > blen)
+                   n = blen;
+                 if (n && iobuf_write (chain, p, n))
+                   rc = gpg_error_from_errno (errno);
+                 p += n;
+                 nbytes -= n;
+               }
+             while (!rc && nbytes >= OP_MIN_PARTIAL_CHUNK);
+             /* store the rest in the buffer */
+             if (!rc && nbytes)
+               {
+                 assert (!a->buflen);
+                 assert (nbytes < OP_MIN_PARTIAL_CHUNK);
+                 if (!a->buffer)
+                   a->buffer = xmalloc (OP_MIN_PARTIAL_CHUNK);
+                 memcpy (a->buffer, p, nbytes);
+                 a->buflen = nbytes;
+               }
+           }
+       }
+      else
+       {                       /* the gnupg scheme (which is not openpgp compliant) */
+         size_t avail, n;
+
+         for (p = buf; !rc && size;)
+           {
+             n = size;
+             avail = a->size - a->count;
+             if (!avail)
+               {
+                 if (n > a->size)
+                   {
+                     iobuf_put (chain, (a->size >> 8) & 0xff);
+                     iobuf_put (chain, a->size & 0xff);
+                     avail = a->size;
+                     a->count = 0;
+                   }
+                 else
+                   {
+                     iobuf_put (chain, (n >> 8) & 0xff);
+                     iobuf_put (chain, n & 0xff);
+                     avail = n;
+                     a->count = a->size - n;
+                   }
+               }
+             if (n > avail)
+               n = avail;
+             if (iobuf_write (chain, p, n))
+               rc = gpg_error_from_errno (errno);
+             a->count += n;
+             p += n;
+             size -= n;
+           }
+       }
+    }
+  else if (control == IOBUFCTRL_INIT)
+    {
+      if (DBG_IOBUF)
+       log_debug ("init block_filter %p\n", a);
+      if (a->partial)
+       a->count = 0;
+      else if (a->use == 1)
+       a->count = a->size = 0;
+      else
+       a->count = a->size;     /* force first length bytes */
+      a->eof = 0;
+      a->buffer = NULL;
+      a->buflen = 0;
+    }
+  else if (control == IOBUFCTRL_DESC)
+    {
+      *(char **) buf = "block_filter";
+    }
+  else if (control == IOBUFCTRL_FREE)
+    {
+      if (a->use == 2)
+       {                       /* write the end markers */
+         if (a->partial)
+           {
+             u32 len;
+             /* write out the remaining bytes without a partial header
+              * the length of this header may be 0 - but if it is
+              * the first block we are not allowed to use a partial header
+              * and frankly we can't do so, because this length must be
+              * a power of 2. This is _really_ complicated because we
+              * have to check the possible length of a packet prior
+              * to it's creation: a chain of filters becomes complicated
+              * and we need a lot of code to handle compressed packets etc.
+              *   :-(((((((
+              */
+             /* construct header */
+             len = a->buflen;
+             /*log_debug("partial: remaining length=%u\n", len ); */
+             if (len < 192)
+               rc = iobuf_put (chain, len);
+             else if (len < 8384)
+               {
+                 if (!(rc = iobuf_put (chain, ((len - 192) / 256) + 192)))
+                   rc = iobuf_put (chain, ((len - 192) % 256));
+               }
+             else
+               {               /* use a 4 byte header */
+                 if (!(rc = iobuf_put (chain, 0xff)))
+                   if (!(rc = iobuf_put (chain, (len >> 24) & 0xff)))
+                     if (!(rc = iobuf_put (chain, (len >> 16) & 0xff)))
+                       if (!(rc = iobuf_put (chain, (len >> 8) & 0xff)))
+                         rc = iobuf_put (chain, len & 0xff);
+               }
+             if (!rc && len)
+               rc = iobuf_write (chain, a->buffer, len);
+             if (rc)
+               {
+                 log_error ("block_filter: write error: %s\n",
+                            strerror (errno));
+                 rc = gpg_error_from_errno (errno);
+               }
+             xfree (a->buffer);
+             a->buffer = NULL;
+             a->buflen = 0;
+           }
+         else
+           {
+             iobuf_writebyte (chain, 0);
+             iobuf_writebyte (chain, 0);
+           }
+       }
+      else if (a->size)
+       {
+         log_error ("block_filter: pending bytes!\n");
+       }
+      if (DBG_IOBUF)
+       log_debug ("free block_filter %p\n", a);
+      xfree (a);               /* we can free our context now */
+    }
+
+  return rc;
+}
+
+
+static void
+print_chain (iobuf_t a)
+{
+  if (!DBG_IOBUF)
+    return;
+  for (; a; a = a->chain)
+    {
+      size_t dummy_len = 0;
+      const char *desc = "[none]";
+
+      if (a->filter)
+       a->filter (a->filter_ov, IOBUFCTRL_DESC, NULL,
+                  (byte *) & desc, &dummy_len);
+
+      log_debug ("iobuf chain: %d.%d `%s' filter_eof=%d start=%d len=%d\n",
+                a->no, a->subno, desc, a->filter_eof,
+                (int) a->d.start, (int) a->d.len);
+    }
+}
+
+int
+iobuf_print_chain (iobuf_t a)
+{
+  print_chain (a);
+  return 0;
+}
+
+/****************
+ * Allocate a new io buffer, with no function assigned.
+ * Use is the desired usage: 1 for input, 2 for output, 3 for temp buffer
+ * BUFSIZE is a suggested buffer size.
+ */
+iobuf_t
+iobuf_alloc (int use, size_t bufsize)
+{
+  iobuf_t a;
+  static int number = 0;
+
+  a = xcalloc (1, sizeof *a);
+  a->use = use;
+  a->d.buf = xmalloc (bufsize);
+  a->d.size = bufsize;
+  a->no = ++number;
+  a->subno = 0;
+  a->opaque = NULL;
+  a->real_fname = NULL;
+  return a;
+}
+
+int
+iobuf_close (iobuf_t a)
+{
+  iobuf_t a2;
+  size_t dummy_len = 0;
+  int rc = 0;
+
+  if (a && a->directfp)
+    {
+      fclose (a->directfp);
+      xfree (a->real_fname);
+      if (DBG_IOBUF)
+       log_debug ("iobuf_close -> %p\n", a->directfp);
+      return 0;
+    }
+
+  for (; a && !rc; a = a2)
+    {
+      a2 = a->chain;
+      if (a->use == 2 && (rc = iobuf_flush (a)))
+       log_error ("iobuf_flush failed on close: %s\n", gpg_strerror (rc));
+
+      if (DBG_IOBUF)
+       log_debug ("iobuf-%d.%d: close `%s'\n", a->no, a->subno, a->desc);
+      if (a->filter && (rc = a->filter (a->filter_ov, IOBUFCTRL_FREE,
+                                       a->chain, NULL, &dummy_len)))
+       log_error ("IOBUFCTRL_FREE failed on close: %s\n", gpg_strerror (rc));
+      xfree (a->real_fname);
+      if (a->d.buf)
+       {
+         memset (a->d.buf, 0, a->d.size);      /* erase the buffer */
+         xfree (a->d.buf);
+       }
+      xfree (a);
+    }
+  return rc;
+}
+
+int
+iobuf_cancel (iobuf_t a)
+{
+  const char *s;
+  iobuf_t a2;
+  int rc;
+#if defined(HAVE_DOSISH_SYSTEM) || defined(__riscos__)
+  char *remove_name = NULL;
+#endif
+
+  if (a && a->use == 2)
+    {
+      s = iobuf_get_real_fname (a);
+      if (s && *s)
+       {
+#if defined(HAVE_DOSISH_SYSTEM) || defined(__riscos__)
+         remove_name = m_strdup (s);
+#else
+         remove (s);
+#endif
+       }
+    }
+
+  /* send a cancel message to all filters */
+  for (a2 = a; a2; a2 = a2->chain)
+    {
+      size_t dummy;
+      if (a2->filter)
+       a2->filter (a2->filter_ov, IOBUFCTRL_CANCEL, a2->chain, NULL, &dummy);
+    }
+
+  rc = iobuf_close (a);
+#if defined(HAVE_DOSISH_SYSTEM) || defined(__riscos__)
+  if (remove_name)
+    {
+      /* Argg, MSDOS does not allow to remove open files.  So
+       * we have to do it here */
+      remove (remove_name);
+      xfree (remove_name);
+    }
+#endif
+  return rc;
+}
+
+
+/****************
+ * create a temporary iobuf, which can be used to collect stuff
+ * in an iobuf and later be written by iobuf_write_temp() to another
+ * iobuf.
+ */
+iobuf_t
+iobuf_temp ()
+{
+  iobuf_t a;
+
+  a = iobuf_alloc (3, 8192);
+
+  return a;
+}
+
+iobuf_t
+iobuf_temp_with_content (const char *buffer, size_t length)
+{
+  iobuf_t a;
+
+  a = iobuf_alloc (3, length);
+  memcpy (a->d.buf, buffer, length);
+  a->d.len = length;
+
+  return a;
+}
+
+void
+iobuf_enable_special_filenames (int yes)
+{
+  special_names_enabled = yes;
+}
+
+/*
+ * see whether the filename has the for "-&nnnn", where n is a
+ * non-zero number.
+ * Returns this number or -1 if it is not the case.
+ */
+static int
+check_special_filename (const char *fname)
+{
+  if (special_names_enabled && fname && *fname == '-' && fname[1] == '&')
+    {
+      int i;
+
+      fname += 2;
+      for (i = 0; isdigit (fname[i]); i++)
+       ;
+      if (!fname[i])
+       return atoi (fname);
+    }
+  return -1;
+}
+
+/****************
+ * Create a head iobuf for reading from a file
+ * returns: NULL if an error occures and sets errno
+ */
+iobuf_t
+iobuf_open (const char *fname)
+{
+  iobuf_t a;
+  FILEP_OR_FD fp;
+  file_filter_ctx_t *fcx;
+  size_t len;
+  int print_only = 0;
+  int fd;
+
+  if (!fname || (*fname == '-' && !fname[1]))
+    {
+      fp = FILEP_OR_FD_FOR_STDIN;
+#ifdef USE_SETMODE
+      setmode (my_fileno (fp), O_BINARY);
+#endif
+      fname = "[stdin]";
+      print_only = 1;
+    }
+  else if ((fd = check_special_filename (fname)) != -1)
+    return iobuf_fdopen (translate_file_handle (fd, 0), "rb");
+  else if ((fp = my_fopen_ro (fname, "rb")) == INVALID_FP)
+    return NULL;
+  a = iobuf_alloc (1, 8192);
+  fcx = xmalloc (sizeof *fcx + strlen (fname));
+  fcx->fp = fp;
+  fcx->print_only_name = print_only;
+  strcpy (fcx->fname, fname);
+  if (!print_only)
+    a->real_fname = xstrdup (fname);
+  a->filter = file_filter;
+  a->filter_ov = fcx;
+  file_filter (fcx, IOBUFCTRL_DESC, NULL, (byte *) & a->desc, &len);
+  file_filter (fcx, IOBUFCTRL_INIT, NULL, NULL, &len);
+  if (DBG_IOBUF)
+    log_debug ("iobuf-%d.%d: open `%s' fd=%d\n",
+              a->no, a->subno, fname, (int) my_fileno (fcx->fp));
+
+  return a;
+}
+
+/****************
+ * Create a head iobuf for reading from a file
+ * returns: NULL if an error occures and sets errno
+ */
+iobuf_t
+iobuf_fdopen (int fd, const char *mode)
+{
+  iobuf_t a;
+  FILEP_OR_FD fp;
+  file_filter_ctx_t *fcx;
+  size_t len;
+
+#ifdef FILE_FILTER_USES_STDIO
+  if (!(fp = fdopen (fd, mode)))
+    return NULL;
+#else
+  fp = (FILEP_OR_FD) fd;
+#endif
+  a = iobuf_alloc (strchr (mode, 'w') ? 2 : 1, 8192);
+  fcx = xmalloc (sizeof *fcx + 20);
+  fcx->fp = fp;
+  fcx->print_only_name = 1;
+  sprintf (fcx->fname, "[fd %d]", fd);
+  a->filter = file_filter;
+  a->filter_ov = fcx;
+  file_filter (fcx, IOBUFCTRL_DESC, NULL, (byte *) & a->desc, &len);
+  file_filter (fcx, IOBUFCTRL_INIT, NULL, NULL, &len);
+  if (DBG_IOBUF)
+    log_debug ("iobuf-%d.%d: fdopen `%s'\n", a->no, a->subno, fcx->fname);
+  iobuf_ioctl (a, 3, 1, NULL); /* disable fd caching */
+  return a;
+}
+
+
+iobuf_t
+iobuf_sockopen (int fd, const char *mode)
+{
+  iobuf_t a;
+#ifdef __MINGW32__
+  sock_filter_ctx_t *scx;
+  size_t len;
+
+  a = iobuf_alloc (strchr (mode, 'w') ? 2 : 1, 8192);
+  scx = m_alloc (sizeof *scx + 25);
+  scx->sock = fd;
+  scx->print_only_name = 1;
+  sprintf (scx->fname, "[sock %d]", fd);
+  a->filter = sock_filter;
+  a->filter_ov = scx;
+  sock_filter (scx, IOBUFCTRL_DESC, NULL, (byte *) & a->desc, &len);
+  sock_filter (scx, IOBUFCTRL_INIT, NULL, NULL, &len);
+  if (DBG_IOBUF)
+    log_debug ("iobuf-%d.%d: sockopen `%s'\n", a->no, a->subno, scx->fname);
+  iobuf_ioctl (a, 3, 1, NULL); /* disable fd caching */
+#else
+  a = iobuf_fdopen (fd, mode);
+#endif
+  return a;
+}
+
+/****************
+ * create an iobuf for writing to a file; the file will be created.
+ */
+iobuf_t
+iobuf_create (const char *fname)
+{
+  iobuf_t a;
+  FILEP_OR_FD fp;
+  file_filter_ctx_t *fcx;
+  size_t len;
+  int print_only = 0;
+  int fd;
+
+  if (!fname || (*fname == '-' && !fname[1]))
+    {
+      fp = FILEP_OR_FD_FOR_STDOUT;
+#ifdef USE_SETMODE
+      setmode (my_fileno (fp), O_BINARY);
+#endif
+      fname = "[stdout]";
+      print_only = 1;
+    }
+  else if ((fd = check_special_filename (fname)) != -1)
+    return iobuf_fdopen (translate_file_handle (fd, 1), "wb");
+  else if ((fp = my_fopen (fname, "wb")) == INVALID_FP)
+    return NULL;
+  a = iobuf_alloc (2, 8192);
+  fcx = xmalloc (sizeof *fcx + strlen (fname));
+  fcx->fp = fp;
+  fcx->print_only_name = print_only;
+  strcpy (fcx->fname, fname);
+  if (!print_only)
+    a->real_fname = xstrdup (fname);
+  a->filter = file_filter;
+  a->filter_ov = fcx;
+  file_filter (fcx, IOBUFCTRL_DESC, NULL, (byte *) & a->desc, &len);
+  file_filter (fcx, IOBUFCTRL_INIT, NULL, NULL, &len);
+  if (DBG_IOBUF)
+    log_debug ("iobuf-%d.%d: create `%s'\n", a->no, a->subno, a->desc);
+
+  return a;
+}
+
+/****************
+ * append to an iobuf; if the file does not exist, create it.
+ * cannot be used for stdout.
+ * Note: This is not used.
+ */
+#if 0                          /* not used */
+iobuf_t
+iobuf_append (const char *fname)
+{
+  iobuf_t a;
+  FILE *fp;
+  file_filter_ctx_t *fcx;
+  size_t len;
+
+  if (!fname)
+    return NULL;
+  else if (!(fp = my_fopen (fname, "ab")))
+    return NULL;
+  a = iobuf_alloc (2, 8192);
+  fcx = m_alloc (sizeof *fcx + strlen (fname));
+  fcx->fp = fp;
+  strcpy (fcx->fname, fname);
+  a->real_fname = m_strdup (fname);
+  a->filter = file_filter;
+  a->filter_ov = fcx;
+  file_filter (fcx, IOBUFCTRL_DESC, NULL, (byte *) & a->desc, &len);
+  file_filter (fcx, IOBUFCTRL_INIT, NULL, NULL, &len);
+  if (DBG_IOBUF)
+    log_debug ("iobuf-%d.%d: append `%s'\n", a->no, a->subno, a->desc);
+
+  return a;
+}
+#endif
+
+iobuf_t
+iobuf_openrw (const char *fname)
+{
+  iobuf_t a;
+  FILEP_OR_FD fp;
+  file_filter_ctx_t *fcx;
+  size_t len;
+
+  if (!fname)
+    return NULL;
+  else if ((fp = my_fopen (fname, "r+b")) == INVALID_FP)
+    return NULL;
+  a = iobuf_alloc (2, 8192);
+  fcx = xmalloc (sizeof *fcx + strlen (fname));
+  fcx->fp = fp;
+  strcpy (fcx->fname, fname);
+  a->real_fname = xstrdup (fname);
+  a->filter = file_filter;
+  a->filter_ov = fcx;
+  file_filter (fcx, IOBUFCTRL_DESC, NULL, (byte *) & a->desc, &len);
+  file_filter (fcx, IOBUFCTRL_INIT, NULL, NULL, &len);
+  if (DBG_IOBUF)
+    log_debug ("iobuf-%d.%d: openrw `%s'\n", a->no, a->subno, a->desc);
+
+  return a;
+}
+
+
+int
+iobuf_ioctl (iobuf_t a, int cmd, int intval, void *ptrval)
+{
+  if (cmd == 1)
+    {                          /* keep system filepointer/descriptor open */
+      if (DBG_IOBUF)
+       log_debug ("iobuf-%d.%d: ioctl `%s' keep=%d\n",
+                  a ? a->no : -1, a ? a->subno : -1, a ? a->desc : "?",
+                  intval);
+      for (; a; a = a->chain)
+       if (!a->chain && a->filter == file_filter)
+         {
+           file_filter_ctx_t *b = a->filter_ov;
+           b->keep_open = intval;
+           return 0;
+         }
+#ifdef __MINGW32__
+       else if (!a->chain && a->filter == sock_filter)
+         {
+           sock_filter_ctx_t *b = a->filter_ov;
+           b->keep_open = intval;
+           return 0;
+         }
+#endif
+    }
+  else if (cmd == 2)
+    {                          /* invalidate cache */
+      if (DBG_IOBUF)
+       log_debug ("iobuf-*.*: ioctl `%s' invalidate\n",
+                  ptrval ? (char *) ptrval : "?");
+      if (!a && !intval && ptrval)
+       {
+#ifndef FILE_FILTER_USES_STDIO
+         fd_cache_invalidate (ptrval);
+#endif
+         return 0;
+       }
+    }
+  else if (cmd == 3)
+    {                          /* disallow/allow caching */
+      if (DBG_IOBUF)
+       log_debug ("iobuf-%d.%d: ioctl `%s' no_cache=%d\n",
+                  a ? a->no : -1, a ? a->subno : -1, a ? a->desc : "?",
+                  intval);
+      for (; a; a = a->chain)
+       if (!a->chain && a->filter == file_filter)
+         {
+           file_filter_ctx_t *b = a->filter_ov;
+           b->no_cache = intval;
+           return 0;
+         }
+#ifdef __MINGW32__
+       else if (!a->chain && a->filter == sock_filter)
+         {
+           sock_filter_ctx_t *b = a->filter_ov;
+           b->no_cache = intval;
+           return 0;
+         }
+#endif
+    }
+
+  return -1;
+}
+
+
+/****************
+ * Register an i/o filter.
+ */
+int
+iobuf_push_filter (iobuf_t a,
+                  int (*f) (void *opaque, int control,
+                            iobuf_t chain, byte * buf, size_t * len),
+                   void *ov)
+{
+  return iobuf_push_filter2 (a, f, ov, 0);
+}
+
+int
+iobuf_push_filter2 (iobuf_t a,
+                   int (*f) (void *opaque, int control,
+                             iobuf_t chain, byte * buf, size_t * len),
+                   void *ov, int rel_ov)
+{
+  iobuf_t b;
+  size_t dummy_len = 0;
+  int rc = 0;
+
+  if (a->directfp)
+    BUG ();
+
+  if (a->use == 2 && (rc = iobuf_flush (a)))
+    return rc;
+  /* make a copy of the current stream, so that
+   * A is the new stream and B the original one.
+   * The contents of the buffers are transferred to the
+   * new stream.
+   */
+  b = xmalloc (sizeof *b);
+  memcpy (b, a, sizeof *b);
+  /* fixme: it is stupid to keep a copy of the name at every level
+   * but we need the name somewhere because the name known by file_filter
+   * may have been released when we need the name of the file */
+  b->real_fname = a->real_fname ? xstrdup (a->real_fname) : NULL;
+  /* remove the filter stuff from the new stream */
+  a->filter = NULL;
+  a->filter_ov = NULL;
+  a->filter_ov_owner = 0;
+  a->filter_eof = 0;
+  if (a->use == 3)
+    a->use = 2;                        /* make a write stream from a temp stream */
+
+  if (a->use == 2)
+    {                          /* allocate a fresh buffer for the
+                                   original stream */
+      b->d.buf = xmalloc (a->d.size);
+      b->d.len = 0;
+      b->d.start = 0;
+    }
+  else
+    {                          /* allocate a fresh buffer for the new
+                                   stream */
+      a->d.buf = xmalloc (a->d.size);
+      a->d.len = 0;
+      a->d.start = 0;
+    }
+  /* disable nlimit for the new stream */
+  a->ntotal = b->ntotal + b->nbytes;
+  a->nlimit = a->nbytes = 0;
+  a->nofast &= ~1;
+  /* make a link from the new stream to the original stream */
+  a->chain = b;
+  a->opaque = b->opaque;
+
+  /* setup the function on the new stream */
+  a->filter = f;
+  a->filter_ov = ov;
+  a->filter_ov_owner = rel_ov;
+
+  a->subno = b->subno + 1;
+  f (ov, IOBUFCTRL_DESC, NULL, (byte *) & a->desc, &dummy_len);
+
+  if (DBG_IOBUF)
+    {
+      log_debug ("iobuf-%d.%d: push `%s'\n", a->no, a->subno, a->desc);
+      print_chain (a);
+    }
+
+  /* now we can initialize the new function if we have one */
+  if (a->filter && (rc = a->filter (a->filter_ov, IOBUFCTRL_INIT, a->chain,
+                                   NULL, &dummy_len)))
+    log_error ("IOBUFCTRL_INIT failed: %s\n", gpg_strerror (rc));
+  return rc;
+}
+
+/****************
+ * Remove an i/o filter.
+ */
+int
+pop_filter (iobuf_t a, int (*f) (void *opaque, int control,
+                              iobuf_t chain, byte * buf, size_t * len),
+           void *ov)
+{
+  iobuf_t b;
+  size_t dummy_len = 0;
+  int rc = 0;
+
+  if (a->directfp)
+    BUG ();
+
+  if (DBG_IOBUF)
+    log_debug ("iobuf-%d.%d: pop `%s'\n", a->no, a->subno, a->desc);
+  if (!a->filter)
+    {                          /* this is simple */
+      b = a->chain;
+      assert (b);
+      xfree (a->d.buf);
+      xfree (a->real_fname);
+      memcpy (a, b, sizeof *a);
+      xfree (b);
+      return 0;
+    }
+  for (b = a; b; b = b->chain)
+    if (b->filter == f && (!ov || b->filter_ov == ov))
+      break;
+  if (!b)
+    log_bug ("pop_filter(): filter function not found\n");
+
+  /* flush this stream if it is an output stream */
+  if (a->use == 2 && (rc = iobuf_flush (b)))
+    {
+      log_error ("iobuf_flush failed in pop_filter: %s\n", gpg_strerror (rc));
+      return rc;
+    }
+  /* and tell the filter to free it self */
+  if (b->filter && (rc = b->filter (b->filter_ov, IOBUFCTRL_FREE, b->chain,
+                                   NULL, &dummy_len)))
+    {
+      log_error ("IOBUFCTRL_FREE failed: %s\n", gpg_strerror (rc));
+      return rc;
+    }
+  if (b->filter_ov && b->filter_ov_owner)
+    {
+      xfree (b->filter_ov);
+      b->filter_ov = NULL;
+    }
+
+
+  /* and see how to remove it */
+  if (a == b && !b->chain)
+    log_bug ("can't remove the last filter from the chain\n");
+  else if (a == b)
+    {                          /* remove the first iobuf from the chain */
+      /* everything from b is copied to a. This is save because
+       * a flush has been done on the to be removed entry
+       */
+      b = a->chain;
+      xfree (a->d.buf);
+      xfree (a->real_fname);
+      memcpy (a, b, sizeof *a);
+      xfree (b);
+      if (DBG_IOBUF)
+       log_debug ("iobuf-%d.%d: popped filter\n", a->no, a->subno);
+    }
+  else if (!b->chain)
+    {                          /* remove the last iobuf from the chain */
+      log_bug ("Ohh jeee, trying to remove a head filter\n");
+    }
+  else
+    {                          /* remove an intermediate iobuf from the chain */
+      log_bug ("Ohh jeee, trying to remove an intermediate filter\n");
+    }
+
+  return rc;
+}
+
+
+/****************
+ * read underflow: read more bytes into the buffer and return
+ * the first byte or -1 on EOF.
+ */
+static int
+underflow (iobuf_t a)
+{
+  size_t len;
+  int rc;
+
+  assert (a->d.start == a->d.len);
+  if (a->use == 3)
+    return -1;                 /* EOF because a temp buffer can't do an underflow */
+
+  if (a->filter_eof)
+    {
+      if (a->chain)
+       {
+         iobuf_t b = a->chain;
+         if (DBG_IOBUF)
+           log_debug ("iobuf-%d.%d: pop `%s' in underflow\n",
+                      a->no, a->subno, a->desc);
+         xfree (a->d.buf);
+         xfree (a->real_fname);
+         memcpy (a, b, sizeof *a);
+         xfree (b);
+         print_chain (a);
+       }
+      else
+       a->filter_eof = 0;      /* for the top level filter */
+      if (DBG_IOBUF)
+       log_debug ("iobuf-%d.%d: underflow: eof (due to filter eof)\n",
+                  a->no, a->subno);
+      return -1;               /* return one(!) EOF */
+    }
+  if (a->error)
+    {
+      if (DBG_IOBUF)
+       log_debug ("iobuf-%d.%d: error\n", a->no, a->subno);
+      return -1;
+    }
+
+  if (a->directfp)
+    {
+      FILE *fp = a->directfp;
+
+      len = fread (a->d.buf, 1, a->d.size, fp);
+      if (len < a->d.size)
+       {
+         if (ferror (fp))
+           a->error = gpg_error_from_errno (errno);
+       }
+      a->d.len = len;
+      a->d.start = 0;
+      return len ? a->d.buf[a->d.start++] : -1;
+    }
+
+
+  if (a->filter)
+    {
+      len = a->d.size;
+      if (DBG_IOBUF)
+       log_debug ("iobuf-%d.%d: underflow: req=%lu\n",
+                  a->no, a->subno, (ulong) len);
+      rc = a->filter (a->filter_ov, IOBUFCTRL_UNDERFLOW, a->chain,
+                     a->d.buf, &len);
+      if (DBG_IOBUF)
+       {
+         log_debug ("iobuf-%d.%d: underflow: got=%lu rc=%d\n",
+                    a->no, a->subno, (ulong) len, rc);
+/*         if( a->no == 1 ) */
+/*                   log_hexdump ("     data:", a->d.buf, len); */
+       }
+      if (a->use == 1 && rc == -1)
+       {                       /* EOF: we can remove the filter */
+         size_t dummy_len = 0;
+
+         /* and tell the filter to free itself */
+         if ((rc = a->filter (a->filter_ov, IOBUFCTRL_FREE, a->chain,
+                              NULL, &dummy_len)))
+           log_error ("IOBUFCTRL_FREE failed: %s\n", gpg_strerror (rc));
+         if (a->filter_ov && a->filter_ov_owner)
+           {
+             xfree (a->filter_ov);
+             a->filter_ov = NULL;
+           }
+         a->filter = NULL;
+         a->desc = NULL;
+         a->filter_ov = NULL;
+         a->filter_eof = 1;
+         if (!len && a->chain)
+           {
+             iobuf_t b = a->chain;
+             if (DBG_IOBUF)
+               log_debug ("iobuf-%d.%d: pop `%s' in underflow (!len)\n",
+                          a->no, a->subno, a->desc);
+             xfree (a->d.buf);
+             xfree (a->real_fname);
+             memcpy (a, b, sizeof *a);
+             xfree (b);
+             print_chain (a);
+           }
+       }
+      else if (rc)
+       a->error = rc;
+
+      if (!len)
+       {
+         if (DBG_IOBUF)
+           log_debug ("iobuf-%d.%d: underflow: eof\n", a->no, a->subno);
+         return -1;
+       }
+      a->d.len = len;
+      a->d.start = 0;
+      return a->d.buf[a->d.start++];
+    }
+  else
+    {
+      if (DBG_IOBUF)
+       log_debug ("iobuf-%d.%d: underflow: eof (no filter)\n",
+                  a->no, a->subno);
+      return -1;               /* no filter; return EOF */
+    }
+}
+
+
+int
+iobuf_flush (iobuf_t a)
+{
+  size_t len;
+  int rc;
+
+  if (a->directfp)
+    return 0;
+
+  if (a->use == 3)
+    {                          /* increase the temp buffer */
+      char *newbuf;
+      size_t newsize = a->d.size + 8192;
+
+      if (DBG_IOBUF)
+       log_debug ("increasing temp iobuf from %lu to %lu\n",
+                  (ulong) a->d.size, (ulong) newsize);
+      newbuf = xmalloc (newsize);
+      memcpy (newbuf, a->d.buf, a->d.len);
+      xfree (a->d.buf);
+      a->d.buf = newbuf;
+      a->d.size = newsize;
+      return 0;
+    }
+  else if (a->use != 2)
+    log_bug ("flush on non-output iobuf\n");
+  else if (!a->filter)
+    log_bug ("iobuf_flush: no filter\n");
+  len = a->d.len;
+  rc = a->filter (a->filter_ov, IOBUFCTRL_FLUSH, a->chain, a->d.buf, &len);
+  if (!rc && len != a->d.len)
+    {
+      log_info ("iobuf_flush did not write all!\n");
+      rc = GPG_ERR_INTERNAL;
+    }
+  else if (rc)
+    a->error = rc;
+  a->d.len = 0;
+
+  return rc;
+}
+
+
+/****************
+ * Read a byte from the iobuf; returns -1 on EOF
+ */
+int
+iobuf_readbyte (iobuf_t a)
+{
+  int c;
+
+  /* nlimit does not work together with unget */
+  /* nbytes is also not valid! */
+  if (a->unget.buf)
+    {
+      if (a->unget.start < a->unget.len)
+       return a->unget.buf[a->unget.start++];
+      xfree (a->unget.buf);
+      a->unget.buf = NULL;
+      a->nofast &= ~2;
+    }
+
+  if (a->nlimit && a->nbytes >= a->nlimit)
+    return -1;                 /* forced EOF */
+
+  if (a->d.start < a->d.len)
+    {
+      c = a->d.buf[a->d.start++];
+    }
+  else if ((c = underflow (a)) == -1)
+    return -1;                 /* EOF */
+
+  a->nbytes++;
+  return c;
+}
+
+
+int
+iobuf_read (iobuf_t a, byte * buf, unsigned buflen)
+{
+  int c, n;
+
+  if (a->unget.buf || a->nlimit)
+    {
+      /* handle special cases */
+      for (n = 0; n < buflen; n++)
+       {
+         if ((c = iobuf_readbyte (a)) == -1)
+           {
+             if (!n)
+               return -1;      /* eof */
+             break;
+           }
+         else if (buf)
+           *buf = c;
+         if (buf)
+           buf++;
+       }
+      return n;
+    }
+
+  n = 0;
+  do
+    {
+      if (n < buflen && a->d.start < a->d.len)
+       {
+         unsigned size = a->d.len - a->d.start;
+         if (size > buflen - n)
+           size = buflen - n;
+         if (buf)
+           memcpy (buf, a->d.buf + a->d.start, size);
+         n += size;
+         a->d.start += size;
+         if (buf)
+           buf += size;
+       }
+      if (n < buflen)
+       {
+         if ((c = underflow (a)) == -1)
+           {
+             a->nbytes += n;
+             return n ? n : -1 /*EOF*/;
+           }
+         if (buf)
+           *buf++ = c;
+         n++;
+       }
+    }
+  while (n < buflen);
+  a->nbytes += n;
+  return n;
+}
+
+
+/****************
+ * Have a look at the iobuf.
+ * NOTE: This only works in special cases.
+ */
+int
+iobuf_peek (iobuf_t a, byte * buf, unsigned buflen)
+{
+  int n = 0;
+
+  if (a->filter_eof)
+    return -1;
+
+  if (!(a->d.start < a->d.len))
+    {
+      if (underflow (a) == -1)
+       return -1;
+      /* and unget this character */
+      assert (a->d.start == 1);
+      a->d.start = 0;
+    }
+
+  for (n = 0; n < buflen && (a->d.start + n) < a->d.len; n++, buf++)
+    *buf = a->d.buf[n];
+  return n;
+}
+
+
+
+
+int
+iobuf_writebyte (iobuf_t a, unsigned c)
+{
+  int rc;
+
+  if (a->directfp)
+    BUG ();
+
+  if (a->d.len == a->d.size)
+    if ((rc=iobuf_flush (a)))
+      return rc;
+
+  assert (a->d.len < a->d.size);
+  a->d.buf[a->d.len++] = c;
+  return 0;
+}
+
+
+int
+iobuf_write (iobuf_t a, byte * buf, unsigned buflen)
+{
+  int rc;
+
+  if (a->directfp)
+    BUG ();
+
+  do
+    {
+      if (buflen && a->d.len < a->d.size)
+       {
+         unsigned size = a->d.size - a->d.len;
+         if (size > buflen)
+           size = buflen;
+         memcpy (a->d.buf + a->d.len, buf, size);
+         buflen -= size;
+         buf += size;
+         a->d.len += size;
+       }
+      if (buflen)
+       {
+         rc = iobuf_flush (a);
+          if (rc)
+           return rc;
+       }
+    }
+  while (buflen);
+  return 0;
+}
+
+
+int
+iobuf_writestr (iobuf_t a, const char *buf)
+{
+  int rc;
+
+  for (; *buf; buf++)
+    if ((rc=iobuf_writebyte (a, *buf)))
+      return rc;
+  return 0;
+}
+
+
+
+/****************
+ * copy the contents of TEMP to A.
+ */
+int
+iobuf_write_temp (iobuf_t a, iobuf_t temp)
+{
+  while (temp->chain)
+    pop_filter (temp, temp->filter, NULL);
+  return iobuf_write (a, temp->d.buf, temp->d.len);
+}
+
+/****************
+ * copy the contents of the temp io stream to BUFFER.
+ */
+size_t
+iobuf_temp_to_buffer (iobuf_t a, byte * buffer, size_t buflen)
+{
+  size_t n = a->d.len;
+
+  if (n > buflen)
+    n = buflen;
+  memcpy (buffer, a->d.buf, n);
+  return n;
+}
+
+
+/****************
+ * Call this function to terminate processing of the temp stream
+ * without closing it. This removes all filters from the stream
+ * makes sure that iobuf_get_temp_{buffer,length}() returns correct
+ * values.
+ */
+void
+iobuf_flush_temp (iobuf_t temp)
+{
+  while (temp->chain)
+    pop_filter (temp, temp->filter, NULL);
+}
+
+
+/****************
+ * Set a limit on how many bytes may be read from the input stream A.
+ * Setting the limit to 0 disables this feature.
+ */
+void
+iobuf_set_limit (iobuf_t a, off_t nlimit)
+{
+  if (nlimit)
+    a->nofast |= 1;
+  else
+    a->nofast &= ~1;
+  a->nlimit = nlimit;
+  a->ntotal += a->nbytes;
+  a->nbytes = 0;
+}
+
+
+
+/****************
+ * Return the length of an open file
+ */
+off_t
+iobuf_get_filelength (iobuf_t a)
+{
+  struct stat st;
+
+  if (a->directfp)
+    {
+      FILE *fp = a->directfp;
+
+      if (!fstat (fileno (fp), &st))
+       return st.st_size;
+      log_error ("fstat() failed: %s\n", strerror (errno));
+      return 0;
+    }
+
+  /* Hmmm: file_filter may have already been removed */
+  for (; a; a = a->chain)
+    if (!a->chain && a->filter == file_filter)
+      {
+       file_filter_ctx_t *b = a->filter_ov;
+       FILEP_OR_FD fp = b->fp;
+
+#if defined(HAVE_DOSISH_SYSTEM) && !defined(FILE_FILTER_USES_STDIO)
+       ulong size;
+
+       if ((size = GetFileSize (fp, NULL)) != 0xffffffff)
+         return size;
+       log_error ("GetFileSize for handle %p failed: ec=%d\n",
+                  fp, (int) GetLastError ());
+#else
+       if (!fstat (my_fileno (fp), &st))
+         return st.st_size;
+       log_error ("fstat() failed: %s\n", strerror (errno));
+#endif
+       break;
+      }
+
+  return 0;
+}
+
+/****************
+ * Tell the file position, where the next read will take place
+ */
+off_t
+iobuf_tell (iobuf_t a)
+{
+  return a->ntotal + a->nbytes;
+}
+
+
+#if !defined(HAVE_FSEEKO) && !defined(fseeko)
+
+#ifdef HAVE_LIMITS_H
+# include <limits.h>
+#endif
+#ifndef LONG_MAX
+# define LONG_MAX ((long) ((unsigned long) -1 >> 1))
+#endif
+#ifndef LONG_MIN
+# define LONG_MIN (-1 - LONG_MAX)
+#endif
+
+/****************
+ * A substitute for fseeko, for hosts that don't have it.
+ */
+static int
+fseeko (FILE * stream, off_t newpos, int whence)
+{
+  while (newpos != (long) newpos)
+    {
+      long pos = newpos < 0 ? LONG_MIN : LONG_MAX;
+      if (fseek (stream, pos, whence) != 0)
+       return -1;
+      newpos -= pos;
+      whence = SEEK_CUR;
+    }
+  return fseek (stream, (long) newpos, whence);
+}
+#endif
+
+/****************
+ * This is a very limited implementation. It simply discards all internal
+ * buffering and removes all filters but the first one.
+ */
+int
+iobuf_seek (iobuf_t a, off_t newpos)
+{
+  file_filter_ctx_t *b = NULL;
+
+  if (a->directfp)
+    {
+      FILE *fp = a->directfp;
+      if (fseeko (fp, newpos, SEEK_SET))
+       {
+         log_error ("can't seek: %s\n", strerror (errno));
+         return -1;
+       }
+      clearerr (fp);
+    }
+  else
+    {
+      for (; a; a = a->chain)
+       {
+         if (!a->chain && a->filter == file_filter)
+           {
+             b = a->filter_ov;
+             break;
+           }
+       }
+      if (!a)
+       return -1;
+#ifdef FILE_FILTER_USES_STDIO
+      if (fseeko (b->fp, newpos, SEEK_SET))
+       {
+         log_error ("can't fseek: %s\n", strerror (errno));
+         return -1;
+       }
+#else
+#ifdef HAVE_DOSISH_SYSTEM
+      if (SetFilePointer (b->fp, newpos, NULL, FILE_BEGIN) == 0xffffffff)
+       {
+         log_error ("SetFilePointer failed on handle %p: ec=%d\n",
+                    b->fp, (int) GetLastError ());
+         return -1;
+       }
+#else
+      if (lseek (b->fp, newpos, SEEK_SET) == (off_t) - 1)
+       {
+         log_error ("can't lseek: %s\n", strerror (errno));
+         return -1;
+       }
+#endif
+#endif
+    }
+  a->d.len = 0;                        /* discard buffer */
+  a->d.start = 0;
+  a->nbytes = 0;
+  a->nlimit = 0;
+  a->nofast &= ~1;
+  a->ntotal = newpos;
+  a->error = 0;
+  /* remove filters, but the last */
+  if (a->chain)
+    log_debug ("pop_filter called in iobuf_seek - please report\n");
+  while (a->chain)
+    pop_filter (a, a->filter, NULL);
+
+  return 0;
+}
+
+
+
+
+
+
+/****************
+ * Retrieve the real filename
+ */
+const char *
+iobuf_get_real_fname (iobuf_t a)
+{
+  if (a->real_fname)
+    return a->real_fname;
+
+  /* the old solution */
+  for (; a; a = a->chain)
+    if (!a->chain && a->filter == file_filter)
+      {
+       file_filter_ctx_t *b = a->filter_ov;
+       return b->print_only_name ? NULL : b->fname;
+      }
+
+  return NULL;
+}
+
+
+/****************
+ * Retrieve the filename
+ */
+const char *
+iobuf_get_fname (iobuf_t a)
+{
+  for (; a; a = a->chain)
+    if (!a->chain && a->filter == file_filter)
+      {
+       file_filter_ctx_t *b = a->filter_ov;
+       return b->fname;
+      }
+
+  return NULL;
+}
+
+/****************
+ * Start the block write mode, see rfc1991.new for details.
+ * A value of 0 for N stops this mode (flushes and writes
+ * the end marker)
+ */
+void
+iobuf_set_block_mode (iobuf_t a, size_t n)
+{
+  block_filter_ctx_t *ctx = xcalloc (1, sizeof *ctx);
+
+  assert (a->use == 1 || a->use == 2);
+  ctx->use = a->use;
+  if (!n)
+    {
+      if (a->use == 1)
+       log_debug ("pop_filter called in set_block_mode - please report\n");
+      pop_filter (a, block_filter, NULL);
+    }
+  else
+    {
+      ctx->size = n;           /* only needed for use 2 */
+      iobuf_push_filter (a, block_filter, ctx);
+    }
+}
+
+/****************
+ * enable partial block mode as described in the OpenPGP draft.
+ * LEN is the first length byte on read, but ignored on writes.
+ */
+void
+iobuf_set_partial_block_mode (iobuf_t a, size_t len)
+{
+  block_filter_ctx_t *ctx = xcalloc (1, sizeof *ctx);
+
+  assert (a->use == 1 || a->use == 2);
+  ctx->use = a->use;
+  if (!len)
+    {
+      if (a->use == 1)
+       log_debug ("pop_filter called in set_partial_block_mode"
+                  " - please report\n");
+      pop_filter (a, block_filter, NULL);
+    }
+  else
+    {
+      ctx->partial = 1;
+      ctx->size = 0;
+      ctx->first_c = len;
+      iobuf_push_filter (a, block_filter, ctx);
+    }
+}
+
+
+/****************
+ * Checks whether the stream is in block mode
+ * Note: This does not work if other filters are pushed on the stream.
+ */
+int
+iobuf_in_block_mode (iobuf_t a)
+{
+  if (a && a->filter == block_filter)
+    return 1;                  /* yes */
+  return 0;                    /* no */
+}
+
+
+/****************
+ * Same as fgets() but if the buffer is too short a larger one will
+ * be allocated up to some limit *max_length.
+ * A line is considered a byte stream ending in a LF.
+ * Returns the length of the line. EOF is indicated by a line of
+ * length zero. The last LF may be missing due to an EOF.
+ * is max_length is zero on return, the line has been truncated.
+ *
+ * Note: The buffer is allocated with enough space to append a CR,LF,EOL
+ */
+unsigned int
+iobuf_read_line (iobuf_t a, byte ** addr_of_buffer,
+                unsigned *length_of_buffer, unsigned *max_length)
+{
+  int c;
+  char *buffer = *addr_of_buffer;
+  unsigned length = *length_of_buffer;
+  unsigned nbytes = 0;
+  unsigned maxlen = *max_length;
+  char *p;
+
+  if (!buffer)
+    {                          /* must allocate a new buffer */
+      length = 256;
+      buffer = xmalloc (length);
+      *addr_of_buffer = buffer;
+      *length_of_buffer = length;
+    }
+
+  length -= 3;                 /* reserve 3 bytes (cr,lf,eol) */
+  p = buffer;
+  while ((c = iobuf_get (a)) != -1)
+    {
+      if (nbytes == length)
+       {                       /* increase the buffer */
+         if (length > maxlen)
+           {                   /* this is out limit */
+             /* skip the rest of the line */
+             while (c != '\n' && (c = iobuf_get (a)) != -1)
+               ;
+             *p++ = '\n';      /* always append a LF (we have reserved space) */
+             nbytes++;
+             *max_length = 0;  /* indicate truncation */
+             break;
+           }
+         length += 3;          /* correct for the reserved byte */
+         length += length < 1024 ? 256 : 1024;
+         buffer = xrealloc (buffer, length);
+         *addr_of_buffer = buffer;
+         *length_of_buffer = length;
+         length -= 3;          /* and reserve again */
+         p = buffer + nbytes;
+       }
+      *p++ = c;
+      nbytes++;
+      if (c == '\n')
+       break;
+    }
+  *p = 0;                      /* make sure the line is a string */
+
+  return nbytes;
+}
+
+/* This is the non iobuf specific function */
+int
+iobuf_translate_file_handle (int fd, int for_write)
+{
+#ifdef __MINGW32__
+  {
+    int x;
+
+    if (fd <= 2)
+      return fd;               /* do not do this for error, stdin, stdout, stderr */
+
+    x = _open_osfhandle (fd, for_write ? 1 : 0);
+    if (x == -1)
+      log_error ("failed to translate osfhandle %p\n", (void *) fd);
+    else
+      {
+       /*log_info ("_open_osfhandle %p yields %d%s\n",
+          (void*)fd, x, for_write? " for writing":"" ); */
+       fd = x;
+      }
+  }
+#endif
+  return fd;
+}
+
+static int
+translate_file_handle (int fd, int for_write)
+{
+#ifdef __MINGW32__
+#ifdef FILE_FILTER_USES_STDIO
+  fd = iobuf_translate_file_handle (fd, for_write);
+#else
+  {
+    int x;
+
+    if (fd == 0)
+      x = (int) GetStdHandle (STD_INPUT_HANDLE);
+    else if (fd == 1)
+      x = (int) GetStdHandle (STD_OUTPUT_HANDLE);
+    else if (fd == 2)
+      x = (int) GetStdHandle (STD_ERROR_HANDLE);
+    else
+      x = fd;
+
+    if (x == -1)
+      log_debug ("GetStdHandle(%d) failed: ec=%d\n",
+                fd, (int) GetLastError ());
+
+    fd = x;
+  }
+#endif
+#endif
+  return fd;
+}
diff --git a/common/iobuf.h b/common/iobuf.h
new file mode 100644 (file)
index 0000000..0af94e2
--- /dev/null
@@ -0,0 +1,170 @@
+/* iobuf.h - I/O buffer
+ * Copyright (C) 1998, 1999, 2000, 2001, 2003 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 2 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, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+#ifndef GNUPG_COMMON_IOBUF_H
+#define GNUPG_COMMON_IOBUF_H
+
+#include "../include/types.h" /* fixme: should be moved elsewhere. */
+
+
+#define DBG_IOBUF   iobuf_debug_mode
+
+
+#define IOBUFCTRL_INIT     1
+#define IOBUFCTRL_FREE     2
+#define IOBUFCTRL_UNDERFLOW 3
+#define IOBUFCTRL_FLUSH     4
+#define IOBUFCTRL_DESC     5
+#define IOBUFCTRL_CANCEL    6
+#define IOBUFCTRL_USER     16
+
+typedef struct iobuf_struct *iobuf_t;
+
+/* fixme: we should hide most of this stuff */
+struct iobuf_struct
+{
+  int use;                     /* 1 input , 2 output, 3 temp */
+  off_t nlimit;
+  off_t nbytes;                        /* used together with nlimit */
+  off_t ntotal;                        /* total bytes read (position of stream) */
+  int nofast;                  /* used by the iobuf_get() */
+  void *directfp;
+  struct
+  {
+    size_t size;               /* allocated size */
+    size_t start;              /* number of invalid bytes at the begin of the buffer */
+    size_t len;                        /* currently filled to this size */
+    byte *buf;
+  }
+  d;
+  int filter_eof;
+  int error;
+  int (*filter) (void *opaque, int control,
+                iobuf_t chain, byte * buf, size_t * len);
+  void *filter_ov;             /* value for opaque */
+  int filter_ov_owner;
+  char *real_fname;
+  iobuf_t chain;                       /* next iobuf used for i/o if any
+                                   (passed to filter) */
+  int no, subno;
+  const char *desc;
+  void *opaque;                        /* can be used to hold any information
+                                   this value is copied to all
+                                   instances */
+  struct
+  {
+    size_t size;               /* allocated size */
+    size_t start;              /* number of invalid bytes at the
+                                   begin of the buffer */
+    size_t len;                        /* currently filled to this size */
+    byte *buf;
+  }
+  unget;
+};
+
+#ifndef EXTERN_UNLESS_MAIN_MODULE
+#if defined (__riscos__) && !defined (INCLUDED_BY_MAIN_MODULE)
+#define EXTERN_UNLESS_MAIN_MODULE extern
+#else
+#define EXTERN_UNLESS_MAIN_MODULE
+#endif
+#endif
+EXTERN_UNLESS_MAIN_MODULE int iobuf_debug_mode;
+
+void iobuf_enable_special_filenames (int yes);
+iobuf_t iobuf_alloc (int use, size_t bufsize);
+iobuf_t iobuf_temp (void);
+iobuf_t iobuf_temp_with_content (const char *buffer, size_t length);
+iobuf_t iobuf_open (const char *fname);
+iobuf_t iobuf_fdopen (int fd, const char *mode);
+iobuf_t iobuf_sockopen (int fd, const char *mode);
+iobuf_t iobuf_create (const char *fname);
+iobuf_t iobuf_append (const char *fname);
+iobuf_t iobuf_openrw (const char *fname);
+int iobuf_ioctl (iobuf_t a, int cmd, int intval, void *ptrval);
+int iobuf_close (iobuf_t iobuf);
+int iobuf_cancel (iobuf_t iobuf);
+
+int iobuf_push_filter (iobuf_t a, int (*f) (void *opaque, int control,
+                                         iobuf_t chain, byte * buf,
+                                         size_t * len), void *ov);
+int iobuf_push_filter2 (iobuf_t a,
+                       int (*f) (void *opaque, int control, iobuf_t chain,
+                                 byte * buf, size_t * len), void *ov,
+                       int rel_ov);
+int iobuf_flush (iobuf_t a);
+void iobuf_clear_eof (iobuf_t a);
+#define iobuf_set_error(a)    do { (a)->error = 1; } while(0)
+#define iobuf_error(a)       ((a)->error)
+
+void iobuf_set_limit (iobuf_t a, off_t nlimit);
+
+off_t iobuf_tell (iobuf_t a);
+int iobuf_seek (iobuf_t a, off_t newpos);
+
+int iobuf_readbyte (iobuf_t a);
+int iobuf_read (iobuf_t a, byte * buf, unsigned buflen);
+unsigned iobuf_read_line (iobuf_t a, byte ** addr_of_buffer,
+                         unsigned *length_of_buffer, unsigned *max_length);
+int iobuf_peek (iobuf_t a, byte * buf, unsigned buflen);
+int iobuf_writebyte (iobuf_t a, unsigned c);
+int iobuf_write (iobuf_t a, byte * buf, unsigned buflen);
+int iobuf_writestr (iobuf_t a, const char *buf);
+
+void iobuf_flush_temp (iobuf_t temp);
+int iobuf_write_temp (iobuf_t a, iobuf_t temp);
+size_t iobuf_temp_to_buffer (iobuf_t a, byte * buffer, size_t buflen);
+void iobuf_unget_and_close_temp (iobuf_t a, iobuf_t temp);
+
+off_t iobuf_get_filelength (iobuf_t a);
+#define IOBUF_FILELENGTH_LIMIT 0xffffffff
+const char *iobuf_get_real_fname (iobuf_t a);
+const char *iobuf_get_fname (iobuf_t a);
+
+void iobuf_set_block_mode (iobuf_t a, size_t n);
+void iobuf_set_partial_block_mode (iobuf_t a, size_t len);
+int iobuf_in_block_mode (iobuf_t a);
+
+int iobuf_translate_file_handle (int fd, int for_write);
+
+
+/* get a byte form the iobuf; must check for eof prior to this function
+ * this function returns values in the range 0 .. 255 or -1 to indicate EOF
+ * iobuf_get_noeof() does not return -1 to indicate EOF, but masks the
+ * returned value to be in the range 0 ..255.
+ */
+#define iobuf_get(a)  \
+     ( ((a)->nofast || (a)->d.start >= (a)->d.len )?  \
+       iobuf_readbyte((a)) : ( (a)->nbytes++, (a)->d.buf[(a)->d.start++] ) )
+#define iobuf_get_noeof(a)    (iobuf_get((a))&0xff)
+
+/* write a byte to the iobuf and return true on write error
+ * This macro does only write the low order byte
+ */
+#define iobuf_put(a,c) iobuf_writebyte(a,c)
+
+#define iobuf_where(a) "[don't know]"
+#define iobuf_id(a)    ((a)->no)
+
+#define iobuf_get_temp_buffer(a) ( (a)->d.buf )
+#define iobuf_get_temp_length(a) ( (a)->d.len )
+#define iobuf_is_temp(a)        ( (a)->use == 3 )
+
+#endif /*GNUPG_COMMON_IOBUF_H*/
diff --git a/common/miscellaneous.c b/common/miscellaneous.c
new file mode 100644 (file)
index 0000000..bdb12c5
--- /dev/null
@@ -0,0 +1,126 @@
+/* miscellaneous.c - Stuff not fitting elsewhere
+ *     Copyright (C) 2003 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 2 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, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+#include <config.h>
+#include <stdlib.h>
+#include <errno.h>
+
+#include "util.h"
+#include "iobuf.h"
+
+/* Decide whether the filename is stdout or a real filename and return
+ * an appropriate string.  */
+const char *
+print_fname_stdout (const char *s)
+{
+    if( !s || (*s == '-' && !s[1]) )
+       return "[stdout]";
+    return s;
+}
+
+
+/* Decide whether the filename is stdin or a real filename and return
+ * an appropriate string.  */
+const char *
+print_fname_stdin (const char *s)
+{
+    if( !s || (*s == '-' && !s[1]) )
+       return "[stdin]";
+    return s;
+}
+
+void
+print_string( FILE *fp, const byte *p, size_t n, int delim )
+{
+  print_sanitized_buffer (fp, p, n, delim);
+}
+
+void
+print_utf8_string2 ( FILE *fp, const byte *p, size_t n, int delim )
+{
+  print_sanitized_utf8_buffer (fp, p, n, delim);
+}
+
+void
+print_utf8_string( FILE *fp, const byte *p, size_t n )
+{
+    print_utf8_string2 (fp, p, n, 0);
+}
+
+char *
+make_printable_string( const byte *p, size_t n, int delim )
+{
+  return sanitize_buffer (p, n, delim);
+}
+
+
+/*
+ * Check if the file is compressed.
+ */
+int
+is_file_compressed (const char *s, int *ret_rc)
+{
+    iobuf_t a;
+    byte buf[4];
+    int i, rc = 0;
+
+    struct magic_compress_s {
+        size_t len;
+        byte magic[4];
+    } magic[] = {
+        { 3, { 0x42, 0x5a, 0x68, 0x00 } }, /* bzip2 */
+        { 3, { 0x1f, 0x8b, 0x08, 0x00 } }, /* gzip */
+        { 4, { 0x50, 0x4b, 0x03, 0x04 } }, /* (pk)zip */
+    };
+    
+    if ( !s || (*s == '-' && !s[1]) || !ret_rc )
+        return 0; /* We can't check stdin or no file was given */
+
+    a = iobuf_open( s );
+    if ( a == NULL ) {
+        *ret_rc = gpg_error_from_errno (errno);
+        return 0;
+    }
+
+    if ( iobuf_get_filelength( a ) < 4 ) {
+        *ret_rc = 0;
+        goto leave;
+    }
+
+    if ( iobuf_read( a, buf, 4 ) == -1 ) {
+        *ret_rc = a->error;
+        goto leave;
+    }
+
+    for ( i = 0; i < DIM( magic ); i++ ) {
+        if ( !memcmp( buf, magic[i].magic, magic[i].len ) ) {
+            *ret_rc = 0;
+            rc = 1;
+            break;
+        }
+    }
+
+leave:    
+    iobuf_close( a );
+    return rc;
+}
+
+
+
diff --git a/common/ttyio.c b/common/ttyio.c
new file mode 100644 (file)
index 0000000..fd74800
--- /dev/null
@@ -0,0 +1,508 @@
+/* ttyio.c -  tty i/O functions
+ * Copyright (C) 1998,1999,2000,2001,2002,2003 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 2 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, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+#include <config.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <unistd.h>
+#ifdef HAVE_TCGETATTR
+#include <termios.h>
+#else
+#ifdef HAVE_TERMIO_H
+/* simulate termios with termio */
+#include <termio.h>
+#define termios termio
+#define tcsetattr ioctl
+#define TCSAFLUSH TCSETAF
+#define tcgetattr(A,B) ioctl(A,TCGETA,B)
+#define HAVE_TCGETATTR
+#endif
+#endif
+#ifdef __MINGW32__ /* use the odd Win32 functions */
+#include <windows.h>
+#ifdef HAVE_TCGETATTR
+#error mingw32 and termios
+#endif
+#endif
+#include <errno.h>
+#include <ctype.h>
+#include "util.h"
+#include "memory.h"
+#include "ttyio.h"
+
+#define CONTROL_D ('D' - 'A' + 1)
+
+#ifdef __MINGW32__ /* use the odd Win32 functions */
+static struct {
+    HANDLE in, out;
+} con;
+#define DEF_INPMODE  (ENABLE_LINE_INPUT|ENABLE_ECHO_INPUT    \
+                                       |ENABLE_PROCESSED_INPUT )
+#define HID_INPMODE  (ENABLE_LINE_INPUT|ENABLE_PROCESSED_INPUT )
+#define DEF_OUTMODE  (ENABLE_WRAP_AT_EOL_OUTPUT|ENABLE_PROCESSED_OUTPUT)
+
+#else /* yeah, we have a real OS */
+static FILE *ttyfp = NULL;
+#endif
+
+static int initialized;
+static int last_prompt_len;
+static int batchmode;
+static int no_terminal;
+
+#ifdef HAVE_TCGETATTR
+    static struct termios termsave;
+    static int restore_termios;
+#endif
+
+
+
+/* This is a wrapper around ttyname so that we can use it even when
+   the standard streams are redirected.  It figures the name out the
+   first time and returns it in a statically allocated buffer. */
+const char *
+tty_get_ttyname (void)
+{
+  static char *name;
+
+  /* On a GNU system ctermid() always return /dev/tty, so this does
+     not make much sense - however if it is ever changed we do the
+     Right Thing now. */
+#ifdef HAVE_CTERMID
+  static int got_name;
+
+  if (!got_name)
+    {
+      const char *s;
+      s = ctermid (NULL);
+      if (s)
+        name = strdup (s);
+      got_name = 1;
+    }
+#endif
+  /* Assume the staandrd tty on memory error or when tehre is no
+     certmid. */
+  return name? name : "/dev/tty";
+}
+
+
+
+#ifdef HAVE_TCGETATTR
+static void
+cleanup(void)
+{
+    if( restore_termios ) {
+       restore_termios = 0; /* do it prios in case it is interrupted again */
+       if( tcsetattr(fileno(ttyfp), TCSAFLUSH, &termsave) )
+           log_error("tcsetattr() failed: %s\n", strerror(errno) );
+    }
+}
+#endif
+
+static void
+init_ttyfp(void)
+{
+    if( initialized )
+       return;
+
+#if defined(__MINGW32__)
+    {
+       SECURITY_ATTRIBUTES sa;
+
+       memset(&sa, 0, sizeof(sa));
+       sa.nLength = sizeof(sa);
+       sa.bInheritHandle = TRUE;
+       con.out = CreateFileA( "CONOUT$", GENERIC_READ|GENERIC_WRITE,
+                              FILE_SHARE_READ|FILE_SHARE_WRITE,
+                              &sa, OPEN_EXISTING, 0, 0 );
+       if( con.out == INVALID_HANDLE_VALUE )
+           log_fatal("open(CONOUT$) failed: rc=%d", (int)GetLastError() );
+       memset(&sa, 0, sizeof(sa));
+       sa.nLength = sizeof(sa);
+       sa.bInheritHandle = TRUE;
+       con.in = CreateFileA( "CONIN$", GENERIC_READ|GENERIC_WRITE,
+                              FILE_SHARE_READ|FILE_SHARE_WRITE,
+                              &sa, OPEN_EXISTING, 0, 0 );
+       if( con.in == INVALID_HANDLE_VALUE )
+           log_fatal("open(CONIN$) failed: rc=%d", (int)GetLastError() );
+    }
+    SetConsoleMode(con.in, DEF_INPMODE );
+    SetConsoleMode(con.out, DEF_OUTMODE );
+
+#elif defined(__EMX__)
+    ttyfp = stdout; /* Fixme: replace by the real functions: see wklib */
+#else
+    ttyfp = batchmode? stderr : fopen (tty_get_ttyname (), "r+");
+    if( !ttyfp ) {
+       log_error("cannot open `%s': %s\n", tty_get_ttyname (),
+                  strerror(errno) );
+       exit(2);
+    }
+#endif
+#ifdef HAVE_TCGETATTR
+    atexit( cleanup );
+#endif
+    initialized = 1;
+}
+
+
+int
+tty_batchmode( int onoff )
+{
+    int old = batchmode;
+    if( onoff != -1 )
+       batchmode = onoff;
+    return old;
+}
+
+int
+tty_no_terminal(int onoff)
+{
+    int old = no_terminal;
+    no_terminal = onoff ? 1 : 0;
+    return old;
+}
+
+void
+tty_printf( const char *fmt, ... )
+{
+    va_list arg_ptr;
+
+    if (no_terminal)
+       return;
+
+    if( !initialized )
+       init_ttyfp();
+
+    va_start( arg_ptr, fmt ) ;
+#ifdef __MINGW32__
+    {   
+        char *buf = NULL;
+        int n;
+       DWORD nwritten;
+
+       n = vasprintf(&buf, fmt, arg_ptr);
+       if( !buf )
+           log_bug("vasprintf() failed\n");
+        
+       if( !WriteConsoleA( con.out, buf, n, &nwritten, NULL ) )
+           log_fatal("WriteConsole failed: rc=%d", (int)GetLastError() );
+       if( n != nwritten )
+           log_fatal("WriteConsole failed: %d != %d\n", n, (int)nwritten );
+       last_prompt_len += n;
+        xfree (buf);
+    }
+#else
+    last_prompt_len += vfprintf(ttyfp,fmt,arg_ptr) ;
+    fflush(ttyfp);
+#endif
+    va_end(arg_ptr);
+}
+
+
+/****************
+ * Print a string, but filter all control characters out.
+ */
+void
+tty_print_string( byte *p, size_t n )
+{
+    if (no_terminal)
+       return;
+
+    if( !initialized )
+       init_ttyfp();
+
+#ifdef __MINGW32__
+    /* not so effective, change it if you want */
+    for( ; n; n--, p++ )
+       if( iscntrl( *p ) ) {
+           if( *p == '\n' )
+               tty_printf("\\n");
+           else if( !*p )
+               tty_printf("\\0");
+           else
+               tty_printf("\\x%02x", *p);
+       }
+       else
+           tty_printf("%c", *p);
+#else
+    for( ; n; n--, p++ )
+       if( iscntrl( *p ) ) {
+           putc('\\', ttyfp);
+           if( *p == '\n' )
+               putc('n', ttyfp);
+           else if( !*p )
+               putc('0', ttyfp);
+           else
+               fprintf(ttyfp, "x%02x", *p );
+       }
+       else
+           putc(*p, ttyfp);
+#endif
+}
+
+void
+tty_print_utf8_string2( byte *p, size_t n, size_t max_n )
+{
+    size_t i;
+    char *buf;
+
+    if (no_terminal)
+       return;
+
+    /* we can handle plain ascii simpler, so check for it first */
+    for(i=0; i < n; i++ ) {
+       if( p[i] & 0x80 )
+           break;
+    }
+    if( i < n ) {
+       buf = utf8_to_native( p, n, 0 );
+       if( max_n && (strlen( buf ) > max_n )) {
+           buf[max_n] = 0;
+       }
+       /*(utf8 conversion already does the control character quoting)*/
+       tty_printf("%s", buf );
+       xfree( buf );
+    }
+    else {
+       if( max_n && (n > max_n) ) {
+           n = max_n;
+       }
+       tty_print_string( p, n );
+    }
+}
+
+void
+tty_print_utf8_string( byte *p, size_t n )
+{
+    tty_print_utf8_string2( p, n, 0 );
+}
+
+
+static char *
+do_get( const char *prompt, int hidden )
+{
+    char *buf;
+#ifndef __riscos__
+    byte cbuf[1];
+#endif
+    int c, n, i;
+
+    if( batchmode ) {
+       log_error("Sorry, we are in batchmode - can't get input\n");
+       exit(2);
+    }
+
+    if (no_terminal) {
+       log_error("Sorry, no terminal at all requested - can't get input\n");
+       exit(2);
+    }
+
+    if( !initialized )
+       init_ttyfp();
+
+    last_prompt_len = 0;
+    tty_printf( "%s", prompt );
+    buf = xmalloc((n=50));
+    i = 0;
+
+#ifdef __MINGW32__ /* windoze version */
+    if( hidden )
+       SetConsoleMode(con.in, HID_INPMODE );
+
+    for(;;) {
+       DWORD nread;
+
+       if( !ReadConsoleA( con.in, cbuf, 1, &nread, NULL ) )
+           log_fatal("ReadConsole failed: rc=%d", (int)GetLastError() );
+       if( !nread )
+           continue;
+       if( *cbuf == '\n' )
+           break;
+
+       if( !hidden )
+           last_prompt_len++;
+       c = *cbuf;
+       if( c == '\t' )
+           c = ' ';
+       else if( c > 0xa0 )
+           ; /* we don't allow 0xa0, as this is a protected blank which may
+              * confuse the user */
+       else if( iscntrl(c) )
+           continue;
+       if( !(i < n-1) ) {
+           n += 50;
+           buf = xrealloc (buf, n);
+       }
+       buf[i++] = c;
+    }
+
+    if( hidden )
+       SetConsoleMode(con.in, DEF_INPMODE );
+
+#elif defined(__riscos__)
+    do {
+        c = riscos_getchar();
+        if (c == 0xa || c == 0xd) { /* Return || Enter */
+            c = (int) '\n';
+        } else if (c == 0x8 || c == 0x7f) { /* Backspace || Delete */
+            if (i>0) {
+                i--;
+                if (!hidden) {
+                    last_prompt_len--;
+                    fputc(8, ttyfp);
+                    fputc(32, ttyfp);
+                    fputc(8, ttyfp);
+                    fflush(ttyfp);
+                }
+            } else {
+                fputc(7, ttyfp);
+                fflush(ttyfp);
+            }
+            continue;
+        } else if (c == (int) '\t') { /* Tab */
+            c = ' ';
+        } else if (c > 0xa0) {
+            ; /* we don't allow 0xa0, as this is a protected blank which may
+               * confuse the user */
+        } else if (iscntrl(c)) {
+            continue;
+        }
+        if(!(i < n-1)) {
+            n += 50;
+            buf = xrealloc (buf, n);
+        }
+        buf[i++] = c;
+        if (!hidden) {
+           last_prompt_len++;
+            fputc(c, ttyfp);
+            fflush(ttyfp);
+        }
+    } while (c != '\n');
+    i = (i>0) ? i-1 : 0;
+#else /* unix version */
+    if( hidden ) {
+#ifdef HAVE_TCGETATTR
+       struct termios term;
+
+       if( tcgetattr(fileno(ttyfp), &termsave) )
+           log_fatal("tcgetattr() failed: %s\n", strerror(errno) );
+       restore_termios = 1;
+       term = termsave;
+       term.c_lflag &= ~(ECHO | ECHOE | ECHOK | ECHONL);
+       if( tcsetattr( fileno(ttyfp), TCSAFLUSH, &term ) )
+           log_fatal("tcsetattr() failed: %s\n", strerror(errno) );
+#endif
+    }
+
+    /* fixme: How can we avoid that the \n is echoed w/o disabling
+     * canonical mode - w/o this kill_prompt can't work */
+    while( read(fileno(ttyfp), cbuf, 1) == 1 && *cbuf != '\n' ) {
+       if( !hidden )
+           last_prompt_len++;
+       c = *cbuf;
+       if( c == CONTROL_D )
+           log_info("control d found\n");
+       if( c == '\t' )
+           c = ' ';
+       else if( c > 0xa0 )
+           ; /* we don't allow 0xa0, as this is a protected blank which may
+              * confuse the user */
+       else if( iscntrl(c) )
+           continue;
+       if( !(i < n-1) ) {
+           n += 50;
+           buf = xrealloc (buf, n );
+       }
+       buf[i++] = c;
+    }
+    if( *cbuf != '\n' ) {
+       buf[0] = CONTROL_D;
+       i = 1;
+    }
+
+
+    if( hidden ) {
+#ifdef HAVE_TCGETATTR
+       if( tcsetattr(fileno(ttyfp), TCSAFLUSH, &termsave) )
+           log_error("tcsetattr() failed: %s\n", strerror(errno) );
+       restore_termios = 0;
+#endif
+    }
+#endif /* end unix version */
+    buf[i] = 0;
+    return buf;
+}
+
+
+char *
+tty_get( const char *prompt )
+{
+    return do_get( prompt, 0 );
+}
+
+char *
+tty_get_hidden( const char *prompt )
+{
+    return do_get( prompt, 1 );
+}
+
+
+void
+tty_kill_prompt()
+{
+    if ( no_terminal )
+       return;
+
+    if( !initialized )
+       init_ttyfp();
+
+    if( batchmode )
+       last_prompt_len = 0;
+    if( !last_prompt_len )
+       return;
+#ifdef __MINGW32__
+    tty_printf("\r%*s\r", last_prompt_len, "");
+#else
+    {
+       int i;
+       putc('\r', ttyfp);
+       for(i=0; i < last_prompt_len; i ++ )
+           putc(' ', ttyfp);
+       putc('\r', ttyfp);
+       fflush(ttyfp);
+    }
+#endif
+    last_prompt_len = 0;
+}
+
+
+int
+tty_get_answer_is_yes( const char *prompt )
+{
+    int yes;
+    char *p = tty_get( prompt );
+    tty_kill_prompt();
+    yes = answer_is_yes(p);
+    xfree(p);
+    return yes;
+}
diff --git a/common/ttyio.h b/common/ttyio.h
new file mode 100644 (file)
index 0000000..b3ca7dc
--- /dev/null
@@ -0,0 +1,40 @@
+/* ttyio.h
+ * Copyright (C) 1998, 1999, 2000, 2001, 2003 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 2 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, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+#ifndef GNUPG_COMMON_TTYIO_H
+#define GNUPG_COMMON_TTYIO_H
+
+const char *tty_get_ttyname (void);
+int tty_batchmode (int onoff);
+#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 5 )
+void tty_printf (const char *fmt, ... ) __attribute__ ((format (printf,1,2)));
+#else
+void tty_printf (const char *fmt, ... );
+#endif
+void tty_print_string (unsigned char *p, size_t n);
+void tty_print_utf8_string (unsigned char *p, size_t n);
+void tty_print_utf8_string2 (unsigned char *p, size_t n, size_t max_n);
+char *tty_get (const char *prompt);
+char *tty_get_hidden (const char *prompt);
+void tty_kill_prompt (void);
+int tty_get_answer_is_yes (const char *prompt);
+int tty_no_terminal (int onoff);
+
+
+#endif /*GNUPG_COMMON_TTYIO_H*/
index c6d2ea7..0458514 100644 (file)
@@ -35,6 +35,7 @@
 #include "../jnlib/mischelp.h"
 #include "../jnlib/strlist.h"
 #include "../jnlib/dotlock.h"
+#include "../jnlib/utf8conv.h"
 
 /* handy malloc macros  - use only them */
 #define xtrymalloc(a)    gcry_malloc ((a))
 #define xfree(a)         gcry_free ((a))
 
 #define xmalloc(a)       gcry_xmalloc ((a))
+#define xmalloc_secure(a)  gcry_xmalloc_secure ((a))
 #define xcalloc(a,b)     gcry_xcalloc ((a),(b))
+#define xcalloc_secure(a,b) gcry_xcalloc_secure ((a),(b))
 #define xrealloc(a,b)    gcry_xrealloc ((a),(b))
 #define xstrdup(a)       gcry_xstrdup ((a))
 
-#define seterr(a)  (GNUPG_ ## a)
-
 /*-- maperror.c --*/
 int map_ksba_err (int err);
 int map_gcry_err (int err);
@@ -61,6 +62,12 @@ int map_to_assuan_status (int rc);
 time_t gnupg_get_time (void);
 void   gnupg_set_time (time_t newtime, int freeze);
 int    gnupg_faked_time_p (void);
+u32    make_timestamp (void);
+u32    scan_isodatestr (const char *string);
+u32    add_days_to_timestamp (u32 stamp, u16 days);
+const char *strtimevalue (u32 stamp);
+const char *strtimestamp (u32 stamp); /* GMT */
+const char *asctimestamp (u32 stamp); /* localized */
 
 /*-- signal.c --*/
 void gnupg_init_signals (int mode, void (*fast_cleanup)(void));
@@ -68,6 +75,22 @@ void gnupg_pause_on_sigusr (int which);
 void gnupg_block_all_signals (void);
 void gnupg_unblock_all_signals (void);
 
+/*-- yesno.c --*/
+int answer_is_yes (const char *s);
+int answer_is_yes_no_default (const char *s, int def_answer);
+int answer_is_yes_no_quit (const char *s);
+
+
+/*-- miscellaneous.c --*/
+const char *print_fname_stdout (const char *s);
+const char *print_fname_stdin (const char *s);
+void print_string (FILE *fp, const byte *p, size_t n, int delim);
+void print_utf8_string2 ( FILE *fp, const byte *p, size_t n, int delim);
+void print_utf8_string (FILE *fp, const byte *p, size_t n);
+char *make_printable_string (const byte *p, size_t n, int delim);
+
+int is_file_compressed (const char *s, int *ret_rc);
+
 
 /*-- replacement functions from funcname.c --*/
 #if !HAVE_VASPRINTF
diff --git a/common/yesno.c b/common/yesno.c
new file mode 100644 (file)
index 0000000..2a96b4e
--- /dev/null
@@ -0,0 +1,96 @@
+/* yesno.c - Yes/No questions
+ * Copyright (C) 1998, 1999, 2000, 2001, 2003 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 2 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, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+#include <config.h>
+#include <stdlib.h>
+#include <errno.h>
+
+#include "i18n.h"
+#include "util.h"
+
+int
+answer_is_yes_no_default( const char *s, int def_answer )
+{
+    const char *long_yes = _("yes");
+    const char *short_yes = _("yY");
+    const char *long_no = _("no");
+    const char *short_no = _("nN");
+
+    /* Note: we have to use the local dependent strcasecmp here */
+    if( !strcasecmp(s, long_yes ) )
+       return 1;
+    if( *s && strchr( short_yes, *s ) && !s[1] )
+       return 1;
+    /* test for no strings to catch ambiguities for the next test */
+    if( !strcasecmp(s, long_no ) )
+       return 0;
+    if( *s && strchr( short_no, *s ) && !s[1] )
+       return 0;
+    /* test for the english version (for those who are used to type yes) */
+    if( !ascii_strcasecmp(s, "yes" ) )
+       return 1;
+    if( *s && strchr( "yY", *s ) && !s[1] )
+       return 1;
+    return def_answer;
+}
+
+int
+answer_is_yes( const char *s )
+{
+  return answer_is_yes_no_default(s,0);
+}
+
+/****************
+ * Return 1 for yes, -1 for quit, or 0 for no
+ */
+int
+answer_is_yes_no_quit( const char *s )
+{
+    const char *long_yes = _("yes");
+    const char *long_no = _("no");
+    const char *long_quit = _("quit");
+    const char *short_yes = _("yY");
+    const char *short_no = _("nN");
+    const char *short_quit = _("qQ");
+
+    /* Note: We have to use the locale dependent strcasecmp */
+    if( !strcasecmp(s, long_no ) )
+       return 0;
+    if( !strcasecmp(s, long_yes ) )
+       return 1;
+    if( !strcasecmp(s, long_quit ) )
+       return -1;
+    if( *s && strchr( short_no, *s ) && !s[1] )
+       return 0;
+    if( *s && strchr( short_yes, *s ) && !s[1] )
+       return 1;
+    if( *s && strchr( short_quit, *s ) && !s[1] )
+       return -1;
+    /* but not here */
+    if( !ascii_strcasecmp(s, "yes" ) )
+       return 1;
+    if( !ascii_strcasecmp(s, "quit" ) )
+       return -1;
+    if( *s && strchr( "yY", *s ) && !s[1] )
+       return 1;
+    if( *s && strchr( "qQ", *s ) && !s[1] )
+       return -1;
+    return 0;
+}
index c3c563c..574867a 100644 (file)
@@ -52,7 +52,7 @@ map_sc_err (int rc)
 #endif
     default: e = GPG_ERR_CARD; break;
     }
-  return gpg_make_error (GPG_ERR_SOURCE_UNKNOWN, e);
+  return gpg_err_make (GPG_ERR_SOURCE_UNKNOWN, e);
 }
 
 /* Get the keygrip from CERT, return 0 on success */
@@ -443,7 +443,7 @@ card_enum_keypairs (CARD card, int idx,
   rc = card->fnc.enum_keypairs (card, idx, keygrip, keyid);
   if (opt.verbose)
     log_info ("card operation enum_keypairs result: %s\n",
-              gnupg_strerror (rc));
+              gpg_strerror (rc));
   return rc;
 }
 
@@ -475,7 +475,7 @@ card_enum_certs (CARD card, int idx, char **certid, int *certtype)
   rc = card->fnc.enum_certs (card, idx, certid, certtype);
   if (opt.verbose)
     log_info ("card operation enum_certs result: %s\n",
-              gnupg_strerror (rc));
+              gpg_strerror (rc));
   return rc;
 }
 
@@ -499,7 +499,7 @@ card_read_cert (CARD card, const char *certidstr,
     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
   rc = card->fnc.read_cert (card, certidstr, cert, ncert);
   if (opt.verbose)
-    log_info ("card operation read_cert result: %s\n", gnupg_strerror (rc));
+    log_info ("card operation read_cert result: %s\n", gpg_strerror (rc));
   return rc;
 }
 
@@ -527,7 +527,7 @@ card_sign (CARD card, const char *keyidstr, int hashalgo,
                         indata, indatalen,
                         outdata, outdatalen);
   if (opt.verbose)
-    log_info ("card operation sign result: %s\n", gnupg_strerror (rc));
+    log_info ("card operation sign result: %s\n", gpg_strerror (rc));
   return rc;
 }
 
@@ -555,6 +555,6 @@ card_decipher (CARD card, const char *keyidstr,
                             indata, indatalen,
                             outdata, outdatalen);
   if (opt.verbose)
-    log_info ("card operation decipher result: %s\n", gnupg_strerror (rc));
+    log_info ("card operation decipher result: %s\n", gpg_strerror (rc));
   return rc;
 }
index 6c30d3d..8267c13 100644 (file)
@@ -317,7 +317,7 @@ cmd_readcert (ASSUAN_CONTEXT ctx, char *line)
   rc = card_read_cert (ctrl->card_ctx, line, &cert, &ncert);
   if (rc)
     {
-      log_error ("card_read_cert failed: %s\n", gnupg_strerror (rc));
+      log_error ("card_read_cert failed: %s\n", gpg_strerror (rc));
     }
   if (!rc)
     {
@@ -351,7 +351,7 @@ cmd_readkey (ASSUAN_CONTEXT ctx, char *line)
   rc = card_read_cert (ctrl->card_ctx, line, &cert, &ncert);
   if (rc)
     {
-      log_error ("card_read_cert failed: %s\n", gnupg_strerror (rc));
+      log_error ("card_read_cert failed: %s\n", gpg_strerror (rc));
       goto leave;
     }
       
@@ -488,7 +488,7 @@ cmd_pksign (ASSUAN_CONTEXT ctx, char *line)
   free (keyidstr);
   if (rc)
     {
-      log_error ("card_sign failed: %s\n", gnupg_strerror (rc));
+      log_error ("card_sign failed: %s\n", gpg_strerror (rc));
     }
   else
     {
@@ -527,7 +527,7 @@ cmd_pkdecrypt (ASSUAN_CONTEXT ctx, char *line)
   free (keyidstr);
   if (rc)
     {
-      log_error ("card_create_signature failed: %s\n", gnupg_strerror (rc));
+      log_error ("card_create_signature failed: %s\n", gpg_strerror (rc));
     }
   else
     {