add files for 2007-09-05T21:47:35Z
authorUnknown <>
Wed, 5 Sep 2007 21:47:35 +0000 (21:47 +0000)
committerNathan Wagner <nw@hydaspes.if.org>
Fri, 7 Sep 2018 00:02:37 +0000 (00:02 +0000)
src/osdep/amiga/mmdf.c [new file with mode: 0644]
src/osdep/unix/mmdf.c [new file with mode: 0644]

diff --git a/src/osdep/amiga/mmdf.c b/src/osdep/amiga/mmdf.c
new file mode 100644 (file)
index 0000000..f79e761
--- /dev/null
@@ -0,0 +1,2550 @@
+/* ========================================================================
+ * Copyright 1988-2007 University of Washington
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 
+ * ========================================================================
+ */
+
+/*
+ * Program:    MMDF mail routines
+ *
+ * Author:     Mark Crispin
+ *             Networks and Distributed Computing
+ *             Computing & Communications
+ *             University of Washington
+ *             Administration Building, AG-44
+ *             Seattle, WA  98195
+ *             Internet: MRC@CAC.Washington.EDU
+ *
+ * Date:       20 December 1989
+ * Last Edited:        5 September 2007
+ */
+
+
+#include <stdio.h>
+#include <ctype.h>
+#include <errno.h>
+extern int errno;              /* just in case */
+#include <signal.h>
+#include "mail.h"
+#include "osdep.h"
+#include <time.h>
+#include <sys/stat.h>
+#include "pseudo.h"
+#include "fdstring.h"
+#include "misc.h"
+#include "dummy.h"
+\f
+/* Supposedly, this page has everything the MMDF driver needs to know about
+ * the MMDF delimiter.  By changing these macros, the MMDF driver should
+ * change with it.  Note that if you change the length of MMDFHDRTXT you
+ * also need to change the ISMMDF and RETIFMMDFWRD macros to reflect the new
+ * size.
+ */
+
+
+/* Useful MMDF constants */
+
+#define MMDFCHR '\01'          /* MMDF character */
+#define MMDFCHRS 0x01010101    /* MMDF header character spread in a word */
+                               /* MMDF header text */
+#define MMDFHDRTXT "\01\01\01\01\n"
+                               /* length of MMDF header text */
+#define MMDFHDRLEN (sizeof (MMDFHDRTXT) - 1)
+
+
+/* Validate MMDF header
+ * Accepts: pointer to candidate string to validate as an MMDF header
+ * Returns: T if valid; else NIL
+ */
+
+#define ISMMDF(s)                                                      \
+  ((*(s) == MMDFCHR) && ((s)[1] == MMDFCHR) && ((s)[2] == MMDFCHR) &&  \
+   ((s)[3] == MMDFCHR) && ((s)[4] == '\n'))
+
+
+/* Return if a 32-bit word has the start of an MMDF header
+ * Accepts: pointer to word of four bytes to validate as an MMDF header
+ * Returns: pointer to MMDF header, else proceeds
+ */
+
+#define RETIFMMDFWRD(s) {                                              \
+  if (s[3] == MMDFCHR) {                                               \
+    if ((s[4] == MMDFCHR) && (s[5] == MMDFCHR) && (s[6] == MMDFCHR) && \
+       (s[7] == '\n')) return s + 3;                                   \
+    else if (s[2] == MMDFCHR) {                                                \
+      if ((s[4] == MMDFCHR) && (s[5] == MMDFCHR) && (s[6] == '\n'))    \
+       return s + 2;                                                   \
+      else if (s[1] == MMDFCHR) {                                      \
+       if ((s[4] == MMDFCHR) && (s[5] == '\n')) return s + 1;          \
+       else if ((*s == MMDFCHR) && (s[4] == '\n')) return s;           \
+      }                                                                        \
+    }                                                                  \
+  }                                                                    \
+}
+\f
+/* Validate line
+ * Accepts: pointer to candidate string to validate as a From header
+ *         return pointer to end of date/time field
+ *         return pointer to offset from t of time (hours of ``mmm dd hh:mm'')
+ *         return pointer to offset from t of time zone (if non-zero)
+ * Returns: t,ti,zn set if valid From string, else ti is NIL
+ */
+
+#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;                       \
+      }                                                                        \
+    }                                                                  \
+  }                                                                    \
+}
+
+/* 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
+ * emacs       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.
+ */
+\f
+/*
+ * 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-5   Validates that there is an end of line and points x at it.
+ * Lines 6-13  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 14     Makes sure that there are at least 27 characters in the line.
+ * Lines 15-20 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 21-23 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 24-27 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 28-31  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 to
+ * see if unquoted spaces were possible.  They are, and I've encountered enough
+ * evil mail to be totally unwilling to trust that ``it will never happen''.
+ */
+\f
+/* Build parameters */
+
+#define KODRETRY 15            /* kiss-of-death retry in seconds */
+#define LOCKTIMEOUT 5          /* lock timeout in minutes */
+
+
+/* MMDF I/O stream local data */
+
+typedef struct mmdf_local {
+  unsigned int dirty : 1;      /* disk copy needs updating */
+  unsigned int ddirty : 1;     /* double-dirty, ping becomes checkpoint */
+  unsigned int pseudo : 1;     /* uses a pseudo message */
+  unsigned int appending : 1;  /* don't mark new messages as old */
+  int fd;                      /* mailbox file descriptor */
+  int ld;                      /* lock file descriptor */
+  char *lname;                 /* lock file name */
+  off_t filesize;              /* file size parsed */
+  time_t filetime;             /* last file time */
+  unsigned char *buf;          /* temporary buffer */
+  unsigned long buflen;                /* current size of temporary buffer */
+  unsigned long uid;           /* current text uid */
+  SIZEDTEXT text;              /* current text */
+  unsigned long textlen;       /* current text length */
+  char *line;                  /* returned line */
+  char *linebuf;               /* line readin buffer */
+  unsigned long linebuflen;    /* current line readin buffer length */
+} MMDFLOCAL;
+
+
+/* Convenient access to local data */
+
+#define LOCAL ((MMDFLOCAL *) stream->local)
+
+
+/* MMDF protected file structure */
+
+typedef struct mmdf_file {
+  MAILSTREAM *stream;          /* current stream */
+  off_t curpos;                        /* current file position */
+  off_t protect;               /* protected position */
+  off_t filepos;               /* current last written file position */
+  char *buf;                   /* overflow buffer */
+  size_t buflen;               /* current overflow buffer length */
+  char *bufpos;                        /* current buffer position */
+} MMDFFILE;
+\f
+/* Function prototypes */
+
+DRIVER *mmdf_valid (char *name);
+long mmdf_isvalid (char *name,char *tmp);
+long mmdf_isvalid_fd (int fd,char *tmp);
+void *mmdf_parameters (long function,void *value);
+void mmdf_scan (MAILSTREAM *stream,char *ref,char *pat,char *contents);
+void mmdf_list (MAILSTREAM *stream,char *ref,char *pat);
+void mmdf_lsub (MAILSTREAM *stream,char *ref,char *pat);
+long mmdf_create (MAILSTREAM *stream,char *mailbox);
+long mmdf_delete (MAILSTREAM *stream,char *mailbox);
+long mmdf_rename (MAILSTREAM *stream,char *old,char *newname);
+MAILSTREAM *mmdf_open (MAILSTREAM *stream);
+void mmdf_close (MAILSTREAM *stream,long options);
+char *mmdf_header (MAILSTREAM *stream,unsigned long msgno,
+                  unsigned long *length,long flags);
+long mmdf_text (MAILSTREAM *stream,unsigned long msgno,STRING *bs,long flags);
+char *mmdf_text_work (MAILSTREAM *stream,MESSAGECACHE *elt,
+                     unsigned long *length,long flags);
+void mmdf_flagmsg (MAILSTREAM *stream,MESSAGECACHE *elt);
+long mmdf_ping (MAILSTREAM *stream);
+void mmdf_check (MAILSTREAM *stream);
+long mmdf_expunge (MAILSTREAM *stream,char *sequence,long options);
+long mmdf_copy (MAILSTREAM *stream,char *sequence,char *mailbox,long options);
+long mmdf_append (MAILSTREAM *stream,char *mailbox,append_t af,void *data);
+int mmdf_collect_msg (MAILSTREAM *stream,FILE *sf,char *flags,char *date,
+                    STRING *msg);
+int mmdf_append_msgs (MAILSTREAM *stream,FILE *sf,FILE *df,SEARCHSET *set);
+
+void mmdf_abort (MAILSTREAM *stream);
+char *mmdf_file (char *dst,char *name);
+int mmdf_lock (char *file,int flags,int mode,DOTLOCK *lock,int op);
+void mmdf_unlock (int fd,MAILSTREAM *stream,DOTLOCK *lock);
+int mmdf_parse (MAILSTREAM *stream,DOTLOCK *lock,int op);
+char *mmdf_mbxline (MAILSTREAM *stream,STRING *bs,unsigned long *size);
+unsigned long mmdf_pseudo (MAILSTREAM *stream,char *hdr);
+unsigned long mmdf_xstatus (MAILSTREAM *stream,char *status,MESSAGECACHE *elt,
+                           unsigned long uid,long flag);
+long mmdf_rewrite (MAILSTREAM *stream,unsigned long *nexp,DOTLOCK *lock,
+                  long flags);
+long mmdf_extend (MAILSTREAM *stream,unsigned long size);
+void mmdf_write (MMDFFILE *f,char *s,unsigned long i);
+void mmdf_phys_write (MMDFFILE *f,char *buf,size_t size);
+\f
+/* MMDF mail routines */
+
+
+/* Driver dispatch used by MAIL */
+
+DRIVER mmdfdriver = {
+  "mmdf",                      /* driver name */
+                               /* driver flags */
+  DR_LOCAL|DR_MAIL|DR_LOCKING|DR_NONEWMAILRONLY|DR_XPOINT,
+  (DRIVER *) NIL,              /* next driver */
+  mmdf_valid,                  /* mailbox is valid for us */
+  mmdf_parameters,             /* manipulate parameters */
+  mmdf_scan,                   /* scan mailboxes */
+  mmdf_list,                   /* list mailboxes */
+  mmdf_lsub,                   /* list subscribed mailboxes */
+  NIL,                         /* subscribe to mailbox */
+  NIL,                         /* unsubscribe from mailbox */
+  mmdf_create,                 /* create mailbox */
+  mmdf_delete,                 /* delete mailbox */
+  mmdf_rename,                 /* rename mailbox */
+  mail_status_default,         /* status of mailbox */
+  mmdf_open,                   /* open mailbox */
+  mmdf_close,                  /* close mailbox */
+  NIL,                         /* fetch message "fast" attributes */
+  NIL,                         /* fetch message flags */
+  NIL,                         /* fetch overview */
+  NIL,                         /* fetch message envelopes */
+  mmdf_header,                 /* fetch message header */
+  mmdf_text,                   /* fetch message text */
+  NIL,                         /* fetch partial message text */
+  NIL,                         /* unique identifier */
+  NIL,                         /* message number */
+  NIL,                         /* modify flags */
+  mmdf_flagmsg,                        /* per-message modify flags */
+  NIL,                         /* search for message based on criteria */
+  NIL,                         /* sort messages */
+  NIL,                         /* thread messages */
+  mmdf_ping,                   /* ping mailbox to see if still alive */
+  mmdf_check,                  /* check for new messages */
+  mmdf_expunge,                        /* expunge deleted messages */
+  mmdf_copy,                   /* copy messages to another mailbox */
+  mmdf_append,                 /* append string message to mailbox */
+  NIL                          /* garbage collect stream */
+};
+
+                               /* prototype stream */
+MAILSTREAM mmdfproto = {&mmdfdriver};
+
+char *mmdfhdr = MMDFHDRTXT;    /* MMDF header */
+\f
+/* MMDF mail validate mailbox
+ * Accepts: mailbox name
+ * Returns: our driver if name is valid, NIL otherwise
+ */
+
+DRIVER *mmdf_valid (char *name)
+{
+  char tmp[MAILTMPLEN];
+  return mmdf_isvalid (name,tmp) ? &mmdfdriver : NIL;
+}
+
+
+/* MMDF mail test for valid mailbox name
+ * Accepts: mailbox name
+ *         scratch buffer
+ * Returns: T if valid, NIL otherwise
+ */
+
+long mmdf_isvalid (char *name,char *tmp)
+{
+  int fd;
+  int ret = NIL;
+  char *t,file[MAILTMPLEN];
+  struct stat sbuf;
+  time_t tp[2];
+  errno = EINVAL;              /* assume invalid argument */
+                               /* must be non-empty file */
+  if ((t = dummy_file (file,name)) && !stat (t,&sbuf)) {
+    if (!sbuf.st_size)errno = 0;/* empty file */
+    else if ((fd = open (file,O_RDONLY,NIL)) >= 0) {
+                               /* error -1 for invalid format */
+      if (!(ret = mmdf_isvalid_fd (fd,tmp))) errno = -1;
+      close (fd);              /* close the file */
+                               /* \Marked status? */
+      if ((sbuf.st_ctime > sbuf.st_atime) || (sbuf.st_mtime > sbuf.st_atime)) {
+       tp[0] = sbuf.st_atime;  /* preserve atime and mtime */
+       tp[1] = sbuf.st_mtime;
+       utime (file,tp);        /* set the times */
+      }
+    }
+  }
+  return ret;                  /* return what we should */
+}
+\f
+/* MMDF mail test for valid mailbox
+ * Accepts: file descriptor
+ *         scratch buffer
+ * Returns: T if valid, NIL otherwise
+ */
+
+long mmdf_isvalid_fd (int fd,char *tmp)
+{
+  int ret = NIL;
+  memset (tmp,'\0',MAILTMPLEN);
+  if (read (fd,tmp,MAILTMPLEN-1) >= 0) ret = ISMMDF (tmp) ? T : NIL;
+  return ret;                  /* return what we should */
+}
+
+
+/* MMDF manipulate driver parameters
+ * Accepts: function code
+ *         function-dependent value
+ * Returns: function-dependent return value
+ */
+
+void *mmdf_parameters (long function,void *value)
+{
+  void *ret = NIL;
+  switch ((int) function) {
+  case GET_INBOXPATH:
+    if (value) ret = dummy_file ((char *) value,"INBOX");
+    break;
+  }
+  return ret;
+}
+\f
+/* MMDF mail scan mailboxes
+ * Accepts: mail stream
+ *         reference
+ *         pattern to search
+ *         string to scan
+ */
+
+void mmdf_scan (MAILSTREAM *stream,char *ref,char *pat,char *contents)
+{
+  if (stream) dummy_scan (NIL,ref,pat,contents);
+}
+
+
+/* MMDF mail list mailboxes
+ * Accepts: mail stream
+ *         reference
+ *         pattern to search
+ */
+
+void mmdf_list (MAILSTREAM *stream,char *ref,char *pat)
+{
+  if (stream) dummy_list (NIL,ref,pat);
+}
+
+
+/* MMDF mail list subscribed mailboxes
+ * Accepts: mail stream
+ *         reference
+ *         pattern to search
+ */
+
+void mmdf_lsub (MAILSTREAM *stream,char *ref,char *pat)
+{
+  if (stream) dummy_lsub (NIL,ref,pat);
+}
+\f
+/* MMDF mail create mailbox
+ * Accepts: MAIL stream
+ *         mailbox name to create
+ * Returns: T on success, NIL on failure
+ */
+
+long mmdf_create (MAILSTREAM *stream,char *mailbox)
+{
+  char *s,mbx[MAILTMPLEN],tmp[MAILTMPLEN];
+  long ret = NIL;
+  int i,fd;
+  time_t ti = time (0);
+  if (!(s = dummy_file (mbx,mailbox))) {
+    sprintf (tmp,"Can't create %.80s: invalid name",mailbox);
+    MM_LOG (tmp,ERROR);
+  }
+                               /* create underlying file */
+  else if (dummy_create_path (stream,s,get_dir_protection (mailbox))) {
+                               /* done if dir-only or whiner */
+    if (((s = strrchr (s,'/')) && !s[1]) ||
+       mail_parameters (NIL,GET_USERHASNOLIFE,NIL)) ret = T;
+    else if ((fd = open (mbx,O_WRONLY,
+                   (long) mail_parameters (NIL,GET_MBXPROTECTION,NIL))) < 0) {
+      sprintf (tmp,"Can't reopen mailbox node %.80s: %s",mbx,strerror (errno));
+      MM_LOG (tmp,ERROR);
+      unlink (mbx);            /* delete the file */
+    }
+    else {                     /* initialize header */
+      memset (tmp,'\0',MAILTMPLEN);
+      sprintf (tmp,"%sFrom %s %sDate: ",mmdfhdr,pseudo_from,ctime (&ti));
+      rfc822_date (s = tmp + strlen (tmp));
+      sprintf (s += strlen (s),        /* write the pseudo-header */
+              "\nFrom: %s <%s@%s>\nSubject: %s\nX-IMAP: %010lu 0000000000",
+              pseudo_name,pseudo_from,mylocalhost (),pseudo_subject,
+              (unsigned long) ti);
+      for (i = 0; i < NUSERFLAGS; ++i) if (default_user_flag (i))
+       sprintf (s += strlen (s)," %s",default_user_flag (i));
+      sprintf (s += strlen (s),"\nStatus: RO\n\n%s\n%s",pseudo_msg,mmdfhdr);
+      if (write (fd,tmp,strlen (tmp)) > 0) ret = T;
+      else {
+       sprintf (tmp,"Can't initialize mailbox node %.80s: %s",mbx,
+                strerror (errno));
+       MM_LOG (tmp,ERROR);
+       unlink (mbx);           /* delete the file */
+      }
+      close (fd);              /* close file */
+    }
+  }
+                               /* set proper protections */
+  return ret ? set_mbx_protections (mailbox,mbx) : NIL;
+}
+\f
+/* MMDF mail delete mailbox
+ * Accepts: MAIL stream
+ *         mailbox name to delete
+ * Returns: T on success, NIL on failure
+ */
+
+long mmdf_delete (MAILSTREAM *stream,char *mailbox)
+{
+  return mmdf_rename (stream,mailbox,NIL);
+}
+
+
+/* MMDF mail rename mailbox
+ * Accepts: MAIL stream
+ *         old mailbox name
+ *         new mailbox name (or NIL for delete)
+ * Returns: T on success, NIL on failure
+ */
+
+long mmdf_rename (MAILSTREAM *stream,char *old,char *newname)
+{
+  long ret = NIL;
+  char c,*s = NIL;
+  char tmp[MAILTMPLEN],file[MAILTMPLEN],lock[MAILTMPLEN];
+  DOTLOCK lockx;
+  int fd,ld;
+  long i;
+  struct stat sbuf;
+  MM_CRITICAL (stream);        /* get the c-client lock */
+  if (!dummy_file (file,old) ||
+      (newname && (!((s = mailboxfile (tmp,newname)) && *s) ||
+                  ((s = strrchr (tmp,'/')) && !s[1]))))
+    sprintf (tmp,newname ?
+            "Can't rename mailbox %.80s to %.80s: invalid name" :
+            "Can't delete mailbox %.80s: invalid name",
+            old,newname);
+                               /* lock out other c-clients */
+  else if ((ld = lockname (lock,file,LOCK_EX|LOCK_NB,&i)) < 0)
+    sprintf (tmp,"Mailbox %.80s is in use by another process",old);
+\f
+  else {
+    if ((fd = mmdf_lock (file,O_RDWR,
+                        (long) mail_parameters (NIL,GET_MBXPROTECTION,NIL),
+                        &lockx,LOCK_EX)) < 0)
+       sprintf (tmp,"Can't lock mailbox %.80s: %s",old,strerror (errno));
+    else {
+      if (newname) {           /* want rename? */
+                               /* found superior to destination name? */
+       if (s = strrchr (s,'/')) {
+         c = *++s;             /* remember first character of inferior */
+         *s = '\0';            /* tie off to get just superior */
+                               /* name doesn't exist, create it */
+         if ((stat (tmp,&sbuf) || ((sbuf.st_mode & S_IFMT) != S_IFDIR)) &&
+             !dummy_create_path (stream,tmp,get_dir_protection (newname))) {
+           mmdf_unlock (fd,NIL,&lockx);
+           mmdf_unlock (ld,NIL,NIL);
+           unlink (lock);
+           MM_NOCRITICAL (stream);
+           return ret;         /* return success or failure */
+         }
+         *s = c;               /* restore full name */
+       }
+       if (rename (file,tmp))
+         sprintf (tmp,"Can't rename mailbox %.80s to %.80s: %s",old,newname,
+                  strerror (errno));
+       else ret = T;           /* set success */
+      }
+      else if (unlink (file))
+       sprintf (tmp,"Can't delete mailbox %.80s: %s",old,strerror (errno));
+      else ret = T;            /* set success */
+      mmdf_unlock (fd,NIL,&lockx);
+    }
+    mmdf_unlock (ld,NIL,NIL);  /* flush the lock */
+    unlink (lock);
+  }
+  MM_NOCRITICAL (stream);      /* no longer critical */
+  if (!ret) MM_LOG (tmp,ERROR);        /* log error */
+  return ret;                  /* return success or failure */
+}
+\f
+/* MMDF mail open
+ * Accepts: Stream to open
+ * Returns: Stream on success, NIL on failure
+ */
+
+MAILSTREAM *mmdf_open (MAILSTREAM *stream)
+{
+  long i;
+  int fd;
+  char tmp[MAILTMPLEN];
+  DOTLOCK lock;
+  long retry;
+                               /* return prototype for OP_PROTOTYPE call */
+  if (!stream) return user_flags (&mmdfproto);
+  retry = stream->silent ? 1 : KODRETRY;
+  if (stream->local) fatal ("mmdf recycle stream");
+  stream->local = memset (fs_get (sizeof (MMDFLOCAL)),0,sizeof (MMDFLOCAL));
+                               /* note if an INBOX or not */
+  stream->inbox = !compare_cstring (stream->mailbox,"INBOX");
+                               /* canonicalize the stream mailbox name */
+  if (!dummy_file (tmp,stream->mailbox)) {
+    sprintf (tmp,"Can't open - invalid name: %.80s",stream->mailbox);
+    MM_LOG (tmp,ERROR);
+    return NIL;
+  }
+                               /* flush old name */
+  fs_give ((void **) &stream->mailbox);
+                               /* save canonical name */
+  stream->mailbox = cpystr (tmp);
+  LOCAL->fd = LOCAL->ld = -1;  /* no file or state locking yet */
+  LOCAL->buf = (char *) fs_get (CHUNKSIZE);
+  LOCAL->buflen = CHUNKSIZE - 1;
+  LOCAL->text.data = (unsigned char *) fs_get (CHUNKSIZE);
+  LOCAL->text.size = CHUNKSIZE - 1;
+  LOCAL->linebuf = (char *) fs_get (CHUNKSIZE);
+  LOCAL->linebuflen = CHUNKSIZE - 1;
+  stream->sequence++;          /* bump sequence number */
+\f
+                               /* make lock for read/write access */
+  if (!stream->rdonly) while (retry) {
+                               /* try to lock file */
+    if ((fd = lockname (tmp,stream->mailbox,LOCK_EX|LOCK_NB,&i)) < 0) {
+                               /* suppressing kiss-of-death? */
+      if (stream->nokod) retry = 0;
+                               /* no, first time through? */
+      else if (retry-- == KODRETRY) {
+                               /* learned other guy's PID and can signal? */
+       if (i && !kill ((int) i,SIGUSR2)) {
+         sprintf (tmp,"Trying to get mailbox lock from process %ld",i);
+         MM_LOG (tmp,WARN);
+       }
+       else retry = 0;         /* give up */
+      }
+      if (!stream->silent) {   /* nothing if silent stream */
+       if (retry) sleep (1);   /* wait a second before trying again */
+       else MM_LOG ("Mailbox is open by another process, access is readonly",
+                    WARN);
+      }
+    }
+    else {                     /* got the lock, nobody else can alter state */
+      LOCAL->ld = fd;          /* note lock's fd and name */
+      LOCAL->lname = cpystr (tmp);
+                               /* make sure mode OK (don't use fchmod()) */
+      chmod (LOCAL->lname,(long) mail_parameters (NIL,GET_LOCKPROTECTION,NIL));
+      if (stream->silent) i = 0;/* silent streams won't accept KOD */
+      else {                   /* note our PID in the lock */
+       sprintf (tmp,"%d",getpid ());
+       write (fd,tmp,(i = strlen (tmp))+1);
+      }
+      ftruncate (fd,i);                /* make sure tied off */
+      fsync (fd);              /* make sure it's available */
+      retry = 0;               /* no more need to try */
+    }
+  }
+\f
+                               /* parse mailbox */
+  stream->nmsgs = stream->recent = 0;
+                               /* will we be able to get write access? */
+  if ((LOCAL->ld >= 0) && access (stream->mailbox,W_OK) && (errno == EACCES)) {
+    MM_LOG ("Can't get write access to mailbox, access is readonly",WARN);
+    flock (LOCAL->ld,LOCK_UN); /* release the lock */
+    close (LOCAL->ld);         /* close the lock file */
+    LOCAL->ld = -1;            /* no more lock fd */
+    unlink (LOCAL->lname);     /* delete it */
+  }
+                               /* reset UID validity */
+  stream->uid_validity = stream->uid_last = 0;
+  if (stream->silent && !stream->rdonly && (LOCAL->ld < 0))
+    mmdf_abort (stream);       /* abort if can't get RW silent stream */
+                               /* parse mailbox */
+  else if (mmdf_parse (stream,&lock,LOCK_SH)) {
+    mmdf_unlock (LOCAL->fd,stream,&lock);
+    mail_unlock (stream);
+    MM_NOCRITICAL (stream);    /* done with critical */
+  }
+  if (!LOCAL) return NIL;      /* failure if stream died */
+                               /* make sure upper level knows readonly */
+  stream->rdonly = (LOCAL->ld < 0);
+                               /* notify about empty mailbox */
+  if (!(stream->nmsgs || stream->silent)) MM_LOG ("Mailbox is empty",NIL);
+  if (!stream->rdonly) {       /* flags stick if readwrite */
+    stream->perm_seen = stream->perm_deleted =
+      stream->perm_flagged = stream->perm_answered = stream->perm_draft = T;
+    if (!stream->uid_nosticky) {/* users with lives get permanent keywords */
+      stream->perm_user_flags = 0xffffffff;
+                               /* and maybe can create them too! */
+      stream->kwd_create = stream->user_flags[NUSERFLAGS-1] ? NIL : T;
+    }
+  }
+  return stream;               /* return stream alive to caller */
+}
+
+
+/* MMDF mail close
+ * Accepts: MAIL stream
+ *         close options
+ */
+
+void mmdf_close (MAILSTREAM *stream,long options)
+{
+  int silent = stream->silent;
+  stream->silent = T;          /* go silent */
+                               /* expunge if requested */
+  if (options & CL_EXPUNGE) mmdf_expunge (stream,NIL,NIL);
+                               /* else dump final checkpoint */
+  else if (LOCAL->dirty) mmdf_check (stream);
+  stream->silent = silent;     /* restore old silence state */
+  mmdf_abort (stream);         /* now punt the file and local data */
+}
+\f
+/* MMDF mail fetch message header
+ * Accepts: MAIL stream
+ *         message # to fetch
+ *         pointer to returned header text length
+ *         option flags
+ * Returns: message header in RFC822 format
+ */
+
+                               /* lines to filter from header */
+static STRINGLIST *mmdf_hlines = NIL;
+
+char *mmdf_header (MAILSTREAM *stream,unsigned long msgno,
+                  unsigned long *length,long flags)
+{
+  MESSAGECACHE *elt;
+  unsigned char *s,*t,*tl;
+  *length = 0;                 /* default to empty */
+  if (flags & FT_UID) return "";/* UID call "impossible" */
+  elt = mail_elt (stream,msgno);/* get cache */
+  if (!mmdf_hlines) {          /* once only code */
+    STRINGLIST *lines = mmdf_hlines = mail_newstringlist ();
+    lines->text.size = strlen ((char *) (lines->text.data =
+                                        (unsigned char *) "Status"));
+    lines = lines->next = mail_newstringlist ();
+    lines->text.size = strlen ((char *) (lines->text.data =
+                                        (unsigned char *) "X-Status"));
+    lines = lines->next = mail_newstringlist ();
+    lines->text.size = strlen ((char *) (lines->text.data =
+                                        (unsigned char *) "X-Keywords"));
+    lines = lines->next = mail_newstringlist ();
+    lines->text.size = strlen ((char *) (lines->text.data =
+                                        (unsigned char *) "X-UID"));
+    lines = lines->next = mail_newstringlist ();
+    lines->text.size = strlen ((char *) (lines->text.data =
+                                        (unsigned char *) "X-IMAP"));
+    lines = lines->next = mail_newstringlist ();
+    lines->text.size = strlen ((char *) (lines->text.data =
+                                        (unsigned char *) "X-IMAPbase"));
+  }
+                               /* go to header position */
+  lseek (LOCAL->fd,elt->private.special.offset +
+        elt->private.msg.header.offset,L_SET);
+\f
+  if (flags & FT_INTERNAL) {   /* initial data OK? */
+    if (elt->private.msg.header.text.size > LOCAL->buflen) {
+      fs_give ((void **) &LOCAL->buf);
+      LOCAL->buf = (char *) fs_get ((LOCAL->buflen =
+                                    elt->private.msg.header.text.size) + 1);
+    }
+                               /* read message */
+    read (LOCAL->fd,LOCAL->buf,elt->private.msg.header.text.size);
+                               /* got text, tie off string */
+    LOCAL->buf[*length = elt->private.msg.header.text.size] = '\0';
+                               /* squeeze out CRs (in case from PC) */
+    for (s = t = LOCAL->buf,tl = LOCAL->buf + *length; t < tl; t++)
+      if (*t != '\r') *s++ = *t;
+    *s = '\0';
+    *length = s - LOCAL->buf;  /* adjust length */
+  }
+  else {                       /* need to make a CRLF version */
+    read (LOCAL->fd,s = (char *) fs_get (elt->private.msg.header.text.size+1),
+         elt->private.msg.header.text.size);
+                               /* tie off string, and convert to CRLF */
+    s[elt->private.msg.header.text.size] = '\0';
+    *length = strcrlfcpy (&LOCAL->buf,&LOCAL->buflen,s,
+                         elt->private.msg.header.text.size);
+    fs_give ((void **) &s);    /* free readin buffer */
+                               /* squeeze out spurious CRs */
+    for (s = t = LOCAL->buf,tl = LOCAL->buf + *length; t < tl; t++)
+      if ((*t != '\r') || (t[1] == '\n')) *s++ = *t;
+    *s = '\0';
+    *length = s - LOCAL->buf;  /* adjust length */
+  }
+  *length = mail_filter (LOCAL->buf,*length,mmdf_hlines,FT_NOT);
+  return (char *) LOCAL->buf;  /* return processed copy */
+}
+\f
+/* MMDF mail fetch message text
+ * Accepts: MAIL stream
+ *         message # to fetch
+ *         pointer to returned stringstruct
+ *         option flags
+ * Returns: T on success, NIL if failure
+ */
+
+long mmdf_text (MAILSTREAM *stream,unsigned long msgno,STRING *bs,long flags)
+{
+  char *s;
+  unsigned long i;
+  MESSAGECACHE *elt;
+                               /* UID call "impossible" */
+  if (flags & FT_UID) return NIL;
+  elt = mail_elt (stream,msgno);/* get cache element */
+                               /* if message not seen */
+  if (!(flags & FT_PEEK) && !elt->seen) {
+                               /* mark message seen and dirty */
+    elt->seen = elt->private.dirty = LOCAL->dirty = T;
+    MM_FLAGS (stream,msgno);
+  }
+  s = mmdf_text_work (stream,elt,&i,flags);
+  INIT (bs,mail_string,s,i);   /* set up stringstruct */
+  return T;                    /* success */
+}
+\f
+/* MMDF mail fetch message text worker routine
+ * Accepts: MAIL stream
+ *         message cache element
+ *         pointer to returned header text length
+ *         option flags
+ */
+
+char *mmdf_text_work (MAILSTREAM *stream,MESSAGECACHE *elt,
+                     unsigned long *length,long flags)
+{
+  FDDATA d;
+  STRING bs;
+  unsigned char c,*s,*t,*tl,tmp[CHUNKSIZE];
+                               /* go to text position */
+  lseek (LOCAL->fd,elt->private.special.offset +
+        elt->private.msg.text.offset,L_SET);
+  if (flags & FT_INTERNAL) {   /* initial data OK? */
+    if (elt->private.msg.text.text.size > LOCAL->buflen) {
+      fs_give ((void **) &LOCAL->buf);
+      LOCAL->buf = (char *) fs_get ((LOCAL->buflen =
+                                    elt->private.msg.text.text.size) + 1);
+    }
+                               /* read message */
+    read (LOCAL->fd,LOCAL->buf,elt->private.msg.text.text.size);
+                               /* got text, tie off string */
+    LOCAL->buf[*length = elt->private.msg.text.text.size] = '\0';
+                               /* squeeze out CRs (in case from PC) */
+    for (s = t = LOCAL->buf,tl = LOCAL->buf + *length; t < tl; t++)
+      if (*t != '\r') *s++ = *t;
+    *s = '\0';
+    *length = s - LOCAL->buf;  /* adjust length */
+    return (char *) LOCAL->buf;
+  }
+\f
+                               /* have it cached already? */
+  if (elt->private.uid != LOCAL->uid) {
+                               /* not cached, cache it now */
+    LOCAL->uid = elt->private.uid;
+                               /* is buffer big enough? */
+    if (elt->rfc822_size > LOCAL->text.size) {
+      /* excessively conservative, but the right thing is too hard to do */
+      fs_give ((void **) &LOCAL->text.data);
+      LOCAL->text.data = (unsigned char *)
+       fs_get ((LOCAL->text.size = elt->rfc822_size) + 1);
+    }
+    d.fd = LOCAL->fd;          /* yes, set up file descriptor */
+    d.pos = elt->private.special.offset + elt->private.msg.text.offset;
+    d.chunk = tmp;             /* initial buffer chunk */
+    d.chunksize = CHUNKSIZE;   /* file chunk size */
+    INIT (&bs,fd_string,&d,elt->private.msg.text.text.size);
+    for (s = (char *) LOCAL->text.data; SIZE (&bs);) switch (c = SNX (&bs)) {
+    case '\r':                 /* carriage return seen */
+      break;
+    case '\n':
+      *s++ = '\r';             /* insert a CR */
+    default:
+      *s++ = c;                        /* copy characters */
+    }
+    *s = '\0';                 /* tie off buffer */
+                               /* calculate length of cached data */
+    LOCAL->textlen = s - LOCAL->text.data;
+  }
+  *length = LOCAL->textlen;    /* return from cache */
+  return (char *) LOCAL->text.data;
+}
+\f
+/* MMDF per-message modify flag
+ * Accepts: MAIL stream
+ *         message cache element
+ */
+
+void mmdf_flagmsg (MAILSTREAM *stream,MESSAGECACHE *elt)
+{
+                               /* only after finishing */
+  if (elt->valid) elt->private.dirty = LOCAL->dirty = T;
+}
+
+
+/* MMDF mail ping mailbox
+ * Accepts: MAIL stream
+ * Returns: T if stream alive, else NIL
+ */
+
+long mmdf_ping (MAILSTREAM *stream)
+{
+  DOTLOCK lock;
+  struct stat sbuf;
+  long reparse;
+                               /* big no-op if not readwrite */
+  if (LOCAL && (LOCAL->ld >= 0) && !stream->lock) {
+    if (stream->rdonly) {      /* does he want to give up readwrite? */
+                               /* checkpoint if we changed something */
+      if (LOCAL->dirty) mmdf_check (stream);
+      flock (LOCAL->ld,LOCK_UN);/* release readwrite lock */
+      close (LOCAL->ld);       /* close the readwrite lock file */
+      LOCAL->ld = -1;          /* no more readwrite lock fd */
+      unlink (LOCAL->lname);   /* delete the readwrite lock file */
+    }
+    else {                     /* see if need to reparse */
+      if (!(reparse = (long) mail_parameters (NIL,GET_NETFSSTATBUG,NIL))) {
+                               /* get current mailbox size */
+       if (LOCAL->fd >= 0) fstat (LOCAL->fd,&sbuf);
+       else if (stat (stream->mailbox,&sbuf)) {
+         sprintf (LOCAL->buf,"Mailbox stat failed, aborted: %s",
+                  strerror (errno));
+         MM_LOG (LOCAL->buf,ERROR);
+         mmdf_abort (stream);
+         return NIL;
+       }
+       reparse = (sbuf.st_size != LOCAL->filesize);
+      }
+                               /* parse if mailbox changed */
+      if ((LOCAL->ddirty || reparse) && mmdf_parse (stream,&lock,LOCK_EX)) {
+                               /* force checkpoint if double-dirty */
+       if (LOCAL->ddirty) mmdf_rewrite (stream,NIL,&lock,NIL);
+                               /* unlock mailbox */
+       else mmdf_unlock (LOCAL->fd,stream,&lock);
+       mail_unlock (stream);   /* and stream */
+                               /* done with critical */
+       MM_NOCRITICAL (stream);
+      }
+    }
+  }
+  return LOCAL ? LONGT : NIL;  /* return if still alive */
+}
+\f
+/* MMDF mail check mailbox
+ * Accepts: MAIL stream
+ */
+
+void mmdf_check (MAILSTREAM *stream)
+{
+  DOTLOCK lock;
+                               /* parse and lock mailbox */
+  if (LOCAL && (LOCAL->ld >= 0) && !stream->lock &&
+      mmdf_parse (stream,&lock,LOCK_EX)) {
+                               /* any unsaved changes? */
+    if (LOCAL->dirty && mmdf_rewrite (stream,NIL,&lock,NIL)) {
+      if (!stream->silent) MM_LOG ("Checkpoint completed",NIL);
+    }
+                               /* no checkpoint needed, just unlock */
+    else mmdf_unlock (LOCAL->fd,stream,&lock);
+    mail_unlock (stream);      /* unlock the stream */
+    MM_NOCRITICAL (stream);    /* done with critical */
+  }
+}
+
+
+/* MMDF mail expunge mailbox
+ * Accepts: MAIL stream
+ *         sequence to expunge if non-NIL
+ *         expunge options
+ * Returns: T, always
+ */
+
+long mmdf_expunge (MAILSTREAM *stream,char *sequence,long options)
+{
+  long ret;
+  unsigned long i;
+  DOTLOCK lock;
+  char *msg = NIL;
+  if (ret = (sequence ? ((options & EX_UID) ?
+                        mail_uid_sequence (stream,sequence) :
+                        mail_sequence (stream,sequence)) : LONGT) &&
+      LOCAL && (LOCAL->ld >= 0) && !stream->lock &&
+      mmdf_parse (stream,&lock,LOCK_EX)) {
+                               /* check expunged messages if not dirty */
+    for (i = 1; !LOCAL->dirty && (i <= stream->nmsgs); i++) {
+      MESSAGECACHE *elt = mail_elt (stream,i);
+      if (mail_elt (stream,i)->deleted) LOCAL->dirty = T;
+    }
+    if (!LOCAL->dirty) {       /* not dirty and no expunged messages */
+      mmdf_unlock (LOCAL->fd,stream,&lock);
+      msg = "No messages deleted, so no update needed";
+    }
+    else if (mmdf_rewrite (stream,&i,&lock,sequence ? LONGT : NIL)) {
+      if (i) sprintf (msg = LOCAL->buf,"Expunged %lu messages",i);
+      else msg = "Mailbox checkpointed, but no messages expunged";
+    }
+                               /* rewrite failed */
+    else mmdf_unlock (LOCAL->fd,stream,&lock);
+    mail_unlock (stream);      /* unlock the stream */
+    MM_NOCRITICAL (stream);    /* done with critical */
+    if (msg && !stream->silent) MM_LOG (msg,NIL);
+  }
+  else if (!stream->silent)
+    MM_LOG ("Expunge ignored on readonly mailbox",WARN);
+  return ret;
+}
+\f
+/* MMDF mail copy message(s)
+ * Accepts: MAIL stream
+ *         sequence
+ *         destination mailbox
+ *         copy options
+ * Returns: T if copy successful, else NIL
+ */
+
+long mmdf_copy (MAILSTREAM *stream,char *sequence,char *mailbox,long options)
+{
+  struct stat sbuf;
+  int fd;
+  char *s,file[MAILTMPLEN];
+  DOTLOCK lock;
+  time_t tp[2];
+  unsigned long i,j;
+  MESSAGECACHE *elt;
+  long ret = T;
+  mailproxycopy_t pc =
+    (mailproxycopy_t) mail_parameters (stream,GET_MAILPROXYCOPY,NIL);
+  copyuid_t cu = (copyuid_t) (mail_parameters (NIL,GET_USERHASNOLIFE,NIL) ?
+                             NIL : mail_parameters (NIL,GET_COPYUID,NIL));
+  SEARCHSET *source = cu ? mail_newsearchset () : NIL;
+  SEARCHSET *dest = cu ? mail_newsearchset () : NIL;
+  MAILSTREAM *tstream = NIL;
+  if (!((options & CP_UID) ? mail_uid_sequence (stream,sequence) :
+       mail_sequence (stream,sequence))) return NIL;
+                               /* make sure destination is valid */
+  if (!(mmdf_valid (mailbox) || !errno))
+    switch (errno) {
+    case ENOENT:               /* no such file? */
+      if (compare_cstring (mailbox,"INBOX")) {
+       MM_NOTIFY (stream,"[TRYCREATE] Must create mailbox before copy",NIL);
+       return NIL;
+      }
+      if (pc) return (*pc) (stream,sequence,mailbox,options);
+      mmdf_create (NIL,"INBOX");/* create empty INBOX */
+    case EACCES:               /* file protected */
+      sprintf (LOCAL->buf,"Can't access destination: %.80s",mailbox);
+      MM_LOG (LOCAL->buf,ERROR);
+      return NIL;
+    case EINVAL:
+      if (pc) return (*pc) (stream,sequence,mailbox,options);
+      sprintf (LOCAL->buf,"Invalid MMDF-format mailbox name: %.80s",mailbox);
+      MM_LOG (LOCAL->buf,ERROR);
+      return NIL;
+    default:
+      if (pc) return (*pc) (stream,sequence,mailbox,options);
+      sprintf (LOCAL->buf,"Not a MMDF-format mailbox: %.80s",mailbox);
+      MM_LOG (LOCAL->buf,ERROR);
+      return NIL;
+    }
+\f
+                               /* try to open rewrite for UIDPLUS */
+  if ((tstream = mail_open_work (&mmdfdriver,NIL,mailbox,
+                                OP_SILENT|OP_NOKOD)) && tstream->rdonly)
+    tstream = mail_close (tstream);
+  if (cu && !tstream) {                /* wanted a COPYUID? */
+    sprintf (LOCAL->buf,"Unable to write-open mailbox for COPYUID: %.80s",
+            mailbox);
+    MM_LOG (LOCAL->buf,WARN);
+    cu = NIL;                  /* don't try to do COPYUID */
+  }
+  LOCAL->buf[0] = '\0';
+  MM_CRITICAL (stream);                /* go critical */
+  if ((fd = mmdf_lock (dummy_file (file,mailbox),O_WRONLY|O_APPEND,
+                      (long) mail_parameters (NIL,GET_MBXPROTECTION,NIL),
+                      &lock,LOCK_EX)) < 0) {
+    MM_NOCRITICAL (stream);    /* done with critical */
+    sprintf (LOCAL->buf,"Can't open destination mailbox: %s",strerror (errno));
+    MM_LOG (LOCAL->buf,ERROR); /* log the error */
+    return NIL;                        /* failed */
+  }
+  fstat (fd,&sbuf);            /* get current file size */
+                               /* write all requested messages to mailbox */
+  for (i = 1; ret && (i <= stream->nmsgs); i++)
+    if ((elt = mail_elt (stream,i))->sequence) {
+      lseek (LOCAL->fd,elt->private.special.offset,L_SET);
+      read (LOCAL->fd,LOCAL->buf,elt->private.special.text.size);
+      if (write (fd,LOCAL->buf,elt->private.special.text.size) < 0) ret = NIL;
+      else {                   /* internal header succeeded */
+       s = mmdf_header (stream,i,&j,FT_INTERNAL);
+                               /* header size, sans trailing newline */
+       if (j && (s[j - 2] == '\n')) j--;
+       if (write (fd,s,j) < 0) ret = NIL;
+       else {                  /* message header succeeded */
+         j = tstream ?         /* write UIDPLUS data if have readwrite */
+           mmdf_xstatus (stream,LOCAL->buf,elt,++(tstream->uid_last),LONGT) :
+           mmdf_xstatus (stream,LOCAL->buf,elt,NIL,NIL);
+         if (write (fd,LOCAL->buf,j) < 0) ret = NIL;
+         else {                /* message status succeeded */
+           s = mmdf_text_work (stream,elt,&j,FT_INTERNAL);
+           if ((write (fd,s,j) < 0) || (write (fd,mmdfhdr,MMDFHDRLEN) < 0))
+             ret = NIL;
+           else if (cu) {      /* need to pass back new UID? */
+             mail_append_set (source,mail_uid (stream,i));
+             mail_append_set (dest,tstream->uid_last);
+           }
+         }
+       }
+      }
+    }
+\f
+  if (!ret || fsync (fd)) {    /* force out the update */
+    sprintf (LOCAL->buf,"Message copy failed: %s",strerror (errno));
+    ftruncate (fd,sbuf.st_size);
+    ret = NIL;
+  }
+                               /* force UIDVALIDITY assignment now */
+  if (tstream && !tstream->uid_validity) tstream->uid_validity = time (0);
+                               /* return sets if doing COPYUID */
+  if (cu && ret) (*cu) (stream,mailbox,tstream->uid_validity,source,dest);
+  else {                       /* flush any sets we may have built */
+    mail_free_searchset (&source);
+    mail_free_searchset (&dest);
+  }
+  tp[1] = time (0);            /* set mtime to now */
+  if (ret) tp[0] = tp[1] - 1;  /* set atime to now-1 if successful copy */
+  else tp[0] =                 /* else preserve \Marked status */
+        ((sbuf.st_ctime > sbuf.st_atime) || (sbuf.st_mtime > sbuf.st_atime)) ?
+        sbuf.st_atime : tp[1];
+  utime (file,tp);             /* set the times */
+  mmdf_unlock (fd,NIL,&lock);  /* unlock and close mailbox */
+  if (tstream) {               /* update last UID if we can */
+    MMDFLOCAL *local = (MMDFLOCAL *) tstream->local;
+    local->dirty = T;          /* do a rewrite */
+    local->appending = T;      /* but not at the cost of marking as old */
+    tstream = mail_close (tstream);
+  }
+                               /* log the error */
+  if (!ret) MM_LOG (LOCAL->buf,ERROR);
+                               /* delete if requested message */
+  else if (options & CP_MOVE) for (i = 1; i <= stream->nmsgs; i++)
+    if ((elt = mail_elt (stream,i))->sequence)
+      elt->deleted = elt->private.dirty = LOCAL->dirty = T;
+  MM_NOCRITICAL (stream);      /* release critical */
+  return ret;
+}
+\f
+/* MMDF mail append message from stringstruct
+ * Accepts: MAIL stream
+ *         destination mailbox
+ *         append callback
+ *         data for callback
+ * Returns: T if append successful, else NIL
+ */
+
+#define BUFLEN 8*MAILTMPLEN
+
+long mmdf_append (MAILSTREAM *stream,char *mailbox,append_t af,void *data)
+{
+  struct stat sbuf;
+  int fd;
+  unsigned long i;
+  char *flags,*date,buf[BUFLEN],tmp[MAILTMPLEN],file[MAILTMPLEN];
+  time_t tp[2];
+  FILE *sf,*df;
+  MESSAGECACHE elt;
+  DOTLOCK lock;
+  STRING *message;
+  unsigned long uidlocation = 0;
+  appenduid_t au = (appenduid_t)
+    (mail_parameters (NIL,GET_USERHASNOLIFE,NIL) ? NIL :
+     mail_parameters (NIL,GET_APPENDUID,NIL));
+  SEARCHSET *dst = au ? mail_newsearchset () : NIL;
+  long ret = LONGT;
+  MAILSTREAM *tstream = NIL;
+                               /* default stream to prototype */
+  if (!stream) {               /* stream specified? */
+    stream = &mmdfproto;       /* no, default stream to prototype */
+    for (i = 0; i < NUSERFLAGS && stream->user_flags[i]; ++i)
+      fs_give ((void **) &stream->user_flags[i]);
+  }
+  if (!mmdf_valid (mailbox)) switch (errno) {
+  case ENOENT:                 /* no such file? */
+    if (compare_cstring (mailbox,"INBOX")) {
+      MM_NOTIFY (stream,"[TRYCREATE] Must create mailbox before append",NIL);
+      return NIL;
+    }
+    mmdf_create (NIL,"INBOX"); /* create empty INBOX */
+  case 0:                      /* merely empty file? */
+    tstream = stream;
+    break;
+  case EACCES:                 /* file protected */
+    sprintf (tmp,"Can't access destination: %.80s",mailbox);
+    MM_LOG (tmp,ERROR);
+    return NIL;
+  case EINVAL:
+    sprintf (tmp,"Invalid MMDF-format mailbox name: %.80s",mailbox);
+    MM_LOG (tmp,ERROR);
+    return NIL;
+  default:
+    sprintf (tmp,"Not a MMDF-format mailbox: %.80s",mailbox);
+    MM_LOG (tmp,ERROR);
+    return NIL;
+  }
+                               /* get sniffing stream for keywords */
+  else if (!(tstream = mail_open (NIL,mailbox,
+                                 OP_READONLY|OP_SILENT|OP_NOKOD|OP_SNIFF))) {
+    sprintf (tmp,"Unable to examine mailbox for APPEND: %.80s",mailbox);
+    MM_LOG (tmp,ERROR);
+    return NIL;
+  }
+\f
+                               /* get first message */
+  if (!MM_APPEND (af) (tstream,data,&flags,&date,&message)) return NIL;
+  if (!(sf = tmpfile ())) {    /* must have scratch file */
+    sprintf (tmp,".%lx.%lx",(unsigned long) time (0),(unsigned long)getpid ());
+    if (!stat (tmp,&sbuf) || !(sf = fopen (tmp,"wb+"))) {
+      sprintf (tmp,"Unable to create scratch file: %.80s",strerror (errno));
+      MM_LOG (tmp,ERROR);
+      return NIL;
+    }
+    unlink (tmp);
+  }
+  do {                         /* parse date */
+    if (!date) rfc822_date (date = tmp);
+    if (!mail_parse_date (&elt,date)) {
+      sprintf (tmp,"Bad date in append: %.80s",date);
+      MM_LOG (tmp,ERROR);
+    }
+    else {                     /* user wants to suppress time zones? */
+      if (mail_parameters (NIL,GET_NOTIMEZONES,NIL)) {
+       time_t when = mail_longdate (&elt);
+       date = ctime (&when);   /* use traditional date */
+      }
+                               /* use POSIX-style date */
+      else date = mail_cdate (tmp,&elt);
+      if (!SIZE (message)) MM_LOG ("Append of zero-length message",ERROR);
+      else if (!mmdf_collect_msg (tstream,sf,flags,date,message)) {
+       sprintf (tmp,"Error writing scratch file: %.80s",strerror (errno));
+       MM_LOG (tmp,ERROR);
+      }
+                               /* get next message */
+      else if (MM_APPEND (af) (tstream,data,&flags,&date,&message)) continue;
+    }
+    fclose (sf);               /* punt scratch file */
+    return NIL;                        /* give up */
+  } while (message);           /* until no more messages */
+  if (fflush (sf)) {
+    sprintf (tmp,"Error finishing scratch file: %.80s",strerror (errno));
+    MM_LOG (tmp,ERROR);
+    fclose (sf);               /* punt scratch file */
+    return NIL;                        /* give up */
+  }
+  i = ftell (sf);              /* size of scratch file */
+  if (tstream != stream) tstream = mail_close (tstream);
+\f
+  MM_CRITICAL (stream);                /* go critical */
+                               /* try to open readwrite for UIDPLUS */
+  if ((tstream = mail_open_work (&mmdfdriver,NIL,mailbox,
+                                OP_SILENT|OP_NOKOD)) && tstream->rdonly)
+    tstream = mail_close (tstream);
+  if (au && !tstream) {                /* wanted an APPENDUID? */
+    sprintf (tmp,"Unable to re-open mailbox for APPENDUID: %.80s",mailbox);
+    MM_LOG (tmp,WARN);
+    au = NIL;
+  }
+  if (((fd = mmdf_lock (dummy_file (file,mailbox),O_WRONLY|O_APPEND,
+                       (long) mail_parameters (NIL,GET_MBXPROTECTION,NIL),
+                       &lock,LOCK_EX)) < 0) ||
+      !(df = fdopen (fd,"ab"))) {
+    MM_NOCRITICAL (stream);    /* done with critical */
+    sprintf (tmp,"Can't open append mailbox: %s",strerror (errno));
+    MM_LOG (tmp,ERROR);
+    return NIL;
+  }
+  fstat (fd,&sbuf);            /* get current file size */
+  rewind (sf);
+  tp[1] = time (0);            /* set mtime to now */
+                               /* write all messages */
+  if (!mmdf_append_msgs (tstream,sf,df,au ? dst : NIL) ||
+      (fflush (df) == EOF) || fsync (fd)) {
+    sprintf (buf,"Message append failed: %s",strerror (errno));
+    MM_LOG (buf,ERROR);
+    ftruncate (fd,sbuf.st_size);
+    tp[0] =                    /* preserve \Marked status */
+      ((sbuf.st_ctime > sbuf.st_atime) || (sbuf.st_mtime > sbuf.st_atime)) ?
+      sbuf.st_atime : tp[1];
+    ret = NIL;                 /* return error */
+  }
+  else tp[0] = tp[1] - 1;      /* set atime to now-1 if successful copy */
+  utime (file,tp);             /* set the times */
+  fclose (sf);                 /* done with scratch file */
+                               /* force UIDVALIDITY assignment now */
+  if (tstream && !tstream->uid_validity) tstream->uid_validity = time (0);
+                               /* return sets if doing APPENDUID */
+  if (au && ret) (*au) (mailbox,tstream->uid_validity,dst);
+  else mail_free_searchset (&dst);
+  mmdf_unlock (fd,NIL,&lock);  /* unlock and close mailbox */
+  fclose (df);
+  if (tstream) {               /* update last UID if we can */
+    MMDFLOCAL *local = (MMDFLOCAL *) tstream->local;
+    local->dirty = T;          /* do a rewrite */
+    local->appending = T;      /* but not at the cost of marking as old */
+    tstream = mail_close (tstream);
+  }
+  MM_NOCRITICAL (stream);      /* release critical */
+  return ret;
+}
+\f
+/* Collect and write single message to append scratch file
+ * Accepts: MAIL stream
+ *         scratch file
+ *         flags
+ *         date
+ *         message stringstruct
+ * Returns: NIL if write error, else T
+ */
+
+int mmdf_collect_msg (MAILSTREAM *stream,FILE *sf,char *flags,char *date,
+                    STRING *msg)
+{
+  unsigned char *s,*t;
+  unsigned long uf;
+  long f = mail_parse_flags (stream,flags,&uf);
+                               /* write metadata, note date ends with NL */
+  if (fprintf (sf,"%ld %lu %s",f,SIZE (msg) + 1,date) < 0) return NIL;
+  while (uf)                   /* write user flags */    
+    if ((s = stream->user_flags[find_rightmost_bit (&uf)]) &&
+       (fprintf (sf," %s",s) < 0)) return NIL;
+  if (putc ('\n',sf) == EOF) return NIL;
+  while (SIZE (msg)) {         /* copy text to scratch file */
+    for (s = (unsigned char *) msg->curpos, t = s + msg->cursize; s < t; ++s)
+      if (!*s) *s = 0x80;      /* disallow NUL */
+                               /* write buffered text */
+    if (fwrite (msg->curpos,1,msg->cursize,sf) == msg->cursize)
+      SETPOS (msg,GETPOS (msg) + msg->cursize);
+    else return NIL;           /* failed */
+  }
+                               /* write trailing newline and return */
+  return (putc ('\n',sf) == EOF) ? NIL : T;
+}
+\f
+/* Append messages from scratch file to mailbox
+ * Accepts: MAIL stream
+ *         source file
+ *         destination file
+ *         uidset to update if non-NIL
+ * Returns: T if success, NIL if failure
+ */
+
+int mmdf_append_msgs (MAILSTREAM *stream,FILE *sf,FILE *df,SEARCHSET *set)
+{
+  int c;
+  long f;
+  unsigned long i,j;
+  char *x,tmp[MAILTMPLEN];
+  int hdrp = T;
+                               /* get message metadata line */
+  while (fgets (tmp,MAILTMPLEN,sf)) {
+    if (!(isdigit (tmp[0]) && strchr (tmp,'\n'))) return NIL;
+    f = strtol (tmp,&x,10);    /* get flags */
+    if (!((*x++ == ' ') && isdigit (*x))) return NIL;
+    i = strtoul (x,&x,10);     /* get message size */
+    if ((*x++ != ' ') ||       /* build initial header */
+       (fprintf (df,"%sFrom %s@%s %sStatus: ",mmdfhdr,myusername(),
+                 mylocalhost(),x) < 0) ||
+       (f&fSEEN && (putc ('R',df) == EOF)) ||
+       (fputs ("\nX-Status: ",df) == EOF) ||
+       (f&fDELETED && (putc ('D',df) == EOF)) ||
+       (f&fFLAGGED && (putc ('F',df) == EOF)) ||
+       (f&fANSWERED && (putc ('A',df) == EOF)) ||
+       (f&fDRAFT && (putc ('T',df) == EOF)) ||
+       (fputs ("\nX-Keywords:",df) == EOF)) return NIL;
+                               /* copy keywords */
+    while ((c = getc (sf)) != '\n') switch (c) {
+    case EOF:
+      return NIL;
+    default:
+      if (putc (c,df) == EOF) return NIL;
+    }
+    if ((putc ('\n',df) == EOF) ||
+       (set && (fprintf (df,"X-UID: %lu\n",++(stream->uid_last)) < 0)))
+      return NIL;
+\f
+    for (c = '\n'; i && fgets (tmp,MAILTMPLEN,sf); c = tmp[j-1]) {
+                               /* get read line length */
+      if (i < (j = strlen (tmp))) fatal ("mmdf_append_msgs overrun");
+      i -= j;                  /* number of bytes left */
+                               /* squish out ^A and CRs (note copies NUL) */
+      for (x = tmp; x = strpbrk (x,"\01\r"); --j) memmove (x,x+1,j-(x-tmp));
+      if (!j) continue;                /* do nothing if line emptied */
+                               /* start of line? */
+      if ((c == '\n')) switch (tmp[0]) {
+      case 'S': case 's':      /* possible "Status:" */
+       if (hdrp && (j > 6) && ((tmp[1] == 't') || (tmp[1] == 'T')) &&
+           ((tmp[2] == 'a') || (tmp[2] == 'A')) &&
+           ((tmp[3] == 't') || (tmp[3] == 'T')) &&
+           ((tmp[4] == 'u') || (tmp[4] == 'U')) &&
+           ((tmp[5] == 's') || (tmp[5] == 'S')) && (tmp[6] == ':') &&
+           (fputs ("X-Original-",df) == EOF)) return NIL;
+       break;
+      case 'X': case 'x':      /* possible X-??? header */
+       if (hdrp && (tmp[1] == '-') &&
+                               /* possible X-UID: */
+           (((j > 5) && ((tmp[2] == 'U') || (tmp[2] == 'u')) &&
+             ((tmp[3] == 'I') || (tmp[3] == 'i')) &&
+             ((tmp[4] == 'D') || (tmp[4] == 'd')) && (tmp[5] == ':')) ||
+                               /* possible X-IMAP: */
+            ((j > 6) && ((tmp[2] == 'I') || (tmp[2] == 'i')) &&
+             ((tmp[3] == 'M') || (tmp[3] == 'm')) &&
+             ((tmp[4] == 'A') || (tmp[4] == 'a')) &&
+             ((tmp[5] == 'P') || (tmp[5] == 'p')) &&
+             ((tmp[6] == ':') ||
+                               /* or X-IMAPbase: */
+              ((j > 10) && ((tmp[6] == 'b') || (tmp[6] == 'B')) &&
+               ((tmp[7] == 'a') || (tmp[7] == 'A')) &&
+               ((tmp[8] == 's') || (tmp[8] == 'S')) &&
+               ((tmp[9] == 'e') || (tmp[9] == 'E')) && (tmp[10] == ':')))) ||
+                               /* possible X-Status: */
+            ((j > 8) && ((tmp[2] == 'S') || (tmp[2] == 's')) &&
+             ((tmp[3] == 't') || (tmp[3] == 'T')) &&
+             ((tmp[4] == 'a') || (tmp[4] == 'A')) &&
+             ((tmp[5] == 't') || (tmp[5] == 'T')) &&
+             ((tmp[6] == 'u') || (tmp[6] == 'U')) &&
+             ((tmp[7] == 's') || (tmp[7] == 'S')) && (tmp[8] == ':')) ||
+                               /* possible X-Keywords: */
+            ((j > 10) && ((tmp[2] == 'K') || (tmp[2] == 'k')) &&
+             ((tmp[3] == 'e') || (tmp[3] == 'E')) &&
+             ((tmp[4] == 'y') || (tmp[4] == 'Y')) &&
+             ((tmp[5] == 'w') || (tmp[5] == 'W')) &&
+             ((tmp[6] == 'o') || (tmp[6] == 'O')) &&
+             ((tmp[7] == 'r') || (tmp[7] == 'R')) &&
+             ((tmp[8] == 'd') || (tmp[8] == 'D')) &&
+             ((tmp[9] == 's') || (tmp[9] == 'S')) && (tmp[10] == ':'))) &&
+           (fputs ("X-Original-",df) == EOF)) return NIL;
+       break;
+      case '\n':               /* blank line */
+       hdrp = NIL;
+       break;
+      default:                 /* nothing to do */
+       break;
+      }
+                               /* just write the line */
+      if (fwrite (tmp,1,j,df) != j) return NIL;
+    }
+                               /* make sure read entire msg & wrote trailer */
+    if (i || (fputs (mmdfhdr,df) == EOF)) return NIL;
+                               /* update set */
+    if (stream) mail_append_set (set,stream->uid_last);
+  }
+  return T;
+}
+\f
+/* Internal routines */
+
+
+/* MMDF mail abort stream
+ * Accepts: MAIL stream
+ */
+
+void mmdf_abort (MAILSTREAM *stream)
+{
+  if (LOCAL) {                 /* only if a file is open */
+    if (LOCAL->fd >= 0) close (LOCAL->fd);
+    if (LOCAL->ld >= 0) {      /* have a mailbox lock? */
+      flock (LOCAL->ld,LOCK_UN);/* yes, release the lock */
+      close (LOCAL->ld);       /* close the lock file */
+      unlink (LOCAL->lname);   /* and delete it */
+    }
+    if (LOCAL->lname) fs_give ((void **) &LOCAL->lname);
+                               /* free local text buffers */
+    if (LOCAL->buf) fs_give ((void **) &LOCAL->buf);
+    if (LOCAL->text.data) fs_give ((void **) &LOCAL->text.data);
+    if (LOCAL->linebuf) fs_give ((void **) &LOCAL->linebuf);
+    if (LOCAL->line) fs_give ((void **) &LOCAL->line);
+                               /* nuke the local data */
+    fs_give ((void **) &stream->local);
+    stream->dtb = NIL;         /* log out the DTB */
+  }
+}
+\f
+/* MMDF open and lock mailbox
+ * Accepts: file name to open/lock
+ *         file open mode
+ *         destination buffer for lock file name
+ *         type of locking operation (LOCK_SH or LOCK_EX)
+ */
+
+int mmdf_lock (char *file,int flags,int mode,DOTLOCK *lock,int op)
+{
+  int fd;
+  blocknotify_t bn = (blocknotify_t) mail_parameters (NIL,GET_BLOCKNOTIFY,NIL);
+  (*bn) (BLOCK_FILELOCK,NIL);
+                               /* try locking the easy way */
+  if (dotlock_lock (file,lock,-1)) {
+                               /* got dotlock file, easy open */
+    if ((fd = open (file,flags,mode)) >= 0) flock (fd,op);
+    else dotlock_unlock (lock);        /* open failed, free the dotlock */
+  }
+                               /* no dot lock file, open file now */
+  else if ((fd = open (file,flags,mode)) >= 0) {
+                               /* try paranoid way to make a dot lock file */
+    if (dotlock_lock (file,lock,fd)) {
+      close (fd);              /* get fresh fd in case of timing race */
+      if ((fd = open (file,flags,mode)) >= 0) flock (fd,op);
+                               /* open failed, free the dotlock */
+      else dotlock_unlock (lock);
+    }
+    else flock (fd,op);                /* paranoid way failed, just flock() it */
+  }
+  (*bn) (BLOCK_NONE,NIL);
+  return fd;
+}
+\f
+/* MMDF unlock and close mailbox
+ * Accepts: file descriptor
+ *         (optional) mailbox stream to check atime/mtime
+ *         (optional) lock file name
+ */
+
+void mmdf_unlock (int fd,MAILSTREAM *stream,DOTLOCK *lock)
+{
+  if (stream) {                        /* need to muck with times? */
+    struct stat sbuf;
+    time_t tp[2];
+    time_t now = time (0);
+    fstat (fd,&sbuf);          /* get file times */
+    if (LOCAL->ld >= 0) {      /* yes, readwrite session? */
+      tp[0] = now;             /* set atime to now */
+                               /* set mtime to (now - 1) if necessary */
+      tp[1] = (now > sbuf.st_mtime) ? sbuf.st_mtime : now - 1;
+    }
+    else if (stream->recent) { /* readonly with recent messages */
+      if ((sbuf.st_atime >= sbuf.st_mtime) ||
+         (sbuf.st_atime >= sbuf.st_ctime))
+                               /* keep past mtime, whack back atime */
+       tp[0] = (tp[1] = (sbuf.st_mtime < now) ? sbuf.st_mtime : now) - 1;
+      else now = 0;            /* no time change needed */
+    }
+                               /* readonly with no recent messages */
+    else if ((sbuf.st_atime < sbuf.st_mtime) ||
+            (sbuf.st_atime < sbuf.st_ctime)) {
+      tp[0] = now;             /* set atime to now */
+                               /* set mtime to (now - 1) if necessary */
+      tp[1] = (now > sbuf.st_mtime) ? sbuf.st_mtime : now - 1;
+    }
+    else now = 0;              /* no time change needed */
+                               /* set the times, note change */
+    if (now && !utime (stream->mailbox,tp)) LOCAL->filetime = tp[1];
+  }
+  flock (fd,LOCK_UN);          /* release flock'ers */
+  if (!stream) close (fd);     /* close the file if no stream */
+  dotlock_unlock (lock);       /* flush the lock file if any */
+}
+\f
+/* MMDF mail parse and lock mailbox
+ * Accepts: MAIL stream
+ *         space to write lock file name
+ *         type of locking operation
+ * Returns: T if parse OK, critical & mailbox is locked shared; NIL if failure
+ */
+
+int mmdf_parse (MAILSTREAM *stream,DOTLOCK *lock,int op)
+{
+  int ti,zn,m;
+  unsigned long i,j,k;
+  unsigned char c,*s,*t,*u,tmp[MAILTMPLEN],date[30];
+  int retain = T;
+  unsigned long nmsgs = stream->nmsgs;
+  unsigned long prevuid = nmsgs ? mail_elt (stream,nmsgs)->private.uid : 0;
+  unsigned long recent = stream->recent;
+  unsigned long oldnmsgs = stream->nmsgs;
+  short silent = stream->silent;
+  short pseudoseen = NIL;
+  struct stat sbuf;
+  STRING bs;
+  FDDATA d;
+  MESSAGECACHE *elt;
+  mail_lock (stream);          /* guard against recursion or pingers */
+                               /* toss out previous descriptor */
+  if (LOCAL->fd >= 0) close (LOCAL->fd);
+  MM_CRITICAL (stream);                /* open and lock mailbox (shared OK) */
+  if ((LOCAL->fd = mmdf_lock (stream->mailbox,(LOCAL->ld >= 0) ?
+                             O_RDWR : O_RDONLY,
+                             (long)mail_parameters(NIL,GET_MBXPROTECTION,NIL),
+                             lock,op)) < 0) {
+    sprintf (tmp,"Mailbox open failed, aborted: %s",strerror (errno));
+    MM_LOG (tmp,ERROR);
+    mmdf_abort (stream);
+    mail_unlock (stream);
+    MM_NOCRITICAL (stream);    /* done with critical */
+    return NIL;
+  }
+  fstat (LOCAL->fd,&sbuf);     /* get status */
+                               /* validate change in size */
+  if (sbuf.st_size < LOCAL->filesize) {
+    sprintf (tmp,"Mailbox shrank from %lu to %lu bytes, aborted",
+            (unsigned long) LOCAL->filesize,(unsigned long) sbuf.st_size);
+    MM_LOG (tmp,ERROR);                /* this is pretty bad */
+    mmdf_unlock (LOCAL->fd,stream,lock);
+    mmdf_abort (stream);
+    mail_unlock (stream);
+    MM_NOCRITICAL (stream);    /* done with critical */
+    return NIL;
+  }
+\f
+                               /* new data? */
+  else if (i = sbuf.st_size - LOCAL->filesize) {
+    d.fd = LOCAL->fd;          /* yes, set up file descriptor */
+    d.pos = LOCAL->filesize;   /* get to that position in the file */
+    d.chunk = LOCAL->buf;      /* initial buffer chunk */
+    d.chunksize = CHUNKSIZE;   /* file chunk size */
+    INIT (&bs,fd_string,&d,i); /* initialize stringstruct */
+                               /* skip leading whitespace for broken MTAs */
+    while (((c = CHR (&bs)) == '\n') || (c == '\r') ||
+          (c == ' ') || (c == '\t')) SNX (&bs);
+    if (SIZE (&bs)) {          /* read new data */
+                               /* remember internal header position */
+      j = LOCAL->filesize + GETPOS (&bs);
+      s = mmdf_mbxline (stream,&bs,&i);
+      stream->silent = T;      /* quell main program new message events */
+      do {                     /* read MMDF header */
+       if (!(i && ISMMDF (s))){/* see if valid MMDF header */
+         sprintf (tmp,"Unexpected changes to mailbox (try restarting): %.20s",
+                  (char *) s);
+                               /* see if we can back up to a line */
+         if (i && (j > MMDFHDRLEN)) {
+           SETPOS (&bs,j -= MMDFHDRLEN);
+                               /* read previous line */
+           s = mmdf_mbxline (stream,&bs,&i);
+                               /* kill the error if it looks good */
+           if (i && ISMMDF (s)) tmp[0] = '\0';
+         }
+         if (tmp[0]) {
+           MM_LOG (tmp,ERROR);
+           mmdf_unlock (LOCAL->fd,stream,lock);
+           mmdf_abort (stream);
+           mail_unlock (stream);
+           MM_NOCRITICAL (stream);
+           return NIL;
+         }
+       }
+                               /* instantiate first new message */
+       mail_exists (stream,++nmsgs);
+       (elt = mail_elt (stream,nmsgs))->valid = T;
+       recent++;               /* assume recent by default */
+       elt->recent = T;
+                               /* note position/size of internal header */
+       elt->private.special.offset = j;
+       elt->private.special.text.size = i;
+\f
+       s = mmdf_mbxline (stream,&bs,&i);
+       ti = 0;                 /* assume not a valid date */
+       zn = 0,t = NIL;
+       if (i) VALID (s,t,ti,zn);
+       if (ti) {               /* generate plausible IMAPish date string */
+                               /* this is also part of header */
+         elt->private.special.text.size += i;
+         date[2] = date[6] = date[20] = '-'; date[11] = ' ';
+         date[14] = date[17] = ':';
+                               /* dd */
+         date[0] = t[ti - 2]; date[1] = t[ti - 1];
+                               /* mmm */
+         date[3] = t[ti - 6]; date[4] = t[ti - 5]; date[5] = t[ti - 4];
+                               /* hh */
+         date[12] = t[ti + 1]; date[13] = t[ti + 2];
+                               /* mm */
+         date[15] = t[ti + 4]; date[16] = t[ti + 5];
+         if (t[ti += 6]==':'){ /* ss */
+           date[18] = t[++ti]; date[19] = t[++ti];
+           ti++;               /* move to space */
+         }
+         else date[18] = date[19] = '0';
+                               /* yy -- advance over timezone if necessary */
+         if (zn == ti) ti += (((t[zn+1] == '+') || (t[zn+1] == '-')) ? 6 : 4);
+         date[7] = t[ti + 1]; date[8] = t[ti + 2];
+         date[9] = t[ti + 3]; date[10] = t[ti + 4];
+                               /* zzz */
+         t = zn ? (t + zn + 1) : (unsigned char *) "LCL";
+         date[21] = *t++; date[22] = *t++; date[23] = *t++;
+         if ((date[21] != '+') && (date[21] != '-')) date[24] = '\0';
+         else {                /* numeric time zone */
+           date[24] = *t++; date[25] = *t++;
+           date[26] = '\0'; date[20] = ' ';
+         }
+                               /* set internal date */
+         if (!mail_parse_date (elt,date)) {
+           sprintf (tmp,"Unable to parse internal date: %s",(char *) date);
+           MM_LOG (tmp,WARN);
+         }
+       }
+       else {                  /* make date from file date */
+         struct tm *tm = gmtime (&sbuf.st_mtime);
+         elt->day = tm->tm_mday; elt->month = tm->tm_mon + 1;
+         elt->year = tm->tm_year + 1900 - BASEYEAR;
+         elt->hours = tm->tm_hour; elt->minutes = tm->tm_min;
+         elt->seconds = tm->tm_sec;
+         elt->zhours = 0; elt->zminutes = 0;
+         t = NIL;              /* suppress line read */
+       }
+                               /* header starts here */
+       elt->private.msg.header.offset = elt->private.special.text.size;
+\f
+       do {                    /* look for message body */
+         j = GETPOS (&bs);     /* note position before line */
+         if (t) s = t = mmdf_mbxline (stream,&bs,&i);
+         else t = s;           /* this line read was suppressed */
+         if (ISMMDF (s)) {     /* found terminator in header? */
+           SETPOS (&bs,j);     /* oops, back up before line */
+                               /* must insert a newline */
+           elt->private.spare.data++;
+           break;              /* punt */
+         }
+                               /* this line is part of header */
+         elt->private.msg.header.text.size += i;
+         if (i) switch (*s) {  /* check header lines */
+         case 'X':             /* possible X-???: line */
+           if (s[1] == '-') {  /* must be immediately followed by hyphen */
+                               /* X-Status: becomes Status: in S case */
+             if (s[2] == 'S' && s[3] == 't' && s[4] == 'a' && s[5] == 't' &&
+                 s[6] == 'u' && s[7] == 's' && s[8] == ':') s += 2;
+                               /* possible X-Keywords */
+             else if (s[2] == 'K' && s[3] == 'e' && s[4] == 'y' &&
+                      s[5] == 'w' && s[6] == 'o' && s[7] == 'r' &&
+                      s[8] == 'd' && s[9] == 's' && s[10] == ':') {
+               SIZEDTEXT uf;
+               retain = NIL;   /* don't retain continuation */
+               s += 11;        /* flush leading whitespace */
+               while (*s && (*s != '\n') && ((*s != '\r') || (s[1] != '\n'))){
+                 while (*s == ' ') s++;
+                               /* find end of keyword */
+                 if (!(u = strpbrk (s," \n\r"))) u = s + strlen (s);
+                               /* got a keyword? */
+                 if ((k = (u - s)) <= MAXUSERFLAG) {
+                   uf.data = (unsigned char *) s;
+                   uf.size = k;
+                   for (j = 0; (j < NUSERFLAGS) && stream->user_flags[j]; ++j)
+                     if (!compare_csizedtext (stream->user_flags[j],&uf)) {
+                       elt->user_flags |= ((long) 1) << j;
+                       break;
+                     }
+                 }
+                 s = u;        /* advance to next keyword */
+               }
+               break;
+             }
+\f
+                               /* possible X-IMAP */
+             else if ((s[2] == 'I') && (s[3] == 'M') && (s[4] == 'A') &&
+                      (s[5] == 'P') && ((m = (s[6] == ':')) ||
+                                        ((s[6] == 'b') && (s[7] == 'a') &&
+                                         (s[8] == 's') && (s[9] == 'e') &&
+                                         (s[10] == ':')))) {
+               retain = NIL;   /* don't retain continuation */
+               if ((nmsgs == 1) && !stream->uid_validity) {
+                               /* advance to data */
+                 s += m ? 7 : 11;
+                               /* flush whitespace */
+                 while (*s == ' ') s++;
+                 j = 0;        /* slurp UID validity */
+                               /* found a digit? */
+                 while (isdigit (*s)) {
+                   j *= 10;    /* yes, add it in */
+                   j += *s++ - '0';
+                 }
+                               /* flush whitespace */
+                 while (*s == ' ') s++;
+                               /* must have valid UID validity and UID last */
+                 if (j && isdigit (*s)) {
+                               /* pseudo-header seen if X-IMAP */
+                   if (m) pseudoseen = LOCAL->pseudo = T;
+                               /* save UID validity */
+                   stream->uid_validity = j;
+                   j = 0;      /* slurp UID last */
+                   while (isdigit (*s)) {
+                     j *= 10;  /* yes, add it in */
+                     j += *s++ - '0';
+                   }
+                               /* save UID last */
+                   stream->uid_last = j;
+                               /* process keywords */
+                   for (j = 0; (*s != '\n') && ((*s != '\r')||(s[1] != '\n'));
+                        s = u,j++) {
+                               /* flush leading whitespace */
+                     while (*s == ' ') s++;
+                     u = strpbrk (s," \n\r");
+                               /* got a keyword? */
+                     if ((j < NUSERFLAGS) && ((k = (u - s)) <= MAXUSERFLAG)) {
+                       if (stream->user_flags[j])
+                         fs_give ((void **) &stream->user_flags[j]);
+                       stream->user_flags[j] = (char *) fs_get (k + 1);
+                       strncpy (stream->user_flags[j],s,k);
+                       stream->user_flags[j][k] = '\0';
+                     }
+                   }
+                 }
+               }
+               break;
+             }
+\f
+                               /* possible X-UID */
+             else if (s[2] == 'U' && s[3] == 'I' && s[4] == 'D' &&
+                      s[5] == ':') {
+               retain = NIL;   /* don't retain continuation */
+                               /* only believe if have a UID validity */
+               if (stream->uid_validity && ((nmsgs > 1) || !pseudoseen)) {
+                 s += 6;       /* advance to UID value */
+                               /* flush whitespace */
+                 while (*s == ' ') s++;
+                 j = 0;
+                               /* found a digit? */
+                 while (isdigit (*s)) {
+                   j *= 10;    /* yes, add it in */
+                   j += *s++ - '0';
+                 }
+                               /* flush remainder of line */
+                 while (*s != '\n') s++;
+                               /* make sure not duplicated */
+                 if (elt->private.uid)
+                   sprintf (tmp,"Message %lu UID %lu already has UID %lu",
+                            pseudoseen ? elt->msgno - 1 : elt->msgno,
+                            j,elt->private.uid);
+                               /* make sure UID doesn't go backwards */
+                 else if (j <= prevuid)
+                   sprintf (tmp,"Message %lu UID %lu less than %lu",
+                            pseudoseen ? elt->msgno - 1 : elt->msgno,
+                            j,prevuid + 1);
+#if 0  /* this is currently broken by UIDPLUS */
+                               /* or skip by mailbox's recorded last */
+                 else if (j > stream->uid_last)
+                   sprintf (tmp,"Message %lu UID %lu greater than last %lu",
+                            pseudoseen ? elt->msgno - 1 : elt->msgno,
+                            j,stream->uid_last);
+#endif
+                 else {        /* normal UID case */
+                   prevuid = elt->private.uid = j;
+#if 1  /* temporary kludge for UIDPLUS */
+                   if (prevuid > stream->uid_last) {
+                     stream->uid_last = prevuid;
+                     LOCAL->ddirty = LOCAL->dirty = T;
+                   }               
+#endif
+                   break;      /* exit this cruft */
+                 }
+                 MM_LOG (tmp,WARN);
+                               /* invalidate UID validity */
+                 stream->uid_validity = 0;
+                 elt->private.uid = 0;
+               }
+               break;
+             }
+           }
+                               /* otherwise fall into S case */
+\f
+         case 'S':             /* possible Status: line */
+           if (s[0] == 'S' && s[1] == 't' && s[2] == 'a' && s[3] == 't' &&
+               s[4] == 'u' && s[5] == 's' && s[6] == ':') {
+             retain = NIL;     /* don't retain continuation */
+             s += 6;           /* advance to status flags */
+             do switch (*s++) {/* parse flags */
+             case 'R':         /* message read */
+               elt->seen = T;
+               break;
+             case 'O':         /* message old */
+               if (elt->recent) {
+                 elt->recent = NIL;
+                 recent--;     /* it really wasn't recent */
+               }
+               break;
+             case 'D':         /* message deleted */
+               elt->deleted = T;
+               break;
+             case 'F':         /* message flagged */
+               elt->flagged = T;
+               break;
+             case 'A':         /* message answered */
+               elt->answered = T;
+               break;
+             case 'T':         /* message is a draft */
+               elt->draft = T;
+               break;
+             default:          /* some other crap */
+               break;
+             } while (*s && (*s != '\n') && ((*s != '\r') || (s[1] != '\n')));
+             break;            /* all done */
+           }
+                               /* otherwise fall into default case */
+\f
+         default:              /* ordinary header line */
+           if ((*s == 'S') || (*s == 's') ||
+               (((*s == 'X') || (*s == 'x')) && (s[1] == '-'))) {
+             unsigned char *e,*v;
+                               /* must match what mail_filter() does */
+             for (u = s,v = tmp,e = u + min (i,MAILTMPLEN - 1);
+                  (u < e) && ((c = (*u ? *u : (*u = ' '))) != ':') &&
+                  ((c > ' ') || ((c != ' ') && (c != '\t') &&
+                                 (c != '\r') && (c != '\n')));
+                  *v++ = *u++);
+             *v = '\0';        /* tie off */
+                               /* matches internal header? */
+             if (!compare_cstring (tmp,"STATUS") ||
+                 !compare_cstring (tmp,"X-STATUS") ||
+                 !compare_cstring (tmp,"X-KEYWORDS") ||
+                 !compare_cstring (tmp,"X-UID") ||
+                 !compare_cstring (tmp,"X-IMAP") ||
+                 !compare_cstring (tmp,"X-IMAPBASE")) {
+               char err[MAILTMPLEN];
+               sprintf (err,"Discarding bogus %s header in message %lu",
+                        (char *) tmp,elt->msgno);
+               MM_LOG (err,WARN);
+               retain = NIL;   /* don't retain continuation */
+               break;          /* different case or something */
+             }
+           }
+                               /* retain or non-continuation? */
+           if (retain || ((*s != ' ') && (*s != '\t'))) {
+             retain = T;       /* retaining continuation now */
+                               /* line length in LF format newline */
+             for (j = k = 0; j < i; ++j) if (s[j] != '\r') ++k;
+                               /* "internal" header size */
+             elt->private.spare.data += k;
+                               /* message size */
+             elt->rfc822_size += k + 1;
+           }
+           else {
+             char err[MAILTMPLEN];
+             sprintf (err,"Discarding bogus continuation in msg %lu: %.80s",
+                     elt->msgno,(char *) s);
+             if (u = strpbrk (err,"\r\n")) *u = '\0';
+             MM_LOG (err,WARN);
+             break;            /* different case or something */
+           }
+           break;
+         }
+       } while (i && (*t != '\n') && ((*t != '\r') || (t[1] != '\n')));
+                               /* "internal" header sans trailing newline */
+       if (i) elt->private.spare.data--;
+                               /* assign a UID if none found */
+       if (((nmsgs > 1) || !pseudoseen) && !elt->private.uid) {
+         prevuid = elt->private.uid = ++stream->uid_last;
+         elt->private.dirty = T;
+       }
+       else elt->private.dirty = elt->recent;
+\f
+                               /* note size of header, location of text */
+       elt->private.msg.header.text.size =
+         (elt->private.msg.text.offset =
+          (LOCAL->filesize + GETPOS (&bs)) - elt->private.special.offset) -
+            elt->private.special.text.size;
+                               /* note current position */
+       j = LOCAL->filesize + GETPOS (&bs);
+       if (i) do {             /* look for next message */
+         s = mmdf_mbxline (stream,&bs,&i);
+         if (i) {              /* got new data? */
+           if (ISMMDF (s)) break;
+           else {              /* not a header line, add it to message */
+             elt->rfc822_size += i;
+             for (j = 0; j < i; ++j) switch (s[j]) {
+             case '\r':        /* squeeze out CRs */
+               elt->rfc822_size -= 1;
+               break;
+             case '\n':        /* LF becomes CRLF */
+               elt->rfc822_size += 1;
+               break;
+             default:
+               break;
+             }
+                               /* update current position */
+             j = LOCAL->filesize + GETPOS (&bs);
+           }
+         }
+       } while (i);            /* until found a header */
+       elt->private.msg.text.text.size = j -
+         (elt->private.special.offset + elt->private.msg.text.offset);
+       if (i) {                /* get next header line */
+                               /* remember first internal header position */
+         j = LOCAL->filesize + GETPOS (&bs);
+         s = mmdf_mbxline (stream,&bs,&i);
+       }
+                               /* until end of buffer */
+      } while (!stream->sniff && i);
+      if (pseudoseen) {                /* flush pseudo-message if present */
+                               /* decrement recent count */
+       if (mail_elt (stream,1)->recent) recent--;
+                               /* and the exists count */
+       mail_exists (stream,nmsgs--);
+       mail_expunged(stream,1);/* fake an expunge of that message */
+      }
+                               /* need to start a new UID validity? */
+      if (!stream->uid_validity) {
+       stream->uid_validity = time (0);
+                               /* in case a whiner with no life */
+       if (mail_parameters (NIL,GET_USERHASNOLIFE,NIL))
+         stream->uid_nosticky = T;
+       else if (nmsgs) {       /* don't bother if empty file */
+                               /* make dirty to restart UID epoch */
+         LOCAL->ddirty = LOCAL->dirty = T;
+                               /* need to rewrite msg 1 if not pseudo */
+         if (!LOCAL->pseudo) mail_elt (stream,1)->private.dirty = T;
+         MM_LOG ("Assigning new unique identifiers to all messages",NIL);
+       }
+      }
+      stream->nmsgs = oldnmsgs;        /* whack it back down */
+      stream->silent = silent; /* restore old silent setting */
+                               /* notify upper level of new mailbox sizes */
+      mail_exists (stream,nmsgs);
+      mail_recent (stream,recent);
+                               /* mark dirty so O flags are set */
+      if (recent) LOCAL->dirty = T;
+    }
+  }
+                               /* no change, don't babble if never got time */
+  else if (LOCAL->filetime && LOCAL->filetime != sbuf.st_mtime)
+    MM_LOG ("New mailbox modification time but apparently no changes",WARN);
+                               /* update parsed file size and time */
+  LOCAL->filesize = sbuf.st_size;
+  LOCAL->filetime = sbuf.st_mtime;
+  return T;                    /* return the winnage */
+}
+\f
+/* MMDF read line from mailbox
+ * Accepts: mail stream
+ *         stringstruct
+ *         pointer to line size
+ * Returns: pointer to input line
+ */
+
+char *mmdf_mbxline (MAILSTREAM *stream,STRING *bs,unsigned long *size)
+{
+  unsigned long i,j,k,m;
+  char *s,*t,*te;
+  char *ret = "";
+                               /* flush old buffer */
+  if (LOCAL->line) fs_give ((void **) &LOCAL->line);
+                               /* if buffer needs refreshing */
+  if (!bs->cursize) SETPOS (bs,GETPOS (bs));
+  if (SIZE (bs)) {             /* find newline */
+                               /* end of fast scan */
+    te = (t = (s = bs->curpos) + bs->cursize) - 12;
+    while (s < te) if ((*s++ == '\n') || (*s++ == '\n') || (*s++ == '\n') ||
+                      (*s++ == '\n') || (*s++ == '\n') || (*s++ == '\n') ||
+                      (*s++ == '\n') || (*s++ == '\n') || (*s++ == '\n') ||
+                      (*s++ == '\n') || (*s++ == '\n') || (*s++ == '\n')) {
+      --s;                     /* back up */
+      break;                   /* exit loop */
+    }
+                               /* final character-at-a-time scan */
+    while ((s < t) && (*s != '\n')) ++s;
+                               /* difficult case if line spans buffer */
+    if ((i = s - bs->curpos) == bs->cursize) {
+                               /* have space in line buffer? */
+      if (i > LOCAL->linebuflen) {
+       fs_give ((void **) &LOCAL->linebuf);
+       LOCAL->linebuf = (char *) fs_get (LOCAL->linebuflen = i);
+      }
+                               /* remember what we have so far */
+      memcpy (LOCAL->linebuf,bs->curpos,i);
+                               /* load next buffer */
+      SETPOS (bs,k = GETPOS (bs) + i);
+                               /* end of fast scan */
+      te = (t = (s = bs->curpos) + bs->cursize) - 12;
+                               /* fast scan in overlap buffer */
+      while (s < te) if ((*s++ == '\n') || (*s++ == '\n') || (*s++ == '\n') ||
+                        (*s++ == '\n') || (*s++ == '\n') || (*s++ == '\n') ||
+                        (*s++ == '\n') || (*s++ == '\n') || (*s++ == '\n') ||
+                        (*s++ == '\n') || (*s++ == '\n') || (*s++ == '\n')) {
+       --s;                    /* back up */
+       break;                  /* exit loop */
+      }
+\f
+                               /* final character-at-a-time scan */
+      while ((s < t) && (*s != '\n')) ++s;
+                               /* huge line? */
+      if ((j = s - bs->curpos) == bs->cursize) {
+       SETPOS (bs,GETPOS (bs) + j);
+                               /* look for end of line (s-l-o-w!!) */
+       for (m = SIZE (bs); m && (SNX (bs) != '\n'); --m,++j);
+       SETPOS (bs,k);          /* go back to where it started */
+      }
+                               /* got size of data, make buffer for return */
+      ret = LOCAL->line = (char *) fs_get (i + j + 2);
+                               /* copy first chunk */
+      memcpy (ret,LOCAL->linebuf,i);
+      while (j) {              /* copy remainder */
+       if (!bs->cursize) SETPOS (bs,GETPOS (bs));
+       memcpy (ret + i,bs->curpos,k = min (j,bs->cursize));
+       i += k;                 /* account for this much read in */
+       j -= k;
+       bs->curpos += k;        /* increment new position */
+       bs->cursize -= k;       /* eat that many bytes */
+      }
+                               /* read newline at end */
+      if (SIZE (bs)) ret[i++] = SNX (bs);
+      ret[i] = '\0';           /* makes debugging easier */
+    }
+    else {                     /* this is easy */
+      ret = bs->curpos;                /* string it at this position */
+      bs->curpos += ++i;       /* increment new position */
+      bs->cursize -= i;                /* eat that many bytes */
+    }
+    *size = i;                 /* return that to user */
+  }
+  else *size = 0;              /* end of data, return empty */
+                               /* embedded MMDF header at end of line? */
+  if ((*size > sizeof (MMDFHDRTXT)) &&
+      (s = ret + *size - (i = sizeof (MMDFHDRTXT) - 1)) && ISMMDF (s)) {
+    SETPOS (bs,GETPOS (bs) - i);/* back up to start of MMDF header */
+    *size -= i;                        /* reduce length of line */
+    ret[*size - 1] = '\n';     /* force newline at end */
+  }
+  return ret;
+}
+\f
+/* MMDF make pseudo-header
+ * Accepts: MAIL stream
+ *         buffer to write pseudo-header
+ * Returns: length of pseudo-header
+ */
+
+unsigned long mmdf_pseudo (MAILSTREAM *stream,char *hdr)
+{
+  int i;
+  char *s,tmp[MAILTMPLEN];
+  time_t now = time (0);
+  rfc822_fixed_date (tmp);
+  sprintf (hdr,"%sFrom %s %.24s\nDate: %s\nFrom: %s <%s@%.80s>\nSubject: %s\nMessage-ID: <%lu@%.80s>\nX-IMAP: %010lu %010lu",
+          mmdfhdr,pseudo_from,ctime (&now),
+          tmp,pseudo_name,pseudo_from,mylocalhost (),pseudo_subject,
+          (unsigned long) now,mylocalhost (),stream->uid_validity,
+          stream->uid_last);
+  for (s = hdr + strlen (hdr),i = 0; i < NUSERFLAGS; ++i)
+    if (stream->user_flags[i])
+      sprintf (s += strlen (s)," %s",stream->user_flags[i]);
+  sprintf (s += strlen (s),"\nStatus: RO\n\n%s\n%s",pseudo_msg,mmdfhdr);
+  return strlen (hdr);
+}
+\f
+/* MMDF make status string
+ * Accepts: MAIL stream
+ *         destination string to write
+ *         message cache entry
+ *         UID to write if non-zero (else use elt->private.uid)
+ *         non-zero flag to write UID (.LT. 0 to write UID base info too)
+ * Returns: length of string
+ */
+
+unsigned long mmdf_xstatus (MAILSTREAM *stream,char *status,MESSAGECACHE *elt,
+                           unsigned long uid,long flag)
+{
+  char *t,stack[64];
+  char *s = status;
+  unsigned long n;
+  int pad = 50;
+  int sticky = uid ? T : !stream->uid_nosticky;
+  /* This used to use sprintf(), but thanks to certain cretinous C libraries
+     with horribly slow implementations of sprintf() I had to change it to this
+     mess.  At least it should be fast. */
+  if ((flag < 0) && sticky) {  /* need to write X-IMAPbase: header? */
+    *s++ = 'X'; *s++ = '-'; *s++ = 'I'; *s++ = 'M'; *s++ = 'A'; *s++ = 'P';
+    *s++ = 'b'; *s++ = 'a'; *s++ = 's'; *s++ = 'e'; *s++ = ':'; *s++ = ' ';
+    t = stack;
+    n = stream->uid_validity;  /* push UID validity digits on the stack */
+    do *t++ = (char) (n % 10) + '0';
+    while (n /= 10);
+                               /* pop UID validity digits from stack */
+    while (t > stack) *s++ = *--t;
+   *s++ = ' ';
+    n = stream->uid_last;      /* push UID last digits on the stack */
+    do *t++ = (char) (n % 10) + '0';
+    while (n /= 10);
+                               /* pop UID last digits from stack */
+    while (t > stack) *s++ = *--t;
+    for (n = 0; n < NUSERFLAGS; ++n) if (t = stream->user_flags[n])
+      for (*s++ = ' '; *t; *s++ = *t++);
+    *s++ = '\n';
+    pad += 30;                 /* increased padding if have IMAPbase */
+  }
+  *s++ = 'S'; *s++ = 't'; *s++ = 'a'; *s++ = 't'; *s++ = 'u'; *s++ = 's';
+  *s++ = ':'; *s++ = ' ';
+  if (elt->seen) *s++ = 'R';
+                               /* only write O if have a UID */
+  if (flag && (!elt->recent || !LOCAL->appending)) *s++ = 'O';
+  *s++ = '\n';
+  *s++ = 'X'; *s++ = '-'; *s++ = 'S'; *s++ = 't'; *s++ = 'a'; *s++ = 't';
+  *s++ = 'u'; *s++ = 's'; *s++ = ':'; *s++ = ' ';
+  if (elt->deleted) *s++ = 'D';
+  if (elt->flagged) *s++ = 'F';
+  if (elt->answered) *s++ = 'A';
+  if (elt->draft) *s++ = 'T';
+    *s++ = '\n';
+\f
+  if (sticky) {                        /* only do this if UIDs sticky */
+    *s++ = 'X'; *s++ = '-'; *s++ = 'K'; *s++ = 'e'; *s++ = 'y'; *s++ = 'w';
+    *s++ = 'o'; *s++ = 'r'; *s++ = 'd'; *s++ = 's'; *s++ = ':';
+    if (n = elt->user_flags) do {
+      *s++ = ' ';
+      for (t = stream->user_flags[find_rightmost_bit (&n)]; *t; *s++ = *t++);
+    } while (n);
+    n = s - status;            /* get size of stuff so far */
+                               /* pad X-Keywords to make size constant */
+    if (n < pad) for (n = pad - n; n > 0; --n) *s++ = ' ';
+    *s++ = '\n';
+    if (flag) {                        /* want to include UID? */
+      t = stack;
+                               /* push UID digits on the stack */
+      n = uid ? uid : elt->private.uid;
+      do *t++ = (char) (n % 10) + '0';
+      while (n /= 10);
+      *s++ = 'X'; *s++ = '-'; *s++ = 'U'; *s++ = 'I'; *s++ = 'D'; *s++ = ':';
+      *s++ = ' ';
+                               /* pop UID from stack */
+      while (t > stack) *s++ = *--t;
+      *s++ = '\n';
+    }
+  }
+  *s++ = '\n'; *s = '\0';      /* end of extended message status */
+  return s - status;           /* return size of resulting string */
+}
+\f
+/* Rewrite mailbox file
+ * Accepts: MAIL stream, must be critical and locked
+ *         return pointer to number of expunged messages if want expunge
+ *         lock file name
+ *         expunge sequence, not deleted flag
+ * Returns: T if success and mailbox unlocked, NIL if failure
+ */
+
+#define OVERFLOWBUFLEN 8192    /* initial overflow buffer length */
+
+long mmdf_rewrite (MAILSTREAM *stream,unsigned long *nexp,DOTLOCK *lock,
+                  long flags)
+{
+  MESSAGECACHE *elt;
+  MMDFFILE f;
+  char *s;
+  time_t tp[2];
+  long ret,flag;
+  unsigned long i,j;
+  unsigned long recent = stream->recent;
+  unsigned long size = LOCAL->pseudo ? mmdf_pseudo (stream,LOCAL->buf) : 0;
+  if (nexp) *nexp = 0;         /* initially nothing expunged */
+                               /* calculate size of mailbox after rewrite */
+  for (i = 1,flag = LOCAL->pseudo ? 1 : -1; i <= stream->nmsgs; i++) {
+    elt = mail_elt (stream,i); /* get cache */
+    if (!(nexp && elt->deleted && (flags ? elt->sequence : T))) {
+                               /* add RFC822 size of this message */
+      size += elt->private.special.text.size + elt->private.spare.data +
+       mmdf_xstatus (stream,LOCAL->buf,elt,NIL,flag) +
+         elt->private.msg.text.text.size + MMDFHDRLEN;
+      flag = 1;                        /* only count X-IMAPbase once */
+    }
+  }
+                               /* no messages, has a life, and no pseudo */
+  if (!size && !mail_parameters (NIL,GET_USERHASNOLIFE,NIL)) {
+    LOCAL->pseudo = T;         /* so make a pseudo-message now */
+    size = mmdf_pseudo (stream,LOCAL->buf);
+  }
+                               /* extend the file as necessary */
+  if (ret = mmdf_extend (stream,size)) {
+    /* Set up buffered I/O file structure
+     * curpos  current position being written through buffering
+     * filepos current position being written physically to the disk
+     * bufpos  current position being written in the buffer
+     * protect current maximum position that can be written to the disk
+     *         before buffering is forced
+     * The code tries to buffer so that that disk is written in multiples of
+     * OVERBLOWBUFLEN bytes.
+     */
+    f.stream = stream;         /* note mail stream */
+    f.curpos = f.filepos = 0;  /* start of file */
+    f.protect = stream->nmsgs ?        /* initial protection pointer */
+    mail_elt (stream,1)->private.special.offset : 8192;
+    f.bufpos = f.buf = (char *) fs_get (f.buflen = OVERFLOWBUFLEN);
+\f
+    if (LOCAL->pseudo)         /* update pseudo-header */
+      mmdf_write (&f,LOCAL->buf,mmdf_pseudo (stream,LOCAL->buf));
+                               /* loop through all messages */
+    for (i = 1,flag = LOCAL->pseudo ? 1 : -1; i <= stream->nmsgs;) {
+      elt = mail_elt (stream,i);/* get cache */
+                               /* expunge this message? */
+      if (nexp && elt->deleted && (flags ? elt->sequence : T)) {
+                               /* one less recent message */
+       if (elt->recent) --recent;
+       mail_expunged(stream,i);/* notify upper levels */
+       ++*nexp;                /* count up one more expunged message */
+      }
+      else {                   /* preserve this message */
+       i++;                    /* advance to next message */
+       if ((flag < 0) ||       /* need to rewrite message? */
+           elt->private.dirty || (f.curpos != elt->private.special.offset) ||
+           (elt->private.msg.header.text.size !=
+            (elt->private.spare.data +
+             mmdf_xstatus (stream,LOCAL->buf,elt,NIL,flag)))) {
+         unsigned long newoffset = f.curpos;
+                               /* yes, seek to internal header */
+         lseek (LOCAL->fd,elt->private.special.offset,L_SET);
+         read (LOCAL->fd,LOCAL->buf,elt->private.special.text.size);
+                               /* see if need to squeeze out a CR */
+         if (LOCAL->buf[elt->private.special.text.size - 2] == '\r') {
+           LOCAL->buf[--elt->private.special.text.size - 1] = '\n';
+           --size;             /* squeezed out a CR from PC */
+         }
+                               /* protection pointer moves to RFC822 header */
+         f.protect = elt->private.special.offset +
+           elt->private.msg.header.offset;
+                               /* write internal header */
+         mmdf_write (&f,LOCAL->buf,elt->private.special.text.size);
+                               /* get RFC822 header */
+         s = mmdf_header (stream,elt->msgno,&j,FT_INTERNAL);
+                               /* in case this got decremented */
+         elt->private.msg.header.offset = elt->private.special.text.size;
+                               /* header size, sans trailing newline */
+         if ((j < 2) || (s[j - 2] == '\n')) j--;
+                               /* this can happen if CRs were squeezed */
+         if (j < elt->private.spare.data) {
+                               /* so fix up counts */
+           size -= elt->private.spare.data - j;
+           elt->private.spare.data = j;
+         }
+         else if (j != elt->private.spare.data)
+           fatal ("header size inconsistent");
+                               /* protection pointer moves to RFC822 text */
+         f.protect = elt->private.special.offset +
+           elt->private.msg.text.offset;
+         mmdf_write (&f,s,j);  /* write RFC822 header */
+                               /* write status and UID */
+         mmdf_write (&f,LOCAL->buf,
+                     j = mmdf_xstatus (stream,LOCAL->buf,elt,NIL,flag));
+         flag = 1;             /* only write X-IMAPbase once */
+                               /* new file header size */
+         elt->private.msg.header.text.size = elt->private.spare.data + j;
+\f
+                               /* did text move? */
+         if (f.curpos != f.protect) {
+                               /* get message text */
+           s = mmdf_text_work (stream,elt,&j,FT_INTERNAL);
+                               /* this can happen if CRs were squeezed */
+           if (j < elt->private.msg.text.text.size) {
+                               /* so fix up counts */
+             size -= elt->private.msg.text.text.size - j;
+             elt->private.msg.text.text.size = j;
+           }
+                               /* can't happen it says here */
+           else if (j > elt->private.msg.text.text.size)
+             fatal ("text size inconsistent");
+                               /* new text offset, status/UID may change it */
+           elt->private.msg.text.offset = f.curpos - newoffset;
+                               /* protection pointer moves to next message */
+           f.protect = (i <= stream->nmsgs) ?
+             mail_elt (stream,i)->private.special.offset :
+               (f.curpos + j + MMDFHDRLEN);
+           mmdf_write (&f,s,j);/* write text */
+                               /* write trailing newline */
+           mmdf_write (&f,mmdfhdr,MMDFHDRLEN);
+         }
+         else {                /* tie off header and status */
+           mmdf_write (&f,NIL,NIL);
+           f.curpos = f.protect =/* restart everything at end of message */
+             f.filepos += elt->private.msg.text.text.size + MMDFHDRLEN;
+         }
+                               /* new internal header offset */
+         elt->private.special.offset = newoffset;
+         elt->private.dirty =NIL;/* message is now clean */
+       }
+       else {                  /* no need to rewrite this message */
+                               /* tie off previous message if needed */
+         mmdf_write (&f,NIL,NIL);
+         f.curpos = f.protect =/* restart everything at end of message */
+           f.filepos += elt->private.special.text.size +
+             elt->private.msg.header.text.size +
+               elt->private.msg.text.text.size + MMDFHDRLEN;
+       }
+      }
+    }
+\f
+    mmdf_write (&f,NIL,NIL);   /* tie off final message */
+    if (size != f.filepos) fatal ("file size inconsistent");
+    fs_give ((void **) &f.buf);        /* free buffer */
+                               /* make sure tied off */
+    ftruncate (LOCAL->fd,LOCAL->filesize = size);
+    fsync (LOCAL->fd);         /* make sure the updates take */
+    if (size && (flag < 0)) fatal ("lost UID base information");
+                               /* no longer dirty */
+    LOCAL->ddirty = LOCAL->dirty = NIL;
+                               /* notify upper level of new mailbox sizes */
+    mail_exists (stream,stream->nmsgs);
+    mail_recent (stream,recent);
+                               /* set atime to now, mtime a second earlier */
+    tp[1] = (tp[0] = time (0)) - 1;
+                               /* set the times, note change */
+    if (!utime (stream->mailbox,tp)) LOCAL->filetime = tp[1];
+    close (LOCAL->fd);         /* close and reopen file */
+    if ((LOCAL->fd = open (stream->mailbox,O_RDWR,
+                          (long) mail_parameters (NIL,GET_MBXPROTECTION,NIL)))
+       < 0) {
+      sprintf (LOCAL->buf,"Mailbox open failed, aborted: %s",strerror (errno));
+      MM_LOG (LOCAL->buf,ERROR);
+      mmdf_abort (stream);
+    }
+    dotlock_unlock (lock);     /* flush the lock file */
+  }
+  return ret;                  /* return state from algorithm */
+}
+\f
+/* Extend MMDF mailbox file
+ * Accepts: MAIL stream
+ *         new desired size
+ * Return: T if success, else NIL
+ */
+
+long mmdf_extend (MAILSTREAM *stream,unsigned long size)
+{
+  unsigned long i = (size > LOCAL->filesize) ? size - LOCAL->filesize : 0;
+  if (i) {                     /* does the mailbox need to grow? */
+    if (i > LOCAL->buflen) {   /* make sure have enough space */
+                               /* this user won the lottery all right */
+      fs_give ((void **) &LOCAL->buf);
+      LOCAL->buf = (char *) fs_get ((LOCAL->buflen = i) + 1);
+    }
+    memset (LOCAL->buf,'\0',i);        /* get a block of nulls */
+    while (T) {                        /* until write successful or punt */
+      lseek (LOCAL->fd,LOCAL->filesize,L_SET);
+      if ((write (LOCAL->fd,LOCAL->buf,i) >= 0) && !fsync (LOCAL->fd)) break;
+      else {
+       long e = errno;         /* note error before doing ftruncate */
+       ftruncate (LOCAL->fd,LOCAL->filesize);
+       if (MM_DISKERROR (stream,e,NIL)) {
+         fsync (LOCAL->fd);    /* user chose to punt */
+         sprintf (LOCAL->buf,"Unable to extend mailbox: %s",strerror (e));
+         if (!stream->silent) MM_LOG (LOCAL->buf,ERROR);
+         return NIL;
+       }
+      }
+    }
+  }
+  return LONGT;
+}
+\f
+/* Write data to buffered file
+ * Accepts: buffered file pointer
+ *         file data or NIL to indicate "flush buffer"
+ *         date size (ignored for "flush buffer")
+ * Does not return until success
+ */
+
+void mmdf_write (MMDFFILE *f,char *buf,unsigned long size)
+{
+  unsigned long i,j,k;
+  if (buf) {                   /* doing buffered write? */
+    i = f->bufpos - f->buf;    /* yes, get size of current buffer data */
+                               /* yes, have space in current buffer chunk? */
+    if (j = i ? ((f->buflen - i) % OVERFLOWBUFLEN) : f->buflen) {
+                               /* yes, fill up buffer as much as we can */
+      memcpy (f->bufpos,buf,k = min (j,size));
+      f->bufpos += k;          /* new buffer position */
+      f->curpos += k;          /* new current position */
+      if (j -= k) return;      /* all done if still have buffer free space */
+      buf += k;                        /* full, get new unwritten data pointer */
+      size -= k;               /* new data size */
+      i += k;                  /* new buffer data size */
+    }
+    /* This chunk of the buffer is full.  See if can make some space by
+     * writing to the disk, if there's enough unprotected space to do so.
+     * Try to fill out any unaligned chunk, along with any subsequent full
+     * chunks that will fit in unprotected space.
+     */
+                               /* any unprotected space we can write to? */
+    if (j = min (i,f->protect - f->filepos)) {
+                               /* yes, filepos not at chunk boundary? */
+      if ((k = f->filepos % OVERFLOWBUFLEN) && ((k = OVERFLOWBUFLEN - k) < j))
+       j -= k;                 /* yes, and can write out partial chunk */
+      else k = 0;              /* no partial chunk to write */
+                               /* if at least a chunk free, write that too */
+      if (j > OVERFLOWBUFLEN) k += j - (j % OVERFLOWBUFLEN);
+      if (k) {                 /* write data if there is anything we can */
+       mmdf_phys_write (f,f->buf,k);
+                               /* slide buffer */
+       if (i -= k) memmove (f->buf,f->buf + k,i);
+       f->bufpos = f->buf + i; /* new end of buffer */
+      }
+    }
+\f
+    /* Have flushed the buffer as best as possible.  All done if no more
+     * data to write.  Otherwise, if the buffer is empty AND if the unwritten
+     * data is larger than a chunk AND the unprotected space is also larger
+     * than a chunk, then write as many chunks as we can directly from the
+     * data.  Buffer the rest, expanding the buffer as needed.
+     */
+    if (size) {                        /* have more data that we need to buffer? */
+                               /* can write any of it to disk instead? */
+      if ((f->bufpos == f->buf) && 
+         ((j = min (f->protect - f->filepos,size)) > OVERFLOWBUFLEN)) {
+                               /* write as much as we can right now */
+       mmdf_phys_write (f,buf,j -= (j % OVERFLOWBUFLEN));
+       buf += j;               /* new data pointer */
+       size -= j;              /* new data size */
+       f->curpos += j;         /* advance current pointer */
+      }
+      if (size) {              /* still have data that we need to buffer? */
+                               /* yes, need to expand the buffer? */
+       if ((i = ((f->bufpos + size) - f->buf)) > f->buflen) {
+                               /* note current position in buffer */
+         j = f->bufpos - f->buf;
+         i += OVERFLOWBUFLEN;  /* yes, grow another chunk */
+         fs_resize ((void **) &f->buf,f->buflen = i - (i % OVERFLOWBUFLEN));
+                               /* in case buffer relocated */
+         f->bufpos = f->buf + j;
+       }
+                               /* buffer remaining data */
+       memcpy (f->bufpos,buf,size);
+       f->bufpos += size;      /* new end of buffer */
+       f->curpos += size;      /* advance current pointer */
+      }
+    }
+  }
+  else {                       /* flush buffer to disk */
+    mmdf_phys_write (f,f->buf,i = f->bufpos - f->buf);
+    f->bufpos = f->buf;                /* reset buffer */
+                               /* update positions */
+    f->curpos = f->protect = f->filepos;
+  }
+}
+\f
+/* Physical disk write
+ * Accepts: buffered file pointer
+ *         buffer address
+ *         buffer size
+ * Does not return until success
+ */
+
+void mmdf_phys_write (MMDFFILE *f,char *buf,size_t size)
+{
+  MAILSTREAM *stream = f->stream;
+                               /* write data at desired position */
+  while (size && ((lseek (LOCAL->fd,f->filepos,L_SET) < 0) ||
+                 (write (LOCAL->fd,buf,size) < 0))) {
+    int e;
+    char tmp[MAILTMPLEN];
+    sprintf (tmp,"Unable to write to mailbox: %s",strerror (e = errno));
+    MM_LOG (tmp,ERROR);
+    MM_DISKERROR (NIL,e,T);    /* serious problem, must retry */
+  }
+  f->filepos += size;          /* update file position */
+}
diff --git a/src/osdep/unix/mmdf.c b/src/osdep/unix/mmdf.c
new file mode 100644 (file)
index 0000000..f79e761
--- /dev/null
@@ -0,0 +1,2550 @@
+/* ========================================================================
+ * Copyright 1988-2007 University of Washington
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 
+ * ========================================================================
+ */
+
+/*
+ * Program:    MMDF mail routines
+ *
+ * Author:     Mark Crispin
+ *             Networks and Distributed Computing
+ *             Computing & Communications
+ *             University of Washington
+ *             Administration Building, AG-44
+ *             Seattle, WA  98195
+ *             Internet: MRC@CAC.Washington.EDU
+ *
+ * Date:       20 December 1989
+ * Last Edited:        5 September 2007
+ */
+
+
+#include <stdio.h>
+#include <ctype.h>
+#include <errno.h>
+extern int errno;              /* just in case */
+#include <signal.h>
+#include "mail.h"
+#include "osdep.h"
+#include <time.h>
+#include <sys/stat.h>
+#include "pseudo.h"
+#include "fdstring.h"
+#include "misc.h"
+#include "dummy.h"
+\f
+/* Supposedly, this page has everything the MMDF driver needs to know about
+ * the MMDF delimiter.  By changing these macros, the MMDF driver should
+ * change with it.  Note that if you change the length of MMDFHDRTXT you
+ * also need to change the ISMMDF and RETIFMMDFWRD macros to reflect the new
+ * size.
+ */
+
+
+/* Useful MMDF constants */
+
+#define MMDFCHR '\01'          /* MMDF character */
+#define MMDFCHRS 0x01010101    /* MMDF header character spread in a word */
+                               /* MMDF header text */
+#define MMDFHDRTXT "\01\01\01\01\n"
+                               /* length of MMDF header text */
+#define MMDFHDRLEN (sizeof (MMDFHDRTXT) - 1)
+
+
+/* Validate MMDF header
+ * Accepts: pointer to candidate string to validate as an MMDF header
+ * Returns: T if valid; else NIL
+ */
+
+#define ISMMDF(s)                                                      \
+  ((*(s) == MMDFCHR) && ((s)[1] == MMDFCHR) && ((s)[2] == MMDFCHR) &&  \
+   ((s)[3] == MMDFCHR) && ((s)[4] == '\n'))
+
+
+/* Return if a 32-bit word has the start of an MMDF header
+ * Accepts: pointer to word of four bytes to validate as an MMDF header
+ * Returns: pointer to MMDF header, else proceeds
+ */
+
+#define RETIFMMDFWRD(s) {                                              \
+  if (s[3] == MMDFCHR) {                                               \
+    if ((s[4] == MMDFCHR) && (s[5] == MMDFCHR) && (s[6] == MMDFCHR) && \
+       (s[7] == '\n')) return s + 3;                                   \
+    else if (s[2] == MMDFCHR) {                                                \
+      if ((s[4] == MMDFCHR) && (s[5] == MMDFCHR) && (s[6] == '\n'))    \
+       return s + 2;                                                   \
+      else if (s[1] == MMDFCHR) {                                      \
+       if ((s[4] == MMDFCHR) && (s[5] == '\n')) return s + 1;          \
+       else if ((*s == MMDFCHR) && (s[4] == '\n')) return s;           \
+      }                                                                        \
+    }                                                                  \
+  }                                                                    \
+}
+\f
+/* Validate line
+ * Accepts: pointer to candidate string to validate as a From header
+ *         return pointer to end of date/time field
+ *         return pointer to offset from t of time (hours of ``mmm dd hh:mm'')
+ *         return pointer to offset from t of time zone (if non-zero)
+ * Returns: t,ti,zn set if valid From string, else ti is NIL
+ */
+
+#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;                       \
+      }                                                                        \
+    }                                                                  \
+  }                                                                    \
+}
+
+/* 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
+ * emacs       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.
+ */
+\f
+/*
+ * 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-5   Validates that there is an end of line and points x at it.
+ * Lines 6-13  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 14     Makes sure that there are at least 27 characters in the line.
+ * Lines 15-20 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 21-23 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 24-27 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 28-31  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 to
+ * see if unquoted spaces were possible.  They are, and I've encountered enough
+ * evil mail to be totally unwilling to trust that ``it will never happen''.
+ */
+\f
+/* Build parameters */
+
+#define KODRETRY 15            /* kiss-of-death retry in seconds */
+#define LOCKTIMEOUT 5          /* lock timeout in minutes */
+
+
+/* MMDF I/O stream local data */
+
+typedef struct mmdf_local {
+  unsigned int dirty : 1;      /* disk copy needs updating */
+  unsigned int ddirty : 1;     /* double-dirty, ping becomes checkpoint */
+  unsigned int pseudo : 1;     /* uses a pseudo message */
+  unsigned int appending : 1;  /* don't mark new messages as old */
+  int fd;                      /* mailbox file descriptor */
+  int ld;                      /* lock file descriptor */
+  char *lname;                 /* lock file name */
+  off_t filesize;              /* file size parsed */
+  time_t filetime;             /* last file time */
+  unsigned char *buf;          /* temporary buffer */
+  unsigned long buflen;                /* current size of temporary buffer */
+  unsigned long uid;           /* current text uid */
+  SIZEDTEXT text;              /* current text */
+  unsigned long textlen;       /* current text length */
+  char *line;                  /* returned line */
+  char *linebuf;               /* line readin buffer */
+  unsigned long linebuflen;    /* current line readin buffer length */
+} MMDFLOCAL;
+
+
+/* Convenient access to local data */
+
+#define LOCAL ((MMDFLOCAL *) stream->local)
+
+
+/* MMDF protected file structure */
+
+typedef struct mmdf_file {
+  MAILSTREAM *stream;          /* current stream */
+  off_t curpos;                        /* current file position */
+  off_t protect;               /* protected position */
+  off_t filepos;               /* current last written file position */
+  char *buf;                   /* overflow buffer */
+  size_t buflen;               /* current overflow buffer length */
+  char *bufpos;                        /* current buffer position */
+} MMDFFILE;
+\f
+/* Function prototypes */
+
+DRIVER *mmdf_valid (char *name);
+long mmdf_isvalid (char *name,char *tmp);
+long mmdf_isvalid_fd (int fd,char *tmp);
+void *mmdf_parameters (long function,void *value);
+void mmdf_scan (MAILSTREAM *stream,char *ref,char *pat,char *contents);
+void mmdf_list (MAILSTREAM *stream,char *ref,char *pat);
+void mmdf_lsub (MAILSTREAM *stream,char *ref,char *pat);
+long mmdf_create (MAILSTREAM *stream,char *mailbox);
+long mmdf_delete (MAILSTREAM *stream,char *mailbox);
+long mmdf_rename (MAILSTREAM *stream,char *old,char *newname);
+MAILSTREAM *mmdf_open (MAILSTREAM *stream);
+void mmdf_close (MAILSTREAM *stream,long options);
+char *mmdf_header (MAILSTREAM *stream,unsigned long msgno,
+                  unsigned long *length,long flags);
+long mmdf_text (MAILSTREAM *stream,unsigned long msgno,STRING *bs,long flags);
+char *mmdf_text_work (MAILSTREAM *stream,MESSAGECACHE *elt,
+                     unsigned long *length,long flags);
+void mmdf_flagmsg (MAILSTREAM *stream,MESSAGECACHE *elt);
+long mmdf_ping (MAILSTREAM *stream);
+void mmdf_check (MAILSTREAM *stream);
+long mmdf_expunge (MAILSTREAM *stream,char *sequence,long options);
+long mmdf_copy (MAILSTREAM *stream,char *sequence,char *mailbox,long options);
+long mmdf_append (MAILSTREAM *stream,char *mailbox,append_t af,void *data);
+int mmdf_collect_msg (MAILSTREAM *stream,FILE *sf,char *flags,char *date,
+                    STRING *msg);
+int mmdf_append_msgs (MAILSTREAM *stream,FILE *sf,FILE *df,SEARCHSET *set);
+
+void mmdf_abort (MAILSTREAM *stream);
+char *mmdf_file (char *dst,char *name);
+int mmdf_lock (char *file,int flags,int mode,DOTLOCK *lock,int op);
+void mmdf_unlock (int fd,MAILSTREAM *stream,DOTLOCK *lock);
+int mmdf_parse (MAILSTREAM *stream,DOTLOCK *lock,int op);
+char *mmdf_mbxline (MAILSTREAM *stream,STRING *bs,unsigned long *size);
+unsigned long mmdf_pseudo (MAILSTREAM *stream,char *hdr);
+unsigned long mmdf_xstatus (MAILSTREAM *stream,char *status,MESSAGECACHE *elt,
+                           unsigned long uid,long flag);
+long mmdf_rewrite (MAILSTREAM *stream,unsigned long *nexp,DOTLOCK *lock,
+                  long flags);
+long mmdf_extend (MAILSTREAM *stream,unsigned long size);
+void mmdf_write (MMDFFILE *f,char *s,unsigned long i);
+void mmdf_phys_write (MMDFFILE *f,char *buf,size_t size);
+\f
+/* MMDF mail routines */
+
+
+/* Driver dispatch used by MAIL */
+
+DRIVER mmdfdriver = {
+  "mmdf",                      /* driver name */
+                               /* driver flags */
+  DR_LOCAL|DR_MAIL|DR_LOCKING|DR_NONEWMAILRONLY|DR_XPOINT,
+  (DRIVER *) NIL,              /* next driver */
+  mmdf_valid,                  /* mailbox is valid for us */
+  mmdf_parameters,             /* manipulate parameters */
+  mmdf_scan,                   /* scan mailboxes */
+  mmdf_list,                   /* list mailboxes */
+  mmdf_lsub,                   /* list subscribed mailboxes */
+  NIL,                         /* subscribe to mailbox */
+  NIL,                         /* unsubscribe from mailbox */
+  mmdf_create,                 /* create mailbox */
+  mmdf_delete,                 /* delete mailbox */
+  mmdf_rename,                 /* rename mailbox */
+  mail_status_default,         /* status of mailbox */
+  mmdf_open,                   /* open mailbox */
+  mmdf_close,                  /* close mailbox */
+  NIL,                         /* fetch message "fast" attributes */
+  NIL,                         /* fetch message flags */
+  NIL,                         /* fetch overview */
+  NIL,                         /* fetch message envelopes */
+  mmdf_header,                 /* fetch message header */
+  mmdf_text,                   /* fetch message text */
+  NIL,                         /* fetch partial message text */
+  NIL,                         /* unique identifier */
+  NIL,                         /* message number */
+  NIL,                         /* modify flags */
+  mmdf_flagmsg,                        /* per-message modify flags */
+  NIL,                         /* search for message based on criteria */
+  NIL,                         /* sort messages */
+  NIL,                         /* thread messages */
+  mmdf_ping,                   /* ping mailbox to see if still alive */
+  mmdf_check,                  /* check for new messages */
+  mmdf_expunge,                        /* expunge deleted messages */
+  mmdf_copy,                   /* copy messages to another mailbox */
+  mmdf_append,                 /* append string message to mailbox */
+  NIL                          /* garbage collect stream */
+};
+
+                               /* prototype stream */
+MAILSTREAM mmdfproto = {&mmdfdriver};
+
+char *mmdfhdr = MMDFHDRTXT;    /* MMDF header */
+\f
+/* MMDF mail validate mailbox
+ * Accepts: mailbox name
+ * Returns: our driver if name is valid, NIL otherwise
+ */
+
+DRIVER *mmdf_valid (char *name)
+{
+  char tmp[MAILTMPLEN];
+  return mmdf_isvalid (name,tmp) ? &mmdfdriver : NIL;
+}
+
+
+/* MMDF mail test for valid mailbox name
+ * Accepts: mailbox name
+ *         scratch buffer
+ * Returns: T if valid, NIL otherwise
+ */
+
+long mmdf_isvalid (char *name,char *tmp)
+{
+  int fd;
+  int ret = NIL;
+  char *t,file[MAILTMPLEN];
+  struct stat sbuf;
+  time_t tp[2];
+  errno = EINVAL;              /* assume invalid argument */
+                               /* must be non-empty file */
+  if ((t = dummy_file (file,name)) && !stat (t,&sbuf)) {
+    if (!sbuf.st_size)errno = 0;/* empty file */
+    else if ((fd = open (file,O_RDONLY,NIL)) >= 0) {
+                               /* error -1 for invalid format */
+      if (!(ret = mmdf_isvalid_fd (fd,tmp))) errno = -1;
+      close (fd);              /* close the file */
+                               /* \Marked status? */
+      if ((sbuf.st_ctime > sbuf.st_atime) || (sbuf.st_mtime > sbuf.st_atime)) {
+       tp[0] = sbuf.st_atime;  /* preserve atime and mtime */
+       tp[1] = sbuf.st_mtime;
+       utime (file,tp);        /* set the times */
+      }
+    }
+  }
+  return ret;                  /* return what we should */
+}
+\f
+/* MMDF mail test for valid mailbox
+ * Accepts: file descriptor
+ *         scratch buffer
+ * Returns: T if valid, NIL otherwise
+ */
+
+long mmdf_isvalid_fd (int fd,char *tmp)
+{
+  int ret = NIL;
+  memset (tmp,'\0',MAILTMPLEN);
+  if (read (fd,tmp,MAILTMPLEN-1) >= 0) ret = ISMMDF (tmp) ? T : NIL;
+  return ret;                  /* return what we should */
+}
+
+
+/* MMDF manipulate driver parameters
+ * Accepts: function code
+ *         function-dependent value
+ * Returns: function-dependent return value
+ */
+
+void *mmdf_parameters (long function,void *value)
+{
+  void *ret = NIL;
+  switch ((int) function) {
+  case GET_INBOXPATH:
+    if (value) ret = dummy_file ((char *) value,"INBOX");
+    break;
+  }
+  return ret;
+}
+\f
+/* MMDF mail scan mailboxes
+ * Accepts: mail stream
+ *         reference
+ *         pattern to search
+ *         string to scan
+ */
+
+void mmdf_scan (MAILSTREAM *stream,char *ref,char *pat,char *contents)
+{
+  if (stream) dummy_scan (NIL,ref,pat,contents);
+}
+
+
+/* MMDF mail list mailboxes
+ * Accepts: mail stream
+ *         reference
+ *         pattern to search
+ */
+
+void mmdf_list (MAILSTREAM *stream,char *ref,char *pat)
+{
+  if (stream) dummy_list (NIL,ref,pat);
+}
+
+
+/* MMDF mail list subscribed mailboxes
+ * Accepts: mail stream
+ *         reference
+ *         pattern to search
+ */
+
+void mmdf_lsub (MAILSTREAM *stream,char *ref,char *pat)
+{
+  if (stream) dummy_lsub (NIL,ref,pat);
+}
+\f
+/* MMDF mail create mailbox
+ * Accepts: MAIL stream
+ *         mailbox name to create
+ * Returns: T on success, NIL on failure
+ */
+
+long mmdf_create (MAILSTREAM *stream,char *mailbox)
+{
+  char *s,mbx[MAILTMPLEN],tmp[MAILTMPLEN];
+  long ret = NIL;
+  int i,fd;
+  time_t ti = time (0);
+  if (!(s = dummy_file (mbx,mailbox))) {
+    sprintf (tmp,"Can't create %.80s: invalid name",mailbox);
+    MM_LOG (tmp,ERROR);
+  }
+                               /* create underlying file */
+  else if (dummy_create_path (stream,s,get_dir_protection (mailbox))) {
+                               /* done if dir-only or whiner */
+    if (((s = strrchr (s,'/')) && !s[1]) ||
+       mail_parameters (NIL,GET_USERHASNOLIFE,NIL)) ret = T;
+    else if ((fd = open (mbx,O_WRONLY,
+                   (long) mail_parameters (NIL,GET_MBXPROTECTION,NIL))) < 0) {
+      sprintf (tmp,"Can't reopen mailbox node %.80s: %s",mbx,strerror (errno));
+      MM_LOG (tmp,ERROR);
+      unlink (mbx);            /* delete the file */
+    }
+    else {                     /* initialize header */
+      memset (tmp,'\0',MAILTMPLEN);
+      sprintf (tmp,"%sFrom %s %sDate: ",mmdfhdr,pseudo_from,ctime (&ti));
+      rfc822_date (s = tmp + strlen (tmp));
+      sprintf (s += strlen (s),        /* write the pseudo-header */
+              "\nFrom: %s <%s@%s>\nSubject: %s\nX-IMAP: %010lu 0000000000",
+              pseudo_name,pseudo_from,mylocalhost (),pseudo_subject,
+              (unsigned long) ti);
+      for (i = 0; i < NUSERFLAGS; ++i) if (default_user_flag (i))
+       sprintf (s += strlen (s)," %s",default_user_flag (i));
+      sprintf (s += strlen (s),"\nStatus: RO\n\n%s\n%s",pseudo_msg,mmdfhdr);
+      if (write (fd,tmp,strlen (tmp)) > 0) ret = T;
+      else {
+       sprintf (tmp,"Can't initialize mailbox node %.80s: %s",mbx,
+                strerror (errno));
+       MM_LOG (tmp,ERROR);
+       unlink (mbx);           /* delete the file */
+      }
+      close (fd);              /* close file */
+    }
+  }
+                               /* set proper protections */
+  return ret ? set_mbx_protections (mailbox,mbx) : NIL;
+}
+\f
+/* MMDF mail delete mailbox
+ * Accepts: MAIL stream
+ *         mailbox name to delete
+ * Returns: T on success, NIL on failure
+ */
+
+long mmdf_delete (MAILSTREAM *stream,char *mailbox)
+{
+  return mmdf_rename (stream,mailbox,NIL);
+}
+
+
+/* MMDF mail rename mailbox
+ * Accepts: MAIL stream
+ *         old mailbox name
+ *         new mailbox name (or NIL for delete)
+ * Returns: T on success, NIL on failure
+ */
+
+long mmdf_rename (MAILSTREAM *stream,char *old,char *newname)
+{
+  long ret = NIL;
+  char c,*s = NIL;
+  char tmp[MAILTMPLEN],file[MAILTMPLEN],lock[MAILTMPLEN];
+  DOTLOCK lockx;
+  int fd,ld;
+  long i;
+  struct stat sbuf;
+  MM_CRITICAL (stream);        /* get the c-client lock */
+  if (!dummy_file (file,old) ||
+      (newname && (!((s = mailboxfile (tmp,newname)) && *s) ||
+                  ((s = strrchr (tmp,'/')) && !s[1]))))
+    sprintf (tmp,newname ?
+            "Can't rename mailbox %.80s to %.80s: invalid name" :
+            "Can't delete mailbox %.80s: invalid name",
+            old,newname);
+                               /* lock out other c-clients */
+  else if ((ld = lockname (lock,file,LOCK_EX|LOCK_NB,&i)) < 0)
+    sprintf (tmp,"Mailbox %.80s is in use by another process",old);
+\f
+  else {
+    if ((fd = mmdf_lock (file,O_RDWR,
+                        (long) mail_parameters (NIL,GET_MBXPROTECTION,NIL),
+                        &lockx,LOCK_EX)) < 0)
+       sprintf (tmp,"Can't lock mailbox %.80s: %s",old,strerror (errno));
+    else {
+      if (newname) {           /* want rename? */
+                               /* found superior to destination name? */
+       if (s = strrchr (s,'/')) {
+         c = *++s;             /* remember first character of inferior */
+         *s = '\0';            /* tie off to get just superior */
+                               /* name doesn't exist, create it */
+         if ((stat (tmp,&sbuf) || ((sbuf.st_mode & S_IFMT) != S_IFDIR)) &&
+             !dummy_create_path (stream,tmp,get_dir_protection (newname))) {
+           mmdf_unlock (fd,NIL,&lockx);
+           mmdf_unlock (ld,NIL,NIL);
+           unlink (lock);
+           MM_NOCRITICAL (stream);
+           return ret;         /* return success or failure */
+         }
+         *s = c;               /* restore full name */
+       }
+       if (rename (file,tmp))
+         sprintf (tmp,"Can't rename mailbox %.80s to %.80s: %s",old,newname,
+                  strerror (errno));
+       else ret = T;           /* set success */
+      }
+      else if (unlink (file))
+       sprintf (tmp,"Can't delete mailbox %.80s: %s",old,strerror (errno));
+      else ret = T;            /* set success */
+      mmdf_unlock (fd,NIL,&lockx);
+    }
+    mmdf_unlock (ld,NIL,NIL);  /* flush the lock */
+    unlink (lock);
+  }
+  MM_NOCRITICAL (stream);      /* no longer critical */
+  if (!ret) MM_LOG (tmp,ERROR);        /* log error */
+  return ret;                  /* return success or failure */
+}
+\f
+/* MMDF mail open
+ * Accepts: Stream to open
+ * Returns: Stream on success, NIL on failure
+ */
+
+MAILSTREAM *mmdf_open (MAILSTREAM *stream)
+{
+  long i;
+  int fd;
+  char tmp[MAILTMPLEN];
+  DOTLOCK lock;
+  long retry;
+                               /* return prototype for OP_PROTOTYPE call */
+  if (!stream) return user_flags (&mmdfproto);
+  retry = stream->silent ? 1 : KODRETRY;
+  if (stream->local) fatal ("mmdf recycle stream");
+  stream->local = memset (fs_get (sizeof (MMDFLOCAL)),0,sizeof (MMDFLOCAL));
+                               /* note if an INBOX or not */
+  stream->inbox = !compare_cstring (stream->mailbox,"INBOX");
+                               /* canonicalize the stream mailbox name */
+  if (!dummy_file (tmp,stream->mailbox)) {
+    sprintf (tmp,"Can't open - invalid name: %.80s",stream->mailbox);
+    MM_LOG (tmp,ERROR);
+    return NIL;
+  }
+                               /* flush old name */
+  fs_give ((void **) &stream->mailbox);
+                               /* save canonical name */
+  stream->mailbox = cpystr (tmp);
+  LOCAL->fd = LOCAL->ld = -1;  /* no file or state locking yet */
+  LOCAL->buf = (char *) fs_get (CHUNKSIZE);
+  LOCAL->buflen = CHUNKSIZE - 1;
+  LOCAL->text.data = (unsigned char *) fs_get (CHUNKSIZE);
+  LOCAL->text.size = CHUNKSIZE - 1;
+  LOCAL->linebuf = (char *) fs_get (CHUNKSIZE);
+  LOCAL->linebuflen = CHUNKSIZE - 1;
+  stream->sequence++;          /* bump sequence number */
+\f
+                               /* make lock for read/write access */
+  if (!stream->rdonly) while (retry) {
+                               /* try to lock file */
+    if ((fd = lockname (tmp,stream->mailbox,LOCK_EX|LOCK_NB,&i)) < 0) {
+                               /* suppressing kiss-of-death? */
+      if (stream->nokod) retry = 0;
+                               /* no, first time through? */
+      else if (retry-- == KODRETRY) {
+                               /* learned other guy's PID and can signal? */
+       if (i && !kill ((int) i,SIGUSR2)) {
+         sprintf (tmp,"Trying to get mailbox lock from process %ld",i);
+         MM_LOG (tmp,WARN);
+       }
+       else retry = 0;         /* give up */
+      }
+      if (!stream->silent) {   /* nothing if silent stream */
+       if (retry) sleep (1);   /* wait a second before trying again */
+       else MM_LOG ("Mailbox is open by another process, access is readonly",
+                    WARN);
+      }
+    }
+    else {                     /* got the lock, nobody else can alter state */
+      LOCAL->ld = fd;          /* note lock's fd and name */
+      LOCAL->lname = cpystr (tmp);
+                               /* make sure mode OK (don't use fchmod()) */
+      chmod (LOCAL->lname,(long) mail_parameters (NIL,GET_LOCKPROTECTION,NIL));
+      if (stream->silent) i = 0;/* silent streams won't accept KOD */
+      else {                   /* note our PID in the lock */
+       sprintf (tmp,"%d",getpid ());
+       write (fd,tmp,(i = strlen (tmp))+1);
+      }
+      ftruncate (fd,i);                /* make sure tied off */
+      fsync (fd);              /* make sure it's available */
+      retry = 0;               /* no more need to try */
+    }
+  }
+\f
+                               /* parse mailbox */
+  stream->nmsgs = stream->recent = 0;
+                               /* will we be able to get write access? */
+  if ((LOCAL->ld >= 0) && access (stream->mailbox,W_OK) && (errno == EACCES)) {
+    MM_LOG ("Can't get write access to mailbox, access is readonly",WARN);
+    flock (LOCAL->ld,LOCK_UN); /* release the lock */
+    close (LOCAL->ld);         /* close the lock file */
+    LOCAL->ld = -1;            /* no more lock fd */
+    unlink (LOCAL->lname);     /* delete it */
+  }
+                               /* reset UID validity */
+  stream->uid_validity = stream->uid_last = 0;
+  if (stream->silent && !stream->rdonly && (LOCAL->ld < 0))
+    mmdf_abort (stream);       /* abort if can't get RW silent stream */
+                               /* parse mailbox */
+  else if (mmdf_parse (stream,&lock,LOCK_SH)) {
+    mmdf_unlock (LOCAL->fd,stream,&lock);
+    mail_unlock (stream);
+    MM_NOCRITICAL (stream);    /* done with critical */
+  }
+  if (!LOCAL) return NIL;      /* failure if stream died */
+                               /* make sure upper level knows readonly */
+  stream->rdonly = (LOCAL->ld < 0);
+                               /* notify about empty mailbox */
+  if (!(stream->nmsgs || stream->silent)) MM_LOG ("Mailbox is empty",NIL);
+  if (!stream->rdonly) {       /* flags stick if readwrite */
+    stream->perm_seen = stream->perm_deleted =
+      stream->perm_flagged = stream->perm_answered = stream->perm_draft = T;
+    if (!stream->uid_nosticky) {/* users with lives get permanent keywords */
+      stream->perm_user_flags = 0xffffffff;
+                               /* and maybe can create them too! */
+      stream->kwd_create = stream->user_flags[NUSERFLAGS-1] ? NIL : T;
+    }
+  }
+  return stream;               /* return stream alive to caller */
+}
+
+
+/* MMDF mail close
+ * Accepts: MAIL stream
+ *         close options
+ */
+
+void mmdf_close (MAILSTREAM *stream,long options)
+{
+  int silent = stream->silent;
+  stream->silent = T;          /* go silent */
+                               /* expunge if requested */
+  if (options & CL_EXPUNGE) mmdf_expunge (stream,NIL,NIL);
+                               /* else dump final checkpoint */
+  else if (LOCAL->dirty) mmdf_check (stream);
+  stream->silent = silent;     /* restore old silence state */
+  mmdf_abort (stream);         /* now punt the file and local data */
+}
+\f
+/* MMDF mail fetch message header
+ * Accepts: MAIL stream
+ *         message # to fetch
+ *         pointer to returned header text length
+ *         option flags
+ * Returns: message header in RFC822 format
+ */
+
+                               /* lines to filter from header */
+static STRINGLIST *mmdf_hlines = NIL;
+
+char *mmdf_header (MAILSTREAM *stream,unsigned long msgno,
+                  unsigned long *length,long flags)
+{
+  MESSAGECACHE *elt;
+  unsigned char *s,*t,*tl;
+  *length = 0;                 /* default to empty */
+  if (flags & FT_UID) return "";/* UID call "impossible" */
+  elt = mail_elt (stream,msgno);/* get cache */
+  if (!mmdf_hlines) {          /* once only code */
+    STRINGLIST *lines = mmdf_hlines = mail_newstringlist ();
+    lines->text.size = strlen ((char *) (lines->text.data =
+                                        (unsigned char *) "Status"));
+    lines = lines->next = mail_newstringlist ();
+    lines->text.size = strlen ((char *) (lines->text.data =
+                                        (unsigned char *) "X-Status"));
+    lines = lines->next = mail_newstringlist ();
+    lines->text.size = strlen ((char *) (lines->text.data =
+                                        (unsigned char *) "X-Keywords"));
+    lines = lines->next = mail_newstringlist ();
+    lines->text.size = strlen ((char *) (lines->text.data =
+                                        (unsigned char *) "X-UID"));
+    lines = lines->next = mail_newstringlist ();
+    lines->text.size = strlen ((char *) (lines->text.data =
+                                        (unsigned char *) "X-IMAP"));
+    lines = lines->next = mail_newstringlist ();
+    lines->text.size = strlen ((char *) (lines->text.data =
+                                        (unsigned char *) "X-IMAPbase"));
+  }
+                               /* go to header position */
+  lseek (LOCAL->fd,elt->private.special.offset +
+        elt->private.msg.header.offset,L_SET);
+\f
+  if (flags & FT_INTERNAL) {   /* initial data OK? */
+    if (elt->private.msg.header.text.size > LOCAL->buflen) {
+      fs_give ((void **) &LOCAL->buf);
+      LOCAL->buf = (char *) fs_get ((LOCAL->buflen =
+                                    elt->private.msg.header.text.size) + 1);
+    }
+                               /* read message */
+    read (LOCAL->fd,LOCAL->buf,elt->private.msg.header.text.size);
+                               /* got text, tie off string */
+    LOCAL->buf[*length = elt->private.msg.header.text.size] = '\0';
+                               /* squeeze out CRs (in case from PC) */
+    for (s = t = LOCAL->buf,tl = LOCAL->buf + *length; t < tl; t++)
+      if (*t != '\r') *s++ = *t;
+    *s = '\0';
+    *length = s - LOCAL->buf;  /* adjust length */
+  }
+  else {                       /* need to make a CRLF version */
+    read (LOCAL->fd,s = (char *) fs_get (elt->private.msg.header.text.size+1),
+         elt->private.msg.header.text.size);
+                               /* tie off string, and convert to CRLF */
+    s[elt->private.msg.header.text.size] = '\0';
+    *length = strcrlfcpy (&LOCAL->buf,&LOCAL->buflen,s,
+                         elt->private.msg.header.text.size);
+    fs_give ((void **) &s);    /* free readin buffer */
+                               /* squeeze out spurious CRs */
+    for (s = t = LOCAL->buf,tl = LOCAL->buf + *length; t < tl; t++)
+      if ((*t != '\r') || (t[1] == '\n')) *s++ = *t;
+    *s = '\0';
+    *length = s - LOCAL->buf;  /* adjust length */
+  }
+  *length = mail_filter (LOCAL->buf,*length,mmdf_hlines,FT_NOT);
+  return (char *) LOCAL->buf;  /* return processed copy */
+}
+\f
+/* MMDF mail fetch message text
+ * Accepts: MAIL stream
+ *         message # to fetch
+ *         pointer to returned stringstruct
+ *         option flags
+ * Returns: T on success, NIL if failure
+ */
+
+long mmdf_text (MAILSTREAM *stream,unsigned long msgno,STRING *bs,long flags)
+{
+  char *s;
+  unsigned long i;
+  MESSAGECACHE *elt;
+                               /* UID call "impossible" */
+  if (flags & FT_UID) return NIL;
+  elt = mail_elt (stream,msgno);/* get cache element */
+                               /* if message not seen */
+  if (!(flags & FT_PEEK) && !elt->seen) {
+                               /* mark message seen and dirty */
+    elt->seen = elt->private.dirty = LOCAL->dirty = T;
+    MM_FLAGS (stream,msgno);
+  }
+  s = mmdf_text_work (stream,elt,&i,flags);
+  INIT (bs,mail_string,s,i);   /* set up stringstruct */
+  return T;                    /* success */
+}
+\f
+/* MMDF mail fetch message text worker routine
+ * Accepts: MAIL stream
+ *         message cache element
+ *         pointer to returned header text length
+ *         option flags
+ */
+
+char *mmdf_text_work (MAILSTREAM *stream,MESSAGECACHE *elt,
+                     unsigned long *length,long flags)
+{
+  FDDATA d;
+  STRING bs;
+  unsigned char c,*s,*t,*tl,tmp[CHUNKSIZE];
+                               /* go to text position */
+  lseek (LOCAL->fd,elt->private.special.offset +
+        elt->private.msg.text.offset,L_SET);
+  if (flags & FT_INTERNAL) {   /* initial data OK? */
+    if (elt->private.msg.text.text.size > LOCAL->buflen) {
+      fs_give ((void **) &LOCAL->buf);
+      LOCAL->buf = (char *) fs_get ((LOCAL->buflen =
+                                    elt->private.msg.text.text.size) + 1);
+    }
+                               /* read message */
+    read (LOCAL->fd,LOCAL->buf,elt->private.msg.text.text.size);
+                               /* got text, tie off string */
+    LOCAL->buf[*length = elt->private.msg.text.text.size] = '\0';
+                               /* squeeze out CRs (in case from PC) */
+    for (s = t = LOCAL->buf,tl = LOCAL->buf + *length; t < tl; t++)
+      if (*t != '\r') *s++ = *t;
+    *s = '\0';
+    *length = s - LOCAL->buf;  /* adjust length */
+    return (char *) LOCAL->buf;
+  }
+\f
+                               /* have it cached already? */
+  if (elt->private.uid != LOCAL->uid) {
+                               /* not cached, cache it now */
+    LOCAL->uid = elt->private.uid;
+                               /* is buffer big enough? */
+    if (elt->rfc822_size > LOCAL->text.size) {
+      /* excessively conservative, but the right thing is too hard to do */
+      fs_give ((void **) &LOCAL->text.data);
+      LOCAL->text.data = (unsigned char *)
+       fs_get ((LOCAL->text.size = elt->rfc822_size) + 1);
+    }
+    d.fd = LOCAL->fd;          /* yes, set up file descriptor */
+    d.pos = elt->private.special.offset + elt->private.msg.text.offset;
+    d.chunk = tmp;             /* initial buffer chunk */
+    d.chunksize = CHUNKSIZE;   /* file chunk size */
+    INIT (&bs,fd_string,&d,elt->private.msg.text.text.size);
+    for (s = (char *) LOCAL->text.data; SIZE (&bs);) switch (c = SNX (&bs)) {
+    case '\r':                 /* carriage return seen */
+      break;
+    case '\n':
+      *s++ = '\r';             /* insert a CR */
+    default:
+      *s++ = c;                        /* copy characters */
+    }
+    *s = '\0';                 /* tie off buffer */
+                               /* calculate length of cached data */
+    LOCAL->textlen = s - LOCAL->text.data;
+  }
+  *length = LOCAL->textlen;    /* return from cache */
+  return (char *) LOCAL->text.data;
+}
+\f
+/* MMDF per-message modify flag
+ * Accepts: MAIL stream
+ *         message cache element
+ */
+
+void mmdf_flagmsg (MAILSTREAM *stream,MESSAGECACHE *elt)
+{
+                               /* only after finishing */
+  if (elt->valid) elt->private.dirty = LOCAL->dirty = T;
+}
+
+
+/* MMDF mail ping mailbox
+ * Accepts: MAIL stream
+ * Returns: T if stream alive, else NIL
+ */
+
+long mmdf_ping (MAILSTREAM *stream)
+{
+  DOTLOCK lock;
+  struct stat sbuf;
+  long reparse;
+                               /* big no-op if not readwrite */
+  if (LOCAL && (LOCAL->ld >= 0) && !stream->lock) {
+    if (stream->rdonly) {      /* does he want to give up readwrite? */
+                               /* checkpoint if we changed something */
+      if (LOCAL->dirty) mmdf_check (stream);
+      flock (LOCAL->ld,LOCK_UN);/* release readwrite lock */
+      close (LOCAL->ld);       /* close the readwrite lock file */
+      LOCAL->ld = -1;          /* no more readwrite lock fd */
+      unlink (LOCAL->lname);   /* delete the readwrite lock file */
+    }
+    else {                     /* see if need to reparse */
+      if (!(reparse = (long) mail_parameters (NIL,GET_NETFSSTATBUG,NIL))) {
+                               /* get current mailbox size */
+       if (LOCAL->fd >= 0) fstat (LOCAL->fd,&sbuf);
+       else if (stat (stream->mailbox,&sbuf)) {
+         sprintf (LOCAL->buf,"Mailbox stat failed, aborted: %s",
+                  strerror (errno));
+         MM_LOG (LOCAL->buf,ERROR);
+         mmdf_abort (stream);
+         return NIL;
+       }
+       reparse = (sbuf.st_size != LOCAL->filesize);
+      }
+                               /* parse if mailbox changed */
+      if ((LOCAL->ddirty || reparse) && mmdf_parse (stream,&lock,LOCK_EX)) {
+                               /* force checkpoint if double-dirty */
+       if (LOCAL->ddirty) mmdf_rewrite (stream,NIL,&lock,NIL);
+                               /* unlock mailbox */
+       else mmdf_unlock (LOCAL->fd,stream,&lock);
+       mail_unlock (stream);   /* and stream */
+                               /* done with critical */
+       MM_NOCRITICAL (stream);
+      }
+    }
+  }
+  return LOCAL ? LONGT : NIL;  /* return if still alive */
+}
+\f
+/* MMDF mail check mailbox
+ * Accepts: MAIL stream
+ */
+
+void mmdf_check (MAILSTREAM *stream)
+{
+  DOTLOCK lock;
+                               /* parse and lock mailbox */
+  if (LOCAL && (LOCAL->ld >= 0) && !stream->lock &&
+      mmdf_parse (stream,&lock,LOCK_EX)) {
+                               /* any unsaved changes? */
+    if (LOCAL->dirty && mmdf_rewrite (stream,NIL,&lock,NIL)) {
+      if (!stream->silent) MM_LOG ("Checkpoint completed",NIL);
+    }
+                               /* no checkpoint needed, just unlock */
+    else mmdf_unlock (LOCAL->fd,stream,&lock);
+    mail_unlock (stream);      /* unlock the stream */
+    MM_NOCRITICAL (stream);    /* done with critical */
+  }
+}
+
+
+/* MMDF mail expunge mailbox
+ * Accepts: MAIL stream
+ *         sequence to expunge if non-NIL
+ *         expunge options
+ * Returns: T, always
+ */
+
+long mmdf_expunge (MAILSTREAM *stream,char *sequence,long options)
+{
+  long ret;
+  unsigned long i;
+  DOTLOCK lock;
+  char *msg = NIL;
+  if (ret = (sequence ? ((options & EX_UID) ?
+                        mail_uid_sequence (stream,sequence) :
+                        mail_sequence (stream,sequence)) : LONGT) &&
+      LOCAL && (LOCAL->ld >= 0) && !stream->lock &&
+      mmdf_parse (stream,&lock,LOCK_EX)) {
+                               /* check expunged messages if not dirty */
+    for (i = 1; !LOCAL->dirty && (i <= stream->nmsgs); i++) {
+      MESSAGECACHE *elt = mail_elt (stream,i);
+      if (mail_elt (stream,i)->deleted) LOCAL->dirty = T;
+    }
+    if (!LOCAL->dirty) {       /* not dirty and no expunged messages */
+      mmdf_unlock (LOCAL->fd,stream,&lock);
+      msg = "No messages deleted, so no update needed";
+    }
+    else if (mmdf_rewrite (stream,&i,&lock,sequence ? LONGT : NIL)) {
+      if (i) sprintf (msg = LOCAL->buf,"Expunged %lu messages",i);
+      else msg = "Mailbox checkpointed, but no messages expunged";
+    }
+                               /* rewrite failed */
+    else mmdf_unlock (LOCAL->fd,stream,&lock);
+    mail_unlock (stream);      /* unlock the stream */
+    MM_NOCRITICAL (stream);    /* done with critical */
+    if (msg && !stream->silent) MM_LOG (msg,NIL);
+  }
+  else if (!stream->silent)
+    MM_LOG ("Expunge ignored on readonly mailbox",WARN);
+  return ret;
+}
+\f
+/* MMDF mail copy message(s)
+ * Accepts: MAIL stream
+ *         sequence
+ *         destination mailbox
+ *         copy options
+ * Returns: T if copy successful, else NIL
+ */
+
+long mmdf_copy (MAILSTREAM *stream,char *sequence,char *mailbox,long options)
+{
+  struct stat sbuf;
+  int fd;
+  char *s,file[MAILTMPLEN];
+  DOTLOCK lock;
+  time_t tp[2];
+  unsigned long i,j;
+  MESSAGECACHE *elt;
+  long ret = T;
+  mailproxycopy_t pc =
+    (mailproxycopy_t) mail_parameters (stream,GET_MAILPROXYCOPY,NIL);
+  copyuid_t cu = (copyuid_t) (mail_parameters (NIL,GET_USERHASNOLIFE,NIL) ?
+                             NIL : mail_parameters (NIL,GET_COPYUID,NIL));
+  SEARCHSET *source = cu ? mail_newsearchset () : NIL;
+  SEARCHSET *dest = cu ? mail_newsearchset () : NIL;
+  MAILSTREAM *tstream = NIL;
+  if (!((options & CP_UID) ? mail_uid_sequence (stream,sequence) :
+       mail_sequence (stream,sequence))) return NIL;
+                               /* make sure destination is valid */
+  if (!(mmdf_valid (mailbox) || !errno))
+    switch (errno) {
+    case ENOENT:               /* no such file? */
+      if (compare_cstring (mailbox,"INBOX")) {
+       MM_NOTIFY (stream,"[TRYCREATE] Must create mailbox before copy",NIL);
+       return NIL;
+      }
+      if (pc) return (*pc) (stream,sequence,mailbox,options);
+      mmdf_create (NIL,"INBOX");/* create empty INBOX */
+    case EACCES:               /* file protected */
+      sprintf (LOCAL->buf,"Can't access destination: %.80s",mailbox);
+      MM_LOG (LOCAL->buf,ERROR);
+      return NIL;
+    case EINVAL:
+      if (pc) return (*pc) (stream,sequence,mailbox,options);
+      sprintf (LOCAL->buf,"Invalid MMDF-format mailbox name: %.80s",mailbox);
+      MM_LOG (LOCAL->buf,ERROR);
+      return NIL;
+    default:
+      if (pc) return (*pc) (stream,sequence,mailbox,options);
+      sprintf (LOCAL->buf,"Not a MMDF-format mailbox: %.80s",mailbox);
+      MM_LOG (LOCAL->buf,ERROR);
+      return NIL;
+    }
+\f
+                               /* try to open rewrite for UIDPLUS */
+  if ((tstream = mail_open_work (&mmdfdriver,NIL,mailbox,
+                                OP_SILENT|OP_NOKOD)) && tstream->rdonly)
+    tstream = mail_close (tstream);
+  if (cu && !tstream) {                /* wanted a COPYUID? */
+    sprintf (LOCAL->buf,"Unable to write-open mailbox for COPYUID: %.80s",
+            mailbox);
+    MM_LOG (LOCAL->buf,WARN);
+    cu = NIL;                  /* don't try to do COPYUID */
+  }
+  LOCAL->buf[0] = '\0';
+  MM_CRITICAL (stream);                /* go critical */
+  if ((fd = mmdf_lock (dummy_file (file,mailbox),O_WRONLY|O_APPEND,
+                      (long) mail_parameters (NIL,GET_MBXPROTECTION,NIL),
+                      &lock,LOCK_EX)) < 0) {
+    MM_NOCRITICAL (stream);    /* done with critical */
+    sprintf (LOCAL->buf,"Can't open destination mailbox: %s",strerror (errno));
+    MM_LOG (LOCAL->buf,ERROR); /* log the error */
+    return NIL;                        /* failed */
+  }
+  fstat (fd,&sbuf);            /* get current file size */
+                               /* write all requested messages to mailbox */
+  for (i = 1; ret && (i <= stream->nmsgs); i++)
+    if ((elt = mail_elt (stream,i))->sequence) {
+      lseek (LOCAL->fd,elt->private.special.offset,L_SET);
+      read (LOCAL->fd,LOCAL->buf,elt->private.special.text.size);
+      if (write (fd,LOCAL->buf,elt->private.special.text.size) < 0) ret = NIL;
+      else {                   /* internal header succeeded */
+       s = mmdf_header (stream,i,&j,FT_INTERNAL);
+                               /* header size, sans trailing newline */
+       if (j && (s[j - 2] == '\n')) j--;
+       if (write (fd,s,j) < 0) ret = NIL;
+       else {                  /* message header succeeded */
+         j = tstream ?         /* write UIDPLUS data if have readwrite */
+           mmdf_xstatus (stream,LOCAL->buf,elt,++(tstream->uid_last),LONGT) :
+           mmdf_xstatus (stream,LOCAL->buf,elt,NIL,NIL);
+         if (write (fd,LOCAL->buf,j) < 0) ret = NIL;
+         else {                /* message status succeeded */
+           s = mmdf_text_work (stream,elt,&j,FT_INTERNAL);
+           if ((write (fd,s,j) < 0) || (write (fd,mmdfhdr,MMDFHDRLEN) < 0))
+             ret = NIL;
+           else if (cu) {      /* need to pass back new UID? */
+             mail_append_set (source,mail_uid (stream,i));
+             mail_append_set (dest,tstream->uid_last);
+           }
+         }
+       }
+      }
+    }
+\f
+  if (!ret || fsync (fd)) {    /* force out the update */
+    sprintf (LOCAL->buf,"Message copy failed: %s",strerror (errno));
+    ftruncate (fd,sbuf.st_size);
+    ret = NIL;
+  }
+                               /* force UIDVALIDITY assignment now */
+  if (tstream && !tstream->uid_validity) tstream->uid_validity = time (0);
+                               /* return sets if doing COPYUID */
+  if (cu && ret) (*cu) (stream,mailbox,tstream->uid_validity,source,dest);
+  else {                       /* flush any sets we may have built */
+    mail_free_searchset (&source);
+    mail_free_searchset (&dest);
+  }
+  tp[1] = time (0);            /* set mtime to now */
+  if (ret) tp[0] = tp[1] - 1;  /* set atime to now-1 if successful copy */
+  else tp[0] =                 /* else preserve \Marked status */
+        ((sbuf.st_ctime > sbuf.st_atime) || (sbuf.st_mtime > sbuf.st_atime)) ?
+        sbuf.st_atime : tp[1];
+  utime (file,tp);             /* set the times */
+  mmdf_unlock (fd,NIL,&lock);  /* unlock and close mailbox */
+  if (tstream) {               /* update last UID if we can */
+    MMDFLOCAL *local = (MMDFLOCAL *) tstream->local;
+    local->dirty = T;          /* do a rewrite */
+    local->appending = T;      /* but not at the cost of marking as old */
+    tstream = mail_close (tstream);
+  }
+                               /* log the error */
+  if (!ret) MM_LOG (LOCAL->buf,ERROR);
+                               /* delete if requested message */
+  else if (options & CP_MOVE) for (i = 1; i <= stream->nmsgs; i++)
+    if ((elt = mail_elt (stream,i))->sequence)
+      elt->deleted = elt->private.dirty = LOCAL->dirty = T;
+  MM_NOCRITICAL (stream);      /* release critical */
+  return ret;
+}
+\f
+/* MMDF mail append message from stringstruct
+ * Accepts: MAIL stream
+ *         destination mailbox
+ *         append callback
+ *         data for callback
+ * Returns: T if append successful, else NIL
+ */
+
+#define BUFLEN 8*MAILTMPLEN
+
+long mmdf_append (MAILSTREAM *stream,char *mailbox,append_t af,void *data)
+{
+  struct stat sbuf;
+  int fd;
+  unsigned long i;
+  char *flags,*date,buf[BUFLEN],tmp[MAILTMPLEN],file[MAILTMPLEN];
+  time_t tp[2];
+  FILE *sf,*df;
+  MESSAGECACHE elt;
+  DOTLOCK lock;
+  STRING *message;
+  unsigned long uidlocation = 0;
+  appenduid_t au = (appenduid_t)
+    (mail_parameters (NIL,GET_USERHASNOLIFE,NIL) ? NIL :
+     mail_parameters (NIL,GET_APPENDUID,NIL));
+  SEARCHSET *dst = au ? mail_newsearchset () : NIL;
+  long ret = LONGT;
+  MAILSTREAM *tstream = NIL;
+                               /* default stream to prototype */
+  if (!stream) {               /* stream specified? */
+    stream = &mmdfproto;       /* no, default stream to prototype */
+    for (i = 0; i < NUSERFLAGS && stream->user_flags[i]; ++i)
+      fs_give ((void **) &stream->user_flags[i]);
+  }
+  if (!mmdf_valid (mailbox)) switch (errno) {
+  case ENOENT:                 /* no such file? */
+    if (compare_cstring (mailbox,"INBOX")) {
+      MM_NOTIFY (stream,"[TRYCREATE] Must create mailbox before append",NIL);
+      return NIL;
+    }
+    mmdf_create (NIL,"INBOX"); /* create empty INBOX */
+  case 0:                      /* merely empty file? */
+    tstream = stream;
+    break;
+  case EACCES:                 /* file protected */
+    sprintf (tmp,"Can't access destination: %.80s",mailbox);
+    MM_LOG (tmp,ERROR);
+    return NIL;
+  case EINVAL:
+    sprintf (tmp,"Invalid MMDF-format mailbox name: %.80s",mailbox);
+    MM_LOG (tmp,ERROR);
+    return NIL;
+  default:
+    sprintf (tmp,"Not a MMDF-format mailbox: %.80s",mailbox);
+    MM_LOG (tmp,ERROR);
+    return NIL;
+  }
+                               /* get sniffing stream for keywords */
+  else if (!(tstream = mail_open (NIL,mailbox,
+                                 OP_READONLY|OP_SILENT|OP_NOKOD|OP_SNIFF))) {
+    sprintf (tmp,"Unable to examine mailbox for APPEND: %.80s",mailbox);
+    MM_LOG (tmp,ERROR);
+    return NIL;
+  }
+\f
+                               /* get first message */
+  if (!MM_APPEND (af) (tstream,data,&flags,&date,&message)) return NIL;
+  if (!(sf = tmpfile ())) {    /* must have scratch file */
+    sprintf (tmp,".%lx.%lx",(unsigned long) time (0),(unsigned long)getpid ());
+    if (!stat (tmp,&sbuf) || !(sf = fopen (tmp,"wb+"))) {
+      sprintf (tmp,"Unable to create scratch file: %.80s",strerror (errno));
+      MM_LOG (tmp,ERROR);
+      return NIL;
+    }
+    unlink (tmp);
+  }
+  do {                         /* parse date */
+    if (!date) rfc822_date (date = tmp);
+    if (!mail_parse_date (&elt,date)) {
+      sprintf (tmp,"Bad date in append: %.80s",date);
+      MM_LOG (tmp,ERROR);
+    }
+    else {                     /* user wants to suppress time zones? */
+      if (mail_parameters (NIL,GET_NOTIMEZONES,NIL)) {
+       time_t when = mail_longdate (&elt);
+       date = ctime (&when);   /* use traditional date */
+      }
+                               /* use POSIX-style date */
+      else date = mail_cdate (tmp,&elt);
+      if (!SIZE (message)) MM_LOG ("Append of zero-length message",ERROR);
+      else if (!mmdf_collect_msg (tstream,sf,flags,date,message)) {
+       sprintf (tmp,"Error writing scratch file: %.80s",strerror (errno));
+       MM_LOG (tmp,ERROR);
+      }
+                               /* get next message */
+      else if (MM_APPEND (af) (tstream,data,&flags,&date,&message)) continue;
+    }
+    fclose (sf);               /* punt scratch file */
+    return NIL;                        /* give up */
+  } while (message);           /* until no more messages */
+  if (fflush (sf)) {
+    sprintf (tmp,"Error finishing scratch file: %.80s",strerror (errno));
+    MM_LOG (tmp,ERROR);
+    fclose (sf);               /* punt scratch file */
+    return NIL;                        /* give up */
+  }
+  i = ftell (sf);              /* size of scratch file */
+  if (tstream != stream) tstream = mail_close (tstream);
+\f
+  MM_CRITICAL (stream);                /* go critical */
+                               /* try to open readwrite for UIDPLUS */
+  if ((tstream = mail_open_work (&mmdfdriver,NIL,mailbox,
+                                OP_SILENT|OP_NOKOD)) && tstream->rdonly)
+    tstream = mail_close (tstream);
+  if (au && !tstream) {                /* wanted an APPENDUID? */
+    sprintf (tmp,"Unable to re-open mailbox for APPENDUID: %.80s",mailbox);
+    MM_LOG (tmp,WARN);
+    au = NIL;
+  }
+  if (((fd = mmdf_lock (dummy_file (file,mailbox),O_WRONLY|O_APPEND,
+                       (long) mail_parameters (NIL,GET_MBXPROTECTION,NIL),
+                       &lock,LOCK_EX)) < 0) ||
+      !(df = fdopen (fd,"ab"))) {
+    MM_NOCRITICAL (stream);    /* done with critical */
+    sprintf (tmp,"Can't open append mailbox: %s",strerror (errno));
+    MM_LOG (tmp,ERROR);
+    return NIL;
+  }
+  fstat (fd,&sbuf);            /* get current file size */
+  rewind (sf);
+  tp[1] = time (0);            /* set mtime to now */
+                               /* write all messages */
+  if (!mmdf_append_msgs (tstream,sf,df,au ? dst : NIL) ||
+      (fflush (df) == EOF) || fsync (fd)) {
+    sprintf (buf,"Message append failed: %s",strerror (errno));
+    MM_LOG (buf,ERROR);
+    ftruncate (fd,sbuf.st_size);
+    tp[0] =                    /* preserve \Marked status */
+      ((sbuf.st_ctime > sbuf.st_atime) || (sbuf.st_mtime > sbuf.st_atime)) ?
+      sbuf.st_atime : tp[1];
+    ret = NIL;                 /* return error */
+  }
+  else tp[0] = tp[1] - 1;      /* set atime to now-1 if successful copy */
+  utime (file,tp);             /* set the times */
+  fclose (sf);                 /* done with scratch file */
+                               /* force UIDVALIDITY assignment now */
+  if (tstream && !tstream->uid_validity) tstream->uid_validity = time (0);
+                               /* return sets if doing APPENDUID */
+  if (au && ret) (*au) (mailbox,tstream->uid_validity,dst);
+  else mail_free_searchset (&dst);
+  mmdf_unlock (fd,NIL,&lock);  /* unlock and close mailbox */
+  fclose (df);
+  if (tstream) {               /* update last UID if we can */
+    MMDFLOCAL *local = (MMDFLOCAL *) tstream->local;
+    local->dirty = T;          /* do a rewrite */
+    local->appending = T;      /* but not at the cost of marking as old */
+    tstream = mail_close (tstream);
+  }
+  MM_NOCRITICAL (stream);      /* release critical */
+  return ret;
+}
+\f
+/* Collect and write single message to append scratch file
+ * Accepts: MAIL stream
+ *         scratch file
+ *         flags
+ *         date
+ *         message stringstruct
+ * Returns: NIL if write error, else T
+ */
+
+int mmdf_collect_msg (MAILSTREAM *stream,FILE *sf,char *flags,char *date,
+                    STRING *msg)
+{
+  unsigned char *s,*t;
+  unsigned long uf;
+  long f = mail_parse_flags (stream,flags,&uf);
+                               /* write metadata, note date ends with NL */
+  if (fprintf (sf,"%ld %lu %s",f,SIZE (msg) + 1,date) < 0) return NIL;
+  while (uf)                   /* write user flags */    
+    if ((s = stream->user_flags[find_rightmost_bit (&uf)]) &&
+       (fprintf (sf," %s",s) < 0)) return NIL;
+  if (putc ('\n',sf) == EOF) return NIL;
+  while (SIZE (msg)) {         /* copy text to scratch file */
+    for (s = (unsigned char *) msg->curpos, t = s + msg->cursize; s < t; ++s)
+      if (!*s) *s = 0x80;      /* disallow NUL */
+                               /* write buffered text */
+    if (fwrite (msg->curpos,1,msg->cursize,sf) == msg->cursize)
+      SETPOS (msg,GETPOS (msg) + msg->cursize);
+    else return NIL;           /* failed */
+  }
+                               /* write trailing newline and return */
+  return (putc ('\n',sf) == EOF) ? NIL : T;
+}
+\f
+/* Append messages from scratch file to mailbox
+ * Accepts: MAIL stream
+ *         source file
+ *         destination file
+ *         uidset to update if non-NIL
+ * Returns: T if success, NIL if failure
+ */
+
+int mmdf_append_msgs (MAILSTREAM *stream,FILE *sf,FILE *df,SEARCHSET *set)
+{
+  int c;
+  long f;
+  unsigned long i,j;
+  char *x,tmp[MAILTMPLEN];
+  int hdrp = T;
+                               /* get message metadata line */
+  while (fgets (tmp,MAILTMPLEN,sf)) {
+    if (!(isdigit (tmp[0]) && strchr (tmp,'\n'))) return NIL;
+    f = strtol (tmp,&x,10);    /* get flags */
+    if (!((*x++ == ' ') && isdigit (*x))) return NIL;
+    i = strtoul (x,&x,10);     /* get message size */
+    if ((*x++ != ' ') ||       /* build initial header */
+       (fprintf (df,"%sFrom %s@%s %sStatus: ",mmdfhdr,myusername(),
+                 mylocalhost(),x) < 0) ||
+       (f&fSEEN && (putc ('R',df) == EOF)) ||
+       (fputs ("\nX-Status: ",df) == EOF) ||
+       (f&fDELETED && (putc ('D',df) == EOF)) ||
+       (f&fFLAGGED && (putc ('F',df) == EOF)) ||
+       (f&fANSWERED && (putc ('A',df) == EOF)) ||
+       (f&fDRAFT && (putc ('T',df) == EOF)) ||
+       (fputs ("\nX-Keywords:",df) == EOF)) return NIL;
+                               /* copy keywords */
+    while ((c = getc (sf)) != '\n') switch (c) {
+    case EOF:
+      return NIL;
+    default:
+      if (putc (c,df) == EOF) return NIL;
+    }
+    if ((putc ('\n',df) == EOF) ||
+       (set && (fprintf (df,"X-UID: %lu\n",++(stream->uid_last)) < 0)))
+      return NIL;
+\f
+    for (c = '\n'; i && fgets (tmp,MAILTMPLEN,sf); c = tmp[j-1]) {
+                               /* get read line length */
+      if (i < (j = strlen (tmp))) fatal ("mmdf_append_msgs overrun");
+      i -= j;                  /* number of bytes left */
+                               /* squish out ^A and CRs (note copies NUL) */
+      for (x = tmp; x = strpbrk (x,"\01\r"); --j) memmove (x,x+1,j-(x-tmp));
+      if (!j) continue;                /* do nothing if line emptied */
+                               /* start of line? */
+      if ((c == '\n')) switch (tmp[0]) {
+      case 'S': case 's':      /* possible "Status:" */
+       if (hdrp && (j > 6) && ((tmp[1] == 't') || (tmp[1] == 'T')) &&
+           ((tmp[2] == 'a') || (tmp[2] == 'A')) &&
+           ((tmp[3] == 't') || (tmp[3] == 'T')) &&
+           ((tmp[4] == 'u') || (tmp[4] == 'U')) &&
+           ((tmp[5] == 's') || (tmp[5] == 'S')) && (tmp[6] == ':') &&
+           (fputs ("X-Original-",df) == EOF)) return NIL;
+       break;
+      case 'X': case 'x':      /* possible X-??? header */
+       if (hdrp && (tmp[1] == '-') &&
+                               /* possible X-UID: */
+           (((j > 5) && ((tmp[2] == 'U') || (tmp[2] == 'u')) &&
+             ((tmp[3] == 'I') || (tmp[3] == 'i')) &&
+             ((tmp[4] == 'D') || (tmp[4] == 'd')) && (tmp[5] == ':')) ||
+                               /* possible X-IMAP: */
+            ((j > 6) && ((tmp[2] == 'I') || (tmp[2] == 'i')) &&
+             ((tmp[3] == 'M') || (tmp[3] == 'm')) &&
+             ((tmp[4] == 'A') || (tmp[4] == 'a')) &&
+             ((tmp[5] == 'P') || (tmp[5] == 'p')) &&
+             ((tmp[6] == ':') ||
+                               /* or X-IMAPbase: */
+              ((j > 10) && ((tmp[6] == 'b') || (tmp[6] == 'B')) &&
+               ((tmp[7] == 'a') || (tmp[7] == 'A')) &&
+               ((tmp[8] == 's') || (tmp[8] == 'S')) &&
+               ((tmp[9] == 'e') || (tmp[9] == 'E')) && (tmp[10] == ':')))) ||
+                               /* possible X-Status: */
+            ((j > 8) && ((tmp[2] == 'S') || (tmp[2] == 's')) &&
+             ((tmp[3] == 't') || (tmp[3] == 'T')) &&
+             ((tmp[4] == 'a') || (tmp[4] == 'A')) &&
+             ((tmp[5] == 't') || (tmp[5] == 'T')) &&
+             ((tmp[6] == 'u') || (tmp[6] == 'U')) &&
+             ((tmp[7] == 's') || (tmp[7] == 'S')) && (tmp[8] == ':')) ||
+                               /* possible X-Keywords: */
+            ((j > 10) && ((tmp[2] == 'K') || (tmp[2] == 'k')) &&
+             ((tmp[3] == 'e') || (tmp[3] == 'E')) &&
+             ((tmp[4] == 'y') || (tmp[4] == 'Y')) &&
+             ((tmp[5] == 'w') || (tmp[5] == 'W')) &&
+             ((tmp[6] == 'o') || (tmp[6] == 'O')) &&
+             ((tmp[7] == 'r') || (tmp[7] == 'R')) &&
+             ((tmp[8] == 'd') || (tmp[8] == 'D')) &&
+             ((tmp[9] == 's') || (tmp[9] == 'S')) && (tmp[10] == ':'))) &&
+           (fputs ("X-Original-",df) == EOF)) return NIL;
+       break;
+      case '\n':               /* blank line */
+       hdrp = NIL;
+       break;
+      default:                 /* nothing to do */
+       break;
+      }
+                               /* just write the line */
+      if (fwrite (tmp,1,j,df) != j) return NIL;
+    }
+                               /* make sure read entire msg & wrote trailer */
+    if (i || (fputs (mmdfhdr,df) == EOF)) return NIL;
+                               /* update set */
+    if (stream) mail_append_set (set,stream->uid_last);
+  }
+  return T;
+}
+\f
+/* Internal routines */
+
+
+/* MMDF mail abort stream
+ * Accepts: MAIL stream
+ */
+
+void mmdf_abort (MAILSTREAM *stream)
+{
+  if (LOCAL) {                 /* only if a file is open */
+    if (LOCAL->fd >= 0) close (LOCAL->fd);
+    if (LOCAL->ld >= 0) {      /* have a mailbox lock? */
+      flock (LOCAL->ld,LOCK_UN);/* yes, release the lock */
+      close (LOCAL->ld);       /* close the lock file */
+      unlink (LOCAL->lname);   /* and delete it */
+    }
+    if (LOCAL->lname) fs_give ((void **) &LOCAL->lname);
+                               /* free local text buffers */
+    if (LOCAL->buf) fs_give ((void **) &LOCAL->buf);
+    if (LOCAL->text.data) fs_give ((void **) &LOCAL->text.data);
+    if (LOCAL->linebuf) fs_give ((void **) &LOCAL->linebuf);
+    if (LOCAL->line) fs_give ((void **) &LOCAL->line);
+                               /* nuke the local data */
+    fs_give ((void **) &stream->local);
+    stream->dtb = NIL;         /* log out the DTB */
+  }
+}
+\f
+/* MMDF open and lock mailbox
+ * Accepts: file name to open/lock
+ *         file open mode
+ *         destination buffer for lock file name
+ *         type of locking operation (LOCK_SH or LOCK_EX)
+ */
+
+int mmdf_lock (char *file,int flags,int mode,DOTLOCK *lock,int op)
+{
+  int fd;
+  blocknotify_t bn = (blocknotify_t) mail_parameters (NIL,GET_BLOCKNOTIFY,NIL);
+  (*bn) (BLOCK_FILELOCK,NIL);
+                               /* try locking the easy way */
+  if (dotlock_lock (file,lock,-1)) {
+                               /* got dotlock file, easy open */
+    if ((fd = open (file,flags,mode)) >= 0) flock (fd,op);
+    else dotlock_unlock (lock);        /* open failed, free the dotlock */
+  }
+                               /* no dot lock file, open file now */
+  else if ((fd = open (file,flags,mode)) >= 0) {
+                               /* try paranoid way to make a dot lock file */
+    if (dotlock_lock (file,lock,fd)) {
+      close (fd);              /* get fresh fd in case of timing race */
+      if ((fd = open (file,flags,mode)) >= 0) flock (fd,op);
+                               /* open failed, free the dotlock */
+      else dotlock_unlock (lock);
+    }
+    else flock (fd,op);                /* paranoid way failed, just flock() it */
+  }
+  (*bn) (BLOCK_NONE,NIL);
+  return fd;
+}
+\f
+/* MMDF unlock and close mailbox
+ * Accepts: file descriptor
+ *         (optional) mailbox stream to check atime/mtime
+ *         (optional) lock file name
+ */
+
+void mmdf_unlock (int fd,MAILSTREAM *stream,DOTLOCK *lock)
+{
+  if (stream) {                        /* need to muck with times? */
+    struct stat sbuf;
+    time_t tp[2];
+    time_t now = time (0);
+    fstat (fd,&sbuf);          /* get file times */
+    if (LOCAL->ld >= 0) {      /* yes, readwrite session? */
+      tp[0] = now;             /* set atime to now */
+                               /* set mtime to (now - 1) if necessary */
+      tp[1] = (now > sbuf.st_mtime) ? sbuf.st_mtime : now - 1;
+    }
+    else if (stream->recent) { /* readonly with recent messages */
+      if ((sbuf.st_atime >= sbuf.st_mtime) ||
+         (sbuf.st_atime >= sbuf.st_ctime))
+                               /* keep past mtime, whack back atime */
+       tp[0] = (tp[1] = (sbuf.st_mtime < now) ? sbuf.st_mtime : now) - 1;
+      else now = 0;            /* no time change needed */
+    }
+                               /* readonly with no recent messages */
+    else if ((sbuf.st_atime < sbuf.st_mtime) ||
+            (sbuf.st_atime < sbuf.st_ctime)) {
+      tp[0] = now;             /* set atime to now */
+                               /* set mtime to (now - 1) if necessary */
+      tp[1] = (now > sbuf.st_mtime) ? sbuf.st_mtime : now - 1;
+    }
+    else now = 0;              /* no time change needed */
+                               /* set the times, note change */
+    if (now && !utime (stream->mailbox,tp)) LOCAL->filetime = tp[1];
+  }
+  flock (fd,LOCK_UN);          /* release flock'ers */
+  if (!stream) close (fd);     /* close the file if no stream */
+  dotlock_unlock (lock);       /* flush the lock file if any */
+}
+\f
+/* MMDF mail parse and lock mailbox
+ * Accepts: MAIL stream
+ *         space to write lock file name
+ *         type of locking operation
+ * Returns: T if parse OK, critical & mailbox is locked shared; NIL if failure
+ */
+
+int mmdf_parse (MAILSTREAM *stream,DOTLOCK *lock,int op)
+{
+  int ti,zn,m;
+  unsigned long i,j,k;
+  unsigned char c,*s,*t,*u,tmp[MAILTMPLEN],date[30];
+  int retain = T;
+  unsigned long nmsgs = stream->nmsgs;
+  unsigned long prevuid = nmsgs ? mail_elt (stream,nmsgs)->private.uid : 0;
+  unsigned long recent = stream->recent;
+  unsigned long oldnmsgs = stream->nmsgs;
+  short silent = stream->silent;
+  short pseudoseen = NIL;
+  struct stat sbuf;
+  STRING bs;
+  FDDATA d;
+  MESSAGECACHE *elt;
+  mail_lock (stream);          /* guard against recursion or pingers */
+                               /* toss out previous descriptor */
+  if (LOCAL->fd >= 0) close (LOCAL->fd);
+  MM_CRITICAL (stream);                /* open and lock mailbox (shared OK) */
+  if ((LOCAL->fd = mmdf_lock (stream->mailbox,(LOCAL->ld >= 0) ?
+                             O_RDWR : O_RDONLY,
+                             (long)mail_parameters(NIL,GET_MBXPROTECTION,NIL),
+                             lock,op)) < 0) {
+    sprintf (tmp,"Mailbox open failed, aborted: %s",strerror (errno));
+    MM_LOG (tmp,ERROR);
+    mmdf_abort (stream);
+    mail_unlock (stream);
+    MM_NOCRITICAL (stream);    /* done with critical */
+    return NIL;
+  }
+  fstat (LOCAL->fd,&sbuf);     /* get status */
+                               /* validate change in size */
+  if (sbuf.st_size < LOCAL->filesize) {
+    sprintf (tmp,"Mailbox shrank from %lu to %lu bytes, aborted",
+            (unsigned long) LOCAL->filesize,(unsigned long) sbuf.st_size);
+    MM_LOG (tmp,ERROR);                /* this is pretty bad */
+    mmdf_unlock (LOCAL->fd,stream,lock);
+    mmdf_abort (stream);
+    mail_unlock (stream);
+    MM_NOCRITICAL (stream);    /* done with critical */
+    return NIL;
+  }
+\f
+                               /* new data? */
+  else if (i = sbuf.st_size - LOCAL->filesize) {
+    d.fd = LOCAL->fd;          /* yes, set up file descriptor */
+    d.pos = LOCAL->filesize;   /* get to that position in the file */
+    d.chunk = LOCAL->buf;      /* initial buffer chunk */
+    d.chunksize = CHUNKSIZE;   /* file chunk size */
+    INIT (&bs,fd_string,&d,i); /* initialize stringstruct */
+                               /* skip leading whitespace for broken MTAs */
+    while (((c = CHR (&bs)) == '\n') || (c == '\r') ||
+          (c == ' ') || (c == '\t')) SNX (&bs);
+    if (SIZE (&bs)) {          /* read new data */
+                               /* remember internal header position */
+      j = LOCAL->filesize + GETPOS (&bs);
+      s = mmdf_mbxline (stream,&bs,&i);
+      stream->silent = T;      /* quell main program new message events */
+      do {                     /* read MMDF header */
+       if (!(i && ISMMDF (s))){/* see if valid MMDF header */
+         sprintf (tmp,"Unexpected changes to mailbox (try restarting): %.20s",
+                  (char *) s);
+                               /* see if we can back up to a line */
+         if (i && (j > MMDFHDRLEN)) {
+           SETPOS (&bs,j -= MMDFHDRLEN);
+                               /* read previous line */
+           s = mmdf_mbxline (stream,&bs,&i);
+                               /* kill the error if it looks good */
+           if (i && ISMMDF (s)) tmp[0] = '\0';
+         }
+         if (tmp[0]) {
+           MM_LOG (tmp,ERROR);
+           mmdf_unlock (LOCAL->fd,stream,lock);
+           mmdf_abort (stream);
+           mail_unlock (stream);
+           MM_NOCRITICAL (stream);
+           return NIL;
+         }
+       }
+                               /* instantiate first new message */
+       mail_exists (stream,++nmsgs);
+       (elt = mail_elt (stream,nmsgs))->valid = T;
+       recent++;               /* assume recent by default */
+       elt->recent = T;
+                               /* note position/size of internal header */
+       elt->private.special.offset = j;
+       elt->private.special.text.size = i;
+\f
+       s = mmdf_mbxline (stream,&bs,&i);
+       ti = 0;                 /* assume not a valid date */
+       zn = 0,t = NIL;
+       if (i) VALID (s,t,ti,zn);
+       if (ti) {               /* generate plausible IMAPish date string */
+                               /* this is also part of header */
+         elt->private.special.text.size += i;
+         date[2] = date[6] = date[20] = '-'; date[11] = ' ';
+         date[14] = date[17] = ':';
+                               /* dd */
+         date[0] = t[ti - 2]; date[1] = t[ti - 1];
+                               /* mmm */
+         date[3] = t[ti - 6]; date[4] = t[ti - 5]; date[5] = t[ti - 4];
+                               /* hh */
+         date[12] = t[ti + 1]; date[13] = t[ti + 2];
+                               /* mm */
+         date[15] = t[ti + 4]; date[16] = t[ti + 5];
+         if (t[ti += 6]==':'){ /* ss */
+           date[18] = t[++ti]; date[19] = t[++ti];
+           ti++;               /* move to space */
+         }
+         else date[18] = date[19] = '0';
+                               /* yy -- advance over timezone if necessary */
+         if (zn == ti) ti += (((t[zn+1] == '+') || (t[zn+1] == '-')) ? 6 : 4);
+         date[7] = t[ti + 1]; date[8] = t[ti + 2];
+         date[9] = t[ti + 3]; date[10] = t[ti + 4];
+                               /* zzz */
+         t = zn ? (t + zn + 1) : (unsigned char *) "LCL";
+         date[21] = *t++; date[22] = *t++; date[23] = *t++;
+         if ((date[21] != '+') && (date[21] != '-')) date[24] = '\0';
+         else {                /* numeric time zone */
+           date[24] = *t++; date[25] = *t++;
+           date[26] = '\0'; date[20] = ' ';
+         }
+                               /* set internal date */
+         if (!mail_parse_date (elt,date)) {
+           sprintf (tmp,"Unable to parse internal date: %s",(char *) date);
+           MM_LOG (tmp,WARN);
+         }
+       }
+       else {                  /* make date from file date */
+         struct tm *tm = gmtime (&sbuf.st_mtime);
+         elt->day = tm->tm_mday; elt->month = tm->tm_mon + 1;
+         elt->year = tm->tm_year + 1900 - BASEYEAR;
+         elt->hours = tm->tm_hour; elt->minutes = tm->tm_min;
+         elt->seconds = tm->tm_sec;
+         elt->zhours = 0; elt->zminutes = 0;
+         t = NIL;              /* suppress line read */
+       }
+                               /* header starts here */
+       elt->private.msg.header.offset = elt->private.special.text.size;
+\f
+       do {                    /* look for message body */
+         j = GETPOS (&bs);     /* note position before line */
+         if (t) s = t = mmdf_mbxline (stream,&bs,&i);
+         else t = s;           /* this line read was suppressed */
+         if (ISMMDF (s)) {     /* found terminator in header? */
+           SETPOS (&bs,j);     /* oops, back up before line */
+                               /* must insert a newline */
+           elt->private.spare.data++;
+           break;              /* punt */
+         }
+                               /* this line is part of header */
+         elt->private.msg.header.text.size += i;
+         if (i) switch (*s) {  /* check header lines */
+         case 'X':             /* possible X-???: line */
+           if (s[1] == '-') {  /* must be immediately followed by hyphen */
+                               /* X-Status: becomes Status: in S case */
+             if (s[2] == 'S' && s[3] == 't' && s[4] == 'a' && s[5] == 't' &&
+                 s[6] == 'u' && s[7] == 's' && s[8] == ':') s += 2;
+                               /* possible X-Keywords */
+             else if (s[2] == 'K' && s[3] == 'e' && s[4] == 'y' &&
+                      s[5] == 'w' && s[6] == 'o' && s[7] == 'r' &&
+                      s[8] == 'd' && s[9] == 's' && s[10] == ':') {
+               SIZEDTEXT uf;
+               retain = NIL;   /* don't retain continuation */
+               s += 11;        /* flush leading whitespace */
+               while (*s && (*s != '\n') && ((*s != '\r') || (s[1] != '\n'))){
+                 while (*s == ' ') s++;
+                               /* find end of keyword */
+                 if (!(u = strpbrk (s," \n\r"))) u = s + strlen (s);
+                               /* got a keyword? */
+                 if ((k = (u - s)) <= MAXUSERFLAG) {
+                   uf.data = (unsigned char *) s;
+                   uf.size = k;
+                   for (j = 0; (j < NUSERFLAGS) && stream->user_flags[j]; ++j)
+                     if (!compare_csizedtext (stream->user_flags[j],&uf)) {
+                       elt->user_flags |= ((long) 1) << j;
+                       break;
+                     }
+                 }
+                 s = u;        /* advance to next keyword */
+               }
+               break;
+             }
+\f
+                               /* possible X-IMAP */
+             else if ((s[2] == 'I') && (s[3] == 'M') && (s[4] == 'A') &&
+                      (s[5] == 'P') && ((m = (s[6] == ':')) ||
+                                        ((s[6] == 'b') && (s[7] == 'a') &&
+                                         (s[8] == 's') && (s[9] == 'e') &&
+                                         (s[10] == ':')))) {
+               retain = NIL;   /* don't retain continuation */
+               if ((nmsgs == 1) && !stream->uid_validity) {
+                               /* advance to data */
+                 s += m ? 7 : 11;
+                               /* flush whitespace */
+                 while (*s == ' ') s++;
+                 j = 0;        /* slurp UID validity */
+                               /* found a digit? */
+                 while (isdigit (*s)) {
+                   j *= 10;    /* yes, add it in */
+                   j += *s++ - '0';
+                 }
+                               /* flush whitespace */
+                 while (*s == ' ') s++;
+                               /* must have valid UID validity and UID last */
+                 if (j && isdigit (*s)) {
+                               /* pseudo-header seen if X-IMAP */
+                   if (m) pseudoseen = LOCAL->pseudo = T;
+                               /* save UID validity */
+                   stream->uid_validity = j;
+                   j = 0;      /* slurp UID last */
+                   while (isdigit (*s)) {
+                     j *= 10;  /* yes, add it in */
+                     j += *s++ - '0';
+                   }
+                               /* save UID last */
+                   stream->uid_last = j;
+                               /* process keywords */
+                   for (j = 0; (*s != '\n') && ((*s != '\r')||(s[1] != '\n'));
+                        s = u,j++) {
+                               /* flush leading whitespace */
+                     while (*s == ' ') s++;
+                     u = strpbrk (s," \n\r");
+                               /* got a keyword? */
+                     if ((j < NUSERFLAGS) && ((k = (u - s)) <= MAXUSERFLAG)) {
+                       if (stream->user_flags[j])
+                         fs_give ((void **) &stream->user_flags[j]);
+                       stream->user_flags[j] = (char *) fs_get (k + 1);
+                       strncpy (stream->user_flags[j],s,k);
+                       stream->user_flags[j][k] = '\0';
+                     }
+                   }
+                 }
+               }
+               break;
+             }
+\f
+                               /* possible X-UID */
+             else if (s[2] == 'U' && s[3] == 'I' && s[4] == 'D' &&
+                      s[5] == ':') {
+               retain = NIL;   /* don't retain continuation */
+                               /* only believe if have a UID validity */
+               if (stream->uid_validity && ((nmsgs > 1) || !pseudoseen)) {
+                 s += 6;       /* advance to UID value */
+                               /* flush whitespace */
+                 while (*s == ' ') s++;
+                 j = 0;
+                               /* found a digit? */
+                 while (isdigit (*s)) {
+                   j *= 10;    /* yes, add it in */
+                   j += *s++ - '0';
+                 }
+                               /* flush remainder of line */
+                 while (*s != '\n') s++;
+                               /* make sure not duplicated */
+                 if (elt->private.uid)
+                   sprintf (tmp,"Message %lu UID %lu already has UID %lu",
+                            pseudoseen ? elt->msgno - 1 : elt->msgno,
+                            j,elt->private.uid);
+                               /* make sure UID doesn't go backwards */
+                 else if (j <= prevuid)
+                   sprintf (tmp,"Message %lu UID %lu less than %lu",
+                            pseudoseen ? elt->msgno - 1 : elt->msgno,
+                            j,prevuid + 1);
+#if 0  /* this is currently broken by UIDPLUS */
+                               /* or skip by mailbox's recorded last */
+                 else if (j > stream->uid_last)
+                   sprintf (tmp,"Message %lu UID %lu greater than last %lu",
+                            pseudoseen ? elt->msgno - 1 : elt->msgno,
+                            j,stream->uid_last);
+#endif
+                 else {        /* normal UID case */
+                   prevuid = elt->private.uid = j;
+#if 1  /* temporary kludge for UIDPLUS */
+                   if (prevuid > stream->uid_last) {
+                     stream->uid_last = prevuid;
+                     LOCAL->ddirty = LOCAL->dirty = T;
+                   }               
+#endif
+                   break;      /* exit this cruft */
+                 }
+                 MM_LOG (tmp,WARN);
+                               /* invalidate UID validity */
+                 stream->uid_validity = 0;
+                 elt->private.uid = 0;
+               }
+               break;
+             }
+           }
+                               /* otherwise fall into S case */
+\f
+         case 'S':             /* possible Status: line */
+           if (s[0] == 'S' && s[1] == 't' && s[2] == 'a' && s[3] == 't' &&
+               s[4] == 'u' && s[5] == 's' && s[6] == ':') {
+             retain = NIL;     /* don't retain continuation */
+             s += 6;           /* advance to status flags */
+             do switch (*s++) {/* parse flags */
+             case 'R':         /* message read */
+               elt->seen = T;
+               break;
+             case 'O':         /* message old */
+               if (elt->recent) {
+                 elt->recent = NIL;
+                 recent--;     /* it really wasn't recent */
+               }
+               break;
+             case 'D':         /* message deleted */
+               elt->deleted = T;
+               break;
+             case 'F':         /* message flagged */
+               elt->flagged = T;
+               break;
+             case 'A':         /* message answered */
+               elt->answered = T;
+               break;
+             case 'T':         /* message is a draft */
+               elt->draft = T;
+               break;
+             default:          /* some other crap */
+               break;
+             } while (*s && (*s != '\n') && ((*s != '\r') || (s[1] != '\n')));
+             break;            /* all done */
+           }
+                               /* otherwise fall into default case */
+\f
+         default:              /* ordinary header line */
+           if ((*s == 'S') || (*s == 's') ||
+               (((*s == 'X') || (*s == 'x')) && (s[1] == '-'))) {
+             unsigned char *e,*v;
+                               /* must match what mail_filter() does */
+             for (u = s,v = tmp,e = u + min (i,MAILTMPLEN - 1);
+                  (u < e) && ((c = (*u ? *u : (*u = ' '))) != ':') &&
+                  ((c > ' ') || ((c != ' ') && (c != '\t') &&
+                                 (c != '\r') && (c != '\n')));
+                  *v++ = *u++);
+             *v = '\0';        /* tie off */
+                               /* matches internal header? */
+             if (!compare_cstring (tmp,"STATUS") ||
+                 !compare_cstring (tmp,"X-STATUS") ||
+                 !compare_cstring (tmp,"X-KEYWORDS") ||
+                 !compare_cstring (tmp,"X-UID") ||
+                 !compare_cstring (tmp,"X-IMAP") ||
+                 !compare_cstring (tmp,"X-IMAPBASE")) {
+               char err[MAILTMPLEN];
+               sprintf (err,"Discarding bogus %s header in message %lu",
+                        (char *) tmp,elt->msgno);
+               MM_LOG (err,WARN);
+               retain = NIL;   /* don't retain continuation */
+               break;          /* different case or something */
+             }
+           }
+                               /* retain or non-continuation? */
+           if (retain || ((*s != ' ') && (*s != '\t'))) {
+             retain = T;       /* retaining continuation now */
+                               /* line length in LF format newline */
+             for (j = k = 0; j < i; ++j) if (s[j] != '\r') ++k;
+                               /* "internal" header size */
+             elt->private.spare.data += k;
+                               /* message size */
+             elt->rfc822_size += k + 1;
+           }
+           else {
+             char err[MAILTMPLEN];
+             sprintf (err,"Discarding bogus continuation in msg %lu: %.80s",
+                     elt->msgno,(char *) s);
+             if (u = strpbrk (err,"\r\n")) *u = '\0';
+             MM_LOG (err,WARN);
+             break;            /* different case or something */
+           }
+           break;
+         }
+       } while (i && (*t != '\n') && ((*t != '\r') || (t[1] != '\n')));
+                               /* "internal" header sans trailing newline */
+       if (i) elt->private.spare.data--;
+                               /* assign a UID if none found */
+       if (((nmsgs > 1) || !pseudoseen) && !elt->private.uid) {
+         prevuid = elt->private.uid = ++stream->uid_last;
+         elt->private.dirty = T;
+       }
+       else elt->private.dirty = elt->recent;
+\f
+                               /* note size of header, location of text */
+       elt->private.msg.header.text.size =
+         (elt->private.msg.text.offset =
+          (LOCAL->filesize + GETPOS (&bs)) - elt->private.special.offset) -
+            elt->private.special.text.size;
+                               /* note current position */
+       j = LOCAL->filesize + GETPOS (&bs);
+       if (i) do {             /* look for next message */
+         s = mmdf_mbxline (stream,&bs,&i);
+         if (i) {              /* got new data? */
+           if (ISMMDF (s)) break;
+           else {              /* not a header line, add it to message */
+             elt->rfc822_size += i;
+             for (j = 0; j < i; ++j) switch (s[j]) {
+             case '\r':        /* squeeze out CRs */
+               elt->rfc822_size -= 1;
+               break;
+             case '\n':        /* LF becomes CRLF */
+               elt->rfc822_size += 1;
+               break;
+             default:
+               break;
+             }
+                               /* update current position */
+             j = LOCAL->filesize + GETPOS (&bs);
+           }
+         }
+       } while (i);            /* until found a header */
+       elt->private.msg.text.text.size = j -
+         (elt->private.special.offset + elt->private.msg.text.offset);
+       if (i) {                /* get next header line */
+                               /* remember first internal header position */
+         j = LOCAL->filesize + GETPOS (&bs);
+         s = mmdf_mbxline (stream,&bs,&i);
+       }
+                               /* until end of buffer */
+      } while (!stream->sniff && i);
+      if (pseudoseen) {                /* flush pseudo-message if present */
+                               /* decrement recent count */
+       if (mail_elt (stream,1)->recent) recent--;
+                               /* and the exists count */
+       mail_exists (stream,nmsgs--);
+       mail_expunged(stream,1);/* fake an expunge of that message */
+      }
+                               /* need to start a new UID validity? */
+      if (!stream->uid_validity) {
+       stream->uid_validity = time (0);
+                               /* in case a whiner with no life */
+       if (mail_parameters (NIL,GET_USERHASNOLIFE,NIL))
+         stream->uid_nosticky = T;
+       else if (nmsgs) {       /* don't bother if empty file */
+                               /* make dirty to restart UID epoch */
+         LOCAL->ddirty = LOCAL->dirty = T;
+                               /* need to rewrite msg 1 if not pseudo */
+         if (!LOCAL->pseudo) mail_elt (stream,1)->private.dirty = T;
+         MM_LOG ("Assigning new unique identifiers to all messages",NIL);
+       }
+      }
+      stream->nmsgs = oldnmsgs;        /* whack it back down */
+      stream->silent = silent; /* restore old silent setting */
+                               /* notify upper level of new mailbox sizes */
+      mail_exists (stream,nmsgs);
+      mail_recent (stream,recent);
+                               /* mark dirty so O flags are set */
+      if (recent) LOCAL->dirty = T;
+    }
+  }
+                               /* no change, don't babble if never got time */
+  else if (LOCAL->filetime && LOCAL->filetime != sbuf.st_mtime)
+    MM_LOG ("New mailbox modification time but apparently no changes",WARN);
+                               /* update parsed file size and time */
+  LOCAL->filesize = sbuf.st_size;
+  LOCAL->filetime = sbuf.st_mtime;
+  return T;                    /* return the winnage */
+}
+\f
+/* MMDF read line from mailbox
+ * Accepts: mail stream
+ *         stringstruct
+ *         pointer to line size
+ * Returns: pointer to input line
+ */
+
+char *mmdf_mbxline (MAILSTREAM *stream,STRING *bs,unsigned long *size)
+{
+  unsigned long i,j,k,m;
+  char *s,*t,*te;
+  char *ret = "";
+                               /* flush old buffer */
+  if (LOCAL->line) fs_give ((void **) &LOCAL->line);
+                               /* if buffer needs refreshing */
+  if (!bs->cursize) SETPOS (bs,GETPOS (bs));
+  if (SIZE (bs)) {             /* find newline */
+                               /* end of fast scan */
+    te = (t = (s = bs->curpos) + bs->cursize) - 12;
+    while (s < te) if ((*s++ == '\n') || (*s++ == '\n') || (*s++ == '\n') ||
+                      (*s++ == '\n') || (*s++ == '\n') || (*s++ == '\n') ||
+                      (*s++ == '\n') || (*s++ == '\n') || (*s++ == '\n') ||
+                      (*s++ == '\n') || (*s++ == '\n') || (*s++ == '\n')) {
+      --s;                     /* back up */
+      break;                   /* exit loop */
+    }
+                               /* final character-at-a-time scan */
+    while ((s < t) && (*s != '\n')) ++s;
+                               /* difficult case if line spans buffer */
+    if ((i = s - bs->curpos) == bs->cursize) {
+                               /* have space in line buffer? */
+      if (i > LOCAL->linebuflen) {
+       fs_give ((void **) &LOCAL->linebuf);
+       LOCAL->linebuf = (char *) fs_get (LOCAL->linebuflen = i);
+      }
+                               /* remember what we have so far */
+      memcpy (LOCAL->linebuf,bs->curpos,i);
+                               /* load next buffer */
+      SETPOS (bs,k = GETPOS (bs) + i);
+                               /* end of fast scan */
+      te = (t = (s = bs->curpos) + bs->cursize) - 12;
+                               /* fast scan in overlap buffer */
+      while (s < te) if ((*s++ == '\n') || (*s++ == '\n') || (*s++ == '\n') ||
+                        (*s++ == '\n') || (*s++ == '\n') || (*s++ == '\n') ||
+                        (*s++ == '\n') || (*s++ == '\n') || (*s++ == '\n') ||
+                        (*s++ == '\n') || (*s++ == '\n') || (*s++ == '\n')) {
+       --s;                    /* back up */
+       break;                  /* exit loop */
+      }
+\f
+                               /* final character-at-a-time scan */
+      while ((s < t) && (*s != '\n')) ++s;
+                               /* huge line? */
+      if ((j = s - bs->curpos) == bs->cursize) {
+       SETPOS (bs,GETPOS (bs) + j);
+                               /* look for end of line (s-l-o-w!!) */
+       for (m = SIZE (bs); m && (SNX (bs) != '\n'); --m,++j);
+       SETPOS (bs,k);          /* go back to where it started */
+      }
+                               /* got size of data, make buffer for return */
+      ret = LOCAL->line = (char *) fs_get (i + j + 2);
+                               /* copy first chunk */
+      memcpy (ret,LOCAL->linebuf,i);
+      while (j) {              /* copy remainder */
+       if (!bs->cursize) SETPOS (bs,GETPOS (bs));
+       memcpy (ret + i,bs->curpos,k = min (j,bs->cursize));
+       i += k;                 /* account for this much read in */
+       j -= k;
+       bs->curpos += k;        /* increment new position */
+       bs->cursize -= k;       /* eat that many bytes */
+      }
+                               /* read newline at end */
+      if (SIZE (bs)) ret[i++] = SNX (bs);
+      ret[i] = '\0';           /* makes debugging easier */
+    }
+    else {                     /* this is easy */
+      ret = bs->curpos;                /* string it at this position */
+      bs->curpos += ++i;       /* increment new position */
+      bs->cursize -= i;                /* eat that many bytes */
+    }
+    *size = i;                 /* return that to user */
+  }
+  else *size = 0;              /* end of data, return empty */
+                               /* embedded MMDF header at end of line? */
+  if ((*size > sizeof (MMDFHDRTXT)) &&
+      (s = ret + *size - (i = sizeof (MMDFHDRTXT) - 1)) && ISMMDF (s)) {
+    SETPOS (bs,GETPOS (bs) - i);/* back up to start of MMDF header */
+    *size -= i;                        /* reduce length of line */
+    ret[*size - 1] = '\n';     /* force newline at end */
+  }
+  return ret;
+}
+\f
+/* MMDF make pseudo-header
+ * Accepts: MAIL stream
+ *         buffer to write pseudo-header
+ * Returns: length of pseudo-header
+ */
+
+unsigned long mmdf_pseudo (MAILSTREAM *stream,char *hdr)
+{
+  int i;
+  char *s,tmp[MAILTMPLEN];
+  time_t now = time (0);
+  rfc822_fixed_date (tmp);
+  sprintf (hdr,"%sFrom %s %.24s\nDate: %s\nFrom: %s <%s@%.80s>\nSubject: %s\nMessage-ID: <%lu@%.80s>\nX-IMAP: %010lu %010lu",
+          mmdfhdr,pseudo_from,ctime (&now),
+          tmp,pseudo_name,pseudo_from,mylocalhost (),pseudo_subject,
+          (unsigned long) now,mylocalhost (),stream->uid_validity,
+          stream->uid_last);
+  for (s = hdr + strlen (hdr),i = 0; i < NUSERFLAGS; ++i)
+    if (stream->user_flags[i])
+      sprintf (s += strlen (s)," %s",stream->user_flags[i]);
+  sprintf (s += strlen (s),"\nStatus: RO\n\n%s\n%s",pseudo_msg,mmdfhdr);
+  return strlen (hdr);
+}
+\f
+/* MMDF make status string
+ * Accepts: MAIL stream
+ *         destination string to write
+ *         message cache entry
+ *         UID to write if non-zero (else use elt->private.uid)
+ *         non-zero flag to write UID (.LT. 0 to write UID base info too)
+ * Returns: length of string
+ */
+
+unsigned long mmdf_xstatus (MAILSTREAM *stream,char *status,MESSAGECACHE *elt,
+                           unsigned long uid,long flag)
+{
+  char *t,stack[64];
+  char *s = status;
+  unsigned long n;
+  int pad = 50;
+  int sticky = uid ? T : !stream->uid_nosticky;
+  /* This used to use sprintf(), but thanks to certain cretinous C libraries
+     with horribly slow implementations of sprintf() I had to change it to this
+     mess.  At least it should be fast. */
+  if ((flag < 0) && sticky) {  /* need to write X-IMAPbase: header? */
+    *s++ = 'X'; *s++ = '-'; *s++ = 'I'; *s++ = 'M'; *s++ = 'A'; *s++ = 'P';
+    *s++ = 'b'; *s++ = 'a'; *s++ = 's'; *s++ = 'e'; *s++ = ':'; *s++ = ' ';
+    t = stack;
+    n = stream->uid_validity;  /* push UID validity digits on the stack */
+    do *t++ = (char) (n % 10) + '0';
+    while (n /= 10);
+                               /* pop UID validity digits from stack */
+    while (t > stack) *s++ = *--t;
+   *s++ = ' ';
+    n = stream->uid_last;      /* push UID last digits on the stack */
+    do *t++ = (char) (n % 10) + '0';
+    while (n /= 10);
+                               /* pop UID last digits from stack */
+    while (t > stack) *s++ = *--t;
+    for (n = 0; n < NUSERFLAGS; ++n) if (t = stream->user_flags[n])
+      for (*s++ = ' '; *t; *s++ = *t++);
+    *s++ = '\n';
+    pad += 30;                 /* increased padding if have IMAPbase */
+  }
+  *s++ = 'S'; *s++ = 't'; *s++ = 'a'; *s++ = 't'; *s++ = 'u'; *s++ = 's';
+  *s++ = ':'; *s++ = ' ';
+  if (elt->seen) *s++ = 'R';
+                               /* only write O if have a UID */
+  if (flag && (!elt->recent || !LOCAL->appending)) *s++ = 'O';
+  *s++ = '\n';
+  *s++ = 'X'; *s++ = '-'; *s++ = 'S'; *s++ = 't'; *s++ = 'a'; *s++ = 't';
+  *s++ = 'u'; *s++ = 's'; *s++ = ':'; *s++ = ' ';
+  if (elt->deleted) *s++ = 'D';
+  if (elt->flagged) *s++ = 'F';
+  if (elt->answered) *s++ = 'A';
+  if (elt->draft) *s++ = 'T';
+    *s++ = '\n';
+\f
+  if (sticky) {                        /* only do this if UIDs sticky */
+    *s++ = 'X'; *s++ = '-'; *s++ = 'K'; *s++ = 'e'; *s++ = 'y'; *s++ = 'w';
+    *s++ = 'o'; *s++ = 'r'; *s++ = 'd'; *s++ = 's'; *s++ = ':';
+    if (n = elt->user_flags) do {
+      *s++ = ' ';
+      for (t = stream->user_flags[find_rightmost_bit (&n)]; *t; *s++ = *t++);
+    } while (n);
+    n = s - status;            /* get size of stuff so far */
+                               /* pad X-Keywords to make size constant */
+    if (n < pad) for (n = pad - n; n > 0; --n) *s++ = ' ';
+    *s++ = '\n';
+    if (flag) {                        /* want to include UID? */
+      t = stack;
+                               /* push UID digits on the stack */
+      n = uid ? uid : elt->private.uid;
+      do *t++ = (char) (n % 10) + '0';
+      while (n /= 10);
+      *s++ = 'X'; *s++ = '-'; *s++ = 'U'; *s++ = 'I'; *s++ = 'D'; *s++ = ':';
+      *s++ = ' ';
+                               /* pop UID from stack */
+      while (t > stack) *s++ = *--t;
+      *s++ = '\n';
+    }
+  }
+  *s++ = '\n'; *s = '\0';      /* end of extended message status */
+  return s - status;           /* return size of resulting string */
+}
+\f
+/* Rewrite mailbox file
+ * Accepts: MAIL stream, must be critical and locked
+ *         return pointer to number of expunged messages if want expunge
+ *         lock file name
+ *         expunge sequence, not deleted flag
+ * Returns: T if success and mailbox unlocked, NIL if failure
+ */
+
+#define OVERFLOWBUFLEN 8192    /* initial overflow buffer length */
+
+long mmdf_rewrite (MAILSTREAM *stream,unsigned long *nexp,DOTLOCK *lock,
+                  long flags)
+{
+  MESSAGECACHE *elt;
+  MMDFFILE f;
+  char *s;
+  time_t tp[2];
+  long ret,flag;
+  unsigned long i,j;
+  unsigned long recent = stream->recent;
+  unsigned long size = LOCAL->pseudo ? mmdf_pseudo (stream,LOCAL->buf) : 0;
+  if (nexp) *nexp = 0;         /* initially nothing expunged */
+                               /* calculate size of mailbox after rewrite */
+  for (i = 1,flag = LOCAL->pseudo ? 1 : -1; i <= stream->nmsgs; i++) {
+    elt = mail_elt (stream,i); /* get cache */
+    if (!(nexp && elt->deleted && (flags ? elt->sequence : T))) {
+                               /* add RFC822 size of this message */
+      size += elt->private.special.text.size + elt->private.spare.data +
+       mmdf_xstatus (stream,LOCAL->buf,elt,NIL,flag) +
+         elt->private.msg.text.text.size + MMDFHDRLEN;
+      flag = 1;                        /* only count X-IMAPbase once */
+    }
+  }
+                               /* no messages, has a life, and no pseudo */
+  if (!size && !mail_parameters (NIL,GET_USERHASNOLIFE,NIL)) {
+    LOCAL->pseudo = T;         /* so make a pseudo-message now */
+    size = mmdf_pseudo (stream,LOCAL->buf);
+  }
+                               /* extend the file as necessary */
+  if (ret = mmdf_extend (stream,size)) {
+    /* Set up buffered I/O file structure
+     * curpos  current position being written through buffering
+     * filepos current position being written physically to the disk
+     * bufpos  current position being written in the buffer
+     * protect current maximum position that can be written to the disk
+     *         before buffering is forced
+     * The code tries to buffer so that that disk is written in multiples of
+     * OVERBLOWBUFLEN bytes.
+     */
+    f.stream = stream;         /* note mail stream */
+    f.curpos = f.filepos = 0;  /* start of file */
+    f.protect = stream->nmsgs ?        /* initial protection pointer */
+    mail_elt (stream,1)->private.special.offset : 8192;
+    f.bufpos = f.buf = (char *) fs_get (f.buflen = OVERFLOWBUFLEN);
+\f
+    if (LOCAL->pseudo)         /* update pseudo-header */
+      mmdf_write (&f,LOCAL->buf,mmdf_pseudo (stream,LOCAL->buf));
+                               /* loop through all messages */
+    for (i = 1,flag = LOCAL->pseudo ? 1 : -1; i <= stream->nmsgs;) {
+      elt = mail_elt (stream,i);/* get cache */
+                               /* expunge this message? */
+      if (nexp && elt->deleted && (flags ? elt->sequence : T)) {
+                               /* one less recent message */
+       if (elt->recent) --recent;
+       mail_expunged(stream,i);/* notify upper levels */
+       ++*nexp;                /* count up one more expunged message */
+      }
+      else {                   /* preserve this message */
+       i++;                    /* advance to next message */
+       if ((flag < 0) ||       /* need to rewrite message? */
+           elt->private.dirty || (f.curpos != elt->private.special.offset) ||
+           (elt->private.msg.header.text.size !=
+            (elt->private.spare.data +
+             mmdf_xstatus (stream,LOCAL->buf,elt,NIL,flag)))) {
+         unsigned long newoffset = f.curpos;
+                               /* yes, seek to internal header */
+         lseek (LOCAL->fd,elt->private.special.offset,L_SET);
+         read (LOCAL->fd,LOCAL->buf,elt->private.special.text.size);
+                               /* see if need to squeeze out a CR */
+         if (LOCAL->buf[elt->private.special.text.size - 2] == '\r') {
+           LOCAL->buf[--elt->private.special.text.size - 1] = '\n';
+           --size;             /* squeezed out a CR from PC */
+         }
+                               /* protection pointer moves to RFC822 header */
+         f.protect = elt->private.special.offset +
+           elt->private.msg.header.offset;
+                               /* write internal header */
+         mmdf_write (&f,LOCAL->buf,elt->private.special.text.size);
+                               /* get RFC822 header */
+         s = mmdf_header (stream,elt->msgno,&j,FT_INTERNAL);
+                               /* in case this got decremented */
+         elt->private.msg.header.offset = elt->private.special.text.size;
+                               /* header size, sans trailing newline */
+         if ((j < 2) || (s[j - 2] == '\n')) j--;
+                               /* this can happen if CRs were squeezed */
+         if (j < elt->private.spare.data) {
+                               /* so fix up counts */
+           size -= elt->private.spare.data - j;
+           elt->private.spare.data = j;
+         }
+         else if (j != elt->private.spare.data)
+           fatal ("header size inconsistent");
+                               /* protection pointer moves to RFC822 text */
+         f.protect = elt->private.special.offset +
+           elt->private.msg.text.offset;
+         mmdf_write (&f,s,j);  /* write RFC822 header */
+                               /* write status and UID */
+         mmdf_write (&f,LOCAL->buf,
+                     j = mmdf_xstatus (stream,LOCAL->buf,elt,NIL,flag));
+         flag = 1;             /* only write X-IMAPbase once */
+                               /* new file header size */
+         elt->private.msg.header.text.size = elt->private.spare.data + j;
+\f
+                               /* did text move? */
+         if (f.curpos != f.protect) {
+                               /* get message text */
+           s = mmdf_text_work (stream,elt,&j,FT_INTERNAL);
+                               /* this can happen if CRs were squeezed */
+           if (j < elt->private.msg.text.text.size) {
+                               /* so fix up counts */
+             size -= elt->private.msg.text.text.size - j;
+             elt->private.msg.text.text.size = j;
+           }
+                               /* can't happen it says here */
+           else if (j > elt->private.msg.text.text.size)
+             fatal ("text size inconsistent");
+                               /* new text offset, status/UID may change it */
+           elt->private.msg.text.offset = f.curpos - newoffset;
+                               /* protection pointer moves to next message */
+           f.protect = (i <= stream->nmsgs) ?
+             mail_elt (stream,i)->private.special.offset :
+               (f.curpos + j + MMDFHDRLEN);
+           mmdf_write (&f,s,j);/* write text */
+                               /* write trailing newline */
+           mmdf_write (&f,mmdfhdr,MMDFHDRLEN);
+         }
+         else {                /* tie off header and status */
+           mmdf_write (&f,NIL,NIL);
+           f.curpos = f.protect =/* restart everything at end of message */
+             f.filepos += elt->private.msg.text.text.size + MMDFHDRLEN;
+         }
+                               /* new internal header offset */
+         elt->private.special.offset = newoffset;
+         elt->private.dirty =NIL;/* message is now clean */
+       }
+       else {                  /* no need to rewrite this message */
+                               /* tie off previous message if needed */
+         mmdf_write (&f,NIL,NIL);
+         f.curpos = f.protect =/* restart everything at end of message */
+           f.filepos += elt->private.special.text.size +
+             elt->private.msg.header.text.size +
+               elt->private.msg.text.text.size + MMDFHDRLEN;
+       }
+      }
+    }
+\f
+    mmdf_write (&f,NIL,NIL);   /* tie off final message */
+    if (size != f.filepos) fatal ("file size inconsistent");
+    fs_give ((void **) &f.buf);        /* free buffer */
+                               /* make sure tied off */
+    ftruncate (LOCAL->fd,LOCAL->filesize = size);
+    fsync (LOCAL->fd);         /* make sure the updates take */
+    if (size && (flag < 0)) fatal ("lost UID base information");
+                               /* no longer dirty */
+    LOCAL->ddirty = LOCAL->dirty = NIL;
+                               /* notify upper level of new mailbox sizes */
+    mail_exists (stream,stream->nmsgs);
+    mail_recent (stream,recent);
+                               /* set atime to now, mtime a second earlier */
+    tp[1] = (tp[0] = time (0)) - 1;
+                               /* set the times, note change */
+    if (!utime (stream->mailbox,tp)) LOCAL->filetime = tp[1];
+    close (LOCAL->fd);         /* close and reopen file */
+    if ((LOCAL->fd = open (stream->mailbox,O_RDWR,
+                          (long) mail_parameters (NIL,GET_MBXPROTECTION,NIL)))
+       < 0) {
+      sprintf (LOCAL->buf,"Mailbox open failed, aborted: %s",strerror (errno));
+      MM_LOG (LOCAL->buf,ERROR);
+      mmdf_abort (stream);
+    }
+    dotlock_unlock (lock);     /* flush the lock file */
+  }
+  return ret;                  /* return state from algorithm */
+}
+\f
+/* Extend MMDF mailbox file
+ * Accepts: MAIL stream
+ *         new desired size
+ * Return: T if success, else NIL
+ */
+
+long mmdf_extend (MAILSTREAM *stream,unsigned long size)
+{
+  unsigned long i = (size > LOCAL->filesize) ? size - LOCAL->filesize : 0;
+  if (i) {                     /* does the mailbox need to grow? */
+    if (i > LOCAL->buflen) {   /* make sure have enough space */
+                               /* this user won the lottery all right */
+      fs_give ((void **) &LOCAL->buf);
+      LOCAL->buf = (char *) fs_get ((LOCAL->buflen = i) + 1);
+    }
+    memset (LOCAL->buf,'\0',i);        /* get a block of nulls */
+    while (T) {                        /* until write successful or punt */
+      lseek (LOCAL->fd,LOCAL->filesize,L_SET);
+      if ((write (LOCAL->fd,LOCAL->buf,i) >= 0) && !fsync (LOCAL->fd)) break;
+      else {
+       long e = errno;         /* note error before doing ftruncate */
+       ftruncate (LOCAL->fd,LOCAL->filesize);
+       if (MM_DISKERROR (stream,e,NIL)) {
+         fsync (LOCAL->fd);    /* user chose to punt */
+         sprintf (LOCAL->buf,"Unable to extend mailbox: %s",strerror (e));
+         if (!stream->silent) MM_LOG (LOCAL->buf,ERROR);
+         return NIL;
+       }
+      }
+    }
+  }
+  return LONGT;
+}
+\f
+/* Write data to buffered file
+ * Accepts: buffered file pointer
+ *         file data or NIL to indicate "flush buffer"
+ *         date size (ignored for "flush buffer")
+ * Does not return until success
+ */
+
+void mmdf_write (MMDFFILE *f,char *buf,unsigned long size)
+{
+  unsigned long i,j,k;
+  if (buf) {                   /* doing buffered write? */
+    i = f->bufpos - f->buf;    /* yes, get size of current buffer data */
+                               /* yes, have space in current buffer chunk? */
+    if (j = i ? ((f->buflen - i) % OVERFLOWBUFLEN) : f->buflen) {
+                               /* yes, fill up buffer as much as we can */
+      memcpy (f->bufpos,buf,k = min (j,size));
+      f->bufpos += k;          /* new buffer position */
+      f->curpos += k;          /* new current position */
+      if (j -= k) return;      /* all done if still have buffer free space */
+      buf += k;                        /* full, get new unwritten data pointer */
+      size -= k;               /* new data size */
+      i += k;                  /* new buffer data size */
+    }
+    /* This chunk of the buffer is full.  See if can make some space by
+     * writing to the disk, if there's enough unprotected space to do so.
+     * Try to fill out any unaligned chunk, along with any subsequent full
+     * chunks that will fit in unprotected space.
+     */
+                               /* any unprotected space we can write to? */
+    if (j = min (i,f->protect - f->filepos)) {
+                               /* yes, filepos not at chunk boundary? */
+      if ((k = f->filepos % OVERFLOWBUFLEN) && ((k = OVERFLOWBUFLEN - k) < j))
+       j -= k;                 /* yes, and can write out partial chunk */
+      else k = 0;              /* no partial chunk to write */
+                               /* if at least a chunk free, write that too */
+      if (j > OVERFLOWBUFLEN) k += j - (j % OVERFLOWBUFLEN);
+      if (k) {                 /* write data if there is anything we can */
+       mmdf_phys_write (f,f->buf,k);
+                               /* slide buffer */
+       if (i -= k) memmove (f->buf,f->buf + k,i);
+       f->bufpos = f->buf + i; /* new end of buffer */
+      }
+    }
+\f
+    /* Have flushed the buffer as best as possible.  All done if no more
+     * data to write.  Otherwise, if the buffer is empty AND if the unwritten
+     * data is larger than a chunk AND the unprotected space is also larger
+     * than a chunk, then write as many chunks as we can directly from the
+     * data.  Buffer the rest, expanding the buffer as needed.
+     */
+    if (size) {                        /* have more data that we need to buffer? */
+                               /* can write any of it to disk instead? */
+      if ((f->bufpos == f->buf) && 
+         ((j = min (f->protect - f->filepos,size)) > OVERFLOWBUFLEN)) {
+                               /* write as much as we can right now */
+       mmdf_phys_write (f,buf,j -= (j % OVERFLOWBUFLEN));
+       buf += j;               /* new data pointer */
+       size -= j;              /* new data size */
+       f->curpos += j;         /* advance current pointer */
+      }
+      if (size) {              /* still have data that we need to buffer? */
+                               /* yes, need to expand the buffer? */
+       if ((i = ((f->bufpos + size) - f->buf)) > f->buflen) {
+                               /* note current position in buffer */
+         j = f->bufpos - f->buf;
+         i += OVERFLOWBUFLEN;  /* yes, grow another chunk */
+         fs_resize ((void **) &f->buf,f->buflen = i - (i % OVERFLOWBUFLEN));
+                               /* in case buffer relocated */
+         f->bufpos = f->buf + j;
+       }
+                               /* buffer remaining data */
+       memcpy (f->bufpos,buf,size);
+       f->bufpos += size;      /* new end of buffer */
+       f->curpos += size;      /* advance current pointer */
+      }
+    }
+  }
+  else {                       /* flush buffer to disk */
+    mmdf_phys_write (f,f->buf,i = f->bufpos - f->buf);
+    f->bufpos = f->buf;                /* reset buffer */
+                               /* update positions */
+    f->curpos = f->protect = f->filepos;
+  }
+}
+\f
+/* Physical disk write
+ * Accepts: buffered file pointer
+ *         buffer address
+ *         buffer size
+ * Does not return until success
+ */
+
+void mmdf_phys_write (MMDFFILE *f,char *buf,size_t size)
+{
+  MAILSTREAM *stream = f->stream;
+                               /* write data at desired position */
+  while (size && ((lseek (LOCAL->fd,f->filepos,L_SET) < 0) ||
+                 (write (LOCAL->fd,buf,size) < 0))) {
+    int e;
+    char tmp[MAILTMPLEN];
+    sprintf (tmp,"Unable to write to mailbox: %s",strerror (e = errno));
+    MM_LOG (tmp,ERROR);
+    MM_DISKERROR (NIL,e,T);    /* serious problem, must retry */
+  }
+  f->filepos += size;          /* update file position */
+}