Print --version etc via estream
[gnupg.git] / common / estream.c
index f43690d..3a17910 100644 (file)
@@ -1,11 +1,11 @@
 /* estream.c - Extended Stream I/O Library
- * Copyright (C) 2004, 2005, 2006, 2007 g10 Code GmbH
+ * Copyright (C) 2004, 2005, 2006, 2007, 2009, 2010 g10 Code GmbH
  *
  * This file is part of Libestream.
  *
  * Libestream is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published
- * by the Free Software Foundation; either version 3 of the License,
+ * by the Free Software Foundation; either version 2 of the License,
  * or (at your option) any later version.
  *
  * Libestream is distributed in the hope that it will be useful, but
  *
  * You should have received a copy of the GNU General Public License
  * along with Libestream; if not, see <http://www.gnu.org/licenses/>.
+ *
+ * ALTERNATIVELY, Libestream may be distributed under the terms of the
+ * following license, in which case the provisions of this license are
+ * required INSTEAD OF the GNU General Public License. If you wish to
+ * allow use of your version of this file only under the terms of the
+ * GNU General Public License, and not to allow others to use your
+ * version of this file under the terms of the following license,
+ * indicate your decision by deleting this paragraph and the license
+ * below.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, and the entire permission notice in its entirety,
+ *    including the disclaimer of warranties.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote
+ *    products derived from this software without specific prior
+ *    written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifdef USE_ESTREAM_SUPPORT_H
 # include <config.h>
 #endif
 
+#if defined(_WIN32) && !defined(HAVE_W32_SYSTEM)
+# define HAVE_W32_SYSTEM 1
+# if defined(__MINGW32CE__) && !defined (HAVE_W32CE_SYSTEM)
+#  define HAVE_W32CE_SYSTEM
+# endif
+#endif
+
 #include <sys/types.h>
 #include <sys/file.h>
 #include <sys/stat.h>
 #include <errno.h>
 #include <stddef.h>
 #include <assert.h>
+#ifdef HAVE_W32_SYSTEM
+# include <windows.h>
+#endif
+#ifdef HAVE_W32CE_SYSTEM
+# include <gpg-error.h> /* ERRNO replacement.  */
+#endif
 
 #ifdef WITHOUT_GNU_PTH /* Give the Makefile a chance to build without Pth.  */
-#undef HAVE_PTH
-#undef USE_GNU_PTH
+# undef HAVE_PTH
+# undef USE_GNU_PTH
 #endif
 
 #ifdef HAVE_PTH
@@ -49,7 +96,7 @@
 
 /* This is for the special hack to use estream.c in GnuPG.  */
 #ifdef GNUPG_MAJOR_VERSION
-#include "../common/util.h"
+# include "../common/util.h"
 #endif
 
 #ifndef HAVE_MKSTEMP
@@ -69,17 +116,27 @@ void *memrchr (const void *block, int c, size_t size);
 #define O_BINARY 0
 #endif
 
+#ifdef HAVE_W32CE_SYSTEM
+# define _set_errno(a)  gpg_err_set_errno ((a))
+/* Setmode is missing in cegcc but available since CE 5.0.  */
+int _setmode (int handle, int mode);
+# define setmode(a,b)   _setmode ((a),(b))
+#else
+# define _set_errno(a)  do { errno = (a); } while (0)
+#endif
+
+#ifdef HAVE_W32_SYSTEM
+# define IS_INVALID_FD(a) ((void*)(a) == (void*)(-1))
+#else
+# define IS_INVALID_FD(a) ((a) == -1)
+#endif
+
+
 /* Generally used types.  */
 
 typedef void *(*func_realloc_t) (void *mem, size_t size);
 typedef void (*func_free_t) (void *mem);
 
-#ifdef HAVE_FOPENCOOKIE
-typedef ssize_t my_funopen_hook_ret_t;
-#else
-typedef int     my_funopen_hook_ret_t;
-#endif
-
 
 \f
 
@@ -90,13 +147,6 @@ typedef int     my_funopen_hook_ret_t;
 
 \f
 
-/* Macros.  */
-
-#define BUFFER_ROUND_TO_BLOCK(size, block_size) \
-  (((size) + (block_size - 1)) / block_size)
-
-\f
-
 /* Locking.  */
 
 #ifdef HAVE_PTH
@@ -114,27 +164,37 @@ typedef pth_mutex_t estream_mutex_t;
 #else
 
 typedef void *estream_mutex_t;
-# define ESTREAM_MUTEX_INITIALIZER NULL
-# define ESTREAM_MUTEX_LOCK(mutex) (void) 0
-# define ESTREAM_MUTEX_UNLOCK(mutex) (void) 0
-# define ESTREAM_MUTEX_TRYLOCK(mutex) 0
-# define ESTREAM_MUTEX_INITIALIZE(mutex) (void) 0
-#endif
 
-/* Memory allocator functions.  */
+static inline void
+dummy_mutex_call_void (estream_mutex_t mutex)
+{
+  (void)mutex;
+}
+
+static inline int
+dummy_mutex_call_int (estream_mutex_t mutex)
+{
+  (void)mutex;
+  return 0;
+}
 
-#define ES_MEM_ALLOC   malloc
-#define ES_MEM_REALLOC realloc
-#define ES_MEM_FREE    free
+# define ESTREAM_MUTEX_INITIALIZER NULL
+# define ESTREAM_MUTEX_LOCK(mutex) dummy_mutex_call_void ((mutex))
+# define ESTREAM_MUTEX_UNLOCK(mutex) dummy_mutex_call_void ((mutex))
+# define ESTREAM_MUTEX_TRYLOCK(mutex) dummy_mutex_call_int ((mutex))
+# define ESTREAM_MUTEX_INITIALIZE(mutex) dummy_mutex_call_void ((mutex))
+#endif
 
 /* Primitive system I/O.  */
 
 #ifdef HAVE_PTH
-# define ESTREAM_SYS_READ  pth_read
-# define ESTREAM_SYS_WRITE pth_write
+# define ESTREAM_SYS_READ  es_pth_read
+# define ESTREAM_SYS_WRITE es_pth_write
+# define ESTREAM_SYS_YIELD() pth_yield (NULL)
 #else
 # define ESTREAM_SYS_READ  read
 # define ESTREAM_SYS_WRITE write
+# define ESTREAM_SYS_YIELD() do { } while (0)
 #endif
 
 /* Misc definitions.  */
@@ -164,6 +224,8 @@ struct estream_internal
     unsigned int eof: 1;
   } indicators;
   unsigned int deallocate_buffer: 1;
+  unsigned int is_stdstream:1;   /* This is a standard stream.  */
+  unsigned int stdstream_fd:2;   /* 0, 1 or 2 for a standard stream.  */
   unsigned int print_err: 1;     /* Error in print_fun_writer.  */
   int print_errno;               /* Errno from print_fun_writer.  */
   size_t print_ntotal;           /* Bytes written from in print_fun_writer. */
@@ -189,15 +251,16 @@ struct estream_list
 };
 
 static estream_list_t estream_list;
-#ifdef HAVE_PTH
-/* Note that we can't use a static initialization with W32Pth, thus we
-   do it in es_init. */
 static estream_mutex_t estream_list_lock;
-#endif
 
 #define ESTREAM_LIST_LOCK   ESTREAM_MUTEX_LOCK   (estream_list_lock)
 #define ESTREAM_LIST_UNLOCK ESTREAM_MUTEX_UNLOCK (estream_list_lock)
 
+/* File descriptors registered to be used as the standard file handles. */
+static int custom_std_fds[3];
+static unsigned char custom_std_fds_valid[3];
+
+
 #ifndef EOPNOTSUPP
 # define EOPNOTSUPP ENOSYS
 #endif
@@ -212,6 +275,9 @@ static estream_mutex_t estream_list_lock;
 #define DIM(array) (sizeof (array) / sizeof (*array))
 #endif
 
+#define tohex(n) ((n) < 10 ? ((n) + '0') : (((n) - 10) + 'A'))
+
+
 /* Evaluate EXPRESSION, setting VARIABLE to the return code, if
    VARIABLE is zero.  */
 #define SET_UNLESS_NONZERO(variable, tmp_variable, expression) \
@@ -223,30 +289,61 @@ static estream_mutex_t estream_list_lock;
     }                                                          \
   while (0)
 
+
+/* Malloc wrappers to overcome problems on some older OSes.  */
+static void *
+mem_alloc (size_t n)
+{
+  if (!n)
+    n++;
+  return malloc (n);
+}
+
+static void *
+mem_realloc (void *p, size_t n)
+{
+  if (!p)
+    return mem_alloc (n);
+  return realloc (p, n);
+}
+
+static void
+mem_free (void *p)
+{
+  if (p)
+    free (p);
+}
+
+
+
 /*
  * List manipulation.
  */
 
-/* Add STREAM to the list of registered stream objects.  */
+/* Add STREAM to the list of registered stream objects.  If
+   WITH_LOCKED_LIST is true we assumed that the list of streams is
+   already locked.  */
 static int
-es_list_add (estream_t stream)
+es_list_add (estream_t stream, int with_locked_list)
 {
   estream_list_t list_obj;
   int ret;
 
-  list_obj = ES_MEM_ALLOC (sizeof (*list_obj));
+  list_obj = mem_alloc (sizeof (*list_obj));
   if (! list_obj)
     ret = -1;
   else
     {
-      ESTREAM_LIST_LOCK;
+      if (!with_locked_list)
+        ESTREAM_LIST_LOCK;
       list_obj->car = stream;
       list_obj->cdr = estream_list;
       list_obj->prev_cdr = &estream_list;
       if (estream_list)
        estream_list->prev_cdr = &list_obj->cdr;
       estream_list = list_obj;
-      ESTREAM_LIST_UNLOCK;
+      if (!with_locked_list)
+        ESTREAM_LIST_UNLOCK;
       ret = 0;
     }
 
@@ -255,21 +352,23 @@ es_list_add (estream_t stream)
 
 /* Remove STREAM from the list of registered stream objects.  */
 static void
-es_list_remove (estream_t stream)
+es_list_remove (estream_t stream, int with_locked_list)
 {
   estream_list_t list_obj;
   
-  ESTREAM_LIST_LOCK;
+  if (!with_locked_list)
+    ESTREAM_LIST_LOCK;
   for (list_obj = estream_list; list_obj; list_obj = list_obj->cdr)
     if (list_obj->car == stream)
       {
        *list_obj->prev_cdr = list_obj->cdr;
        if (list_obj->cdr)
          list_obj->cdr->prev_cdr = list_obj->prev_cdr;
-       ES_MEM_FREE (list_obj);
+       mem_free (list_obj);
        break;
       }
-  ESTREAM_LIST_UNLOCK;
+  if (!with_locked_list)
+    ESTREAM_LIST_UNLOCK;
 }
 
 /* Type of an stream-iterator-function.  */
@@ -291,8 +390,55 @@ es_list_iterate (estream_iterator_t iterator)
   return ret;
 }
 
+
+\f
+/*
+ * I/O Helper
+ *
+ * Unfortunately our Pth emulation for Windows expects system handles
+ * for pth_read and pth_write.  We use a simple approach to fix this:
+ * If the function returns an error we fall back to a vanilla read or
+ * write, assuming that we do I/O on a plain file where the operation
+ * can't block.
+ */
+#ifdef HAVE_PTH
+static int
+es_pth_read (int fd, void *buffer, size_t size)
+{
+# ifdef HAVE_W32_SYSTEM
+  int rc = pth_read (fd, buffer, size);
+  if (rc == -1 && errno == EINVAL)
+    rc = read (fd, buffer, size);
+  return rc;
+# else /*!HAVE_W32_SYSTEM*/
+  return pth_read (fd, buffer, size);
+# endif /* !HAVE_W32_SYSTEM*/
+}
+
+static int
+es_pth_write (int fd, const void *buffer, size_t size)
+{
+# ifdef HAVE_W32_SYSTEM
+  int rc = pth_write (fd, buffer, size);
+  if (rc == -1 && errno == EINVAL)
+    rc = write (fd, buffer, size);
+  return rc;
+# else /*!HAVE_W32_SYSTEM*/
+  return pth_write (fd, buffer, size);
+# endif /* !HAVE_W32_SYSTEM*/
+}
+#endif /*HAVE_PTH*/
+
 \f
 
+static void
+es_deinit (void)
+{
+  /* Flush all streams. */
+  es_fflush (NULL);
+}
+
+
 /*
  * Initialization.
  */
@@ -300,17 +446,20 @@ es_list_iterate (estream_iterator_t iterator)
 static int
 es_init_do (void)
 {
-#ifdef HAVE_PTH
   static int initialized;
 
   if (!initialized)
     {
+#ifdef HAVE_PTH
       if (!pth_init () && errno != EPERM )
         return -1;
       if (pth_mutex_init (&estream_list_lock))
         initialized = 1;
-    }
+#else
+      initialized = 1;
 #endif
+      atexit (es_deinit);  
+    }
   return 0;
 }
 
@@ -326,53 +475,59 @@ es_init_do (void)
 typedef struct estream_cookie_mem
 {
   unsigned int modeflags;      /* Open flags.  */
-  unsigned char *memory;       /* Data.  */
-  size_t memory_size;          /* Size of MEMORY.  */
+  unsigned char *memory;       /* Allocated data buffer.  */
+  size_t memory_size;          /* Allocated size of MEMORY.  */
+  size_t memory_limit;          /* Caller supplied maximum allowed
+                                   allocation size or 0 for no limit.  */
   size_t offset;               /* Current offset in MEMORY.  */
-  size_t data_len;             /* Length of data in MEMORY.  */
+  size_t data_len;             /* Used length of data in MEMORY.  */
   size_t block_size;           /* Block size.  */
-  unsigned int grow: 1;                /* MEMORY is allowed to grow.  */
-  unsigned int append_zero: 1; /* Append zero after data.  */
-  unsigned int dont_free: 1;   /* Append zero after data.  */
-  char **ptr;
-  size_t *size;
+  struct {
+    unsigned int grow: 1;      /* MEMORY is allowed to grow.  */
+  } flags;
   func_realloc_t func_realloc;
   func_free_t func_free;
 } *estream_cookie_mem_t;
 
-/* Create function for memory objects.  */
+
+/* Create function for memory objects.  DATA is either NULL or a user
+   supplied buffer with the initial conetnt of the memory buffer.  If
+   DATA is NULL, DATA_N and DATA_LEN need to be 0 as well.  If DATA is
+   not NULL, DATA_N gives the allocated size of DATA and DATA_LEN the
+   used length in DATA.  */
 static int
 es_func_mem_create (void *ES__RESTRICT *ES__RESTRICT cookie,
                    unsigned char *ES__RESTRICT data, size_t data_n,
                    size_t data_len,
                    size_t block_size, unsigned int grow,
-                   unsigned int append_zero, unsigned int dont_free,
-                   char **ptr, size_t *size,
                    func_realloc_t func_realloc, func_free_t func_free,
-                   unsigned int modeflags)
+                   unsigned int modeflags,
+                    size_t memory_limit)
 {
   estream_cookie_mem_t mem_cookie;
   int err;
 
-  mem_cookie = ES_MEM_ALLOC (sizeof (*mem_cookie));
-  if (! mem_cookie)
+  if (!data && (data_n || data_len))
+    {
+      _set_errno (EINVAL);
+      return -1;
+    }
+
+  mem_cookie = mem_alloc (sizeof (*mem_cookie));
+  if (!mem_cookie)
     err = -1;
   else
     {
       mem_cookie->modeflags = modeflags;
       mem_cookie->memory = data;
       mem_cookie->memory_size = data_n;
+      mem_cookie->memory_limit = memory_limit;
       mem_cookie->offset = 0;
       mem_cookie->data_len = data_len;
       mem_cookie->block_size = block_size;
-      mem_cookie->grow = grow ? 1 : 0;
-      mem_cookie->append_zero = append_zero ? 1 : 0;
-      mem_cookie->dont_free = dont_free ? 1 : 0;
-      mem_cookie->ptr = ptr;
-      mem_cookie->size = size;
-      mem_cookie->func_realloc = func_realloc ? func_realloc : ES_MEM_REALLOC;
-      mem_cookie->func_free = func_free ? func_free : ES_MEM_FREE;
-      mem_cookie->offset = 0;
+      mem_cookie->flags.grow = !!grow;
+      mem_cookie->func_realloc = func_realloc ? func_realloc : mem_realloc;
+      mem_cookie->func_free = func_free ? func_free : mem_free;
       *cookie = mem_cookie;
       err = 0;
     }
@@ -380,6 +535,7 @@ es_func_mem_create (void *ES__RESTRICT *ES__RESTRICT cookie,
   return err;
 }
 
+
 /* Read function for memory objects.  */
 static ssize_t
 es_func_mem_read (void *cookie, void *buffer, size_t size)
@@ -397,115 +553,100 @@ es_func_mem_read (void *cookie, void *buffer, size_t size)
     }
   
   ret = size;
-
   return ret;
 }
 
+
 /* Write function for memory objects.  */
 static ssize_t
 es_func_mem_write (void *cookie, const void *buffer, size_t size)
 {
   estream_cookie_mem_t mem_cookie = cookie;
-  func_realloc_t func_realloc = mem_cookie->func_realloc;
-  unsigned char *memory_new;
-  size_t newsize;
   ssize_t ret;
-  int err;
+  size_t nleft;
 
-  if (size)
-    {
-      /* Regular write.  */
-
-      if (mem_cookie->modeflags & O_APPEND)
-       /* Append to data.  */
-       mem_cookie->offset = mem_cookie->data_len;
-         
-      if (! mem_cookie->grow)
-       if (size > mem_cookie->memory_size - mem_cookie->offset)
-         size = mem_cookie->memory_size - mem_cookie->offset;
+  if (!size)
+    return 0;  /* A flush is a NOP for memory objects.  */
 
-      err = 0;
+  if (mem_cookie->modeflags & O_APPEND)
+    {
+      /* Append to data.  */
+      mem_cookie->offset = mem_cookie->data_len;
+    }
 
-      while (size > (mem_cookie->memory_size - mem_cookie->offset))
-       {
-         memory_new = (*func_realloc) (mem_cookie->memory,
-                                       mem_cookie->memory_size
-                                       + mem_cookie->block_size);
-         if (! memory_new)
-           {
-             err = -1;
-             break;
-           }
-         else
-           {
-             if (mem_cookie->memory != memory_new)
-               mem_cookie->memory = memory_new;
-             mem_cookie->memory_size += mem_cookie->block_size;
-           }
-       }
-      if (err)
-       goto out;
+  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 (!mem_cookie->flags.grow && size > nleft)
+    size = nleft;
 
-      if (size)
-       {
-         memcpy (mem_cookie->memory + mem_cookie->offset, buffer, size);
-         if (mem_cookie->offset + size > mem_cookie->data_len)
-           mem_cookie->data_len = mem_cookie->offset + size;
-         mem_cookie->offset += size;
-       }
-    }
-  else
+  /* Enlarge the memory buffer if needed.  */
+  if (size > nleft)
     {
-      /* Flush.  */
-
-      err = 0;
-      if (mem_cookie->append_zero)
-       {
-         if (mem_cookie->data_len >= mem_cookie->memory_size)
-           {
-             newsize = BUFFER_ROUND_TO_BLOCK (mem_cookie->data_len + 1,
-                                              mem_cookie->block_size)
-               * mem_cookie->block_size;
-         
-             memory_new = (*func_realloc) (mem_cookie->memory, newsize);
-             if (! memory_new)
-               {
-                 err = -1;
-                 goto out;
-               }
-
-             if (mem_cookie->memory != memory_new)
-               mem_cookie->memory = memory_new;
-             mem_cookie->memory_size = newsize;
-           }
+      unsigned char *newbuf;
+      size_t newsize;
 
-         mem_cookie->memory[mem_cookie->data_len + 1] = 0;
-       }
+      if (!mem_cookie->memory_size)
+        newsize = size;  /* Not yet allocated.  */
+      else
+        newsize = mem_cookie->memory_size + (nleft - size);
+      if (newsize < mem_cookie->offset)
+        {
+          _set_errno (EINVAL);
+          return -1;
+        }
 
-      /* Return information to user if necessary.  */
-      if (mem_cookie->ptr)
-       *mem_cookie->ptr = (char *) mem_cookie->memory;
-      if (mem_cookie->size)
-       *mem_cookie->size = mem_cookie->data_len;
-    }
+      /* Round up to the next block length.  BLOCK_SIZE should always
+         be set; we check anyway.  */
+      if (mem_cookie->block_size)
+        {
+          newsize += mem_cookie->block_size - 1;
+          if (newsize < mem_cookie->offset)
+            {
+              _set_errno (EINVAL);
+              return -1;
+            }
+          newsize /= mem_cookie->block_size;
+          newsize *= mem_cookie->block_size;
+        }
 
- out:
+      /* Check for a total limit.  */
+      if (mem_cookie->memory_limit && newsize > mem_cookie->memory_limit)
+        {
+          _set_errno (ENOSPC);
+          return -1;
+        }
+      
+      newbuf = mem_cookie->func_realloc (mem_cookie->memory, newsize);
+      if (!newbuf)
+        return -1;
+      
+      mem_cookie->memory = newbuf;
+      mem_cookie->memory_size = newsize;
 
-  if (err)
-    ret = -1;
-  else
-    ret = size;
+      assert (mem_cookie->memory_size >= mem_cookie->offset);
+      nleft = mem_cookie->memory_size - mem_cookie->offset;
+      
+      assert (size <= nleft);
+    }
+      
+  memcpy (mem_cookie->memory + mem_cookie->offset, buffer, size);
+  if (mem_cookie->offset + size > mem_cookie->data_len)
+    mem_cookie->data_len = mem_cookie->offset + size;
+  mem_cookie->offset += size;
 
+  ret = size;
   return ret;
 }
 
+
 /* Seek function for memory objects.  */
 static int
 es_func_mem_seek (void *cookie, off_t *offset, int whence)
 {
   estream_cookie_mem_t mem_cookie = cookie;
   off_t pos_new;
-  int err = 0;
 
   switch (whence)
     {
@@ -522,69 +663,74 @@ es_func_mem_seek (void *cookie, off_t *offset, int whence)
       break;
 
     default:
-      /* Never reached.  */
-      pos_new = 0;
+      _set_errno (EINVAL);
+      return -1;
     }
 
   if (pos_new > mem_cookie->memory_size)
     {
-      /* Grow buffer if possible.  */
+      size_t newsize;
+      void *newbuf;
 
-      if (mem_cookie->grow)
+      if (!mem_cookie->flags.grow)
        {
-         func_realloc_t func_realloc = mem_cookie->func_realloc;
-         size_t newsize;
-         void *p;
+         _set_errno (ENOSPC);
+         return -1;
+        }
 
-         newsize = BUFFER_ROUND_TO_BLOCK (pos_new, mem_cookie->block_size);
-         p = (*func_realloc) (mem_cookie->memory, newsize);
-         if (! p)
-           {
-             err = -1;
-             goto out;
-           }
-         else
-           {
-             if (mem_cookie->memory != p)
-               mem_cookie->memory = p;
-             mem_cookie->memory_size = newsize;
-           }
-       }
-      else
-       {
-         errno = EINVAL;
-         err = -1;
-         goto out;
-       }
+      newsize = pos_new + mem_cookie->block_size - 1;
+      if (newsize < pos_new)
+        {
+          _set_errno (EINVAL);
+          return -1;
+        }
+      newsize /= mem_cookie->block_size;
+      newsize *= mem_cookie->block_size;
+
+      if (mem_cookie->memory_limit && newsize > mem_cookie->memory_limit)
+        {
+          _set_errno (ENOSPC);
+          return -1;
+        }
+      
+      newbuf = mem_cookie->func_realloc (mem_cookie->memory, newsize);
+      if (!newbuf)
+        return -1;
+
+      mem_cookie->memory = newbuf;
+      mem_cookie->memory_size = newsize;
     }
 
   if (pos_new > mem_cookie->data_len)
-    /* Fill spare space with zeroes.  */
-    memset (mem_cookie->memory + mem_cookie->data_len,
-           0, pos_new - mem_cookie->data_len);
+    {
+      /* Fill spare space with zeroes.  */
+      memset (mem_cookie->memory + mem_cookie->data_len,
+              0, pos_new - mem_cookie->data_len);
+      mem_cookie->data_len = pos_new;
+    }
 
   mem_cookie->offset = pos_new;
   *offset = pos_new;
 
- out:
-
-  return err;
+  return 0;
 }
 
+
 /* Destroy function for memory objects.  */
 static int
 es_func_mem_destroy (void *cookie)
 {
   estream_cookie_mem_t mem_cookie = cookie;
-  func_free_t func_free = mem_cookie->func_free;
-
-  if (! mem_cookie->dont_free)
-    (*func_free) (mem_cookie->memory);
-  ES_MEM_FREE (mem_cookie);
 
+  if (cookie)
+    {
+      mem_cookie->func_free (mem_cookie->memory);
+      mem_free (mem_cookie);
+    }
   return 0;
 }
 
+
 static es_cookie_io_functions_t estream_functions_mem =
   {
     es_func_mem_read,
@@ -611,7 +757,7 @@ es_func_fd_create (void **cookie, int fd, unsigned int modeflags, int no_close)
   estream_cookie_fd_t fd_cookie;
   int err;
 
-  fd_cookie = ES_MEM_ALLOC (sizeof (*fd_cookie));
+  fd_cookie = mem_alloc (sizeof (*fd_cookie));
   if (! fd_cookie)
     err = -1;
   else
@@ -620,6 +766,8 @@ es_func_fd_create (void **cookie, int fd, unsigned int modeflags, int no_close)
       /* Make sure it is in binary mode if requested.  */
       if ( (modeflags & O_BINARY) )
         setmode (fd, O_BINARY);
+#else
+      (void)modeflags;
 #endif
       fd_cookie->fd = fd;
       fd_cookie->no_close = no_close;
@@ -637,10 +785,18 @@ es_func_fd_read (void *cookie, void *buffer, size_t size)
 {
   estream_cookie_fd_t file_cookie = cookie;
   ssize_t bytes_read;
-
-  do 
-    bytes_read = ESTREAM_SYS_READ (file_cookie->fd, buffer, size);
-  while (bytes_read == -1 && errno == EINTR);
+  
+  if (IS_INVALID_FD (file_cookie->fd))
+    {
+      ESTREAM_SYS_YIELD ();
+      bytes_read = 0;
+    }
+  else
+    {
+      do 
+        bytes_read = ESTREAM_SYS_READ (file_cookie->fd, buffer, size);
+      while (bytes_read == -1 && errno == EINTR);
+    }
 
   return bytes_read;
 }
@@ -648,14 +804,21 @@ es_func_fd_read (void *cookie, void *buffer, size_t size)
 /* Write function for fd objects.  */
 static ssize_t
 es_func_fd_write (void *cookie, const void *buffer, size_t size)
-                          
 {
   estream_cookie_fd_t file_cookie = cookie;
   ssize_t bytes_written;
 
-  do
-    bytes_written = ESTREAM_SYS_WRITE (file_cookie->fd, buffer, size);
-  while (bytes_written == -1 && errno == EINTR);
+  if (IS_INVALID_FD (file_cookie->fd))
+    {
+      ESTREAM_SYS_YIELD ();
+      bytes_written = size; /* Yeah:  Success writing to the bit bucket.  */
+    }
+  else
+    {
+      do
+        bytes_written = ESTREAM_SYS_WRITE (file_cookie->fd, buffer, size);
+      while (bytes_written == -1 && errno == EINTR);
+    }
 
   return bytes_written;
 }
@@ -668,13 +831,21 @@ es_func_fd_seek (void *cookie, off_t *offset, int whence)
   off_t offset_new;
   int err;
 
-  offset_new = lseek (file_cookie->fd, *offset, whence);
-  if (offset_new == -1)
-    err = -1;
+  if (IS_INVALID_FD (file_cookie->fd))
+    {
+      _set_errno (ESPIPE);
+      err = -1;
+    }
   else
     {
-      *offset = offset_new;
-      err = 0;
+      offset_new = lseek (file_cookie->fd, *offset, whence);
+      if (offset_new == -1)
+        err = -1;
+      else
+        {
+          *offset = offset_new;
+          err = 0;
+        }
     }
 
   return err;
@@ -689,8 +860,11 @@ es_func_fd_destroy (void *cookie)
 
   if (fd_cookie)
     {
-      err = fd_cookie->no_close? 0 : close (fd_cookie->fd);
-      ES_MEM_FREE (fd_cookie);
+      if (IS_INVALID_FD (fd_cookie->fd))
+        err = 0;
+      else
+        err = fd_cookie->no_close? 0 : close (fd_cookie->fd);
+      mem_free (fd_cookie);
     }
   else
     err = 0;
@@ -721,12 +895,13 @@ typedef struct estream_cookie_fp
 
 /* Create function for fd objects.  */
 static int
-es_func_fp_create (void **cookie, FILE *fp, unsigned int modeflags, int no_close)
+es_func_fp_create (void **cookie, FILE *fp, 
+                   unsigned int modeflags, int no_close)
 {
   estream_cookie_fp_t fp_cookie;
   int err;
 
-  fp_cookie = ES_MEM_ALLOC (sizeof *fp_cookie);
+  fp_cookie = mem_alloc (sizeof *fp_cookie);
   if (!fp_cookie)
     err = -1;
   else
@@ -735,6 +910,8 @@ es_func_fp_create (void **cookie, FILE *fp, unsigned int modeflags, int no_close
       /* Make sure it is in binary mode if requested.  */
       if ( (modeflags & O_BINARY) )
         setmode (fileno (fp), O_BINARY);
+#else
+      (void)modeflags;
 #endif
       fp_cookie->fp = fp;
       fp_cookie->no_close = no_close;
@@ -753,7 +930,10 @@ es_func_fp_read (void *cookie, void *buffer, size_t size)
   estream_cookie_fp_t file_cookie = cookie;
   ssize_t bytes_read;
 
-  bytes_read = fread (buffer, 1, size, file_cookie->fp);
+  if (file_cookie->fp)
+    bytes_read = fread (buffer, 1, size, file_cookie->fp);
+  else
+    bytes_read = 0;
   if (!bytes_read && ferror (file_cookie->fp))
     return -1;
   return bytes_read;
@@ -767,7 +947,11 @@ es_func_fp_write (void *cookie, const void *buffer, size_t size)
   estream_cookie_fp_t file_cookie = cookie;
   size_t bytes_written;
 
-  bytes_written = fwrite (buffer, 1, size, file_cookie->fp);
+
+  if (file_cookie->fp)
+    bytes_written = fwrite (buffer, 1, size, file_cookie->fp);
+  else
+    bytes_written = size; /* Successfully written to the bit bucket.  */
   if (bytes_written != size)
     return -1;
   return bytes_written;
@@ -780,17 +964,25 @@ es_func_fp_seek (void *cookie, off_t *offset, int whence)
   estream_cookie_fp_t file_cookie = cookie;
   long int offset_new;
 
+  if (!file_cookie->fp)
+    {
+      _set_errno (ESPIPE);
+      return -1; 
+    }
+
   if ( fseek (file_cookie->fp, (long int)*offset, whence) )
     {
-      fprintf (stderr, "\nfseek failed: errno=%d (%s)\n", errno,strerror (errno));
-    return -1;
+      /* fprintf (stderr, "\nfseek failed: errno=%d (%s)\n", */
+      /*          errno,strerror (errno)); */
+      return -1;
     }
 
   offset_new = ftell (file_cookie->fp);
   if (offset_new == -1)
     {
-      fprintf (stderr, "\nftell failed: errno=%d (%s)\n", errno,strerror (errno));
-    return -1;
+      /* fprintf (stderr, "\nftell failed: errno=%d (%s)\n",  */
+      /*          errno,strerror (errno)); */
+      return -1;
     }
   *offset = offset_new;
   return 0;
@@ -805,9 +997,14 @@ es_func_fp_destroy (void *cookie)
 
   if (fp_cookie)
     {
-      fflush (fp_cookie->fp);
-      err = fp_cookie->no_close? 0 : fclose (fp_cookie->fp);
-      ES_MEM_FREE (fp_cookie);
+      if (fp_cookie->fp)
+        {
+          fflush (fp_cookie->fp);
+          err = fp_cookie->no_close? 0 : fclose (fp_cookie->fp);
+        }
+      else
+        err = 0;
+      mem_free (fp_cookie);
     }
   else
     err = 0;
@@ -841,7 +1038,7 @@ es_func_file_create (void **cookie, int *filedes,
   err = 0;
   fd = -1;
 
-  file_cookie = ES_MEM_ALLOC (sizeof (*file_cookie));
+  file_cookie = mem_alloc (sizeof (*file_cookie));
   if (! file_cookie)
     {
       err = -1;
@@ -861,13 +1058,14 @@ es_func_file_create (void **cookie, int *filedes,
 #endif
 
   file_cookie->fd = fd;
+  file_cookie->no_close = 0;
   *cookie = file_cookie;
   *filedes = fd;
 
  out:
 
   if (err)
-    ES_MEM_FREE (file_cookie);
+    mem_free (file_cookie);
 
   return err;
 }
@@ -881,67 +1079,49 @@ static es_cookie_io_functions_t estream_functions_file =
   };
 
 \f
-
-/* Stream primitives.  */
-
 static int
 es_convert_mode (const char *mode, unsigned int *modeflags)
 {
+  unsigned int omode, oflags;
 
-  /* FIXME: We need to allow all mode flags permutations.  */
-  struct
-  {
-    const char *mode;
-    unsigned int flags;
-  } mode_flags[] = { { "r",
-                      O_RDONLY },
-                    { "rb",
-                      O_RDONLY | O_BINARY },
-                    { "w",
-                      O_WRONLY | O_TRUNC | O_CREAT },
-                    { "wb",
-                      O_WRONLY | O_TRUNC | O_CREAT | O_BINARY },
-                    { "a",
-                      O_WRONLY | O_APPEND | O_CREAT },
-                    { "ab",
-                      O_WRONLY | O_APPEND | O_CREAT | O_BINARY },
-                    { "r+",
-                      O_RDWR },
-                    { "rb+",
-                      O_RDWR | O_BINARY },
-                    { "r+b",
-                      O_RDONLY | O_WRONLY | O_BINARY },
-                    { "w+",
-                      O_RDWR | O_TRUNC | O_CREAT },
-                    { "wb+",
-                      O_RDWR | O_TRUNC | O_CREAT | O_BINARY },
-                    { "w+b",
-                      O_RDWR | O_TRUNC | O_CREAT | O_BINARY },
-                    { "a+",
-                      O_RDWR | O_CREAT | O_APPEND },
-                    { "ab+",
-                      O_RDWR | O_CREAT | O_APPEND | O_BINARY },
-                    { "a+b",
-                      O_RDWR | O_CREAT | O_APPEND | O_BINARY }
-  };
-  unsigned int i;
-  int err; 
-
-  for (i = 0; i < DIM (mode_flags); i++)
-    if (! strcmp (mode_flags[i].mode, mode))
-      break;
-  if (i == DIM (mode_flags))
+  switch (*mode)
     {
-      errno = EINVAL;
-      err = -1;
+    case 'r':
+      omode = O_RDONLY;
+      oflags = 0;
+      break;
+    case 'w':
+      omode = O_WRONLY;
+      oflags = O_TRUNC | O_CREAT;
+      break;
+    case 'a':
+      omode = O_WRONLY;
+      oflags = O_APPEND | O_CREAT;
+      break;
+    default:
+      _set_errno (EINVAL);
+      return -1;
     }
-  else
+  for (mode++; *mode; mode++)
     {
-      err = 0;
-      *modeflags = mode_flags[i].flags;
+      switch (*mode)
+        {
+        case '+':
+          omode = O_RDWR;
+          break;
+        case 'b':
+          oflags |= O_BINARY;
+          break;
+        case 'x':
+          oflags |= O_EXCL;
+          break;
+        default: /* Ignore unknown flags.  */
+          break; 
+        }
     }
 
-  return err;
+  *modeflags = (omode | oflags);
+  return 0;
 }
 
 \f
@@ -958,7 +1138,7 @@ es_fill (estream_t stream)
 
   if (!stream->intern->func_read)
     {
-      errno = EOPNOTSUPP;
+      _set_errno (EOPNOTSUPP);
       err = -1;
     }
   else
@@ -1092,6 +1272,8 @@ es_initialize (estream_t stream,
   stream->intern->print_fp = NULL;
   stream->intern->indicators.err = 0;
   stream->intern->indicators.eof = 0;
+  stream->intern->is_stdstream = 0;
+  stream->intern->stdstream_fd = 0;
   stream->intern->deallocate_buffer = 0;
 
   stream->data_len = 0;
@@ -1100,7 +1282,7 @@ es_initialize (estream_t stream,
   stream->unread_data_len = 0;
   /* Depending on the modeflags we set whether we start in writing or
      reading mode.  This is required in case we are working on a
-     wronly stream which is not seeekable (like stdout).  Without this
+     stream which is not seeekable (like stdout).  Without this
      pre-initialization we would do a seek at the first write call and
      as this will fail no utput will be delivered. */
   if ((modeflags & O_WRONLY) || (modeflags & O_RDWR) )
@@ -1121,7 +1303,7 @@ es_deinitialize (estream_t stream)
       int save_errno = errno;
       fclose (stream->intern->print_fp);
       stream->intern->print_fp = NULL;
-      errno = save_errno;
+      _set_errno (save_errno);
     }
 
   func_close = stream->intern->func_close;
@@ -1139,7 +1321,8 @@ es_deinitialize (estream_t stream)
 /* Create a new stream object, initialize it.  */
 static int
 es_create (estream_t *stream, void *cookie, int fd,
-          es_cookie_io_functions_t functions, unsigned int modeflags)
+          es_cookie_io_functions_t functions, unsigned int modeflags,
+           int with_locked_list)
 {
   estream_internal_t stream_internal_new;
   estream_t stream_new;
@@ -1148,14 +1331,14 @@ es_create (estream_t *stream, void *cookie, int fd,
   stream_new = NULL;
   stream_internal_new = NULL;
 
-  stream_new = ES_MEM_ALLOC (sizeof (*stream_new));
+  stream_new = mem_alloc (sizeof (*stream_new));
   if (! stream_new)
     {
       err = -1;
       goto out;
     }
 
-  stream_internal_new = ES_MEM_ALLOC (sizeof (*stream_internal_new));
+  stream_internal_new = mem_alloc (sizeof (*stream_internal_new));
   if (! stream_internal_new)
     {
       err = -1;
@@ -1171,7 +1354,7 @@ es_create (estream_t *stream, void *cookie, int fd,
   ESTREAM_MUTEX_INITIALIZE (stream_new->intern->lock);
   es_initialize (stream_new, cookie, fd, functions, modeflags);
 
-  err = es_list_add (stream_new);
+  err = es_list_add (stream_new, with_locked_list);
   if (err)
     goto out;
 
@@ -1184,7 +1367,7 @@ es_create (estream_t *stream, void *cookie, int fd,
       if (stream_new)
        {
          es_deinitialize (stream_new);
-         ES_MEM_FREE (stream_new);
+         mem_free (stream_new);
        }
     }
 
@@ -1193,16 +1376,16 @@ es_create (estream_t *stream, void *cookie, int fd,
 
 /* Deinitialize a stream object and destroy it.  */
 static int
-es_destroy (estream_t stream)
+es_destroy (estream_t stream, int with_locked_list)
 {
   int err = 0;
 
   if (stream)
     {
-      es_list_remove (stream);
+      es_list_remove (stream, with_locked_list);
       err = es_deinitialize (stream);
-      ES_MEM_FREE (stream->intern);
-      ES_MEM_FREE (stream);
+      mem_free (stream->intern);
+      mem_free (stream);
     }
 
   return err;
@@ -1371,7 +1554,7 @@ es_readn (estream_t ES__RESTRICT stream,
 }
 
 /* Try to unread DATA_N bytes from DATA into STREAM, storing the
-   amount of bytes succesfully unread in *BYTES_UNREAD.  */
+   amount of bytes successfully unread in *BYTES_UNREAD.  */
 static void
 es_unreadn (estream_t ES__RESTRICT stream,
            const unsigned char *ES__RESTRICT data, size_t data_n,
@@ -1408,7 +1591,7 @@ es_seek (estream_t ES__RESTRICT stream, off_t offset, int whence,
 
   if (! func_seek)
     {
-      errno = EOPNOTSUPP;
+      _set_errno (EOPNOTSUPP);
       err = -1;
       goto out;
     }
@@ -1678,7 +1861,7 @@ es_skip (estream_t stream, size_t size)
 
   if (stream->data_offset + size > stream->data_len)
     {
-      errno = EINVAL;
+      _set_errno (EINVAL);
       err = -1;
     }
   else
@@ -1693,8 +1876,8 @@ es_skip (estream_t stream, size_t size)
 
 static int
 doreadline (estream_t ES__RESTRICT stream, size_t max_length,
-             char *ES__RESTRICT *ES__RESTRICT line,
-             size_t *ES__RESTRICT line_length)
+            char *ES__RESTRICT *ES__RESTRICT line,
+            size_t *ES__RESTRICT line_length)
 {
   size_t space_left;
   size_t line_size;
@@ -1710,14 +1893,16 @@ doreadline (estream_t ES__RESTRICT stream, size_t max_length,
   line_stream = NULL;
   line_stream_cookie = NULL;
 
-  err = es_func_mem_create (&line_stream_cookie, NULL, 0, 0, BUFFER_BLOCK_SIZE,
-                           1, 0, 0, NULL, 0, ES_MEM_REALLOC, ES_MEM_FREE,
-                            O_RDWR);
+  err = es_func_mem_create (&line_stream_cookie, NULL, 0, 0,
+                            BUFFER_BLOCK_SIZE, 1,
+                            mem_realloc, mem_free, 
+                            O_RDWR,
+                            0);
   if (err)
     goto out;
 
   err = es_create (&line_stream, line_stream_cookie, -1,
-                  estream_functions_mem, O_RDWR);
+                  estream_functions_mem, O_RDWR, 0);
   if (err)
     goto out;
 
@@ -1778,7 +1963,7 @@ doreadline (estream_t ES__RESTRICT stream, size_t max_length,
 
   if (! *line)
     {
-      line_new = ES_MEM_ALLOC (line_size + 1);
+      line_new = mem_alloc (line_size + 1);
       if (! line_new)
        {
          err = -1;
@@ -1802,14 +1987,14 @@ doreadline (estream_t ES__RESTRICT stream, size_t max_length,
  out:
 
   if (line_stream)
-    es_destroy (line_stream);
+    es_destroy (line_stream, 0);
   else if (line_stream_cookie)
     es_func_mem_destroy (line_stream_cookie);
 
   if (err)
     {
       if (! *line)
-       ES_MEM_FREE (line_new);
+       mem_free (line_new);
       stream->intern->indicators.err = 1;
     }
 
@@ -1893,7 +2078,7 @@ es_set_buffering (estream_t ES__RESTRICT stream,
   if (stream->intern->deallocate_buffer)
     {
       stream->intern->deallocate_buffer = 0;
-      ES_MEM_FREE (stream->buffer);
+      mem_free (stream->buffer);
       stream->buffer = NULL;
     }
 
@@ -1907,7 +2092,9 @@ es_set_buffering (estream_t ES__RESTRICT stream,
        buffer_new = buffer;
       else
        {
-         buffer_new = ES_MEM_ALLOC (size);
+          if (!size)
+            size = BUFSIZ;
+         buffer_new = mem_alloc (size);
          if (! buffer_new)
            {
              err = -1;
@@ -1999,7 +2186,7 @@ es_fopen (const char *ES__RESTRICT path, const char *ES__RESTRICT mode)
     goto out;
 
   create_called = 1;
-  err = es_create (&stream, cookie, fd, estream_functions_file, modeflags);
+  err = es_create (&stream, cookie, fd, estream_functions_file, modeflags, 0);
   if (err)
     goto out;
 
@@ -2033,13 +2220,13 @@ es_mopen (unsigned char *ES__RESTRICT data, size_t data_n, size_t data_len,
     goto out;
 
   err = es_func_mem_create (&cookie, data, data_n, data_len,
-                           BUFFER_BLOCK_SIZE, grow, 0, 0,
-                           NULL, 0, func_realloc, func_free, modeflags);
+                           BUFFER_BLOCK_SIZE, grow, 
+                           func_realloc, func_free, modeflags, 0);
   if (err)
     goto out;
   
   create_called = 1;
-  err = es_create (&stream, cookie, -1, estream_functions_mem, modeflags);
+  err = es_create (&stream, cookie, -1, estream_functions_mem, modeflags, 0);
 
  out:
 
@@ -2051,37 +2238,33 @@ es_mopen (unsigned char *ES__RESTRICT data, size_t data_n, size_t data_len,
 
 
 estream_t
-es_open_memstream (char **ptr, size_t *size)
+es_fopenmem (size_t memlimit, const char *ES__RESTRICT mode)
 {
   unsigned int modeflags;
-  int create_called;
-  estream_t stream;
-  void *cookie;
-  int err;
+  estream_t stream = NULL;
+  void *cookie = NULL;
+
+  /* Memory streams are always read/write.  We use MODE only to get
+     the append flag.  */
+  if (es_convert_mode (mode, &modeflags))
+    return NULL;
+  modeflags |= O_RDWR;
 
-  modeflags = O_RDWR;
-  create_called = 0;
-  stream = NULL;
-  cookie = 0;
   
-  err = es_func_mem_create (&cookie, NULL, 0, 0,
-                           BUFFER_BLOCK_SIZE, 1, 1, 1,
-                           ptr, size, ES_MEM_REALLOC, ES_MEM_FREE, modeflags);
-  if (err)
-    goto out;
+  if (es_func_mem_create (&cookie, NULL, 0, 0,
+                          BUFFER_BLOCK_SIZE, 1,
+                          mem_realloc, mem_free, modeflags,
+                          memlimit))
+    return NULL;
   
-  create_called = 1;
-  err = es_create (&stream, cookie, -1, estream_functions_mem, modeflags);
-
- out:
-
-  if (err && create_called)
+  if (es_create (&stream, cookie, -1, estream_functions_mem, modeflags, 0))
     (*estream_functions_mem.func_close) (cookie);
 
   return stream;
 }
 
 
+
 estream_t
 es_fopencookie (void *ES__RESTRICT cookie,
                const char *ES__RESTRICT mode,
@@ -2098,7 +2281,7 @@ es_fopencookie (void *ES__RESTRICT cookie,
   if (err)
     goto out;
 
-  err = es_create (&stream, cookie, -1, functions, modeflags);
+  err = es_create (&stream, cookie, -1, functions, modeflags, 0);
   if (err)
     goto out;
 
@@ -2109,7 +2292,7 @@ es_fopencookie (void *ES__RESTRICT cookie,
 
 
 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;
@@ -2130,7 +2313,8 @@ do_fdopen (int filedes, const char *mode, int no_close)
     goto out;
 
   create_called = 1;
-  err = es_create (&stream, cookie, filedes, estream_functions_fd, modeflags);
+  err = es_create (&stream, cookie, filedes, estream_functions_fd,
+                   modeflags, with_locked_list);
 
  out:
 
@@ -2143,19 +2327,19 @@ do_fdopen (int filedes, const char *mode, int no_close)
 estream_t
 es_fdopen (int filedes, const char *mode)
 {
-  return do_fdopen (filedes, mode, 0);
+  return do_fdopen (filedes, mode, 0, 0);
 }
 
 /* A variant of es_fdopen which does not close FILEDES at the end.  */
 estream_t
 es_fdopen_nc (int filedes, const char *mode)
 {
-  return do_fdopen (filedes, mode, 1);
+  return do_fdopen (filedes, mode, 1, 0);
 }
 
 
 estream_t
-do_fpopen (FILE *fp, const char *mode, int no_close)
+do_fpopen (FILE *fp, const char *mode, int no_close, int with_locked_list)
 {
   unsigned int modeflags;
   int create_called;
@@ -2171,14 +2355,15 @@ do_fpopen (FILE *fp, const char *mode, int no_close)
   if (err)
     goto out;
 
-  fflush (fp);
+  if (fp)
+    fflush (fp);
   err = es_func_fp_create (&cookie, fp, modeflags, no_close);
   if (err)
     goto out;
-
+  
   create_called = 1;
-  err = es_create (&stream, cookie, fileno (fp), estream_functions_fp,
-                   modeflags);
+  err = es_create (&stream, cookie, fp? fileno (fp):-1, estream_functions_fp,
+                   modeflags, with_locked_list);
 
  out:
 
@@ -2200,7 +2385,7 @@ do_fpopen (FILE *fp, const char *mode, int no_close)
 estream_t
 es_fpopen (FILE *fp, const char *mode)
 {
-  return do_fpopen (fp, mode, 0);
+  return do_fpopen (fp, mode, 0, 0);
 }
 
 
@@ -2208,7 +2393,83 @@ es_fpopen (FILE *fp, const char *mode)
 estream_t
 es_fpopen_nc (FILE *fp, const char *mode)
 {
-  return do_fpopen (fp, mode, 1);
+  return do_fpopen (fp, mode, 1, 0);
+}
+
+
+/* Set custom standard descriptors to be used for stdin, stdout and
+   stderr.  This function needs to be called before any of the
+   standard streams are accessed.  */
+void
+_es_set_std_fd (int no, int fd)
+{
+  ESTREAM_LIST_LOCK;
+  if (no >= 0 && no < 3 && !custom_std_fds_valid[no])
+    {
+      custom_std_fds[no] = fd;
+      custom_std_fds_valid[no] = 1;
+    }
+  ESTREAM_LIST_UNLOCK;
+}
+
+
+/* Return the stream used for stdin, stdout or stderr.  */
+estream_t
+_es_get_std_stream (int fd)
+{
+  estream_list_t list_obj;
+  estream_t stream = NULL;
+
+  fd %= 3; /* We only allow 0, 1 or 2 but we don't want to return an error. */
+  ESTREAM_LIST_LOCK;
+  for (list_obj = estream_list; list_obj; list_obj = list_obj->cdr)
+    if (list_obj->car->intern->is_stdstream
+        && list_obj->car->intern->stdstream_fd == fd)
+      {
+       stream = list_obj->car;
+       break;
+      }
+  if (!stream)
+    {
+      /* Standard stream not yet created.  We first try to create them
+         from registered file descriptors.  */
+      if (!fd && custom_std_fds_valid[0])
+        stream = do_fdopen (custom_std_fds[0], "r", 1, 1);
+      else if (fd == 1 && custom_std_fds_valid[1])
+        stream = do_fdopen (custom_std_fds[1], "a", 1, 1);
+      else if (custom_std_fds_valid[2])
+        stream = do_fdopen (custom_std_fds[1], "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);
+    }
+  ESTREAM_LIST_UNLOCK;
+  return stream;
 }
 
 
@@ -2250,7 +2511,7 @@ es_freopen (const char *ES__RESTRICT path, const char *ES__RESTRICT mode,
          if (create_called)
            es_func_fd_destroy (cookie);
       
-         es_destroy (stream);
+         es_destroy (stream, 0);
          stream = NULL;
        }
       else
@@ -2259,9 +2520,9 @@ es_freopen (const char *ES__RESTRICT path, const char *ES__RESTRICT mode,
   else
     {
       /* FIXME?  We don't support re-opening at the moment.  */
-      errno = EINVAL;
+      _set_errno (EINVAL);
       es_deinitialize (stream);
-      es_destroy (stream);
+      es_destroy (stream, 0);
       stream = NULL;
     }
 
@@ -2274,7 +2535,7 @@ es_fclose (estream_t stream)
 {
   int err;
 
-  err = es_destroy (stream);
+  err = es_destroy (stream, 0);
 
   return err;
 }
@@ -2376,6 +2637,23 @@ es_clearerr (estream_t stream)
 }
 
 
+static int
+do_fflush (estream_t stream)
+{
+  int err;
+  
+  if (stream->flags.writing)
+    err = es_flush (stream);
+  else
+    {
+      es_empty (stream);
+      err = 0;
+    }
+
+  return err;
+}
+
+
 int
 es_fflush (estream_t stream)
 {
@@ -2384,17 +2662,11 @@ es_fflush (estream_t stream)
   if (stream)
     {
       ESTREAM_LOCK (stream);
-      if (stream->flags.writing)
-       err = es_flush (stream);
-      else
-       {
-         es_empty (stream);
-         err = 0;
-       }
+      err = do_fflush (stream);
       ESTREAM_UNLOCK (stream);
     }
   else
-    err = es_list_iterate (es_fflush);
+    err = es_list_iterate (do_fflush);
 
   return err ? EOF : 0;
 }
@@ -2612,26 +2884,46 @@ es_fwrite (const void *ES__RESTRICT ptr, size_t size, size_t nitems,
 
 
 char *
-es_fgets (char *ES__RESTRICT s, int n, estream_t ES__RESTRICT stream)
+es_fgets (char *ES__RESTRICT buffer, int length, estream_t ES__RESTRICT stream)
 {
-  char *ret = NULL;
-  
-  if (n)
+  unsigned char *s = (unsigned char*)buffer;
+  int c;
+   
+  if (!length)
+    return NULL;
+     
+  c = EOF;
+  ESTREAM_LOCK (stream);
+  while (length > 1 && (c = es_getc_unlocked (stream)) != EOF && c != '\n')
     {
-      int err;
-      
-      ESTREAM_LOCK (stream);
-      err = doreadline (stream, n, &s, NULL);
-      ESTREAM_UNLOCK (stream);
-      if (! err)
-       ret = s;
+      *s++ = c;
+      length--;
     }
-  
-  return ret;
+  ESTREAM_UNLOCK (stream);
+
+  if (c == EOF && s == (unsigned char*)buffer)
+    return NULL; /* Nothing read.  */
+
+  if (c != EOF && length > 1)
+    *s++ = c;
+
+  *s = 0;
+  return buffer;
 }
 
 
 int
+es_fputs_unlocked (const char *ES__RESTRICT s, estream_t ES__RESTRICT stream)
+{
+  size_t length;
+  int err;
+
+  length = strlen (s);
+  err = es_writen (stream, s, length, NULL);
+  return err ? EOF : 0;
+}
+
+int
 es_fputs (const char *ES__RESTRICT s, estream_t ES__RESTRICT stream)
 {
   size_t length;
@@ -2670,7 +2962,7 @@ es_getline (char *ES__RESTRICT *ES__RESTRICT lineptr, size_t *ES__RESTRICT n,
 
          void *p;
 
-         p = ES_MEM_REALLOC (*lineptr, line_n + 1);
+         p = mem_realloc (*lineptr, line_n + 1);
          if (! p)
            err = -1;
          else
@@ -2686,7 +2978,7 @@ es_getline (char *ES__RESTRICT *ES__RESTRICT lineptr, size_t *ES__RESTRICT n,
          if (*n != line_n)
            *n = line_n;
        }
-      ES_MEM_FREE (line);
+      mem_free (line);
     }
   else
     {
@@ -2697,7 +2989,7 @@ es_getline (char *ES__RESTRICT *ES__RESTRICT lineptr, size_t *ES__RESTRICT n,
 
  out:
 
-  return err ? err : line_n;
+  return err ? err : (ssize_t)line_n;
 }
 
 
@@ -2746,7 +3038,7 @@ es_read_line (estream_t stream,
     { 
       /* No buffer given - allocate a new one. */
       length = 256;
-      buffer = ES_MEM_ALLOC (length);
+      buffer = mem_alloc (length);
       *addr_of_buffer = buffer;
       if (!buffer)
         {
@@ -2760,9 +3052,9 @@ es_read_line (estream_t stream,
 
   if (length < 4)
     {
-      /* This should never happen. If it does, the fucntion has been
+      /* This should never happen. If it does, the function has been
          called with wrong arguments. */
-      errno = EINVAL;
+      _set_errno (EINVAL);
       return -1;
     }
   length -= 3; /* Reserve 3 bytes for CR,LF,EOL. */
@@ -2787,14 +3079,16 @@ es_read_line (estream_t stream,
             }
           length += 3; /* Adjust for the reserved bytes. */
           length += length < 1024? 256 : 1024;
-          *addr_of_buffer = ES_MEM_REALLOC (buffer, length);
+          *addr_of_buffer = mem_realloc (buffer, length);
           if (!*addr_of_buffer)
             {
               int save_errno = errno;
-              ES_MEM_FREE (buffer); 
-              *length_of_buffer = *max_length = 0;
+              mem_free (buffer); 
+              *length_of_buffer = 0;
+              if (max_length)
+                *max_length = 0;
               ESTREAM_UNLOCK (stream);
-              errno = save_errno;
+              _set_errno (save_errno);
               return -1;
             }
           buffer = *addr_of_buffer;
@@ -2819,8 +3113,16 @@ es_read_line (estream_t stream,
 void
 es_free (void *a)
 {
-  if (a)
-    ES_MEM_FREE (a);
+  mem_free (a);
+}
+
+
+int
+es_vfprintf_unlocked (estream_t ES__RESTRICT stream,
+                      const char *ES__RESTRICT format,
+                      va_list ap)
+{
+  return es_print (stream, format, ap);
 }
 
 
@@ -2838,9 +3140,9 @@ es_vfprintf (estream_t ES__RESTRICT stream, const char *ES__RESTRICT format,
 }
 
 
-static int
+int
 es_fprintf_unlocked (estream_t ES__RESTRICT stream,
-           const char *ES__RESTRICT format, ...)
+                     const char *ES__RESTRICT format, ...)
 {
   int ret;
   
@@ -2869,9 +3171,123 @@ es_fprintf (estream_t ES__RESTRICT stream,
   return ret;
 }
 
+/* A variant of asprintf.  The function returns the allocated buffer
+   or NULL on error; ERRNO is set in the error case.  The caller
+   should use es_free to release the buffer.  This function actually
+   belongs into estream-printf but we put it here as a convenience
+   and because es_free is required anyway.  */
+char *
+es_asprintf (const char *ES__RESTRICT format, ...)
+{
+  int rc;
+  va_list ap;
+  char *buf;
+
+  va_start (ap, format);
+  rc = estream_vasprintf (&buf, format, ap);
+  va_end (ap);
+  if (rc < 0)
+    return NULL;
+  return buf;
+}
+
+
+/* A variant of vasprintf.  The function returns the allocated buffer
+   or NULL on error; ERRNO is set in the error case.  The caller
+   should use es_free to release the buffer.  This function actually
+   belongs into estream-printf but we put it here as a convenience
+   and because es_free is required anyway.  */
+char * 
+es_vasprintf (const char *ES__RESTRICT format, va_list ap)
+{
+  int rc;
+  char *buf;
+
+  rc = estream_vasprintf (&buf, format, ap);
+  if (rc < 0)
+    return NULL;
+  return buf;
+}
+
+
 static int
 tmpfd (void)
 {
+#ifdef HAVE_W32_SYSTEM
+  int attempts, n;
+#ifdef HAVE_W32CE_SYSTEM
+  wchar_t buffer[MAX_PATH+9+12+1];
+# define mystrlen(a) wcslen (a)
+  wchar_t *name, *p;
+#else
+  char buffer[MAX_PATH+9+12+1];
+# define mystrlen(a) strlen (a)
+  char *name, *p;
+#endif
+  HANDLE file;
+  int pid = GetCurrentProcessId ();
+  unsigned int value;
+  int i;
+  
+  n = GetTempPath (MAX_PATH+1, buffer);
+  if (!n || n > MAX_PATH || mystrlen (buffer) > MAX_PATH)
+    {
+      _set_errno (ENOENT);
+      return -1;
+    }
+  p = buffer + mystrlen (buffer);
+#ifdef HAVE_W32CE_SYSTEM
+  wcscpy (p, L"_estream");
+#else
+  strcpy (p, "_estream");
+#endif
+  p += 8;
+  /* We try to create the directory but don't care about an error as
+     it may already exist and the CreateFile would throw an error
+     anyway.  */
+  CreateDirectory (buffer, NULL);
+  *p++ = '\\';
+  name = p;
+  for (attempts=0; attempts < 10; attempts++)
+    {
+      p = name;
+      value = (GetTickCount () ^ ((pid<<16) & 0xffff0000));
+      for (i=0; i < 8; i++)
+        {
+          *p++ = tohex (((value >> 28) & 0x0f));
+          value <<= 4;
+        }
+#ifdef HAVE_W32CE_SYSTEM
+      wcscpy (p, L".tmp");
+#else
+      strcpy (p, ".tmp");
+#endif
+      file = CreateFile (buffer,
+                         GENERIC_READ | GENERIC_WRITE,
+                         0,
+                         NULL,
+                         CREATE_NEW,
+                         FILE_ATTRIBUTE_TEMPORARY | FILE_FLAG_DELETE_ON_CLOSE,
+                         NULL);
+      if (file != INVALID_HANDLE_VALUE)
+        {
+#ifdef HAVE_W32CE_SYSTEM
+          int fd = (int)file;
+#else
+          int fd = _open_osfhandle ((long)file, 0);
+          if (fd == -1)
+            {
+              CloseHandle (file);
+              return -1;
+            }
+#endif
+          return fd;
+        }
+      Sleep (1); /* One ms as this is the granularity of GetTickCount.  */
+    }
+  _set_errno (ENOENT);
+  return -1;
+#else /*!HAVE_W32_SYSTEM*/
   FILE *fp;
   int fp_fd;
   int fd;
@@ -2892,6 +3308,7 @@ tmpfd (void)
     fclose (fp);
 
   return fd;
+#endif /*!HAVE_W32_SYSTEM*/
 }
 
 estream_t
@@ -2921,7 +3338,7 @@ es_tmpfile (void)
     goto out;
 
   create_called = 1;
-  err = es_create (&stream, cookie, fd, estream_functions_fd, modeflags);
+  err = es_create (&stream, cookie, fd, estream_functions_fd, modeflags, 0);
 
  out:
 
@@ -2944,8 +3361,8 @@ es_setvbuf (estream_t ES__RESTRICT stream,
 {
   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);
@@ -2953,7 +3370,7 @@ es_setvbuf (estream_t ES__RESTRICT stream,
     }
   else
     {
-      errno = EINVAL;
+      _set_errno (EINVAL);
       err = -1;
     }
 
@@ -3009,7 +3426,7 @@ es_write_sanitized (estream_t ES__RESTRICT stream,
   for (; length; length--, p++, count++)
     {
       if (*p < 0x20 
-          || (*p >= 0x7f && *p < 0xa0)
+          || *p == 0x7f
           || (delimiters 
               && (strchr (delimiters, *p) || *p == '\\')))
         {
@@ -3080,6 +3497,8 @@ es_write_hexstring (estream_t ES__RESTRICT stream,
   const unsigned char *s;
   size_t count = 0;
 
+  (void)reserved;
+
 #define tohex(n) ((n) < 10 ? ((n) + '0') : (((n) - 10) + 'A'))
 
   if (!length)
@@ -3139,7 +3558,7 @@ es_write_sanitized_utf8_buffer (estream_t stream,
         *bytes_written = strlen (buf);
       ret = es_fputs (buf, stream);
       xfree (buf);
-      return i;
+      return ret == EOF? ret : (int)i;
     }
   else
     return es_write_sanitized (stream, p, length, delimiters, bytes_written);