From 094ca96844842928810f14844413109fc6cdd890 Mon Sep 17 00:00:00 2001 From: Eduardo Chappa Date: Sun, 3 Feb 2013 00:59:38 -0700 Subject: Initial Alpine Version --- imap/src/osdep/amiga/mmdf.c | 2549 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 2549 insertions(+) create mode 100644 imap/src/osdep/amiga/mmdf.c (limited to 'imap/src/osdep/amiga/mmdf.c') diff --git a/imap/src/osdep/amiga/mmdf.c b/imap/src/osdep/amiga/mmdf.c new file mode 100644 index 00000000..e962434e --- /dev/null +++ b/imap/src/osdep/amiga/mmdf.c @@ -0,0 +1,2549 @@ +/* ======================================================================== + * Copyright 1988-2008 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 + * UW Technology + * University of Washington + * Seattle, WA 98195 + * Internet: MRC@Washington.EDU + * + * Date: 20 December 1989 + * Last Edited: 27 March 2008 + */ + + +#include +#include +#include +extern int errno; /* just in case */ +#include +#include "mail.h" +#include "osdep.h" +#include +#include +#include "pseudo.h" +#include "fdstring.h" +#include "misc.h" +#include "dummy.h" + +/* 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; \ + } \ + } \ + } \ +} + +/* 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. + */ + +/* + * 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''. + */ + +/* 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; + +/* 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); + +/* 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 */ + +/* 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 */ +} + +/* 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; +} + +/* 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); +} + +/* 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; +} + +/* 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); + + 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 */ +} + +/* 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 */ + + /* 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 */ + } + } + + /* 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 */ +} + +/* 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); + + 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 */ +} + +/* 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 */ +} + +/* 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; + } + + /* 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; +} + +/* 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 */ +} + +/* 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; +} + +/* 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; + } + + /* 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); + } + } + } + } + } + + 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; +} + +/* 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; + } + + /* 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); + + 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; +} + +/* 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; +} + +/* 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; + + 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; +} + +/* 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 */ + } +} + +/* 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; +} + +/* 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 */ +} + +/* 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; + } + + /* 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; + + 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; + + 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)) && (k <= 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; + } + + /* 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)) && + (k <= 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; + } + + /* 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 */ + + 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 */ + + 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; + + /* 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 */ +} + +/* 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 */ + } + + /* 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; +} + +/* 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); +} + +/* 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'; + + 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 */ +} + +/* 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); + + 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; + + /* 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; + } + } + } + + 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 */ +} + +/* 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; +} + +/* 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 */ + } + } + + /* 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; + } +} + +/* 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 */ +} -- cgit v1.2.3-54-g00ecf