body.c mailer.c mbx_unixscan.c net.c tcp.c transcode.c

 	include/private/attribute0.h include/private/body0.h
 	include/private/mailer0.h include/private/net0.h
 	include/private/tcp.h include/public/body.h
 	include/public/mailer.h include/public/net.h

parsing and little of networking code, making a path for Pop and IMAP.

+/* GNU mailutils - a suite of utilities for electronic mail
+   Copyright (C) 1999, 2000 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.  */
+
+
+#include <body0.h>
+#include <io0.h>
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+static int body_read (stream_t is, char *buf, size_t buflen,
+			 off_t off, size_t *pnread );
+static int body_write (stream_t os, const char *buf, size_t buflen,
+			  off_t off, size_t *pnwrite);
+static FILE *lazy_create (void);
+static int body_get_fd (stream_t stream, int *pfd);
+
+int
+body_create (body_t *pbody, void *owner)
+{
+  body_t body;
+
+  if (pbody == NULL || owner == NULL)
+    return EINVAL;
+
+  body = calloc (1, sizeof (*body));
+  if (body == NULL)
+    return ENOMEM;
+
+  body->owner = owner;
+  *pbody = body;
+  return 0;
+}
+
+void
+body_destroy (body_t *pbody, void *owner)
+{
+  if (pbody && *pbody)
+    {
+      body_t body = *pbody;
+      if (body->owner == owner)
+	{
+	  if (body->file)
+	    {
+	      fclose (body->file);
+	      body->file = NULL;
+	    }
+	  free (body->filename); body->filename = NULL;
+	  stream_destroy (&(body->stream), body);
+	}
+      *pbody = NULL;
+    }
+}
+
+int
+body_get_stream (body_t body, stream_t *pstream)
+{
+  if (body == NULL || pstream == NULL)
+    return EINVAL;
+
+  if (body->stream == NULL)
+    {
+      stream_t stream;
+      int status;
+      /* lazy floating body it is created when
+       * doing the first body_write call
+       */
+      status = stream_create (&stream, body);
+      if (status != 0)
+	return status;
+      stream_set_read (stream, body_read, body);
+      stream_set_write (stream, body_write, body);
+      stream_set_fd (stream, body_get_fd, body);
+      body->stream = stream;
+    }
+
+  *pstream = body->stream;
+  return 0;
+}
+
+int
+body_set_stream (body_t body, stream_t stream, void *owner)
+{
+  if (body == NULL)
+   return EINVAL;
+  if (body->owner != owner)
+    return EACCES;
+  /* make sure we destroy the old one if it is own by the body */
+  stream_destroy (&(body->stream), body);
+  if (body->file)
+    {
+      fclose (body->file);
+      body->file = NULL;
+    }
+  body->stream = stream;
+  return 0;
+}
+
+int
+body_set_lines (body_t body, int (*_lines)(body_t, size_t *), void *owner)
+{
+  if (body == NULL)
+    return EINVAL;
+  if (body->owner == owner)
+    return EACCES;
+  body->_lines = _lines;
+  return 0;
+}
+
+int
+body_lines (body_t body, size_t *plines)
+{
+  if (body == NULL)
+    return EINVAL;
+  if (body->_lines)
+    return body->_lines (body, plines);
+  if (plines)
+    *plines = 0;
+  return 0;
+}
+
+int
+body_size (body_t body, size_t *psize)
+{
+  if (body == NULL)
+    return EINVAL;
+
+  /* Check to see if they want to doit themselves,
+   * it was probably not a floating message */
+  if (body->_size)
+    return body->_size (body, psize);
+
+  /* ok we should handle this */
+  if (body->file)
+    {
+      struct stat st;
+      if (fstat (fileno (body->file), &st) == -1)
+	return errno;
+      if (psize)
+	*psize = st.st_size;
+    }
+  else if (body->filename)
+    {
+      struct stat st;
+      if (stat (body->filename, &st) == -1)
+	return errno;
+      if (psize)
+	*psize = st.st_size;
+    }
+  else if (psize)
+    *psize = 0;
+
+  return 0;
+}
+
+int
+body_set_size (body_t body, int (*_size)(body_t, size_t*) , void *owner)
+{
+  if (body == NULL)
+    return EINVAL;
+  if (body->owner != owner)
+    return EACCES;
+  body->_size = _size;
+  return 0;
+}
+
+static int
+body_read (stream_t is, char *buf, size_t buflen,
+	      off_t off, size_t *pnread )
+{
+  body_t body;
+  size_t nread = 0;
+
+  if (is == NULL || (body = is->owner) == NULL)
+    return EINVAL;
+
+  /* check if they want to read from a file */
+  if (body->file == NULL && body->filename)
+    {
+      /* try read only, we don't want to
+       * handle nasty security issues here.
+       */
+      body->file = fopen (body->filename, "r");
+      if (body->file == NULL)
+	{
+	  if (pnread)
+	    *pnread = 0;
+	  return errno;
+	}
+    }
+
+  if (body->file)
+    {
+      /* should we check the error of fseek for some handlers
+       * like socket where fseek () will fail.
+       * FIXME: Alternative is to check fseeck and errno == EBADF
+       * if not a seekable stream.
+       */
+      if (fseek (body->file, off, SEEK_SET) == -1)
+	return errno;
+
+      nread = fread (buf, sizeof (char), buflen, body->file);
+      if (nread == 0)
+	{
+	  if (ferror (body->file))
+	    return errno;
+	  /* clear the error for feof() */
+	  clearerr (body->file);
+	}
+    }
+
+  if (pnread)
+    *pnread = nread;
+  return 0;
+}
+
+static int
+body_write (stream_t os, const char *buf, size_t buflen,
+	       off_t off, size_t *pnwrite)
+{
+  body_t body;
+  size_t nwrite = 0;
+
+  if (os == NULL || (body = os->owner) == NULL)
+    return EINVAL;
+
+  /* FIXME: security issues, Refuse to write to an unknow file */
+  if (body->file == NULL && body->filename)
+    return EINVAL;
+
+  /* Probably being lazy, then create a body for the stream */
+  if (body->file == NULL)
+    {
+      body->file = lazy_create ();
+      if (body->file == NULL)
+	return errno;
+    }
+
+  /* should we check the error of fseek for some handlers
+   * like socket where it does not make sense.
+   * FIXME: Alternative is to check fseeck and errno == EBADF
+   * if not a seekable stream.
+   */
+  if (fseek (body->file, off, SEEK_SET) == -1)
+    return errno;
+
+  nwrite = fwrite (buf, sizeof (char), buflen, body->file);
+  if (nwrite == 0)
+    {
+      if (ferror (body->file))
+	return errno;
+      /* clear the error for feof() */
+      clearerr (body->file);
+    }
+
+  if (pnwrite)
+    *pnwrite = nwrite;
+  return 0;
+}
+
+static int
+body_get_fd (stream_t stream, int *pfd)
+{
+  body_t body;
+
+  if (stream == NULL || (body = stream->owner) == NULL)
+    return EINVAL;
+
+  /* Probably being lazy, then create a body for the stream */
+  if (body->file == NULL)
+    {
+      body->file = lazy_create ();
+      if (body->file == 0)
+        return errno;
+    }
+
+  if (pfd)
+    *pfd = fileno (body->file);
+  return 0;
+}
+
+static FILE *
+lazy_create ()
+{
+  FILE *file;
+#ifdef HAVE_MKSTEMP
+  char tmpbuf[L_tmpnam + 1];
+  int fd;
+
+  if (tmpnam (tmpbuf) == NULL ||
+      (fd = mkstemp (tmpbuf)) == -1 ||
+      (file = fdopen(fd, "w+")) == NULL)
+    return NULL;
+  (void)remove(tmpbuf);
+#else
+  file = tmpfile ();
+  /* make sure the mode is right */
+  if (file)
+    fchmod (fileno (file), 0600);
+#endif
+  return file;
+}

+/* GNU mailutils - a suite of utilities for electronic mail
+   Copyright (C) 1999, 2000 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 _ATTRIBUTE0_H
+# define _ATTRIBUTE0_H
+
+#include <attribute.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef __P
+# ifdef __STDC__
+#  define __P(args) args
+# else
+#  define __P(args) ()
+# endif
+#endif /*__P */
+
+struct _attribute
+{
+  size_t flag;
+  void *owner;
+};
+
+#define MU_ATTRIBUTE_SEEN ((int)1)
+#define MU_ATTRIBUTE_ANSWERED (MU_ATTRIBUTE_SEEN << 1)
+#define MU_ATTRIBUTE_FLAGGED  (MU_ATTRIBUTE_ANSWERED << 1)
+#define MU_ATTRIBUTE_DELETED  (MU_ATTRIBUTE_FLAGGED << 1)
+#define MU_ATTRIBUTE_DRAFT    (MU_ATTRIBUTE_DELETED << 1)
+#define MU_ATTRIBUTE_RECENT   (MU_ATTRIBUTE_DRAFT << 1)
+#define MU_ATTRIBUTE_READ     (MU_ATTRIBUTE_RECENT << 1)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _ATTRIBUTE0_H */

+/* GNU mailutils - a suite of utilities for electronic mail
+   Copyright (C) 1999, 2000 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 _BODY0_H
+#define _BODY0_H
+
+#include <io.h>
+#include <body.h>
+
+#include <stdio.h>
+#include <sys/types.h>
+
+#ifndef __P
+# ifdef __STDC__
+#  define __P(args) args
+# else
+#  define __P(args) ()
+# endif
+#endif /* __P */
+
+#ifdef _cplusplus
+extern "C" {
+#endif
+
+struct _body
+{
+  void *owner;
+
+  /* it's better and more portable to use stdio */
+  FILE *file;
+  char *filename;
+  stream_t stream;
+  int (*_size)  (body_t, size_t*);
+  int (*_lines) (body_t, size_t*);
+};
+
+#ifdef _cplusplus
+}
+#endif
+
+#endif /* _BODY0_H */

+/* GNU mailutils - a suite of utilities for electronic mail
+   Copyright (C) 1999, 2000 Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU Library General 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 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 _MAILER0_H
+#define _MAILER0_H
+
+#include <sys/types.h>
+#include <mailer.h>
+
+#ifdef _cplusplus
+extern "C" {
+#endif
+
+#ifndef __P
+# ifdef __STDC__
+#  define __P(args) args
+# else
+#  define __P(args) ()
+# endif
+#endif /*__P */
+
+// mailer states
+#define MAILER_STATE_HDR		1
+#define MAILER_STATE_MSG		2
+#define MAILER_STATE_COMPLETE	3
+
+// mailer messages
+#define MAILER_HELO	1
+#define MAILER_MAIL	2
+#define MAILER_RCPT	3
+#define MAILER_DATA	4
+#define MAILER_RSET	5
+#define MAILER_QUIT	6
+
+#define MAILER_LINE_BUF_SIZE	1000
+
+struct _mailer
+{
+	int			socket;
+	char 		*hostname;
+	char 		line_buf[MAILER_LINE_BUF_SIZE];
+	int			offset;
+	int			state;
+	int			add_dot;
+	stream_t	stream;
+	char		last_char;
+};
+
+#ifdef _cplusplus
+}
+#endif
+
+#endif /* MAILER0_H */

+/* GNU mailutils - a suite of utilities for electronic mail
+   Copyright (C) 1999, 2000 Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU Library General 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 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 _NET0_H
+#define _NET0_H
+
+#include <sys/types.h>
+
+#include <io.h>
+#include <net.h>
+
+#ifdef _cplusplus
+extern "C" {
+#endif
+
+#ifndef __P
+#ifdef __STDC__
+#define __P(args) args
+#else
+#define __P(args) ()
+#endif
+#endif /*__P */
+
+
+struct _net_api {
+	int (*new)(void *netdata, net_t parent, void **data);
+	int (*connect)(void *data, const char *host, int port);
+	int (*get_stream)(void *data, stream_t *iostr);
+	int (*close)(void *data);
+	int (*free)(void **data);
+};
+
+struct _netregistrar {
+	const char 	*type;
+
+	int (*create)(void **netdata, struct _net_api **api);
+	int (*set_option)(void *netdata, const char *name, const char *value);
+	int (*destroy)(void **netdata);
+};
+
+struct _net {
+	struct _net_api		*api;
+	void				*data;
+	struct _net			*parent;
+
+	struct _netregistrar *net_reg;
+};
+
+struct _netinstance {
+	struct _net_api	*api;
+	void			*data;
+};
+
+int _tcp_create(void **data, struct _net_api **api);
+int _tcp_set_option(void *data, const char *name, const char *value);
+int _tcp_destroy(void **data);
+
+#ifdef _cplusplus
+}
+#endif
+
+#endif /* NET0_H */

+/* GNU mailutils - a suite of utilities for electronic mail
+   Copyright (C) 1999, 2000 Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU Library General 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 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.  */
+
+#include <net0.h>
+
+#define TCP_STATE_INIT 			1
+#define TCP_STATE_RESOLVE		2
+#define TCP_STATE_RESOLVING		3
+#define TCP_STATE_CONNECTING 	4
+#define TCP_STATE_CONNECTED		5
+
+struct _tcp_options {
+	int 		non_block;
+	int 		net_timeout;
+};
+
+struct _tcp_instance {
+	struct _tcp_options	*options;
+	int 		fd;
+	char 		*host;
+	int 		port;
+	int			state;
+	stream_t	stream;
+	unsigned long	address;
+};

+/* GNU mailutils - a suite of utilities for electronic mail
+   Copyright (C) 1999, 2000 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 _BODY_H
+#define _BODY_H
+
+#include <sys/types.h>
+#include <io.h>
+
+#ifndef __P
+# ifdef __STDC__
+#  define __P(args) args
+# else
+#  define __P(args) ()
+# endif
+#endif /* __P */
+
+#ifdef _cplusplus
+extern "C" {
+#endif
+
+/* forward declaration */
+struct _body;
+typedef struct _body *body_t;
+
+extern int body_create       __P ((body_t *, void *owner));
+extern void body_destroy     __P ((body_t *, void *owner));
+
+extern int body_get_stream   __P ((body_t, stream_t *));
+extern int body_set_stream   __P ((body_t, stream_t, void *owner));
+
+extern int body_get_filename __P ((body_t, char *, size_t, size_t *));
+extern int body_set_filename __P ((body_t, const char*));
+
+extern int body_size     __P ((body_t, size_t*));
+extern int body_set_size     __P ((body_t,
+				   int (*_size) __P ((body_t, size_t*)),
+				   void *owner));
+extern int body_lines   __P ((body_t, size_t *));
+extern int body_set_lines     __P ((body_t,
+				    int (*_lines) __P ((body_t, size_t*)),
+				    void *owner));
+
+#ifdef _cplusplus
+}
+#endif
+
+#endif /* _BODY_H */

+/* GNU mailutils - a suite of utilities for electronic mail
+   Copyright (C) 1999, 2000 Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU Library General 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 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 _MAILER_H
+#define _MAILER_H
+
+#include "message.h"
+#include <sys/types.h>
+
+#ifndef __P
+# ifdef __STDC__
+#  define __P(args) args
+# else
+#  define __P(args) ()
+# endif
+#endif /* __P */
+
+#ifdef _cplusplus
+extern "C" {
+#endif
+
+/* forward declaration */
+struct _mailer;
+typedef struct _mailer *mailer_t;
+
+extern int mailer_create			__P ((mailer_t *, message_t));
+extern int mailer_connect		__P ((mailer_t, char *host));
+extern int mailer_disconnect	__P ((mailer_t));
+extern int mailer_send_header	__P ((mailer_t, message_t));
+extern int mailer_send_message	__P ((mailer_t, message_t));
+
+#ifdef _cplusplus
+}
+#endif
+
+#endif /* _MAILER_H */

+/* GNU mailutils - a suite of utilities for electronic mail
+   Copyright (C) 1999, 2000 Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU Library General 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 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 _NET_H
+#define _NET_H
+
+#include <sys/types.h>
+
+#include <io.h>
+
+#ifdef _cplusplus
+extern "C" {
+#endif
+
+#ifndef __P
+#ifdef __STDC__
+#define __P(args) args
+#else
+#define __P(args) ()
+#endif
+#endif /*__P */
+
+struct _net;
+typedef struct _net *net_t;
+
+extern int net_api_create 		__P((net_t *, net_t, const char *type));
+extern int net_api_set_option	__P((net_t net, const char *name, const char *value));
+extern int net_api_destroy		__P((net_t *));
+
+struct _netinstance;
+typedef struct _netinstance *netinstance_t;
+
+extern int net_new				__P((net_t, netinstance_t *));
+extern int net_connect			__P((netinstance_t, const char *host, int port));
+extern int net_get_stream		__P((netinstance_t, stream_t *iostr));
+extern int net_close			__P((netinstance_t));
+extern int net_free				__P((netinstance_t *));
+
+#ifdef _cplusplus
+}
+#endif
+
+#endif /* NET_H */

+/* GNU mailutils - a suite of utilities for electronic mail
+   Copyright (C) 1999, 2000 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.  */
+
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netdb.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/select.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <fcntl.h>
+#include <ctype.h>
+
+#include <mailer0.h>
+
+int 	_mailer_sock_connect(char *host, int port);
+char	*_mailer_find_mailbox(char *addr);
+int 	_mailer_send_command(mailer_t ml, message_t msg, int cmd);
+char 	*nb_fgets(char *buf, int size, int s);
+char 	*nb_fprintf(int s, char *format, ...);
+
+#define nb_read		read
+#define nb_write 	write
+#define BUFFSIZE 	4096
+
+int
+mailer_create(mailer_t *pml, message_t msg)
+{
+	mailer_t ml;
+
+	(void)msg;
+	if (!pml)
+	  return EINVAL;
+
+	ml = calloc (1, sizeof (*ml));
+	if (ml == NULL)
+		return (ENOMEM);
+
+	*pml = ml;
+
+	return (0);
+}
+
+int
+mailer_destroy(mailer_t *pml)
+{
+	mailer_t ml;
+
+	if (!pml)
+		return (EINVAL);
+	ml = *pml;
+	if (ml->hostname)
+		free(ml->hostname);
+	mailer_disconnect(ml);
+	free(ml);
+	*pml = NULL;
+
+	return (0);
+}
+
+int 
+mailer_connect(mailer_t ml, char *host) 
+{
+	if (!ml || !host)
+		return (EINVAL);
+
+	if ((ml->socket = _mailer_sock_connect(host, 25)) < 0)
+		return (-1);
+	do 	
+	{
+		nb_fgets(ml->line_buf, MAILER_LINE_BUF_SIZE, ml->socket); /* read header line */
+	} while ( strlen(ml->line_buf) > 4 && *(ml->line_buf+3) == '-');
+
+	return (0);
+}
+
+int 
+mailer_disconnect(mailer_t ml) 
+{
+	if (!ml || (ml->socket != -1))
+		return (EINVAL);
+
+	close(ml->socket);
+	return (0);
+}
+
+int 
+mailer_send_header(mailer_t ml, message_t msg)
+{
+	header_t 	hdr;
+	char		buf[64];
+
+	if (!ml || !msg || (ml->socket == -1))
+		return (EINVAL);
+
+	if (!ml->hostname)
+	{
+	    if (gethostname(buf, 64) < 0)
+	    	return (-1);
+	    ml->hostname = strdup(buf);
+	}
+
+	if (_mailer_send_command(ml, msg, MAILER_HELO) != 0)
+		return (-1);
+	if (_mailer_send_command(ml, msg, MAILER_MAIL) != 0)
+		return (-1);
+	if (_mailer_send_command(ml, msg, MAILER_RCPT) != 0)
+		return (-1);
+	if (_mailer_send_command(ml, msg, MAILER_DATA) != 0)
+		return (-1);
+
+	message_get_header(msg, &hdr);
+	header_get_stream(hdr, &(ml->stream));
+
+	ml->state = MAILER_STATE_HDR;
+
+	return (0);
+}
+
+int
+mailer_send_message(mailer_t ml, message_t msg)
+{
+	int 	status, len = 0, data_len = 0, consumed = 0;
+	char 	*data, *p, *q;
+
+	if (!ml || !msg || (ml->socket == -1))
+		return (EINVAL);
+
+	// alloca
+	if (!(data = alloca(MAILER_LINE_BUF_SIZE)))
+		return (ENOMEM);
+
+	memset(data, 0, 1000);
+	if ((status = stream_read(ml->stream, data, MAILER_LINE_BUF_SIZE, ml->offset, &len)) != 0)
+		return (-1);
+
+	if ((len == 0) && (ml->state == MAILER_STATE_HDR))
+	{
+		ml->state = MAILER_STATE_MSG;
+		ml->offset = 0;
+		message_get_stream(msg, &(ml->stream));
+		return (1);
+	}
+	else if (len == 0)
+	{
+		strcpy(ml->line_buf, "\r\n.\r\n");
+		consumed = strlen(data);
+	}
+	else
+	{
+		p = data;
+		q = ml->line_buf;
+		memset(ml->line_buf, 0, MAILER_LINE_BUF_SIZE);
+		while (consumed < len)
+		{
+			// RFC821: if the first character on a line is a '.' you must add an
+			//         extra '.' to the line which will get stipped off at the other end
+			if ((*p == '.') && (ml->last_char == '\n'))
+				ml->add_dot = 1;
+			ml->last_char = *p;
+			*q++ = *p++; 	// store the character
+			data_len++;		// increase the length by 1
+			consumed++;
+			if (((MAILER_LINE_BUF_SIZE - data_len) > 1) && (ml->add_dot == 1))
+			{
+				*q++ = '.';
+				data_len++;
+				ml->add_dot = 0;
+			}
+		}
+	}
+
+	ml->offset += consumed;
+	nb_fprintf(ml->socket, "%s\r\n", ml->line_buf);
+
+	if (len == 0)
+	{
+		ml->state = MAILER_STATE_COMPLETE;
+		return (0);
+	}
+
+	return (consumed);
+}
+
+int
+_mailer_sock_connect(char *host, int port)
+{
+	struct sockaddr_in saddr;
+	struct hostent *hp;
+	int s;
+
+	memset(&saddr, 0, sizeof(struct sockaddr_in));
+	saddr.sin_family = AF_INET;
+	saddr.sin_port = htons(port);
+	if ((s = socket(AF_INET, SOCK_STREAM, 0)) == -1)
+			return (-1);
+	if ((hp = gethostbyname(host)) == 0)
+			return (-1);
+	memcpy(&saddr.sin_addr, hp->h_addr, hp->h_length);
+	if (connect(s, (struct sockaddr *)&saddr, sizeof(saddr)) == 0)
+			return (s);
+	close(s);
+
+	return (-1);
+}
+
+char *
+_mailer_find_mailbox(char *addr)
+{
+    char *p, *c;
+    p = addr;
+    if ( (c = strchr( p, '<')) != 0) 
+    {
+        p = c+1;
+        if ( c = strchr( p, '>'))
+            *c = '\0';
+    }
+    else if ( (c = strchr( p, '(' )) != 0 ) 
+    {
+        --c;
+        while ( c > p && *c && isspace( *c ) ) {
+            *c = '\0';
+            --c;
+        }
+    }
+    return p;
+}
+
+int
+_mailer_rctp(mailer_t ml, char *str)
+{
+	char 		*p, *c = NULL, *q = NULL;
+
+	for (q = p = str; q && *p; p = q+1)
+	{
+		if ( q = strchr( p, ','))
+			*q = '\0';
+		while ( p && *p && isspace( *p ) )
+			p++;
+		c = strdup(p);
+		p = _mailer_find_mailbox(c);
+		nb_fprintf(ml->socket, "RCPT TO:<%s>\r\n", p);
+		free(c);
+		nb_fgets(ml->line_buf, sizeof(ml->line_buf), ml->socket);
+		if (strncmp(ml->line_buf, "250", 3))
+			return (-strtol(ml->line_buf, 0, 10));
+	}
+	return (0);
+}
+
+int
+_mailer_send_command(mailer_t ml, message_t msg, int cmd)
+{
+	header_t	hdr;
+	char 		*p, *c = NULL, *q = NULL;
+	char		str[128];
+	size_t		str_len;
+	char		*success = "250";
+
+	switch (cmd)
+	{
+		case MAILER_HELO:
+			nb_fprintf(ml->socket, "HELO %s\r\n", ml->hostname);
+			break;
+		case MAILER_MAIL:
+			message_get_header(msg, &hdr);
+			header_get_value(hdr, MU_HEADER_FROM, str, 128, &str_len);
+			str[str_len] = '\0';
+			p = _mailer_find_mailbox(str);
+			nb_fprintf(ml->socket, "MAIL From: %s\r\n", p);
+			break;
+		case MAILER_RCPT:
+			message_get_header(msg, &hdr);
+			header_get_value(hdr, MU_HEADER_TO, str, 128, &str_len);
+			str[str_len] = '\0';
+			if (_mailer_rctp(ml, str) == -1)
+				return (-1);
+			header_get_value(hdr, MU_HEADER_CC, str, 128, &str_len);
+			str[str_len] = '\0';
+			if (_mailer_rctp(ml, str) == -1)
+				return (-1);
+			return (0);
+			break;
+		case MAILER_DATA:
+			nb_fprintf(ml->socket, "DATA\r\n");
+			success = "354";
+			break;
+		case MAILER_RSET:
+			nb_fprintf(ml->socket, "RSET\r\n");
+			break;
+		case MAILER_QUIT:
+			nb_fprintf(ml->socket, "QUIT\r\n");
+			success = "221";
+			break;
+	}
+
+	nb_fgets(ml->line_buf, sizeof(ml->line_buf), ml->socket);
+	if (strncmp(ml->line_buf, success, 3) == 0)
+		return (0);
+	else
+		return (-strtol(ml->line_buf, 0, 10));
+}
+
+char *
+nb_fgets( char *buf, int size, int s ) 
+{
+	static char *buffer[25];
+	char *p, *b, *d;
+	int bytes, i;
+	int flags;
+
+	if ( !buffer[s] && !( buffer[s] = calloc( BUFFSIZE+1, 1 ) ) )
+		return 0;
+	bytes = i = strlen( p = b = buffer[s] );
+	*( d = buf ) = '\0';
+	for ( ; i-- > 0; p++ ) 
+		{
+		if ( *p == '\n' ) 
+			{
+			char c = *( p+1 );
+
+			*( p+1 ) = '\0';
+			strcat( d, b );
+			*( p+1 ) = c;
+			memmove( b, p+1, i+1 );
+			return buf;
+			}
+		}
+	flags = fcntl( s, F_GETFL );
+	fcntl( s, F_SETFL, O_NONBLOCK );
+	while ( bytes <= size ) 
+		{
+		fd_set fds;
+
+		FD_ZERO( &fds );
+		FD_SET( s, &fds );
+		select( s+1, &fds, 0, 0, 0 ); /* we really don't care what it returns */
+		if ( ( i = nb_read( s, p, BUFFSIZE - bytes ) ) == -1 ) 
+			{
+			*b = '\0';
+			return 0;
+			} 
+		else if ( i == 0 ) 
+			{
+			*( p+1 ) = '\0';
+			strcat( d, b );
+			*b = '\0';
+			fcntl( s, F_SETFL, flags );
+			return strlen( buf ) ? buf : 0;
+			}
+		*( p+i ) = '\0';
+		bytes += i;
+		for ( ; i-- > 0; p++ ) 
+			{
+			if ( *p == '\n' ) 
+				{
+				char c = *( p+1 );
+
+				*( p+1 ) = '\0';
+				strcat( d, b );
+				*( p+1 ) = c;
+				memmove( b, p+1, i+1 );
+				fcntl( s, F_SETFL, flags );
+				return buf;
+				}
+			}
+		if ( bytes == BUFFSIZE ) 
+			{
+			memcpy( d, b, BUFFSIZE );
+			d += BUFFSIZE;
+			size -= BUFFSIZE;
+			bytes = 0;
+			*( p = b ) = '\0';
+			}
+		}
+	memcpy( d, b, size );
+	memmove( b, b+size, strlen( b+size )+1 );
+	fcntl( s, F_SETFL, flags );
+	return buf;
+}
+
+char *
+nb_fprintf( int s, char *format, ... ) 
+{
+	char buf[MAILER_LINE_BUF_SIZE];
+	va_list vl;
+	int i;
+
+	va_start( vl, format );
+	vsprintf( buf, format, vl );
+	va_end( vl );
+	i = strlen( buf );
+	if ( nb_write( s, buf, i ) != i )
+		return 0;
+	return format;
+}

+/* GNU mailutils - a suite of utilities for electronic mail
+   Copyright (C) 1999, 2000 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.  */
+
+/* Credits to the c-client and its Authors
+ * The notorius c-client VALID() macro, was written by Mark Crispin.
+ */
+
+/* Parsing.
+ * The approach is to detect the "From " as start of a
+ * new message, give the position of the header and scan
+ * until "\n" then set header_end, set body position, if we have
+ * a Content-Length field jump to the point if not
+ * scan until we it another "From " and set body_end.
+ *
+ ************************************
+ * This is a classic case of premature optimisation
+ * being the root of all Evil(Donald E. Knuth).
+ * But I'm under "pressure" ;-) to come with
+ * something "faster".  I think it's wastefull
+ * to spend time to gain a few seconds on 30Megs mailboxes
+ * ... but then again ... in computer time, 60 seconds, is eternity.
+ *
+ * If they use the event notification stuff
+ * to get some headers/messages early ... it's like pissing
+ * in the wind(sorry don't have the english equivalent).
+ * The worst is progress_bar it should be ... &*($^ nuke.
+ * For the events, we have to remove the *.LCK file,
+ * release the locks, flush the stream save the pointers
+ * etc ... hurry and wait...
+ * I this point I'm pretty much ranting.
+ *
+ */
+
+/* From the C-Client, part of pine */
+/* You are not expected to understand this macro, but read the next page if
+ * you are not faint of heart.
+ *
+ * Known formats to the VALID macro are:
+ *              From user Wed Dec  2 05:53 1992
+ * BSD          From user Wed Dec  2 05:53:22 1992
+ * SysV         From user Wed Dec  2 05:53 PST 1992
+ * rn           From user Wed Dec  2 05:53:22 PST 1992
+ *              From user Wed Dec  2 05:53 -0700 1992
+ *              From user Wed Dec  2 05:53:22 -0700 1992
+ *              From user Wed Dec  2 05:53 1992 PST
+ *              From user Wed Dec  2 05:53:22 1992 PST
+ *              From user Wed Dec  2 05:53 1992 -0700
+ * Solaris      From user Wed Dec  2 05:53:22 1992 -0700
+ *
+ * Plus all of the above with `` remote from xxx'' after it. Thank you very
+ * much, smail and Solaris, for making my life considerably more complicated.
+ */
+/*
+ * What?  You want to understand the VALID macro anyway?  Alright, since you
+ * insist.  Actually, it isn't really all that difficult, provided that you
+ * take it step by step.
+ *
+ * Line 1       Initializes the return ti value to failure (0);
+ * Lines 2-3    Validates that the 1st-5th characters are ``From ''.
+ * Lines 4-6    Validates that there is an end of line and points x at it.
+ * Lines 7-14   First checks to see if the line is at least 41 characters long
+.
+ *              If so, it scans backwards to find the rightmost space.  From
+ *              that point, it scans backwards to see if the string matches
+ *              `` remote from''.  If so, it sets x to point to the space at
+ *              the start of the string.
+ * Line 15      Makes sure that there are at least 27 characters in the line.
+ * Lines 16-21  Checks if the date/time ends with the year (there is a space
+ *              five characters back).  If there is a colon three characters
+ *              further back, there is no timezone field, so zn is set to 0
+ *              and ti is set in front of the year.  Otherwise, there must
+ *              either to be a space four characters back for a three-letter
+ *              timezone, or a space six characters back followed by a + or -
+ *              for a numeric timezone; in either case, zn and ti become the
+ *              offset of the space immediately before it.
+ * Lines 22-24  Are the failure case for line 14.  If there is a space four
+ *              characters back, it is a three-letter timezone; there must be
+a
+ *              space for the year nine characters back.  zn is the zone
+ *              offset; ti is the offset of the space.
+ * Lines 25-28  Are the failure case for line 20.  If there is a space six
+ *              characters back, it is a numeric timezone; there must be a
+ *              space eleven characters back and a + or - five characters back
+.
+ *              zn is the zone offset; ti is the offset of the space.
+ * Line 29-32   If ti is valid, make sure that the string before ti is of the
+ *              form www mmm dd hh:mm or www mmm dd hh:mm:ss, otherwise
+ *              invalidate ti.  There must be a colon three characters back
+ *              and a space six or nine characters back (depending upon
+ *              whether or not the character six characters back is a colon).
+ *              There must be a space three characters further back (in front
+ *              of the day), one seven characters back (in front of the month)
+,
+ *              and one eleven characters back (in front of the day of week).
+ *              ti is set to be the offset of the space before the time.
+ *
+ * Why a macro?  It gets invoked a *lot* in a tight loop.  On some of the
+ * newer pipelined machines it is faster being open-coded than it would be if
+ * subroutines are called.
+ *
+ * Why does it scan backwards from the end of the line, instead of doing the
+ * much easier forward scan?  There is no deterministic way to parse the
+ * ``user'' field, because it may contain unquoted spaces!  Yes, I tested it t
+o
+ * see if unquoted spaces were possible.  They are, and I've encountered enoug
+h
+ * evil mail to be totally unwilling to trust that ``it will never happen''.
+ */
+#define VALID(s,x,ti,zn) {                      \
+  ti = 0;                               \
+  if ((*s == 'F') && (s[1] == 'r') && (s[2] == 'o') && (s[3] == 'm') && \
+      (s[4] == ' ')) {                          \
+    for (x = s + 5; *x && *x != '\n'; x++);             \
+    if (x) {                                \
+      if (x - s >= 41) {                        \
+    for (zn = -1; x[zn] != ' '; zn--);              \
+    if ((x[zn-1] == 'm') && (x[zn-2] == 'o') && (x[zn-3] == 'r') && \
+        (x[zn-4] == 'f') && (x[zn-5] == ' ') && (x[zn-6] == 'e') && \
+        (x[zn-7] == 't') && (x[zn-8] == 'o') && (x[zn-9] == 'm') && \
+        (x[zn-10] == 'e') && (x[zn-11] == 'r') && (x[zn-12] == ' '))\
+      x += zn - 12;                         \
+      }                                 \
+      if (x - s >= 27) {                        \
+    if (x[-5] == ' ') {                     \
+      if (x[-8] == ':') zn = 0,ti = -5;             \
+      else if (x[-9] == ' ') ti = zn = -9;              \
+      else if ((x[-11] == ' ') && ((x[-10]=='+') || (x[-10]=='-'))) \
+        ti = zn = -11;                      \
+    }                               \
+    else if (x[-4] == ' ') {                    \
+      if (x[-9] == ' ') zn = -4,ti = -9;                \
+    }                               \
+    else if (x[-6] == ' ') {                    \
+      if ((x[-11] == ' ') && ((x[-5] == '+') || (x[-5] == '-')))    \
+        zn = -6,ti = -11;                       \
+    }                               \
+    if (ti && !((x[ti - 3] == ':') &&               \
+            (x[ti -= ((x[ti - 6] == ':') ? 9 : 6)] == ' ') &&   \
+            (x[ti - 3] == ' ') && (x[ti - 7] == ' ') &&     \
+            (x[ti - 11] == ' '))) ti = 0;           \
+      }                                 \
+    }                                   \
+  }                                 \
+}
+
+#define STRLEN(s, i) \
+do \
+{ \
+  char *tmp = (s);\
+  while (*tmp) tmp++; \
+  i = tmp - s; \
+} while (0)
+
+#define ATTRIBUTE_SET(s,buf,mum,c0,c1,type) \
+do \
+{ \
+  for (s = buf + 7; *s; s++) \
+  { \
+    if (*s == c0 || *s == c1) \
+      { \
+        mum->old_attr->flag |= type; \
+        break; \
+      } \
+  } \
+} while (0)
+
+#define ISSTATUS(buf) (\
+(buf[0] == 'S' || buf[0] == 's') && \
+(buf[1] == 'T' || buf[1] == 't') && \
+(buf[2] == 'A' || buf[2] == 'a') && \
+(buf[3] == 'T' || buf[3] == 't') && \
+(buf[4] == 'U' || buf[4] == 'u') && \
+(buf[5] == 'S' || buf[5] == 's') && (buf[6] == ':'))
+
+/* notification */
+#define MAILBOX_NOTIFICATION(mbx, which) \
+do \
+{ \
+  size_t i; \
+  event_t event; \
+  for (i = 0; i < mbx->event_num; i++) \
+    { \
+      event = &(mbx->event[i]); \
+      if ((event->_action) &&  (event->type & which)) \
+        status |= event->_action (which, event->arg); \
+    } \
+} while (0)
+
+/* notifications ADD_MESG */
+#define DISPATCH_ADD_MSG() \
+do \
+{ \
+  mailbox_unix_iunlock (mbox); \
+  MAILBOX_NOTIFICATION (mbox, MU_EVT_MBX_MSG_ADD); \
+  if (status != 0) \
+    { \
+      if (pcount) \
+        *pcount = mud->messages_count; \
+      fclose (file); \
+      mailbox_unix_unlock (mbox); \
+      return EINTR; \
+    } \
+  mailbox_unix_ilock (mbox, MU_LOCKER_WRLOCK); \
+} while (0);
+
+/* notification MBX_PROGRESS
+ * We do not want to fire up the progress notification
+ * every line, it will be too expensive, so we do it
+ * arbitrarely every 10 000 Lines.
+ * FIXME: maybe this should be configurable.
+ */
+/*
+ * This is more tricky we can not leave the mum
+ * struct incomplete.  If they want to bailout
+ * they probably did not care about the last message
+ * we should free it;
+ */
+#define DISPATCH_PROGRESS() \
+do \
+{ \
+    { \
+      mailbox_unix_iunlock (mbox); \
+      MAILBOX_NOTIFICATION (mbox, MU_EVT_MBX_PROGRESS); \
+      if (status != 0) \
+	{ \
+	  if (mum) \
+	    { \
+	      attribute_destroy (&(mum->old_attr), mbox); \
+	      attribute_destroy (&(mum->new_attr), mbox); \
+	      message_destroy (&(mum->message), mbox); \
+	      free (mum); \
+	      mud->umessages[mud->messages_count - 1] = NULL; \
+	      mud->messages_count--; \
+	    } \
+	  if (pcount) \
+	    *pcount = mud->messages_count; \
+          fclose (file); \
+          mailbox_unix_unlock (mbox); \
+	  return EINTR; \
+	} \
+      mailbox_unix_ilock (mbox, MU_LOCKER_WRLOCK); \
+    } \
+} while (0)
+
+/* skip a function call, ?? do we gain that much */
+#define ATTRIBUTE_CREATE(attr,own) \
+do \
+{ \
+  attr = calloc (1, sizeof(*(attr))); \
+  if ((attr) == NULL) \
+    { \
+      fclose (file); \
+      mailbox_unix_iunlock (mbox); \
+      mailbox_unix_unlock (mbox); \
+      return ENOMEM; \
+    } \
+  (attr)->owner = own; \
+} while (0)
+
+/* allocate slots for the new messages */
+#define ALLOCATE_MSGS() \
+do \
+{ \
+  if (mud->messages_count >= mud->umessages_count) \
+  { \
+    mailbox_unix_message_t *m; \
+    size_t i; \
+    size_t num = 2 * (mud->messages_count) + 10; \
+    m = realloc (mud->umessages, num * sizeof (*m)); \
+    if (m == NULL) \
+      { \
+        fclose (file); \
+        mailbox_unix_iunlock (mbox); \
+        mailbox_unix_unlock (mbox); \
+        return ENOMEM; \
+      } \
+    mud->umessages = m; \
+    for (i = mud->umessages_count; i < num; i++) \
+      { \
+        mud->umessages[i] = calloc (1, sizeof (*mum)); \
+        if (mud->umessages[i] == NULL) \
+          { \
+            fclose (file); \
+            mailbox_unix_iunlock (mbox); \
+            mailbox_unix_unlock (mbox); \
+            return ENOMEM; \
+          } \
+        ATTRIBUTE_CREATE ((mud->umessages[i])->old_attr, mbox); \
+        ATTRIBUTE_CREATE ((mud->umessages[i])->new_attr, mbox); \
+      } \
+    mud->umessages_count = num - 1; \
+    mum = mud->umessages[mud->messages_count - 1]; \
+  } \
+  else \
+    mum = mud->umessages[mud->messages_count - 1]; \
+  mum->file = mud->file; \
+} while (0)
+
+//fprintf (stderr, "%d %d %d\n", mud->umessages_count, mud->messages_count, (int)mum);
+static int
+mailbox_unix_scan (mailbox_t mbox, size_t msgno, size_t *pcount)
+{
+#define MSGLINELEN 1024
+  char buf[MSGLINELEN];
+  int inheader;
+  int inbody;
+  off_t total;
+  mailbox_unix_data_t mud;
+  mailbox_unix_message_t mum = NULL;
+  int status = 0;
+  size_t lines;
+  int newline;
+  FILE *file;
+
+  int zn, isfrom = 0;
+  char *temp;
+
+  /* sanity */
+  if (mbox == NULL ||
+      (mud = (mailbox_unix_data_t)mbox->data) == NULL)
+    return EINVAL;
+
+  /* the simplest way to deal with reentrancy issues is to
+   * duplicate the FILE * pointer instead of the orignal.
+   *
+   * QnX4(and earlier ?) has a BUFSIZ of about 512 ???
+   * we use setvbuf () to reset to something sane.
+   * Really something smaller would be counter productive.
+   */
+  {
+    int fd = dup (fileno (mud->file));
+    if (fd == -1)
+      return errno;
+    file = fdopen (fd, "r");
+    if (file == NULL)
+      return errno;
+#if BUFSIZ <= 1024
+    {
+      char *iobuffer;
+      iobuffer = malloc (8192);
+      if (iobuffer != NULL)
+	if (setvbuf (file, iobuffer, _IOFBF, 8192) != 0)
+	  free (iobuffer);
+    }
+#endif
+  }
+
+  /* grab the locks */
+  mailbox_unix_ilock (mbox, MU_LOCKER_WRLOCK);
+  mailbox_unix_lock (mbox, MU_LOCKER_RDLOCK);
+
+  /* save the timestamp and size */
+  {
+    struct stat st;
+    if (fstat (fileno (file), &st) != 0)
+      {
+	status = errno;
+	fclose (file);
+	mailbox_unix_iunlock (mbox);
+	mailbox_unix_unlock (mbox);
+	return status;
+      }
+    mud->mtime = st.st_mtime;
+    mud->size = st.st_size;
+  }
+
+  /* seek to the starting point */
+  if (mud->umessages)
+    {
+      if (mud->messages_count > 0 &&
+	  msgno != 0 &&
+	  msgno <= mud->messages_count)
+	{
+	  mum = mud->umessages[msgno - 1];
+	  if (mum)
+	    fseek (file, mum->body_end, SEEK_SET);
+	  mud->messages_count = msgno;
+	}
+    }
+
+  rewind (file);
+  newline = 1;
+  errno = total = lines = inheader = inbody = 0;
+
+  while (fgets (buf, sizeof (buf), file))
+    {
+      int over, nl;
+      STRLEN (buf, over);
+      total += over;
+
+      nl = (*buf == '\n') ? 1 : 0;
+      VALID(buf, temp, isfrom, zn);
+      isfrom = (isfrom) ? 1 : 0;
+
+      /* which part of the message are we in ? */
+      inheader = isfrom | ((!nl) & inheader);
+      inbody = (!isfrom) & (!inheader);
+
+      lines++;
+
+      if (inheader)
+	{
+	  /* new message */
+	  if (isfrom)
+	    {
+	      /* signal the end of the body */
+	      if (mum && !mum->body_end)
+		{
+		  mum->body_end = total - over - newline;
+		  mum->body_lines = --lines - newline;
+		  DISPATCH_ADD_MSG();
+		}
+	      mud->messages_count++;
+	      /* allocate_msgs will initialize mum */
+	      ALLOCATE_MSGS();
+              mum->header_from = total - over;
+              mum->header_from_end = total;
+	      lines = 0;
+	    }
+	  else if ((over > 7) && ISSTATUS(buf))
+	    {
+	      char *s;
+	      mum->header_status = total - over;
+	      mum->header_status_end = total;
+	      ATTRIBUTE_SET(s, buf, mum, 'r', 'R', MU_ATTRIBUTE_READ);
+	      ATTRIBUTE_SET(s, buf, mum, 'o', 'O', MU_ATTRIBUTE_SEEN);
+	      ATTRIBUTE_SET(s, buf, mum, 'a', 'A', MU_ATTRIBUTE_ANSWERED);
+	      ATTRIBUTE_SET(s, buf, mum, 'd', 'D', MU_ATTRIBUTE_DELETED);
+	      mum->new_attr->flag = mum->old_attr->flag;
+	    }
+	}
+
+      /* body */
+      if (inbody)
+	{
+	  /* set the body position */
+	  if (!mum->body)
+	    {
+	      mum->body = total - over + nl;
+	      mum->header_lines = lines;
+	      lines = 0;
+	    }
+	}
+
+      newline = nl;
+      /* every 50 mesgs update the lock, it should be every minute */
+      if ((mud->messages_count % 50) == 0)
+	mailbox_unix_touchlock (mbox);
+
+      if (((lines +1) % 10000) == 0)
+	DISPATCH_PROGRESS();
+
+    } /* while */
+
+  status = errno;
+
+  /* not an error if we reach EOF */
+  if (feof (file))
+    status = 0;
+  clearerr (file);
+
+  if (mum)
+    {
+      //mailbox_notification (mbox, MU_EVT_MBX_MSG_ADD);
+      mum->body_end = total - newline;
+      mum->header_lines = lines - newline;
+    }
+  fclose (file);
+  mailbox_unix_iunlock (mbox);
+  mailbox_unix_unlock (mbox);
+  if (pcount)
+    *pcount = mud->messages_count;
+  return status;
+}
+

+/* GNU mailutils - a suite of utilities for electronic mail
+   Copyright (C) 1999, 2000 Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU Library General 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 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.  */
+
+
+#include <stdlib.h>
+#include <errno.h>
+
+#include <net0.h>
+
+static struct _netregistrar _netreg[1] = { "tcp", _tcp_create, _tcp_set_option, _tcp_destroy };
+
+int net_api_create(net_t *net, net_t parent, const char *type)
+{
+	net_t n;
+	int i, napis, ret = 0;
+	
+	if ( net == NULL || type == NULL ) 
+		return EINVAL;
+
+	*net = NULL;		
+
+	if ( ( n = calloc(1, sizeof(*n)) ) == NULL )
+		return ENOMEM;
+	napis = sizeof(_netreg) / sizeof(_netreg[0]); 
+	for( i = 0; i < napis; i++ ) {
+		if ( strcasecmp(_netreg[i].type, type) == 0 )
+			break;
+	}
+	if ( i == napis )
+		return ENOTSUP;
+	if ( ret = ( _netreg[i].create(&(n->data), &(n->api)) ) != 0 )
+		free(n);
+	n->parent = parent;
+	n->net_reg = &_netreg[i];
+	*net = n;
+	return 0;
+}
+
+int net_api_set_option(net_t net, const char *name, const char *value)
+{
+	if ( net && name && value ) 
+		return net->net_reg->set_option(net->data, name, value);
+	return EINVAL;	
+}
+
+int net_api_destroy(net_t *net)
+{
+	net_t n;
+	if ( net == NULL || *net == NULL ) 
+		return EINVAL;
+
+	n = *net;			
+	n->net_reg->destroy(&n->data);	
+	free(n);
+	*net = NULL;		
+	return 0;	
+}
+
+int net_new(net_t net, netinstance_t *inst)
+{
+	netinstance_t netinst;
+	int ret = 0;
+	
+	if ( net == NULL || inst == NULL )
+		return EINVAL;
+	
+	*inst = NULL;
+		
+	if ( ( netinst = calloc(1, sizeof(*netinst)) ) == NULL ) 
+		return ENOMEM;
+	netinst->api = net->api;
+	if ( ( ret = net->api->new(net->data, net->parent, &(netinst->data)) ) != 0 ) {
+		free(netinst);
+		return ret;
+	}
+	*inst = netinst;
+	return 0;
+}
+
+int net_connect(netinstance_t inst, const char *host, int port)
+{
+	if ( inst == NULL || host == NULL )
+		return EINVAL;
+	
+	return inst->api->connect(inst->data, host, port);
+}
+
+int net_get_stream(netinstance_t inst, stream_t *iostr)
+{
+	if ( inst == NULL || iostr == NULL )
+		return EINVAL;
+	
+	return inst->api->get_stream(inst->data, iostr);
+}
+
+int net_close(netinstance_t inst)
+{
+	if ( inst == NULL )
+		return EINVAL;
+	
+	return inst->api->close(inst->data);
+}
+
+int net_free(netinstance_t *pinst)
+{
+	int ret;
+	netinstance_t inst;
+	
+	if ( pinst == NULL || *pinst == NULL )
+		return EINVAL;
+	
+	inst = *pinst;
+	ret = inst->api->free(&(inst->data));
+	free(inst);
+	*pinst = NULL;
+	return ret;
+}

+/* GNU mailutils - a suite of utilities for electronic mail
+   Copyright (C) 1999, 2000 Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU Library General 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 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.  */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+#include <netdb.h>
+#include <fcntl.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+#include <net0.h>
+#include <io0.h>
+#include <tcp.h>
+
+static int _tcp_close(void *data);
+
+static int _tcp_doconnect(struct _tcp_instance *tcp)
+{
+	int 					flgs, ret;
+	size_t					namelen;
+	struct sockaddr_in 		peer_addr;
+	struct hostent 			*phe;
+	struct sockaddr_in      soc_addr;
+	
+	switch( tcp->state ) {
+		case TCP_STATE_INIT:
+			if ( tcp->fd == -1 ) {
+				if ( ( tcp->fd = socket(AF_INET, SOCK_STREAM, 0)) == -1 )
+					return errno;
+			}
+			if ( tcp->options->non_block ) {
+				flgs = fcntl(tcp->fd, F_GETFL);
+				flgs |= O_NONBLOCK;
+				fcntl(tcp->fd, F_SETFL, flgs);
+			}
+			tcp->state = TCP_STATE_RESOLVING;
+		case TCP_STATE_RESOLVING:
+			if ( tcp->host == NULL || tcp->port == -1 ) 
+				return EINVAL;
+			tcp->address = inet_addr(tcp->host);
+			if (tcp->address == INADDR_NONE) {
+				phe = gethostbyname(tcp->host);
+				if ( !phe ) {
+					_tcp_close(tcp);
+					return EINVAL;
+				}
+				tcp->address = *(((unsigned long **)phe->h_addr_list)[0]);
+			}
+			tcp->state = TCP_STATE_RESOLVE;
+		case TCP_STATE_RESOLVE:
+			memset (&soc_addr, 0, sizeof (soc_addr));
+			soc_addr.sin_family = AF_INET;
+			soc_addr.sin_port = htons(tcp->port);  
+			soc_addr.sin_addr.s_addr = tcp->address;
+	
+			if ( ( connect(tcp->fd, (struct sockaddr *) &soc_addr, sizeof(soc_addr)) ) == -1 ) {
+				ret = errno;
+				if ( ret == EINPROGRESS || ret == EAGAIN ) {
+					tcp->state = TCP_STATE_CONNECTING;
+					ret = EAGAIN;
+				} else
+					_tcp_close(tcp);
+				return ret;
+			}
+			tcp->state = TCP_STATE_CONNECTING;
+		case TCP_STATE_CONNECTING:
+			namelen = sizeof (peer_addr);
+			if ( getpeername (tcp->fd, (struct sockaddr *)&peer_addr, &namelen) == 0 )
+				tcp->state = TCP_STATE_CONNECTED;
+			else {
+				ret = errno;
+				_tcp_close(tcp);
+				return ret;
+			}
+			break;
+	}
+	return 0;
+}
+
+static int _tcp_get_fd(stream_t stream, int *fd)
+{
+	struct _tcp_instance *tcp = stream->owner;
+
+	if ( fd == NULL )
+		return EINVAL;
+		
+	if ( tcp->fd == -1 ) {
+		if ( ( tcp->fd = socket(AF_INET, SOCK_STREAM, 0)) == -1 )
+			return errno;
+	}
+	*fd = tcp->fd;
+	return 0;	
+}
+
+static int _tcp_read(stream_t stream, char *buf, size_t buf_size, off_t offset, size_t *br)
+{
+	struct _tcp_instance *tcp = stream->owner;
+	
+	offset;
+	if ( br == NULL )	
+		return EINVAL;
+	*br = 0;
+	if ( ( *br = recv(tcp->fd, buf, buf_size, 0) ) == -1 ) {
+		*br = 0;
+		return errno;
+	}
+	return 0;
+}
+
+static int _tcp_write(stream_t stream, const char *buf, size_t buf_size, off_t offset, size_t *bw)
+{
+	struct _tcp_instance *tcp = stream->owner;
+	
+	offset;
+	if ( bw == NULL )	
+		return EINVAL;
+	*bw = 0;
+	if ( ( *bw = send(tcp->fd, buf, buf_size, 0) ) == -1 ) {
+		*bw = 0;
+		return errno;
+	}
+	return 0;
+}
+
+static int _tcp_new(void *netdata, net_t parent, void **data)
+{
+	struct _tcp_instance *tcp;
+	
+	if ( parent )		/* tcp must be top level api */
+		return EINVAL;	
+
+	if ( ( tcp = malloc(sizeof(*tcp)) ) == NULL )
+		return ENOMEM;
+	tcp->options = (struct _tcp_options *)netdata;
+	tcp->fd = -1;
+	tcp->host = NULL;
+	tcp->port = -1;
+	tcp->state = TCP_STATE_INIT;
+	stream_create(&tcp->stream, tcp);
+	stream_set_read(tcp->stream, _tcp_read, tcp);
+	stream_set_write(tcp->stream, _tcp_write, tcp);
+	stream_set_fd(tcp->stream, _tcp_get_fd, tcp);
+	*data = tcp;
+	return 0;
+}
+
+static int _tcp_connect(void *data, const char *host, int port)
+{
+	struct _tcp_instance *tcp = data;
+	
+	if ( tcp->state == TCP_STATE_INIT ) {
+		tcp->port = port;	
+		if ( ( tcp->host = strdup(host) ) == NULL )
+			return ENOMEM;
+	}
+	if ( tcp->state < TCP_STATE_CONNECTED )
+		return _tcp_doconnect(tcp);
+	return 0;
+}
+
+static int _tcp_get_stream(void *data, stream_t *stream)
+{
+	struct _tcp_instance *tcp = data;
+
+	*stream = tcp->stream;
+	return 0;
+}
+
+static int _tcp_close(void *data)
+{
+	struct _tcp_instance *tcp = data;
+
+	if ( tcp->fd != -1 )
+		close(tcp->fd);
+	tcp->fd = -1;
+	tcp->state = TCP_STATE_INIT;
+	return 0;
+}
+
+static int _tcp_free(void **data)
+{
+	struct _tcp_instance *tcp;
+
+	if ( data == NULL || *data == NULL ) 
+		return EINVAL;
+	tcp = *data;
+
+	if ( tcp->host ) 
+		free(tcp->host);
+	if ( tcp->fd != -1 )
+		close(tcp->fd);
+	
+	free(*data);
+	*data = NULL;
+	return 0;
+}
+
+static struct _net_api _tcp_net_api = {
+	_tcp_new,
+	_tcp_connect,
+	_tcp_get_stream,
+	_tcp_close,
+	_tcp_free
+};
+
+int _tcp_create(void **netdata, struct _net_api **netapi) 
+{
+	struct _tcp_options *options;
+	
+	if ( ( options = malloc(sizeof(*options)) ) == NULL )
+		return ENOMEM;
+
+	options->non_block = 0;
+	options->net_timeout = -1; 		/* system default */
+
+	*netdata = options;
+	*netapi = &_tcp_net_api;
+	return 0;
+}
+
+int _tcp_set_option(void *netdata, const char *name, const char *value)
+{
+	struct _tcp_options *options = netdata;
+	
+	if ( strcasecmp(name, "tcp_non_block") == 0 ) {
+		if ( value[0] == 't' || value[0] == 'T' || value[0] == '1' || value[0] == 'y' || value[0] == 'Y')
+			options->non_block = 1;
+		else
+			options->non_block = 0;
+	} 
+	else if ( strcasecmp(name, "tcp_timeout") == 0 )
+		options->net_timeout = atoi(value);
+	else
+		return EINVAL;
+	return 0;
+}
+
+int _tcp_destroy(void **netdata)
+{
+	struct _tcp_options *options = *netdata;
+	
+	free(options);
+	*netdata = NULL;
+	return 0;
+}
+

+/* GNU mailutils - a suite of utilities for electronic mail
+   Copyright (C) 1999, 2000 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.  */
+
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <io0.h>
+#include <transcode.h>
+
+int _base64_decode(stream_t stream, char *optr, size_t osize, off_t offset, size_t *nbytes);
+int _base64_encode(stream_t stream, const char *optr, size_t osize, off_t offset, size_t *nbytes);
+void _base64_destroy(transcoder_t tc);
+int _qp_decode(stream_t stream, char *optr, size_t osize, off_t offset, size_t *nbytes);
+int _qp_encode(stream_t stream, const char *iptr, size_t isize, off_t offset, size_t *nbytes);
+int _identity_decode(stream_t stream, char *optr, size_t osize, off_t offset, size_t *nbytes);
+int _identity_encode(stream_t stream, const char *iptr, size_t isize, off_t offset, size_t *nbytes);
+
+struct _tc_desc {
+	const char *encoding;
+	int (*decode_read)(stream_t, char *, size_t, off_t, size_t *);
+	int (*encode_write)(stream_t, const char *, size_t, off_t, size_t *);
+	void (*destroy)(transcoder_t tc);
+};
+
+#define NUM_TRANSCODERS 5
+struct _tc_desc tclist[NUM_TRANSCODERS] =     { { "base64", 			_base64_decode, 	_base64_encode, 	_base64_destroy }, 
+						 						{ "quoted-printable", 	_qp_decode, 		_qp_encode, 		NULL },
+												{ "7bit", 				_identity_decode, 	_identity_encode, 	NULL },
+												{ "8bit", 				_identity_decode, 	_identity_encode, 	NULL },
+												{ "binary", 			_identity_decode, 	_identity_encode, 	NULL }
+											  };
+
+int transcode_create(transcoder_t *ptc, char *encoding)
+{
+	transcoder_t tc;
+	int i;
+		
+	if ( ( tc = calloc(sizeof(struct _transcoder), 1) ) == NULL )
+		return ENOMEM;
+	for( i = 0; i < NUM_TRANSCODERS; i++ ) {
+		if ( strcasecmp( encoding, tclist[i].encoding ) == 0 )
+			break;
+	}
+	if ( i == NUM_TRANSCODERS )
+		return ENOTSUP;
+
+	stream_create(&tc->ustream, tc );
+	stream_set_read(tc->ustream, tclist[i].decode_read, tc );
+	stream_set_write(tc->ustream, tclist[i].encode_write, tc );
+	tc->destroy = tclist[i].destroy;
+	*ptc = tc;
+	return 0;
+}
+
+void transcode_destroy(transcoder_t *ptc)
+{
+	transcoder_t tc = *ptc;
+
+	if ( tc->destroy) 
+		tc->destroy(tc);	
+	stream_destroy(&tc->ustream, tc);
+	free(tc);
+	*ptc = NULL;
+}
+
+int transcode_get_stream(transcoder_t tc, stream_t *pstream)
+{
+	if (tc == NULL || pstream == NULL)
+		return EINVAL;
+	*pstream = tc->ustream;
+	return 0;		
+}
+
+int transcode_set_stream(transcoder_t tc, stream_t stream)
+{
+	if (tc == NULL || stream == NULL)
+		return EINVAL;
+	tc->stream = stream;
+	return 0;		
+}
+
+/*------------------------------------------------------
+ * base64 encode/decode
+ *----------------------------------------------------*/
+
+struct _b64_decode
+{
+	int cur_offset;
+	int offset;
+	int	data_len;
+	char data[4];
+};
+
+static int _b64_input(char c)
+{
+	const char table[64] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+	int 	i;
+
+	for (i = 0; i < 64; i++) {
+		if (table[i] == c)
+			return i;
+	}
+	return -1;
+}
+
+#if 0
+static int _b64_output(int index)
+{
+	const char table[64] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+	if (index < 64)
+		return table[index];
+	return -1;
+}
+#endif
+
+void _base64_destroy(transcoder_t tc)
+{
+	free(tc->tcdata);
+	tc->tcdata = NULL;
+}
+
+int _base64_decode(stream_t ustream, char *optr, size_t osize, off_t offset, size_t *nbytes)
+{
+	int i, tmp = 0, ret;
+	size_t isize, consumed = 0;
+	char *iptr;
+	transcoder_t tc = (transcoder_t)ustream->owner;	
+	struct _b64_decode *decode;
+	
+	if ( nbytes == NULL || optr == NULL || osize == 0 )
+		return EINVAL;
+
+	*nbytes = 0;
+	if ( ( decode = tc->tcdata ) == NULL ) {
+		if ( ( decode = calloc(1, sizeof(struct _b64_decode)) ) == NULL )
+			return ENOMEM;
+		tc->tcdata = decode;		
+	}
+	if ( decode->offset != offset )
+		return ESPIPE;
+		
+	if ( ( iptr = alloca(osize) ) == NULL )
+		return ENOMEM;
+	isize = osize;
+
+	if ( ( ret = stream_read(tc->stream, iptr, isize, decode->cur_offset, &isize) ) != 0 ) 
+		return ret;
+		
+	decode->cur_offset += isize;	
+	i = decode->data_len;
+	while ( consumed < isize ) {
+		while ( ( i < 4 ) && ( consumed < isize ) ) {
+			tmp = _b64_input(*iptr++);
+			consumed++;
+			if ( tmp != -1 )
+				decode->data[i++] = tmp;
+		}
+		if ( i == 4 ) { // I have a entire block of data 32 bits
+			// get the output data
+			*optr++ = ( decode->data[0] << 2 ) | ( ( decode->data[1] & 0x30 ) >> 4 );
+			*optr++ = ( ( decode->data[1] & 0xf ) << 4 ) | ( ( decode->data[2] & 0x3c ) >> 2 );
+			*optr++ = ( ( decode->data[2] & 0x3 ) << 6 ) | decode->data[3];
+			(*nbytes) += 3;
+			decode->data_len = 0;
+		}
+		else { // I did not get all the data
+			decode->data_len = i;
+			decode->offset += *nbytes;
+			return 0;
+		}
+		i = 0;
+	}
+	decode->offset += *nbytes;
+	return 0;
+}
+
+int _base64_encode(stream_t ustream, const char *iptr, size_t osize, off_t offset, size_t *nbytes)
+{
+	(void)ustream; (void)iptr; (void)osize; (void)offset; (void)nbytes;
+	return ENOTSUP;
+}
+
+/*------------------------------------------------------
+ * quoted-printable decoder/encoder
+ *------------------------------------------------------*/
+struct _qp_decode
+{
+	int cur_offset;
+	int offset;
+	int	data_len;
+	char data[3];
+};
+
+static const char _hexdigits[16] = "0123456789ABCDEF";
+
+static int _ishex(int c)
+{
+	int i;
+
+	if ((c == 0x0a) || (c == 0x0d))
+		return 1;
+
+	for (i = 0; i < 16; i++)
+		if (c == _hexdigits[i])
+			return 1;
+
+	return 0;
+}
+
+
+int _qp_decode(stream_t ustream, char *optr, size_t osize, off_t offset, size_t *nbytes)
+{
+	transcoder_t tc = ustream->owner;
+	char c;
+	int last_char = 0, ret;
+	size_t isize, consumed = 0;
+	struct _qp_decode *decode;
+	char *iptr;
+	
+	if ( nbytes == NULL || optr == NULL )
+		return EINVAL;
+
+	*nbytes = 0;
+	if ( ( decode = tc->tcdata ) == NULL ) {
+		if ( ( decode = calloc(1, sizeof(struct _qp_decode)) ) == NULL )
+			return ENOMEM;
+		tc->tcdata = decode;		
+	}
+	if ( decode->offset != offset )
+		return ESPIPE;
+		
+	if ( ( iptr = alloca(osize) ) == NULL )
+		return ENOMEM;
+	isize = osize;
+
+	if ( decode->data_len )
+		memcpy( iptr, decode->data, decode->data_len);
+
+	if ( ( ret = stream_read(tc->stream, iptr + decode->data_len, isize - decode->data_len, decode->cur_offset, &isize) ) != 0 ) 
+		return ret;
+
+	decode->data_len = 0;
+	decode->cur_offset += isize;	
+	while (consumed < isize) {
+			c = *iptr++;
+		if ( ((c >= 33) && (c <= 60)) || ((c >= 62) && (c <= 126)) || ((c == '=') && !_ishex(*iptr)) ) {
+			*optr++ = c;
+			(*nbytes)++;
+			consumed++;
+		}
+		else if (c == '=') {
+			// there must be 2 more characters before I consume this
+			if ((isize - consumed) < 3) {
+				memcpy( decode->data, iptr-1, decode->data_len = isize - consumed + 1);
+				return 0;
+			} 
+			else {
+				// you get =XX where XX are hex characters
+				char 	chr[2];
+				int 	new_c;
+
+				chr[0] = *iptr++;
+				if (chr[0] != 0x0a) { // LF after = means soft line break, ignore it
+					chr[1] = *iptr++;
+					new_c = strtoul(chr, NULL, 16);
+					if (new_c == '\r')
+						new_c = '\n';
+					*optr++ = new_c;
+					(*nbytes)++;
+					consumed += 3;
+				}
+				else
+					consumed += 2;
+			}
+		}
+		else if (c == 0x0d) { // CR character
+			// there must be at least 1 more character before I consume this
+			if ((isize - consumed) < 2)
+			    return (consumed);
+			else {
+				iptr++; // skip the LF character
+				*optr++ = '\n';
+				(*nbytes)++;
+				consumed += 2;
+			}
+		}
+		else if ((c == 9) || (c == 32)) {
+			if ((last_char == 9) || (last_char == 32))
+				consumed++;
+			else {
+				*optr++ = c;
+				(*nbytes)++;
+				consumed++;
+			}
+		}
+		last_char = c;
+	}
+	decode->offset += *nbytes;
+	return 0;
+}
+
+
+#define QP_LINE_MAX	76
+struct _qp_encode
+{
+	char *obuf;
+	int	 osize;
+};
+
+int _qp_encode(stream_t ustream, const char *iptr, size_t isize, off_t offset, size_t *nbytes)
+{
+#if 0
+	transcoder_t tc = ustream->owner;
+
+	static int count = 0;
+	int consumed = 0, c, osize;
+	char *obuf;
+	struct _qp_encode *encode;
+	
+
+	if ( nbytes == NULL || iptr == NULL )
+		return EINVAL;
+
+	if ( isize == 0 )
+		return 0;
+
+	*nbytes = 0;		
+	if ( ( encode = tc->tcdata ) == NULL ) {
+		
+	}
+	if ( ( encode->obuf = malloc(isize) ) == NULL )
+		return ENOMEM;
+
+	optr = obuf;
+	while (consumed < isize) {
+		if (count == QP_LINE_MAX) {
+			*optr++ = '=';
+			*optr++ = '\n';
+			osize += 2;
+			count = 0;
+		}
+
+		c = *iptr++;
+		if ( ((c >= 32) && (c <= 60)) || ((c >= 62) && (c <= 126)) || (c == 9)) {
+		    *optr++ = c;
+		    osize++;
+		    count++;
+		}
+		else {
+			char chr[3];
+
+			if (count >= (QP_LINE_MAX - 3)) {
+				// add spaces
+				while (count < QP_LINE_MAX) {
+					*optr++ = ' ';
+					osize++;
+					count++;
+				}
+				consumed--;
+				iptr--;
+			}
+			else {
+				*optr++ = '=';
+				sprintf(chr, "%02X", c);
+				*optr++ = chr[0];
+				*optr++ = chr[1];
+				osize += 3;
+				count += 3;
+			}
+		}
+		consumed++;
+		if ( osize + 4 >= isize ) {
+			if (stream_write( tc->stream, obuf, osize
+		}
+	}
+#endif
+	(void)ustream; (void)iptr; (void)isize; (void)offset; (void)nbytes;
+	return EINVAL;
+}
+
+/*------------------------------------------------------
+ * identity decoder/encoder for 7bit, 8bit & binary
+ *------------------------------------------------------*/
+int _identity_decode(stream_t ustream, char *optr, size_t osize, off_t offset, size_t *nbytes)
+{
+	transcoder_t tc = ustream->owner;
+	if ( tc->stream )
+		return stream_read(tc->stream, optr, osize, offset, nbytes );
+	return EINVAL;
+}
+
+int _identity_encode(stream_t ustream, const char *iptr, size_t isize, off_t offset, size_t *nbytes)
+{
+	transcoder_t tc = ustream->owner;
+	if ( tc->stream )
+		return stream_write(tc->stream, iptr, isize, offset, nbytes );
+	return EINVAL;
+}