Imported Upstream version 2.0.19upstream/2.0.19

1 files changed, 3687 insertions, 0 deletions

diff --git a/common/estream.c b/common/estream.c
new file mode 100644
index 0000000..2d68415
--- /dev/null
+++ b/common/estream.c
@@ -0,0 +1,3687 @@
+/* estream.c - Extended Stream I/O Library
+ * 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 2 of the License,
+ * or (at your option) any later version.
+ *
+ * Libestream is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with 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 <estream-support.h>
+#endif
+
+#ifdef HAVE_CONFIG_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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdarg.h>
+#include <fcntl.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
+#endif
+
+#ifdef HAVE_PTH
+# include <pth.h>
+#endif
+
+/* This is for the special hack to use estream.c in GnuPG.  */
+#ifdef GNUPG_MAJOR_VERSION
+# include "../common/util.h"
+#endif
+
+#ifndef HAVE_MKSTEMP
+int mkstemp (char *template);
+#endif
+
+#ifndef HAVE_MEMRCHR
+void *memrchr (const void *block, int c, size_t size);
+#endif
+
+#include <estream.h>
+#include <estream-printf.h>
+
+
+
+#ifndef O_BINARY
+#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);
+
+
+
+
+/* Buffer management layer.  */
+
+#define BUFFER_BLOCK_SIZE  BUFSIZ
+#define BUFFER_UNREAD_SIZE 16
+
+
+
+/* Locking.  */
+
+#ifdef HAVE_PTH
+typedef pth_mutex_t estream_mutex_t;
+#else /*!HAVE_PTH*/
+typedef void *estream_mutex_t;
+#endif /*!HAVE_PTH*/
+
+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;
+}
+
+
+#ifdef HAVE_PTH
+
+static int estream_pth_killed;
+
+# define ESTREAM_MUTEX_INITIALIZER PTH_MUTEX_INIT
+# define ESTREAM_MUTEX_LOCK(mutex)                              \
+  (estream_pth_killed ? dummy_mutex_call_void ((mutex))         \
+   : pth_mutex_acquire (&(mutex), 0, NULL))
+# define ESTREAM_MUTEX_UNLOCK(mutex)                            \
+  (estream_pth_killed ? dummy_mutex_call_void ((mutex))         \
+   : pth_mutex_release (&(mutex)))
+# define ESTREAM_MUTEX_TRYLOCK(mutex)                                   \
+  (estream_pth_killed ? dummy_mutex_call_int ((mutex))                  \
+   : ((pth_mutex_acquire (&(mutex), 1, NULL) == TRUE)? 0:-1))
+# define ESTREAM_MUTEX_INITIALIZE(mutex)                        \
+  (estream_pth_killed ? dummy_mutex_call_void ((mutex))         \
+   : pth_mutex_init (&(mutex)))
+
+#else /*!HAVE_PTH*/
+
+# 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 /*!HAVE_PTH*/
+
+/* Primitive system I/O.  */
+
+#ifdef HAVE_PTH
+# define ESTREAM_SYS_READ  es_pth_read
+# define ESTREAM_SYS_WRITE es_pth_write
+# define ESTREAM_SYS_YIELD() \
+  do { if (!estream_pth_killed) pth_yield (NULL); } while (0)
+#else
+# define ESTREAM_SYS_READ  read
+# define ESTREAM_SYS_WRITE write
+# define ESTREAM_SYS_YIELD() do { } while (0)
+#endif
+
+/* Misc definitions.  */
+
+#define ES_DEFAULT_OPEN_MODE (S_IRUSR | S_IWUSR)
+
+/* An internal stream object.  */
+
+struct estream_internal
+{
+  unsigned char buffer[BUFFER_BLOCK_SIZE];
+  unsigned char unread_buffer[BUFFER_UNREAD_SIZE];
+  estream_mutex_t lock;		 /* Lock. */
+  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;
+  es_cookie_close_function_t func_close;
+  int strategy;
+  int fd;
+  struct
+  {
+    unsigned int err: 1;
+    unsigned int eof: 1;
+  } indicators;
+  unsigned int deallocate_buffer: 1;
+  unsigned int is_stdstream:1;   /* This is a standard stream.  */
+  unsigned int stdstream_fd:2;   /* 0, 1 or 2 for a standard stream.  */
+  unsigned int print_err: 1;     /* Error in print_fun_writer.  */
+  unsigned int printable_fname_inuse: 1;  /* es_fname_get has been used.  */
+  int print_errno;               /* Errno from print_fun_writer.  */
+  size_t print_ntotal;           /* Bytes written from in print_fun_writer. */
+  FILE *print_fp;                /* Stdio stream used by print_fun_writer.  */
+};
+
+
+typedef struct estream_internal *estream_internal_t;
+
+#define ESTREAM_LOCK(stream) ESTREAM_MUTEX_LOCK (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
+{
+  estream_t car;
+  estream_list_t cdr;
+  estream_list_t *prev_cdr;
+};
+
+static estream_list_t estream_list;
+static estream_mutex_t estream_list_lock;
+
+#define ESTREAM_LIST_LOCK   ESTREAM_MUTEX_LOCK   (estream_list_lock)
+#define ESTREAM_LIST_UNLOCK ESTREAM_MUTEX_UNLOCK (estream_list_lock)
+
+/* File descriptors registered to be used as the standard file handles. */
+static int custom_std_fds[3];
+static unsigned char custom_std_fds_valid[3];
+
+
+#ifndef EOPNOTSUPP
+# define EOPNOTSUPP ENOSYS
+#endif
+
+
+/* Local prototypes.  */
+static void fname_set_internal (estream_t stream, const char *fname, int quote);
+
+
+
+
+/* Macros.  */
+
+/* Calculate array dimension.  */
+#ifndef DIM
+#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) \
+  do                                                           \
+    {                                                          \
+      tmp_variable = expression;                               \
+      if ((! variable) && tmp_variable)                        \
+        variable = tmp_variable;                               \
+    }                                                          \
+  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.  If
+   WITH_LOCKED_LIST is true we assumed that the list of streams is
+   already locked.  */
+static int
+es_list_add (estream_t stream, int with_locked_list)
+{
+  estream_list_t list_obj;
+  int ret;
+
+  list_obj = mem_alloc (sizeof (*list_obj));
+  if (! list_obj)
+    ret = -1;
+  else
+    {
+      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;
+      if (!with_locked_list)
+        ESTREAM_LIST_UNLOCK;
+      ret = 0;
+    }
+
+  return ret;
+}
+
+/* Remove STREAM from the list of registered stream objects.  */
+static void
+es_list_remove (estream_t stream, int with_locked_list)
+{
+  estream_list_t list_obj;
+
+  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;
+	mem_free (list_obj);
+	break;
+      }
+  if (!with_locked_list)
+    ESTREAM_LIST_UNLOCK;
+}
+
+/* Type of an stream-iterator-function.  */
+typedef int (*estream_iterator_t) (estream_t stream);
+
+/* Iterate over list of registered streams, calling ITERATOR for each
+   of them.  */
+static int
+es_list_iterate (estream_iterator_t iterator)
+{
+  estream_list_t list_obj;
+  int ret = 0;
+
+  ESTREAM_LIST_LOCK;
+  for (list_obj = estream_list; list_obj; list_obj = list_obj->cdr)
+    ret |= (*iterator) (list_obj->car);
+  ESTREAM_LIST_UNLOCK;
+
+  return ret;
+}
+
+
+
+/*
+ * 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)
+{
+  if (estream_pth_killed)
+    return read (fd, buffer, size);
+  else
+    {
+# 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)
+{
+  if (estream_pth_killed)
+    return write (fd, buffer, size);
+  else
+    {
+# 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*/
+
+
+
+static void
+es_deinit (void)
+{
+  /* Flush all streams. */
+  es_fflush (NULL);
+}
+
+
+/* A replacement for pth_kill.  The reason we need this is that after
+   a pth_kill all our pth functions may not be used anymore.  Thus
+   applications using estream and pth need to use this function
+   instead of a plain pth_kill.  */
+int
+es_pth_kill (void)
+{
+#ifdef HAVE_PTH
+  int rc;
+
+  rc = pth_kill ();
+  if (rc)
+    estream_pth_killed = 1;
+  return rc;
+#else /*!HAVE_PTH*/
+  return 0;
+#endif /*!HAVE_PTH*/
+}
+
+
+/*
+ * Initialization.
+ */
+
+static int
+es_init_do (void)
+{
+  static int initialized;
+
+  if (!initialized)
+    {
+#ifdef HAVE_PTH
+      if (estream_pth_killed)
+        initialized = 1;
+      else
+        {
+          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;
+}
+
+
+
+/*
+ * I/O methods.
+ */
+
+/* Implementation of Memory I/O.  */
+
+/* Cookie for memory objects.  */
+typedef struct estream_cookie_mem
+{
+  unsigned int modeflags;	/* Open flags.  */
+  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;		/* Used length of data in MEMORY.  */
+  size_t block_size;		/* Block 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.  DATA is either NULL or a user
+   supplied buffer with the initial content 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,
+		    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;
+
+  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->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;
+    }
+
+  return err;
+}
+
+
+/* Read function for memory objects.  */
+static ssize_t
+es_func_mem_read (void *cookie, void *buffer, size_t size)
+{
+  estream_cookie_mem_t mem_cookie = cookie;
+  ssize_t ret;
+
+  if (size > mem_cookie->data_len - mem_cookie->offset)
+    size = mem_cookie->data_len - mem_cookie->offset;
+
+  if (size)
+    {
+      memcpy (buffer, mem_cookie->memory + mem_cookie->offset, size);
+      mem_cookie->offset += 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;
+  ssize_t ret;
+  size_t nleft;
+
+  if (!size)
+    return 0;  /* A flush is a NOP for memory objects.  */
+
+  if (mem_cookie->modeflags & O_APPEND)
+    {
+      /* Append to data.  */
+      mem_cookie->offset = mem_cookie->data_len;
+    }
+
+  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;
+
+  /* Enlarge the memory buffer if needed.  */
+  if (size > nleft)
+    {
+      unsigned char *newbuf;
+      size_t newsize;
+
+      if (!mem_cookie->memory_size)
+        newsize = size;  /* Not yet allocated.  */
+      else
+        newsize = mem_cookie->memory_size + (size - nleft);
+      if (newsize < mem_cookie->offset)
+        {
+          _set_errno (EINVAL);
+          return -1;
+        }
+
+      /* 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;
+        }
+
+      /* 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;
+
+      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;
+
+  switch (whence)
+    {
+    case SEEK_SET:
+      pos_new = *offset;
+      break;
+
+    case SEEK_CUR:
+      pos_new = mem_cookie->offset += *offset;
+      break;
+
+    case SEEK_END:
+      pos_new = mem_cookie->data_len += *offset;
+      break;
+
+    default:
+      _set_errno (EINVAL);
+      return -1;
+    }
+
+  if (pos_new > mem_cookie->memory_size)
+    {
+      size_t newsize;
+      void *newbuf;
+
+      if (!mem_cookie->flags.grow)
+	{
+	  _set_errno (ENOSPC);
+	  return -1;
+        }
+
+      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);
+      mem_cookie->data_len = pos_new;
+    }
+
+  mem_cookie->offset = pos_new;
+  *offset = pos_new;
+
+  return 0;
+}
+
+
+/* Destroy function for memory objects.  */
+static int
+es_func_mem_destroy (void *cookie)
+{
+  estream_cookie_mem_t mem_cookie = 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,
+    es_func_mem_write,
+    es_func_mem_seek,
+    es_func_mem_destroy
+  };
+
+
+
+/* Implementation of fd I/O.  */
+
+/* Cookie for fd objects.  */
+typedef struct estream_cookie_fd
+{
+  int fd;        /* The file descriptor we are using for actual output.  */
+  int no_close;  /* If set we won't close the file descriptor.  */
+} *estream_cookie_fd_t;
+
+/* Create function for fd objects.  */
+static int
+es_func_fd_create (void **cookie, int fd, unsigned int modeflags, int no_close)
+{
+  estream_cookie_fd_t fd_cookie;
+  int err;
+
+  fd_cookie = mem_alloc (sizeof (*fd_cookie));
+  if (! fd_cookie)
+    err = -1;
+  else
+    {
+#ifdef HAVE_DOSISH_SYSTEM
+      /* Make sure it is in binary mode if requested.  */
+      if ( (modeflags & O_BINARY) )
+        setmode (fd, O_BINARY);
+#else
+      (void)modeflags;
+#endif
+      fd_cookie->fd = fd;
+      fd_cookie->no_close = no_close;
+      *cookie = fd_cookie;
+      err = 0;
+    }
+
+  return err;
+}
+
+/* Read function for fd objects.  */
+static ssize_t
+es_func_fd_read (void *cookie, void *buffer, size_t size)
+
+{
+  estream_cookie_fd_t file_cookie = cookie;
+  ssize_t bytes_read;
+
+  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;
+}
+
+/* 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;
+
+  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;
+}
+
+/* Seek function for fd objects.  */
+static int
+es_func_fd_seek (void *cookie, off_t *offset, int whence)
+{
+  estream_cookie_fd_t file_cookie = cookie;
+  off_t offset_new;
+  int err;
+
+  if (IS_INVALID_FD (file_cookie->fd))
+    {
+      _set_errno (ESPIPE);
+      err = -1;
+    }
+  else
+    {
+      offset_new = lseek (file_cookie->fd, *offset, whence);
+      if (offset_new == -1)
+        err = -1;
+      else
+        {
+          *offset = offset_new;
+          err = 0;
+        }
+    }
+
+  return err;
+}
+
+/* Destroy function for fd objects.  */
+static int
+es_func_fd_destroy (void *cookie)
+{
+  estream_cookie_fd_t fd_cookie = cookie;
+  int err;
+
+  if (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;
+
+  return err;
+}
+
+
+static es_cookie_io_functions_t estream_functions_fd =
+  {
+    es_func_fd_read,
+    es_func_fd_write,
+    es_func_fd_seek,
+    es_func_fd_destroy
+  };
+
+
+
+
+/* Implementation of FILE* I/O.  */
+
+/* Cookie for fp objects.  */
+typedef struct estream_cookie_fp
+{
+  FILE *fp;      /* The file pointer we are using for actual output.  */
+  int no_close;  /* If set we won't close the file pointer.  */
+} *estream_cookie_fp_t;
+
+/* Create function for fd objects.  */
+static int
+es_func_fp_create (void **cookie, FILE *fp,
+                   unsigned int modeflags, int no_close)
+{
+  estream_cookie_fp_t fp_cookie;
+  int err;
+
+  fp_cookie = mem_alloc (sizeof *fp_cookie);
+  if (!fp_cookie)
+    err = -1;
+  else
+    {
+#ifdef HAVE_DOSISH_SYSTEM
+      /* Make sure it is in binary mode if requested.  */
+      if ( (modeflags & O_BINARY) )
+        setmode (fileno (fp), O_BINARY);
+#else
+      (void)modeflags;
+#endif
+      fp_cookie->fp = fp;
+      fp_cookie->no_close = no_close;
+      *cookie = fp_cookie;
+      err = 0;
+    }
+
+  return err;
+}
+
+/* Read function for FILE* objects.  */
+static ssize_t
+es_func_fp_read (void *cookie, void *buffer, size_t size)
+
+{
+  estream_cookie_fp_t file_cookie = cookie;
+  ssize_t bytes_read;
+
+  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;
+}
+
+/* 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;
+
+
+  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;
+}
+
+/* Seek function for FILE* objects.  */
+static int
+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;
+    }
+
+  offset_new = ftell (file_cookie->fp);
+  if (offset_new == -1)
+    {
+      /* fprintf (stderr, "\nftell failed: errno=%d (%s)\n",  */
+      /*          errno,strerror (errno)); */
+      return -1;
+    }
+  *offset = offset_new;
+  return 0;
+}
+
+/* Destroy function for FILE* objects.  */
+static int
+es_func_fp_destroy (void *cookie)
+{
+  estream_cookie_fp_t fp_cookie = cookie;
+  int err;
+
+  if (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;
+
+  return err;
+}
+
+
+static es_cookie_io_functions_t estream_functions_fp =
+  {
+    es_func_fp_read,
+    es_func_fp_write,
+    es_func_fp_seek,
+    es_func_fp_destroy
+  };
+
+
+
+
+/* Implementation of file I/O.  */
+
+/* Create function for file objects.  */
+static int
+es_func_file_create (void **cookie, int *filedes,
+		     const char *path, unsigned int modeflags)
+{
+  estream_cookie_fd_t file_cookie;
+  int err;
+  int fd;
+
+  err = 0;
+  fd = -1;
+
+  file_cookie = mem_alloc (sizeof (*file_cookie));
+  if (! file_cookie)
+    {
+      err = -1;
+      goto out;
+    }
+
+  fd = open (path, modeflags, ES_DEFAULT_OPEN_MODE);
+  if (fd == -1)
+    {
+      err = -1;
+      goto out;
+    }
+#ifdef HAVE_DOSISH_SYSTEM
+  /* Make sure it is in binary mode if requested.  */
+  if ( (modeflags & O_BINARY) )
+    setmode (fd, O_BINARY);
+#endif
+
+  file_cookie->fd = fd;
+  file_cookie->no_close = 0;
+  *cookie = file_cookie;
+  *filedes = fd;
+
+ out:
+
+  if (err)
+    mem_free (file_cookie);
+
+  return err;
+}
+
+
+static int
+es_convert_mode (const char *mode, unsigned int *modeflags)
+{
+  unsigned int omode, oflags;
+
+  switch (*mode)
+    {
+    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;
+    }
+  for (mode++; *mode; mode++)
+    {
+      switch (*mode)
+        {
+        case '+':
+          omode = O_RDWR;
+          break;
+        case 'b':
+          oflags |= O_BINARY;
+          break;
+        case 'x':
+          oflags |= O_EXCL;
+          break;
+        default: /* Ignore unknown flags.  */
+          break;
+        }
+    }
+
+  *modeflags = (omode | oflags);
+  return 0;
+}
+
+
+
+/*
+ * Low level stream functionality.
+ */
+
+static int
+es_fill (estream_t stream)
+{
+  size_t bytes_read = 0;
+  int err;
+
+  if (!stream->intern->func_read)
+    {
+      _set_errno (EOPNOTSUPP);
+      err = -1;
+    }
+  else
+    {
+      es_cookie_read_function_t func_read = stream->intern->func_read;
+      ssize_t ret;
+
+      ret = (*func_read) (stream->intern->cookie,
+			  stream->buffer, stream->buffer_size);
+      if (ret == -1)
+	{
+	  bytes_read = 0;
+	  err = -1;
+	}
+      else
+	{
+	  bytes_read = ret;
+	  err = 0;
+	}
+    }
+
+  if (err)
+    stream->intern->indicators.err = 1;
+  else if (!bytes_read)
+    stream->intern->indicators.eof = 1;
+
+  stream->intern->offset += stream->data_len;
+  stream->data_len = bytes_read;
+  stream->data_offset = 0;
+
+  return err;
+}
+
+static int
+es_flush (estream_t stream)
+{
+  es_cookie_write_function_t func_write = stream->intern->func_write;
+  int err;
+
+  assert (stream->flags.writing);
+
+  if (stream->data_offset)
+    {
+      size_t bytes_written;
+      size_t data_flushed;
+      ssize_t ret;
+
+      if (! func_write)
+	{
+	  err = EOPNOTSUPP;
+	  goto out;
+	}
+
+      /* Note: to prevent an endless loop caused by user-provided
+	 write-functions that pretend to have written more bytes than
+	 they were asked to write, we have to check for
+	 "(stream->data_offset - data_flushed) > 0" instead of
+	 "stream->data_offset - data_flushed".  */
+
+      data_flushed = 0;
+      err = 0;
+
+      while ((((ssize_t) (stream->data_offset - data_flushed)) > 0) && (! err))
+	{
+	  ret = (*func_write) (stream->intern->cookie,
+			       stream->buffer + data_flushed,
+			       stream->data_offset - data_flushed);
+	  if (ret == -1)
+	    {
+	      bytes_written = 0;
+	      err = -1;
+	    }
+	  else
+	    bytes_written = ret;
+
+	  data_flushed += bytes_written;
+	  if (err)
+	    break;
+	}
+
+      stream->data_flushed += data_flushed;
+      if (stream->data_offset == data_flushed)
+	{
+	  stream->intern->offset += stream->data_offset;
+	  stream->data_offset = 0;
+	  stream->data_flushed = 0;
+
+	  /* Propagate flush event.  */
+	  (*func_write) (stream->intern->cookie, NULL, 0);
+	}
+    }
+  else
+    err = 0;
+
+ out:
+
+  if (err)
+    stream->intern->indicators.err = 1;
+
+  return err;
+}
+
+/* Discard buffered data for STREAM.  */
+static void
+es_empty (estream_t stream)
+{
+  assert (!stream->flags.writing);
+  stream->data_len = 0;
+  stream->data_offset = 0;
+  stream->unread_data_len = 0;
+}
+
+/* Initialize STREAM.  */
+static void
+es_initialize (estream_t stream,
+	       void *cookie, int fd, es_cookie_io_functions_t functions,
+               unsigned int modeflags)
+{
+  stream->intern->cookie = cookie;
+  stream->intern->opaque = NULL;
+  stream->intern->offset = 0;
+  stream->intern->func_read = functions.func_read;
+  stream->intern->func_write = functions.func_write;
+  stream->intern->func_seek = functions.func_seek;
+  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->print_ntotal = 0;
+  stream->intern->print_fp = NULL;
+  stream->intern->indicators.err = 0;
+  stream->intern->indicators.eof = 0;
+  stream->intern->is_stdstream = 0;
+  stream->intern->stdstream_fd = 0;
+  stream->intern->deallocate_buffer = 0;
+  stream->intern->printable_fname = NULL;
+  stream->intern->printable_fname_inuse = 0;
+
+  stream->data_len = 0;
+  stream->data_offset = 0;
+  stream->data_flushed = 0;
+  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 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) )
+    stream->flags.writing = 1;
+  else
+    stream->flags.writing = 0;
+}
+
+/* Deinitialize STREAM.  */
+static int
+es_deinitialize (estream_t stream)
+{
+  es_cookie_close_function_t func_close;
+  int err, tmp_err;
+
+  if (stream->intern->print_fp)
+    {
+      int save_errno = errno;
+      fclose (stream->intern->print_fp);
+      stream->intern->print_fp = NULL;
+      _set_errno (save_errno);
+    }
+
+  func_close = stream->intern->func_close;
+
+  err = 0;
+  if (stream->flags.writing)
+    SET_UNLESS_NONZERO (err, tmp_err, es_flush (stream));
+  if (func_close)
+    SET_UNLESS_NONZERO (err, tmp_err, (*func_close) (stream->intern->cookie));
+
+  mem_free (stream->intern->printable_fname);
+  stream->intern->printable_fname = NULL;
+  stream->intern->printable_fname_inuse = 0;
+
+  return err;
+}
+
+/* Create a new stream object, initialize it.  */
+static int
+es_create (estream_t *stream, void *cookie, int fd,
+	   es_cookie_io_functions_t functions, unsigned int modeflags,
+           int with_locked_list)
+{
+  estream_internal_t stream_internal_new;
+  estream_t stream_new;
+  int err;
+
+  stream_new = NULL;
+  stream_internal_new = NULL;
+
+  stream_new = mem_alloc (sizeof (*stream_new));
+  if (! stream_new)
+    {
+      err = -1;
+      goto out;
+    }
+
+  stream_internal_new = mem_alloc (sizeof (*stream_internal_new));
+  if (! stream_internal_new)
+    {
+      err = -1;
+      goto out;
+    }
+
+  stream_new->buffer = stream_internal_new->buffer;
+  stream_new->buffer_size = sizeof (stream_internal_new->buffer);
+  stream_new->unread_buffer = stream_internal_new->unread_buffer;
+  stream_new->unread_buffer_size = sizeof (stream_internal_new->unread_buffer);
+  stream_new->intern = stream_internal_new;
+
+  ESTREAM_MUTEX_INITIALIZE (stream_new->intern->lock);
+  es_initialize (stream_new, cookie, fd, functions, modeflags);
+
+  err = es_list_add (stream_new, with_locked_list);
+  if (err)
+    goto out;
+
+  *stream = stream_new;
+
+ out:
+
+  if (err)
+    {
+      if (stream_new)
+	{
+	  es_deinitialize (stream_new);
+	  mem_free (stream_new);
+	}
+    }
+
+  return err;
+}
+
+/* Deinitialize a stream object and destroy it.  */
+static int
+es_destroy (estream_t stream, int with_locked_list)
+{
+  int err = 0;
+
+  if (stream)
+    {
+      es_list_remove (stream, with_locked_list);
+      err = es_deinitialize (stream);
+      mem_free (stream->intern);
+      mem_free (stream);
+    }
+
+  return err;
+}
+
+/* Try to read BYTES_TO_READ bytes FROM STREAM into BUFFER in
+   unbuffered-mode, storing the amount of bytes read in
+   *BYTES_READ.  */
+static int
+es_read_nbf (estream_t ES__RESTRICT stream,
+	     unsigned char *ES__RESTRICT buffer,
+	     size_t bytes_to_read, size_t *ES__RESTRICT bytes_read)
+{
+  es_cookie_read_function_t func_read = stream->intern->func_read;
+  size_t data_read;
+  ssize_t ret;
+  int err;
+
+  data_read = 0;
+  err = 0;
+
+  while (bytes_to_read - data_read)
+    {
+      ret = (*func_read) (stream->intern->cookie,
+			  buffer + data_read, bytes_to_read - data_read);
+      if (ret == -1)
+	{
+	  err = -1;
+	  break;
+	}
+      else if (ret)
+	data_read += ret;
+      else
+	break;
+    }
+
+  stream->intern->offset += data_read;
+  *bytes_read = data_read;
+
+  return err;
+}
+
+/* Try to read BYTES_TO_READ bytes FROM STREAM into BUFFER in
+   fully-buffered-mode, storing the amount of bytes read in
+   *BYTES_READ.  */
+static int
+es_read_fbf (estream_t ES__RESTRICT stream,
+	     unsigned char *ES__RESTRICT buffer,
+	     size_t bytes_to_read, size_t *ES__RESTRICT bytes_read)
+{
+  size_t data_available;
+  size_t data_to_read;
+  size_t data_read;
+  int err;
+
+  data_read = 0;
+  err = 0;
+
+  while ((bytes_to_read - data_read) && (! err))
+    {
+      if (stream->data_offset == stream->data_len)
+	{
+	  /* Nothing more to read in current container, try to
+	     fill container with new data.  */
+	  err = es_fill (stream);
+	  if (! err)
+	    if (! stream->data_len)
+	      /* Filling did not result in any data read.  */
+	      break;
+	}
+
+      if (! err)
+	{
+	  /* Filling resulted in some new data.  */
+
+	  data_to_read = bytes_to_read - data_read;
+	  data_available = stream->data_len - stream->data_offset;
+	  if (data_to_read > data_available)
+	    data_to_read = data_available;
+
+	  memcpy (buffer + data_read,
+		  stream->buffer + stream->data_offset, data_to_read);
+	  stream->data_offset += data_to_read;
+	  data_read += data_to_read;
+	}
+    }
+
+  *bytes_read = data_read;
+
+  return err;
+}
+
+/* Try to read BYTES_TO_READ bytes FROM STREAM into BUFFER in
+   line-buffered-mode, storing the amount of bytes read in
+   *BYTES_READ.  */
+static int
+es_read_lbf (estream_t ES__RESTRICT stream,
+	     unsigned char *ES__RESTRICT buffer,
+	     size_t bytes_to_read, size_t *ES__RESTRICT bytes_read)
+{
+  int err;
+
+  err = es_read_fbf (stream, buffer, bytes_to_read, bytes_read);
+
+  return err;
+}
+
+/* Try to read BYTES_TO_READ bytes FROM STREAM into BUFFER, storing
+   *the amount of bytes read in BYTES_READ.  */
+static int
+es_readn (estream_t ES__RESTRICT stream,
+	  void *ES__RESTRICT buffer_arg,
+	  size_t bytes_to_read, size_t *ES__RESTRICT bytes_read)
+{
+  unsigned char *buffer = (unsigned char *)buffer_arg;
+  size_t data_read_unread, data_read;
+  int err;
+
+  data_read_unread = 0;
+  data_read = 0;
+  err = 0;
+
+  if (stream->flags.writing)
+    {
+      /* Switching to reading mode -> flush output.  */
+      err = es_flush (stream);
+      if (err)
+	goto out;
+      stream->flags.writing = 0;
+    }
+
+  /* Read unread data first.  */
+  while ((bytes_to_read - data_read_unread) && stream->unread_data_len)
+    {
+      buffer[data_read_unread]
+	= stream->unread_buffer[stream->unread_data_len - 1];
+      stream->unread_data_len--;
+      data_read_unread++;
+    }
+
+  switch (stream->intern->strategy)
+    {
+    case _IONBF:
+      err = es_read_nbf (stream,
+			 buffer + data_read_unread,
+			 bytes_to_read - data_read_unread, &data_read);
+      break;
+    case _IOLBF:
+      err = es_read_lbf (stream,
+			 buffer + data_read_unread,
+			 bytes_to_read - data_read_unread, &data_read);
+      break;
+    case _IOFBF:
+      err = es_read_fbf (stream,
+			 buffer + data_read_unread,
+			 bytes_to_read - data_read_unread, &data_read);
+      break;
+    }
+
+ out:
+
+  if (bytes_read)
+    *bytes_read = data_read_unread + data_read;
+
+  return err;
+}
+
+/* Try to unread DATA_N bytes from DATA into STREAM, storing the
+   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,
+	    size_t *ES__RESTRICT bytes_unread)
+{
+  size_t space_left;
+
+  space_left = stream->unread_buffer_size - stream->unread_data_len;
+
+  if (data_n > space_left)
+    data_n = space_left;
+
+  if (! data_n)
+    goto out;
+
+  memcpy (stream->unread_buffer + stream->unread_data_len, data, data_n);
+  stream->unread_data_len += data_n;
+  stream->intern->indicators.eof = 0;
+
+ out:
+
+  if (bytes_unread)
+    *bytes_unread = data_n;
+}
+
+/* Seek in STREAM.  */
+static int
+es_seek (estream_t ES__RESTRICT stream, off_t offset, int whence,
+	 off_t *ES__RESTRICT offset_new)
+{
+  es_cookie_seek_function_t func_seek = stream->intern->func_seek;
+  int err, ret;
+  off_t off;
+
+  if (! func_seek)
+    {
+      _set_errno (EOPNOTSUPP);
+      err = -1;
+      goto out;
+    }
+
+  if (stream->flags.writing)
+    {
+      /* Flush data first in order to prevent flushing it to the wrong
+	 offset.  */
+      err = es_flush (stream);
+      if (err)
+	goto out;
+      stream->flags.writing = 0;
+    }
+
+  off = offset;
+  if (whence == SEEK_CUR)
+    {
+      off = off - stream->data_len + stream->data_offset;
+      off -= stream->unread_data_len;
+    }
+
+  ret = (*func_seek) (stream->intern->cookie, &off, whence);
+  if (ret == -1)
+    {
+      err = -1;
+      goto out;
+    }
+
+  err = 0;
+  es_empty (stream);
+
+  if (offset_new)
+    *offset_new = off;
+
+  stream->intern->indicators.eof = 0;
+  stream->intern->offset = off;
+
+ out:
+
+  if (err)
+    stream->intern->indicators.err = 1;
+
+  return err;
+}
+
+/* Write BYTES_TO_WRITE bytes from BUFFER into STREAM in
+   unbuffered-mode, storing the amount of bytes written in
+   *BYTES_WRITTEN.  */
+static int
+es_write_nbf (estream_t ES__RESTRICT stream,
+	      const unsigned char *ES__RESTRICT buffer,
+	      size_t bytes_to_write, size_t *ES__RESTRICT bytes_written)
+{
+  es_cookie_write_function_t func_write = stream->intern->func_write;
+  size_t data_written;
+  ssize_t ret;
+  int err;
+
+  if (bytes_to_write && (! func_write))
+    {
+      err = EOPNOTSUPP;
+      goto out;
+    }
+
+  data_written = 0;
+  err = 0;
+
+  while (bytes_to_write - data_written)
+    {
+      ret = (*func_write) (stream->intern->cookie,
+			   buffer + data_written,
+			   bytes_to_write - data_written);
+      if (ret == -1)
+	{
+	  err = -1;
+	  break;
+	}
+      else
+	data_written += ret;
+    }
+
+  stream->intern->offset += data_written;
+  *bytes_written = data_written;
+
+ out:
+
+  return err;
+}
+
+/* Write BYTES_TO_WRITE bytes from BUFFER into STREAM in
+   fully-buffered-mode, storing the amount of bytes written in
+   *BYTES_WRITTEN.  */
+static int
+es_write_fbf (estream_t ES__RESTRICT stream,
+	      const unsigned char *ES__RESTRICT buffer,
+	      size_t bytes_to_write, size_t *ES__RESTRICT bytes_written)
+{
+  size_t space_available;
+  size_t data_to_write;
+  size_t data_written;
+  int err;
+
+  data_written = 0;
+  err = 0;
+
+  while ((bytes_to_write - data_written) && (! err))
+    {
+      if (stream->data_offset == stream->buffer_size)
+	/* Container full, flush buffer.  */
+	err = es_flush (stream);
+
+      if (! err)
+	{
+	  /* Flushing resulted in empty container.  */
+
+	  data_to_write = bytes_to_write - data_written;
+	  space_available = stream->buffer_size - stream->data_offset;
+	  if (data_to_write > space_available)
+	    data_to_write = space_available;
+
+	  memcpy (stream->buffer + stream->data_offset,
+		  buffer + data_written, data_to_write);
+	  stream->data_offset += data_to_write;
+	  data_written += data_to_write;
+	}
+    }
+
+  *bytes_written = data_written;
+
+  return err;
+}
+
+
+/* Write BYTES_TO_WRITE bytes from BUFFER into STREAM in
+   line-buffered-mode, storing the amount of bytes written in
+   *BYTES_WRITTEN.  */
+static int
+es_write_lbf (estream_t ES__RESTRICT stream,
+	      const unsigned char *ES__RESTRICT buffer,
+	      size_t bytes_to_write, size_t *ES__RESTRICT bytes_written)
+{
+  size_t data_flushed = 0;
+  size_t data_buffered = 0;
+  unsigned char *nlp;
+  int err = 0;
+
+  nlp = memrchr (buffer, '\n', bytes_to_write);
+  if (nlp)
+    {
+      /* Found a newline, directly write up to (including) this
+	 character.  */
+      err = es_flush (stream);
+      if (!err)
+	err = es_write_nbf (stream, buffer, nlp - buffer + 1, &data_flushed);
+    }
+
+  if (!err)
+    {
+      /* Write remaining data fully buffered.  */
+      err = es_write_fbf (stream, buffer + data_flushed,
+			  bytes_to_write - data_flushed, &data_buffered);
+    }
+
+  *bytes_written = data_flushed + data_buffered;
+  return err;
+}
+
+
+/* Write BYTES_TO_WRITE bytes from BUFFER into STREAM in, storing the
+   amount of bytes written in BYTES_WRITTEN.  */
+static int
+es_writen (estream_t ES__RESTRICT stream,
+	   const void *ES__RESTRICT buffer,
+	   size_t bytes_to_write, size_t *ES__RESTRICT bytes_written)
+{
+  size_t data_written;
+  int err;
+
+  data_written = 0;
+  err = 0;
+
+  if (!stream->flags.writing)
+    {
+      /* Switching to writing mode -> discard input data and seek to
+	 position at which reading has stopped.  We can do this only
+	 if a seek function has been registered. */
+      if (stream->intern->func_seek)
+        {
+          err = es_seek (stream, 0, SEEK_CUR, NULL);
+          if (err)
+            {
+              if (errno == ESPIPE)
+                err = 0;
+              else
+                goto out;
+            }
+        }
+    }
+
+  switch (stream->intern->strategy)
+    {
+    case _IONBF:
+      err = es_write_nbf (stream, buffer, bytes_to_write, &data_written);
+      break;
+
+    case _IOLBF:
+      err = es_write_lbf (stream, buffer, bytes_to_write, &data_written);
+      break;
+
+    case _IOFBF:
+      err = es_write_fbf (stream, buffer, bytes_to_write, &data_written);
+      break;
+    }
+
+ out:
+
+  if (bytes_written)
+    *bytes_written = data_written;
+  if (data_written)
+    if (!stream->flags.writing)
+      stream->flags.writing = 1;
+
+  return err;
+}
+
+
+static int
+es_peek (estream_t ES__RESTRICT stream, unsigned char **ES__RESTRICT data,
+	 size_t *ES__RESTRICT data_len)
+{
+  int err;
+
+  if (stream->flags.writing)
+    {
+      /* Switching to reading mode -> flush output.  */
+      err = es_flush (stream);
+      if (err)
+	goto out;
+      stream->flags.writing = 0;
+    }
+
+  if (stream->data_offset == stream->data_len)
+    {
+      /* Refill container.  */
+      err = es_fill (stream);
+      if (err)
+	goto out;
+    }
+
+  if (data)
+    *data = stream->buffer + stream->data_offset;
+  if (data_len)
+    *data_len = stream->data_len - stream->data_offset;
+  err = 0;
+
+ out:
+
+  return err;
+}
+
+
+/* Skip SIZE bytes of input data contained in buffer.  */
+static int
+es_skip (estream_t stream, size_t size)
+{
+  int err;
+
+  if (stream->data_offset + size > stream->data_len)
+    {
+      _set_errno (EINVAL);
+      err = -1;
+    }
+  else
+    {
+      stream->data_offset += size;
+      err = 0;
+    }
+
+  return err;
+}
+
+
+static int
+doreadline (estream_t ES__RESTRICT stream, size_t max_length,
+            char *ES__RESTRICT *ES__RESTRICT line,
+            size_t *ES__RESTRICT line_length)
+{
+  size_t space_left;
+  size_t line_size;
+  estream_t line_stream;
+  char *line_new;
+  void *line_stream_cookie;
+  char *newline;
+  unsigned char *data;
+  size_t data_len;
+  int err;
+
+  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);
+  if (err)
+    goto out;
+
+  err = es_create (&line_stream, line_stream_cookie, -1,
+		   estream_functions_mem, O_RDWR, 0);
+  if (err)
+    goto out;
+
+  space_left = max_length;
+  line_size = 0;
+  while (1)
+    {
+      if (max_length && (space_left == 1))
+	break;
+
+      err = es_peek (stream, &data, &data_len);
+      if (err || (! data_len))
+	break;
+
+      if (data_len > (space_left - 1))
+	data_len = space_left - 1;
+
+      newline = memchr (data, '\n', data_len);
+      if (newline)
+	{
+	  data_len = (newline - (char *) data) + 1;
+	  err = es_write (line_stream, data, data_len, NULL);
+	  if (! err)
+	    {
+	      space_left -= data_len;
+	      line_size += data_len;
+	      es_skip (stream, data_len);
+	      break;
+	    }
+	}
+      else
+	{
+	  err = es_write (line_stream, data, data_len, NULL);
+	  if (! err)
+	    {
+	      space_left -= data_len;
+	      line_size += data_len;
+	      es_skip (stream, data_len);
+	    }
+	}
+      if (err)
+	break;
+    }
+  if (err)
+    goto out;
+
+  /* Complete line has been written to line_stream.  */
+
+  if ((max_length > 1) && (! line_size))
+    {
+      stream->intern->indicators.eof = 1;
+      goto out;
+    }
+
+  err = es_seek (line_stream, 0, SEEK_SET, NULL);
+  if (err)
+    goto out;
+
+  if (! *line)
+    {
+      line_new = mem_alloc (line_size + 1);
+      if (! line_new)
+	{
+	  err = -1;
+	  goto out;
+	}
+    }
+  else
+    line_new = *line;
+
+  err = es_read (line_stream, line_new, line_size, NULL);
+  if (err)
+    goto out;
+
+  line_new[line_size] = '\0';
+
+  if (! *line)
+    *line = line_new;
+  if (line_length)
+    *line_length = line_size;
+
+ out:
+
+  if (line_stream)
+    es_destroy (line_stream, 0);
+  else if (line_stream_cookie)
+    es_func_mem_destroy (line_stream_cookie);
+
+  if (err)
+    {
+      if (! *line)
+	mem_free (line_new);
+      stream->intern->indicators.err = 1;
+    }
+
+  return err;
+}
+
+
+/* Output fucntion used for estream_format.  */
+static int
+print_writer (void *outfncarg, const char *buf, size_t buflen)
+{
+  estream_t stream = outfncarg;
+  size_t nwritten;
+  int rc;
+
+  nwritten = 0;
+  rc = es_writen (stream, buf, buflen, &nwritten);
+  stream->intern->print_ntotal += nwritten;
+  return rc;
+}
+
+
+/* The core of our printf function.  This is called in locked state. */
+static int
+es_print (estream_t ES__RESTRICT stream,
+	  const char *ES__RESTRICT format, va_list ap)
+{
+  int rc;
+
+  stream->intern->print_ntotal = 0;
+  rc = estream_format (print_writer, stream, format, ap);
+  if (rc)
+    return -1;
+  return (int)stream->intern->print_ntotal;
+}
+
+
+static void
+es_set_indicators (estream_t stream, int ind_err, int ind_eof)
+{
+  if (ind_err != -1)
+    stream->intern->indicators.err = ind_err ? 1 : 0;
+  if (ind_eof != -1)
+    stream->intern->indicators.eof = ind_eof ? 1 : 0;
+}
+
+
+static int
+es_get_indicator (estream_t stream, int ind_err, int ind_eof)
+{
+  int ret = 0;
+
+  if (ind_err)
+    ret = stream->intern->indicators.err;
+  else if (ind_eof)
+    ret = stream->intern->indicators.eof;
+
+  return ret;
+}
+
+
+static int
+es_set_buffering (estream_t ES__RESTRICT stream,
+		  char *ES__RESTRICT buffer, int mode, size_t size)
+{
+  int err;
+
+  /* Flush or empty buffer depending on mode.  */
+  if (stream->flags.writing)
+    {
+      err = es_flush (stream);
+      if (err)
+	goto out;
+    }
+  else
+    es_empty (stream);
+
+  es_set_indicators (stream, -1, 0);
+
+  /* Free old buffer in case that was allocated by this function.  */
+  if (stream->intern->deallocate_buffer)
+    {
+      stream->intern->deallocate_buffer = 0;
+      mem_free (stream->buffer);
+      stream->buffer = NULL;
+    }
+
+  if (mode == _IONBF)
+    stream->buffer_size = 0;
+  else
+    {
+      void *buffer_new;
+
+      if (buffer)
+	buffer_new = buffer;
+      else
+	{
+          if (!size)
+            size = BUFSIZ;
+	  buffer_new = mem_alloc (size);
+	  if (! buffer_new)
+	    {
+	      err = -1;
+	      goto out;
+	    }
+	}
+
+      stream->buffer = buffer_new;
+      stream->buffer_size = size;
+      if (! buffer)
+	stream->intern->deallocate_buffer = 1;
+    }
+  stream->intern->strategy = mode;
+  err = 0;
+
+ out:
+
+  return err;
+}
+
+
+static off_t
+es_offset_calculate (estream_t stream)
+{
+  off_t offset;
+
+  offset = stream->intern->offset + stream->data_offset;
+  if (offset < stream->unread_data_len)
+    /* Offset undefined.  */
+    offset = 0;
+  else
+    offset -= stream->unread_data_len;
+
+  return offset;
+}
+
+
+static void
+es_opaque_ctrl (estream_t ES__RESTRICT stream, void *ES__RESTRICT opaque_new,
+		void **ES__RESTRICT opaque_old)
+{
+  if (opaque_old)
+    *opaque_old = stream->intern->opaque;
+  if (opaque_new)
+    stream->intern->opaque = opaque_new;
+}
+
+
+static int
+es_get_fd (estream_t stream)
+{
+  return stream->intern->fd;
+}
+
+
+
+/* API.  */
+
+int
+es_init (void)
+{
+  int err;
+
+  err = es_init_do ();
+
+  return err;
+}
+
+estream_t
+es_fopen (const char *ES__RESTRICT path, const char *ES__RESTRICT mode)
+{
+  unsigned int modeflags;
+  int create_called;
+  estream_t stream;
+  void *cookie;
+  int err;
+  int fd;
+
+  stream = NULL;
+  cookie = NULL;
+  create_called = 0;
+
+  err = es_convert_mode (mode, &modeflags);
+  if (err)
+    goto out;
+
+  err = es_func_file_create (&cookie, &fd, path, modeflags);
+  if (err)
+    goto out;
+
+  create_called = 1;
+  err = es_create (&stream, cookie, fd, estream_functions_fd, modeflags, 0);
+  if (err)
+    goto out;
+
+  if (stream && path)
+    fname_set_internal (stream, path, 1);
+
+ out:
+
+  if (err && create_called)
+    (*estream_functions_fd.func_close) (cookie);
+
+  return stream;
+}
+
+
+estream_t
+es_mopen (unsigned char *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 modeflags;
+  int create_called;
+  estream_t stream;
+  void *cookie;
+  int err;
+
+  cookie = 0;
+  stream = NULL;
+  create_called = 0;
+
+  err = es_convert_mode (mode, &modeflags);
+  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);
+  if (err)
+    goto out;
+
+  create_called = 1;
+  err = es_create (&stream, cookie, -1, estream_functions_mem, modeflags, 0);
+
+ out:
+
+  if (err && create_called)
+    (*estream_functions_mem.func_close) (cookie);
+
+  return stream;
+}
+
+
+estream_t
+es_fopenmem (size_t memlimit, const char *ES__RESTRICT mode)
+{
+  unsigned int modeflags;
+  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;
+
+
+  if (es_func_mem_create (&cookie, NULL, 0, 0,
+                          BUFFER_BLOCK_SIZE, 1,
+                          mem_realloc, mem_free, modeflags,
+                          memlimit))
+    return NULL;
+
+  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,
+		es_cookie_io_functions_t functions)
+{
+  unsigned int modeflags;
+  estream_t stream;
+  int err;
+
+  stream = NULL;
+  modeflags = 0;
+
+  err = es_convert_mode (mode, &modeflags);
+  if (err)
+    goto out;
+
+  err = es_create (&stream, cookie, -1, functions, modeflags, 0);
+  if (err)
+    goto out;
+
+ out:
+
+  return stream;
+}
+
+
+estream_t
+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;
+
+  stream = NULL;
+  cookie = NULL;
+  create_called = 0;
+
+  err = es_convert_mode (mode, &modeflags);
+  if (err)
+    goto out;
+
+  err = es_func_fd_create (&cookie, filedes, modeflags, no_close);
+  if (err)
+    goto out;
+
+  create_called = 1;
+  err = es_create (&stream, cookie, filedes, estream_functions_fd,
+                   modeflags, with_locked_list);
+
+ out:
+
+  if (err && create_called)
+    (*estream_functions_fd.func_close) (cookie);
+
+  return stream;
+}
+
+estream_t
+es_fdopen (int filedes, const char *mode)
+{
+  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, 0);
+}
+
+
+estream_t
+do_fpopen (FILE *fp, const char *mode, int no_close, int with_locked_list)
+{
+  unsigned int modeflags;
+  int create_called;
+  estream_t stream;
+  void *cookie;
+  int err;
+
+  stream = NULL;
+  cookie = NULL;
+  create_called = 0;
+
+  err = es_convert_mode (mode, &modeflags);
+  if (err)
+    goto out;
+
+  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, fp? fileno (fp):-1, estream_functions_fp,
+                   modeflags, with_locked_list);
+
+ out:
+
+  if (err && create_called)
+    (*estream_functions_fp.func_close) (cookie);
+
+  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)
+{
+  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);
+}
+
+
+/* Set custom standard descriptors to be used for stdin, stdout and
+   stderr.  This function needs to be called before any of the
+   standard streams are accessed.  */
+void
+_es_set_std_fd (int no, int fd)
+{
+  ESTREAM_LIST_LOCK;
+  if (no >= 0 && no < 3 && !custom_std_fds_valid[no])
+    {
+      custom_std_fds[no] = fd;
+      custom_std_fds_valid[no] = 1;
+    }
+  ESTREAM_LIST_UNLOCK;
+}
+
+
+/* Return the stream used for stdin, stdout or stderr.  */
+estream_t
+_es_get_std_stream (int fd)
+{
+  estream_list_t list_obj;
+  estream_t stream = NULL;
+
+  fd %= 3; /* We only allow 0, 1 or 2 but we don't want to return an error. */
+  ESTREAM_LIST_LOCK;
+  for (list_obj = estream_list; list_obj; list_obj = list_obj->cdr)
+    if (list_obj->car->intern->is_stdstream
+        && list_obj->car->intern->stdstream_fd == fd)
+      {
+	stream = list_obj->car;
+	break;
+      }
+  if (!stream)
+    {
+      /* Standard stream not yet created.  We first try to create them
+         from registered file descriptors.  */
+      if (!fd && custom_std_fds_valid[0])
+        stream = do_fdopen (custom_std_fds[0], "r", 1, 1);
+      else if (fd == 1 && custom_std_fds_valid[1])
+        stream = do_fdopen (custom_std_fds[1], "a", 1, 1);
+      else if (custom_std_fds_valid[2])
+        stream = do_fdopen (custom_std_fds[2], "a", 1, 1);
+
+      if (!stream)
+        {
+          /* Second try is to use the standard C streams.  */
+          if (!fd)
+            stream = do_fpopen (stdin, "r", 1, 1);
+          else if (fd == 1)
+            stream = do_fpopen (stdout, "a", 1, 1);
+          else
+            stream = do_fpopen (stderr, "a", 1, 1);
+        }
+
+      if (!stream)
+        {
+          /* Last try: Create a bit bucket.  */
+          stream = do_fpopen (NULL, fd? "a":"r", 0, 1);
+          if (!stream)
+            {
+              fprintf (stderr, "fatal: error creating a dummy estream"
+                       " for %d: %s\n", fd, strerror (errno));
+              abort();
+            }
+        }
+
+      stream->intern->is_stdstream = 1;
+      stream->intern->stdstream_fd = fd;
+      if (fd == 2)
+        es_set_buffering (stream, NULL, _IOLBF, 0);
+      fname_set_internal (stream,
+                          fd == 0? "[stdin]" :
+                          fd == 1? "[stdout]" : "[stderr]", 0);
+    }
+  ESTREAM_LIST_UNLOCK;
+  return stream;
+}
+
+
+estream_t
+es_freopen (const char *ES__RESTRICT path, const char *ES__RESTRICT mode,
+	    estream_t ES__RESTRICT stream)
+{
+  int err;
+
+  if (path)
+    {
+      unsigned int modeflags;
+      int create_called;
+      void *cookie;
+      int fd;
+
+      cookie = NULL;
+      create_called = 0;
+
+      ESTREAM_LOCK (stream);
+
+      es_deinitialize (stream);
+
+      err = es_convert_mode (mode, &modeflags);
+      if (err)
+	goto leave;
+
+      err = es_func_file_create (&cookie, &fd, path, modeflags);
+      if (err)
+	goto leave;
+
+      create_called = 1;
+      es_initialize (stream, cookie, fd, estream_functions_fd, modeflags);
+
+    leave:
+
+      if (err)
+	{
+	  if (create_called)
+	    es_func_fd_destroy (cookie);
+
+	  es_destroy (stream, 0);
+	  stream = NULL;
+	}
+      else
+        {
+          if (stream && path)
+            fname_set_internal (stream, path, 1);
+          ESTREAM_UNLOCK (stream);
+        }
+    }
+  else
+    {
+      /* FIXME?  We don't support re-opening at the moment.  */
+      _set_errno (EINVAL);
+      es_deinitialize (stream);
+      es_destroy (stream, 0);
+      stream = NULL;
+    }
+
+  return stream;
+}
+
+
+int
+es_fclose (estream_t stream)
+{
+  int err;
+
+  err = es_destroy (stream, 0);
+
+  return err;
+}
+
+int
+es_fileno_unlocked (estream_t stream)
+{
+  return es_get_fd (stream);
+}
+
+
+void
+es_flockfile (estream_t stream)
+{
+  ESTREAM_LOCK (stream);
+}
+
+
+int
+es_ftrylockfile (estream_t stream)
+{
+  return ESTREAM_TRYLOCK (stream);
+}
+
+
+void
+es_funlockfile (estream_t stream)
+{
+  ESTREAM_UNLOCK (stream);
+}
+
+
+int
+es_fileno (estream_t stream)
+{
+  int ret;
+
+  ESTREAM_LOCK (stream);
+  ret = es_fileno_unlocked (stream);
+  ESTREAM_UNLOCK (stream);
+
+  return ret;
+}
+
+
+int
+es_feof_unlocked (estream_t stream)
+{
+  return es_get_indicator (stream, 0, 1);
+}
+
+
+int
+es_feof (estream_t stream)
+{
+  int ret;
+
+  ESTREAM_LOCK (stream);
+  ret = es_feof_unlocked (stream);
+  ESTREAM_UNLOCK (stream);
+
+  return ret;
+}
+
+
+int
+es_ferror_unlocked (estream_t stream)
+{
+  return es_get_indicator (stream, 1, 0);
+}
+
+
+int
+es_ferror (estream_t stream)
+{
+  int ret;
+
+  ESTREAM_LOCK (stream);
+  ret = es_ferror_unlocked (stream);
+  ESTREAM_UNLOCK (stream);
+
+  return ret;
+}
+
+
+void
+es_clearerr_unlocked (estream_t stream)
+{
+  es_set_indicators (stream, 0, 0);
+}
+
+
+void
+es_clearerr (estream_t stream)
+{
+  ESTREAM_LOCK (stream);
+  es_clearerr_unlocked (stream);
+  ESTREAM_UNLOCK (stream);
+}
+
+
+static int
+do_fflush (estream_t stream)
+{
+  int err;
+
+  if (stream->flags.writing)
+    err = es_flush (stream);
+  else
+    {
+      es_empty (stream);
+      err = 0;
+    }
+
+  return err;
+}
+
+
+int
+es_fflush (estream_t stream)
+{
+  int err;
+
+  if (stream)
+    {
+      ESTREAM_LOCK (stream);
+      err = do_fflush (stream);
+      ESTREAM_UNLOCK (stream);
+    }
+  else
+    err = es_list_iterate (do_fflush);
+
+  return err ? EOF : 0;
+}
+
+
+int
+es_fseek (estream_t stream, long int offset, int whence)
+{
+  int err;
+
+  ESTREAM_LOCK (stream);
+  err = es_seek (stream, offset, whence, NULL);
+  ESTREAM_UNLOCK (stream);
+
+  return err;
+}
+
+
+int
+es_fseeko (estream_t stream, off_t offset, int whence)
+{
+  int err;
+
+  ESTREAM_LOCK (stream);
+  err = es_seek (stream, offset, whence, NULL);
+  ESTREAM_UNLOCK (stream);
+
+  return err;
+}
+
+
+long int
+es_ftell (estream_t stream)
+{
+  long int ret;
+
+  ESTREAM_LOCK (stream);
+  ret = es_offset_calculate (stream);
+  ESTREAM_UNLOCK (stream);
+
+  return ret;
+}
+
+
+off_t
+es_ftello (estream_t stream)
+{
+  off_t ret = -1;
+
+  ESTREAM_LOCK (stream);
+  ret = es_offset_calculate (stream);
+  ESTREAM_UNLOCK (stream);
+
+  return ret;
+}
+
+
+void
+es_rewind (estream_t stream)
+{
+  ESTREAM_LOCK (stream);
+  es_seek (stream, 0L, SEEK_SET, NULL);
+  es_set_indicators (stream, 0, -1);
+  ESTREAM_UNLOCK (stream);
+}
+
+
+int
+_es_getc_underflow (estream_t stream)
+{
+  int err;
+  unsigned char c;
+  size_t bytes_read;
+
+  err = es_readn (stream, &c, 1, &bytes_read);
+
+  return (err || (! bytes_read)) ? EOF : c;
+}
+
+
+int
+_es_putc_overflow (int c, estream_t stream)
+{
+  unsigned char d = c;
+  int err;
+
+  err = es_writen (stream, &d, 1, NULL);
+
+  return err ? EOF : c;
+}
+
+
+int
+es_fgetc (estream_t stream)
+{
+  int ret;
+
+  ESTREAM_LOCK (stream);
+  ret = es_getc_unlocked (stream);
+  ESTREAM_UNLOCK (stream);
+
+  return ret;
+}
+
+
+int
+es_fputc (int c, estream_t stream)
+{
+  int ret;
+
+  ESTREAM_LOCK (stream);
+  ret = es_putc_unlocked (c, stream);
+  ESTREAM_UNLOCK (stream);
+
+  return ret;
+}
+
+
+int
+es_ungetc (int c, estream_t stream)
+{
+  unsigned char data = (unsigned char) c;
+  size_t data_unread;
+
+  ESTREAM_LOCK (stream);
+  es_unreadn (stream, &data, 1, &data_unread);
+  ESTREAM_UNLOCK (stream);
+
+  return data_unread ? c : EOF;
+}
+
+
+int
+es_read (estream_t ES__RESTRICT stream,
+	 void *ES__RESTRICT buffer, size_t bytes_to_read,
+	 size_t *ES__RESTRICT bytes_read)
+{
+  int err;
+
+  if (bytes_to_read)
+    {
+      ESTREAM_LOCK (stream);
+      err = es_readn (stream, buffer, bytes_to_read, bytes_read);
+      ESTREAM_UNLOCK (stream);
+    }
+  else
+    err = 0;
+
+  return err;
+}
+
+
+int
+es_write (estream_t ES__RESTRICT stream,
+	  const void *ES__RESTRICT buffer, size_t bytes_to_write,
+	  size_t *ES__RESTRICT bytes_written)
+{
+  int err;
+
+  if (bytes_to_write)
+    {
+      ESTREAM_LOCK (stream);
+      err = es_writen (stream, buffer, bytes_to_write, bytes_written);
+      ESTREAM_UNLOCK (stream);
+    }
+  else
+    err = 0;
+
+  return err;
+}
+
+
+size_t
+es_fread (void *ES__RESTRICT ptr, size_t size, size_t nitems,
+	  estream_t ES__RESTRICT stream)
+{
+  size_t ret, bytes;
+
+  if (size * nitems)
+    {
+      ESTREAM_LOCK (stream);
+      es_readn (stream, ptr, size * nitems, &bytes);
+      ESTREAM_UNLOCK (stream);
+
+      ret = bytes / size;
+    }
+  else
+    ret = 0;
+
+  return ret;
+}
+
+
+size_t
+es_fwrite (const void *ES__RESTRICT ptr, size_t size, size_t nitems,
+	   estream_t ES__RESTRICT stream)
+{
+  size_t ret, bytes;
+
+  if (size * nitems)
+    {
+      ESTREAM_LOCK (stream);
+      es_writen (stream, ptr, size * nitems, &bytes);
+      ESTREAM_UNLOCK (stream);
+
+      ret = bytes / size;
+    }
+  else
+    ret = 0;
+
+  return ret;
+}
+
+
+char *
+es_fgets (char *ES__RESTRICT buffer, int length, estream_t ES__RESTRICT stream)
+{
+  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')
+    {
+      *s++ = c;
+      length--;
+    }
+  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;
+  int err;
+
+  length = strlen (s);
+  ESTREAM_LOCK (stream);
+  err = es_writen (stream, s, length, NULL);
+  ESTREAM_UNLOCK (stream);
+
+  return err ? EOF : 0;
+}
+
+
+ssize_t
+es_getline (char *ES__RESTRICT *ES__RESTRICT lineptr, size_t *ES__RESTRICT n,
+	    estream_t ES__RESTRICT stream)
+{
+  char *line = NULL;
+  size_t line_n = 0;
+  int err;
+
+  ESTREAM_LOCK (stream);
+  err = doreadline (stream, 0, &line, &line_n);
+  ESTREAM_UNLOCK (stream);
+  if (err)
+    goto out;
+
+  if (*n)
+    {
+      /* Caller wants us to use his buffer.  */
+
+      if (*n < (line_n + 1))
+	{
+	  /* Provided buffer is too small -> resize.  */
+
+	  void *p;
+
+	  p = mem_realloc (*lineptr, line_n + 1);
+	  if (! p)
+	    err = -1;
+	  else
+	    {
+	      if (*lineptr != p)
+		*lineptr = p;
+	    }
+	}
+
+      if (! err)
+	{
+	  memcpy (*lineptr, line, line_n + 1);
+	  if (*n != line_n)
+	    *n = line_n;
+	}
+      mem_free (line);
+    }
+  else
+    {
+      /* Caller wants new buffers.  */
+      *lineptr = line;
+      *n = line_n;
+    }
+
+ out:
+
+  return err ? err : (ssize_t)line_n;
+}
+
+
+
+/* Same as fgets() but if the provided buffer is too short a larger
+   one will be allocated.  This is similar to getline. A line is
+   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.
+
+   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
+   MAX_LENGTH to 0.  If the returned value is less then 0 not enough
+   memory was enable or another error occurred; ERRNO is then set
+   accordingly.
+
+   If a line has been truncated, the file pointer is moved forward to
+   the end of the line so that the next read starts with the next
+   line.  Note that MAX_LENGTH must be re-initialzied in this case.
+
+   The caller initially needs to provide the address of a variable,
+   initialized to NULL, at ADDR_OF_BUFFER and don't change this value
+   anymore with the following invocations.  LENGTH_OF_BUFFER should be
+   the address of a variable, initialized to 0, which is also
+   maintained by this function.  Thus, both paramaters should be
+   considered the state of this function.
+
+   Note: The returned buffer is allocated with enough extra space to
+   allow the caller to append a CR,LF,Nul.  The buffer should be
+   released using es_free.
+ */
+ssize_t
+es_read_line (estream_t stream,
+              char **addr_of_buffer, size_t *length_of_buffer,
+              size_t *max_length)
+{
+  int c;
+  char  *buffer = *addr_of_buffer;
+  size_t length = *length_of_buffer;
+  size_t nbytes = 0;
+  size_t maxlen = max_length? *max_length : 0;
+  char *p;
+
+  if (!buffer)
+    {
+      /* No buffer given - allocate a new one. */
+      length = 256;
+      buffer = mem_alloc (length);
+      *addr_of_buffer = buffer;
+      if (!buffer)
+        {
+          *length_of_buffer = 0;
+          if (max_length)
+            *max_length = 0;
+          return -1;
+        }
+      *length_of_buffer = length;
+    }
+
+  if (length < 4)
+    {
+      /* This should never happen. If it does, the function has been
+         called with wrong arguments. */
+      _set_errno (EINVAL);
+      return -1;
+    }
+  length -= 3; /* Reserve 3 bytes for CR,LF,EOL. */
+
+  ESTREAM_LOCK (stream);
+  p = buffer;
+  while  ((c = es_getc_unlocked (stream)) != EOF)
+    {
+      if (nbytes == length)
+        {
+          /* Enlarge the buffer. */
+          if (maxlen && length > maxlen)
+            {
+              /* We are beyond our limit: Skip the rest of the line. */
+              while (c != '\n' && (c=es_getc_unlocked (stream)) != EOF)
+                ;
+              *p++ = '\n'; /* Always append a LF (we reserved some space). */
+              nbytes++;
+              if (max_length)
+                *max_length = 0; /* Indicate truncation. */
+              break; /* the while loop. */
+            }
+          length += 3; /* Adjust for the reserved bytes. */
+          length += length < 1024? 256 : 1024;
+          *addr_of_buffer = mem_realloc (buffer, length);
+          if (!*addr_of_buffer)
+            {
+              int save_errno = errno;
+              mem_free (buffer);
+              *length_of_buffer = 0;
+              if (max_length)
+                *max_length = 0;
+              ESTREAM_UNLOCK (stream);
+              _set_errno (save_errno);
+              return -1;
+            }
+          buffer = *addr_of_buffer;
+          *length_of_buffer = length;
+          length -= 3;
+          p = buffer + nbytes;
+	}
+      *p++ = c;
+      nbytes++;
+      if (c == '\n')
+        break;
+    }
+  *p = 0; /* Make sure the line is a string. */
+  ESTREAM_UNLOCK (stream);
+
+  return nbytes;
+}
+
+/* Wrapper around free() to match the memory allocation system used
+   by estream.  Should be used for all buffers returned to the caller
+   by libestream. */
+void
+es_free (void *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);
+}
+
+
+int
+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);
+
+  return ret;
+}
+
+
+int
+es_fprintf_unlocked (estream_t ES__RESTRICT stream,
+                     const char *ES__RESTRICT format, ...)
+{
+  int ret;
+
+  va_list ap;
+  va_start (ap, format);
+  ret = es_print (stream, format, ap);
+  va_end (ap);
+
+  return ret;
+}
+
+
+int
+es_fprintf (estream_t ES__RESTRICT stream,
+	    const char *ES__RESTRICT format, ...)
+{
+  int ret;
+
+  va_list ap;
+  va_start (ap, format);
+  ESTREAM_LOCK (stream);
+  ret = es_print (stream, format, ap);
+  ESTREAM_UNLOCK (stream);
+  va_end (ap);
+
+  return ret;
+}
+
+/* A variant of asprintf.  The function returns the allocated buffer
+   or NULL on error; ERRNO is set in the error case.  The caller
+   should use es_free to release the buffer.  This function actually
+   belongs into estream-printf but we put it here as a convenience
+   and because es_free is required anyway.  */
+char *
+es_asprintf (const char *ES__RESTRICT format, ...)
+{
+  int rc;
+  va_list ap;
+  char *buf;
+
+  va_start (ap, format);
+  rc = estream_vasprintf (&buf, format, ap);
+  va_end (ap);
+  if (rc < 0)
+    return NULL;
+  return buf;
+}
+
+
+/* A variant of vasprintf.  The function returns the allocated buffer
+   or NULL on error; ERRNO is set in the error case.  The caller
+   should use es_free to release the buffer.  This function actually
+   belongs into estream-printf but we put it here as a convenience
+   and because es_free is required anyway.  */
+char *
+es_vasprintf (const char *ES__RESTRICT format, va_list ap)
+{
+  int rc;
+  char *buf;
+
+  rc = estream_vasprintf (&buf, format, ap);
+  if (rc < 0)
+    return NULL;
+  return buf;
+}
+
+
+static int
+tmpfd (void)
+{
+#ifdef HAVE_W32_SYSTEM
+  int attempts, n;
+#ifdef HAVE_W32CE_SYSTEM
+  wchar_t buffer[MAX_PATH+9+12+1];
+# define mystrlen(a) wcslen (a)
+  wchar_t *name, *p;
+#else
+  char buffer[MAX_PATH+9+12+1];
+# define mystrlen(a) strlen (a)
+  char *name, *p;
+#endif
+  HANDLE file;
+  int pid = GetCurrentProcessId ();
+  unsigned int value;
+  int i;
+
+  n = GetTempPath (MAX_PATH+1, buffer);
+  if (!n || n > MAX_PATH || mystrlen (buffer) > MAX_PATH)
+    {
+      _set_errno (ENOENT);
+      return -1;
+    }
+  p = buffer + mystrlen (buffer);
+#ifdef HAVE_W32CE_SYSTEM
+  wcscpy (p, L"_estream");
+#else
+  strcpy (p, "_estream");
+#endif
+  p += 8;
+  /* We try to create the directory but don't care about an error as
+     it may already exist and the CreateFile would throw an error
+     anyway.  */
+  CreateDirectory (buffer, NULL);
+  *p++ = '\\';
+  name = p;
+  for (attempts=0; attempts < 10; attempts++)
+    {
+      p = name;
+      value = (GetTickCount () ^ ((pid<<16) & 0xffff0000));
+      for (i=0; i < 8; i++)
+        {
+          *p++ = tohex (((value >> 28) & 0x0f));
+          value <<= 4;
+        }
+#ifdef HAVE_W32CE_SYSTEM
+      wcscpy (p, L".tmp");
+#else
+      strcpy (p, ".tmp");
+#endif
+      file = CreateFile (buffer,
+                         GENERIC_READ | GENERIC_WRITE,
+                         0,
+                         NULL,
+                         CREATE_NEW,
+                         FILE_ATTRIBUTE_TEMPORARY | FILE_FLAG_DELETE_ON_CLOSE,
+                         NULL);
+      if (file != INVALID_HANDLE_VALUE)
+        {
+#ifdef HAVE_W32CE_SYSTEM
+          int fd = (int)file;
+#else
+          int fd = _open_osfhandle ((long)file, 0);
+          if (fd == -1)
+            {
+              CloseHandle (file);
+              return -1;
+            }
+#endif
+          return fd;
+        }
+      Sleep (1); /* One ms as this is the granularity of GetTickCount.  */
+    }
+  _set_errno (ENOENT);
+  return -1;
+#else /*!HAVE_W32_SYSTEM*/
+  FILE *fp;
+  int fp_fd;
+  int fd;
+
+  fp = NULL;
+  fd = -1;
+
+  fp = tmpfile ();
+  if (! fp)
+    goto out;
+
+  fp_fd = fileno (fp);
+  fd = dup (fp_fd);
+
+ out:
+
+  if (fp)
+    fclose (fp);
+
+  return fd;
+#endif /*!HAVE_W32_SYSTEM*/
+}
+
+estream_t
+es_tmpfile (void)
+{
+  unsigned int modeflags;
+  int create_called;
+  estream_t stream;
+  void *cookie;
+  int err;
+  int fd;
+
+  create_called = 0;
+  stream = NULL;
+  modeflags = O_RDWR | O_TRUNC | O_CREAT;
+  cookie = NULL;
+
+  fd = tmpfd ();
+  if (fd == -1)
+    {
+      err = -1;
+      goto out;
+    }
+
+  err = es_func_fd_create (&cookie, fd, modeflags, 0);
+  if (err)
+    goto out;
+
+  create_called = 1;
+  err = es_create (&stream, cookie, fd, estream_functions_fd, modeflags, 0);
+
+ out:
+
+  if (err)
+    {
+      if (create_called)
+	es_func_fd_destroy (cookie);
+      else if (fd != -1)
+	close (fd);
+      stream = NULL;
+    }
+
+  return stream;
+}
+
+
+int
+es_setvbuf (estream_t ES__RESTRICT stream,
+	    char *ES__RESTRICT buf, int type, size_t size)
+{
+  int err;
+
+  if ((type == _IOFBF || type == _IOLBF || type == _IONBF)
+      && (!buf || size || type == _IONBF))
+    {
+      ESTREAM_LOCK (stream);
+      err = es_set_buffering (stream, buf, type, size);
+      ESTREAM_UNLOCK (stream);
+    }
+  else
+    {
+      _set_errno (EINVAL);
+      err = -1;
+    }
+
+  return err;
+}
+
+
+void
+es_setbuf (estream_t ES__RESTRICT stream, char *ES__RESTRICT buf)
+{
+  ESTREAM_LOCK (stream);
+  es_set_buffering (stream, buf, buf ? _IOFBF : _IONBF, BUFSIZ);
+  ESTREAM_UNLOCK (stream);
+}
+
+void
+es_opaque_set (estream_t stream, void *opaque)
+{
+  ESTREAM_LOCK (stream);
+  es_opaque_ctrl (stream, opaque, NULL);
+  ESTREAM_UNLOCK (stream);
+}
+
+
+void *
+es_opaque_get (estream_t stream)
+{
+  void *opaque;
+
+  ESTREAM_LOCK (stream);
+  es_opaque_ctrl (stream, NULL, &opaque);
+  ESTREAM_UNLOCK (stream);
+
+  return opaque;
+}
+
+
+static void
+fname_set_internal (estream_t stream, const char *fname, int quote)
+{
+  if (stream->intern->printable_fname
+      && !stream->intern->printable_fname_inuse)
+    {
+      mem_free (stream->intern->printable_fname);
+      stream->intern->printable_fname = NULL;
+    }
+  if (stream->intern->printable_fname)
+    return; /* Can't change because it is in use.  */
+
+  if (*fname != '[')
+    quote = 0;
+  else
+    quote = !!quote;
+
+  stream->intern->printable_fname = mem_alloc (strlen (fname) + quote + 1);
+  if (fname)
+    {
+      if (quote)
+        stream->intern->printable_fname[0] = '\\';
+      strcpy (stream->intern->printable_fname+quote, fname);
+    }
+}
+
+
+/* Set the filename attribute of STREAM.  There is no error return.
+   as long as STREAM is valid.  This function is called internally by
+   functions which open a filename.  */
+void
+es_fname_set (estream_t stream, const char *fname)
+{
+  if (fname)
+    {
+      ESTREAM_LOCK (stream);
+      fname_set_internal (stream, fname, 1);
+      ESTREAM_UNLOCK (stream);
+    }
+}
+
+
+/* Return the filename attribute of STREAM.  In case no filename has
+   been set, "[?]" will be returned.  The returned file name is valid
+   as long as STREAM is valid.  */
+const char *
+es_fname_get (estream_t stream)
+{
+  const char *fname;
+
+  ESTREAM_LOCK (stream);
+  fname = stream->intern->printable_fname;
+  if (fname)
+    stream->intern->printable_fname_inuse = 1;
+  ESTREAM_UNLOCK (stream);
+  if (!fname)
+    fname = "[?]";
+  return fname;
+}
+
+
+/* Print a BUFFER to STREAM while replacing all control characters and
+   the characters in DELIMITERS by standard C escape sequences.
+   Returns 0 on success or -1 on error.  If BYTES_WRITTEN is not NULL
+   the number of bytes actually written are stored at this
+   address.  */
+int
+es_write_sanitized (estream_t ES__RESTRICT stream,
+                    const void * ES__RESTRICT buffer, size_t length,
+                    const char * delimiters,
+                    size_t * ES__RESTRICT bytes_written)
+{
+  const unsigned char *p = buffer;
+  size_t count = 0;
+  int ret;
+
+  ESTREAM_LOCK (stream);
+  for (; length; length--, p++, count++)
+    {
+      if (*p < 0x20
+          || *p == 0x7f
+          || (delimiters
+              && (strchr (delimiters, *p) || *p == '\\')))
+        {
+          es_putc_unlocked ('\\', stream);
+          count++;
+          if (*p == '\n')
+            {
+              es_putc_unlocked ('n', stream);
+              count++;
+            }
+          else if (*p == '\r')
+            {
+              es_putc_unlocked ('r', stream);
+              count++;
+            }
+          else if (*p == '\f')
+            {
+              es_putc_unlocked ('f', stream);
+              count++;
+            }
+          else if (*p == '\v')
+            {
+              es_putc_unlocked ('v', stream);
+              count++;
+            }
+          else if (*p == '\b')
+            {
+              es_putc_unlocked ('b', stream);
+              count++;
+            }
+          else if (!*p)
+            {
+              es_putc_unlocked('0', stream);
+              count++;
+            }
+          else
+            {
+              es_fprintf_unlocked (stream, "x%02x", *p);
+              count += 3;
+            }
+	}
+      else
+        {
+          es_putc_unlocked (*p, stream);
+          count++;
+        }
+    }
+
+  if (bytes_written)
+    *bytes_written = count;
+  ret =  es_ferror_unlocked (stream)? -1 : 0;
+  ESTREAM_UNLOCK (stream);
+
+  return ret;
+}
+
+
+/* Write LENGTH bytes of BUFFER to STREAM as a hex encoded string.
+   RESERVED must be 0.  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
+es_write_hexstring (estream_t ES__RESTRICT stream,
+                    const void *ES__RESTRICT buffer, size_t length,
+                    int reserved, size_t *ES__RESTRICT bytes_written )
+{
+  int ret;
+  const unsigned char *s;
+  size_t count = 0;
+
+  (void)reserved;
+
+#define tohex(n) ((n) < 10 ? ((n) + '0') : (((n) - 10) + 'A'))
+
+  if (!length)
+    return 0;
+
+  ESTREAM_LOCK (stream);
+
+  for (s = buffer; length; s++, length--)
+    {
+      es_putc_unlocked ( tohex ((*s>>4)&15), stream);
+      es_putc_unlocked ( tohex (*s&15), stream);
+      count += 2;
+    }
+
+  if (bytes_written)
+    *bytes_written = count;
+  ret = es_ferror_unlocked (stream)? -1 : 0;
+
+  ESTREAM_UNLOCK (stream);
+
+  return ret;
+
+#undef tohex
+}
+
+
+
+#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.
+
+   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 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++ )
+    {
+      if ( (p[i] & 0x80) )
+        break;
+    }
+  if (i < length)
+    {
+      int delim = delimiters? *delimiters : 0;
+      char *buf;
+      int ret;
+
+      /*(utf8 conversion already does the control character quoting). */
+      buf = utf8_to_native (p, length, delim);
+      if (bytes_written)
+        *bytes_written = strlen (buf);
+      ret = es_fputs (buf, stream);
+      xfree (buf);
+      return ret == EOF? ret : (int)i;
+    }
+  else
+    return es_write_sanitized (stream, p, length, delimiters, bytes_written);
+}
+#endif /*GNUPG_MAJOR_VERSION*/