w32: Add icons and version information.
[gnupg.git] / common / estream.c
index af7da70..79e3efb 100644 (file)
@@ -1,5 +1,5 @@
 /* estream.c - Extended Stream I/O Library
 /* estream.c - Extended Stream I/O Library
- * Copyright (C) 2004, 2005, 2006, 2007, 2009, 2010 g10 Code GmbH
+ * Copyright (C) 2004, 2005, 2006, 2007, 2009, 2010, 2011 g10 Code GmbH
  *
  * This file is part of Libestream.
  *
  *
  * This file is part of Libestream.
  *
@@ -38,7 +38,7 @@
  *    products derived from this software without specific prior
  *    written permission.
  *
  *    products derived from this software without specific prior
  *    written permission.
  *
- * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * 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,
  * 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,
 # include <gpg-error.h> /* ERRNO replacement.  */
 #endif
 
 # 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
 
 #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.  */
 #endif
 
 /* This is for the special hack to use estream.c in GnuPG.  */
@@ -116,12 +116,31 @@ void *memrchr (const void *block, int c, size_t size);
 #define O_BINARY 0
 #endif
 
 #define O_BINARY 0
 #endif
 
+#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
+
+
 #ifdef HAVE_W32CE_SYSTEM
 # define _set_errno(a)  gpg_err_set_errno ((a))
 #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
 
 #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
+# define IS_INVALID_FD(a)    ((a) == -1)
+#endif
+
 
 /* Generally used types.  */
 
 
 /* Generally used types.  */
 
@@ -140,7 +159,7 @@ typedef void (*func_free_t) (void *mem);
 
 /* Locking.  */
 
 
 /* Locking.  */
 
-#ifdef HAVE_PTH
+#ifdef HAVE_NPTH
 
 typedef pth_mutex_t estream_mutex_t;
 # define ESTREAM_MUTEX_INITIALIZER PTH_MUTEX_INIT
 
 typedef pth_mutex_t estream_mutex_t;
 # define ESTREAM_MUTEX_INITIALIZER PTH_MUTEX_INIT
@@ -178,20 +197,38 @@ dummy_mutex_call_int (estream_mutex_t mutex)
 
 /* Primitive system I/O.  */
 
 
 /* Primitive system I/O.  */
 
-#ifdef HAVE_PTH
-# define ESTREAM_SYS_READ  es_pth_read
-# define ESTREAM_SYS_WRITE es_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
 #else
 # define ESTREAM_SYS_READ  read
 # define ESTREAM_SYS_WRITE write
+# define ESTREAM_SYS_YIELD() do { } while (0)
 #endif
 
 #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;
+
+
+/* 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.  */
 
 
+
+/* An internal stream object.  */
 struct estream_internal
 {
   unsigned char buffer[BUFFER_BLOCK_SIZE];
 struct estream_internal
 {
   unsigned char buffer[BUFFER_BLOCK_SIZE];
@@ -200,23 +237,26 @@ struct estream_internal
   void *cookie;                         /* Cookie.                */
   void *opaque;                         /* Opaque data.           */
   unsigned int modeflags;       /* Flags for the backend. */
   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;
   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;
   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;
   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.  */
 };
 
 
 };
 
 
@@ -226,30 +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)
 
 #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;
 static estream_list_t estream_list;
-static estream_mutex_t estream_list_lock;
 
 
+/* File descriptors registered to be used as the standard file handles. */
+static int custom_std_fds[3];
+static unsigned char custom_std_fds_valid[3];
+
+/* 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)
 
 #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
 
 
 #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.  */
 /* Macros.  */
 
 /* Calculate array dimension.  */
@@ -296,74 +343,100 @@ mem_free (void *p)
     free (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.
  */
 
 
 /*
  * 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
 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 = 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
 }
 
 /* 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)
-      {
-       *list_obj->prev_cdr = list_obj->cdr;
-       if (list_obj->cdr)
-         list_obj->cdr->prev_cdr = list_obj->prev_cdr;
-       mem_free (list_obj);
-       break;
-      }
-  ESTREAM_LIST_UNLOCK;
-}
-
-/* Type of an stream-iterator-function.  */
-typedef int (*estream_iterator_t) (estream_t stream);
+  estream_list_t item;
 
 
-/* Iterate over list of registered streams, calling ITERATOR for each
-   of them.  */
-static int
-es_list_iterate (estream_iterator_t iterator)
-{
-  estream_list_t list_obj;
-  int ret = 0;
+  if (!with_locked_list)
+    ESTREAM_LIST_LOCK;
 
 
-  ESTREAM_LIST_LOCK;
-  for (list_obj = estream_list; list_obj; list_obj = list_obj->cdr)
-    ret |= (*iterator) (list_obj->car);
-  ESTREAM_LIST_UNLOCK;
+  for (item = estream_list; item; item = item->next)
+    if (item->stream == stream)
+      {
+        item->stream = NULL;
+        break;
+      }
 
 
-  return ret;
+  if (!with_locked_list)
+    ESTREAM_LIST_UNLOCK;
 }
 
 
 }
 
 
@@ -377,9 +450,9 @@ es_list_iterate (estream_iterator_t iterator)
  * write, assuming that we do I/O on a plain file where the operation
  * can't block.
  */
  * write, assuming that we do I/O on a plain file where the operation
  * can't block.
  */
-#ifdef HAVE_PTH
+#ifdef HAVE_NPTH
 static int
 static int
-es_pth_read (int fd, void *buffer, size_t size)
+do_pth_read (int fd, void *buffer, size_t size)
 {
 # ifdef HAVE_W32_SYSTEM
   int rc = pth_read (fd, buffer, size);
 {
 # ifdef HAVE_W32_SYSTEM
   int rc = pth_read (fd, buffer, size);
@@ -392,7 +465,7 @@ es_pth_read (int fd, void *buffer, size_t size)
 }
 
 static int
 }
 
 static int
-es_pth_write (int fd, const void *buffer, size_t size)
+do_pth_write (int fd, const void *buffer, size_t size)
 {
 # ifdef HAVE_W32_SYSTEM
   int rc = pth_write (fd, buffer, size);
 {
 # ifdef HAVE_W32_SYSTEM
   int rc = pth_write (fd, buffer, size);
@@ -403,28 +476,47 @@ es_pth_write (int fd, const void *buffer, size_t size)
   return pth_write (fd, buffer, size);
 # endif /* !HAVE_W32_SYSTEM*/
 }
   return pth_write (fd, buffer, size);
 # endif /* !HAVE_W32_SYSTEM*/
 }
-#endif /*HAVE_PTH*/
+#endif /*HAVE_NPTH*/
 
 \f
 
 
 \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
 /*
  * Initialization.
  */
 
 static int
-es_init_do (void)
+do_init (void)
 {
 {
-#ifdef HAVE_PTH
   static int initialized;
 
   if (!initialized)
     {
   static int initialized;
 
   if (!initialized)
     {
+#ifdef HAVE_NPTH
       if (!pth_init () && errno != EPERM )
         return -1;
       if (pth_mutex_init (&estream_list_lock))
         initialized = 1;
       if (!pth_init () && errno != EPERM )
         return -1;
       if (pth_mutex_init (&estream_list_lock))
         initialized = 1;
-    }
+#else
+      initialized = 1;
 #endif
 #endif
+      atexit (do_deinit);
+    }
   return 0;
 }
 
   return 0;
 }
 
@@ -459,15 +551,17 @@ typedef struct estream_cookie_mem
    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
    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.  */
+   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
 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,
-                   func_realloc_t func_realloc, func_free_t func_free,
-                   unsigned int modeflags,
-                    size_t memory_limit)
+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;
 {
   estream_cookie_mem_t mem_cookie;
   int err;
@@ -477,6 +571,11 @@ es_func_mem_create (void *ES__RESTRICT *ES__RESTRICT cookie,
       _set_errno (EINVAL);
       return -1;
     }
       _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)
 
   mem_cookie = mem_alloc (sizeof (*mem_cookie));
   if (!mem_cookie)
@@ -491,7 +590,8 @@ es_func_mem_create (void *ES__RESTRICT *ES__RESTRICT cookie,
       mem_cookie->data_len = data_len;
       mem_cookie->block_size = block_size;
       mem_cookie->flags.grow = !!grow;
       mem_cookie->data_len = data_len;
       mem_cookie->block_size = block_size;
       mem_cookie->flags.grow = !!grow;
-      mem_cookie->func_realloc = func_realloc ? func_realloc : mem_realloc;
+      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;
       mem_cookie->func_free = func_free ? func_free : mem_free;
       *cookie = mem_cookie;
       err = 0;
@@ -516,7 +616,7 @@ es_func_mem_read (void *cookie, void *buffer, size_t size)
       memcpy (buffer, mem_cookie->memory + mem_cookie->offset, size);
       mem_cookie->offset += size;
     }
       memcpy (buffer, mem_cookie->memory + mem_cookie->offset, size);
       mem_cookie->offset += size;
     }
-  
+
   ret = size;
   return ret;
 }
   ret = size;
   return ret;
 }
@@ -541,8 +641,9 @@ es_func_mem_write (void *cookie, const void *buffer, size_t size)
 
   assert (mem_cookie->memory_size >= mem_cookie->offset);
   nleft = mem_cookie->memory_size - mem_cookie->offset;
 
   assert (mem_cookie->memory_size >= mem_cookie->offset);
   nleft = mem_cookie->memory_size - mem_cookie->offset;
-  
-  /* If we are not allowed to grow limit the size to the left space.  */
+
+  /* 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;
 
   if (!mem_cookie->flags.grow && size > nleft)
     size = nleft;
 
@@ -555,7 +656,7 @@ es_func_mem_write (void *cookie, const void *buffer, size_t size)
       if (!mem_cookie->memory_size)
         newsize = size;  /* Not yet allocated.  */
       else
       if (!mem_cookie->memory_size)
         newsize = size;  /* Not yet allocated.  */
       else
-        newsize = mem_cookie->memory_size + (nleft - size);
+        newsize = mem_cookie->memory_size + (size - nleft);
       if (newsize < mem_cookie->offset)
         {
           _set_errno (EINVAL);
       if (newsize < mem_cookie->offset)
         {
           _set_errno (EINVAL);
@@ -582,20 +683,21 @@ es_func_mem_write (void *cookie, const void *buffer, size_t size)
           _set_errno (ENOSPC);
           return -1;
         }
           _set_errno (ENOSPC);
           return -1;
         }
-      
+
+      assert (mem_cookie->func_realloc);
       newbuf = mem_cookie->func_realloc (mem_cookie->memory, newsize);
       if (!newbuf)
         return -1;
       newbuf = mem_cookie->func_realloc (mem_cookie->memory, newsize);
       if (!newbuf)
         return -1;
-      
+
       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;
       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);
     }
       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;
   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;
@@ -657,7 +759,8 @@ es_func_mem_seek (void *cookie, off_t *offset, int whence)
           _set_errno (ENOSPC);
           return -1;
         }
           _set_errno (ENOSPC);
           return -1;
         }
-      
+
+      assert (mem_cookie->func_realloc);
       newbuf = mem_cookie->func_realloc (mem_cookie->memory, newsize);
       if (!newbuf)
         return -1;
       newbuf = mem_cookie->func_realloc (mem_cookie->memory, newsize);
       if (!newbuf)
         return -1;
@@ -680,6 +783,33 @@ es_func_mem_seek (void *cookie, off_t *offset, int whence)
   return 0;
 }
 
   return 0;
 }
 
+/* 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
 
 /* Destroy function for memory objects.  */
 static int
@@ -706,7 +836,7 @@ static es_cookie_io_functions_t estream_functions_mem =
 
 
 \f
 
 
 \f
-/* Implementation of fd I/O.  */
+/* Implementation of file descriptor based I/O.  */
 
 /* Cookie for fd objects.  */
 typedef struct estream_cookie_fd
 
 /* Cookie for fd objects.  */
 typedef struct estream_cookie_fd
@@ -715,9 +845,9 @@ typedef struct estream_cookie_fd
   int no_close;  /* If set we won't close the file descriptor.  */
 } *estream_cookie_fd_t;
 
   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
 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;
 {
   estream_cookie_fd_t fd_cookie;
   int err;
@@ -739,7 +869,7 @@ es_func_fd_create (void **cookie, int fd, unsigned int modeflags, int no_close)
       *cookie = fd_cookie;
       err = 0;
     }
       *cookie = fd_cookie;
       err = 0;
     }
-  
+
   return err;
 }
 
   return err;
 }
 
@@ -751,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;
 
   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;
 }
 
   return bytes_read;
 }
@@ -761,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)
 /* 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;
 
 {
   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;
 }
 
   return bytes_written;
 }
@@ -781,13 +926,21 @@ es_func_fd_seek (void *cookie, off_t *offset, int whence)
   off_t offset_new;
   int err;
 
   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
     {
   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;
     }
 
   return err;
@@ -802,7 +955,10 @@ es_func_fd_destroy (void *cookie)
 
   if (fd_cookie)
     {
 
   if (fd_cookie)
     {
-      err = fd_cookie->no_close? 0 : close (fd_cookie->fd);
+      if (IS_INVALID_FD (fd_cookie->fd))
+        err = 0;
+      else
+        err = fd_cookie->no_close? 0 : close (fd_cookie->fd);
       mem_free (fd_cookie);
     }
   else
       mem_free (fd_cookie);
     }
   else
@@ -823,6 +979,217 @@ static es_cookie_io_functions_t estream_functions_fd =
 
 
 \f
 
 
 \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.  */
 /* Implementation of FILE* I/O.  */
 
 /* Cookie for fp objects.  */
@@ -832,10 +1199,11 @@ typedef struct estream_cookie_fp
   int no_close;  /* If set we won't close the file pointer.  */
 } *estream_cookie_fp_t;
 
   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
 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;
 {
   estream_cookie_fp_t fp_cookie;
   int err;
@@ -857,7 +1225,7 @@ es_func_fp_create (void **cookie, FILE *fp,
       *cookie = fp_cookie;
       err = 0;
     }
       *cookie = fp_cookie;
       err = 0;
     }
-  
+
   return err;
 }
 
   return err;
 }
 
@@ -869,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;
 
   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;
   if (!bytes_read && ferror (file_cookie->fp))
     return -1;
   return bytes_read;
@@ -878,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)
 /* 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;
 
 {
   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;
   if (bytes_written != size)
     return -1;
   return bytes_written;
@@ -896,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;
 
   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) )
     {
   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)
     {
     }
 
   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;
 }
 
     }
   *offset = offset_new;
   return 0;
 }
 
-/* Destroy function for fd objects.  */
+/* Destroy function for FILE* objects.  */
 static int
 es_func_fp_destroy (void *cookie)
 {
 static int
 es_func_fp_destroy (void *cookie)
 {
@@ -921,8 +1324,13 @@ es_func_fp_destroy (void *cookie)
 
   if (fp_cookie)
     {
 
   if (fp_cookie)
     {
-      fflush (fp_cookie->fp);
-      err = fp_cookie->no_close? 0 : fclose (fp_cookie->fp);
+      if (fp_cookie->fp)
+        {
+          fflush (fp_cookie->fp);
+          err = fp_cookie->no_close? 0 : fclose (fp_cookie->fp);
+        }
+      else
+        err = 0;
       mem_free (fp_cookie);
     }
   else
       mem_free (fp_cookie);
     }
   else
@@ -945,10 +1353,10 @@ static es_cookie_io_functions_t estream_functions_fp =
 \f
 /* Implementation of file I/O.  */
 
 \f
 /* Implementation of file I/O.  */
 
-/* Create function for file objects.  */
+/* Create function for objects identified by a file name.  */
 static int
 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;
 {
   estream_cookie_fd_t file_cookie;
   int err;
@@ -964,7 +1372,7 @@ es_func_file_create (void **cookie, int *filedes,
       goto out;
     }
 
       goto out;
     }
 
-  fd = open (path, modeflags, ES_DEFAULT_OPEN_MODE);
+  fd = open (path, modeflags, cmode);
   if (fd == -1)
     {
       err = -1;
   if (fd == -1)
     {
       err = -1;
@@ -989,21 +1397,36 @@ es_func_file_create (void **cookie, int *filedes,
   return err;
 }
 
   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
 
 \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
 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;
+  unsigned int omode, oflags, cmode;
+  int got_cmode = 0;
 
 
-  switch (*mode)
+  switch (*modestr)
     {
     case 'r':
       omode = O_RDONLY;
     {
     case 'r':
       omode = O_RDONLY;
@@ -1021,9 +1444,9 @@ es_convert_mode (const char *mode, unsigned int *modeflags)
       _set_errno (EINVAL);
       return -1;
     }
       _set_errno (EINVAL);
       return -1;
     }
-  for (mode++; *mode; mode++)
+  for (modestr++; *modestr; modestr++)
     {
     {
-      switch (*mode)
+      switch (*modestr)
         {
         case '+':
           omode = O_RDWR;
         {
         case '+':
           omode = O_RDWR;
@@ -1034,12 +1457,54 @@ es_convert_mode (const char *mode, unsigned int *modeflags)
         case 'x':
           oflags |= O_EXCL;
           break;
         case 'x':
           oflags |= O_EXCL;
           break;
+        case ',':
+          goto keyvalue;
         default: /* Ignore unknown flags.  */
         default: /* Ignore unknown flags.  */
-          break; 
+          break;
         }
     }
 
         }
     }
 
+ keyvalue:
+  /* Parse key/value pairs (similar to fopen on mainframes).  */
+  for (cmode=0; *modestr == ','; modestr += strcspn (modestr, ","))
+    {
+      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);
+
   *modeflags = (omode | oflags);
   *modeflags = (omode | oflags);
+  if (r_cmode)
+    *r_cmode = cmode;
   return 0;
 }
 
   return 0;
 }
 
@@ -1116,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".  */
         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;
       data_flushed = 0;
       err = 0;
-      
+
       while ((((ssize_t) (stream->data_offset - data_flushed)) > 0) && (! err))
        {
          ret = (*func_write) (stream->intern->cookie,
       while ((((ssize_t) (stream->data_offset - data_flushed)) > 0) && (! err))
        {
          ret = (*func_write) (stream->intern->cookie,
@@ -1153,7 +1618,7 @@ es_flush (estream_t stream)
     err = 0;
 
  out:
     err = 0;
 
  out:
-    
+
   if (err)
     stream->intern->indicators.err = 1;
 
   if (err)
     stream->intern->indicators.err = 1;
 
@@ -1173,7 +1638,8 @@ es_empty (estream_t stream)
 /* Initialize STREAM.  */
 static void
 es_initialize (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;
                unsigned int modeflags)
 {
   stream->intern->cookie = cookie;
@@ -1182,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_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->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_ntotal = 0;
-  stream->intern->print_fp = NULL;
   stream->intern->indicators.err = 0;
   stream->intern->indicators.eof = 0;
   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->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;
 
   stream->data_len = 0;
   stream->data_offset = 0;
@@ -1199,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
   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) )
      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) )
@@ -1215,14 +1684,6 @@ es_deinitialize (estream_t stream)
   es_cookie_close_function_t func_close;
   int err, tmp_err;
 
   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;
-      _set_errno (save_errno);
-    }
-
   func_close = stream->intern->func_close;
 
   err = 0;
   func_close = stream->intern->func_close;
 
   err = 0;
@@ -1231,14 +1692,24 @@ es_deinitialize (estream_t stream)
   if (func_close)
     SET_UNLESS_NONZERO (err, tmp_err, (*func_close) (stream->intern->cookie));
 
   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
   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;
 {
   estream_internal_t stream_internal_new;
   estream_t stream_new;
@@ -1268,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);
   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;
 
   if (err)
     goto out;
 
@@ -1292,21 +1763,61 @@ es_create (estream_t *stream, void *cookie, int fd,
 
 /* Deinitialize a stream object and destroy it.  */
 static int
 
 /* 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)
     {
 
   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);
       mem_free (stream->intern);
       mem_free (stream);
     }
       err = es_deinitialize (stream);
       mem_free (stream->intern);
       mem_free (stream);
     }
+  else
+    err = 0;
 
   return err;
 }
 
 
   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.  */
 /* Try to read BYTES_TO_READ bytes FROM STREAM into BUFFER in
    unbuffered-mode, storing the amount of bytes read in
    *BYTES_READ.  */
@@ -1431,7 +1942,7 @@ es_readn (estream_t ES__RESTRICT stream,
       if (err)
        goto out;
       stream->flags.writing = 0;
       if (err)
        goto out;
       stream->flags.writing = 0;
-    }  
+    }
 
   /* Read unread data first.  */
   while ((bytes_to_read - data_read_unread) && stream->unread_data_len)
 
   /* Read unread data first.  */
   while ((bytes_to_read - data_read_unread) && stream->unread_data_len)
@@ -1528,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;
     }
       off = off - stream->data_len + stream->data_offset;
       off -= stream->unread_data_len;
     }
-  
+
   ret = (*func_seek) (stream->intern->cookie, &off, whence);
   if (ret == -1)
     {
   ret = (*func_seek) (stream->intern->cookie, &off, whence);
   if (ret == -1)
     {
@@ -1546,7 +2057,7 @@ es_seek (estream_t ES__RESTRICT stream, off_t offset, int whence,
   stream->intern->offset = off;
 
  out:
   stream->intern->offset = off;
 
  out:
-  
+
   if (err)
     stream->intern->indicators.err = 1;
 
   if (err)
     stream->intern->indicators.err = 1;
 
@@ -1570,11 +2081,11 @@ es_write_nbf (estream_t ES__RESTRICT stream,
     {
       err = EOPNOTSUPP;
       goto out;
     {
       err = EOPNOTSUPP;
       goto out;
-    }  
+    }
 
   data_written = 0;
   err = 0;
 
   data_written = 0;
   err = 0;
-  
+
   while (bytes_to_write - data_written)
     {
       ret = (*func_write) (stream->intern->cookie,
   while (bytes_to_write - data_written)
     {
       ret = (*func_write) (stream->intern->cookie,
@@ -1622,12 +2133,12 @@ es_write_fbf (estream_t ES__RESTRICT stream,
       if (! err)
        {
          /* Flushing resulted in empty container.  */
       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;
          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;
          memcpy (stream->buffer + stream->data_offset,
                  buffer + data_written, data_to_write);
          stream->data_offset += data_to_write;
@@ -1688,7 +2199,7 @@ es_writen (estream_t ES__RESTRICT stream,
 
   data_written = 0;
   err = 0;
 
   data_written = 0;
   err = 0;
-  
+
   if (!stream->flags.writing)
     {
       /* Switching to writing mode -> discard input data and seek to
   if (!stream->flags.writing)
     {
       /* Switching to writing mode -> discard input data and seek to
@@ -1723,7 +2234,7 @@ es_writen (estream_t ES__RESTRICT stream,
     }
 
  out:
     }
 
  out:
-    
+
   if (bytes_written)
     *bytes_written = data_written;
   if (data_written)
   if (bytes_written)
     *bytes_written = data_written;
   if (data_written)
@@ -1747,7 +2258,7 @@ es_peek (estream_t ES__RESTRICT stream, unsigned char **ES__RESTRICT data,
       if (err)
        goto out;
       stream->flags.writing = 0;
       if (err)
        goto out;
       stream->flags.writing = 0;
-    }  
+    }
 
   if (stream->data_offset == stream->data_len)
     {
 
   if (stream->data_offset == stream->data_len)
     {
@@ -1756,7 +2267,7 @@ es_peek (estream_t ES__RESTRICT stream, unsigned char **ES__RESTRICT data,
       if (err)
        goto out;
     }
       if (err)
        goto out;
     }
-  
+
   if (data)
     *data = stream->buffer + stream->data_offset;
   if (data_len)
   if (data)
     *data = stream->buffer + stream->data_offset;
   if (data_len)
@@ -1804,21 +2315,23 @@ doreadline (estream_t ES__RESTRICT stream, size_t max_length,
   unsigned char *data;
   size_t data_len;
   int err;
   unsigned char *data;
   size_t data_len;
   int err;
+  es_syshd_t syshd;
 
   line_new = NULL;
   line_stream = NULL;
   line_stream_cookie = NULL;
 
 
   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,
-                            mem_realloc, mem_free, 
-                            O_RDWR,
-                            0);
+  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;
 
   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;
 
   if (err)
     goto out;
 
@@ -1866,7 +2379,7 @@ doreadline (estream_t ES__RESTRICT stream, size_t max_length,
     goto out;
 
   /* Complete line has been written to line_stream.  */
     goto out;
 
   /* Complete line has been written to line_stream.  */
-  
+
   if ((max_length > 1) && (! line_size))
     {
       stream->intern->indicators.eof = 1;
   if ((max_length > 1) && (! line_size))
     {
       stream->intern->indicators.eof = 1;
@@ -1903,7 +2416,7 @@ doreadline (estream_t ES__RESTRICT stream, size_t max_length,
  out:
 
   if (line_stream)
  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);
 
   else if (line_stream_cookie)
     es_func_mem_destroy (line_stream_cookie);
 
@@ -1962,7 +2475,7 @@ static int
 es_get_indicator (estream_t stream, int ind_err, int ind_eof)
 {
   int ret = 0;
 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)
   if (ind_err)
     ret = stream->intern->indicators.err;
   else if (ind_eof)
@@ -1989,7 +2502,7 @@ es_set_buffering (estream_t ES__RESTRICT stream,
     es_empty (stream);
 
   es_set_indicators (stream, -1, 0);
     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)
     {
   /* Free old buffer in case that was allocated by this function.  */
   if (stream->intern->deallocate_buffer)
     {
@@ -2003,11 +2516,13 @@ es_set_buffering (estream_t ES__RESTRICT stream,
   else
     {
       void *buffer_new;
   else
     {
       void *buffer_new;
-      
+
       if (buffer)
        buffer_new = buffer;
       else
        {
       if (buffer)
        buffer_new = buffer;
       else
        {
+          if (!size)
+            size = BUFSIZ;
          buffer_new = mem_alloc (size);
          if (! buffer_new)
            {
          buffer_new = mem_alloc (size);
          if (! buffer_new)
            {
@@ -2057,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.  */
 \f
 
 /* API.  */
@@ -2072,75 +2581,98 @@ es_init (void)
 {
   int err;
 
 {
   int err;
 
-  err = es_init_do ();
+  err = do_init ();
 
   return err;
 }
 
 
   return err;
 }
 
+
+\f
 estream_t
 es_fopen (const char *ES__RESTRICT path, const char *ES__RESTRICT mode)
 {
 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;
   int create_called;
   estream_t stream;
   void *cookie;
   int err;
   int fd;
+  es_syshd_t syshd;
 
   stream = NULL;
   cookie = NULL;
   create_called = 0;
 
 
   stream = NULL;
   cookie = NULL;
   create_called = 0;
 
-  err = es_convert_mode (mode, &modeflags);
+  err = parse_mode (mode, &modeflags, &cmode);
   if (err)
     goto out;
   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;
 
   if (err)
     goto out;
 
+  syshd.type = ES_SYSHD_FD;
+  syshd.u.fd = fd;
+
   create_called = 1;
   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 (err)
     goto out;
 
+  if (stream && path)
+    fname_set_internal (stream, path, 1);
+
  out:
  out:
-  
+
   if (err && create_called)
   if (err && create_called)
-    (*estream_functions_file.func_close) (cookie);
+    (*estream_functions_fd.func_close) (cookie);
 
   return stream;
 }
 
 
 
   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
 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)
 {
          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;
   unsigned int modeflags;
-  int create_called;
-  estream_t stream;
-  void *cookie;
   int err;
   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;
 
   if (err)
     goto out;
 
-  err = es_func_mem_create (&cookie, data, data_n, data_len,
-                           BUFFER_BLOCK_SIZE, grow, 
-                           func_realloc, func_free, modeflags, 0);
+  err = func_mem_create (&cookie, data, data_n, data_len,
+                         BUFFER_BLOCK_SIZE, grow,
+                         func_realloc, func_free, modeflags, 0);
   if (err)
     goto out;
   if (err)
     goto out;
-  
+
+  memset (&syshd, 0, sizeof syshd);
   create_called = 1;
   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:
 
 
  out:
 
@@ -2151,34 +2683,72 @@ es_mopen (unsigned char *ES__RESTRICT data, size_t data_n, size_t data_len,
 }
 
 
 }
 
 
+\f
 estream_t
 es_fopenmem (size_t memlimit, const char *ES__RESTRICT mode)
 {
   unsigned int modeflags;
   estream_t stream = NULL;
   void *cookie = NULL;
 estream_t
 es_fopenmem (size_t memlimit, const char *ES__RESTRICT mode)
 {
   unsigned int modeflags;
   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.  */
 
   /* Memory streams are always read/write.  We use MODE only to get
      the append flag.  */
-  if (es_convert_mode (mode, &modeflags))
+  if (parse_mode (mode, &modeflags, NULL))
     return NULL;
   modeflags |= O_RDWR;
 
     return NULL;
   modeflags |= O_RDWR;
 
-  
-  if (es_func_mem_create (&cookie, NULL, 0, 0,
-                          BUFFER_BLOCK_SIZE, 1,
-                          mem_realloc, mem_free, modeflags,
-                          memlimit))
+  if (func_mem_create (&cookie, NULL, 0, 0,
+                       BUFFER_BLOCK_SIZE, 1,
+                       mem_realloc, mem_free, modeflags,
+                       memlimit))
     return NULL;
     return NULL;
-  
-  if (es_create (&stream, cookie, -1, estream_functions_mem, modeflags))
+
+  memset (&syshd, 0, sizeof syshd);
+  if (es_create (&stream, cookie, &syshd, estream_functions_mem, modeflags, 0))
     (*estream_functions_mem.func_close) (cookie);
 
     (*estream_functions_mem.func_close) (cookie);
 
+  if (stream)
+    stream->intern->func_ioctl = es_func_mem_ioctl;
+
   return stream;
 }
 
   return stream;
 }
 
+\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,
 estream_t
 es_fopencookie (void *ES__RESTRICT cookie,
                const char *ES__RESTRICT mode,
@@ -2187,50 +2757,55 @@ es_fopencookie (void *ES__RESTRICT cookie,
   unsigned int modeflags;
   estream_t stream;
   int err;
   unsigned int modeflags;
   estream_t stream;
   int err;
+  es_syshd_t syshd;
 
   stream = NULL;
   modeflags = 0;
 
   stream = NULL;
   modeflags = 0;
-  
-  err = es_convert_mode (mode, &modeflags);
+
+  err = parse_mode (mode, &modeflags, NULL);
   if (err)
     goto out;
 
   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:
   if (err)
     goto out;
 
  out:
-
   return stream;
 }
 
 
   return stream;
 }
 
 
+\f
 estream_t
 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;
 {
   unsigned int modeflags;
   int create_called;
   estream_t stream;
   void *cookie;
   int err;
+  es_syshd_t syshd;
 
   stream = NULL;
   cookie = NULL;
   create_called = 0;
 
 
   stream = NULL;
   cookie = NULL;
   create_called = 0;
 
-  err = es_convert_mode (mode, &modeflags);
+  err = parse_mode (mode, &modeflags, NULL);
   if (err)
     goto out;
 
   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;
 
   if (err)
     goto out;
 
+  syshd.type = ES_SYSHD_FD;
+  syshd.u.fd = filedes;
   create_called = 1;
   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:
 
  out:
-
   if (err && create_called)
     (*estream_functions_fd.func_close) (cookie);
 
   if (err && create_called)
     (*estream_functions_fd.func_close) (cookie);
 
@@ -2240,42 +2815,47 @@ do_fdopen (int filedes, const char *mode, int no_close)
 estream_t
 es_fdopen (int filedes, const char *mode)
 {
 estream_t
 es_fdopen (int filedes, const char *mode)
 {
-  return do_fdopen (filedes, mode, 0);
+  return do_fdopen (filedes, mode, 0, 0);
 }
 
 /* A variant of es_fdopen which does not close FILEDES at the end.  */
 estream_t
 es_fdopen_nc (int filedes, const char *mode)
 {
 }
 
 /* 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
 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;
   int create_called;
   estream_t stream;
   void *cookie;
   int err;
+  es_syshd_t syshd;
 
   stream = NULL;
   cookie = NULL;
   create_called = 0;
 
 
   stream = NULL;
   cookie = NULL;
   create_called = 0;
 
-  err = es_convert_mode (mode, &modeflags);
+  err = parse_mode (mode, &modeflags, &cmode);
   if (err)
     goto out;
 
   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;
 
   if (err)
     goto out;
 
+  syshd.type = ES_SYSHD_FD;
+  syshd.u.fd = fp? fileno (fp): -1;
   create_called = 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:
 
 
  out:
 
@@ -2285,27 +2865,188 @@ do_fpopen (FILE *fp, const char *mode, int no_close)
   return stream;
 }
 
   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
-   under Windows where the 3 standard streams are associated with the
-   console whereas a duped and fd-opened stream of one of this stream
-   won't be associated with the console.  As this messes things up it
-   is easier to keep on using the standard I/O stream as a backend for
-   estream. */
-estream_t
-es_fpopen (FILE *fp, const char *mode)
+
+/* 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
+   under Windows where the 3 standard streams are associated with the
+   console whereas a duped and fd-opened stream of one of this stream
+   won't be associated with the console.  As this messes things up it
+   is easier to keep on using the standard I/O stream as a backend for
+   estream. */
+estream_t
+es_fpopen (FILE *fp, const char *mode)
+{
+  return do_fpopen (fp, mode, 0, 0);
+}
+
+
+/* Same as es_fpopen but does not close  FP at the end.  */
+estream_t
+es_fpopen_nc (FILE *fp, const char *mode)
+{
+  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)
 {
 {
-  return do_fpopen (fp, mode, 0);
+  /* 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;
 }
 
 
 }
 
 
-/* Same as es_fpopen but does not close  FP at the end.  */
+/* Return the stream used for stdin, stdout or stderr.  */
 estream_t
 estream_t
-es_fpopen_nc (FILE *fp, const char *mode)
+_es_get_std_stream (int fd)
 {
 {
-  return do_fpopen (fp, mode, 1);
+  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;
 }
 
 
 }
 
 
@@ -2317,28 +3058,31 @@ es_freopen (const char *ES__RESTRICT path, const char *ES__RESTRICT mode,
 
   if (path)
     {
 
   if (path)
     {
-      unsigned int modeflags;
+      unsigned int modeflags, cmode;
       int create_called;
       void *cookie;
       int fd;
       int create_called;
       void *cookie;
       int fd;
+      es_syshd_t syshd;
 
       cookie = NULL;
       create_called = 0;
 
       cookie = NULL;
       create_called = 0;
-      
+
       ESTREAM_LOCK (stream);
 
       es_deinitialize (stream);
 
       ESTREAM_LOCK (stream);
 
       es_deinitialize (stream);
 
-      err = es_convert_mode (mode, &modeflags);
+      err = parse_mode (mode, &modeflags, &cmode);
       if (err)
        goto leave;
       if (err)
        goto leave;
-      
-      err = es_func_file_create (&cookie, &fd, path, modeflags);
+
+      err = func_file_create (&cookie, &fd, path, modeflags, cmode);
       if (err)
        goto leave;
 
       if (err)
        goto leave;
 
+      syshd.type = ES_SYSHD_FD;
+      syshd.u.fd = fd;
       create_called = 1;
       create_called = 1;
-      es_initialize (stream, cookie, fd, estream_functions_file, modeflags);
+      es_initialize (stream, cookie, &syshd, estream_functions_fd, modeflags);
 
     leave:
 
 
     leave:
 
@@ -2346,19 +3090,23 @@ es_freopen (const char *ES__RESTRICT path, const char *ES__RESTRICT mode,
        {
          if (create_called)
            es_func_fd_destroy (cookie);
        {
          if (create_called)
            es_func_fd_destroy (cookie);
-      
-         es_destroy (stream);
+
+         do_close (stream, 0);
          stream = NULL;
        }
       else
          stream = NULL;
        }
       else
-       ESTREAM_UNLOCK (stream);
+        {
+          if (stream && path)
+            fname_set_internal (stream, path, 1);
+          ESTREAM_UNLOCK (stream);
+        }
     }
   else
     {
       /* FIXME?  We don't support re-opening at the moment.  */
       _set_errno (EINVAL);
       es_deinitialize (stream);
     }
   else
     {
       /* FIXME?  We don't support re-opening at the moment.  */
       _set_errno (EINVAL);
       es_deinitialize (stream);
-      es_destroy (stream);
+      do_close (stream, 0);
       stream = NULL;
     }
 
       stream = NULL;
     }
 
@@ -2371,15 +3119,139 @@ es_fclose (estream_t stream)
 {
   int err;
 
 {
   int err;
 
-  err = es_destroy (stream);
+  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;
+
+  /* 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.  */
+
+  if (r_buffer)
+    {
+      cookie_ioctl_function_t func_ioctl = stream->intern->func_ioctl;
+      size_t buflen;
+
+      *r_buffer = NULL;
+
+      if (!func_ioctl)
+        {
+          _set_errno (EOPNOTSUPP);
+          err = -1;
+          goto 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)
+        goto leave;
+      if (r_buflen)
+        *r_buflen = buflen;
+    }
+
+  err = do_close (stream, 0);
+
+ leave:
+  if (err && r_buffer)
+    {
+      mem_free (*r_buffer);
+      *r_buffer = NULL;
+    }
+  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_onclose (estream_t stream, int mode,
+            void (*fnc) (estream_t, void*), void *fnc_value)
+{
+  int err;
+
+  ESTREAM_LOCK (stream);
+  err = do_onclose (stream, mode, fnc, fnc_value);
+  ESTREAM_UNLOCK (stream);
 
   return err;
 }
 
 
   return err;
 }
 
+
 int
 es_fileno_unlocked (estream_t stream)
 {
 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;
 }
 
 
 }
 
 
@@ -2417,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)
 {
 int
 es_feof_unlocked (estream_t stream)
 {
@@ -2473,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;
 int
 es_fflush (estream_t stream)
 {
   int err;
-  
+
   if (stream)
     {
       ESTREAM_LOCK (stream);
   if (stream)
     {
       ESTREAM_LOCK (stream);
-      if (stream->flags.writing)
-       err = es_flush (stream);
-      else
-       {
-         es_empty (stream);
-         err = 0;
-       }
+      err = do_fflush (stream);
       ESTREAM_UNLOCK (stream);
     }
   else
       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;
 }
 
   return err ? EOF : 0;
 }
 
@@ -2514,7 +3426,7 @@ int
 es_fseeko (estream_t stream, off_t offset, int whence)
 {
   int err;
 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);
   ESTREAM_LOCK (stream);
   err = es_seek (stream, offset, whence, NULL);
   ESTREAM_UNLOCK (stream);
@@ -2527,7 +3439,7 @@ long int
 es_ftell (estream_t stream)
 {
   long int ret;
 es_ftell (estream_t stream)
 {
   long int ret;
-  
+
   ESTREAM_LOCK (stream);
   ret = es_offset_calculate (stream);
   ESTREAM_UNLOCK (stream);
   ESTREAM_LOCK (stream);
   ret = es_offset_calculate (stream);
   ESTREAM_UNLOCK (stream);
@@ -2588,7 +3500,7 @@ int
 es_fgetc (estream_t stream)
 {
   int ret;
 es_fgetc (estream_t stream)
 {
   int ret;
-  
+
   ESTREAM_LOCK (stream);
   ret = es_getc_unlocked (stream);
   ESTREAM_UNLOCK (stream);
   ESTREAM_LOCK (stream);
   ret = es_getc_unlocked (stream);
   ESTREAM_UNLOCK (stream);
@@ -2601,7 +3513,7 @@ int
 es_fputc (int c, estream_t stream)
 {
   int ret;
 es_fputc (int c, estream_t stream)
 {
   int ret;
-  
+
   ESTREAM_LOCK (stream);
   ret = es_putc_unlocked (c, stream);
   ESTREAM_UNLOCK (stream);
   ESTREAM_LOCK (stream);
   ret = es_putc_unlocked (c, stream);
   ESTREAM_UNLOCK (stream);
@@ -2669,12 +3581,11 @@ es_fread (void *ES__RESTRICT ptr, size_t size, size_t nitems,
          estream_t ES__RESTRICT stream)
 {
   size_t ret, bytes;
          estream_t ES__RESTRICT stream)
 {
   size_t ret, bytes;
-  int err;
 
   if (size * nitems)
     {
       ESTREAM_LOCK (stream);
 
   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;
       ESTREAM_UNLOCK (stream);
 
       ret = bytes / size;
@@ -2691,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;
           estream_t ES__RESTRICT stream)
 {
   size_t ret, bytes;
-  int err;
 
   if (size * nitems)
     {
       ESTREAM_LOCK (stream);
 
   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;
       ESTREAM_UNLOCK (stream);
 
       ret = bytes / size;
@@ -2713,10 +3623,10 @@ es_fgets (char *ES__RESTRICT buffer, int length, estream_t ES__RESTRICT stream)
 {
   unsigned char *s = (unsigned char*)buffer;
   int c;
 {
   unsigned char *s = (unsigned char*)buffer;
   int c;
-   
+
   if (!length)
     return NULL;
   if (!length)
     return NULL;
-     
+
   c = EOF;
   ESTREAM_LOCK (stream);
   while (length > 1 && (c = es_getc_unlocked (stream)) != EOF && c != '\n')
   c = EOF;
   ESTREAM_LOCK (stream);
   while (length > 1 && (c = es_getc_unlocked (stream)) != EOF && c != '\n')
@@ -2738,6 +3648,17 @@ es_fgets (char *ES__RESTRICT buffer, int length, estream_t ES__RESTRICT stream)
 
 
 int
 
 
 int
+es_fputs_unlocked (const char *ES__RESTRICT s, estream_t ES__RESTRICT stream)
+{
+  size_t length;
+  int err;
+
+  length = strlen (s);
+  err = es_writen (stream, s, length, NULL);
+  return err ? EOF : 0;
+}
+
+int
 es_fputs (const char *ES__RESTRICT s, estream_t ES__RESTRICT stream)
 {
   size_t length;
 es_fputs (const char *ES__RESTRICT s, estream_t ES__RESTRICT stream)
 {
   size_t length;
@@ -2769,7 +3690,7 @@ es_getline (char *ES__RESTRICT *ES__RESTRICT lineptr, size_t *ES__RESTRICT n,
   if (*n)
     {
       /* Caller wants us to use his buffer.  */
   if (*n)
     {
       /* Caller wants us to use his buffer.  */
-      
+
       if (*n < (line_n + 1))
        {
          /* Provided buffer is too small -> resize.  */
       if (*n < (line_n + 1))
        {
          /* Provided buffer is too small -> resize.  */
@@ -2813,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
    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
 
    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
@@ -2837,7 +3758,7 @@ es_getline (char *ES__RESTRICT *ES__RESTRICT lineptr, size_t *ES__RESTRICT n,
    released using es_free.
  */
 ssize_t
    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)
 {
               char **addr_of_buffer, size_t *length_of_buffer,
               size_t *max_length)
 {
@@ -2849,7 +3770,7 @@ es_read_line (estream_t stream,
   char *p;
 
   if (!buffer)
   char *p;
 
   if (!buffer)
-    { 
+    {
       /* No buffer given - allocate a new one. */
       length = 256;
       buffer = mem_alloc (length);
       /* No buffer given - allocate a new one. */
       length = 256;
       buffer = mem_alloc (length);
@@ -2878,9 +3799,9 @@ es_read_line (estream_t stream,
   while  ((c = es_getc_unlocked (stream)) != EOF)
     {
       if (nbytes == length)
   while  ((c = es_getc_unlocked (stream)) != EOF)
     {
       if (nbytes == length)
-        { 
+        {
           /* Enlarge the buffer. */
           /* 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)
             {
               /* We are beyond our limit: Skip the rest of the line. */
               while (c != '\n' && (c=es_getc_unlocked (stream)) != EOF)
@@ -2897,7 +3818,7 @@ es_read_line (estream_t stream,
           if (!*addr_of_buffer)
             {
               int save_errno = errno;
           if (!*addr_of_buffer)
             {
               int save_errno = errno;
-              mem_free (buffer); 
+              mem_free (buffer);
               *length_of_buffer = 0;
               if (max_length)
                 *max_length = 0;
               *length_of_buffer = 0;
               if (max_length)
                 *max_length = 0;
@@ -2907,7 +3828,7 @@ es_read_line (estream_t stream,
             }
           buffer = *addr_of_buffer;
           *length_of_buffer = length;
             }
           buffer = *addr_of_buffer;
           *length_of_buffer = length;
-          length -= 3; 
+          length -= 3;
           p = buffer + nbytes;
        }
       *p++ = c;
           p = buffer + nbytes;
        }
       *p++ = c;
@@ -2932,11 +3853,20 @@ es_free (void *a)
 
 
 int
 
 
 int
+es_vfprintf_unlocked (estream_t ES__RESTRICT stream,
+                      const char *ES__RESTRICT format,
+                      va_list ap)
+{
+  return es_print (stream, format, ap);
+}
+
+
+int
 es_vfprintf (estream_t ES__RESTRICT stream, const char *ES__RESTRICT format,
             va_list ap)
 {
   int ret;
 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);
   ESTREAM_LOCK (stream);
   ret = es_print (stream, format, ap);
   ESTREAM_UNLOCK (stream);
@@ -2945,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,
 es_fprintf_unlocked (estream_t ES__RESTRICT stream,
-           const char *ES__RESTRICT format, ...)
+                     const char *ES__RESTRICT format, ...)
 {
   int ret;
 {
   int ret;
-  
+
   va_list ap;
   va_start (ap, format);
   ret = es_print (stream, format, ap);
   va_list ap;
   va_start (ap, format);
   ret = es_print (stream, format, ap);
@@ -2965,7 +3895,38 @@ es_fprintf (estream_t ES__RESTRICT stream,
            const char *ES__RESTRICT format, ...)
 {
   int ret;
            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);
   va_list ap;
   va_start (ap, format);
   ESTREAM_LOCK (stream);
@@ -2976,6 +3937,7 @@ es_fprintf (estream_t ES__RESTRICT stream,
   return ret;
 }
 
   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
 /* 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
@@ -3002,7 +3964,7 @@ es_asprintf (const char *ES__RESTRICT format, ...)
    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.  */
    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 * 
+char *
 es_vasprintf (const char *ES__RESTRICT format, va_list ap)
 {
   int rc;
 es_vasprintf (const char *ES__RESTRICT format, va_list ap)
 {
   int rc;
@@ -3033,7 +3995,7 @@ tmpfd (void)
   int pid = GetCurrentProcessId ();
   unsigned int value;
   int i;
   int pid = GetCurrentProcessId ();
   unsigned int value;
   int i;
-  
+
   n = GetTempPath (MAX_PATH+1, buffer);
   if (!n || n > MAX_PATH || mystrlen (buffer) > MAX_PATH)
     {
   n = GetTempPath (MAX_PATH+1, buffer);
   if (!n || n > MAX_PATH || mystrlen (buffer) > MAX_PATH)
     {
@@ -3099,7 +4061,7 @@ tmpfd (void)
 
   fp = NULL;
   fd = -1;
 
   fp = NULL;
   fd = -1;
-  
+
   fp = tmpfile ();
   if (! fp)
     goto out;
   fp = tmpfile ();
   if (! fp)
     goto out;
@@ -3125,12 +4087,13 @@ es_tmpfile (void)
   void *cookie;
   int err;
   int fd;
   void *cookie;
   int err;
   int fd;
+  es_syshd_t syshd;
 
   create_called = 0;
   stream = NULL;
   modeflags = O_RDWR | O_TRUNC | O_CREAT;
   cookie = NULL;
 
   create_called = 0;
   stream = NULL;
   modeflags = O_RDWR | O_TRUNC | O_CREAT;
   cookie = NULL;
-  
+
   fd = tmpfd ();
   if (fd == -1)
     {
   fd = tmpfd ();
   if (fd == -1)
     {
@@ -3138,15 +4101,16 @@ es_tmpfile (void)
       goto out;
     }
 
       goto out;
     }
 
-  err = es_func_fd_create (&cookie, fd, modeflags, 0);
+  err = func_fd_create (&cookie, fd, modeflags, 0);
   if (err)
     goto out;
 
   if (err)
     goto out;
 
+  syshd.type = ES_SYSHD_FD;
+  syshd.u.fd = fd;
   create_called = 1;
   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:
 
  out:
-
   if (err)
     {
       if (create_called)
   if (err)
     {
       if (create_called)
@@ -3155,7 +4119,7 @@ es_tmpfile (void)
        close (fd);
       stream = NULL;
     }
        close (fd);
       stream = NULL;
     }
-  
+
   return stream;
 }
 
   return stream;
 }
 
@@ -3165,9 +4129,9 @@ es_setvbuf (estream_t ES__RESTRICT stream,
            char *ES__RESTRICT buf, int type, size_t size)
 {
   int err;
            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);
     {
       ESTREAM_LOCK (stream);
       err = es_set_buffering (stream, buf, type, size);
@@ -3191,6 +4155,39 @@ es_setbuf (estream_t ES__RESTRICT stream, char *ES__RESTRICT buf)
   ESTREAM_UNLOCK (stream);
 }
 
   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)
 {
 void
 es_opaque_set (estream_t stream, void *opaque)
 {
@@ -3204,7 +4201,7 @@ void *
 es_opaque_get (estream_t stream)
 {
   void *opaque;
 es_opaque_get (estream_t stream)
 {
   void *opaque;
-  
+
   ESTREAM_LOCK (stream);
   es_opaque_ctrl (stream, NULL, &opaque);
   ESTREAM_UNLOCK (stream);
   ESTREAM_LOCK (stream);
   es_opaque_ctrl (stream, NULL, &opaque);
   ESTREAM_UNLOCK (stream);
@@ -3212,15 +4209,77 @@ es_opaque_get (estream_t stream)
   return opaque;
 }
 
   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.  */
 /* 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,
 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;
                     size_t * ES__RESTRICT bytes_written)
 {
   const unsigned char *p = buffer;
@@ -3230,9 +4289,9 @@ es_write_sanitized (estream_t ES__RESTRICT stream,
   ESTREAM_LOCK (stream);
   for (; length; length--, p++, count++)
     {
   ESTREAM_LOCK (stream);
   for (; length; length--, p++, count++)
     {
-      if (*p < 0x20 
+      if (*p < 0x20
           || *p == 0x7f
           || *p == 0x7f
-          || (delimiters 
+          || (delimiters
               && (strchr (delimiters, *p) || *p == '\\')))
         {
           es_putc_unlocked ('\\', stream);
               && (strchr (delimiters, *p) || *p == '\\')))
         {
           es_putc_unlocked ('\\', stream);
@@ -3334,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
 #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,
 
    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. */
                                 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;
     {
       if ( (p[i] & 0x80) )
         break;