In order to provide inheritance, it is necessary to make

	the base functions/methods visible so the extended object
	could reuse some base methods if necessary.  Inheritance
	is possible because we always add to the end of the vtable
	structure new functions.
	For example, mime_t object will be also a message_t.
	and it will be possible to do
	{
	  mime_t mime;
	  header_t header;
	  ...
	  message_get_header ((message_t)mime, header);
	}
	Another example is tcpstream(socket stream) extends
	fdstream(file description stream);
	Also the name of the functions have change to match better
	there purpose.

	* mailbox2/Makefile.am: lockfile.c added.
	* mailbox2/bstream.c: Reoganisation to make the
	functions visible.
	* mailbox2/dattribute.c: Likewise.
	* mailbox2/dotlock.c: Likewise.
	* mailbox2/fdstream.c: Likewise.
	* mailbox2/fstream.c: Likewise.
	* mailbox2/mapstream.c: Likewise.
	* mailbox2/memstream.c: Likewise.
	* mailbox2/pticket.c: Likewise.
	* mailbox2/sdebug.c: Likewise.
	* mailbox2/tcpstream.c: Likewise.

	* mailbox2/include/mailutils/Makefile.am: lockfile.h added.
	* mailbox2/include/mailutils/attribute.h: Add the new prototypes.
	* mailbox2/include/mailutils/mbox.h: Add the new prototypes.
	* mailbox2/include/mailutils/stream.h: Add the new prototypes.

	* mailbox2/include/mailutils/sys/Makefile.am: dattribute.h lockfile.h
	mapstream.h pticket.h added.
	* mailbox2/include/mailutils/sys/bstream.h: Add new prototypes.
	* mailbox2/include/mailutils/sys/fdstream.h: Likewise.
	* mailbox2/include/mailutils/sys/fstream.h: Likewise.
	* mailbox2/include/mailutils/sys/mbox.h: Likewise.
	* mailbox2/include/mailutils/sys/memstream.h: Likewise.
	* mailbox2/include/mailutils/sys/sdebug.h: Likewise.
	* mailbox2/include/mailutils/sys/tcpstream.h: Likewise.

+2001-09-22 Alain Magloire
+
+	In order to provide inheritance, it is necessary to make
+	the base functions/methods visible so the extended object
+	could reuse some base methods if necessary.  Inheritance
+	is possible because we always add to the end of the vtable
+	structure new functions.
+	For example, mime_t object will be also a message_t.
+	and it will be possible to do
+	{
+	  mime_t mime;
+	  header_t header;
+	  ...
+	  message_get_header ((message_t)mime, header);
+	}
+	Another example is tcpstream(socket stream) extends
+	fdstream(file description stream);
+	Also the name of the functions have change to match better
+	there purpose.
+
+	* mailbox2/Makefile.am: lockfile.c added.
+	* mailbox2/bstream.c: Reoganisation to make the
+	functions visible.
+	* mailbox2/dattribute.c: Likewise.
+	* mailbox2/dotlock.c: Likewise.
+	* mailbox2/fdstream.c: Likewise.
+	* mailbox2/fstream.c: Likewise.
+	* mailbox2/mapstream.c: Likewise.
+	* mailbox2/memstream.c: Likewise.
+	* mailbox2/pticket.c: Likewise.
+	* mailbox2/sdebug.c: Likewise.
+	* mailbox2/tcpstream.c: Likewise.
+
+	* mailbox2/include/mailutils/Makefile.am: lockfile.h added.
+	* mailbox2/include/mailutils/attribute.h: Add the new prototypes.
+	* mailbox2/include/mailutils/mbox.h: Add the new prototypes.
+	* mailbox2/include/mailutils/stream.h: Add the new prototypes.
+
+	* mailbox2/include/mailutils/sys/Makefile.am: dattribute.h lockfile.h
+	mapstream.h pticket.h added.
+	* mailbox2/include/mailutils/sys/bstream.h: Add new prototypes.
+	* mailbox2/include/mailutils/sys/fdstream.h: Likewise.
+	* mailbox2/include/mailutils/sys/fstream.h: Likewise.
+	* mailbox2/include/mailutils/sys/mbox.h: Likewise.
+	* mailbox2/include/mailutils/sys/memstream.h: Likewise.
+	* mailbox2/include/mailutils/sys/sdebug.h: Likewise.
+	* mailbox2/include/mailutils/sys/tcpstream.h: Likewise.
+
 2001-09-20 Sergey Poznyakoff
 2001-09-20 Sergey Poznyakoff
 
 
 	* frm/frm.c: Print newline not depending on the presence
 	* frm/frm.c: Print newline not depending on the presence
@@ -21,22 +69,21 @@
 	* mailbox2/sdebug.c (mu_debug_stream_create): New function
 	* mailbox2/sdebug.c (mu_debug_stream_create): New function
 	replace mu_debug_stdio_create().
 	replace mu_debug_stdio_create().
 	* mailbox2/fdstream.c (_fds_desroy): Do not close the stream
 	* mailbox2/fdstream.c (_fds_desroy): Do not close the stream
-	when distroying, it should have been done explicitely with
+	when destroying, it should have been done explicitely with
 	stream_close ();
 	stream_close ();
 	* mailbox2/fstream.c (_fs_desroy): Do not close the stream
 	* mailbox2/fstream.c (_fs_desroy): Do not close the stream
-	when distroying, it should have been done explicitely with
+	when destroying, it should have been done explicitely with
 	stream_close ();
 	stream_close ();
 	* mailbox2/mapstream.c (_map_desroy): Do not close the stream
 	* mailbox2/mapstream.c (_map_desroy): Do not close the stream
-	when distroying, it should have been done explicitely with
+	when destroying, it should have been done explicitely with
 	stream_close ();
 	stream_close ();
 	* mailbox2/memstream.c (_memory_desroy): Do not close the stream
 	* mailbox2/memstream.c (_memory_desroy): Do not close the stream
-	when distroying, it should have been done explicitely with
+	when destroying, it should have been done explicitely with
 	stream_close ();
 	stream_close ();
 	* mailbox2/tcpstream.c (_tcp_desroy): Do not close the stream
 	* mailbox2/tcpstream.c (_tcp_desroy): Do not close the stream
-	when distroying, it should have been done explicitely with
+	when destroying, it should have been done explicitely with
 	stream_close ();
 	stream_close ();
 
 
-
 2001-09-18 Sam Roberts
 2001-09-18 Sam Roberts
 
 
 	* mailbox/mbx_pop.c: Check url authentication type at
 	* mailbox/mbx_pop.c: Check url authentication type at
@@ -2144,7 +2191,7 @@
 2001-04-23  Alain Magloire
 2001-04-23  Alain Magloire
 
 
 	Sergey Poznyakoff noted: When the user's mailbox has zero size, mmap
 	Sergey Poznyakoff noted: When the user's mailbox has zero size, mmap
-	fails on Solaris. On GNU/Linux it reuturn NULL buf subsequent munmap
+	fails on Solaris. On GNU/Linux it return NULL buf subsequent munmap
 	fails.
 	fails.
 
 
 	* mailbox/mapfile_stream.c:  To take care of this, mfs->ptr is set
 	* mailbox/mapfile_stream.c:  To take care of this, mfs->ptr is set

@@ -25,7 +25,7 @@ libmailbox_la_SOURCES = \
  header.c     \
  header.c     \
  iterator.c   \
  iterator.c   \
  list.c       \
  list.c       \
- locker.c     \
+ lockfile.c   \
  mailbox.c    \
  mailbox.c    \
  md5-rsa.c    \
  md5-rsa.c    \
  memstream.c  \
  memstream.c  \

@@ -37,14 +37,14 @@
 #include <mailutils/sys/bstream.h>
 #include <mailutils/sys/bstream.h>
 
 
 static void
 static void
-_bs_cleanup (void *arg)
+_stream_buffer_cleanup (void *arg)
 {
 {
-  struct _bs *bs = arg;
+  struct _stream_buffer *bs = arg;
   mu_refcount_unlock (bs->refcount);
   mu_refcount_unlock (bs->refcount);
 }
 }
 
 
 static int
 static int
-refill (struct _bs *bs)
+refill (struct _stream_buffer *bs)
 {
 {
   int status;
   int status;
   if (bs->rbuffer.base == NULL)
   if (bs->rbuffer.base == NULL)
@@ -60,17 +60,17 @@ refill (struct _bs *bs)
   return status;
   return status;
 }
 }
 
 
-static int
-_bs_ref (stream_t stream)
+int
+_stream_buffer_ref (stream_t stream)
 {
 {
-  struct _bs *bs = (struct _bs *)stream;
+  struct _stream_buffer *bs = (struct _stream_buffer *)stream;
   return mu_refcount_inc (bs->refcount);
   return mu_refcount_inc (bs->refcount);
 }
 }
 
 
-static void
-_bs_destroy (stream_t *pstream)
+void
+_stream_buffer_destroy (stream_t *pstream)
 {
 {
-  struct _bs *bs = (struct _bs *)*pstream;
+  struct _stream_buffer *bs = (struct _stream_buffer *)*pstream;
   if (mu_refcount_dec (bs->refcount) == 0)
   if (mu_refcount_dec (bs->refcount) == 0)
     {
     {
       stream_destroy (&bs->stream);
       stream_destroy (&bs->stream);
@@ -79,17 +79,17 @@ _bs_destroy (stream_t *pstream)
     }
     }
 }
 }
 
 
-static int
-_bs_open (stream_t stream, const char *name, int port, int flags)
+int
+_stream_buffer_open (stream_t stream, const char *name, int port, int flags)
 {
 {
-  struct _bs *bs = (struct _bs *)stream;
+  struct _stream_buffer *bs = (struct _stream_buffer *)stream;
   return stream_open (bs->stream, name, port, flags);
   return stream_open (bs->stream, name, port, flags);
 }
 }
 
 
-static int
-_bs_close (stream_t stream)
+int
+_stream_buffer_close (stream_t stream)
 {
 {
-  struct _bs *bs = (struct _bs *)stream;
+  struct _stream_buffer *bs = (struct _stream_buffer *)stream;
   mu_refcount_lock (bs->refcount);
   mu_refcount_lock (bs->refcount);
   /* Clear the buffer of any residue left.  */
   /* Clear the buffer of any residue left.  */
   if (bs->rbuffer.base && bs->rbuffer.bufsize)
   if (bs->rbuffer.base && bs->rbuffer.bufsize)
@@ -106,11 +106,11 @@ _bs_close (stream_t stream)
    use as a fully fledge buffer mechanism.  It is a simple mechanims for
    use as a fully fledge buffer mechanism.  It is a simple mechanims for
    networking. Lots of code between POP and IMAP can be share this way.
    networking. Lots of code between POP and IMAP can be share this way.
    The buffering is on the read only, the writes fall through.  */
    The buffering is on the read only, the writes fall through.  */
-static int
-_bs_read (stream_t stream, void *buf, size_t count, size_t *pnread)
+int
+_stream_buffer_read (stream_t stream, void *buf, size_t count, size_t *pnread)
 {
 {
   int status = 0;
   int status = 0;
-  struct _bs *bs = (struct _bs *)stream;
+  struct _stream_buffer *bs = (struct _stream_buffer *)stream;
 
 
   /* Noop.  */
   /* Noop.  */
   if (count == 0)
   if (count == 0)
@@ -131,7 +131,7 @@ _bs_read (stream_t stream, void *buf, size_t count, size_t *pnread)
       int r;
       int r;
 
 
       mu_refcount_lock (bs->refcount);
       mu_refcount_lock (bs->refcount);
-      monitor_cleanup_push (_bs_cleanup, bs);
+      monitor_cleanup_push (_stream_buffer_cleanup, bs);
 
 
       /* If the amount requested is bigger then the buffer cache size
       /* If the amount requested is bigger then the buffer cache size
 	 bypass it.  Do no waste time and let it through.  */
 	 bypass it.  Do no waste time and let it through.  */
@@ -199,11 +199,11 @@ _bs_read (stream_t stream, void *buf, size_t count, size_t *pnread)
  * Read at most n-1 characters.
  * Read at most n-1 characters.
  * Stop when a newline has been read, or the count runs out.
  * Stop when a newline has been read, or the count runs out.
  */
  */
-static int
-_bs_readline (stream_t stream, char *buf, size_t count, size_t *pnread)
+int
+_stream_buffer_readline (stream_t stream, char *buf, size_t count, size_t *pnread)
 {
 {
   int status = 0;
   int status = 0;
-  struct _bs *bs = (struct _bs *)stream;
+  struct _stream_buffer *bs = (struct _stream_buffer *)stream;
 
 
   /* Noop.  */
   /* Noop.  */
   if (count == 0)
   if (count == 0)
@@ -224,7 +224,7 @@ _bs_readline (stream_t stream, char *buf, size_t count, size_t *pnread)
       size_t total = 0;
       size_t total = 0;
 
 
       mu_refcount_lock (bs->refcount);
       mu_refcount_lock (bs->refcount);
-      monitor_cleanup_push (_bs_cleanup, bs);
+      monitor_cleanup_push (_stream_buffer_cleanup, bs);
 
 
       count--;  /* Leave space for the null.  */
       count--;  /* Leave space for the null.  */
 
 
@@ -277,91 +277,74 @@ _bs_readline (stream_t stream, char *buf, size_t count, size_t *pnread)
   return status;
   return status;
 }
 }
 
 
-static int
-_bs_write (stream_t stream, const void *buf, size_t count, size_t *pnwrite)
+int
+_stream_buffer_write (stream_t stream, const void *buf, size_t count,
+		      size_t *pnwrite)
 {
 {
-  struct _bs *bs = (struct _bs *)stream;
-  int err = 0;
-  size_t nwriten = 0;
-  size_t total = 0;
-  int nleft = count;
-  const char *p = buf;
-
-  /* First try to send it all.  */
-  while (nleft > 0)
-    {
-      err = stream_write (bs->stream, p, nleft, &nwriten);
-      if (err != 0 || nwriten == 0)
-        break;
-      nleft -= nwriten;
-      total += nwriten;
-      p += nwriten;
-    }
-  if (pnwrite)
-    *pnwrite = total;
-  return err;
+  struct _stream_buffer *bs = (struct _stream_buffer *)stream;
+  return stream_write (bs->stream, buf, count, pnwrite);
 }
 }
 
 
-static int
-_bs_get_fd (stream_t stream, int *pfd)
+int
+_stream_buffer_get_fd (stream_t stream, int *pfd)
 {
 {
-  struct _bs *bs = (struct _bs *)stream;
+  struct _stream_buffer *bs = (struct _stream_buffer *)stream;
   return stream_get_fd (bs->stream, pfd);
   return stream_get_fd (bs->stream, pfd);
 }
 }
 
 
-static int
-_bs_get_flags (stream_t stream, int *pfl)
+int
+_stream_buffer_get_flags (stream_t stream, int *pfl)
 {
 {
-  struct _bs *bs = (struct _bs *)stream;
+  struct _stream_buffer *bs = (struct _stream_buffer *)stream;
   return stream_get_flags (bs->stream, pfl);
   return stream_get_flags (bs->stream, pfl);
 }
 }
 
 
-static int
-_bs_get_size (stream_t stream, off_t *psize)
+int
+_stream_buffer_get_size (stream_t stream, off_t *psize)
 {
 {
-  struct _bs *bs = (struct _bs *)stream;
+  struct _stream_buffer *bs = (struct _stream_buffer *)stream;
   return stream_get_size (bs->stream, psize);
   return stream_get_size (bs->stream, psize);
 }
 }
 
 
-static int
-_bs_truncate (stream_t stream, off_t len)
+int
+_stream_buffer_truncate (stream_t stream, off_t len)
 {
 {
-  struct _bs *bs = (struct _bs *)stream;
+  struct _stream_buffer *bs = (struct _stream_buffer *)stream;
   return stream_truncate (bs->stream, len);
   return stream_truncate (bs->stream, len);
 }
 }
 
 
-static int
-_bs_flush (stream_t stream)
+int
+_stream_buffer_flush (stream_t stream)
 {
 {
-  struct _bs *bs = (struct _bs *)stream;
+  struct _stream_buffer *bs = (struct _stream_buffer *)stream;
   return stream_flush (bs->stream);
   return stream_flush (bs->stream);
 }
 }
 
 
-static int
-_bs_get_state (stream_t stream, enum stream_state *pstate)
+int
+_stream_buffer_get_state (stream_t stream, enum stream_state *pstate)
 {
 {
-  struct _bs *bs = (struct _bs *)stream;
+  struct _stream_buffer *bs = (struct _stream_buffer *)stream;
   return stream_get_state (bs->stream, pstate);
   return stream_get_state (bs->stream, pstate);
 }
 }
 
 
-static int
-_bs_seek (stream_t stream, off_t off, enum stream_whence whence)
+int
+_stream_buffer_seek (stream_t stream, off_t off, enum stream_whence whence)
 {
 {
-  struct _bs *bs = (struct _bs *)stream;
+  struct _stream_buffer *bs = (struct _stream_buffer *)stream;
   return stream_seek (bs->stream, off, whence);
   return stream_seek (bs->stream, off, whence);
 }
 }
 
 
-static int
-_bs_tell (stream_t stream, off_t *off)
+int
+_stream_buffer_tell (stream_t stream, off_t *off)
 {
 {
-  struct _bs *bs = (struct _bs *)stream;
+  struct _stream_buffer *bs = (struct _stream_buffer *)stream;
   return stream_tell (bs->stream, off);
   return stream_tell (bs->stream, off);
 }
 }
 
 
-static int
-_bs_is_readready (stream_t stream, int timeout)
+int
+_stream_buffer_is_readready (stream_t stream, int timeout)
 {
 {
-  struct _bs *bs = (struct _bs *)stream;
+  struct _stream_buffer *bs = (struct _stream_buffer *)stream;
   /* Drain our buffer first.  */
   /* Drain our buffer first.  */
   mu_refcount_lock (bs->refcount);
   mu_refcount_lock (bs->refcount);
   if (bs->rbuffer.count > 0)
   if (bs->rbuffer.count > 0)
@@ -373,62 +356,84 @@ _bs_is_readready (stream_t stream, int timeout)
   return stream_is_readready (bs->stream, timeout);
   return stream_is_readready (bs->stream, timeout);
 }
 }
 
 
-static int
-_bs_is_writeready (stream_t stream, int timeout)
+int
+_stream_buffer_is_writeready (stream_t stream, int timeout)
 {
 {
-  struct _bs *bs = (struct _bs *)stream;
+  struct _stream_buffer *bs = (struct _stream_buffer *)stream;
   return stream_is_writeready (bs->stream, timeout);
   return stream_is_writeready (bs->stream, timeout);
 }
 }
 
 
-static int
-_bs_is_exceptionpending (stream_t stream, int timeout)
+int
+_stream_buffer_is_exceptionpending (stream_t stream, int timeout)
 {
 {
-  struct _bs *bs = (struct _bs *)stream;
+  struct _stream_buffer *bs = (struct _stream_buffer *)stream;
   return stream_is_exceptionpending (bs->stream, timeout);
   return stream_is_exceptionpending (bs->stream, timeout);
 }
 }
 
 
-static int
-_bs_is_open (stream_t stream)
+int
+_stream_buffer_is_open (stream_t stream)
 {
 {
-  struct _bs *bs = (struct _bs *)stream;
+  struct _stream_buffer *bs = (struct _stream_buffer *)stream;
   return stream_is_open (bs->stream);
   return stream_is_open (bs->stream);
 }
 }
 
 
 
 
-static struct _stream_vtable _bs_vtable =
+static struct _stream_vtable _stream_buffer_vtable =
 {
 {
-  _bs_ref,
-  _bs_destroy,
+  _stream_buffer_ref,
+  _stream_buffer_destroy,
 
 
-  _bs_open,
-  _bs_close,
+  _stream_buffer_open,
+  _stream_buffer_close,
 
 
-  _bs_read,
-  _bs_readline,
-  _bs_write,
+  _stream_buffer_read,
+  _stream_buffer_readline,
+  _stream_buffer_write,
 
 
-  _bs_seek,
-  _bs_tell,
+  _stream_buffer_seek,
+  _stream_buffer_tell,
 
 
-  _bs_get_size,
-  _bs_truncate,
-  _bs_flush,
+  _stream_buffer_get_size,
+  _stream_buffer_truncate,
+  _stream_buffer_flush,
 
 
-  _bs_get_fd,
-  _bs_get_flags,
-  _bs_get_state,
+  _stream_buffer_get_fd,
+  _stream_buffer_get_flags,
+  _stream_buffer_get_state,
 
 
-  _bs_is_readready,
-  _bs_is_writeready,
-  _bs_is_exceptionpending,
+  _stream_buffer_is_readready,
+  _stream_buffer_is_writeready,
+  _stream_buffer_is_exceptionpending,
 
 
-  _bs_is_open
+  _stream_buffer_is_open
 };
 };
 
 
 int
 int
+_stream_buffer_ctor (struct _stream_buffer *bs, stream_t stream,
+		     size_t bufsize)
+{
+  mu_refcount_create (&(bs->refcount));
+  if (bs->refcount == NULL)
+    return MU_ERROR_NO_MEMORY;
+
+  bs->stream = stream;
+  bs->rbuffer.bufsize = bufsize;
+  bs->base.vtable = &_stream_buffer_vtable;
+  return 0;
+}
+
+void
+_stream_buffer_dtor (struct _stream_buffer *bs)
+{
+  stream_destroy (&bs->stream);
+  mu_refcount_destroy (&bs->refcount);
+}
+
+int
 stream_buffer_create (stream_t *pstream, stream_t stream, size_t bufsize)
 stream_buffer_create (stream_t *pstream, stream_t stream, size_t bufsize)
 {
 {
-  struct _bs *bs;
+  struct _stream_buffer *bs;
+  int status;
 
 
   if (pstream == NULL || stream == NULL || bufsize == 0)
   if (pstream == NULL || stream == NULL || bufsize == 0)
     return MU_ERROR_INVALID_PARAMETER;
     return MU_ERROR_INVALID_PARAMETER;
@@ -437,16 +442,9 @@ stream_buffer_create (stream_t *pstream, stream_t stream, size_t bufsize)
   if (bs == NULL)
   if (bs == NULL)
     return MU_ERROR_NO_MEMORY;
     return MU_ERROR_NO_MEMORY;
 
 
-  mu_refcount_create (&(bs->refcount));
-  if (bs->refcount == NULL)
-    {
-      free (bs);
-      return MU_ERROR_NO_MEMORY;
-    }
-
-  bs->stream = stream;
-  bs->rbuffer.bufsize = bufsize;
-  bs->base.vtable = &_bs_vtable;
+  status = _stream_buffer_ctor (bs, stream, bufsize);
+  if (status != 0)
+    return status;
   *pstream = &bs->base;
   *pstream = &bs->base;
   return 0;
   return 0;
 }
 }

@@ -28,19 +28,19 @@
 #endif
 #endif
 
 
 #include <mailutils/error.h>
 #include <mailutils/error.h>
-#include <mailutils/sys/attribute.h>
+#include <mailutils/sys/dattribute.h>
 
 
-static int
-_da_ref (attribute_t attribute)
+int
+_attribute_default_ref (attribute_t attribute)
 {
 {
-  struct _da *da = (struct _da *)attribute;
+  struct _attribute_default *da = (struct _attribute_default *)attribute;
   return mu_refcount_inc (da->refcount);
   return mu_refcount_inc (da->refcount);
 }
 }
 
 
-static void
-_da_destroy (attribute_t *pattribute)
+void
+_attribute_default_destroy (attribute_t *pattribute)
 {
 {
-  struct _da *da = (struct _da *)*pattribute;
+  struct _attribute_default *da = (struct _attribute_default *)*pattribute;
   if (mu_refcount_dec (da->refcount) == 0)
   if (mu_refcount_dec (da->refcount) == 0)
     {
     {
       mu_refcount_destroy (&da->refcount);
       mu_refcount_destroy (&da->refcount);
@@ -48,10 +48,10 @@ _da_destroy (attribute_t *pattribute)
     }
     }
 }
 }
 
 
-static int
-_da_get_flags (attribute_t attribute, int *pflags)
+int
+_attribute_default_get_flags (attribute_t attribute, int *pflags)
 {
 {
-  struct _da *da = (struct _da *)attribute;
+  struct _attribute_default *da = (struct _attribute_default *)attribute;
   mu_refcount_lock (da->refcount);
   mu_refcount_lock (da->refcount);
   if (pflags)
   if (pflags)
     *pflags = da->flags;
     *pflags = da->flags;
@@ -59,20 +59,20 @@ _da_get_flags (attribute_t attribute, int *pflags)
   return 0;
   return 0;
 }
 }
 
 
-static int
-_da_set_flags (attribute_t attribute, int flags)
+int
+_attribute_default_set_flags (attribute_t attribute, int flags)
 {
 {
-  struct _da *da = (struct _da *)attribute;
+  struct _attribute_default *da = (struct _attribute_default *)attribute;
   mu_refcount_lock (da->refcount);
   mu_refcount_lock (da->refcount);
   da->flags |= (flags | MU_ATTRIBUTE_MODIFIED);
   da->flags |= (flags | MU_ATTRIBUTE_MODIFIED);
   mu_refcount_unlock (da->refcount);
   mu_refcount_unlock (da->refcount);
   return 0;
   return 0;
 }
 }
 
 
-static int
-_da_unset_flags (attribute_t attribute, int flags)
+int
+_attribute_default_unset_flags (attribute_t attribute, int flags)
 {
 {
-  struct _da *da = (struct _da *)attribute;
+  struct _attribute_default *da = (struct _attribute_default *)attribute;
   mu_refcount_lock (da->refcount);
   mu_refcount_lock (da->refcount);
   da->flags &= ~flags;
   da->flags &= ~flags;
   /* If Modified was being unset do not reset it.  */
   /* If Modified was being unset do not reset it.  */
@@ -82,45 +82,115 @@ _da_unset_flags (attribute_t attribute, int flags)
   return 0;
   return 0;
 }
 }
 
 
-static int
-_da_clear_flags (attribute_t attribute)
+int
+_attribute_default_clear_flags (attribute_t attribute)
 {
 {
-  struct _da *da = (struct _da *)attribute;
+  struct _attribute_default *da = (struct _attribute_default *)attribute;
   mu_refcount_lock (da->refcount);
   mu_refcount_lock (da->refcount);
   da->flags = 0;
   da->flags = 0;
   mu_refcount_unlock (da->refcount);
   mu_refcount_unlock (da->refcount);
   return 0;
   return 0;
 }
 }
 
 
-static struct _attribute_vtable _da_vtable =
+static struct _attribute_vtable _attribute_default_vtable =
 {
 {
-  _da_ref,
-  _da_destroy,
+  _attribute_default_ref,
+  _attribute_default_destroy,
 
 
-  _da_get_flags,
-  _da_set_flags,
-  _da_unset_flags,
-  _da_clear_flags
+  _attribute_default_get_flags,
+  _attribute_default_set_flags,
+  _attribute_default_unset_flags,
+  _attribute_default_clear_flags
 };
 };
 
 
 int
 int
-attribute_create (attribute_t *pattribute)
+_attribute_default_ctor (struct _attribute_default *da)
+{
+  mu_refcount_create (&(da->refcount));
+  if (da->refcount == NULL)
+    return MU_ERROR_NO_MEMORY;
+  da->flags = 0;
+  da->base.vtable = &_attribute_default_vtable;
+  return 0;
+}
+
+void
+_attribute_default_dtor (struct _attribute_default *da)
+{
+  mu_refcount_destroy (&da->refcount);
+}
+
+int
+attribute_default_create (attribute_t *pattribute)
 {
 {
-  struct _da *da;
+  struct _attribute_default *da;
+  int status;
+
   if (pattribute == NULL)
   if (pattribute == NULL)
     return MU_ERROR_INVALID_PARAMETER;
     return MU_ERROR_INVALID_PARAMETER;
+
   da = calloc (1, sizeof *da);
   da = calloc (1, sizeof *da);
   if (da == NULL)
   if (da == NULL)
     return MU_ERROR_NO_MEMORY;
     return MU_ERROR_NO_MEMORY;
 
 
-  mu_refcount_create (&(da->refcount));
-  if (da->refcount == NULL)
+  status = _attribute_default_ctor (da);
+  if (status != 0)
     {
     {
       free (da);
       free (da);
+      return status;
+    }
+  *pattribute = &da->base;
+  return 0;
+}
+
+int
+attribute_status_create (attribute_t *pattribute, const char *field)
+{
+  struct _attribute_default *da;
+  int status;
+  char *colon;
+
+  if (pattribute == NULL || field == NULL)
+    return MU_ERROR_INVALID_PARAMETER;
+
+  da = calloc (1, sizeof *da);
+  if (da == NULL)
     return MU_ERROR_NO_MEMORY;
     return MU_ERROR_NO_MEMORY;
+
+  status = _attribute_default_ctor (da);
+  if (status != 0)
+    {
+      free (da);
+      return status;
     }
     }
-  da->flags = 0;
-  da->base.vtable = &_da_vtable;
   *pattribute = &da->base;
   *pattribute = &da->base;
+
+  colon = strchr (field, ':');
+  if (colon)
+    field = ++colon;
+
+  for (; *field; field++)
+    {
+      switch (*field)
+	{
+	case 'r':
+	case 'R':
+	  attribute_set_read (*pattribute);
+	  break;
+	case 'O':
+	case 'o':
+	  attribute_set_seen (*pattribute);
+	  break;
+	case 'a':
+	case 'A':
+	  attribute_set_answered (*pattribute);
+	  break;
+	case 'd':
+	case 'D':
+	  attribute_set_deleted (*pattribute);
+	  break;
+	}
+    }
+  attribute_unset_modified (*pattribute);
   return 0;
   return 0;
 }
 }

@@ -33,53 +33,35 @@
 #include <signal.h>
 #include <signal.h>
 
 
 #include <mailutils/error.h>
 #include <mailutils/error.h>
-#include <mailutils/sys/locker.h>
+#include <mailutils/sys/dotlock.h>
 #include <mailutils/refcount.h>
 #include <mailutils/refcount.h>
 
 
-/* locking flags */
-#define MU_DOTLOCK_PID    1
-#define MU_DOTLOCK_FCNTL  2
-#define MU_DOTLOCK_TIME   4
-
-#define MU_DOTLOCK_EXPIRE_TIME        (5 * 60)
-
-#define LOCKFILE_ATTR           0444
-
 /* First draft by Brian Edmond. */
 /* First draft by Brian Edmond. */
 
 
-struct _dotlock
-{
-  struct _locker base;
-  mu_refcount_t refcount;
-  int fd;
-  int refcnt;
-  char *fname;
-  int flags;
-};
-
-static int
-_dotlock_ref (locker_t locker)
+int
+_lockfile_dotlock_ref (lockfile_t lockfile)
 {
 {
-  struct _dotlock *dotlock = (struct _dotlock *)locker;
+  struct _lockfile_dotlock *dotlock = (struct _lockfile_dotlock *)lockfile;
   return mu_refcount_inc (dotlock->refcount);
   return mu_refcount_inc (dotlock->refcount);
 }
 }
 
 
-static void
-_dotlock_destroy (locker_t *plocker)
+void
+_lockfile_dotlock_destroy (lockfile_t *plockfile)
 {
 {
-  struct _dotlock *dotlock = (struct _dotlock *)*plocker;
+  struct _lockfile_dotlock *dotlock = (struct _lockfile_dotlock *)*plockfile;
   if (mu_refcount_dec (dotlock->refcount) == 0)
   if (mu_refcount_dec (dotlock->refcount) == 0)
     {
     {
       mu_refcount_destroy (&dotlock->refcount);
       mu_refcount_destroy (&dotlock->refcount);
+      if (dotlock->fname)
 	free (dotlock->fname);
 	free (dotlock->fname);
       free (dotlock);
       free (dotlock);
     }
     }
 }
 }
 
 
-static int
-_dotlock_lock (locker_t locker)
+int
+_lockfile_dotlock_lock (lockfile_t lockfile)
 {
 {
-  struct _dotlock *dotlock = (struct _dotlock *)locker;
+  struct _lockfile_dotlock *dotlock = (struct _lockfile_dotlock *)lockfile;
   int   fd = -1;
   int   fd = -1;
   char  buf[16];
   char  buf[16];
   pid_t pid;
   pid_t pid;
@@ -104,31 +86,34 @@ _dotlock_lock (locker_t locker)
   if (fd != -1)
   if (fd != -1)
     {
     {
       /* Check to see if this process is still running.  */
       /* Check to see if this process is still running.  */
-      if (dotlock->flags & MU_DOTLOCK_PID)
+      if (dotlock->flags & MU_LOCKFILE_DOTLOCK_PID)
         {
         {
 	  int nread = read (fd, buf, sizeof (buf) - 1);
 	  int nread = read (fd, buf, sizeof (buf) - 1);
           if (nread > 0)
           if (nread > 0)
             {
             {
 	      buf[nread] = '\0';
 	      buf[nread] = '\0';
-              pid = strtol (buf, NULL, 10);
-              if (pid > 0)
+              switch (pid = strtol (buf, NULL, 10))
 		{
 		{
+		case LONG_MIN:
+		case LONG_MAX:
+		  if (errno == ERANGE)
+		    removed = 1;
+		  break;
+		default:
 		  /* Process is gone so we try to remove the lock.  */
 		  /* Process is gone so we try to remove the lock.  */
 		  if (kill (pid, 0) == -1)
 		  if (kill (pid, 0) == -1)
 		    removed = 1;
 		    removed = 1;
 		}
 		}
-	      else
-		removed = 1; /* Corrupted file, remove the lock.  */
 	    }
 	    }
         }
         }
       /* Check to see if the lock expired.  */
       /* Check to see if the lock expired.  */
-      if (dotlock->flags & MU_DOTLOCK_TIME)
+      if (dotlock->flags & MU_LOCKFILE_DOTLOCK_TIME)
         {
         {
           struct stat stbuf;
           struct stat stbuf;
 
 
           fstat (fd, &stbuf);
           fstat (fd, &stbuf);
           /* The lock has expired.  */
           /* The lock has expired.  */
-          if ((time (NULL) - stbuf.st_mtime) > MU_DOTLOCK_EXPIRE_TIME)
+          if ((time (NULL) - stbuf.st_mtime) > MU_LOCKFILE_DOTLOCK_EXPIRE_TIME)
             removed = 1;
             removed = 1;
         }
         }
 
 
@@ -138,7 +123,7 @@ _dotlock_lock (locker_t locker)
     }
     }
 
 
   /* Try to create the lockfile.  */
   /* Try to create the lockfile.  */
-  fd = open (dotlock->fname, O_WRONLY | O_CREAT | O_EXCL, LOCKFILE_ATTR);
+  fd = open (dotlock->fname, O_WRONLY | O_CREAT | O_EXCL, MU_LOCKFILE_DOTLOCK_ATTR);
   if (fd == -1)
   if (fd == -1)
     return errno;
     return errno;
   else
   else
@@ -165,7 +150,7 @@ _dotlock_lock (locker_t locker)
   write (fd, buf, strlen (buf));
   write (fd, buf, strlen (buf));
 
 
   /* Try to get a file lock.  */
   /* Try to get a file lock.  */
-  if (dotlock->flags & MU_DOTLOCK_FCNTL)
+  if (dotlock->flags & MU_LOCKFILE_DOTLOCK_FCNTL)
     {
     {
       struct flock fl;
       struct flock fl;
 
 
@@ -186,26 +171,26 @@ _dotlock_lock (locker_t locker)
   return 0;
   return 0;
 }
 }
 
 
-static int
-_dotlock_touchlock (locker_t locker)
+int
+_lockfile_dotlock_touchlock (lockfile_t lockfile)
 {
 {
-  struct _dotlock *dotlock = (struct _dotlock *)locker;
+  struct _lockfile_dotlock *dotlock = (struct _lockfile_dotlock *)lockfile;
   if (!dotlock || !dotlock->fname || dotlock->fd == -1)
   if (!dotlock || !dotlock->fname || dotlock->fd == -1)
     return MU_ERROR_INVALID_PARAMETER;
     return MU_ERROR_INVALID_PARAMETER;
   return utime (dotlock->fname, NULL);
   return utime (dotlock->fname, NULL);
 }
 }
 
 
-static int
-_dotlock_unlock (locker_t locker)
+int
+_lockfile_dotlock_unlock (lockfile_t lockfile)
 {
 {
-  struct _dotlock *dotlock = (struct _dotlock *)locker;
+  struct _lockfile_dotlock *dotlock = (struct _lockfile_dotlock *)lockfile;
   if (!dotlock || !dotlock->fname || dotlock->fd == -1 || dotlock->refcnt <= 0)
   if (!dotlock || !dotlock->fname || dotlock->fd == -1 || dotlock->refcnt <= 0)
     return EINVAL;
     return EINVAL;
 
 
   if (--dotlock->refcnt > 0)
   if (--dotlock->refcnt > 0)
     return 0;
     return 0;
 
 
-  if (dotlock->flags & MU_DOTLOCK_FCNTL)
+  if (dotlock->flags & MU_LOCKFILE_DOTLOCK_FCNTL)
     {
     {
       struct flock fl;
       struct flock fl;
 
 
@@ -221,48 +206,68 @@ _dotlock_unlock (locker_t locker)
   return 0;
   return 0;
 }
 }
 
 
-static struct _locker_vtable _dotlock_vtable =
+static struct _lockfile_vtable _lockfile_dotlock_vtable =
 {
 {
-  _dotlock_ref,
-  _dotlock_destroy,
+  _lockfile_dotlock_ref,
+  _lockfile_dotlock_destroy,
 
 
-  _dotlock_lock,
-  _dotlock_touchlock,
-  _dotlock_unlock,
+  _lockfile_dotlock_lock,
+  _lockfile_dotlock_touchlock,
+  _lockfile_dotlock_unlock,
 };
 };
 
 
 int
 int
-locker_dotlock_create (locker_t *plocker, const char *filename)
+_lockfile_dotlock_ctor (struct _lockfile_dotlock *dotlock,
+			const char *filename)
 {
 {
-  struct _dotlock *dotlock;
-
-  if (plocker == NULL || filename == NULL)
-    return MU_ERROR_INVALID_PARAMETER;
-
-  dotlock = calloc (1, sizeof *dotlock);
-  if (dotlock == NULL)
-    return MU_ERROR_NO_MEMORY;
-
   mu_refcount_create (&dotlock->refcount);
   mu_refcount_create (&dotlock->refcount);
   if (dotlock->refcount)
   if (dotlock->refcount)
-    {
-      free (dotlock);
     return MU_ERROR_NO_MEMORY;
     return MU_ERROR_NO_MEMORY;
-    }
 
 
   dotlock->fname = calloc (strlen (filename) + 5 /*strlen(".lock")*/ + 1, 1);
   dotlock->fname = calloc (strlen (filename) + 5 /*strlen(".lock")*/ + 1, 1);
   if (dotlock->fname == NULL)
   if (dotlock->fname == NULL)
     {
     {
-      free (dotlock);
+      mu_refcount_destroy (&dotlock->refcount);
       return MU_ERROR_NO_MEMORY;
       return MU_ERROR_NO_MEMORY;
     }
     }
   strcpy (dotlock->fname, filename);
   strcpy (dotlock->fname, filename);
   strcat (dotlock->fname, ".lock");
   strcat (dotlock->fname, ".lock");
 
 
-  dotlock->flags = MU_DOTLOCK_PID | MU_DOTLOCK_TIME | MU_DOTLOCK_FCNTL;
+  dotlock->flags = MU_LOCKFILE_DOTLOCK_PID | MU_LOCKFILE_DOTLOCK_TIME
+    | MU_LOCKFILE_DOTLOCK_FCNTL;
   dotlock->fd = -1;
   dotlock->fd = -1;
   dotlock->refcnt = 0;
   dotlock->refcnt = 0;
-  dotlock->base.vtable = &_dotlock_vtable;
-  *plocker = &dotlock->base;
+  dotlock->base.vtable = &_lockfile_dotlock_vtable;
+  return 0;
+}
+
+void
+_lockfile_dotlock_dtor (struct _lockfile_dotlock *dotlock)
+{
+  mu_refcount_destroy (&dotlock->refcount);
+  if (dotlock->fname)
+    free (dotlock->fname);
+}
+
+int
+lockfile_dotlock_create (lockfile_t *plockfile, const char *filename)
+{
+  struct _lockfile_dotlock *dotlock;
+  int status;
+
+  if (plockfile == NULL || filename == NULL)
+    return MU_ERROR_INVALID_PARAMETER;
+
+  dotlock = calloc (1, sizeof *dotlock);
+  if (dotlock == NULL)
+    return MU_ERROR_NO_MEMORY;
+
+  status = _lockfile_dotlock_ctor (dotlock, filename);
+  if (status != 0)
+    {
+      free (dotlock);
+      return status;
+    }
+  *plockfile = &dotlock->base;
   return 0;
   return 0;
 }
 }

@@ -33,23 +33,23 @@
 #include <mailutils/error.h>
 #include <mailutils/error.h>
 
 
 static void
 static void
-_fds_cleanup (void *arg)
+_stream_fd_cleanup (void *arg)
 {
 {
-  struct _fds *fds = arg;
+  struct _stream_fd *fds = arg;
   mu_refcount_unlock (fds->refcount);
   mu_refcount_unlock (fds->refcount);
 }
 }
 
 
-static int
-_fds_ref (stream_t stream)
+int
+_stream_fd_ref (stream_t stream)
 {
 {
-  struct _fds *fds = (struct _fds *)stream;
+  struct _stream_fd *fds = (struct _stream_fd *)stream;
   return mu_refcount_inc (fds->refcount);
   return mu_refcount_inc (fds->refcount);
 }
 }
 
 
-static void
-_fds_destroy (stream_t *pstream)
+void
+_stream_fd_destroy (stream_t *pstream)
 {
 {
-  struct _fds *fds = (struct _fds *)*pstream;
+  struct _stream_fd *fds = (struct _stream_fd *)*pstream;
   if (mu_refcount_dec (fds->refcount) == 0)
   if (mu_refcount_dec (fds->refcount) == 0)
     {
     {
       mu_refcount_destroy (&fds->refcount);
       mu_refcount_destroy (&fds->refcount);
@@ -58,39 +58,40 @@ _fds_destroy (stream_t *pstream)
 }
 }
 
 
 static int
 static int
-_fds_close0 (stream_t stream)
+_stream_fd_close0 (stream_t stream)
 {
 {
-  struct _fds *fds = (struct _fds *)stream;
+  struct _stream_fd *fds = (struct _stream_fd *)stream;
+  fds->state = MU_STREAM_STATE_CLOSE;
   if (fds->fd != -1)
   if (fds->fd != -1)
     close (fds->fd);
     close (fds->fd);
   fds->fd = -1;
   fds->fd = -1;
   return 0;
   return 0;
 }
 }
 
 
-static int
-_fds_close (stream_t stream)
+int
+_stream_fd_close (stream_t stream)
 {
 {
-  struct _fds *fds = (struct _fds *)stream;
+  struct _stream_fd *fds = (struct _stream_fd *)stream;
 
 
   mu_refcount_lock (fds->refcount);
   mu_refcount_lock (fds->refcount);
-  monitor_cleanup_push (_fds_cleanup, fds);
-  _fds_close0 (stream);
+  monitor_cleanup_push (_stream_fd_cleanup, fds);
+  _stream_fd_close0 (stream);
   mu_refcount_unlock (fds->refcount);
   mu_refcount_unlock (fds->refcount);
   monitor_cleanup_pop (0);
   monitor_cleanup_pop (0);
   return 0;
   return 0;
 }
 }
 
 
-static int
-_fds_open (stream_t stream, const char *name, int port, int flags)
+int
+_stream_fd_open (stream_t stream, const char *name, int port, int flags)
 {
 {
   (void)stream; (void)name; (void)port; (void)flags;
   (void)stream; (void)name; (void)port; (void)flags;
   return MU_ERROR_NOT_SUPPORTED;
   return MU_ERROR_NOT_SUPPORTED;
 }
 }
 
 
-static int
-_fds_get_fd (stream_t stream, int *fd)
+int
+_stream_fd_get_fd (stream_t stream, int *fd)
 {
 {
-  struct _fds *fds = (struct _fds *)stream;
+  struct _stream_fd *fds = (struct _stream_fd *)stream;
 
 
   if (fd == NULL || fds->fd == -1)
   if (fd == NULL || fds->fd == -1)
     return MU_ERROR_INVALID_PARAMETER;
     return MU_ERROR_INVALID_PARAMETER;
@@ -99,13 +100,14 @@ _fds_get_fd (stream_t stream, int *fd)
   return 0;
   return 0;
 }
 }
 
 
-static int
-_fds_read (stream_t stream, void *buf, size_t buf_size, size_t *br)
+int
+_stream_fd_read (stream_t stream, void *buf, size_t buf_size, size_t *br)
 {
 {
-  struct _fds *fds = (struct _fds *)stream;
+  struct _stream_fd *fds = (struct _stream_fd *)stream;
   int bytes = 0;
   int bytes = 0;
   int status = 0;
   int status = 0;
 
 
+  fds->state = MU_STREAM_STATE_READ;
   bytes = read (fds->fd, buf, buf_size);
   bytes = read (fds->fd, buf, buf_size);
   if (bytes == -1)
   if (bytes == -1)
     {
     {
@@ -117,15 +119,16 @@ _fds_read (stream_t stream, void *buf, size_t buf_size, size_t *br)
   return status;
   return status;
 }
 }
 
 
-static int
-_fds_readline (stream_t stream, char *buf, size_t buf_size, size_t *br)
+int
+_stream_fd_readline (stream_t stream, char *buf, size_t buf_size, size_t *br)
 {
 {
-  struct _fds *fds = (struct _fds *)stream;
+  struct _stream_fd *fds = (struct _stream_fd *)stream;
   int status = 0;
   int status = 0;
   size_t n;
   size_t n;
   int nr = 0;
   int nr = 0;
   char c;
   char c;
 
 
+  fds->state = MU_STREAM_STATE_READ;
   /* Grossly inefficient hopefully they override this */
   /* Grossly inefficient hopefully they override this */
   for (n = 1; n < buf_size; n++)
   for (n = 1; n < buf_size; n++)
     {
     {
@@ -154,13 +157,14 @@ _fds_readline (stream_t stream, char *buf, size_t buf_size, size_t *br)
   return status;
   return status;
 }
 }
 
 
-static int
-_fds_write (stream_t stream, const void *buf, size_t buf_size, size_t *bw)
+int
+_stream_fd_write (stream_t stream, const void *buf, size_t buf_size, size_t *bw)
 {
 {
-  struct _fds *fds = (struct _fds *)stream;
+  struct _stream_fd *fds = (struct _stream_fd *)stream;
   int bytes = 0;
   int bytes = 0;
   int status = 0;
   int status = 0;
 
 
+  fds->state = MU_STREAM_STATE_WRITE;
   bytes = write (fds->fd, buf, buf_size);
   bytes = write (fds->fd, buf, buf_size);
   if (bytes == -1)
   if (bytes == -1)
     {
     {
@@ -172,10 +176,10 @@ _fds_write (stream_t stream, const void *buf, size_t buf_size, size_t *bw)
   return status;
   return status;
 }
 }
 
 
-static int
-_fds_seek (stream_t stream, off_t off, enum stream_whence whence)
+int
+_stream_fd_seek (stream_t stream, off_t off, enum stream_whence whence)
 {
 {
-  struct _fds *fds = (struct _fds *)stream;
+  struct _stream_fd *fds = (struct _stream_fd *)stream;
   int err = 0;
   int err = 0;
   if (fds->fd)
   if (fds->fd)
     {
     {
@@ -193,10 +197,10 @@ _fds_seek (stream_t stream, off_t off, enum stream_whence whence)
   return err;
   return err;
 }
 }
 
 
-static int
-_fds_tell (stream_t stream, off_t *off)
+int
+_stream_fd_tell (stream_t stream, off_t *off)
 {
 {
-  struct _fds *fds = (struct _fds *)stream;
+  struct _stream_fd *fds = (struct _stream_fd *)stream;
   int err = 0;
   int err = 0;
   if (off)
   if (off)
     {
     {
@@ -207,13 +211,13 @@ _fds_tell (stream_t stream, off_t *off)
 	  *off = 0;
 	  *off = 0;
 	}
 	}
     }
     }
-  return err;;
+  return err;
 }
 }
 
 
-static int
-_fds_get_size (stream_t stream, off_t *psize)
+int
+_stream_fd_get_size (stream_t stream, off_t *psize)
 {
 {
-  struct _fds *fds = (struct _fds *)stream;
+  struct _stream_fd *fds = (struct _stream_fd *)stream;
   struct stat stbuf;
   struct stat stbuf;
   int err = 0;
   int err = 0;
   stbuf.st_size = 0;
   stbuf.st_size = 0;
@@ -224,47 +228,47 @@ _fds_get_size (stream_t stream, off_t *psize)
   return err;
   return err;
 }
 }
 
 
-static int
-_fds_truncate (stream_t stream, off_t len)
+int
+_stream_fd_truncate (stream_t stream, off_t len)
 {
 {
-  struct _fds *fds = (struct _fds *)stream;
+  struct _stream_fd *fds = (struct _stream_fd *)stream;
   int err = 0;
   int err = 0;
   if (ftruncate (fds->fd, len) == -1)
   if (ftruncate (fds->fd, len) == -1)
-    err = errno ;
+    err = errno;
   return err;
   return err;
 }
 }
 
 
-static int
-_fds_flush (stream_t stream)
+int
+_stream_fd_flush (stream_t stream)
 {
 {
   (void)stream;
   (void)stream;
   return 0;
   return 0;
 }
 }
 
 
-static int
-_fds_get_flags (stream_t stream, int *flags)
+int
+_stream_fd_get_flags (stream_t stream, int *flags)
 {
 {
-  struct _fds *fds = (struct _fds *)stream;
+  struct _stream_fd *fds = (struct _stream_fd *)stream;
   if (flags == NULL)
   if (flags == NULL)
     return MU_ERROR_INVALID_PARAMETER;
     return MU_ERROR_INVALID_PARAMETER;
   *flags = fds->flags;
   *flags = fds->flags;
   return 0;
   return 0;
 }
 }
 
 
-static int
-_fds_get_state (stream_t stream, enum stream_state *state)
+int
+_stream_fd_get_state (stream_t stream, enum stream_state *state)
 {
 {
-  (void)stream;
+  struct _stream_fd *fds = (struct _stream_fd *)stream;
   if (state == NULL)
   if (state == NULL)
     return MU_ERROR_INVALID_PARAMETER;
     return MU_ERROR_INVALID_PARAMETER;
-  *state = MU_STREAM_NO_STATE;
+  *state = fds->state;
   return 0;
   return 0;
 }
 }
 
 
-static int
-_fds_is_readready (stream_t stream, int timeout)
+int
+_stream_fd_is_readready (stream_t stream, int timeout)
 {
 {
-  struct _fds *fds = (struct _fds *)stream;
+  struct _stream_fd *fds = (struct _stream_fd *)stream;
   int ready = 0;
   int ready = 0;
 
 
   if (fds->fd >= 0)
   if (fds->fd >= 0)
@@ -285,13 +289,13 @@ _fds_is_readready (stream_t stream, int timeout)
   return ready;
   return ready;
 }
 }
 
 
-static int
-_fds_is_writeready (stream_t stream, int timeout)
+int
+_stream_fd_is_writeready (stream_t stream, int timeout)
 {
 {
-  struct _fds *fds = (struct _fds *)stream;
+  struct _stream_fd *fds = (struct _stream_fd *)stream;
   int ready = 0;
   int ready = 0;
 
 
-  if (fds->fd)
+  if (fds->fd >= 0)
     {
     {
       struct timeval tv;
       struct timeval tv;
       fd_set fset;
       fd_set fset;
@@ -309,13 +313,13 @@ _fds_is_writeready (stream_t stream, int timeout)
   return ready;
   return ready;
 }
 }
 
 
-static int
-_fds_is_exceptionpending (stream_t stream, int timeout)
+int
+_stream_fd_is_exceptionpending (stream_t stream, int timeout)
 {
 {
-  struct _fds *fds = (struct _fds *)stream;
+  struct _stream_fd *fds = (struct _stream_fd *)stream;
   int ready = 0;
   int ready = 0;
 
 
-  if (fds->fd)
+  if (fds->fd >= 0)
     {
     {
       struct timeval tv;
       struct timeval tv;
       fd_set fset;
       fd_set fset;
@@ -333,47 +337,66 @@ _fds_is_exceptionpending (stream_t stream, int timeout)
   return 0;
   return 0;
 }
 }
 
 
-static int
-_fds_is_open (stream_t stream)
+int
+_stream_fd_is_open (stream_t stream)
 {
 {
-  struct _fds *fds = (struct _fds *)stream;
+  struct _stream_fd *fds = (struct _stream_fd *)stream;
   return fds->fd >= 0;
   return fds->fd >= 0;
 }
 }
 
 
-static struct _stream_vtable _fds_vtable =
+static struct _stream_vtable _stream_fd_vtable =
 {
 {
-  _fds_ref,
-  _fds_destroy,
+  _stream_fd_ref,
+  _stream_fd_destroy,
 
 
-  _fds_open,
-  _fds_close,
+  _stream_fd_open,
+  _stream_fd_close,
 
 
-  _fds_read,
-  _fds_readline,
-  _fds_write,
+  _stream_fd_read,
+  _stream_fd_readline,
+  _stream_fd_write,
 
 
-  _fds_seek,
-  _fds_tell,
+  _stream_fd_seek,
+  _stream_fd_tell,
 
 
-  _fds_get_size,
-  _fds_truncate,
-  _fds_flush,
+  _stream_fd_get_size,
+  _stream_fd_truncate,
+  _stream_fd_flush,
 
 
-  _fds_get_fd,
-  _fds_get_flags,
-  _fds_get_state,
+  _stream_fd_get_fd,
+  _stream_fd_get_flags,
+  _stream_fd_get_state,
 
 
-  _fds_is_readready,
-  _fds_is_writeready,
-  _fds_is_exceptionpending,
+  _stream_fd_is_readready,
+  _stream_fd_is_writeready,
+  _stream_fd_is_exceptionpending,
 
 
-  _fds_is_open
+  _stream_fd_is_open
 };
 };
 
 
+
+int
+_stream_fd_ctor (struct _stream_fd *fds, int fd)
+{
+  mu_refcount_create (&fds->refcount);
+  if (fds->refcount == NULL)
+    return MU_ERROR_NO_MEMORY;
+  fds->fd = fd;
+  fds->base.vtable = &_stream_fd_vtable;
+  return 0;
+}
+
+void
+_stream_fd_dtor (struct _stream_fd *fds)
+{
+  mu_refcount_destroy (&fds->refcount);
+}
+
 int
 int
 stream_fd_create (stream_t *pstream, int fd)
 stream_fd_create (stream_t *pstream, int fd)
 {
 {
-  struct _fds *fds;
+  struct _stream_fd *fds;
+  int status;
 
 
   if (pstream == NULL || fd < 0)
   if (pstream == NULL || fd < 0)
     return MU_ERROR_INVALID_PARAMETER;
     return MU_ERROR_INVALID_PARAMETER;
@@ -382,14 +405,12 @@ stream_fd_create (stream_t *pstream, int fd)
   if (fds == NULL)
   if (fds == NULL)
     return MU_ERROR_NO_MEMORY;
     return MU_ERROR_NO_MEMORY;
 
 
-  mu_refcount_create (&fds->refcount);
-  if (fds->refcount == NULL)
+  status = _stream_fd_ctor (fds, fd);
+  if (status != 0)
     {
     {
       free (fds);
       free (fds);
-      return MU_ERROR_NO_MEMORY;
+      return status;
     }
     }
-  fds->fd = fd;
-  fds->base.vtable = &_fds_vtable;
   *pstream = &fds->base;
   *pstream = &fds->base;
   return 0;
   return 0;
 }
 }

@@ -34,17 +34,17 @@
 #include <mailutils/error.h>
 #include <mailutils/error.h>
 
 
 
 
-static int
-_fs_ref (stream_t stream)
+int
+_stream_stdio_ref (stream_t stream)
 {
 {
-  struct _fs *fs = (struct _fs *)stream;
+  struct _stream_stdio *fs = (struct _stream_stdio *)stream;
   return mu_refcount_inc (fs->refcount);
   return mu_refcount_inc (fs->refcount);
 }
 }
 
 
-static void
-_fs_destroy (stream_t *pstream)
+void
+_stream_stdio_destroy (stream_t *pstream)
 {
 {
-  struct _fs *fs = (struct _fs *)*pstream;
+  struct _stream_stdio *fs = (struct _stream_stdio *)*pstream;
   if (mu_refcount_dec (fs->refcount) == 0)
   if (mu_refcount_dec (fs->refcount) == 0)
     {
     {
       mu_refcount_destroy (&fs->refcount);
       mu_refcount_destroy (&fs->refcount);
@@ -52,10 +52,10 @@ _fs_destroy (stream_t *pstream)
     }
     }
 }
 }
 
 
-static int
-_fs_read (stream_t stream, void *optr, size_t osize, size_t *nbytes)
+int
+_stream_stdio_read (stream_t stream, void *optr, size_t osize, size_t *nbytes)
 {
 {
-  struct _fs *fs = (struct _fs *)stream;
+  struct _stream_stdio *fs = (struct _stream_stdio *)stream;
   size_t n = 0;
   size_t n = 0;
   int err = 0;
   int err = 0;
 
 
@@ -74,10 +74,10 @@ _fs_read (stream_t stream, void *optr, size_t osize, size_t *nbytes)
   return err;
   return err;
 }
 }
 
 
-static int
-_fs_readline (stream_t stream, char *optr, size_t osize, size_t *nbytes)
+int
+_stream_stdio_readline (stream_t stream, char *optr, size_t osize, size_t *nbytes)
 {
 {
-  struct _fs *fs = (struct _fs *)stream;
+  struct _stream_stdio *fs = (struct _stream_stdio *)stream;
   size_t n = 0;
   size_t n = 0;
   int err = 0;
   int err = 0;
 
 
@@ -99,10 +99,10 @@ _fs_readline (stream_t stream, char *optr, size_t osize, size_t *nbytes)
   return err;
   return err;
 }
 }
 
 
-static int
-_fs_write (stream_t stream, const void *iptr, size_t isize, size_t *nbytes)
+int
+_stream_stdio_write (stream_t stream, const void *iptr, size_t isize, size_t *nbytes)
 {
 {
-  struct _fs *fs = (struct _fs *)stream;
+  struct _stream_stdio *fs = (struct _stream_stdio *)stream;
   size_t n = 0;
   size_t n = 0;
   int err = 0;
   int err = 0;
 
 
@@ -123,19 +123,19 @@ _fs_write (stream_t stream, const void *iptr, size_t isize, size_t *nbytes)
   return err;
   return err;
 }
 }
 
 
-static int
-_fs_truncate (stream_t stream, off_t len)
+int
+_stream_stdio_truncate (stream_t stream, off_t len)
 {
 {
-  struct _fs *fs = (struct _fs *)stream;
+  struct _stream_stdio *fs = (struct _stream_stdio *)stream;
   if (fs->file && ftruncate (fileno (fs->file), len) != 0)
   if (fs->file && ftruncate (fileno (fs->file), len) != 0)
     return MU_ERROR_IO;
     return MU_ERROR_IO;
   return 0;
   return 0;
 }
 }
 
 
-static int
-_fs_get_size (stream_t stream, off_t *psize)
+int
+_stream_stdio_get_size (stream_t stream, off_t *psize)
 {
 {
-  struct _fs *fs = (struct _fs *)stream;
+  struct _stream_stdio *fs = (struct _stream_stdio *)stream;
   struct stat stbuf;
   struct stat stbuf;
   stbuf.st_size = 0;
   stbuf.st_size = 0;
   if (fs->file)
   if (fs->file)
@@ -149,19 +149,19 @@ _fs_get_size (stream_t stream, off_t *psize)
   return 0;
   return 0;
 }
 }
 
 
-static int
-_fs_flush (stream_t stream)
+int
+_stream_stdio_flush (stream_t stream)
 {
 {
-  struct _fs *fs = (struct _fs *)stream;
+  struct _stream_stdio *fs = (struct _stream_stdio *)stream;
   if (fs->file)
   if (fs->file)
     return fflush (fs->file);
     return fflush (fs->file);
   return 0;
   return 0;
 }
 }
 
 
-static int
-_fs_get_fd (stream_t stream, int *pfd)
+int
+_stream_stdio_get_fd (stream_t stream, int *pfd)
 {
 {
-  struct _fs *fs = (struct _fs *)stream;
+  struct _stream_stdio *fs = (struct _stream_stdio *)stream;
   int status = 0;
   int status = 0;
   if (pfd)
   if (pfd)
     {
     {
@@ -173,10 +173,10 @@ _fs_get_fd (stream_t stream, int *pfd)
   return status;
   return status;
 }
 }
 
 
-static int
-_fs_seek (stream_t stream, off_t off, enum stream_whence whence)
+int
+_stream_stdio_seek (stream_t stream, off_t off, enum stream_whence whence)
 {
 {
-  struct _fs *fs = (struct _fs *)stream;
+  struct _stream_stdio *fs = (struct _stream_stdio *)stream;
   int err = 0;
   int err = 0;
   if (fs->file)
   if (fs->file)
     {
     {
@@ -194,28 +194,28 @@ _fs_seek (stream_t stream, off_t off, enum stream_whence whence)
   return err;
   return err;
 }
 }
 
 
-static int
-_fs_tell (stream_t stream, off_t *off)
+int
+_stream_stdio_tell (stream_t stream, off_t *off)
 {
 {
-  struct _fs *fs = (struct _fs *)stream;
+  struct _stream_stdio *fs = (struct _stream_stdio *)stream;
   if (off == NULL)
   if (off == NULL)
     return MU_ERROR_INVALID_PARAMETER;
     return MU_ERROR_INVALID_PARAMETER;
   *off = (fs->file) ? ftell (fs->file) : 0;
   *off = (fs->file) ? ftell (fs->file) : 0;
   return 0;
   return 0;
 }
 }
 
 
-static int
-_fs_get_flags (stream_t stream, int *flags)
+int
+_stream_stdio_get_flags (stream_t stream, int *flags)
 {
 {
-  struct _fs *fs = (struct _fs *)stream;
+  struct _stream_stdio *fs = (struct _stream_stdio *)stream;
   if (flags == NULL)
   if (flags == NULL)
     return MU_ERROR_INVALID_PARAMETER;
     return MU_ERROR_INVALID_PARAMETER;
   *flags = fs->flags;
   *flags = fs->flags;
   return 0;
   return 0;
 }
 }
 
 
-static int
-_fs_get_state (stream_t stream, enum stream_state *state)
+int
+_stream_stdio_get_state (stream_t stream, enum stream_state *state)
 {
 {
   (void)stream;
   (void)stream;
   if (state == NULL)
   if (state == NULL)
@@ -224,40 +224,39 @@ _fs_get_state (stream_t stream, enum stream_state *state)
   return 0;
   return 0;
 }
 }
 
 
-static int
-_fs_is_open (stream_t stream)
+int
+_stream_stdio_is_open (stream_t stream)
 {
 {
-  struct _fs *fs = (struct _fs *)stream;
+  struct _stream_stdio *fs = (struct _stream_stdio *)stream;
   return (fs->file) ? 1 : 0;
   return (fs->file) ? 1 : 0;
 }
 }
 
 
-static int
-_fs_is_readready (stream_t stream, int timeout)
+int
+_stream_stdio_is_readready (stream_t stream, int timeout)
 {
 {
   (void)timeout;
   (void)timeout;
-  return _fs_is_open (stream);
+  return _stream_stdio_is_open (stream);
 }
 }
 
 
-static int
-_fs_is_writeready (stream_t stream, int timeout)
+int
+_stream_stdio_is_writeready (stream_t stream, int timeout)
 {
 {
   (void)timeout;
   (void)timeout;
-  return _fs_is_open (stream);
+  return _stream_stdio_is_open (stream);
 }
 }
 
 
-static int
-_fs_is_exceptionpending (stream_t stream, int timeout)
+int
+_stream_stdio_is_exceptionpending (stream_t stream, int timeout)
 {
 {
   (void)stream;
   (void)stream;
   (void)timeout;
   (void)timeout;
   return 0;
   return 0;
 }
 }
 
 
-
-static int
-_fs_close (stream_t stream)
+int
+_stream_stdio_close (stream_t stream)
 {
 {
-  struct _fs *fs = (struct _fs *)stream;
+  struct _stream_stdio *fs = (struct _stream_stdio *)stream;
   int err = 0;
   int err = 0;
   if (fs->file)
   if (fs->file)
     {
     {
@@ -268,10 +267,10 @@ _fs_close (stream_t stream)
   return err;
   return err;
 }
 }
 
 
-static int
-_fs_open (stream_t stream, const char *filename, int port, int flags)
+int
+_stream_stdio_open (stream_t stream, const char *filename, int port, int flags)
 {
 {
-  struct _fs *fs = (struct _fs *)stream;
+  struct _stream_stdio *fs = (struct _stream_stdio *)stream;
   int flg;
   int flg;
   int fd;
   int fd;
   const char *mode;
   const char *mode;
@@ -371,40 +370,60 @@ _fs_open (stream_t stream, const char *filename, int port, int flags)
   return 0;
   return 0;
 }
 }
 
 
-static struct _stream_vtable _fs_vtable =
+static struct _stream_vtable _stream_stdio_vtable =
 {
 {
-  _fs_ref,
-  _fs_destroy,
+  _stream_stdio_ref,
+  _stream_stdio_destroy,
 
 
-  _fs_open,
-  _fs_close,
+  _stream_stdio_open,
+  _stream_stdio_close,
 
 
-  _fs_read,
-  _fs_readline,
-  _fs_write,
+  _stream_stdio_read,
+  _stream_stdio_readline,
+  _stream_stdio_write,
 
 
-  _fs_seek,
-  _fs_tell,
+  _stream_stdio_seek,
+  _stream_stdio_tell,
 
 
-  _fs_get_size,
-  _fs_truncate,
-  _fs_flush,
+  _stream_stdio_get_size,
+  _stream_stdio_truncate,
+  _stream_stdio_flush,
 
 
-  _fs_get_fd,
-  _fs_get_flags,
-  _fs_get_state,
+  _stream_stdio_get_fd,
+  _stream_stdio_get_flags,
+  _stream_stdio_get_state,
 
 
-  _fs_is_readready,
-  _fs_is_writeready,
-  _fs_is_exceptionpending,
+  _stream_stdio_is_readready,
+  _stream_stdio_is_writeready,
+  _stream_stdio_is_exceptionpending,
 
 
-  _fs_is_open
+  _stream_stdio_is_open
 };
 };
 
 
 int
 int
+_stream_stdio_ctor (struct _stream_stdio *fs, FILE *fp)
+{
+  mu_refcount_create (&fs->refcount);
+  if (fs->refcount == NULL)
+    return MU_ERROR_NO_MEMORY ;
+  fs->file = fp;
+  fs->flags = 0;
+  fs->base.vtable = &_stream_stdio_vtable;
+  return 0;
+}
+
+void
+_stream_stdio_dtor (struct _stream_stdio *fs)
+{
+  mu_refcount_destroy (&fs->refcount);
+  /* We may leak if they did not close the FILE * */
+  fs->file = NULL;
+}
+
+int
 stream_file_create (stream_t *pstream)
 stream_file_create (stream_t *pstream)
 {
 {
-  struct _fs *fs;
+  struct _stream_stdio *fs;
 
 
   if (pstream == NULL)
   if (pstream == NULL)
     return MU_ERROR_INVALID_PARAMETER;
     return MU_ERROR_INVALID_PARAMETER;
@@ -421,7 +440,7 @@ stream_file_create (stream_t *pstream)
     }
     }
   fs->file = NULL;
   fs->file = NULL;
   fs->flags = 0;
   fs->flags = 0;
-  fs->base.vtable = &_fs_vtable;
+  fs->base.vtable = &_stream_stdio_vtable;
   *pstream = &fs->base;
   *pstream = &fs->base;
   return 0;
   return 0;
 }
 }
@@ -429,7 +448,7 @@ stream_file_create (stream_t *pstream)
 int
 int
 stream_stdio_create (stream_t *pstream, FILE *fp)
 stream_stdio_create (stream_t *pstream, FILE *fp)
 {
 {
-  struct _fs *fs;
+  struct _stream_stdio *fs;
 
 
   if (pstream == NULL)
   if (pstream == NULL)
     return MU_ERROR_INVALID_PARAMETER;
     return MU_ERROR_INVALID_PARAMETER;
@@ -446,7 +465,7 @@ stream_stdio_create (stream_t *pstream, FILE *fp)
     }
     }
   fs->file = fp;
   fs->file = fp;
   fs->flags = 0;
   fs->flags = 0;
-  fs->base.vtable = &_fs_vtable;
+  fs->base.vtable = &_stream_stdio_vtable;
   *pstream = &fs->base;
   *pstream = &fs->base;
   return 0;
   return 0;
 }
 }

@@ -15,7 +15,7 @@ pkginclude_HEADERS = \
  header.h     \
  header.h     \
  iterator.h   \
  iterator.h   \
  list.h       \
  list.h       \
- locker.h     \
+ lockfile.h   \
  mailbox.h    \
  mailbox.h    \
  mbox.h       \
  mbox.h       \
  md5-rsa.h    \
  md5-rsa.h    \

@@ -42,8 +42,6 @@ typedef struct _attribute * attribute_t;
 #define MU_ATTRIBUTE_MODIFIED 0x1000
 #define MU_ATTRIBUTE_MODIFIED 0x1000
 #define MU_ATTRIBUTE_RECENT   0x0000
 #define MU_ATTRIBUTE_RECENT   0x0000
 
 
-extern int  attribute_create          __P ((attribute_t *));
-
 extern int  attribute_ref             __P ((attribute_t));
 extern int  attribute_ref             __P ((attribute_t));
 extern void attribute_destroy        __P ((attribute_t *));
 extern void attribute_destroy        __P ((attribute_t *));
 
 
@@ -83,6 +81,8 @@ extern int  attribute_clear_flags     __P ((attribute_t));
 extern int  attribute_is_equal        __P ((attribute_t, attribute_t));
 extern int  attribute_is_equal        __P ((attribute_t, attribute_t));
 extern int  attribute_copy            __P ((attribute_t dst, attribute_t src));
 extern int  attribute_copy            __P ((attribute_t dst, attribute_t src));
 
 
+extern int  attribute_default_create  __P ((attribute_t *));
+extern int  attribute_status_create   __P ((attribute_t *, const char *));
 
 
 #ifdef __cplusplus
 #ifdef __cplusplus
 }
 }

@@ -15,8 +15,8 @@
    along with this program; if not, write to the Free Software
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 
 
-#ifndef _MAILUTILS_LOCKER_H
-#define _MAILUTILS_LOCKER_H
+#ifndef _MAILUTILS_LOCKFILE_H
+#define _MAILUTILS_LOCKFILE_H
 
 
 #include <sys/types.h>
 #include <sys/types.h>
 
 
@@ -32,21 +32,21 @@ extern "C" {
 # endif
 # endif
 #endif /*__P */
 #endif /*__P */
 
 
-struct _locker;
-typedef struct _locker *locker_t;
+struct _lockfile;
+typedef struct _lockfile *lockfile_t;
 
 
-extern int  locker_ref            __P ((locker_t));
-extern void locker_destroy        __P ((locker_t *));
+extern int  lockfile_ref            __P ((lockfile_t));
+extern void lockfile_destroy        __P ((lockfile_t *));
 
 
-extern int  locker_lock           __P ((locker_t));
-extern int  locker_touchlock      __P ((locker_t));
-extern int  locker_unlock         __P ((locker_t));
+extern int  lockfile_lock           __P ((lockfile_t));
+extern int  lockfile_touchlock      __P ((lockfile_t));
+extern int  lockfile_unlock         __P ((lockfile_t));
 
 
-extern int  locker_dotlock_create __P ((locker_t *, const char *filename));
-extern int  locker_nfslock_create __P ((locker_t *, const char *filename));
+extern int  lockfile_dotlock_create __P ((lockfile_t *, const char *filename));
+extern int  lockfile_nfslock_create __P ((lockfile_t *, const char *filename));
 
 
 #ifdef __cplusplus
 #ifdef __cplusplus
 }
 }
 #endif
 #endif
 
 
-#endif /* _MAILUTILS_MAILBOX_H */
+#endif /* _MAILUTILS_LOCKFILE_H */

@@ -41,7 +41,7 @@ extern int  mbox_create          __P ((mbox_t *));
 extern void mbox_destroy         __P ((mbox_t *));
 extern void mbox_destroy         __P ((mbox_t *));
 
 
 extern int  mbox_get_uidvalidity __P ((mbox_t, unsigned long *));
 extern int  mbox_get_uidvalidity __P ((mbox_t, unsigned long *));
-extern int  mbox_get_uidnext     __P ((mbox_t, unsigned long));
+extern int  mbox_get_uidnext     __P ((mbox_t, unsigned long *));
 
 
 extern int  mbox_open            __P ((mbox_t, const char *, int));
 extern int  mbox_open            __P ((mbox_t, const char *, int));
 extern int  mbox_close           __P ((mbox_t));
 extern int  mbox_close           __P ((mbox_t));
@@ -57,7 +57,7 @@ extern int  mbox_set_hstream     __P ((mbox_t, unsigned int, stream_t));
 extern int  mbox_get_hsize       __P ((mbox_t, unsigned int, unsigned int *));
 extern int  mbox_get_hsize       __P ((mbox_t, unsigned int, unsigned int *));
 extern int  mbox_get_hlines      __P ((mbox_t, unsigned int, unsigned int *));
 extern int  mbox_get_hlines      __P ((mbox_t, unsigned int, unsigned int *));
 
 
-extern int  mbox_get_bstream     __P ((mbox_t, unsigned int, stream_t int *));
+extern int  mbox_get_bstream     __P ((mbox_t, unsigned int, stream_t *));
 extern int  mbox_set_bstream     __P ((mbox_t, unsigned int, stream_t));
 extern int  mbox_set_bstream     __P ((mbox_t, unsigned int, stream_t));
 extern int  mbox_get_bsize       __P ((mbox_t, unsigned int, unsigned int *));
 extern int  mbox_get_bsize       __P ((mbox_t, unsigned int, unsigned int *));
 extern int  mbox_get_blines      __P ((mbox_t, unsigned int, unsigned int *));
 extern int  mbox_get_blines      __P ((mbox_t, unsigned int, unsigned int *));
@@ -75,12 +75,18 @@ extern int  mbox_set_newmsg_cb   __P ((mbox_t, int (*) __P ((int, void *)), void
 extern int  mbox_newmsg_cb       __P ((mbox_t, int));
 extern int  mbox_newmsg_cb       __P ((mbox_t, int));
 extern int  mbox_progress_cb     __P ((mbox_t, int));
 extern int  mbox_progress_cb     __P ((mbox_t, int));
 
 
-extern int  mbox_scan            __P ((mbox_t, unsigned int, unsigned int *));
+extern int  mbox_scan            __P ((mbox_t, unsigned int, unsigned int *, int));
 extern int  mbox_messages_count  __P ((mbox_t, unsigned int *));
 extern int  mbox_messages_count  __P ((mbox_t, unsigned int *));
 
 
 extern int  mbox_append          __P ((mbox_t, const char *, stream_t));
 extern int  mbox_append          __P ((mbox_t, const char *, stream_t));
 extern int  mbox_append_hb       __P ((mbox_t, const char *, stream_t, stream_t));
 extern int  mbox_append_hb       __P ((mbox_t, const char *, stream_t, stream_t));
 
 
+extern int  mbox_get_carrier     __P ((mbox_t, stream_t *));
+extern int  mbox_set_carrier     __P ((mbox_t, stream_t));
+
+extern int  mbox_set_hcache       __P ((mbox_t, char **, unsigned int));
+extern int  mbox_hcache_get_value __P ((mbox_t, const char *, char *, size_t,
+					size_t *));
 
 
 #ifdef __cplusplus
 #ifdef __cplusplus
 }
 }

@@ -81,8 +81,8 @@ extern int  stream_is_open __P ((stream_t));
 /* Misc.  */
 /* Misc.  */
 extern int  stream_file_create    __P ((stream_t *));
 extern int  stream_file_create    __P ((stream_t *));
 extern int  stream_stdio_create   __P ((stream_t *, FILE *));
 extern int  stream_stdio_create   __P ((stream_t *, FILE *));
-extern int  stream_mapfile_create __P ((stream_t *));
-extern int  stream_memory_create  __P ((stream_t *));
+extern int  stream_mmap_create    __P ((stream_t *));
+extern int  stream_memory_create  __P ((stream_t *, size_t));
 extern int  stream_tcp_create     __P ((stream_t *));
 extern int  stream_tcp_create     __P ((stream_t *));
 extern int  stream_fd_create      __P ((stream_t *, int));
 extern int  stream_fd_create      __P ((stream_t *, int));
 extern int  stream_buffer_create  __P ((stream_t *, stream_t, size_t));
 extern int  stream_buffer_create  __P ((stream_t *, stream_t, size_t));

@@ -5,6 +5,7 @@ pkginclude_HEADERS = \
  attribute.h  \
  attribute.h  \
  authority.h  \
  authority.h  \
  bstream.h    \
  bstream.h    \
+ dattribute.h \
  debug.h      \
  debug.h      \
  envelope.h   \
  envelope.h   \
  folder.h     \
  folder.h     \
@@ -12,15 +13,16 @@ pkginclude_HEADERS = \
  header.h     \
  header.h     \
  iterator.h   \
  iterator.h   \
  list.h       \
  list.h       \
- locker.h     \
+ lockfile.h   \
  mailbox.h    \
  mailbox.h    \
  mbox.h       \
  mbox.h       \
+ mapstream.h  \
  memstream.h  \
  memstream.h  \
  message.h    \
  message.h    \
- mstream.h    \
  observable.h \
  observable.h \
  observer.h   \
  observer.h   \
  pop3.h       \
  pop3.h       \
+ pticket.h    \
  refcount.h   \
  refcount.h   \
  sdebug.h     \
  sdebug.h     \
  stream.h     \
  stream.h     \

@@ -21,6 +21,10 @@
 #include <mailutils/sys/stream.h>
 #include <mailutils/sys/stream.h>
 #include <mailutils/refcount.h>
 #include <mailutils/refcount.h>
 
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* Read buffer */
 /* Read buffer */
 struct _rbuffer
 struct _rbuffer
 {
 {
@@ -30,7 +34,7 @@ struct _rbuffer
   size_t bufsize;
   size_t bufsize;
 };
 };
 
 
-struct _bs
+struct _stream_buffer
 {
 {
   struct _stream base;
   struct _stream base;
   mu_refcount_t refcount;
   mu_refcount_t refcount;
@@ -38,4 +42,30 @@ struct _bs
   struct _rbuffer rbuffer;
   struct _rbuffer rbuffer;
 };
 };
 
 
+extern int  _stream_buffer_ctor __P ((struct _stream_buffer *, stream_t, size_t));
+extern void _stream_buffer_dtor __P ((struct _stream_buffer *));
+extern int  _stream_buffer_ref  __P ((stream_t));
+extern void _stream_buffer_destroy __P ((stream_t *));
+extern int  _stream_buffer_open    __P ((stream_t, const char *, int, int));
+extern int  _stream_buffer_close   __P ((stream_t));
+extern int  _stream_buffer_read    __P ((stream_t, void *, size_t, size_t *));
+extern int  _stream_buffer_readline __P ((stream_t, char *, size_t, size_t *));
+extern int  _stream_buffer_write __P ((stream_t, const void *, size_t, size_t *));
+extern int  _stream_buffer_get_fd __P ((stream_t, int *));
+extern int  _stream_buffer_get_flags __P ((stream_t, int *));
+extern int  _stream_buffer_get_size  __P ((stream_t, off_t *));
+extern int  _stream_buffer_truncate  __P ((stream_t, off_t));
+extern int  _stream_buffer_flush     __P ((stream_t));
+extern int  _stream_buffer_get_state __P ((stream_t, enum stream_state *));
+extern int  _stream_buffer_seek __P ((stream_t, off_t, enum stream_whence));
+extern int  _stream_buffer_tell __P ((stream_t, off_t *));
+extern int  _stream_buffer_is_readready __P ((stream_t, int ));
+extern int  _stream_buffer_is_writeready __P ((stream_t, int));
+extern int  _stream_buffer_is_exceptionpending __P ((stream_t, int));
+extern int  _stream_buffer_is_open __P ((stream_t));
+
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* _MAILUTILS_SYS_BSTREAM_H */
 #endif /* _MAILUTILS_SYS_BSTREAM_H */

+/* GNU mailutils - a suite of utilities for electronic mail
+   Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Library Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program 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 Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#ifndef _MAILUTILS_SYS_DATTRIBUTE_H
+# define _MAILUTILS_SYS_DATTRIBUTE_H
+
+#ifdef DMALLOC
+#  include <dmalloc.h>
+#endif
+
+#include <mailutils/sys/attribute.h>
+#include <mailutils/refcount.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* A simple default attribute implementation.  */
+struct _attribute_default
+{
+  struct _attribute base;
+  mu_refcount_t refcount;
+  int flags;
+};
+
+extern int  _attribute_default_ctor        __P ((struct _attribute_default *));
+extern void _attribute_default_dtor        __P ((struct _attribute_default *));
+extern int  _attribute_default_ref         __P ((attribute_t));
+extern void _attribute_default_destroy     __P ((attribute_t *));
+
+extern int  _attribute_default_get_flags   __P ((attribute_t, int *));
+extern int  _attribute_default_set_flags   __P ((attribute_t, int));
+extern int  _attribute_default_unset_flags __P ((attribute_t, int));
+extern int  _attribute_default_clear_flags __P ((attribute_t));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _MAILUTILS_SYS_ATTRIBUTE_H */

+/* GNU mailutils - a suite of utilities for electronic mail
+   Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Library Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program 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 Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#ifndef _MAILUTILS_SYS_DOTLOCK_H
+#define _MAILUTILS_SYS_DOTLOCK_H
+
+#ifdef DMALLOC
+#include <dmalloc.h>
+#endif
+
+#include <mailutils/refcount.h>
+#include <mailutils/sys/lockfile.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* locking flags */
+#define MU_LOCKFILE_DOTLOCK_PID    1
+#define MU_LOCKFILE_DOTLOCK_FCNTL  2
+#define MU_LOCKFILE_DOTLOCK_TIME   4
+
+#define MU_LOCKFILE_DOTLOCK_EXPIRE_TIME        (5 * 60)
+
+#define MU_LOCKFILE_DOTLOCK_ATTR           0444
+
+struct _lockfile_dotlock
+{
+  struct _lockfile base;
+  mu_refcount_t refcount;
+  int fd;
+  int refcnt; /* For recursive file locking.  */
+  char *fname;
+  int flags;
+};
+
+extern int  _lockfile_dotlock_ctor __P ((struct _lockfile_dotlock *, const char *));
+extern void _lockfile_dotlock_dtor __P ((struct _lockfile_dotlock *));
+extern int  _lockfile_dotlock_ref  __P ((lockfile_t));
+extern void _lockfile_dotlock_destroy __P ((lockfile_t *));
+
+extern int  _lockfile_dotlock_lock    __P ((lockfile_t));
+extern int  _lockfile_dotlock_touchlock __P ((lockfile_t));
+extern int  _lockfile_dotlock_unlock    __P ((lockfile_t));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _MAILUTILS_SYS_DOTLOCK_H */

@@ -21,7 +21,11 @@
 #include <mailutils/refcount.h>
 #include <mailutils/refcount.h>
 #include <mailutils/sys/stream.h>
 #include <mailutils/sys/stream.h>
 
 
-struct _fds
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _stream_fd
 {
 {
   struct _stream base;
   struct _stream base;
   mu_refcount_t refcount;
   mu_refcount_t refcount;
@@ -30,4 +34,31 @@ struct _fds
   int flags;
   int flags;
 };
 };
 
 
+int  _stream_fd_ctor __P ((struct _stream_fd *, int));
+void _stream_fd_dtor __P ((struct _stream_fd *));
+
+int  _stream_fd_ref  __P ((stream_t));
+void _stream_fd_destroy __P ((stream_t *));
+int  _stream_fd_open    __P ((stream_t, const char *, int, int));
+int  _stream_fd_close   __P ((stream_t));
+int  _stream_fd_read    __P ((stream_t, void *, size_t, size_t *));
+int  _stream_fd_readline __P ((stream_t, char *, size_t, size_t *));
+int  _stream_fd_write    __P ((stream_t, const void *, size_t, size_t *));
+int  _stream_fd_get_fd   __P ((stream_t, int *));
+int  _stream_fd_get_flags __P ((stream_t, int *));
+int  _stream_fd_get_size  __P ((stream_t, off_t *));
+int  _stream_fd_truncate  __P ((stream_t, off_t));
+int  _stream_fd_flush     __P ((stream_t));
+int  _stream_fd_get_state __P ((stream_t, enum stream_state *));
+int  _stream_fd_seek      __P ((stream_t, off_t, enum stream_whence));
+int  _stream_fd_tell      __P ((stream_t, off_t *));
+int  _stream_fd_is_readready __P ((stream_t, int ));
+int  _stream_fd_is_writeready __P ((stream_t, int));
+int  _stream_fd_is_exceptionpending __P ((stream_t, int));
+int  _stream_fd_is_open __P ((stream_t));
+
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* _MAILUTILS_SYS_FDSTREAM_H */
 #endif /* _MAILUTILS_SYS_FDSTREAM_H */

@@ -21,7 +21,11 @@
 #include <mailutils/sys/stream.h>
 #include <mailutils/sys/stream.h>
 #include <mailutils/refcount.h>
 #include <mailutils/refcount.h>
 
 
-struct _fs
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _stream_stdio
 {
 {
   struct _stream base;
   struct _stream base;
   mu_refcount_t refcount;
   mu_refcount_t refcount;
@@ -29,4 +33,30 @@ struct _fs
   FILE *file;
   FILE *file;
 };
 };
 
 
+extern int  _stream_stdio_ctor __P ((struct _stream_stdio *, FILE *));
+extern void _stream_stdio_dtor __P ((struct _stream_stdio *));
+extern int  _stream_stdio_ref  __P ((stream_t));
+extern void _stream_stdio_destroy __P ((stream_t *));
+extern int  _stream_stdio_open    __P ((stream_t, const char *, int, int));
+extern int  _stream_stdio_close   __P ((stream_t));
+extern int  _stream_stdio_read    __P ((stream_t, void *, size_t, size_t *));
+extern int  _stream_stdio_readline __P ((stream_t, char *, size_t, size_t *));
+extern int  _stream_stdio_write __P ((stream_t, const void *, size_t, size_t *));
+extern int  _stream_stdio_get_fd __P ((stream_t, int *));
+extern int  _stream_stdio_get_flags __P ((stream_t, int *));
+extern int  _stream_stdio_get_size  __P ((stream_t, off_t *));
+extern int  _stream_stdio_truncate  __P ((stream_t, off_t));
+extern int  _stream_stdio_flush     __P ((stream_t));
+extern int  _stream_stdio_get_state __P ((stream_t, enum stream_state *));
+extern int  _stream_stdio_seek __P ((stream_t, off_t, enum stream_whence));
+extern int  _stream_stdio_tell __P ((stream_t, off_t *));
+extern int  _stream_stdio_is_readready __P ((stream_t, int ));
+extern int  _stream_stdio_is_writeready __P ((stream_t, int));
+extern int  _stream_stdio_is_exceptionpending __P ((stream_t, int));
+extern int  _stream_stdio_is_open __P ((stream_t));
+
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* _MAILUTILS_SYS_FSTREAM_H */
 #endif /* _MAILUTILS_SYS_FSTREAM_H */

@@ -15,14 +15,14 @@
    along with this program; if not, write to the Free Software
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 
 
-#ifndef _MAILUTILS_SYS_LOCKER_H
-#define _MAILUTILS_SYS_LOCKER_H
+#ifndef _MAILUTILS_SYS_LOCKFILE_H
+#define _MAILUTILS_SYS_LOCKFILE_H
 
 
 #ifdef DMALLOC
 #ifdef DMALLOC
 #include <dmalloc.h>
 #include <dmalloc.h>
 #endif
 #endif
 
 
-#include <mailutils/locker.h>
+#include <mailutils/lockfile.h>
 
 
 #ifdef __cplusplus
 #ifdef __cplusplus
 extern "C" {
 extern "C" {
@@ -36,23 +36,23 @@ extern "C" {
 # endif
 # endif
 #endif /*__P */
 #endif /*__P */
 
 
-struct _locker_vtable
+struct _lockfile_vtable
 {
 {
-  int  (*ref)       __P ((locker_t));
-  void (*destroy)   __P ((locker_t *));
+  int  (*ref)       __P ((lockfile_t));
+  void (*destroy)   __P ((lockfile_t *));
 
 
-  int  (*lock)      __P ((locker_t));
-  int  (*touchlock) __P ((locker_t));
-  int  (*unlock)    __P ((locker_t));
+  int  (*lock)      __P ((lockfile_t));
+  int  (*touchlock) __P ((lockfile_t));
+  int  (*unlock)    __P ((lockfile_t));
 };
 };
 
 
-struct _locker
+struct _lockfile
 {
 {
-  struct _locker_vtable *vtable;
+  struct _lockfile_vtable *vtable;
 };
 };
 
 
 #ifdef __cplusplus
 #ifdef __cplusplus
 }
 }
 #endif
 #endif
 
 
-#endif /* _MAILUTILS_SYS_ENVELOPE_H */
+#endif /* _MAILUTILS_SYS_LOCKFILE_H */

@@ -18,10 +18,18 @@
 #ifndef MAILUTILS_SYS_MSTREAM_H
 #ifndef MAILUTILS_SYS_MSTREAM_H
 #define MAILUTILS_SYS_MSTREAM_H
 #define MAILUTILS_SYS_MSTREAM_H
 
 
+#include <unistd.h>
+
 #include <mailutils/sys/stream.h>
 #include <mailutils/sys/stream.h>
 #include <mailutils/refcount.h>
 #include <mailutils/refcount.h>
 
 
-struct _ms
+#ifdef _POSIX_MAPPED_FILES
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _stream_mmap
 {
 {
   struct _stream base;
   struct _stream base;
   mu_refcount_t refcount;
   mu_refcount_t refcount;
@@ -33,4 +41,31 @@ struct _ms
   off_t offset;
   off_t offset;
 };
 };
 
 
+extern int  _stream_mmap_ctor __P ((struct _stream_mmap *));
+extern void _stream_mmap_dtor __P ((struct _stream_mmap *));
+extern int  _stream_mmap_ref  __P ((stream_t));
+extern void _stream_mmap_destroy __P ((stream_t *));
+extern int  _stream_mmap_open    __P ((stream_t, const char *, int, int));
+extern int  _stream_mmap_close   __P ((stream_t));
+extern int  _stream_mmap_read    __P ((stream_t, void *, size_t, size_t *));
+extern int  _stream_mmap_readline __P ((stream_t, char *, size_t, size_t *));
+extern int  _stream_mmap_write __P ((stream_t, const void *, size_t, size_t *));
+extern int  _stream_mmap_get_fd __P ((stream_t, int *));
+extern int  _stream_mmap_get_flags __P ((stream_t, int *));
+extern int  _stream_mmap_get_size  __P ((stream_t, off_t *));
+extern int  _stream_mmap_truncate  __P ((stream_t, off_t));
+extern int  _stream_mmap_flush     __P ((stream_t));
+extern int  _stream_mmap_get_state __P ((stream_t, enum stream_state *));
+extern int  _stream_mmap_seek      __P ((stream_t, off_t, enum stream_whence));
+extern int  _stream_mmap_tell      __P ((stream_t, off_t *));
+extern int  _stream_mmap_is_readready __P ((stream_t, int ));
+extern int  _stream_mmap_is_writeready __P ((stream_t, int));
+extern int  _stream_mmap_is_exceptionpending __P ((stream_t, int));
+extern int  _stream_mmap_is_open __P ((stream_t));
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* _MAILUTILS_SYS_MSTREAM_H */
 #endif /* _MAILUTILS_SYS_MSTREAM_H */

@@ -19,7 +19,7 @@
 #define _MAILUTILS_SYS_MBOX_H
 #define _MAILUTILS_SYS_MBOX_H
 
 
 #include <time.h>
 #include <time.h>
-#include <mailutils/locker.h>
+#include <mailutils/lockfile.h>
 #include <mailutils/mbox.h>
 #include <mailutils/mbox.h>
 
 
 #ifdef __cplusplus
 #ifdef __cplusplus
@@ -28,35 +28,6 @@ extern "C" {
 
 
 typedef struct _mbox_message* mbox_message_t;
 typedef struct _mbox_message* mbox_message_t;
 
 
-
-/* Keep the file positions of where the headers and bodies start and end.
-   attribute is the "Status:" message.  */
-struct _mbox_message
-{
-  /* Offset of the messages in the mailbox.  */
-  off_t from_;
-
-  /* Fast header retrieve, we save here the most common headers. This will
-     speed the header search.  The entire headers are copied, when modified,
-     by the header_t object, we do not have to worry about updating them.  */
-  char **fhdr;
-
-  struct
-  {
-    stream_t stream;
-    unsigned int lines;
-    unsigned int size;
-    off_t start;
-    off_t end;
-  } header, body;
-
-  /* UID i.e. see IMAP  */
-  unsigned long uid;
-  attribute_t attribute; /* The attr_flags contains the "Status:" attribute  */
-
-  mbox_t mbox; /* Back pointer.  */
-};
-
 /* The umessages is an array of pointers that contains umessages_count of
 /* The umessages is an array of pointers that contains umessages_count of
    mbox_message_t*; umessages[umessages_count].  We do it this way because
    mbox_message_t*; umessages[umessages_count].  We do it this way because
    realloc() can move everything to a new memory region and invalidate all
    realloc() can move everything to a new memory region and invalidate all
@@ -85,8 +56,7 @@ struct _mbox
     MBOX_STATE_APPEND_BODY
     MBOX_STATE_APPEND_BODY
   } state ;
   } state ;
 
 
-  locker_t  locker;
-
+  lockfile_t  lockfile;
   struct
   struct
   {
   {
     int (*cb) __P ((int, void *));
     int (*cb) __P ((int, void *));
@@ -94,6 +64,35 @@ struct _mbox
   } newmsg, progress, corrupt;
   } newmsg, progress, corrupt;
 };
 };
 
 
+/* Keep the file positions of where the headers and bodies start and end.
+   attribute is the "Status:" message.  */
+struct _mbox_message
+{
+  /* Offset of the messages in the mailbox.  */
+  off_t from_;
+
+  /* Fast header retrieve, we save here the most common headers. This will
+     speed the header search.  The entire headers are copied, when modified,
+     by the header_t object, we do not have to worry about updating them.  */
+  char **fhdr;
+
+  struct
+  {
+    stream_t stream;
+    unsigned int lines;
+    unsigned int size;
+    off_t start;
+    off_t end;
+  } header, body;
+
+  /* UID i.e. see IMAP  */
+  unsigned long uid;
+  unsigned int attr_flags;
+  attribute_t attribute; /* The attr_flags contains the "Status:" attribute  */
+
+  mbox_t mbox; /* Back pointer.  */
+};
+
 #ifdef __cplusplus
 #ifdef __cplusplus
 }
 }
 #endif
 #endif

@@ -23,14 +23,49 @@
 #include <mailutils/refcount.h>
 #include <mailutils/refcount.h>
 #include <mailutils/sys/stream.h>
 #include <mailutils/sys/stream.h>
 
 
-struct _memory_stream
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef MU_STREAM_MEMORY_BLOCKSIZE
+#define MU_STREAM_MEMORY_BLOCKSIZE 512
+#endif
+
+struct _stream_memory
 {
 {
   struct _stream base;
   struct _stream base;
   mu_refcount_t refcount;
   mu_refcount_t refcount;
   char *ptr;
   char *ptr;
+  size_t capacity;
   size_t size;
   size_t size;
   off_t offset;
   off_t offset;
   int flags;
   int flags;
 };
 };
 
 
+extern int  _stream_memory_ctor __P ((struct _stream_memory *, size_t));
+extern void _stream_memory_dtor __P ((struct _stream_memory *));
+extern int  _stream_memory_ref  __P ((stream_t));
+extern void _stream_memory_destroy __P ((stream_t *));
+extern int  _stream_memory_open    __P ((stream_t, const char *, int, int));
+extern int  _stream_memory_close   __P ((stream_t));
+extern int  _stream_memory_read    __P ((stream_t, void *, size_t, size_t *));
+extern int  _stream_memory_readline __P ((stream_t, char *, size_t, size_t *));
+extern int  _stream_memory_write __P ((stream_t, const void *, size_t, size_t *));
+extern int  _stream_memory_get_fd __P ((stream_t, int *));
+extern int  _stream_memory_get_flags __P ((stream_t, int *));
+extern int  _stream_memory_get_size  __P ((stream_t, off_t *));
+extern int  _stream_memory_truncate  __P ((stream_t, off_t));
+extern int  _stream_memory_flush     __P ((stream_t));
+extern int  _stream_memory_get_state __P ((stream_t, enum stream_state *));
+extern int  _stream_memory_seek __P ((stream_t, off_t, enum stream_whence));
+extern int  _stream_memory_tell __P ((stream_t, off_t *));
+extern int  _stream_memory_is_readready __P ((stream_t, int ));
+extern int  _stream_memory_is_writeready __P ((stream_t, int));
+extern int  _stream_memory_is_exceptionpending __P ((stream_t, int));
+extern int  _stream_memory_is_open __P ((stream_t));
+
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* _MAILUTILS_SYS_MEMSTREAM_H */
 #endif /* _MAILUTILS_SYS_MEMSTREAM_H */

+/* GNU mailutils - a suite of utilities for electronic mail
+   Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Library Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program 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 Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#ifndef _MAILUTILS_SYS_PTICKET_H
+#define _MAILUTILS_SYS_PTICKET_H
+
+#include <mailutils/sys/ticket.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _ticket_prompt
+{
+  struct _ticket base;
+  mu_refcount_t refcount;
+};
+
+extern int  _ticket_prompt_ctor __P ((struct _ticket_prompt *));
+extern void _ticket_prompt_dtor __P ((struct _ticket_prompt *));
+extern int  _ticket_prompt_ref  __P ((ticket_t));
+extern void _ticket_prompt_destroy __P ((ticket_t *));
+extern int  _ticket_prompt_pop     __P ((ticket_t, const char *, char **));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _MAILUTILS_SYS_PTICKET_H */

@@ -29,15 +29,7 @@
 extern "C" {
 extern "C" {
 #endif
 #endif
 
 
-#ifndef __P
-# ifdef __STDC__
-#  define __P(args) args
-# else
-#  define __P(args) ()
-# endif
-#endif /*__P */
-
-struct _sdebug
+struct _mu_debug_stream
 {
 {
   struct _mu_debug base;
   struct _mu_debug base;
   mu_refcount_t refcount;
   mu_refcount_t refcount;
@@ -46,6 +38,14 @@ struct _sdebug
   int close_on_destroy;
   int close_on_destroy;
 };
 };
 
 
+int  _mu_debug_stream_ctor __P ((struct _mu_debug_stream *));
+int  _mu_debug_stream_dtor __P ((struct _mu_debug_stream *));
+int  _mu_debug_stream_ref  __P ((mu_debug_t));
+void _mu_debug_stream_destroy __P ((mu_debug_t *));
+int  _mu_debug_stream_set_level __P ((mu_debug_t, size_t));
+int  _mu_debug_stream_get_level __P ((mu_debug_t, size_t *));
+int  _mu_debug_stream_print     __P ((mu_debug_t, size_t, const char *));
+
 #ifdef __cplusplus
 #ifdef __cplusplus
 }
 }
 #endif
 #endif

@@ -19,9 +19,13 @@
 #define MAILUTILS_SYS_TCP_H
 #define MAILUTILS_SYS_TCP_H
 
 
 #include <mailutils/refcount.h>
 #include <mailutils/refcount.h>
-#include <mailutils/sys/stream.h>
+#include <mailutils/sys/fdstream.h>
 
 
-enum _tcp_state
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum _stream_tcp_state
 {
 {
   TCP_STATE_INIT,
   TCP_STATE_INIT,
   TCP_STATE_RESOLVE,
   TCP_STATE_RESOLVE,
@@ -30,16 +34,21 @@ enum _tcp_state
   TCP_STATE_CONNECTED
   TCP_STATE_CONNECTED
 };
 };
 
 
-struct _tcp_instance
+struct _stream_tcp
 {
 {
-  struct _stream base;
-  mu_refcount_t refcount;
-  int  fd;
+  struct _stream_fd base;
   char *host;
   char *host;
   int  port;
   int  port;
   int  state;
   int  state;
-  int flags;
   unsigned long address;
   unsigned long address;
 };
 };
 
 
+void _stream_tcp_destroy __P ((stream_t *));
+int  _stream_tcp_close __P ((stream_t));
+int _stream_tcp_open     __P ((stream_t, const char *, int, int));
+
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* _MAILUTILS_SYS_TCP_H */
 #endif /* _MAILUTILS_SYS_TCP_H */

@@ -21,52 +21,52 @@
 
 
 #include <stdlib.h>
 #include <stdlib.h>
 #include <mailutils/error.h>
 #include <mailutils/error.h>
-#include <mailutils/sys/locker.h>
+#include <mailutils/sys/lockfile.h>
 
 
 int
 int
-locker_ref (locker_t locker)
+lockfile_ref (lockfile_t lockfile)
 {
 {
-  if (locker == NULL || locker->vtable == NULL
-      || locker->vtable->ref == NULL)
+  if (lockfile == NULL || lockfile->vtable == NULL
+      || lockfile->vtable->ref == NULL)
     return MU_ERROR_NOT_SUPPORTED;
     return MU_ERROR_NOT_SUPPORTED;
-  return locker->vtable->ref (locker);
+  return lockfile->vtable->ref (lockfile);
 }
 }
 
 
 void
 void
-locker_destroy (locker_t *plocker)
+lockfile_destroy (lockfile_t *plockfile)
 {
 {
-  if (plocker && *plocker)
+  if (plockfile && *plockfile)
     {
     {
-      locker_t locker = *plocker;
-      if (locker->vtable && locker->vtable->destroy)
-	locker->vtable->destroy (plocker);
-      *plocker = NULL;
+      lockfile_t lockfile = *plockfile;
+      if (lockfile->vtable && lockfile->vtable->destroy)
+	lockfile->vtable->destroy (plockfile);
+      *plockfile = NULL;
     }
     }
 }
 }
 
 
 int
 int
-locker_lock (locker_t locker)
+lockfile_lock (lockfile_t lockfile)
 {
 {
-  if (locker == NULL || locker->vtable == NULL
-      || locker->vtable->lock == NULL)
+  if (lockfile == NULL || lockfile->vtable == NULL
+      || lockfile->vtable->lock == NULL)
     return MU_ERROR_NOT_SUPPORTED;
     return MU_ERROR_NOT_SUPPORTED;
-  return locker->vtable->lock (locker);
+  return lockfile->vtable->lock (lockfile);
 }
 }
 
 
 int
 int
-locker_touchlock (locker_t locker)
+lockfile_touchlock (lockfile_t lockfile)
 {
 {
-  if (locker == NULL || locker->vtable == NULL
-      || locker->vtable->lock == NULL)
+  if (lockfile == NULL || lockfile->vtable == NULL
+      || lockfile->vtable->lock == NULL)
     return MU_ERROR_NOT_SUPPORTED;
     return MU_ERROR_NOT_SUPPORTED;
-  return locker->vtable->lock (locker);
+  return lockfile->vtable->lock (lockfile);
 }
 }
 
 
 int
 int
-locker_unlock (locker_t locker)
+lockfile_unlock (lockfile_t lockfile)
 {
 {
-  if (locker == NULL || locker->vtable == NULL
-      || locker->vtable->lock == NULL)
+  if (lockfile == NULL || lockfile->vtable == NULL
+      || lockfile->vtable->lock == NULL)
     return MU_ERROR_NOT_SUPPORTED;
     return MU_ERROR_NOT_SUPPORTED;
-  return locker->vtable->lock (locker);
+  return lockfile->vtable->lock (lockfile);
 }
 }

@@ -29,7 +29,7 @@
 #include <fcntl.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <unistd.h>
 
 
-#include <mailutils/sys/mstream.h>
+#include <mailutils/sys/mapstream.h>
 #include <mailutils/error.h>
 #include <mailutils/error.h>
 
 
 #ifdef _POSIX_MAPPED_FILES
 #ifdef _POSIX_MAPPED_FILES
@@ -39,17 +39,17 @@
 # define MAP_FAILED (void*)-1
 # define MAP_FAILED (void*)-1
 #endif
 #endif
 
 
-static int
-_map_ref (stream_t stream)
+int
+_stream_mmap_ref (stream_t stream)
 {
 {
-  struct _ms *ms = (struct _ms *)stream;
+  struct _stream_mmap *ms = (struct _stream_mmap *)stream;
   return mu_refcount_inc (ms->refcount);
   return mu_refcount_inc (ms->refcount);
 }
 }
 
 
-static void
-_map_destroy (stream_t *pstream)
+void
+_stream_mmap_destroy (stream_t *pstream)
 {
 {
-  struct _ms *ms = (struct _ms *)*pstream;
+  struct _stream_mmap *ms = (struct _stream_mmap *)*pstream;
 
 
   if (mu_refcount_dec (ms->refcount) == 0)
   if (mu_refcount_dec (ms->refcount) == 0)
     {
     {
@@ -58,10 +58,10 @@ _map_destroy (stream_t *pstream)
     }
     }
 }
 }
 
 
-static int
-_map_read (stream_t stream, void *optr, size_t osize, size_t *nbytes)
+int
+_stream_mmap_read (stream_t stream, void *optr, size_t osize, size_t *nbytes)
 {
 {
-  struct _ms *ms = (struct _ms *)stream;
+  struct _stream_mmap *ms = (struct _stream_mmap *)stream;
   size_t n = 0;
   size_t n = 0;
 
 
   mu_refcount_lock (ms->refcount);
   mu_refcount_lock (ms->refcount);
@@ -82,10 +82,10 @@ _map_read (stream_t stream, void *optr, size_t osize, size_t *nbytes)
   return 0;
   return 0;
 }
 }
 
 
-static int
-_map_readline (stream_t stream, char *optr, size_t osize, size_t *nbytes)
+int
+_stream_mmap_readline (stream_t stream, char *optr, size_t osize, size_t *nbytes)
 {
 {
-  struct _ms *ms = (struct _ms *)stream;
+  struct _stream_mmap *ms = (struct _stream_mmap *)stream;
   size_t n = 0;
   size_t n = 0;
 
 
   mu_refcount_lock (ms->refcount);
   mu_refcount_lock (ms->refcount);
@@ -111,10 +111,10 @@ _map_readline (stream_t stream, char *optr, size_t osize, size_t *nbytes)
   return 0;
   return 0;
 }
 }
 
 
-static int
-_map_write (stream_t stream, const void *iptr, size_t isize, size_t *nbytes)
+int
+_stream_mmap_write (stream_t stream, const void *iptr, size_t isize, size_t *nbytes)
 {
 {
-  struct _ms *ms = (struct _ms *)stream;
+  struct _stream_mmap *ms = (struct _stream_mmap *)stream;
   int err = 0;
   int err = 0;
   size_t n = 0;
   size_t n = 0;
 
 
@@ -157,10 +157,10 @@ _map_write (stream_t stream, const void *iptr, size_t isize, size_t *nbytes)
   return err;
   return err;
 }
 }
 
 
-static int
-_map_truncate (stream_t stream, off_t len)
+int
+_stream_mmap_truncate (stream_t stream, off_t len)
 {
 {
-  struct _ms *ms = (struct _ms *)stream;
+  struct _stream_mmap *ms = (struct _stream_mmap *)stream;
   int err = 0;
   int err = 0;
 
 
   mu_refcount_lock (ms->refcount);
   mu_refcount_lock (ms->refcount);
@@ -188,10 +188,10 @@ _map_truncate (stream_t stream, off_t len)
   return err;
   return err;
 }
 }
 
 
-static int
-_map_get_size (stream_t stream, off_t *psize)
+int
+_stream_mmap_get_size (stream_t stream, off_t *psize)
 {
 {
-  struct _ms *ms = (struct _ms *)stream;
+  struct _stream_mmap *ms = (struct _stream_mmap *)stream;
   struct stat stbuf;
   struct stat stbuf;
   int err = 0;
   int err = 0;
 
 
@@ -232,11 +232,11 @@ _map_get_size (stream_t stream, off_t *psize)
   return err;
   return err;
 }
 }
 
 
-static int
-_map_flush (stream_t stream)
+int
+_stream_mmap_flush (stream_t stream)
 {
 {
   int err = 0;
   int err = 0;
-  struct _ms *ms = (struct _ms *)stream;
+  struct _stream_mmap *ms = (struct _stream_mmap *)stream;
   mu_refcount_lock (ms->refcount);
   mu_refcount_lock (ms->refcount);
   if (ms->ptr != MAP_FAILED && ms->ptr != NULL)
   if (ms->ptr != MAP_FAILED && ms->ptr != NULL)
     err = msync (ms->ptr, ms->size, MS_SYNC);
     err = msync (ms->ptr, ms->size, MS_SYNC);
@@ -244,27 +244,27 @@ _map_flush (stream_t stream)
   return 0;
   return 0;
 }
 }
 
 
-static int
-_map_get_fd (stream_t stream, int *pfd)
+int
+_stream_mmap_get_fd (stream_t stream, int *pfd)
 {
 {
-  struct _ms *ms = (struct _ms *)stream;
+  struct _stream_mmap *ms = (struct _stream_mmap *)stream;
   if (pfd)
   if (pfd)
     *pfd = ms->fd;
     *pfd = ms->fd;
   return 0;
   return 0;
 }
 }
 
 
-static int
-_map_get_flags (stream_t stream, int *flags)
+int
+_stream_mmap_get_flags (stream_t stream, int *flags)
 {
 {
-  struct _ms *ms = (struct _ms *)stream;
+  struct _stream_mmap *ms = (struct _stream_mmap *)stream;
   if (flags == NULL)
   if (flags == NULL)
     return MU_ERROR_INVALID_PARAMETER;
     return MU_ERROR_INVALID_PARAMETER;
   *flags = ms->flags;
   *flags = ms->flags;
   return 0;
   return 0;
 }
 }
 
 
-static int
-_map_get_state (stream_t stream, enum stream_state *state)
+int
+_stream_mmap_get_state (stream_t stream, enum stream_state *state)
 {
 {
   (void)stream;
   (void)stream;
   if (state == NULL)
   if (state == NULL)
@@ -273,10 +273,10 @@ _map_get_state (stream_t stream, enum stream_state *state)
   return 0;
   return 0;
 }
 }
 
 
-static int
-_map_seek (stream_t stream, off_t off, enum stream_whence whence)
+int
+_stream_mmap_seek (stream_t stream, off_t off, enum stream_whence whence)
 {
 {
-  struct _ms *ms = (struct _ms *)stream;
+  struct _stream_mmap *ms = (struct _stream_mmap *)stream;
   off_t noff = ms->offset;
   off_t noff = ms->offset;
   int err = 0;
   int err = 0;
   if (whence == MU_STREAM_WHENCE_SET)
   if (whence == MU_STREAM_WHENCE_SET)
@@ -290,7 +290,7 @@ _map_seek (stream_t stream, off_t off, enum stream_whence whence)
   if (noff >= 0)
   if (noff >= 0)
     {
     {
       if (noff > ms->offset)
       if (noff > ms->offset)
-	_map_truncate (stream, noff);
+	_stream_mmap_truncate (stream, noff);
       ms->offset = noff;
       ms->offset = noff;
     }
     }
   else
   else
@@ -298,20 +298,20 @@ _map_seek (stream_t stream, off_t off, enum stream_whence whence)
   return err;
   return err;
 }
 }
 
 
-static int
-_map_tell (stream_t stream, off_t *off)
+int
+_stream_mmap_tell (stream_t stream, off_t *off)
 {
 {
-  struct _ms *ms = (struct _ms *)stream;
+  struct _stream_mmap *ms = (struct _stream_mmap *)stream;
   if (off == NULL)
   if (off == NULL)
     return MU_ERROR_INVALID_PARAMETER;
     return MU_ERROR_INVALID_PARAMETER;
   *off = ms->offset;
   *off = ms->offset;
   return 0;
   return 0;
 }
 }
 
 
-static int
-_map_close (stream_t stream)
+int
+_stream_mmap_close (stream_t stream)
 {
 {
-  struct _ms *ms = (struct _ms *)stream;
+  struct _stream_mmap *ms = (struct _stream_mmap *)stream;
   int err = 0;
   int err = 0;
   mu_refcount_lock (ms->refcount);
   mu_refcount_lock (ms->refcount);
   if (ms->ptr != MAP_FAILED)
   if (ms->ptr != MAP_FAILED)
@@ -328,40 +328,39 @@ _map_close (stream_t stream)
   return err;
   return err;
 }
 }
 
 
-static int
-_map_is_open (stream_t stream)
+int
+_stream_mmap_is_open (stream_t stream)
 {
 {
-  struct _ms *ms = (struct _ms *)stream;
+  struct _stream_mmap *ms = (struct _stream_mmap *)stream;
   return (ms->ptr == MAP_FAILED) ? 0 : 1;
   return (ms->ptr == MAP_FAILED) ? 0 : 1;
 }
 }
 
 
-static int
-_map_is_readready (stream_t stream, int timeout)
+int
+_stream_mmap_is_readready (stream_t stream, int timeout)
 {
 {
   (void)timeout;
   (void)timeout;
-  return _map_is_open (stream);
+  return _stream_mmap_is_open (stream);
 }
 }
 
 
-static int
-_map_is_writeready (stream_t stream, int timeout)
+int
+_stream_mmap_is_writeready (stream_t stream, int timeout)
 {
 {
   (void)timeout;
   (void)timeout;
-  return _map_is_open (stream);
+  return _stream_mmap_is_open (stream);
 }
 }
 
 
-static int
-_map_is_exceptionpending (stream_t stream, int timeout)
+int
+_stream_mmap_is_exceptionpending (stream_t stream, int timeout)
 {
 {
   (void)stream;
   (void)stream;
   (void)timeout;
   (void)timeout;
   return 0;
   return 0;
 }
 }
 
 
-
-static int
-_map_open (stream_t stream, const char *filename, int port, int flags)
+int
+_stream_mmap_open (stream_t stream, const char *filename, int port, int flags)
 {
 {
-  struct _ms *ms = (struct _ms *)stream;
+  struct _stream_mmap *ms = (struct _stream_mmap *)stream;
   int mflag, flg;
   int mflag, flg;
   struct stat st;
   struct stat st;
 
 
@@ -400,7 +399,19 @@ _map_open (stream_t stream, const char *filename, int port, int flags)
       flg = O_RDONLY;
       flg = O_RDONLY;
     }
     }
 
 
+  /* Anonymous Mapping.  */
+  if (filename == NULL)
+    {
+#ifdef MAP_ANON
+      mflag |= MAP_ANON;
+#else
+      filename = "/dev/zero";
+      ms->fd = open (filename, flg);
+#endif
+    }
+  else
     ms->fd = open (filename, flg);
     ms->fd = open (filename, flg);
+
   if (ms->fd < 0)
   if (ms->fd < 0)
     return errno;
     return errno;
   if (fstat (ms->fd, &st) != 0)
   if (fstat (ms->fd, &st) != 0)
@@ -428,45 +439,70 @@ _map_open (stream_t stream, const char *filename, int port, int flags)
   return 0;
   return 0;
 }
 }
 
 
-static struct _stream_vtable _map_vtable =
+static struct _stream_vtable _stream_mmap_vtable =
 {
 {
-  _map_ref,
-  _map_destroy,
+  _stream_mmap_ref,
+  _stream_mmap_destroy,
 
 
-  _map_open,
-  _map_close,
+  _stream_mmap_open,
+  _stream_mmap_close,
 
 
-  _map_read,
-  _map_readline,
-  _map_write,
+  _stream_mmap_read,
+  _stream_mmap_readline,
+  _stream_mmap_write,
 
 
-  _map_seek,
-  _map_tell,
+  _stream_mmap_seek,
+  _stream_mmap_tell,
 
 
-  _map_get_size,
-  _map_truncate,
-  _map_flush,
+  _stream_mmap_get_size,
+  _stream_mmap_truncate,
+  _stream_mmap_flush,
 
 
-  _map_get_fd,
-  _map_get_flags,
-  _map_get_state,
+  _stream_mmap_get_fd,
+  _stream_mmap_get_flags,
+  _stream_mmap_get_state,
 
 
-  _map_is_readready,
-  _map_is_writeready,
-  _map_is_exceptionpending,
+  _stream_mmap_is_readready,
+  _stream_mmap_is_writeready,
+  _stream_mmap_is_exceptionpending,
 
 
-  _map_is_open
+  _stream_mmap_is_open
 };
 };
 
 
+int
+_stream_mmap_ctor (struct _stream_mmap *ms)
+{
+  mu_refcount_create (&ms->refcount);
+  if (ms->refcount == NULL)
+    return MU_ERROR_NO_MEMORY;
+  ms->fd = -1;
+  ms->offset = -1;
+  ms->flags = 0;
+  ms->mflags = 0;
+  ms->base.vtable = &_stream_mmap_vtable;
+  return 0;
+}
+
+void
+_stream_mmap_dtor (struct _stream_mmap *ms)
+{
+  mu_refcount_destroy (&ms->refcount);
+  ms->fd = -1;
+  ms->offset = -1;
+  ms->mflags = 0;
+  ms->ptr = MAP_FAILED;
+}
+
 #endif /* _POSIX_MAPPED_FILES */
 #endif /* _POSIX_MAPPED_FILES */
 
 
 int
 int
-stream_mapfile_create (stream_t *pstream)
+stream_mmap_create (stream_t *pstream)
 {
 {
 #ifndef _POSIX_MAPPED_FILES
 #ifndef _POSIX_MAPPED_FILES
   return ENOSYS;
   return ENOSYS;
 #else
 #else
-  struct _ms *ms;
+  struct _stream_mmap *ms;
+  int status;
 
 
   if (pstream == NULL)
   if (pstream == NULL)
     return MU_ERROR_INVALID_PARAMETER;
     return MU_ERROR_INVALID_PARAMETER;
@@ -475,19 +511,10 @@ stream_mapfile_create (stream_t *pstream)
   if (ms == NULL)
   if (ms == NULL)
     return MU_ERROR_NO_MEMORY;
     return MU_ERROR_NO_MEMORY;
 
 
-  mu_refcount_create (&ms->refcount);
-  if (ms->refcount == NULL)
-    {
-      free (ms);
-      return MU_ERROR_NO_MEMORY;
-    }
-  ms->fd = -1;
-  ms->offset = -1;
-  ms->flags = 0;
-  ms->mflags = 0;
-  ms->base.vtable = &_map_vtable;
+  status = _stream_mmap_ctor (ms);
+  if (status != 0)
+    return status;
   *pstream = &ms->base;
   *pstream = &ms->base;
-
   return 0;
   return 0;
 #endif /* _POSIX_MAPPED_FILES */
 #endif /* _POSIX_MAPPED_FILES */
 }
 }

@@ -21,22 +21,25 @@
 
 
 #include <errno.h>
 #include <errno.h>
 #include <stdlib.h>
 #include <stdlib.h>
+#include <stdio.h>
 #include <string.h>
 #include <string.h>
+#include <sys/stat.h>
+#include <unistd.h>
 
 
 #include <mailutils/error.h>
 #include <mailutils/error.h>
 #include <mailutils/sys/memstream.h>
 #include <mailutils/sys/memstream.h>
 
 
-static int
-_memory_ref (stream_t stream)
+int
+_stream_memory_ref (stream_t stream)
 {
 {
-  struct _memory_stream *mem = (struct _memory_stream *)stream;
+  struct _stream_memory *mem = (struct _stream_memory *)stream;
   return mu_refcount_inc (mem->refcount);
   return mu_refcount_inc (mem->refcount);
 }
 }
 
 
-static void
-_memory_destroy (stream_t *pstream)
+void
+_stream_memory_destroy (stream_t *pstream)
 {
 {
-  struct _memory_stream *mem = (struct _memory_stream *)*pstream;
+  struct _stream_memory *mem = (struct _stream_memory *)*pstream;
   if (mu_refcount_dec (mem->refcount) == 0)
   if (mu_refcount_dec (mem->refcount) == 0)
     {
     {
       mu_refcount_destroy (&mem->refcount);
       mu_refcount_destroy (&mem->refcount);
@@ -44,10 +47,10 @@ _memory_destroy (stream_t *pstream)
     }
     }
 }
 }
 
 
-static int
-_memory_read (stream_t stream, void *optr, size_t osize, size_t *nbytes)
+int
+_stream_memory_read (stream_t stream, void *optr, size_t osize, size_t *nbytes)
 {
 {
-  struct _memory_stream *mem = (struct _memory_stream *)stream;
+  struct _stream_memory *mem = (struct _stream_memory *)stream;
   size_t n = 0;
   size_t n = 0;
 
 
   mu_refcount_lock (mem->refcount);
   mu_refcount_lock (mem->refcount);
@@ -64,10 +67,10 @@ _memory_read (stream_t stream, void *optr, size_t osize, size_t *nbytes)
   return 0;
   return 0;
 }
 }
 
 
-static int
-_memory_readline (stream_t stream, char *optr, size_t osize, size_t *nbytes)
+int
+_stream_memory_readline (stream_t stream, char *optr, size_t osize, size_t *nbytes)
 {
 {
-  struct _memory_stream *mem = (struct _memory_stream *)stream;
+  struct _stream_memory *mem = (struct _stream_memory *)stream;
   char *nl;
   char *nl;
   size_t n = 0;
   size_t n = 0;
   mu_refcount_lock (mem->refcount);
   mu_refcount_lock (mem->refcount);
@@ -88,20 +91,25 @@ _memory_readline (stream_t stream, char *optr, size_t osize, size_t *nbytes)
   return 0;
   return 0;
 }
 }
 
 
-static int
-_memory_write (stream_t stream, const void *iptr, size_t isize, size_t *nbytes)
+int
+_stream_memory_write (stream_t stream, const void *iptr, size_t isize,
+		      size_t *nbytes)
 {
 {
-  struct _memory_stream *mem = (struct _memory_stream *)stream;
+  struct _stream_memory *mem = (struct _stream_memory *)stream;
 
 
   mu_refcount_lock (mem->refcount);
   mu_refcount_lock (mem->refcount);
   /* Bigger we have to realloc.  */
   /* Bigger we have to realloc.  */
-  if (mem->size < (mem->offset + isize))
+  if (mem->capacity < (mem->offset + isize))
     {
     {
-      char *tmp =  realloc (mem->ptr, mem->offset + isize);
+      /* Realloc by blocks of 512.  */
+      int newsize = MU_STREAM_MEMORY_BLOCKSIZE *
+	(((mem->offset + isize)/MU_STREAM_MEMORY_BLOCKSIZE) + 1);
+      char *tmp =  realloc (mem->ptr, newsize);
       if (tmp == NULL)
       if (tmp == NULL)
 	return ENOMEM;
 	return ENOMEM;
       mem->ptr = tmp;
       mem->ptr = tmp;
       mem->size = mem->offset + isize;
       mem->size = mem->offset + isize;
+      mem->capacity = newsize;
     }
     }
 
 
   memcpy (mem->ptr + mem->offset, iptr, isize);
   memcpy (mem->ptr + mem->offset, iptr, isize);
@@ -112,10 +120,10 @@ _memory_write (stream_t stream, const void *iptr, size_t isize, size_t *nbytes)
   return 0;
   return 0;
 }
 }
 
 
-static int
-_memory_truncate (stream_t stream, off_t len)
+int
+_stream_memory_truncate (stream_t stream, off_t len)
 {
 {
-  struct _memory_stream *mem = (struct _memory_stream *)stream;
+  struct _stream_memory *mem = (struct _stream_memory *)stream;
 
 
   mu_refcount_lock (mem->refcount);
   mu_refcount_lock (mem->refcount);
   if (len == 0)
   if (len == 0)
@@ -130,16 +138,17 @@ _memory_truncate (stream_t stream, off_t len)
 	return ENOMEM;
 	return ENOMEM;
       mem->ptr = tmp;
       mem->ptr = tmp;
     }
     }
+  mem->capacity = len;
   mem->size = len;
   mem->size = len;
   mem->offset = len;
   mem->offset = len;
   mu_refcount_unlock (mem->refcount);
   mu_refcount_unlock (mem->refcount);
   return 0;
   return 0;
 }
 }
 
 
-static int
-_memory_get_size (stream_t stream, off_t *psize)
+int
+_stream_memory_get_size (stream_t stream, off_t *psize)
 {
 {
-  struct _memory_stream *mem = (struct _memory_stream *)stream;
+  struct _stream_memory *mem = (struct _stream_memory *)stream;
   mu_refcount_lock (mem->refcount);
   mu_refcount_lock (mem->refcount);
   if (psize)
   if (psize)
     *psize = mem->size;
     *psize = mem->size;
@@ -147,46 +156,47 @@ _memory_get_size (stream_t stream, off_t *psize)
   return 0;
   return 0;
 }
 }
 
 
-static int
-_memory_close (stream_t stream)
+int
+_stream_memory_close (stream_t stream)
 {
 {
-  struct _memory_stream *mem = (struct _memory_stream *)stream;
+  struct _stream_memory *mem = (struct _stream_memory *)stream;
   mu_refcount_lock (mem->refcount);
   mu_refcount_lock (mem->refcount);
   if (mem->ptr)
   if (mem->ptr)
     free (mem->ptr);
     free (mem->ptr);
   mem->ptr = NULL;
   mem->ptr = NULL;
+  mem->capacity = 0;
   mem->size = 0;
   mem->size = 0;
   mem->offset = 0;
   mem->offset = 0;
   mu_refcount_unlock (mem->refcount);
   mu_refcount_unlock (mem->refcount);
   return 0;
   return 0;
 }
 }
 
 
-static int
-_memory_flush (stream_t stream)
+int
+_stream_memory_flush (stream_t stream)
 {
 {
   (void)stream;
   (void)stream;
   return 0;
   return 0;
 }
 }
 
 
-static int
-_memory_get_fd (stream_t stream, int *pfd)
+int
+_stream_memory_get_fd (stream_t stream, int *pfd)
 {
 {
   (void)stream; (void)pfd;
   (void)stream; (void)pfd;
   return MU_ERROR_NOT_SUPPORTED;
   return MU_ERROR_NOT_SUPPORTED;
 }
 }
 
 
-static int
-_memory_get_flags (stream_t stream, int *flags)
+int
+_stream_memory_get_flags (stream_t stream, int *flags)
 {
 {
-  struct _memory_stream *mem = (struct _memory_stream *)stream;
+  struct _stream_memory *mem = (struct _stream_memory *)stream;
   if (flags == NULL)
   if (flags == NULL)
     return MU_ERROR_INVALID_PARAMETER;
     return MU_ERROR_INVALID_PARAMETER;
   *flags = mem->flags;
   *flags = mem->flags;
   return 0;
   return 0;
 }
 }
 
 
-static int
-_memory_get_state (stream_t stream, enum stream_state *state)
+int
+_stream_memory_get_state (stream_t stream, enum stream_state *state)
 {
 {
   (void)stream;
   (void)stream;
   if (state == NULL)
   if (state == NULL)
@@ -195,10 +205,10 @@ _memory_get_state (stream_t stream, enum stream_state *state)
   return 0;
   return 0;
 }
 }
 
 
-static int
-_memory_seek (stream_t stream, off_t off, enum stream_whence whence)
+int
+_stream_memory_seek (stream_t stream, off_t off, enum stream_whence whence)
 {
 {
-  struct _memory_stream *mem = (struct _memory_stream *)stream;
+  struct _stream_memory *mem = (struct _stream_memory *)stream;
   off_t noff = mem->offset;
   off_t noff = mem->offset;
   int err = 0;
   int err = 0;
   if (whence == MU_STREAM_WHENCE_SET)
   if (whence == MU_STREAM_WHENCE_SET)
@@ -212,7 +222,7 @@ _memory_seek (stream_t stream, off_t off, enum stream_whence whence)
   if (noff >= 0)
   if (noff >= 0)
     {
     {
       if (noff > mem->offset)
       if (noff > mem->offset)
-        _memory_truncate (stream, noff);
+        _stream_memory_truncate (stream, noff);
       mem->offset = noff;
       mem->offset = noff;
     }
     }
   else
   else
@@ -220,41 +230,41 @@ _memory_seek (stream_t stream, off_t off, enum stream_whence whence)
   return err;
   return err;
 }
 }
 
 
-static int
-_memory_tell (stream_t stream, off_t *off)
+int
+_stream_memory_tell (stream_t stream, off_t *off)
 {
 {
-  struct _memory_stream *mem = (struct _memory_stream *)stream;
+  struct _stream_memory *mem = (struct _stream_memory *)stream;
   if (off == NULL)
   if (off == NULL)
     return MU_ERROR_INVALID_PARAMETER;
     return MU_ERROR_INVALID_PARAMETER;
   *off = mem->offset;
   *off = mem->offset;
   return 0;
   return 0;
 }
 }
 
 
-static int
-_memory_is_open (stream_t stream)
+int
+_stream_memory_is_open (stream_t stream)
 {
 {
   (void)stream;
   (void)stream;
   return 1;
   return 1;
 }
 }
 
 
-static int
-_memory_is_readready (stream_t stream, int timeout)
+int
+_stream_memory_is_readready (stream_t stream, int timeout)
 {
 {
   (void)stream;
   (void)stream;
   (void)timeout;
   (void)timeout;
   return 1;
   return 1;
 }
 }
 
 
-static int
-_memory_is_writeready (stream_t stream, int timeout)
+int
+_stream_memory_is_writeready (stream_t stream, int timeout)
 {
 {
   (void)stream;
   (void)stream;
   (void)timeout;
   (void)timeout;
   return 1;
   return 1;
 }
 }
 
 
-static int
-_memory_is_exceptionpending (stream_t stream, int timeout)
+int
+_stream_memory_is_exceptionpending (stream_t stream, int timeout)
 {
 {
   (void)stream;
   (void)stream;
   (void)timeout;
   (void)timeout;
@@ -262,61 +272,134 @@ _memory_is_exceptionpending (stream_t stream, int timeout)
 }
 }
 
 
 
 
-static int
-_memory_open (stream_t stream, const char *filename, int port, int flags)
+int
+_stream_memory_open (stream_t stream, const char *filename, int port,
+		     int flags)
 {
 {
-  struct _memory_stream *mem = (struct _memory_stream *)stream;
+  struct _stream_memory *mem = (struct _stream_memory *)stream;
+  int status = 0;
 
 
   (void)port; /* Ignored.  */
   (void)port; /* Ignored.  */
-  (void)filename; /* Ignored.  */
-  (void)flags; /* Ignored.  */
 
 
   mu_refcount_lock (mem->refcount);
   mu_refcount_lock (mem->refcount);
-  /* Close any previous file.  */
+  /* Free any previous memory.  */
   if (mem->ptr)
   if (mem->ptr)
     free (mem->ptr);
     free (mem->ptr);
   mem->ptr = NULL;
   mem->ptr = NULL;
+  mem->capacity = 0;
   mem->size = 0;
   mem->size = 0;
   mem->offset = 0;
   mem->offset = 0;
   mem->flags = flags;
   mem->flags = flags;
+  if (filename)
+    {
+      struct stat statbuf;
+      if (stat (filename, &statbuf) == 0)
+	{
+	  mem->ptr = calloc (1, statbuf.st_size);
+	  if (mem->ptr)
+	    {
+	      FILE *fp;
+	      mem->capacity = statbuf.st_size;
+	      mem->size = statbuf.st_size;
+	      fp = fopen (filename, "r");
+	      if (fp)
+		{
+		  size_t r = fread (mem->ptr, mem->size, 1, fp);
+		  if (r != mem->size)
+		    status = MU_ERROR_IO;
+		  fclose (fp);
+		}
+	      else
+		status = errno;
+	      if (status != 0)
+		{
+		  free (mem->ptr);
+		  mem->ptr = NULL;
+		  mem->capacity = 0;
+		  mem->size = 0;
+		}
+	    }
+	  else
+	    status = MU_ERROR_NO_MEMORY;
+	}
+      else
+	status = MU_ERROR_IO;
+    }
   mu_refcount_unlock (mem->refcount);
   mu_refcount_unlock (mem->refcount);
-  return 0;
+  return status;
 }
 }
 
 
-static struct _stream_vtable _mem_vtable =
+static struct _stream_vtable _stream_memory_vtable =
 {
 {
-  _memory_ref,
-  _memory_destroy,
+  _stream_memory_ref,
+  _stream_memory_destroy,
 
 
-  _memory_open,
-  _memory_close,
+  _stream_memory_open,
+  _stream_memory_close,
 
 
-  _memory_read,
-  _memory_readline,
-  _memory_write,
+  _stream_memory_read,
+  _stream_memory_readline,
+  _stream_memory_write,
 
 
-  _memory_seek,
-  _memory_tell,
+  _stream_memory_seek,
+  _stream_memory_tell,
 
 
-  _memory_get_size,
-  _memory_truncate,
-  _memory_flush,
+  _stream_memory_get_size,
+  _stream_memory_truncate,
+  _stream_memory_flush,
 
 
-  _memory_get_fd,
-  _memory_get_flags,
-  _memory_get_state,
+  _stream_memory_get_fd,
+  _stream_memory_get_flags,
+  _stream_memory_get_state,
 
 
-  _memory_is_readready,
-  _memory_is_writeready,
-  _memory_is_exceptionpending,
+  _stream_memory_is_readready,
+  _stream_memory_is_writeready,
+  _stream_memory_is_exceptionpending,
 
 
-  _memory_is_open
+  _stream_memory_is_open
 };
 };
 
 
 int
 int
-stream_memory_create (stream_t *pstream)
+_stream_memory_ctor (struct _stream_memory *mem, size_t capacity)
+{
+  mu_refcount_create (&mem->refcount);
+  if (mem->refcount == NULL)
+    return MU_ERROR_NO_MEMORY;
+  if (capacity)
+    {
+      mem->ptr = calloc (1, capacity);
+      if (mem->ptr == NULL)
+	{
+	  mu_refcount_destroy (&mem->refcount);
+	  return MU_ERROR_NO_MEMORY;
+	}
+      mem->capacity = capacity;
+    }
+  else
+    mem->capacity = 0;
+  mem->size = 0;
+  mem->offset = 0;
+  mem->flags = 0;
+  mem->base.vtable = &_stream_memory_vtable;
+  return 0;
+}
+
+void
+_stream_memory_dtor (struct _stream_memory *mem)
+{
+  mu_refcount_destroy (&mem->refcount);
+  mem->ptr = NULL;
+  mem->capacity = 0;
+  mem->size = 0;
+  mem->offset = 0;
+  mem->flags = 0;
+}
+
+int
+stream_memory_create (stream_t *pstream, size_t capacity)
 {
 {
-  struct _memory_stream *mem;
+  struct _stream_memory *mem;
+  int status;
 
 
   if (pstream == NULL)
   if (pstream == NULL)
     return MU_ERROR_INVALID_PARAMETER;
     return MU_ERROR_INVALID_PARAMETER;
@@ -325,17 +408,13 @@ stream_memory_create (stream_t *pstream)
   if (mem == NULL)
   if (mem == NULL)
     return MU_ERROR_NO_MEMORY;
     return MU_ERROR_NO_MEMORY;
 
 
-  mu_refcount_create (&mem->refcount);
-  if (mem->refcount == NULL)
+  status = _stream_memory_ctor (mem, capacity);
+  if (status != 0)
     {
     {
       free (mem);
       free (mem);
-      return MU_ERROR_NO_MEMORY;
+      return status;
     }
     }
-  mem->ptr = NULL;
-  mem->size = 0;
-  mem->offset = 0;
-  mem->flags = 0;
-  mem->base.vtable = &_mem_vtable;
+  mem->base.vtable = &_stream_memory_vtable;
   *pstream = &mem->base;
   *pstream = &mem->base;
   return 0;
   return 0;
 }
 }

@@ -27,14 +27,7 @@
 
 
 #include <mailutils/error.h>
 #include <mailutils/error.h>
 #include <mailutils/refcount.h>
 #include <mailutils/refcount.h>
-#include <mailutils/sys/ticket.h>
-
-struct _prompt_ticket
-{
-  struct _ticket base;
-  int ref;
-  mu_refcount_t refcount;
-};
+#include <mailutils/sys/pticket.h>
 
 
 static void
 static void
 echo_off(struct termios *stored_settings)
 echo_off(struct termios *stored_settings)
@@ -52,17 +45,17 @@ echo_on(struct termios *stored_settings)
   tcsetattr (0, TCSANOW, stored_settings);
   tcsetattr (0, TCSANOW, stored_settings);
 }
 }
 
 
-static int
-_prompt_ref (ticket_t ticket)
+int
+_ticket_prompt_ref (ticket_t ticket)
 {
 {
-  struct _prompt_ticket *prompt = (struct _prompt_ticket *)ticket;
+  struct _ticket_prompt *prompt = (struct _ticket_prompt *)ticket;
   return mu_refcount_inc (prompt->refcount);
   return mu_refcount_inc (prompt->refcount);
 }
 }
 
 
-static void
-_prompt_destroy (ticket_t *pticket)
+void
+_ticket_prompt_destroy (ticket_t *pticket)
 {
 {
-  struct _prompt_ticket *prompt = (struct _prompt_ticket *)*pticket;
+  struct _ticket_prompt *prompt = (struct _ticket_prompt *)*pticket;
   if (mu_refcount_dec (prompt->refcount) == 0)
   if (mu_refcount_dec (prompt->refcount) == 0)
     {
     {
       mu_refcount_destroy (&prompt->refcount);
       mu_refcount_destroy (&prompt->refcount);
@@ -70,8 +63,8 @@ _prompt_destroy (ticket_t *pticket)
     }
     }
 }
 }
 
 
-static int
-_prompt_pop (ticket_t ticket, const char *challenge, char **parg)
+int
+_ticket_prompt_pop (ticket_t ticket, const char *challenge, char **parg)
 {
 {
   char arg[256];
   char arg[256];
   struct termios stored_settings;
   struct termios stored_settings;
@@ -98,18 +91,35 @@ _prompt_pop (ticket_t ticket, const char *challenge, char **parg)
   return 0;
   return 0;
 }
 }
 
 
-static struct _ticket_vtable _prompt_vtable =
+static struct _ticket_vtable _ticket_prompt_vtable =
 {
 {
-  _prompt_ref,
-  _prompt_destroy,
+  _ticket_prompt_ref,
+  _ticket_prompt_destroy,
 
 
-  _prompt_pop,
+  _ticket_prompt_pop,
 };
 };
 
 
 int
 int
+_ticket_prompt_ctor (struct _ticket_prompt *prompt)
+{
+  mu_refcount_create (&prompt->refcount);
+  if (prompt->refcount == NULL)
+    return MU_ERROR_NO_MEMORY;
+  prompt->base.vtable = &_ticket_prompt_vtable;
+  return 0;
+}
+
+void
+_ticket_prompt_dtor (struct _ticket_prompt *prompt)
+{
+  mu_refcount_destroy (&prompt->refcount);
+}
+
+int
 ticket_prompt_create (ticket_t *pticket)
 ticket_prompt_create (ticket_t *pticket)
 {
 {
-  struct _prompt_ticket *prompt;
+  struct _ticket_prompt *prompt;
+  int status;
 
 
   if (pticket == NULL)
   if (pticket == NULL)
     return MU_ERROR_INVALID_PARAMETER;
     return MU_ERROR_INVALID_PARAMETER;
@@ -118,14 +128,12 @@ ticket_prompt_create (ticket_t *pticket)
   if (prompt == NULL)
   if (prompt == NULL)
     return MU_ERROR_NO_MEMORY;
     return MU_ERROR_NO_MEMORY;
 
 
-  mu_refcount_create (&prompt->refcount);
-  if (prompt->refcount == NULL)
+  status = _ticket_prompt_ctor (prompt);
+  if (status != 0)
     {
     {
       free (prompt);
       free (prompt);
-      return MU_ERROR_NO_MEMORY;
+      return status;
     }
     }
   *pticket = &prompt->base;
   *pticket = &prompt->base;
-  prompt->base.vtable = &_prompt_vtable;
   return 0;
   return 0;
 }
 }
-

@@ -27,19 +27,19 @@
 #include <mailutils/sys/sdebug.h>
 #include <mailutils/sys/sdebug.h>
 #include <mailutils/error.h>
 #include <mailutils/error.h>
 
 
-static int
-_sdebug_ref (mu_debug_t debug)
+int
+_mu_debug_stream_ref (mu_debug_t debug)
 {
 {
-  struct _sdebug *sdebug = (struct _sdebug *)debug;
+  struct _mu_debug_stream *sdebug = (struct _mu_debug_stream *)debug;
   return mu_refcount_inc (sdebug->refcount);
   return mu_refcount_inc (sdebug->refcount);
 }
 }
 
 
-static void
-_sdebug_destroy (mu_debug_t *pdebug)
+void
+_mu_debug_stream_destroy (mu_debug_t *pdebug)
 {
 {
   if (pdebug && *pdebug)
   if (pdebug && *pdebug)
     {
     {
-      struct _sdebug *sdebug = (struct _sdebug *)*pdebug;
+      struct _mu_debug_stream *sdebug = (struct _mu_debug_stream *)*pdebug;
       if (mu_refcount_dec (sdebug->refcount) == 0)
       if (mu_refcount_dec (sdebug->refcount) == 0)
 	{
 	{
 	  if (sdebug->stream)
 	  if (sdebug->stream)
@@ -55,27 +55,27 @@ _sdebug_destroy (mu_debug_t *pdebug)
     }
     }
 }
 }
 
 
-static int
-_sdebug_set_level (mu_debug_t debug, size_t level)
+int
+_mu_debug_stream_set_level (mu_debug_t debug, size_t level)
 {
 {
-  struct _sdebug *sdebug = (struct _sdebug *)debug;
+  struct _mu_debug_stream *sdebug = (struct _mu_debug_stream *)debug;
   sdebug->level = level;
   sdebug->level = level;
   return 0;
   return 0;
 }
 }
 
 
-static int
-_sdebug_get_level (mu_debug_t debug, size_t *plevel)
+int
+_mu_debug_stream_get_level (mu_debug_t debug, size_t *plevel)
 {
 {
-  struct _sdebug *sdebug = (struct _sdebug *)debug;
+  struct _mu_debug_stream *sdebug = (struct _mu_debug_stream *)debug;
   if (plevel)
   if (plevel)
     *plevel = sdebug->level;
     *plevel = sdebug->level;
   return 0;
   return 0;
 }
 }
 
 
-static int
-_sdebug_print (mu_debug_t debug, size_t level, const char *mesg)
+int
+_mu_debug_stream_print (mu_debug_t debug, size_t level, const char *mesg)
 {
 {
-  struct _sdebug *sdebug = (struct _sdebug *)debug;
+  struct _mu_debug_stream *sdebug = (struct _mu_debug_stream *)debug;
 
 
   if (mesg == NULL)
   if (mesg == NULL)
     return MU_ERROR_INVALID_PARAMETER;
     return MU_ERROR_INVALID_PARAMETER;
@@ -86,21 +86,21 @@ _sdebug_print (mu_debug_t debug, size_t level, const char *mesg)
   return stream_write (sdebug->stream, mesg, strlen (mesg), NULL);
   return stream_write (sdebug->stream, mesg, strlen (mesg), NULL);
 }
 }
 
 
-struct _mu_debug_vtable _sdebug_vtable =
+static struct _mu_debug_vtable _mu_debug_stream_vtable =
 {
 {
-  _sdebug_ref,
-  _sdebug_destroy,
+  _mu_debug_stream_ref,
+  _mu_debug_stream_destroy,
 
 
-  _sdebug_get_level,
-  _sdebug_set_level,
-  _sdebug_print
+  _mu_debug_stream_get_level,
+  _mu_debug_stream_set_level,
+  _mu_debug_stream_print
 };
 };
 
 
 int
 int
 mu_debug_stream_create (mu_debug_t *pdebug, stream_t stream,
 mu_debug_stream_create (mu_debug_t *pdebug, stream_t stream,
 			int close_on_destroy)
 			int close_on_destroy)
 {
 {
-  struct _sdebug *sdebug;
+  struct _mu_debug_stream *sdebug;
 
 
   if (pdebug == NULL || stream == NULL)
   if (pdebug == NULL || stream == NULL)
     return MU_ERROR_INVALID_PARAMETER;
     return MU_ERROR_INVALID_PARAMETER;
@@ -119,7 +119,7 @@ mu_debug_stream_create (mu_debug_t *pdebug, stream_t stream,
   sdebug->level = 0;
   sdebug->level = 0;
   sdebug->stream = stream;
   sdebug->stream = stream;
   sdebug->close_on_destroy = close_on_destroy;
   sdebug->close_on_destroy = close_on_destroy;
-  sdebug->base.vtable = &_sdebug_vtable;
+  sdebug->base.vtable = &_mu_debug_stream_vtable;
   *pdebug = &sdebug->base;
   *pdebug = &sdebug->base;
   return 0;
   return 0;
 }
 }