w32: Add icons and version information.
[gnupg.git] / common / estream.c
index 06c6244..79e3efb 100644 (file)
@@ -1,11 +1,11 @@
 /* estream.c - Extended Stream I/O Library
- * Copyright (C) 2004, 2005, 2006, 2007 g10 Code GmbH
+ * Copyright (C) 2004, 2005, 2006, 2007, 2009, 2010, 2011 g10 Code GmbH
  *
  * This file is part of Libestream.
  *
  * Libestream is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published
- * by the Free Software Foundation; either version 3 of the License,
+ * by the Free Software Foundation; either version 2 of the License,
  * or (at your option) any later version.
  *
  * Libestream is distributed in the hope that it will be useful, but
  *
  * You should have received a copy of the GNU General Public License
  * along with Libestream; if not, see <http://www.gnu.org/licenses/>.
+ *
+ * ALTERNATIVELY, Libestream may be distributed under the terms of the
+ * following license, in which case the provisions of this license are
+ * required INSTEAD OF the GNU General Public License. If you wish to
+ * allow use of your version of this file only under the terms of the
+ * GNU General Public License, and not to allow others to use your
+ * version of this file under the terms of the following license,
+ * indicate your decision by deleting this paragraph and the license
+ * below.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, and the entire permission notice in its entirety,
+ *    including the disclaimer of warranties.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote
+ *    products derived from this software without specific prior
+ *    written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifdef USE_ESTREAM_SUPPORT_H
 # include <config.h>
 #endif
 
+#if defined(_WIN32) && !defined(HAVE_W32_SYSTEM)
+# define HAVE_W32_SYSTEM 1
+# if defined(__MINGW32CE__) && !defined (HAVE_W32CE_SYSTEM)
+#  define HAVE_W32CE_SYSTEM
+# endif
+#endif
+
 #include <sys/types.h>
 #include <sys/file.h>
 #include <sys/stat.h>
 #include <errno.h>
 #include <stddef.h>
 #include <assert.h>
+#ifdef HAVE_W32_SYSTEM
+# include <windows.h>
+#endif
+#ifdef HAVE_W32CE_SYSTEM
+# include <gpg-error.h> /* ERRNO replacement.  */
+#endif
 
-#ifdef WITHOUT_GNU_PTH /* Give the Makefile a chance to build without Pth.  */
-#undef HAVE_PTH
-#undef USE_GNU_PTH
+#ifdef WITHOUT_NPTH /* Give the Makefile a chance to build without Pth.  */
+# undef HAVE_NPTH
+# undef USE_NPTH
 #endif
 
-#ifdef HAVE_PTH
-# include <pth.h>
+#ifdef HAVE_NPTH
+# include <npth.h>
 #endif
 
 /* This is for the special hack to use estream.c in GnuPG.  */
 #ifdef GNUPG_MAJOR_VERSION
-#include "../common/util.h"
+# include "../common/util.h"
 #endif
 
 #ifndef HAVE_MKSTEMP
@@ -69,37 +116,50 @@ void *memrchr (const void *block, int c, size_t size);
 #define O_BINARY 0
 #endif
 
-/* Generally used types.  */
+#ifdef HAVE_W32_SYSTEM
+# define S_IRGRP S_IRUSR
+# define S_IROTH S_IRUSR
+# define S_IWGRP S_IWUSR
+# define S_IWOTH S_IWUSR
+# define S_IXGRP S_IXUSR
+# define S_IXOTH S_IXUSR
+#endif
 
-typedef void *(*func_realloc_t) (void *mem, size_t size);
-typedef void (*func_free_t) (void *mem);
 
-#ifdef HAVE_FOPENCOOKIE
-typedef ssize_t my_funopen_hook_ret_t;
+#ifdef HAVE_W32CE_SYSTEM
+# define _set_errno(a)  gpg_err_set_errno ((a))
+/* Setmode is missing in cegcc but available since CE 5.0.  */
+int _setmode (int handle, int mode);
+# define setmode(a,b)   _setmode ((a),(b))
+#else
+# define _set_errno(a)  do { errno = (a); } while (0)
+#endif
+
+#ifdef HAVE_W32_SYSTEM
+# define IS_INVALID_FD(a)    ((void*)(a) == (void*)(-1)) /* ?? FIXME.  */
 #else
-typedef int     my_funopen_hook_ret_t;
+# define IS_INVALID_FD(a)    ((a) == -1)
 #endif
 
 
-\f
+/* Generally used types.  */
 
-/* Buffer management layer.  */
+typedef void *(*func_realloc_t) (void *mem, size_t size);
+typedef void (*func_free_t) (void *mem);
 
-#define BUFFER_BLOCK_SIZE  BUFSIZ
-#define BUFFER_UNREAD_SIZE 16
 
 \f
 
-/* Macros.  */
+/* Buffer management layer.  */
 
-#define BUFFER_ROUND_TO_BLOCK(size, block_size) \
-  (((size) + (block_size - 1)) / block_size)
+#define BUFFER_BLOCK_SIZE  BUFSIZ
+#define BUFFER_UNREAD_SIZE 16
 
 \f
 
 /* Locking.  */
 
-#ifdef HAVE_PTH
+#ifdef HAVE_NPTH
 
 typedef pth_mutex_t estream_mutex_t;
 # define ESTREAM_MUTEX_INITIALIZER PTH_MUTEX_INIT
@@ -114,35 +174,61 @@ typedef pth_mutex_t estream_mutex_t;
 #else
 
 typedef void *estream_mutex_t;
-# define ESTREAM_MUTEX_INITIALIZER NULL
-# define ESTREAM_MUTEX_LOCK(mutex) (void) 0
-# define ESTREAM_MUTEX_UNLOCK(mutex) (void) 0
-# define ESTREAM_MUTEX_TRYLOCK(mutex) 0
-# define ESTREAM_MUTEX_INITIALIZE(mutex) (void) 0
-#endif
 
-/* Memory allocator functions.  */
+static inline void
+dummy_mutex_call_void (estream_mutex_t mutex)
+{
+  (void)mutex;
+}
 
-#define ES_MEM_ALLOC   malloc
-#define ES_MEM_REALLOC realloc
-#define ES_MEM_FREE    free
+static inline int
+dummy_mutex_call_int (estream_mutex_t mutex)
+{
+  (void)mutex;
+  return 0;
+}
+
+# define ESTREAM_MUTEX_INITIALIZER NULL
+# define ESTREAM_MUTEX_LOCK(mutex) dummy_mutex_call_void ((mutex))
+# define ESTREAM_MUTEX_UNLOCK(mutex) dummy_mutex_call_void ((mutex))
+# define ESTREAM_MUTEX_TRYLOCK(mutex) dummy_mutex_call_int ((mutex))
+# define ESTREAM_MUTEX_INITIALIZE(mutex) dummy_mutex_call_void ((mutex))
+#endif
 
 /* Primitive system I/O.  */
 
-#ifdef HAVE_PTH
-# define ESTREAM_SYS_READ  pth_read
-# define ESTREAM_SYS_WRITE pth_write
+#ifdef HAVE_NPTH
+# define ESTREAM_SYS_READ  do_pth_read
+# define ESTREAM_SYS_WRITE do_pth_write
+# define ESTREAM_SYS_YIELD() pth_yield (NULL)
 #else
 # define ESTREAM_SYS_READ  read
 # define ESTREAM_SYS_WRITE write
+# define ESTREAM_SYS_YIELD() do { } while (0)
 #endif
 
-/* Misc definitions.  */
 
-#define ES_DEFAULT_OPEN_MODE (S_IRUSR | S_IWUSR)
+/* A linked list to hold notification functions. */
+struct notify_list_s
+{
+  struct notify_list_s *next;
+  void (*fnc) (estream_t, void*); /* The notification function.  */
+  void *fnc_value;                /* The value to be passed to FNC.  */
+};
+typedef struct notify_list_s *notify_list_t;
+
 
-/* An internal stream object.  */
+/* A private cookie function to implement an internal IOCTL
+   service.  */
+typedef int (*cookie_ioctl_function_t) (void *cookie, int cmd,
+                                       void *ptr, size_t *len);
+/* IOCTL commands for the private cookie function.  */
+#define COOKIE_IOCTL_SNATCH_BUFFER 1
 
+
+
+
+/* An internal stream object.  */
 struct estream_internal
 {
   unsigned char buffer[BUFFER_BLOCK_SIZE];
@@ -151,23 +237,26 @@ struct estream_internal
   void *cookie;                         /* Cookie.                */
   void *opaque;                         /* Opaque data.           */
   unsigned int modeflags;       /* Flags for the backend. */
+  char *printable_fname;         /* Malloced filename for es_fname_get.  */
   off_t offset;
   es_cookie_read_function_t func_read;
   es_cookie_write_function_t func_write;
   es_cookie_seek_function_t func_seek;
+  cookie_ioctl_function_t func_ioctl;
   es_cookie_close_function_t func_close;
   int strategy;
-  int fd;
+  es_syshd_t syshd;              /* A copy of the sytem handle.  */
   struct
   {
     unsigned int err: 1;
     unsigned int eof: 1;
   } indicators;
   unsigned int deallocate_buffer: 1;
-  unsigned int print_err: 1;     /* Error in print_fun_writer.  */
-  int print_errno;               /* Errno from print_fun_writer.  */
-  size_t print_ntotal;           /* Bytes written from in print_fun_writer. */
-  FILE *print_fp;                /* Stdio stream used by print_fun_writer.  */
+  unsigned int is_stdstream:1;   /* This is a standard stream.  */
+  unsigned int stdstream_fd:2;   /* 0, 1 or 2 for a standard stream.  */
+  unsigned int printable_fname_inuse: 1;  /* es_fname_get has been used.  */
+  size_t print_ntotal;           /* Bytes written from in print_writer. */
+  notify_list_t onclose;         /* On close notify function list.  */
 };
 
 
@@ -177,34 +266,37 @@ typedef struct estream_internal *estream_internal_t;
 #define ESTREAM_UNLOCK(stream) ESTREAM_MUTEX_UNLOCK (stream->intern->lock)
 #define ESTREAM_TRYLOCK(stream) ESTREAM_MUTEX_TRYLOCK (stream->intern->lock)
 
-/* Stream list.  */
-
-typedef struct estream_list *estream_list_t;
-
-struct estream_list
+/* A linked list to hold active stream objects.   */
+struct estream_list_s
 {
-  estream_t car;
-  estream_list_t cdr;
-  estream_list_t *prev_cdr;
+  struct estream_list_s *next;
+  estream_t stream;  /* Entry is not used if NULL.  */
 };
-
+typedef struct estream_list_s *estream_list_t;
 static estream_list_t estream_list;
-#ifdef HAVE_PTH
-/* Note that we can't use a static initialization with W32Pth, thus we
-   do it in es_init. */
-static estream_mutex_t estream_list_lock;
-#endif
 
+/* File descriptors registered to be used as the standard file handles. */
+static int custom_std_fds[3];
+static unsigned char custom_std_fds_valid[3];
+
+/* A lock object for the estream list and the custom_std_fds array.  */
+static estream_mutex_t estream_list_lock;
 #define ESTREAM_LIST_LOCK   ESTREAM_MUTEX_LOCK   (estream_list_lock)
 #define ESTREAM_LIST_UNLOCK ESTREAM_MUTEX_UNLOCK (estream_list_lock)
 
+
+/* Error code replacements.  */
 #ifndef EOPNOTSUPP
 # define EOPNOTSUPP ENOSYS
 #endif
 
 
-\f
+/* Local prototypes.  */
+static void fname_set_internal (estream_t stream, const char *fname, int quote);
+
+
 
+\f
 /* Macros.  */
 
 /* Calculate array dimension.  */
@@ -212,6 +304,9 @@ static estream_mutex_t estream_list_lock;
 #define DIM(array) (sizeof (array) / sizeof (*array))
 #endif
 
+#define tohex(n) ((n) < 10 ? ((n) + '0') : (((n) - 10) + 'A'))
+
+
 /* Evaluate EXPRESSION, setting VARIABLE to the return code, if
    VARIABLE is zero.  */
 #define SET_UNLESS_NONZERO(variable, tmp_variable, expression) \
@@ -223,94 +318,205 @@ static estream_mutex_t estream_list_lock;
     }                                                          \
   while (0)
 
+
+/* Malloc wrappers to overcome problems on some older OSes.  */
+static void *
+mem_alloc (size_t n)
+{
+  if (!n)
+    n++;
+  return malloc (n);
+}
+
+static void *
+mem_realloc (void *p, size_t n)
+{
+  if (!p)
+    return mem_alloc (n);
+  return realloc (p, n);
+}
+
+static void
+mem_free (void *p)
+{
+  if (p)
+    free (p);
+}
+
+#ifdef HAVE_W32_SYSTEM
+static int
+map_w32_to_errno (DWORD w32_err)
+{
+  switch (w32_err)
+    {
+    case 0:
+      return 0;
+
+    case ERROR_FILE_NOT_FOUND:
+      return ENOENT;
+
+    case ERROR_PATH_NOT_FOUND:
+      return ENOENT;
+
+    case ERROR_ACCESS_DENIED:
+      return EPERM;
+
+    case ERROR_INVALID_HANDLE:
+    case ERROR_INVALID_BLOCK:
+      return EINVAL;
+
+    case ERROR_NOT_ENOUGH_MEMORY:
+      return ENOMEM;
+
+    case ERROR_NO_DATA:
+      return EPIPE;
+
+    default:
+      return EIO;
+    }
+}
+#endif /*HAVE_W32_SYSTEM*/
+
 /*
  * List manipulation.
  */
 
-/* Add STREAM to the list of registered stream objects.  */
+/* Add STREAM to the list of registered stream objects.  If
+   WITH_LOCKED_LIST is true it is assumed that the list of streams is
+   already locked.  The implementation is straightforward: We first
+   look for an unused entry in the list and use that; if none is
+   available we put a new item at the head.  We drawback of the
+   strategy never to shorten the list is that a one time allocation of
+   many streams will lead to scanning unused entries later.  If that
+   turns out to be a problem, we may either free some items from the
+   list or append new entries at the end; or use a table.  Returns 0
+   on success; on error or non-zero is returned and ERRNO set.  */
 static int
-es_list_add (estream_t stream)
+do_list_add (estream_t stream, int with_locked_list)
 {
-  estream_list_t list_obj;
-  int ret;
+  estream_list_t item;
 
-  list_obj = ES_MEM_ALLOC (sizeof (*list_obj));
-  if (! list_obj)
-    ret = -1;
-  else
+  if (!with_locked_list)
+    ESTREAM_LIST_LOCK;
+
+  for (item = estream_list; item && item->stream; item = item->next)
+    ;
+  if (!item)
     {
-      ESTREAM_LIST_LOCK;
-      list_obj->car = stream;
-      list_obj->cdr = estream_list;
-      list_obj->prev_cdr = &estream_list;
-      if (estream_list)
-       estream_list->prev_cdr = &list_obj->cdr;
-      estream_list = list_obj;
-      ESTREAM_LIST_UNLOCK;
-      ret = 0;
+      item = mem_alloc (sizeof *item);
+      if (item)
+        {
+          item->next = estream_list;
+          estream_list = item;
+        }
     }
+  if (item)
+    item->stream = stream;
 
-  return ret;
+  if (!with_locked_list)
+    ESTREAM_LIST_UNLOCK;
+
+  return item? 0 : -1;
 }
 
 /* Remove STREAM from the list of registered stream objects.  */
 static void
-es_list_remove (estream_t stream)
+do_list_remove (estream_t stream, int with_locked_list)
 {
-  estream_list_t list_obj;
-  
-  ESTREAM_LIST_LOCK;
-  for (list_obj = estream_list; list_obj; list_obj = list_obj->cdr)
-    if (list_obj->car == stream)
+  estream_list_t item;
+
+  if (!with_locked_list)
+    ESTREAM_LIST_LOCK;
+
+  for (item = estream_list; item; item = item->next)
+    if (item->stream == stream)
       {
-       *list_obj->prev_cdr = list_obj->cdr;
-       if (list_obj->cdr)
-         list_obj->cdr->prev_cdr = list_obj->prev_cdr;
-       ES_MEM_FREE (list_obj);
-       break;
+        item->stream = NULL;
+        break;
       }
-  ESTREAM_LIST_UNLOCK;
+
+  if (!with_locked_list)
+    ESTREAM_LIST_UNLOCK;
 }
 
-/* Type of an stream-iterator-function.  */
-typedef int (*estream_iterator_t) (estream_t stream);
 
-/* Iterate over list of registered streams, calling ITERATOR for each
-   of them.  */
+\f
+/*
+ * I/O Helper
+ *
+ * Unfortunately our Pth emulation for Windows expects system handles
+ * for pth_read and pth_write.  We use a simple approach to fix this:
+ * If the function returns an error we fall back to a vanilla read or
+ * write, assuming that we do I/O on a plain file where the operation
+ * can't block.
+ */
+#ifdef HAVE_NPTH
 static int
-es_list_iterate (estream_iterator_t iterator)
+do_pth_read (int fd, void *buffer, size_t size)
 {
-  estream_list_t list_obj;
-  int ret = 0;
-
-  ESTREAM_LIST_LOCK;
-  for (list_obj = estream_list; list_obj; list_obj = list_obj->cdr)
-    ret |= (*iterator) (list_obj->car);
-  ESTREAM_LIST_UNLOCK;
+# ifdef HAVE_W32_SYSTEM
+  int rc = pth_read (fd, buffer, size);
+  if (rc == -1 && errno == EINVAL)
+    rc = read (fd, buffer, size);
+  return rc;
+# else /*!HAVE_W32_SYSTEM*/
+  return pth_read (fd, buffer, size);
+# endif /* !HAVE_W32_SYSTEM*/
+}
 
-  return ret;
+static int
+do_pth_write (int fd, const void *buffer, size_t size)
+{
+# ifdef HAVE_W32_SYSTEM
+  int rc = pth_write (fd, buffer, size);
+  if (rc == -1 && errno == EINVAL)
+    rc = write (fd, buffer, size);
+  return rc;
+# else /*!HAVE_W32_SYSTEM*/
+  return pth_write (fd, buffer, size);
+# endif /* !HAVE_W32_SYSTEM*/
 }
+#endif /*HAVE_NPTH*/
 
 \f
 
+static void
+do_deinit (void)
+{
+  /* Flush all streams. */
+  es_fflush (NULL);
+
+  /* We should release the estream_list.  However there is one
+     problem: That list is also used to search for the standard
+     estream file descriptors.  If we would remove the entire list,
+     any use of es_foo in another atexit function may re-create the
+     list and the streams with possible undesirable effects.  Given
+     that we don't close the stream either, it should not matter that
+     we keep the list and let the OS clean it up at process end.  */
+}
+
+
 /*
  * Initialization.
  */
 
 static int
-es_init_do (void)
+do_init (void)
 {
-#ifdef HAVE_PTH
   static int initialized;
 
   if (!initialized)
     {
+#ifdef HAVE_NPTH
       if (!pth_init () && errno != EPERM )
         return -1;
       if (pth_mutex_init (&estream_list_lock))
         initialized = 1;
-    }
+#else
+      initialized = 1;
 #endif
+      atexit (do_deinit);
+    }
   return 0;
 }
 
@@ -326,53 +532,67 @@ es_init_do (void)
 typedef struct estream_cookie_mem
 {
   unsigned int modeflags;      /* Open flags.  */
-  unsigned char *memory;       /* Data.  */
-  size_t memory_size;          /* Size of MEMORY.  */
+  unsigned char *memory;       /* Allocated data buffer.  */
+  size_t memory_size;          /* Allocated size of MEMORY.  */
+  size_t memory_limit;          /* Caller supplied maximum allowed
+                                   allocation size or 0 for no limit.  */
   size_t offset;               /* Current offset in MEMORY.  */
-  size_t data_len;             /* Length of data in MEMORY.  */
+  size_t data_len;             /* Used length of data in MEMORY.  */
   size_t block_size;           /* Block size.  */
-  unsigned int grow: 1;                /* MEMORY is allowed to grow.  */
-  unsigned int append_zero: 1; /* Append zero after data.  */
-  unsigned int dont_free: 1;   /* Append zero after data.  */
-  char **ptr;
-  size_t *size;
+  struct {
+    unsigned int grow: 1;      /* MEMORY is allowed to grow.  */
+  } flags;
   func_realloc_t func_realloc;
   func_free_t func_free;
 } *estream_cookie_mem_t;
 
-/* Create function for memory objects.  */
+
+/* Create function for memory objects.  DATA is either NULL or a user
+   supplied buffer with the initial conetnt of the memory buffer.  If
+   DATA is NULL, DATA_N and DATA_LEN need to be 0 as well.  If DATA is
+   not NULL, DATA_N gives the allocated size of DATA and DATA_LEN the
+   used length in DATA.  If this fucntion succeeds DATA is now owned
+   by this function.  If GROW is false FUNC_REALLOC is not
+   required. */
 static int
-es_func_mem_create (void *ES__RESTRICT *ES__RESTRICT cookie,
-                   unsigned char *ES__RESTRICT data, size_t data_n,
-                   size_t data_len,
-                   size_t block_size, unsigned int grow,
-                   unsigned int append_zero, unsigned int dont_free,
-                   char **ptr, size_t *size,
-                   func_realloc_t func_realloc, func_free_t func_free,
-                   unsigned int modeflags)
+func_mem_create (void *ES__RESTRICT *ES__RESTRICT cookie,
+                 unsigned char *ES__RESTRICT data, size_t data_n,
+                 size_t data_len,
+                 size_t block_size, unsigned int grow,
+                 func_realloc_t func_realloc, func_free_t func_free,
+                 unsigned int modeflags,
+                 size_t memory_limit)
 {
   estream_cookie_mem_t mem_cookie;
   int err;
 
-  mem_cookie = ES_MEM_ALLOC (sizeof (*mem_cookie));
-  if (! mem_cookie)
+  if (!data && (data_n || data_len))
+    {
+      _set_errno (EINVAL);
+      return -1;
+    }
+  if (grow && func_free && !func_realloc)
+    {
+      _set_errno (EINVAL);
+      return -1;
+    }
+
+  mem_cookie = mem_alloc (sizeof (*mem_cookie));
+  if (!mem_cookie)
     err = -1;
   else
     {
       mem_cookie->modeflags = modeflags;
       mem_cookie->memory = data;
       mem_cookie->memory_size = data_n;
+      mem_cookie->memory_limit = memory_limit;
       mem_cookie->offset = 0;
       mem_cookie->data_len = data_len;
       mem_cookie->block_size = block_size;
-      mem_cookie->grow = grow ? 1 : 0;
-      mem_cookie->append_zero = append_zero ? 1 : 0;
-      mem_cookie->dont_free = dont_free ? 1 : 0;
-      mem_cookie->ptr = ptr;
-      mem_cookie->size = size;
-      mem_cookie->func_realloc = func_realloc ? func_realloc : ES_MEM_REALLOC;
-      mem_cookie->func_free = func_free ? func_free : ES_MEM_FREE;
-      mem_cookie->offset = 0;
+      mem_cookie->flags.grow = !!grow;
+      mem_cookie->func_realloc
+        = grow? (func_realloc ? func_realloc : mem_realloc) : NULL;
+      mem_cookie->func_free = func_free ? func_free : mem_free;
       *cookie = mem_cookie;
       err = 0;
     }
@@ -380,6 +600,7 @@ es_func_mem_create (void *ES__RESTRICT *ES__RESTRICT cookie,
   return err;
 }
 
+
 /* Read function for memory objects.  */
 static ssize_t
 es_func_mem_read (void *cookie, void *buffer, size_t size)
@@ -395,117 +616,104 @@ es_func_mem_read (void *cookie, void *buffer, size_t size)
       memcpy (buffer, mem_cookie->memory + mem_cookie->offset, size);
       mem_cookie->offset += size;
     }
-  
-  ret = size;
 
+  ret = size;
   return ret;
 }
 
+
 /* Write function for memory objects.  */
 static ssize_t
 es_func_mem_write (void *cookie, const void *buffer, size_t size)
 {
   estream_cookie_mem_t mem_cookie = cookie;
-  func_realloc_t func_realloc = mem_cookie->func_realloc;
-  unsigned char *memory_new;
-  size_t newsize;
   ssize_t ret;
-  int err;
+  size_t nleft;
 
-  if (size)
+  if (!size)
+    return 0;  /* A flush is a NOP for memory objects.  */
+
+  if (mem_cookie->modeflags & O_APPEND)
     {
-      /* Regular write.  */
+      /* Append to data.  */
+      mem_cookie->offset = mem_cookie->data_len;
+    }
 
-      if (mem_cookie->modeflags & O_APPEND)
-       /* Append to data.  */
-       mem_cookie->offset = mem_cookie->data_len;
-         
-      if (! mem_cookie->grow)
-       if (size > mem_cookie->memory_size - mem_cookie->offset)
-         size = mem_cookie->memory_size - mem_cookie->offset;
+  assert (mem_cookie->memory_size >= mem_cookie->offset);
+  nleft = mem_cookie->memory_size - mem_cookie->offset;
 
-      err = 0;
+  /* If we are not allowed to grow the buffer, limit the size to the
+     left space.  */
+  if (!mem_cookie->flags.grow && size > nleft)
+    size = nleft;
 
-      while (size > (mem_cookie->memory_size - mem_cookie->offset))
-       {
-         memory_new = (*func_realloc) (mem_cookie->memory,
-                                       mem_cookie->memory_size
-                                       + mem_cookie->block_size);
-         if (! memory_new)
-           {
-             err = -1;
-             break;
-           }
-         else
-           {
-             if (mem_cookie->memory != memory_new)
-               mem_cookie->memory = memory_new;
-             mem_cookie->memory_size += mem_cookie->block_size;
-           }
-       }
-      if (err)
-       goto out;
-
-      if (size)
-       {
-         memcpy (mem_cookie->memory + mem_cookie->offset, buffer, size);
-         if (mem_cookie->offset + size > mem_cookie->data_len)
-           mem_cookie->data_len = mem_cookie->offset + size;
-         mem_cookie->offset += size;
-       }
-    }
-  else
+  /* Enlarge the memory buffer if needed.  */
+  if (size > nleft)
     {
-      /* Flush.  */
+      unsigned char *newbuf;
+      size_t newsize;
 
-      err = 0;
-      if (mem_cookie->append_zero)
-       {
-         if (mem_cookie->data_len >= mem_cookie->memory_size)
-           {
-             newsize = BUFFER_ROUND_TO_BLOCK (mem_cookie->data_len + 1,
-                                              mem_cookie->block_size)
-               * mem_cookie->block_size;
-         
-             memory_new = (*func_realloc) (mem_cookie->memory, newsize);
-             if (! memory_new)
-               {
-                 err = -1;
-                 goto out;
-               }
-
-             if (mem_cookie->memory != memory_new)
-               mem_cookie->memory = memory_new;
-             mem_cookie->memory_size = newsize;
-           }
+      if (!mem_cookie->memory_size)
+        newsize = size;  /* Not yet allocated.  */
+      else
+        newsize = mem_cookie->memory_size + (size - nleft);
+      if (newsize < mem_cookie->offset)
+        {
+          _set_errno (EINVAL);
+          return -1;
+        }
 
-         mem_cookie->memory[mem_cookie->data_len + 1] = 0;
-       }
+      /* Round up to the next block length.  BLOCK_SIZE should always
+         be set; we check anyway.  */
+      if (mem_cookie->block_size)
+        {
+          newsize += mem_cookie->block_size - 1;
+          if (newsize < mem_cookie->offset)
+            {
+              _set_errno (EINVAL);
+              return -1;
+            }
+          newsize /= mem_cookie->block_size;
+          newsize *= mem_cookie->block_size;
+        }
 
-      /* Return information to user if necessary.  */
-      if (mem_cookie->ptr)
-       *mem_cookie->ptr = (char *) mem_cookie->memory;
-      if (mem_cookie->size)
-       *mem_cookie->size = mem_cookie->data_len;
-    }
+      /* Check for a total limit.  */
+      if (mem_cookie->memory_limit && newsize > mem_cookie->memory_limit)
+        {
+          _set_errno (ENOSPC);
+          return -1;
+        }
 
- out:
+      assert (mem_cookie->func_realloc);
+      newbuf = mem_cookie->func_realloc (mem_cookie->memory, newsize);
+      if (!newbuf)
+        return -1;
 
-  if (err)
-    ret = -1;
-  else
-    ret = size;
+      mem_cookie->memory = newbuf;
+      mem_cookie->memory_size = newsize;
+
+      assert (mem_cookie->memory_size >= mem_cookie->offset);
+      nleft = mem_cookie->memory_size - mem_cookie->offset;
+
+      assert (size <= nleft);
+    }
 
+  memcpy (mem_cookie->memory + mem_cookie->offset, buffer, size);
+  if (mem_cookie->offset + size > mem_cookie->data_len)
+    mem_cookie->data_len = mem_cookie->offset + size;
+  mem_cookie->offset += size;
+
+  ret = size;
   return ret;
 }
 
+
 /* Seek function for memory objects.  */
 static int
 es_func_mem_seek (void *cookie, off_t *offset, int whence)
 {
   estream_cookie_mem_t mem_cookie = cookie;
   off_t pos_new;
-  int err = 0;
 
   switch (whence)
     {
@@ -522,69 +730,102 @@ es_func_mem_seek (void *cookie, off_t *offset, int whence)
       break;
 
     default:
-      /* Never reached.  */
-      pos_new = 0;
+      _set_errno (EINVAL);
+      return -1;
     }
 
   if (pos_new > mem_cookie->memory_size)
     {
-      /* Grow buffer if possible.  */
+      size_t newsize;
+      void *newbuf;
 
-      if (mem_cookie->grow)
+      if (!mem_cookie->flags.grow)
        {
-         func_realloc_t func_realloc = mem_cookie->func_realloc;
-         size_t newsize;
-         void *p;
+         _set_errno (ENOSPC);
+         return -1;
+        }
 
-         newsize = BUFFER_ROUND_TO_BLOCK (pos_new, mem_cookie->block_size);
-         p = (*func_realloc) (mem_cookie->memory, newsize);
-         if (! p)
-           {
-             err = -1;
-             goto out;
-           }
-         else
-           {
-             if (mem_cookie->memory != p)
-               mem_cookie->memory = p;
-             mem_cookie->memory_size = newsize;
-           }
-       }
-      else
-       {
-         errno = EINVAL;
-         err = -1;
-         goto out;
-       }
+      newsize = pos_new + mem_cookie->block_size - 1;
+      if (newsize < pos_new)
+        {
+          _set_errno (EINVAL);
+          return -1;
+        }
+      newsize /= mem_cookie->block_size;
+      newsize *= mem_cookie->block_size;
+
+      if (mem_cookie->memory_limit && newsize > mem_cookie->memory_limit)
+        {
+          _set_errno (ENOSPC);
+          return -1;
+        }
+
+      assert (mem_cookie->func_realloc);
+      newbuf = mem_cookie->func_realloc (mem_cookie->memory, newsize);
+      if (!newbuf)
+        return -1;
+
+      mem_cookie->memory = newbuf;
+      mem_cookie->memory_size = newsize;
     }
 
   if (pos_new > mem_cookie->data_len)
-    /* Fill spare space with zeroes.  */
-    memset (mem_cookie->memory + mem_cookie->data_len,
-           0, pos_new - mem_cookie->data_len);
+    {
+      /* Fill spare space with zeroes.  */
+      memset (mem_cookie->memory + mem_cookie->data_len,
+              0, pos_new - mem_cookie->data_len);
+      mem_cookie->data_len = pos_new;
+    }
 
   mem_cookie->offset = pos_new;
   *offset = pos_new;
 
- out:
+  return 0;
+}
 
-  return err;
+/* An IOCTL function for memory objects.  */
+static int
+es_func_mem_ioctl (void *cookie, int cmd, void *ptr, size_t *len)
+{
+  estream_cookie_mem_t mem_cookie = cookie;
+  int ret;
+
+  if (cmd == COOKIE_IOCTL_SNATCH_BUFFER)
+    {
+      /* Return the internal buffer of the stream to the caller and
+         invalidate it for the stream.  */
+      *(void**)ptr = mem_cookie->memory;
+      *len = mem_cookie->offset;
+      mem_cookie->memory = NULL;
+      mem_cookie->memory_size = 0;
+      mem_cookie->offset = 0;
+      ret = 0;
+    }
+  else
+    {
+      _set_errno (EINVAL);
+      ret = -1;
+    }
+
+  return ret;
 }
 
+
 /* Destroy function for memory objects.  */
 static int
 es_func_mem_destroy (void *cookie)
 {
   estream_cookie_mem_t mem_cookie = cookie;
-  func_free_t func_free = mem_cookie->func_free;
-
-  if (! mem_cookie->dont_free)
-    (*func_free) (mem_cookie->memory);
-  ES_MEM_FREE (mem_cookie);
 
+  if (cookie)
+    {
+      mem_cookie->func_free (mem_cookie->memory);
+      mem_free (mem_cookie);
+    }
   return 0;
 }
 
+
 static es_cookie_io_functions_t estream_functions_mem =
   {
     es_func_mem_read,
@@ -595,7 +836,7 @@ static es_cookie_io_functions_t estream_functions_mem =
 
 
 \f
-/* Implementation of fd I/O.  */
+/* Implementation of file descriptor based I/O.  */
 
 /* Cookie for fd objects.  */
 typedef struct estream_cookie_fd
@@ -604,14 +845,14 @@ typedef struct estream_cookie_fd
   int no_close;  /* If set we won't close the file descriptor.  */
 } *estream_cookie_fd_t;
 
-/* Create function for fd objects.  */
+/* Create function for objects indentified by a libc file descriptor.  */
 static int
-es_func_fd_create (void **cookie, int fd, unsigned int modeflags, int no_close)
+func_fd_create (void **cookie, int fd, unsigned int modeflags, int no_close)
 {
   estream_cookie_fd_t fd_cookie;
   int err;
 
-  fd_cookie = ES_MEM_ALLOC (sizeof (*fd_cookie));
+  fd_cookie = mem_alloc (sizeof (*fd_cookie));
   if (! fd_cookie)
     err = -1;
   else
@@ -620,13 +861,15 @@ es_func_fd_create (void **cookie, int fd, unsigned int modeflags, int no_close)
       /* Make sure it is in binary mode if requested.  */
       if ( (modeflags & O_BINARY) )
         setmode (fd, O_BINARY);
+#else
+      (void)modeflags;
 #endif
       fd_cookie->fd = fd;
       fd_cookie->no_close = no_close;
       *cookie = fd_cookie;
       err = 0;
     }
-  
+
   return err;
 }
 
@@ -638,9 +881,17 @@ es_func_fd_read (void *cookie, void *buffer, size_t size)
   estream_cookie_fd_t file_cookie = cookie;
   ssize_t bytes_read;
 
-  do 
-    bytes_read = ESTREAM_SYS_READ (file_cookie->fd, buffer, size);
-  while (bytes_read == -1 && errno == EINTR);
+  if (IS_INVALID_FD (file_cookie->fd))
+    {
+      ESTREAM_SYS_YIELD ();
+      bytes_read = 0;
+    }
+  else
+    {
+      do
+        bytes_read = ESTREAM_SYS_READ (file_cookie->fd, buffer, size);
+      while (bytes_read == -1 && errno == EINTR);
+    }
 
   return bytes_read;
 }
@@ -648,14 +899,21 @@ es_func_fd_read (void *cookie, void *buffer, size_t size)
 /* Write function for fd objects.  */
 static ssize_t
 es_func_fd_write (void *cookie, const void *buffer, size_t size)
-                          
 {
   estream_cookie_fd_t file_cookie = cookie;
   ssize_t bytes_written;
 
-  do
-    bytes_written = ESTREAM_SYS_WRITE (file_cookie->fd, buffer, size);
-  while (bytes_written == -1 && errno == EINTR);
+  if (IS_INVALID_FD (file_cookie->fd))
+    {
+      ESTREAM_SYS_YIELD ();
+      bytes_written = size; /* Yeah:  Success writing to the bit bucket.  */
+    }
+  else
+    {
+      do
+        bytes_written = ESTREAM_SYS_WRITE (file_cookie->fd, buffer, size);
+      while (bytes_written == -1 && errno == EINTR);
+    }
 
   return bytes_written;
 }
@@ -668,13 +926,21 @@ es_func_fd_seek (void *cookie, off_t *offset, int whence)
   off_t offset_new;
   int err;
 
-  offset_new = lseek (file_cookie->fd, *offset, whence);
-  if (offset_new == -1)
-    err = -1;
+  if (IS_INVALID_FD (file_cookie->fd))
+    {
+      _set_errno (ESPIPE);
+      err = -1;
+    }
   else
     {
-      *offset = offset_new;
-      err = 0;
+      offset_new = lseek (file_cookie->fd, *offset, whence);
+      if (offset_new == -1)
+        err = -1;
+      else
+        {
+          *offset = offset_new;
+          err = 0;
+        }
     }
 
   return err;
@@ -689,8 +955,11 @@ es_func_fd_destroy (void *cookie)
 
   if (fd_cookie)
     {
-      err = fd_cookie->no_close? 0 : close (fd_cookie->fd);
-      ES_MEM_FREE (fd_cookie);
+      if (IS_INVALID_FD (fd_cookie->fd))
+        err = 0;
+      else
+        err = fd_cookie->no_close? 0 : close (fd_cookie->fd);
+      mem_free (fd_cookie);
     }
   else
     err = 0;
@@ -710,6 +979,217 @@ static es_cookie_io_functions_t estream_functions_fd =
 
 
 \f
+#ifdef HAVE_W32_SYSTEM
+/* Implementation of W32 handle based I/O.  */
+
+/* Cookie for fd objects.  */
+typedef struct estream_cookie_w32
+{
+  HANDLE hd;     /* The handle we are using for actual output.  */
+  int no_close;  /* If set we won't close the handle.  */
+} *estream_cookie_w32_t;
+
+
+/* Create function for w32 handle objects.  */
+static int
+es_func_w32_create (void **cookie, HANDLE hd,
+                    unsigned int modeflags, int no_close)
+{
+  estream_cookie_w32_t w32_cookie;
+  int err;
+
+  w32_cookie = mem_alloc (sizeof (*w32_cookie));
+  if (!w32_cookie)
+    err = -1;
+  else
+    {
+      /* CR/LF translations are not supported when using the bare W32
+         API.  If that is really required we need to implemented that
+         in the upper layer.  */
+      (void)modeflags;
+
+      w32_cookie->hd = hd;
+      w32_cookie->no_close = no_close;
+      *cookie = w32_cookie;
+      err = 0;
+    }
+
+  return err;
+}
+
+/* Read function for W32 handle objects.  */
+static ssize_t
+es_func_w32_read (void *cookie, void *buffer, size_t size)
+{
+  estream_cookie_w32_t w32_cookie = cookie;
+  ssize_t bytes_read;
+
+  if (w32_cookie->hd == INVALID_HANDLE_VALUE)
+    {
+      ESTREAM_SYS_YIELD ();
+      bytes_read = 0;
+    }
+  else
+    {
+      do
+        {
+#ifdef HAVE_NPTH
+          /* Note: Our pth_read actually uses HANDLE! */
+          bytes_read = pth_read ((int)w32_cookie->hd, buffer, size);
+#else
+          DWORD nread, ec;
+
+          if (!ReadFile (w32_cookie->hd, buffer, size, &nread, NULL))
+            {
+              ec = GetLastError ();
+              if (ec == ERROR_BROKEN_PIPE)
+                bytes_read = 0; /* Like our pth_read we handle this as EOF.  */
+              else
+                {
+                  _set_errno (map_w32_to_errno (ec));
+                  log_debug ("estream: ReadFile returned %d\n",
+                             (int)GetLastError ());
+                  bytes_read = -1;
+                }
+            }
+          else
+            bytes_read = (int)nread;
+#endif
+        }
+      while (bytes_read == -1 && errno == EINTR);
+    }
+
+  return bytes_read;
+}
+
+/* Write function for W32 handle objects.  */
+static ssize_t
+es_func_w32_write (void *cookie, const void *buffer, size_t size)
+{
+  estream_cookie_w32_t w32_cookie = cookie;
+  ssize_t bytes_written;
+
+  if (w32_cookie->hd == INVALID_HANDLE_VALUE)
+    {
+      ESTREAM_SYS_YIELD ();
+      bytes_written = size; /* Yeah:  Success writing to the bit bucket.  */
+    }
+  else
+    {
+      do
+        {
+#ifdef HAVE_NPTH
+          /* Note: Our pth_write actually uses HANDLE! */
+          bytes_written = pth_write ((int)w32_cookie->hd, buffer, size);
+#else
+          DWORD nwritten;
+
+         if (!WriteFile (w32_cookie->hd, buffer, size, &nwritten, NULL))
+           {
+             _set_errno (map_w32_to_errno (GetLastError ()));
+             bytes_written = -1;
+           }
+         else
+           bytes_written = (int)nwritten;
+#endif
+        }
+      while (bytes_written == -1 && errno == EINTR);
+    }
+
+  return bytes_written;
+}
+
+/* Seek function for W32 handle objects.  */
+static int
+es_func_w32_seek (void *cookie, off_t *offset, int whence)
+{
+  estream_cookie_w32_t w32_cookie = cookie;
+  DWORD method;
+  LARGE_INTEGER distance, newoff;
+
+  if (w32_cookie->hd == INVALID_HANDLE_VALUE)
+    {
+      _set_errno (ESPIPE);
+      return -1;
+    }
+
+  if (whence == SEEK_SET)
+    {
+      method = FILE_BEGIN;
+      distance.QuadPart = (unsigned long long)(*offset);
+    }
+  else if (whence == SEEK_CUR)
+    {
+      method = FILE_CURRENT;
+      distance.QuadPart = (long long)(*offset);
+    }
+  else if (whence == SEEK_END)
+    {
+      method = FILE_END;
+      distance.QuadPart = (long long)(*offset);
+    }
+  else
+    {
+      _set_errno (EINVAL);
+      return -1;
+    }
+#ifdef HAVE_W32CE_SYSTEM
+# warning need to use SetFilePointer
+#else
+  if (!SetFilePointerEx (w32_cookie->hd, distance, &newoff, method))
+    {
+      _set_errno (map_w32_to_errno (GetLastError ()));
+      return -1;
+    }
+#endif
+  *offset = (unsigned long long)newoff.QuadPart;
+  return 0;
+}
+
+/* Destroy function for W32 handle objects.  */
+static int
+es_func_w32_destroy (void *cookie)
+{
+  estream_cookie_w32_t w32_cookie = cookie;
+  int err;
+
+  if (w32_cookie)
+    {
+      if (w32_cookie->hd == INVALID_HANDLE_VALUE)
+        err = 0;
+      else if (w32_cookie->no_close)
+        err = 0;
+      else
+        {
+          if (!CloseHandle (w32_cookie->hd))
+            {
+             _set_errno (map_w32_to_errno (GetLastError ()));
+              err = -1;
+            }
+          else
+            err = 0;
+        }
+      mem_free (w32_cookie);
+    }
+  else
+    err = 0;
+
+  return err;
+}
+
+
+static es_cookie_io_functions_t estream_functions_w32 =
+  {
+    es_func_w32_read,
+    es_func_w32_write,
+    es_func_w32_seek,
+    es_func_w32_destroy
+  };
+#endif /*HAVE_W32_SYSTEM*/
+
+
+
+\f
 /* Implementation of FILE* I/O.  */
 
 /* Cookie for fp objects.  */
@@ -719,14 +1199,16 @@ typedef struct estream_cookie_fp
   int no_close;  /* If set we won't close the file pointer.  */
 } *estream_cookie_fp_t;
 
-/* Create function for fd objects.  */
+
+/* Create function for FILE objects.  */
 static int
-es_func_fp_create (void **cookie, FILE *fp, unsigned int modeflags, int no_close)
+func_fp_create (void **cookie, FILE *fp,
+                unsigned int modeflags, int no_close)
 {
   estream_cookie_fp_t fp_cookie;
   int err;
 
-  fp_cookie = ES_MEM_ALLOC (sizeof *fp_cookie);
+  fp_cookie = mem_alloc (sizeof *fp_cookie);
   if (!fp_cookie)
     err = -1;
   else
@@ -735,13 +1217,15 @@ es_func_fp_create (void **cookie, FILE *fp, unsigned int modeflags, int no_close
       /* Make sure it is in binary mode if requested.  */
       if ( (modeflags & O_BINARY) )
         setmode (fileno (fp), O_BINARY);
+#else
+      (void)modeflags;
 #endif
       fp_cookie->fp = fp;
       fp_cookie->no_close = no_close;
       *cookie = fp_cookie;
       err = 0;
     }
-  
+
   return err;
 }
 
@@ -753,7 +1237,10 @@ es_func_fp_read (void *cookie, void *buffer, size_t size)
   estream_cookie_fp_t file_cookie = cookie;
   ssize_t bytes_read;
 
-  bytes_read = fread (buffer, 1, size, file_cookie->fp);
+  if (file_cookie->fp)
+    bytes_read = fread (buffer, 1, size, file_cookie->fp);
+  else
+    bytes_read = 0;
   if (!bytes_read && ferror (file_cookie->fp))
     return -1;
   return bytes_read;
@@ -762,12 +1249,36 @@ es_func_fp_read (void *cookie, void *buffer, size_t size)
 /* Write function for FILE* objects.  */
 static ssize_t
 es_func_fp_write (void *cookie, const void *buffer, size_t size)
-                          
 {
   estream_cookie_fp_t file_cookie = cookie;
   size_t bytes_written;
 
-  bytes_written = fwrite (buffer, 1, size, file_cookie->fp);
+  if (file_cookie->fp)
+    {
+#ifdef HAVE_W32_SYSTEM
+      /* Using an fwrite to stdout connected to the console fails with
+        the error "Not enough space" for an fwrite size of >= 52KB
+        (tested on Windows XP SP2).  To solve this we always chunk
+        the writes up into smaller blocks.  */
+      bytes_written = 0;
+      while (bytes_written < size)
+        {
+          size_t cnt = size - bytes_written;
+
+          if (cnt > 32*1024)
+            cnt = 32*1024;
+          if (fwrite ((const char*)buffer + bytes_written,
+                      cnt, 1, file_cookie->fp) != 1)
+            break; /* Write error.  */
+          bytes_written += cnt;
+        }
+#else
+      bytes_written = fwrite (buffer, 1, size, file_cookie->fp);
+#endif
+      fflush (file_cookie->fp);
+    }
+  else
+    bytes_written = size; /* Successfully written to the bit bucket.  */
   if (bytes_written != size)
     return -1;
   return bytes_written;
@@ -780,23 +1291,31 @@ es_func_fp_seek (void *cookie, off_t *offset, int whence)
   estream_cookie_fp_t file_cookie = cookie;
   long int offset_new;
 
+  if (!file_cookie->fp)
+    {
+      _set_errno (ESPIPE);
+      return -1;
+    }
+
   if ( fseek (file_cookie->fp, (long int)*offset, whence) )
     {
-      fprintf (stderr, "\nfseek failed: errno=%d (%s)\n", errno,strerror (errno));
-    return -1;
+      /* fprintf (stderr, "\nfseek failed: errno=%d (%s)\n", */
+      /*          errno,strerror (errno)); */
+      return -1;
     }
 
   offset_new = ftell (file_cookie->fp);
   if (offset_new == -1)
     {
-      fprintf (stderr, "\nftell failed: errno=%d (%s)\n", errno,strerror (errno));
-    return -1;
+      /* fprintf (stderr, "\nftell failed: errno=%d (%s)\n",  */
+      /*          errno,strerror (errno)); */
+      return -1;
     }
   *offset = offset_new;
   return 0;
 }
 
-/* Destroy function for fd objects.  */
+/* Destroy function for FILE* objects.  */
 static int
 es_func_fp_destroy (void *cookie)
 {
@@ -805,9 +1324,14 @@ es_func_fp_destroy (void *cookie)
 
   if (fp_cookie)
     {
-      fflush (fp_cookie->fp);
-      err = fp_cookie->no_close? 0 : fclose (fp_cookie->fp);
-      ES_MEM_FREE (fp_cookie);
+      if (fp_cookie->fp)
+        {
+          fflush (fp_cookie->fp);
+          err = fp_cookie->no_close? 0 : fclose (fp_cookie->fp);
+        }
+      else
+        err = 0;
+      mem_free (fp_cookie);
     }
   else
     err = 0;
@@ -829,10 +1353,10 @@ static es_cookie_io_functions_t estream_functions_fp =
 \f
 /* Implementation of file I/O.  */
 
-/* Create function for file objects.  */
+/* Create function for objects identified by a file name.  */
 static int
-es_func_file_create (void **cookie, int *filedes,
-                    const char *path, unsigned int modeflags)
+func_file_create (void **cookie, int *filedes,
+                  const char *path, unsigned int modeflags, unsigned int cmode)
 {
   estream_cookie_fd_t file_cookie;
   int err;
@@ -841,14 +1365,14 @@ es_func_file_create (void **cookie, int *filedes,
   err = 0;
   fd = -1;
 
-  file_cookie = ES_MEM_ALLOC (sizeof (*file_cookie));
+  file_cookie = mem_alloc (sizeof (*file_cookie));
   if (! file_cookie)
     {
       err = -1;
       goto out;
     }
 
-  fd = open (path, modeflags, ES_DEFAULT_OPEN_MODE);
+  fd = open (path, modeflags, cmode);
   if (fd == -1)
     {
       err = -1;
@@ -868,81 +1392,120 @@ es_func_file_create (void **cookie, int *filedes,
  out:
 
   if (err)
-    ES_MEM_FREE (file_cookie);
+    mem_free (file_cookie);
 
   return err;
 }
 
-static es_cookie_io_functions_t estream_functions_file =
-  {
-    es_func_fd_read,
-    es_func_fd_write,
-    es_func_fd_seek,
-    es_func_fd_destroy
-  };
-
-\f
-
-/* Stream primitives.  */
 
+\f
+/* Parse the mode flags of fopen et al.  In addition to the POSIX
+   defined mode flags keyword parameters are supported.  These are
+   key/value pairs delimited by comma and optional white spaces.
+   Keywords and values may not contain a comma or white space; unknown
+   keyword are skipped.  The only supported keyword is mode; for
+   example:
+
+     "wb,mode=-rw-r--"
+
+   Creates a file and gives the new file read and write permissions
+   for the user and read permission for the group.  The format of the
+   string is the same as shown by the -l option of the ls(1) command.
+   However the first letter must be a dash and it is allowed to leave
+   out trailing dashes.  If this keyword parameter is not given the
+   default mode for creating files is "-rw-rw-r--" (664).  Note that
+   the system still applies the current umask to the mode when crating
+   a file.
+
+   Note: R_CMODE is optional because is only required by functions
+   which are able to creat a file.  */
 static int
-es_convert_mode (const char *mode, unsigned int *modeflags)
+parse_mode (const char *modestr,
+            unsigned int *modeflags, unsigned int *r_cmode)
 {
+  unsigned int omode, oflags, cmode;
+  int got_cmode = 0;
 
-  /* FIXME: We need to allow all mode flags permutations.  */
-  struct
-  {
-    const char *mode;
-    unsigned int flags;
-  } mode_flags[] = { { "r",
-                      O_RDONLY },
-                    { "rb",
-                      O_RDONLY | O_BINARY },
-                    { "w",
-                      O_WRONLY | O_TRUNC | O_CREAT },
-                    { "wb",
-                      O_WRONLY | O_TRUNC | O_CREAT | O_BINARY },
-                    { "a",
-                      O_WRONLY | O_APPEND | O_CREAT },
-                    { "ab",
-                      O_WRONLY | O_APPEND | O_CREAT | O_BINARY },
-                    { "r+",
-                      O_RDWR },
-                    { "rb+",
-                      O_RDWR | O_BINARY },
-                    { "r+b",
-                      O_RDONLY | O_WRONLY | O_BINARY },
-                    { "w+",
-                      O_RDWR | O_TRUNC | O_CREAT },
-                    { "wb+",
-                      O_RDWR | O_TRUNC | O_CREAT | O_BINARY },
-                    { "w+b",
-                      O_RDWR | O_TRUNC | O_CREAT | O_BINARY },
-                    { "a+",
-                      O_RDWR | O_CREAT | O_APPEND },
-                    { "ab+",
-                      O_RDWR | O_CREAT | O_APPEND | O_BINARY },
-                    { "a+b",
-                      O_RDWR | O_CREAT | O_APPEND | O_BINARY }
-  };
-  unsigned int i;
-  int err; 
-
-  for (i = 0; i < DIM (mode_flags); i++)
-    if (! strcmp (mode_flags[i].mode, mode))
+  switch (*modestr)
+    {
+    case 'r':
+      omode = O_RDONLY;
+      oflags = 0;
+      break;
+    case 'w':
+      omode = O_WRONLY;
+      oflags = O_TRUNC | O_CREAT;
+      break;
+    case 'a':
+      omode = O_WRONLY;
+      oflags = O_APPEND | O_CREAT;
       break;
-  if (i == DIM (mode_flags))
+    default:
+      _set_errno (EINVAL);
+      return -1;
+    }
+  for (modestr++; *modestr; modestr++)
     {
-      errno = EINVAL;
-      err = -1;
+      switch (*modestr)
+        {
+        case '+':
+          omode = O_RDWR;
+          break;
+        case 'b':
+          oflags |= O_BINARY;
+          break;
+        case 'x':
+          oflags |= O_EXCL;
+          break;
+        case ',':
+          goto keyvalue;
+        default: /* Ignore unknown flags.  */
+          break;
+        }
     }
-  else
+
+ keyvalue:
+  /* Parse key/value pairs (similar to fopen on mainframes).  */
+  for (cmode=0; *modestr == ','; modestr += strcspn (modestr, ","))
     {
-      err = 0;
-      *modeflags = mode_flags[i].flags;
+      modestr++;
+      modestr += strspn (modestr, " \t");
+      if (!strncmp (modestr, "mode=", 5))
+        {
+          static struct {
+            char letter;
+            unsigned int value;
+          } table[] = { { '-', 0 },
+                        { 'r', S_IRUSR }, { 'w', S_IWUSR }, { 'x', S_IXUSR },
+                        { 'r', S_IRGRP }, { 'w', S_IWGRP }, { 'x', S_IXGRP },
+                        { 'r', S_IROTH }, { 'w', S_IWOTH }, { 'x', S_IXOTH }};
+          int idx;
+
+          got_cmode = 1;
+          modestr += 5;
+          /* For now we only support a string as used by ls(1) and no
+             octal numbers.  The first character must be a dash.  */
+          for (idx=0; idx < 10 && *modestr; idx++, modestr++)
+            {
+              if (*modestr == table[idx].letter)
+                cmode |= table[idx].value;
+              else if (*modestr != '-')
+                break;
+            }
+          if (*modestr && !strchr (" \t,", *modestr))
+            {
+              _set_errno (EINVAL);
+              return -1;
+            }
+        }
     }
+  if (!got_cmode)
+    cmode = (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH);
 
-  return err;
+  *modeflags = (omode | oflags);
+  if (r_cmode)
+    *r_cmode = cmode;
+  return 0;
 }
 
 \f
@@ -959,7 +1522,7 @@ es_fill (estream_t stream)
 
   if (!stream->intern->func_read)
     {
-      errno = EOPNOTSUPP;
+      _set_errno (EOPNOTSUPP);
       err = -1;
     }
   else
@@ -1018,10 +1581,10 @@ es_flush (estream_t stream)
         they were asked to write, we have to check for
         "(stream->data_offset - data_flushed) > 0" instead of
         "stream->data_offset - data_flushed".  */
-      
+
       data_flushed = 0;
       err = 0;
-      
+
       while ((((ssize_t) (stream->data_offset - data_flushed)) > 0) && (! err))
        {
          ret = (*func_write) (stream->intern->cookie,
@@ -1055,7 +1618,7 @@ es_flush (estream_t stream)
     err = 0;
 
  out:
-    
+
   if (err)
     stream->intern->indicators.err = 1;
 
@@ -1075,7 +1638,8 @@ es_empty (estream_t stream)
 /* Initialize STREAM.  */
 static void
 es_initialize (estream_t stream,
-              void *cookie, int fd, es_cookie_io_functions_t functions,
+              void *cookie, es_syshd_t *syshd,
+               es_cookie_io_functions_t functions,
                unsigned int modeflags)
 {
   stream->intern->cookie = cookie;
@@ -1084,16 +1648,19 @@ es_initialize (estream_t stream,
   stream->intern->func_read = functions.func_read;
   stream->intern->func_write = functions.func_write;
   stream->intern->func_seek = functions.func_seek;
+  stream->intern->func_ioctl = NULL;
   stream->intern->func_close = functions.func_close;
   stream->intern->strategy = _IOFBF;
-  stream->intern->fd = fd;
-  stream->intern->print_err = 0;
-  stream->intern->print_errno = 0;
+  stream->intern->syshd = *syshd;
   stream->intern->print_ntotal = 0;
-  stream->intern->print_fp = NULL;
   stream->intern->indicators.err = 0;
   stream->intern->indicators.eof = 0;
+  stream->intern->is_stdstream = 0;
+  stream->intern->stdstream_fd = 0;
   stream->intern->deallocate_buffer = 0;
+  stream->intern->printable_fname = NULL;
+  stream->intern->printable_fname_inuse = 0;
+  stream->intern->onclose = NULL;
 
   stream->data_len = 0;
   stream->data_offset = 0;
@@ -1101,7 +1668,7 @@ es_initialize (estream_t stream,
   stream->unread_data_len = 0;
   /* Depending on the modeflags we set whether we start in writing or
      reading mode.  This is required in case we are working on a
-     wronly stream which is not seeekable (like stdout).  Without this
+     stream which is not seeekable (like stdout).  Without this
      pre-initialization we would do a seek at the first write call and
      as this will fail no utput will be delivered. */
   if ((modeflags & O_WRONLY) || (modeflags & O_RDWR) )
@@ -1117,14 +1684,6 @@ es_deinitialize (estream_t stream)
   es_cookie_close_function_t func_close;
   int err, tmp_err;
 
-  if (stream->intern->print_fp)
-    {
-      int save_errno = errno;
-      fclose (stream->intern->print_fp);
-      stream->intern->print_fp = NULL;
-      errno = save_errno;
-    }
-
   func_close = stream->intern->func_close;
 
   err = 0;
@@ -1133,14 +1692,24 @@ es_deinitialize (estream_t stream)
   if (func_close)
     SET_UNLESS_NONZERO (err, tmp_err, (*func_close) (stream->intern->cookie));
 
-  
+  mem_free (stream->intern->printable_fname);
+  stream->intern->printable_fname = NULL;
+  stream->intern->printable_fname_inuse = 0;
+  while (stream->intern->onclose)
+    {
+      notify_list_t tmp = stream->intern->onclose->next;
+      mem_free (stream->intern->onclose);
+      stream->intern->onclose = tmp;
+    }
+
   return err;
 }
 
 /* Create a new stream object, initialize it.  */
 static int
-es_create (estream_t *stream, void *cookie, int fd,
-          es_cookie_io_functions_t functions, unsigned int modeflags)
+es_create (estream_t *stream, void *cookie, es_syshd_t *syshd,
+          es_cookie_io_functions_t functions, unsigned int modeflags,
+           int with_locked_list)
 {
   estream_internal_t stream_internal_new;
   estream_t stream_new;
@@ -1149,14 +1718,14 @@ es_create (estream_t *stream, void *cookie, int fd,
   stream_new = NULL;
   stream_internal_new = NULL;
 
-  stream_new = ES_MEM_ALLOC (sizeof (*stream_new));
+  stream_new = mem_alloc (sizeof (*stream_new));
   if (! stream_new)
     {
       err = -1;
       goto out;
     }
 
-  stream_internal_new = ES_MEM_ALLOC (sizeof (*stream_internal_new));
+  stream_internal_new = mem_alloc (sizeof (*stream_internal_new));
   if (! stream_internal_new)
     {
       err = -1;
@@ -1170,9 +1739,9 @@ es_create (estream_t *stream, void *cookie, int fd,
   stream_new->intern = stream_internal_new;
 
   ESTREAM_MUTEX_INITIALIZE (stream_new->intern->lock);
-  es_initialize (stream_new, cookie, fd, functions, modeflags);
+  es_initialize (stream_new, cookie, syshd, functions, modeflags);
 
-  err = es_list_add (stream_new);
+  err = do_list_add (stream_new, with_locked_list);
   if (err)
     goto out;
 
@@ -1185,7 +1754,7 @@ es_create (estream_t *stream, void *cookie, int fd,
       if (stream_new)
        {
          es_deinitialize (stream_new);
-         ES_MEM_FREE (stream_new);
+         mem_free (stream_new);
        }
     }
 
@@ -1194,21 +1763,61 @@ es_create (estream_t *stream, void *cookie, int fd,
 
 /* Deinitialize a stream object and destroy it.  */
 static int
-es_destroy (estream_t stream)
+do_close (estream_t stream, int with_locked_list)
 {
-  int err = 0;
+  int err;
 
   if (stream)
     {
-      es_list_remove (stream);
+      do_list_remove (stream, with_locked_list);
+      while (stream->intern->onclose)
+        {
+          notify_list_t tmp = stream->intern->onclose->next;
+
+          if (stream->intern->onclose->fnc)
+            stream->intern->onclose->fnc (stream,
+                                          stream->intern->onclose->fnc_value);
+          mem_free (stream->intern->onclose);
+          stream->intern->onclose = tmp;
+        }
       err = es_deinitialize (stream);
-      ES_MEM_FREE (stream->intern);
-      ES_MEM_FREE (stream);
+      mem_free (stream->intern);
+      mem_free (stream);
     }
+  else
+    err = 0;
 
   return err;
 }
 
+
+/* This worker function is called with a locked stream.  */
+static int
+do_onclose (estream_t stream, int mode,
+            void (*fnc) (estream_t, void*), void *fnc_value)
+{
+  notify_list_t item;
+
+  if (!mode)
+    {
+      for (item = stream->intern->onclose; item; item = item->next)
+        if (item->fnc && item->fnc == fnc && item->fnc_value == fnc_value)
+          item->fnc = NULL; /* Disable this notification.  */
+    }
+  else
+    {
+      item = mem_alloc (sizeof *item);
+      if (!item)
+        return -1;
+      item->fnc = fnc;
+      item->fnc_value = fnc_value;
+      item->next = stream->intern->onclose;
+      stream->intern->onclose = item;
+    }
+  return 0;
+}
+
+
 /* Try to read BYTES_TO_READ bytes FROM STREAM into BUFFER in
    unbuffered-mode, storing the amount of bytes read in
    *BYTES_READ.  */
@@ -1333,7 +1942,7 @@ es_readn (estream_t ES__RESTRICT stream,
       if (err)
        goto out;
       stream->flags.writing = 0;
-    }  
+    }
 
   /* Read unread data first.  */
   while ((bytes_to_read - data_read_unread) && stream->unread_data_len)
@@ -1372,7 +1981,7 @@ es_readn (estream_t ES__RESTRICT stream,
 }
 
 /* Try to unread DATA_N bytes from DATA into STREAM, storing the
-   amount of bytes succesfully unread in *BYTES_UNREAD.  */
+   amount of bytes successfully unread in *BYTES_UNREAD.  */
 static void
 es_unreadn (estream_t ES__RESTRICT stream,
            const unsigned char *ES__RESTRICT data, size_t data_n,
@@ -1409,7 +2018,7 @@ es_seek (estream_t ES__RESTRICT stream, off_t offset, int whence,
 
   if (! func_seek)
     {
-      errno = EOPNOTSUPP;
+      _set_errno (EOPNOTSUPP);
       err = -1;
       goto out;
     }
@@ -1430,7 +2039,7 @@ es_seek (estream_t ES__RESTRICT stream, off_t offset, int whence,
       off = off - stream->data_len + stream->data_offset;
       off -= stream->unread_data_len;
     }
-  
+
   ret = (*func_seek) (stream->intern->cookie, &off, whence);
   if (ret == -1)
     {
@@ -1448,7 +2057,7 @@ es_seek (estream_t ES__RESTRICT stream, off_t offset, int whence,
   stream->intern->offset = off;
 
  out:
-  
+
   if (err)
     stream->intern->indicators.err = 1;
 
@@ -1472,11 +2081,11 @@ es_write_nbf (estream_t ES__RESTRICT stream,
     {
       err = EOPNOTSUPP;
       goto out;
-    }  
+    }
 
   data_written = 0;
   err = 0;
-  
+
   while (bytes_to_write - data_written)
     {
       ret = (*func_write) (stream->intern->cookie,
@@ -1524,12 +2133,12 @@ es_write_fbf (estream_t ES__RESTRICT stream,
       if (! err)
        {
          /* Flushing resulted in empty container.  */
-         
+
          data_to_write = bytes_to_write - data_written;
          space_available = stream->buffer_size - stream->data_offset;
          if (data_to_write > space_available)
            data_to_write = space_available;
-             
+
          memcpy (stream->buffer + stream->data_offset,
                  buffer + data_written, data_to_write);
          stream->data_offset += data_to_write;
@@ -1590,7 +2199,7 @@ es_writen (estream_t ES__RESTRICT stream,
 
   data_written = 0;
   err = 0;
-  
+
   if (!stream->flags.writing)
     {
       /* Switching to writing mode -> discard input data and seek to
@@ -1625,7 +2234,7 @@ es_writen (estream_t ES__RESTRICT stream,
     }
 
  out:
-    
+
   if (bytes_written)
     *bytes_written = data_written;
   if (data_written)
@@ -1649,7 +2258,7 @@ es_peek (estream_t ES__RESTRICT stream, unsigned char **ES__RESTRICT data,
       if (err)
        goto out;
       stream->flags.writing = 0;
-    }  
+    }
 
   if (stream->data_offset == stream->data_len)
     {
@@ -1658,7 +2267,7 @@ es_peek (estream_t ES__RESTRICT stream, unsigned char **ES__RESTRICT data,
       if (err)
        goto out;
     }
-  
+
   if (data)
     *data = stream->buffer + stream->data_offset;
   if (data_len)
@@ -1679,7 +2288,7 @@ es_skip (estream_t stream, size_t size)
 
   if (stream->data_offset + size > stream->data_len)
     {
-      errno = EINVAL;
+      _set_errno (EINVAL);
       err = -1;
     }
   else
@@ -1694,8 +2303,8 @@ es_skip (estream_t stream, size_t size)
 
 static int
 doreadline (estream_t ES__RESTRICT stream, size_t max_length,
-             char *ES__RESTRICT *ES__RESTRICT line,
-             size_t *ES__RESTRICT line_length)
+            char *ES__RESTRICT *ES__RESTRICT line,
+            size_t *ES__RESTRICT line_length)
 {
   size_t space_left;
   size_t line_size;
@@ -1706,19 +2315,23 @@ doreadline (estream_t ES__RESTRICT stream, size_t max_length,
   unsigned char *data;
   size_t data_len;
   int err;
+  es_syshd_t syshd;
 
   line_new = NULL;
   line_stream = NULL;
   line_stream_cookie = NULL;
 
-  err = es_func_mem_create (&line_stream_cookie, NULL, 0, 0, BUFFER_BLOCK_SIZE,
-                           1, 0, 0, NULL, 0, ES_MEM_REALLOC, ES_MEM_FREE,
-                            O_RDWR);
+  err = func_mem_create (&line_stream_cookie, NULL, 0, 0,
+                         BUFFER_BLOCK_SIZE, 1,
+                         mem_realloc, mem_free,
+                         O_RDWR,
+                         0);
   if (err)
     goto out;
 
-  err = es_create (&line_stream, line_stream_cookie, -1,
-                  estream_functions_mem, O_RDWR);
+  memset (&syshd, 0, sizeof syshd);
+  err = es_create (&line_stream, line_stream_cookie, &syshd,
+                  estream_functions_mem, O_RDWR, 0);
   if (err)
     goto out;
 
@@ -1766,7 +2379,7 @@ doreadline (estream_t ES__RESTRICT stream, size_t max_length,
     goto out;
 
   /* Complete line has been written to line_stream.  */
-  
+
   if ((max_length > 1) && (! line_size))
     {
       stream->intern->indicators.eof = 1;
@@ -1779,7 +2392,7 @@ doreadline (estream_t ES__RESTRICT stream, size_t max_length,
 
   if (! *line)
     {
-      line_new = ES_MEM_ALLOC (line_size + 1);
+      line_new = mem_alloc (line_size + 1);
       if (! line_new)
        {
          err = -1;
@@ -1803,14 +2416,14 @@ doreadline (estream_t ES__RESTRICT stream, size_t max_length,
  out:
 
   if (line_stream)
-    es_destroy (line_stream);
+    do_close (line_stream, 0);
   else if (line_stream_cookie)
     es_func_mem_destroy (line_stream_cookie);
 
   if (err)
     {
       if (! *line)
-       ES_MEM_FREE (line_new);
+       mem_free (line_new);
       stream->intern->indicators.err = 1;
     }
 
@@ -1862,7 +2475,7 @@ static int
 es_get_indicator (estream_t stream, int ind_err, int ind_eof)
 {
   int ret = 0;
-  
+
   if (ind_err)
     ret = stream->intern->indicators.err;
   else if (ind_eof)
@@ -1889,12 +2502,12 @@ es_set_buffering (estream_t ES__RESTRICT stream,
     es_empty (stream);
 
   es_set_indicators (stream, -1, 0);
-  
+
   /* Free old buffer in case that was allocated by this function.  */
   if (stream->intern->deallocate_buffer)
     {
       stream->intern->deallocate_buffer = 0;
-      ES_MEM_FREE (stream->buffer);
+      mem_free (stream->buffer);
       stream->buffer = NULL;
     }
 
@@ -1903,12 +2516,14 @@ es_set_buffering (estream_t ES__RESTRICT stream,
   else
     {
       void *buffer_new;
-      
+
       if (buffer)
        buffer_new = buffer;
       else
        {
-         buffer_new = ES_MEM_ALLOC (size);
+          if (!size)
+            size = BUFSIZ;
+         buffer_new = mem_alloc (size);
          if (! buffer_new)
            {
              err = -1;
@@ -1957,12 +2572,6 @@ es_opaque_ctrl (estream_t ES__RESTRICT stream, void *ES__RESTRICT opaque_new,
 }
 
 
-static int
-es_get_fd (estream_t stream)
-{
-  return stream->intern->fd;
-}
-
 \f
 
 /* API.  */
@@ -1972,75 +2581,98 @@ es_init (void)
 {
   int err;
 
-  err = es_init_do ();
+  err = do_init ();
 
   return err;
 }
 
+
+\f
 estream_t
 es_fopen (const char *ES__RESTRICT path, const char *ES__RESTRICT mode)
 {
-  unsigned int modeflags;
+  unsigned int modeflags, cmode;
   int create_called;
   estream_t stream;
   void *cookie;
   int err;
   int fd;
+  es_syshd_t syshd;
 
   stream = NULL;
   cookie = NULL;
   create_called = 0;
 
-  err = es_convert_mode (mode, &modeflags);
+  err = parse_mode (mode, &modeflags, &cmode);
   if (err)
     goto out;
-  
-  err = es_func_file_create (&cookie, &fd, path, modeflags);
+
+  err = func_file_create (&cookie, &fd, path, modeflags, cmode);
   if (err)
     goto out;
 
+  syshd.type = ES_SYSHD_FD;
+  syshd.u.fd = fd;
+
   create_called = 1;
-  err = es_create (&stream, cookie, fd, estream_functions_file, modeflags);
+  err = es_create (&stream, cookie, &syshd, estream_functions_fd, modeflags, 0);
   if (err)
     goto out;
 
+  if (stream && path)
+    fname_set_internal (stream, path, 1);
+
  out:
-  
+
   if (err && create_called)
-    (*estream_functions_file.func_close) (cookie);
+    (*estream_functions_fd.func_close) (cookie);
 
   return stream;
 }
 
 
+\f
+/* Create a new estream object in memory.  If DATA is not NULL this
+   buffer will be used as the memory buffer; thus after this functions
+   returns with the success the the memory at DATA belongs to the new
+   estream.  The allocated length of DATA is given by DATA_LEN and its
+   used length by DATA_N.  Usually this is malloced buffer; if a
+   static buffer is provided, the caller must pass false for GROW and
+   provide a dummy function for FUNC_FREE.  FUNC_FREE and FUNC_REALLOC
+   allow the caller to provide custom functions for realloc and free
+   to be used by the new estream object.  Note that the realloc
+   function is also used for initial allocation.  If DATA is NULL a
+   buffer is internally allocated; either using internal function or
+   those provide by the caller.  It is an error to provide a realloc
+   function but no free function.  Providing only a free function is
+   allowed as long as GROW is false.  */
 estream_t
-es_mopen (unsigned char *ES__RESTRICT data, size_t data_n, size_t data_len,
+es_mopen (void *ES__RESTRICT data, size_t data_n, size_t data_len,
          unsigned int grow,
          func_realloc_t func_realloc, func_free_t func_free,
          const char *ES__RESTRICT mode)
 {
+  int create_called = 0;
+  estream_t stream = NULL;
+  void *cookie = NULL;
   unsigned int modeflags;
-  int create_called;
-  estream_t stream;
-  void *cookie;
   int err;
+  es_syshd_t syshd;
 
-  cookie = 0;
-  stream = NULL;
-  create_called = 0;
-  
-  err = es_convert_mode (mode, &modeflags);
+  err = parse_mode (mode, &modeflags, NULL);
   if (err)
     goto out;
 
-  err = es_func_mem_create (&cookie, data, data_n, data_len,
-                           BUFFER_BLOCK_SIZE, grow, 0, 0,
-                           NULL, 0, func_realloc, func_free, modeflags);
+  err = func_mem_create (&cookie, data, data_n, data_len,
+                         BUFFER_BLOCK_SIZE, grow,
+                         func_realloc, func_free, modeflags, 0);
   if (err)
     goto out;
-  
+
+  memset (&syshd, 0, sizeof syshd);
   create_called = 1;
-  err = es_create (&stream, cookie, -1, estream_functions_mem, modeflags);
+  err = es_create (&stream, cookie, &syshd,
+                   estream_functions_mem, modeflags, 0);
 
  out:
 
@@ -2051,38 +2683,72 @@ es_mopen (unsigned char *ES__RESTRICT data, size_t data_n, size_t data_len,
 }
 
 
+\f
 estream_t
-es_open_memstream (char **ptr, size_t *size)
+es_fopenmem (size_t memlimit, const char *ES__RESTRICT mode)
 {
   unsigned int modeflags;
-  int create_called;
-  estream_t stream;
-  void *cookie;
-  int err;
+  estream_t stream = NULL;
+  void *cookie = NULL;
+  es_syshd_t syshd;
+
+  /* Memory streams are always read/write.  We use MODE only to get
+     the append flag.  */
+  if (parse_mode (mode, &modeflags, NULL))
+    return NULL;
+  modeflags |= O_RDWR;
+
+  if (func_mem_create (&cookie, NULL, 0, 0,
+                       BUFFER_BLOCK_SIZE, 1,
+                       mem_realloc, mem_free, modeflags,
+                       memlimit))
+    return NULL;
+
+  memset (&syshd, 0, sizeof syshd);
+  if (es_create (&stream, cookie, &syshd, estream_functions_mem, modeflags, 0))
+    (*estream_functions_mem.func_close) (cookie);
 
-  modeflags = O_RDWR;
-  create_called = 0;
-  stream = NULL;
-  cookie = 0;
-  
-  err = es_func_mem_create (&cookie, NULL, 0, 0,
-                           BUFFER_BLOCK_SIZE, 1, 1, 1,
-                           ptr, size, ES_MEM_REALLOC, ES_MEM_FREE, modeflags);
-  if (err)
-    goto out;
-  
-  create_called = 1;
-  err = es_create (&stream, cookie, -1, estream_functions_mem, modeflags);
+  if (stream)
+    stream->intern->func_ioctl = es_func_mem_ioctl;
 
- out:
+  return stream;
+}
 
-  if (err && create_called)
-    (*estream_functions_mem.func_close) (cookie);
+\f
+/* This is the same as es_fopenmem but intializes the memory with a
+   copy of (DATA,DATALEN).  The stream is initally set to the
+   beginning.  If MEMLIMIT is not 0 but shorter than DATALEN it
+   DATALEN will be used as the value for MEMLIMIT.  */
+estream_t
+es_fopenmem_init (size_t memlimit, const char *ES__RESTRICT mode,
+                  const void *data, size_t datalen)
+{
+  estream_t stream;
+
+  if (memlimit && memlimit < datalen)
+    memlimit = datalen;
 
+  stream = es_fopenmem (memlimit, mode);
+  if (stream && data && datalen)
+    {
+      if (es_writen (stream, data, datalen, NULL))
+        {
+          int saveerrno = errno;
+          es_fclose (stream);
+          stream = NULL;
+          _set_errno (saveerrno);
+        }
+      else
+        {
+          es_seek (stream, 0L, SEEK_SET, NULL);
+          es_set_indicators (stream, 0, 0);
+        }
+    }
   return stream;
 }
 
 
+\f
 estream_t
 es_fopencookie (void *ES__RESTRICT cookie,
                const char *ES__RESTRICT mode,
@@ -2091,50 +2757,55 @@ es_fopencookie (void *ES__RESTRICT cookie,
   unsigned int modeflags;
   estream_t stream;
   int err;
+  es_syshd_t syshd;
 
   stream = NULL;
   modeflags = 0;
-  
-  err = es_convert_mode (mode, &modeflags);
+
+  err = parse_mode (mode, &modeflags, NULL);
   if (err)
     goto out;
 
-  err = es_create (&stream, cookie, -1, functions, modeflags);
+  memset (&syshd, 0, sizeof syshd);
+  err = es_create (&stream, cookie, &syshd, functions, modeflags, 0);
   if (err)
     goto out;
 
  out:
-
   return stream;
 }
 
 
+\f
 estream_t
-do_fdopen (int filedes, const char *mode, int no_close)
+do_fdopen (int filedes, const char *mode, int no_close, int with_locked_list)
 {
   unsigned int modeflags;
   int create_called;
   estream_t stream;
   void *cookie;
   int err;
+  es_syshd_t syshd;
 
   stream = NULL;
   cookie = NULL;
   create_called = 0;
 
-  err = es_convert_mode (mode, &modeflags);
+  err = parse_mode (mode, &modeflags, NULL);
   if (err)
     goto out;
 
-  err = es_func_fd_create (&cookie, filedes, modeflags, no_close);
+  err = func_fd_create (&cookie, filedes, modeflags, no_close);
   if (err)
     goto out;
 
+  syshd.type = ES_SYSHD_FD;
+  syshd.u.fd = filedes;
   create_called = 1;
-  err = es_create (&stream, cookie, filedes, estream_functions_fd, modeflags);
+  err = es_create (&stream, cookie, &syshd, estream_functions_fd,
+                   modeflags, with_locked_list);
 
  out:
-
   if (err && create_called)
     (*estream_functions_fd.func_close) (cookie);
 
@@ -2144,42 +2815,47 @@ do_fdopen (int filedes, const char *mode, int no_close)
 estream_t
 es_fdopen (int filedes, const char *mode)
 {
-  return do_fdopen (filedes, mode, 0);
+  return do_fdopen (filedes, mode, 0, 0);
 }
 
 /* A variant of es_fdopen which does not close FILEDES at the end.  */
 estream_t
 es_fdopen_nc (int filedes, const char *mode)
 {
-  return do_fdopen (filedes, mode, 1);
+  return do_fdopen (filedes, mode, 1, 0);
 }
 
 
+\f
 estream_t
-do_fpopen (FILE *fp, const char *mode, int no_close)
+do_fpopen (FILE *fp, const char *mode, int no_close, int with_locked_list)
 {
-  unsigned int modeflags;
+  unsigned int modeflags, cmode;
   int create_called;
   estream_t stream;
   void *cookie;
   int err;
+  es_syshd_t syshd;
 
   stream = NULL;
   cookie = NULL;
   create_called = 0;
 
-  err = es_convert_mode (mode, &modeflags);
+  err = parse_mode (mode, &modeflags, &cmode);
   if (err)
     goto out;
 
-  fflush (fp);
-  err = es_func_fp_create (&cookie, fp, modeflags, no_close);
+  if (fp)
+    fflush (fp);
+  err = func_fp_create (&cookie, fp, modeflags, no_close);
   if (err)
     goto out;
 
+  syshd.type = ES_SYSHD_FD;
+  syshd.u.fd = fp? fileno (fp): -1;
   create_called = 1;
-  err = es_create (&stream, cookie, fileno (fp), estream_functions_fp,
-                   modeflags);
+  err = es_create (&stream, cookie, &syshd, estream_functions_fp,
+                   modeflags, with_locked_list);
 
  out:
 
@@ -2189,7 +2865,7 @@ do_fpopen (FILE *fp, const char *mode, int no_close)
   return stream;
 }
 
-  
+
 /* Create an estream from the stdio stream FP.  This mechanism is
    useful in case the stdio streams have special properties and may
    not be mixed with fd based functions.  This is for example the case
@@ -2201,7 +2877,7 @@ do_fpopen (FILE *fp, const char *mode, int no_close)
 estream_t
 es_fpopen (FILE *fp, const char *mode)
 {
-  return do_fpopen (fp, mode, 0);
+  return do_fpopen (fp, mode, 0, 0);
 }
 
 
@@ -2209,7 +2885,168 @@ es_fpopen (FILE *fp, const char *mode)
 estream_t
 es_fpopen_nc (FILE *fp, const char *mode)
 {
-  return do_fpopen (fp, mode, 1);
+  return do_fpopen (fp, mode, 1, 0);
+}
+
+
+\f
+#ifdef HAVE_W32_SYSTEM
+estream_t
+do_w32open (HANDLE hd, const char *mode,
+            int no_close, int with_locked_list)
+{
+  unsigned int modeflags, cmode;
+  int create_called = 0;
+  estream_t stream = NULL;
+  void *cookie = NULL;
+  int err;
+  es_syshd_t syshd;
+
+  err = parse_mode (mode, &modeflags, &cmode);
+  if (err)
+    goto leave;
+
+  err = es_func_w32_create (&cookie, hd, modeflags, no_close);
+  if (err)
+    goto leave;
+
+  syshd.type = ES_SYSHD_HANDLE;
+  syshd.u.handle = hd;
+  create_called = 1;
+  err = es_create (&stream, cookie, &syshd, estream_functions_w32,
+                   modeflags, with_locked_list);
+
+ leave:
+  if (err && create_called)
+    (*estream_functions_w32.func_close) (cookie);
+
+  return stream;
+}
+#endif /*HAVE_W32_SYSTEM*/
+
+static estream_t
+do_sysopen (es_syshd_t *syshd, const char *mode, int no_close)
+{
+  estream_t stream;
+
+  switch (syshd->type)
+    {
+    case ES_SYSHD_FD:
+    case ES_SYSHD_SOCK:
+      stream = do_fdopen (syshd->u.fd, mode, no_close, 0);
+      break;
+
+#ifdef HAVE_W32_SYSTEM
+    case ES_SYSHD_HANDLE:
+      stream = do_w32open (syshd->u.handle, mode, no_close, 0);
+      break;
+#endif
+
+    /* FIXME: Support RVIDs under Wince?  */
+
+    default:
+      _set_errno (EINVAL);
+      stream = NULL;
+    }
+  return stream;
+}
+
+/* On POSIX systems this function is an alias for es_fdopen.  Under
+   Windows it uses the bare W32 API and thus a HANDLE instead of a
+   file descriptor.  */
+estream_t
+es_sysopen (es_syshd_t *syshd, const char *mode)
+{
+  return do_sysopen (syshd, mode, 0);
+}
+
+/* Same as es_sysopen but the handle/fd will not be closed by
+   es_fclose.  */
+estream_t
+es_sysopen_nc (es_syshd_t *syshd, const char *mode)
+{
+  return do_sysopen (syshd, mode, 1);
+}
+
+
+
+/* Set custom standard descriptors to be used for stdin, stdout and
+   stderr.  This function needs to be called before any of the
+   standard streams are accessed.  */
+void
+_es_set_std_fd (int no, int fd)
+{
+  /* fprintf (stderr, "es_set_std_fd(%d, %d)\n", no, fd); */
+  ESTREAM_LIST_LOCK;
+  if (no >= 0 && no < 3 && !custom_std_fds_valid[no])
+    {
+      custom_std_fds[no] = fd;
+      custom_std_fds_valid[no] = 1;
+    }
+  ESTREAM_LIST_UNLOCK;
+}
+
+
+/* Return the stream used for stdin, stdout or stderr.  */
+estream_t
+_es_get_std_stream (int fd)
+{
+  estream_list_t list_obj;
+  estream_t stream = NULL;
+
+  fd %= 3; /* We only allow 0, 1 or 2 but we don't want to return an error. */
+  ESTREAM_LIST_LOCK;
+  for (list_obj = estream_list; list_obj; list_obj = list_obj->next)
+    if (list_obj->stream && list_obj->stream->intern->is_stdstream
+        && list_obj->stream->intern->stdstream_fd == fd)
+      {
+       stream = list_obj->stream;
+       break;
+      }
+  if (!stream)
+    {
+      /* Standard stream not yet created.  We first try to create them
+         from registered file descriptors.  */
+      if (!fd && custom_std_fds_valid[0])
+        stream = do_fdopen (custom_std_fds[0], "r", 1, 1);
+      else if (fd == 1 && custom_std_fds_valid[1])
+        stream = do_fdopen (custom_std_fds[1], "a", 1, 1);
+      else if (custom_std_fds_valid[2])
+        stream = do_fdopen (custom_std_fds[2], "a", 1, 1);
+
+      if (!stream)
+        {
+          /* Second try is to use the standard C streams.  */
+          if (!fd)
+            stream = do_fpopen (stdin, "r", 1, 1);
+          else if (fd == 1)
+            stream = do_fpopen (stdout, "a", 1, 1);
+          else
+            stream = do_fpopen (stderr, "a", 1, 1);
+        }
+
+      if (!stream)
+        {
+          /* Last try: Create a bit bucket.  */
+          stream = do_fpopen (NULL, fd? "a":"r", 0, 1);
+          if (!stream)
+            {
+              fprintf (stderr, "fatal: error creating a dummy estream"
+                       " for %d: %s\n", fd, strerror (errno));
+              abort();
+            }
+        }
+
+      stream->intern->is_stdstream = 1;
+      stream->intern->stdstream_fd = fd;
+      if (fd == 2)
+        es_set_buffering (stream, NULL, _IOLBF, 0);
+      fname_set_internal (stream,
+                          fd == 0? "[stdin]" :
+                          fd == 1? "[stdout]" : "[stderr]", 0);
+    }
+  ESTREAM_LIST_UNLOCK;
+  return stream;
 }
 
 
@@ -2221,69 +3058,200 @@ es_freopen (const char *ES__RESTRICT path, const char *ES__RESTRICT mode,
 
   if (path)
     {
-      unsigned int modeflags;
+      unsigned int modeflags, cmode;
       int create_called;
       void *cookie;
       int fd;
+      es_syshd_t syshd;
+
+      cookie = NULL;
+      create_called = 0;
+
+      ESTREAM_LOCK (stream);
+
+      es_deinitialize (stream);
+
+      err = parse_mode (mode, &modeflags, &cmode);
+      if (err)
+       goto leave;
+
+      err = func_file_create (&cookie, &fd, path, modeflags, cmode);
+      if (err)
+       goto leave;
+
+      syshd.type = ES_SYSHD_FD;
+      syshd.u.fd = fd;
+      create_called = 1;
+      es_initialize (stream, cookie, &syshd, estream_functions_fd, modeflags);
+
+    leave:
+
+      if (err)
+       {
+         if (create_called)
+           es_func_fd_destroy (cookie);
+
+         do_close (stream, 0);
+         stream = NULL;
+       }
+      else
+        {
+          if (stream && path)
+            fname_set_internal (stream, path, 1);
+          ESTREAM_UNLOCK (stream);
+        }
+    }
+  else
+    {
+      /* FIXME?  We don't support re-opening at the moment.  */
+      _set_errno (EINVAL);
+      es_deinitialize (stream);
+      do_close (stream, 0);
+      stream = NULL;
+    }
+
+  return stream;
+}
+
+
+int
+es_fclose (estream_t stream)
+{
+  int err;
+
+  err = do_close (stream, 0);
+
+  return err;
+}
+
+
+/* This is a special version of es_fclose which can be used with
+   es_fopenmem to return the memory buffer.  This is feature is useful
+   to write to a memory buffer using estream.  Note that the function
+   does not close the stream if the stream does not support snatching
+   the buffer.  On error NULL is stored at R_BUFFER.  Note that if no
+   write operation has happened, NULL may also be stored at BUFFER on
+   success.  The caller needs to release the returned memory using
+   es_free.  */
+int
+es_fclose_snatch (estream_t stream, void **r_buffer, size_t *r_buflen)
+{
+  int err;
 
-      cookie = NULL;
-      create_called = 0;
-      
-      ESTREAM_LOCK (stream);
+  /* Note: There is no need to lock the stream in a close call.  The
+     object will be destroyed after the close and thus any other
+     contender for the lock would work on a closed stream.  */
 
-      es_deinitialize (stream);
+  if (r_buffer)
+    {
+      cookie_ioctl_function_t func_ioctl = stream->intern->func_ioctl;
+      size_t buflen;
 
-      err = es_convert_mode (mode, &modeflags);
-      if (err)
-       goto leave;
-      
-      err = es_func_file_create (&cookie, &fd, path, modeflags);
-      if (err)
-       goto leave;
+      *r_buffer = NULL;
 
-      create_called = 1;
-      es_initialize (stream, cookie, fd, estream_functions_file, modeflags);
+      if (!func_ioctl)
+        {
+          _set_errno (EOPNOTSUPP);
+          err = -1;
+          goto leave;
+        }
 
-    leave:
+      if (stream->flags.writing)
+        {
+          err = es_flush (stream);
+          if (err)
+            goto leave;
+          stream->flags.writing = 0;
+        }
 
+      err = func_ioctl (stream->intern->cookie, COOKIE_IOCTL_SNATCH_BUFFER,
+                        r_buffer, &buflen);
       if (err)
-       {
-         if (create_called)
-           es_func_fd_destroy (cookie);
-      
-         es_destroy (stream);
-         stream = NULL;
-       }
-      else
-       ESTREAM_UNLOCK (stream);
+        goto leave;
+      if (r_buflen)
+        *r_buflen = buflen;
     }
-  else
+
+  err = do_close (stream, 0);
+
+ leave:
+  if (err && r_buffer)
     {
-      /* FIXME?  We don't support re-opening at the moment.  */
-      errno = EINVAL;
-      es_deinitialize (stream);
-      es_destroy (stream);
-      stream = NULL;
+      mem_free (*r_buffer);
+      *r_buffer = NULL;
     }
-
-  return stream;
+  return err;
 }
 
 
+/* Register or unregister a close notification function for STREAM.
+   FNC is the function to call and FNC_VALUE the value passed as
+   second argument.  To register the notification the value for MODE
+   must be 1.  If mode is 0 the function tries to remove or disable an
+   already registered notification; for this to work the value of FNC
+   and FNC_VALUE must be the same as with the registration and
+   FNC_VALUE must be a unique value.  No error will be returned if
+   MODE is 0.
+
+   FIXME: I think the next comment is not anymore correct:
+   Unregister should only be used in the error case because it may not
+   be able to remove memory internally allocated for the onclose
+   handler.
+
+   FIXME: Unregister is not thread safe.
+
+   The notification will be called right before the stream is closed.
+   It may not call any estream function for STREAM, neither direct nor
+   indirectly. */
 int
-es_fclose (estream_t stream)
+es_onclose (estream_t stream, int mode,
+            void (*fnc) (estream_t, void*), void *fnc_value)
 {
   int err;
 
-  err = es_destroy (stream);
+  ESTREAM_LOCK (stream);
+  err = do_onclose (stream, mode, fnc, fnc_value);
+  ESTREAM_UNLOCK (stream);
 
   return err;
 }
 
+
 int
 es_fileno_unlocked (estream_t stream)
 {
-  return es_get_fd (stream);
+  es_syshd_t syshd;
+
+  if (es_syshd (stream, &syshd))
+    return -1;
+  switch (syshd.type)
+    {
+    case ES_SYSHD_FD:   return syshd.u.fd;
+    case ES_SYSHD_SOCK: return syshd.u.sock;
+    default:
+      _set_errno (EINVAL);
+      return -1;
+    }
+}
+
+
+/* Return the handle of a stream which has been opened by es_sysopen.
+   The caller needs to pass a structure which will be filled with the
+   sys handle.  Return 0 on success or true on error and sets errno.
+   This is the unlocked version.  */
+int
+es_syshd_unlocked (estream_t stream, es_syshd_t *syshd)
+{
+  if (!stream || !syshd || stream->intern->syshd.type == ES_SYSHD_NONE)
+    {
+      if (syshd)
+        syshd->type = ES_SYSHD_NONE;
+      _set_errno (EINVAL);
+      return -1;
+    }
+
+  *syshd = stream->intern->syshd;
+  return 0;
 }
 
 
@@ -2321,6 +3289,23 @@ es_fileno (estream_t stream)
 }
 
 
+/* Return the handle of a stream which has been opened by es_sysopen.
+   The caller needs to pass a structure which will be filled with the
+   sys handle.  Return 0 on success or true on error and sets errno.
+   This is the unlocked version.  */
+int
+es_syshd (estream_t stream, es_syshd_t *syshd)
+{
+  int ret;
+
+  ESTREAM_LOCK (stream);
+  ret = es_syshd_unlocked (stream, syshd);
+  ESTREAM_UNLOCK (stream);
+
+  return ret;
+}
+
+
 int
 es_feof_unlocked (estream_t stream)
 {
@@ -2377,26 +3362,49 @@ es_clearerr (estream_t stream)
 }
 
 
+static int
+do_fflush (estream_t stream)
+{
+  int err;
+
+  if (stream->flags.writing)
+    err = es_flush (stream);
+  else
+    {
+      es_empty (stream);
+      err = 0;
+    }
+
+  return err;
+}
+
+
 int
 es_fflush (estream_t stream)
 {
   int err;
-  
+
   if (stream)
     {
       ESTREAM_LOCK (stream);
-      if (stream->flags.writing)
-       err = es_flush (stream);
-      else
-       {
-         es_empty (stream);
-         err = 0;
-       }
+      err = do_fflush (stream);
       ESTREAM_UNLOCK (stream);
     }
   else
-    err = es_list_iterate (es_fflush);
+    {
+      estream_list_t item;
 
+      err = 0;
+      ESTREAM_LIST_LOCK;
+      for (item = estream_list; item; item = item->next)
+        if (item->stream)
+          {
+            ESTREAM_LOCK (item->stream);
+            err |= do_fflush (item->stream);
+            ESTREAM_UNLOCK (item->stream);
+          }
+      ESTREAM_LIST_UNLOCK;
+    }
   return err ? EOF : 0;
 }
 
@@ -2418,7 +3426,7 @@ int
 es_fseeko (estream_t stream, off_t offset, int whence)
 {
   int err;
-  
+
   ESTREAM_LOCK (stream);
   err = es_seek (stream, offset, whence, NULL);
   ESTREAM_UNLOCK (stream);
@@ -2431,7 +3439,7 @@ long int
 es_ftell (estream_t stream)
 {
   long int ret;
-  
+
   ESTREAM_LOCK (stream);
   ret = es_offset_calculate (stream);
   ESTREAM_UNLOCK (stream);
@@ -2492,7 +3500,7 @@ int
 es_fgetc (estream_t stream)
 {
   int ret;
-  
+
   ESTREAM_LOCK (stream);
   ret = es_getc_unlocked (stream);
   ESTREAM_UNLOCK (stream);
@@ -2505,7 +3513,7 @@ int
 es_fputc (int c, estream_t stream)
 {
   int ret;
-  
+
   ESTREAM_LOCK (stream);
   ret = es_putc_unlocked (c, stream);
   ESTREAM_UNLOCK (stream);
@@ -2573,12 +3581,11 @@ es_fread (void *ES__RESTRICT ptr, size_t size, size_t nitems,
          estream_t ES__RESTRICT stream)
 {
   size_t ret, bytes;
-  int err;
 
   if (size * nitems)
     {
       ESTREAM_LOCK (stream);
-      err = es_readn (stream, ptr, size * nitems, &bytes);
+      es_readn (stream, ptr, size * nitems, &bytes);
       ESTREAM_UNLOCK (stream);
 
       ret = bytes / size;
@@ -2595,12 +3602,11 @@ es_fwrite (const void *ES__RESTRICT ptr, size_t size, size_t nitems,
           estream_t ES__RESTRICT stream)
 {
   size_t ret, bytes;
-  int err;
 
   if (size * nitems)
     {
       ESTREAM_LOCK (stream);
-      err = es_writen (stream, ptr, size * nitems, &bytes);
+      es_writen (stream, ptr, size * nitems, &bytes);
       ESTREAM_UNLOCK (stream);
 
       ret = bytes / size;
@@ -2613,26 +3619,46 @@ es_fwrite (const void *ES__RESTRICT ptr, size_t size, size_t nitems,
 
 
 char *
-es_fgets (char *ES__RESTRICT s, int n, estream_t ES__RESTRICT stream)
+es_fgets (char *ES__RESTRICT buffer, int length, estream_t ES__RESTRICT stream)
 {
-  char *ret = NULL;
-  
-  if (n)
+  unsigned char *s = (unsigned char*)buffer;
+  int c;
+
+  if (!length)
+    return NULL;
+
+  c = EOF;
+  ESTREAM_LOCK (stream);
+  while (length > 1 && (c = es_getc_unlocked (stream)) != EOF && c != '\n')
     {
-      int err;
-      
-      ESTREAM_LOCK (stream);
-      err = doreadline (stream, n, &s, NULL);
-      ESTREAM_UNLOCK (stream);
-      if (! err)
-       ret = s;
+      *s++ = c;
+      length--;
     }
-  
-  return ret;
+  ESTREAM_UNLOCK (stream);
+
+  if (c == EOF && s == (unsigned char*)buffer)
+    return NULL; /* Nothing read.  */
+
+  if (c != EOF && length > 1)
+    *s++ = c;
+
+  *s = 0;
+  return buffer;
 }
 
 
 int
+es_fputs_unlocked (const char *ES__RESTRICT s, estream_t ES__RESTRICT stream)
+{
+  size_t length;
+  int err;
+
+  length = strlen (s);
+  err = es_writen (stream, s, length, NULL);
+  return err ? EOF : 0;
+}
+
+int
 es_fputs (const char *ES__RESTRICT s, estream_t ES__RESTRICT stream)
 {
   size_t length;
@@ -2664,14 +3690,14 @@ es_getline (char *ES__RESTRICT *ES__RESTRICT lineptr, size_t *ES__RESTRICT n,
   if (*n)
     {
       /* Caller wants us to use his buffer.  */
-      
+
       if (*n < (line_n + 1))
        {
          /* Provided buffer is too small -> resize.  */
 
          void *p;
 
-         p = ES_MEM_REALLOC (*lineptr, line_n + 1);
+         p = mem_realloc (*lineptr, line_n + 1);
          if (! p)
            err = -1;
          else
@@ -2687,7 +3713,7 @@ es_getline (char *ES__RESTRICT *ES__RESTRICT lineptr, size_t *ES__RESTRICT n,
          if (*n != line_n)
            *n = line_n;
        }
-      ES_MEM_FREE (line);
+      mem_free (line);
     }
   else
     {
@@ -2698,7 +3724,7 @@ es_getline (char *ES__RESTRICT *ES__RESTRICT lineptr, size_t *ES__RESTRICT n,
 
  out:
 
-  return err ? err : line_n;
+  return err ? err : (ssize_t)line_n;
 }
 
 
@@ -2708,7 +3734,7 @@ es_getline (char *ES__RESTRICT *ES__RESTRICT lineptr, size_t *ES__RESTRICT n,
    considered a byte stream ending in a LF.
 
    If MAX_LENGTH is not NULL, it shall point to a value with the
-   maximum allowed allocation.  
+   maximum allowed allocation.
 
    Returns the length of the line. EOF is indicated by a line of
    length zero. A truncated line is indicated my setting the value at
@@ -2732,7 +3758,7 @@ es_getline (char *ES__RESTRICT *ES__RESTRICT lineptr, size_t *ES__RESTRICT n,
    released using es_free.
  */
 ssize_t
-es_read_line (estream_t stream, 
+es_read_line (estream_t stream,
               char **addr_of_buffer, size_t *length_of_buffer,
               size_t *max_length)
 {
@@ -2744,10 +3770,10 @@ es_read_line (estream_t stream,
   char *p;
 
   if (!buffer)
-    { 
+    {
       /* No buffer given - allocate a new one. */
       length = 256;
-      buffer = ES_MEM_ALLOC (length);
+      buffer = mem_alloc (length);
       *addr_of_buffer = buffer;
       if (!buffer)
         {
@@ -2761,9 +3787,9 @@ es_read_line (estream_t stream,
 
   if (length < 4)
     {
-      /* This should never happen. If it does, the fucntion has been
+      /* This should never happen. If it does, the function has been
          called with wrong arguments. */
-      errno = EINVAL;
+      _set_errno (EINVAL);
       return -1;
     }
   length -= 3; /* Reserve 3 bytes for CR,LF,EOL. */
@@ -2773,9 +3799,9 @@ es_read_line (estream_t stream,
   while  ((c = es_getc_unlocked (stream)) != EOF)
     {
       if (nbytes == length)
-        { 
+        {
           /* Enlarge the buffer. */
-          if (maxlen && length > maxlen) 
+          if (maxlen && length > maxlen)
             {
               /* We are beyond our limit: Skip the rest of the line. */
               while (c != '\n' && (c=es_getc_unlocked (stream)) != EOF)
@@ -2788,19 +3814,21 @@ es_read_line (estream_t stream,
             }
           length += 3; /* Adjust for the reserved bytes. */
           length += length < 1024? 256 : 1024;
-          *addr_of_buffer = ES_MEM_REALLOC (buffer, length);
+          *addr_of_buffer = mem_realloc (buffer, length);
           if (!*addr_of_buffer)
             {
               int save_errno = errno;
-              ES_MEM_FREE (buffer); 
-              *length_of_buffer = *max_length = 0;
+              mem_free (buffer);
+              *length_of_buffer = 0;
+              if (max_length)
+                *max_length = 0;
               ESTREAM_UNLOCK (stream);
-              errno = save_errno;
+              _set_errno (save_errno);
               return -1;
             }
           buffer = *addr_of_buffer;
           *length_of_buffer = length;
-          length -= 3; 
+          length -= 3;
           p = buffer + nbytes;
        }
       *p++ = c;
@@ -2820,8 +3848,16 @@ es_read_line (estream_t stream,
 void
 es_free (void *a)
 {
-  if (a)
-    ES_MEM_FREE (a);
+  mem_free (a);
+}
+
+
+int
+es_vfprintf_unlocked (estream_t ES__RESTRICT stream,
+                      const char *ES__RESTRICT format,
+                      va_list ap)
+{
+  return es_print (stream, format, ap);
 }
 
 
@@ -2830,7 +3866,7 @@ es_vfprintf (estream_t ES__RESTRICT stream, const char *ES__RESTRICT format,
             va_list ap)
 {
   int ret;
-  
+
   ESTREAM_LOCK (stream);
   ret = es_print (stream, format, ap);
   ESTREAM_UNLOCK (stream);
@@ -2839,12 +3875,12 @@ es_vfprintf (estream_t ES__RESTRICT stream, const char *ES__RESTRICT format,
 }
 
 
-static int
+int
 es_fprintf_unlocked (estream_t ES__RESTRICT stream,
-           const char *ES__RESTRICT format, ...)
+                     const char *ES__RESTRICT format, ...)
 {
   int ret;
-  
+
   va_list ap;
   va_start (ap, format);
   ret = es_print (stream, format, ap);
@@ -2859,7 +3895,38 @@ es_fprintf (estream_t ES__RESTRICT stream,
            const char *ES__RESTRICT format, ...)
 {
   int ret;
-  
+
+  va_list ap;
+  va_start (ap, format);
+  ESTREAM_LOCK (stream);
+  ret = es_print (stream, format, ap);
+  ESTREAM_UNLOCK (stream);
+  va_end (ap);
+
+  return ret;
+}
+
+
+int
+es_printf_unlocked (const char *ES__RESTRICT format, ...)
+{
+  int ret;
+
+  va_list ap;
+  va_start (ap, format);
+  ret = es_print (es_stdout, format, ap);
+  va_end (ap);
+
+  return ret;
+}
+
+
+int
+es_printf (const char *ES__RESTRICT format, ...)
+{
+  int ret;
+  estream_t stream = es_stdout;
+
   va_list ap;
   va_start (ap, format);
   ESTREAM_LOCK (stream);
@@ -2870,16 +3937,131 @@ es_fprintf (estream_t ES__RESTRICT stream,
   return ret;
 }
 
+
+/* A variant of asprintf.  The function returns the allocated buffer
+   or NULL on error; ERRNO is set in the error case.  The caller
+   should use es_free to release the buffer.  This function actually
+   belongs into estream-printf but we put it here as a convenience
+   and because es_free is required anyway.  */
+char *
+es_asprintf (const char *ES__RESTRICT format, ...)
+{
+  int rc;
+  va_list ap;
+  char *buf;
+
+  va_start (ap, format);
+  rc = estream_vasprintf (&buf, format, ap);
+  va_end (ap);
+  if (rc < 0)
+    return NULL;
+  return buf;
+}
+
+
+/* A variant of vasprintf.  The function returns the allocated buffer
+   or NULL on error; ERRNO is set in the error case.  The caller
+   should use es_free to release the buffer.  This function actually
+   belongs into estream-printf but we put it here as a convenience
+   and because es_free is required anyway.  */
+char *
+es_vasprintf (const char *ES__RESTRICT format, va_list ap)
+{
+  int rc;
+  char *buf;
+
+  rc = estream_vasprintf (&buf, format, ap);
+  if (rc < 0)
+    return NULL;
+  return buf;
+}
+
+
 static int
 tmpfd (void)
 {
+#ifdef HAVE_W32_SYSTEM
+  int attempts, n;
+#ifdef HAVE_W32CE_SYSTEM
+  wchar_t buffer[MAX_PATH+9+12+1];
+# define mystrlen(a) wcslen (a)
+  wchar_t *name, *p;
+#else
+  char buffer[MAX_PATH+9+12+1];
+# define mystrlen(a) strlen (a)
+  char *name, *p;
+#endif
+  HANDLE file;
+  int pid = GetCurrentProcessId ();
+  unsigned int value;
+  int i;
+
+  n = GetTempPath (MAX_PATH+1, buffer);
+  if (!n || n > MAX_PATH || mystrlen (buffer) > MAX_PATH)
+    {
+      _set_errno (ENOENT);
+      return -1;
+    }
+  p = buffer + mystrlen (buffer);
+#ifdef HAVE_W32CE_SYSTEM
+  wcscpy (p, L"_estream");
+#else
+  strcpy (p, "_estream");
+#endif
+  p += 8;
+  /* We try to create the directory but don't care about an error as
+     it may already exist and the CreateFile would throw an error
+     anyway.  */
+  CreateDirectory (buffer, NULL);
+  *p++ = '\\';
+  name = p;
+  for (attempts=0; attempts < 10; attempts++)
+    {
+      p = name;
+      value = (GetTickCount () ^ ((pid<<16) & 0xffff0000));
+      for (i=0; i < 8; i++)
+        {
+          *p++ = tohex (((value >> 28) & 0x0f));
+          value <<= 4;
+        }
+#ifdef HAVE_W32CE_SYSTEM
+      wcscpy (p, L".tmp");
+#else
+      strcpy (p, ".tmp");
+#endif
+      file = CreateFile (buffer,
+                         GENERIC_READ | GENERIC_WRITE,
+                         0,
+                         NULL,
+                         CREATE_NEW,
+                         FILE_ATTRIBUTE_TEMPORARY | FILE_FLAG_DELETE_ON_CLOSE,
+                         NULL);
+      if (file != INVALID_HANDLE_VALUE)
+        {
+#ifdef HAVE_W32CE_SYSTEM
+          int fd = (int)file;
+#else
+          int fd = _open_osfhandle ((long)file, 0);
+          if (fd == -1)
+            {
+              CloseHandle (file);
+              return -1;
+            }
+#endif
+          return fd;
+        }
+      Sleep (1); /* One ms as this is the granularity of GetTickCount.  */
+    }
+  _set_errno (ENOENT);
+  return -1;
+#else /*!HAVE_W32_SYSTEM*/
   FILE *fp;
   int fp_fd;
   int fd;
 
   fp = NULL;
   fd = -1;
-  
+
   fp = tmpfile ();
   if (! fp)
     goto out;
@@ -2893,6 +4075,7 @@ tmpfd (void)
     fclose (fp);
 
   return fd;
+#endif /*!HAVE_W32_SYSTEM*/
 }
 
 estream_t
@@ -2904,12 +4087,13 @@ es_tmpfile (void)
   void *cookie;
   int err;
   int fd;
+  es_syshd_t syshd;
 
   create_called = 0;
   stream = NULL;
   modeflags = O_RDWR | O_TRUNC | O_CREAT;
   cookie = NULL;
-  
+
   fd = tmpfd ();
   if (fd == -1)
     {
@@ -2917,15 +4101,16 @@ es_tmpfile (void)
       goto out;
     }
 
-  err = es_func_fd_create (&cookie, fd, modeflags, 0);
+  err = func_fd_create (&cookie, fd, modeflags, 0);
   if (err)
     goto out;
 
+  syshd.type = ES_SYSHD_FD;
+  syshd.u.fd = fd;
   create_called = 1;
-  err = es_create (&stream, cookie, fd, estream_functions_fd, modeflags);
+  err = es_create (&stream, cookie, &syshd, estream_functions_fd, modeflags, 0);
 
  out:
-
   if (err)
     {
       if (create_called)
@@ -2934,7 +4119,7 @@ es_tmpfile (void)
        close (fd);
       stream = NULL;
     }
-  
+
   return stream;
 }
 
@@ -2944,9 +4129,9 @@ es_setvbuf (estream_t ES__RESTRICT stream,
            char *ES__RESTRICT buf, int type, size_t size)
 {
   int err;
-  
-  if (((type == _IOFBF) || (type == _IOLBF) || (type == _IONBF))
-      && (! ((! size) && (type != _IONBF))))
+
+  if ((type == _IOFBF || type == _IOLBF || type == _IONBF)
+      && (!buf || size || type == _IONBF))
     {
       ESTREAM_LOCK (stream);
       err = es_set_buffering (stream, buf, type, size);
@@ -2954,7 +4139,7 @@ es_setvbuf (estream_t ES__RESTRICT stream,
     }
   else
     {
-      errno = EINVAL;
+      _set_errno (EINVAL);
       err = -1;
     }
 
@@ -2970,6 +4155,39 @@ es_setbuf (estream_t ES__RESTRICT stream, char *ES__RESTRICT buf)
   ESTREAM_UNLOCK (stream);
 }
 
+
+/* Put a stream into binary mode.  This is only needed for the
+   standard streams if they are to be used in a binary way.  On Unix
+   systems it is never needed but MSDOS based systems require such a
+   call.  It needs to be called before any I/O is done on STREAM.  */
+void
+es_set_binary (estream_t stream)
+{
+  ESTREAM_LOCK (stream);
+  if (!(stream->intern->modeflags & O_BINARY))
+    {
+      stream->intern->modeflags |= O_BINARY;
+#ifdef HAVE_DOSISH_SYSTEM
+      if (stream->intern->func_read == es_func_fd_read)
+        {
+          estream_cookie_fd_t fd_cookie = stream->intern->cookie;
+
+          if (!IS_INVALID_FD (fd_cookie->fd))
+            setmode (fd_cookie->fd, O_BINARY);
+        }
+      else if (stream->intern->func_read == es_func_fp_read)
+        {
+          estream_cookie_fp_t fp_cookie = stream->intern->cookie;
+
+          if (fp_cookie->fp)
+            setmode (fileno (fp_cookie->fp), O_BINARY);
+        }
+#endif
+    }
+  ESTREAM_UNLOCK (stream);
+}
+
+
 void
 es_opaque_set (estream_t stream, void *opaque)
 {
@@ -2983,7 +4201,7 @@ void *
 es_opaque_get (estream_t stream)
 {
   void *opaque;
-  
+
   ESTREAM_LOCK (stream);
   es_opaque_ctrl (stream, NULL, &opaque);
   ESTREAM_UNLOCK (stream);
@@ -2991,15 +4209,77 @@ es_opaque_get (estream_t stream)
   return opaque;
 }
 
+
+static void
+fname_set_internal (estream_t stream, const char *fname, int quote)
+{
+  if (stream->intern->printable_fname
+      && !stream->intern->printable_fname_inuse)
+    {
+      mem_free (stream->intern->printable_fname);
+      stream->intern->printable_fname = NULL;
+    }
+  if (stream->intern->printable_fname)
+    return; /* Can't change because it is in use.  */
+
+  if (*fname != '[')
+    quote = 0;
+  else
+    quote = !!quote;
+
+  stream->intern->printable_fname = mem_alloc (strlen (fname) + quote + 1);
+  if (fname)
+    {
+      if (quote)
+        stream->intern->printable_fname[0] = '\\';
+      strcpy (stream->intern->printable_fname+quote, fname);
+    }
+}
+
+
+/* Set the filename attribute of STREAM.  There is no error return.
+   as long as STREAM is valid.  This function is called internally by
+   functions which open a filename.  */
+void
+es_fname_set (estream_t stream, const char *fname)
+{
+  if (fname)
+    {
+      ESTREAM_LOCK (stream);
+      fname_set_internal (stream, fname, 1);
+      ESTREAM_UNLOCK (stream);
+    }
+}
+
+
+/* Return the filename attribute of STREAM.  In case no filename has
+   been set, "[?]" will be returned.  The returned file name is valid
+   as long as STREAM is valid.  */
+const char *
+es_fname_get (estream_t stream)
+{
+  const char *fname;
+
+  ESTREAM_LOCK (stream);
+  fname = stream->intern->printable_fname;
+  if (fname)
+    stream->intern->printable_fname_inuse = 1;
+  ESTREAM_UNLOCK (stream);
+  if (!fname)
+    fname = "[?]";
+  return fname;
+}
+
+
 /* Print a BUFFER to STREAM while replacing all control characters and
    the characters in DELIMITERS by standard C escape sequences.
    Returns 0 on success or -1 on error.  If BYTES_WRITTEN is not NULL
    the number of bytes actually written are stored at this
    address.  */
-int 
+int
 es_write_sanitized (estream_t ES__RESTRICT stream,
                     const void * ES__RESTRICT buffer, size_t length,
-                    const char * delimiters, 
+                    const char * delimiters,
                     size_t * ES__RESTRICT bytes_written)
 {
   const unsigned char *p = buffer;
@@ -3009,9 +4289,9 @@ es_write_sanitized (estream_t ES__RESTRICT stream,
   ESTREAM_LOCK (stream);
   for (; length; length--, p++, count++)
     {
-      if (*p < 0x20 
-          || (*p >= 0x7f && *p < 0xa0)
-          || (delimiters 
+      if (*p < 0x20
+          || *p == 0x7f
+          || (delimiters
               && (strchr (delimiters, *p) || *p == '\\')))
         {
           es_putc_unlocked ('\\', stream);
@@ -3081,6 +4361,8 @@ es_write_hexstring (estream_t ES__RESTRICT stream,
   const unsigned char *s;
   size_t count = 0;
 
+  (void)reserved;
+
 #define tohex(n) ((n) < 10 ? ((n) + '0') : (((n) - 10) + 'A'))
 
   if (!length)
@@ -3111,19 +4393,19 @@ es_write_hexstring (estream_t ES__RESTRICT stream,
 #ifdef GNUPG_MAJOR_VERSION
 /* Special estream function to print an UTF8 string in the native
    encoding.  The interface is the same as es_write_sanitized, however
-   only one delimiter may be supported. 
+   only one delimiter may be supported.
 
    THIS IS NOT A STANDARD ESTREAM FUNCTION AND ONLY USED BY GNUPG!. */
 int
 es_write_sanitized_utf8_buffer (estream_t stream,
-                                const void *buffer, size_t length, 
+                                const void *buffer, size_t length,
                                 const char *delimiters, size_t *bytes_written)
 {
   const char *p = buffer;
   size_t i;
 
   /* We can handle plain ascii simpler, so check for it first. */
-  for (i=0; i < length; i++ ) 
+  for (i=0; i < length; i++ )
     {
       if ( (p[i] & 0x80) )
         break;
@@ -3140,7 +4422,7 @@ es_write_sanitized_utf8_buffer (estream_t stream,
         *bytes_written = strlen (buf);
       ret = es_fputs (buf, stream);
       xfree (buf);
-      return i;
+      return ret == EOF? ret : (int)i;
     }
   else
     return es_write_sanitized (stream, p, length, delimiters, bytes_written);