开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 网络编程 > 查看源码
mtx.c
资源名称：imap-4.7.tar.Z　[点击查看]
上传用户：ycwykj01
上传日期：2007-01-04
资源大小：1819k
文件大小：41k
源码类别：

网络编程

开发平台：

Unix_Linux

mtx.c：源码内容
  1. /*
  2.  * Program: MTX mail routines
  3.  *
  4.  * Author: Mark Crispin
  5.  * Networks and Distributed Computing
  6.  * Computing & Communications
  7.  * University of Washington
  8.  * Administration Building, AG-44
  9.  * Seattle, WA  98195
  10.  * Internet: MRC@CAC.Washington.EDU
  11.  *
  12.  * Date: 22 May 1990
  13.  * Last Edited: 21 September 1999
  14.  *
  15.  * Copyright 1999 by the University of Washington
  16.  *
  17.  *  Permission to use, copy, modify, and distribute this software and its
  18.  * documentation for any purpose and without fee is hereby granted, provided
  19.  * that the above copyright notice appears in all copies and that both the
  20.  * above copyright notice and this permission notice appear in supporting
  21.  * documentation, and that the name of the University of Washington not be
  22.  * used in advertising or publicity pertaining to distribution of the software
  23.  * without specific, written prior permission.  This software is made
  24.  * available "as is", and
  25.  * THE UNIVERSITY OF WASHINGTON DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED,
  26.  * WITH REGARD TO THIS SOFTWARE, INCLUDING WITHOUT LIMITATION ALL IMPLIED
  27.  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, AND IN
  28.  * NO EVENT SHALL THE UNIVERSITY OF WASHINGTON BE LIABLE FOR ANY SPECIAL,
  29.  * INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  30.  * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, TORT
  31.  * (INCLUDING NEGLIGENCE) OR STRICT LIABILITY, ARISING OUT OF OR IN CONNECTION
  32.  * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  33.  *
  34.  */
  37. #include <stdio.h>
  38. #include <ctype.h>
  39. #include <errno.h>
  40. extern int errno; /* just in case */
  41. #include "mail.h"
  42. #include "osdep.h"
  43. #include <pwd.h>
  44. #include <sys/stat.h>
  45. #include <sys/time.h>
  46. #include "mtx.h"
  47. #include "misc.h"
  48. #include "dummy.h"
  50. /* MTX mail routines */
  53. /* Driver dispatch used by MAIL */
  55. DRIVER mtxdriver = {
  56.   "mtx", /* driver name */
  57. /* driver flags */
  58.   DR_LOCAL|DR_MAIL|DR_CRLF|DR_NOSTICKY,
  59.   (DRIVER *) NIL, /* next driver */
  60.   mtx_valid, /* mailbox is valid for us */
  61.   mtx_parameters, /* manipulate parameters */
  62.   mtx_scan, /* scan mailboxes */
  63.   mtx_list, /* list mailboxes */
  64.   mtx_lsub, /* list subscribed mailboxes */
  65.   NIL, /* subscribe to mailbox */
  66.   NIL, /* unsubscribe from mailbox */
  67.   dummy_create, /* create mailbox */
  68.   mtx_delete, /* delete mailbox */
  69.   mtx_rename, /* rename mailbox */
  70.   mtx_status, /* status of mailbox */
  71.   mtx_open, /* open mailbox */
  72.   mtx_close, /* close mailbox */
  73.   mtx_flags, /* fetch message "fast" attributes */
  74.   mtx_flags, /* fetch message flags */
  75.   NIL, /* fetch overview */
  76.   NIL, /* fetch message envelopes */
  77.   mtx_header, /* fetch message header */
  78.   mtx_text, /* fetch message body */
  79.   NIL, /* fetch partial message text */
  80.   NIL, /* unique identifier */
  81.   NIL, /* message number */
  82.   mtx_flag, /* modify flags */
  83.   mtx_flagmsg, /* per-message modify flags */
  84.   NIL, /* search for message based on criteria */
  85.   NIL, /* sort messages */
  86.   NIL, /* thread messages */
  87.   mtx_ping, /* ping mailbox to see if still alive */
  88.   mtx_check, /* check for new messages */
  89.   mtx_expunge, /* expunge deleted messages */
  90.   mtx_copy, /* copy messages to another mailbox */
  91.   mtx_append, /* append string message to mailbox */
  92.   NIL /* garbage collect stream */
  93. };
  95. /* prototype stream */
  96. MAILSTREAM mtxproto = {&mtxdriver};
  98. /* MTX mail validate mailbox
  99.  * Accepts: mailbox name
  100.  * Returns: our driver if name is valid, NIL otherwise
  101.  */
  103. DRIVER *mtx_valid (char *name)
  104. {
  105.   char tmp[MAILTMPLEN];
  106.   return mtx_isvalid (name,tmp) ? &mtxdriver : NIL;
  107. }
  110. /* MTX mail test for valid mailbox
  111.  * Accepts: mailbox name
  112.  * Returns: T if valid, NIL otherwise
  113.  */
  115. int mtx_isvalid (char *name,char *tmp)
  116. {
  117.   int fd;
  118.   int ret = NIL;
  119.   char *s,file[MAILTMPLEN];
  120.   struct stat sbuf;
  121.   time_t tp[2];
  122.   errno = EINVAL; /* assume invalid argument */
  123. /* if file, get its status */
  124.   if ((s = mtx_file (file,name)) && !stat (s,&sbuf)) {
  125.     if (!sbuf.st_size) { /* allow empty file if INBOX */
  126.       if ((s = mailboxfile (tmp,name)) && !*s) ret = T;
  127.       else errno = 0; /* empty file */
  128.     }
  129.     else if ((fd = open (file,O_RDONLY,NIL)) >= 0) {
  130.       memset (tmp,'',MAILTMPLEN);
  131.       if ((read (fd,tmp,64) >= 0) && (s = strchr (tmp,'15')) &&
  132.   (s[1] == '12')) { /* valid format? */
  133. *s = ''; /* tie off header */
  134. /* must begin with dd-mmm-yy" */
  135. ret = (((tmp[2] == '-' && tmp[6] == '-') ||
  136. (tmp[1] == '-' && tmp[5] == '-')) &&
  137.        (s = strchr (tmp+20,',')) && strchr (s+2,';')) ? T : NIL;
  138.       }
  139.       else errno = -1; /* bogus format */
  140.       close (fd); /* close the file */
  141.       tp[0] = sbuf.st_atime; /* preserve atime and mtime */
  142.       tp[1] = sbuf.st_mtime;
  143.       utime (file,tp); /* set the times */
  144.     }
  145.   }
  146. /* in case INBOX but not mtx format */
  147.   else if ((errno == ENOENT) && ((name[0] == 'I') || (name[0] == 'i')) &&
  148.    ((name[1] == 'N') || (name[1] == 'n')) &&
  149.    ((name[2] == 'B') || (name[2] == 'b')) &&
  150.    ((name[3] == 'O') || (name[3] == 'o')) &&
  151.    ((name[4] == 'X') || (name[4] == 'x')) && !name[5]) errno = -1;
  152.   return ret; /* return what we should */
  153. }
  155. /* MTX manipulate driver parameters
  156.  * Accepts: function code
  157.  *     function-dependent value
  158.  * Returns: function-dependent return value
  159.  */
  161. void *mtx_parameters (long function,void *value)
  162. {
  163.   return NIL;
  164. }
  167. /* MTX mail scan mailboxes
  168.  * Accepts: mail stream
  169.  *     reference
  170.  *     pattern to search
  171.  *     string to scan
  172.  */
  174. void mtx_scan (MAILSTREAM *stream,char *ref,char *pat,char *contents)
  175. {
  176.   if (stream) dummy_scan (NIL,ref,pat,contents);
  177. }
  180. /* MTX mail list mailboxes
  181.  * Accepts: mail stream
  182.  *     reference
  183.  *     pattern to search
  184.  */
  186. void mtx_list (MAILSTREAM *stream,char *ref,char *pat)
  187. {
  188.   if (stream) dummy_list (NIL,ref,pat);
  189. }
  192. /* MTX mail list subscribed mailboxes
  193.  * Accepts: mail stream
  194.  *     reference
  195.  *     pattern to search
  196.  */
  198. void mtx_lsub (MAILSTREAM *stream,char *ref,char *pat)
  199. {
  200.   if (stream) dummy_lsub (NIL,ref,pat);
  201. }
  203. /* MTX mail delete mailbox
  204.  * Accepts: MAIL stream
  205.  *     mailbox name to delete
  206.  * Returns: T on success, NIL on failure
  207.  */
  209. long mtx_delete (MAILSTREAM *stream,char *mailbox)
  210. {
  211.   return mtx_rename (stream,mailbox,NIL);
  212. }
  215. /* MTX mail rename mailbox
  216.  * Accepts: MAIL stream
  217.  *     old mailbox name
  218.  *     new mailbox name (or NIL for delete)
  219.  * Returns: T on success, NIL on failure
  220.  */
  222. long mtx_rename (MAILSTREAM *stream,char *old,char *newname)
  223. {
  224.   long ret = T;
  225.   char c,*s,tmp[MAILTMPLEN],file[MAILTMPLEN],lock[MAILTMPLEN];
  226.   int ld;
  227.   int fd = open (mtx_file (file,old),O_RDWR,NIL);
  228.   struct stat sbuf;
  229.   if (fd < 0) { /* open mailbox */
  230.     sprintf (tmp,"Can't open mailbox %.80s: %s",old,strerror (errno));
  231.     mm_log (tmp,ERROR);
  232.     return NIL;
  233.   }
  234. /* get exclusive parse/append permission */
  235.   if ((ld = lockfd (fd,lock,LOCK_EX)) < 0) {
  236.     mm_log ("Unable to lock rename mailbox",ERROR);
  237.     return NIL;
  238.   }
  239. /* lock out other users */
  240.   if (flock (fd,LOCK_EX|LOCK_NB)) {
  241.     close (fd); /* couldn't lock, give up on it then */
  242.     sprintf (tmp,"Mailbox %.80s is in use by another process",old);
  243.     mm_log (tmp,ERROR);
  244.     unlockfd (ld,lock); /* release exclusive parse/append permission */
  245.     return NIL;
  246.   }
  248.   if (newname) { /* want rename? */
  249.     if (!((s = mtx_file (tmp,newname)) && *s)) {
  250.       sprintf (tmp,"Can't rename mailbox %.80s to %.80s: invalid name",
  251.        old,newname);
  252.       mm_log (tmp,ERROR);
  253.       ret = NIL; /* set failure */
  254.     }
  255.     if (s = strrchr (s,'/')) { /* found superior to destination name? */
  256.       c = *++s; /* remember first character of inferior */
  257.       *s = ''; /* tie off to get just superior */
  258. /* name doesn't exist, create it */
  259.       if ((stat (tmp,&sbuf) || ((sbuf.st_mode & S_IFMT) != S_IFDIR)) &&
  260.   !dummy_create (stream,tmp)) ret = NIL;
  261.       else *s = c; /* restore full name */
  262.     }
  263. /* rename the file */
  264.     if (ret && rename (file,tmp)) {
  265.       sprintf (tmp,"Can't rename mailbox %.80s to %.80s: %s",old,newname,
  266.        strerror (errno));
  267.       mm_log (tmp,ERROR);
  268.       ret = NIL; /* set failure */
  269.     }
  270.   }
  271.   else if (unlink (file)) {
  272.     sprintf (tmp,"Can't delete mailbox %.80s: %s",old,strerror (errno));
  273.     mm_log (tmp,ERROR);
  274.     ret = NIL; /* set failure */
  275.   }
  276.   flock (fd,LOCK_UN); /* release lock on the file */
  277.   close (fd); /* close the file */
  278.   unlockfd (ld,lock); /* release exclusive parse/append permission */
  279. /* recreate file if renamed INBOX */
  280.   if (ret && !strcmp (ucase (strcpy (tmp,old)),"INBOX"))
  281.     dummy_create (NIL,"INBOX.MTX");
  282.   return ret; /* return success */
  283. }
  285. /* Mtx Mail status
  286.  * Accepts: mail stream
  287.  *     mailbox name
  288.  *     status flags
  289.  * Returns: T on success, NIL on failure
  290.  */
  292. long mtx_status (MAILSTREAM *stream,char *mbx,long flags)
  293. {
  294.   MAILSTATUS status;
  295.   unsigned long i;
  296.   MAILSTREAM *tstream = NIL;
  297.   MAILSTREAM *systream = NIL;
  298. /* make temporary stream (unless this mbx) */
  299.   if (!stream && !(stream = tstream =
  300.    mail_open (NIL,mbx,OP_READONLY|OP_SILENT))) return NIL;
  301.   status.flags = flags; /* return status values */
  302.   status.messages = stream->nmsgs;
  303.   status.recent = stream->recent;
  304.   if (flags & SA_UNSEEN) /* must search to get unseen messages */
  305.     for (i = 1,status.unseen = 0; i <= stream->nmsgs; i++)
  306.       if (!mail_elt (stream,i)->seen) status.unseen++;
  307.   status.uidnext = stream->uid_last + 1;
  308.   status.uidvalidity = stream->uid_validity;
  309. /* calculate post-snarf results */
  310.   if (!status.recent && stream->inbox &&
  311.       (systream = mail_open (NIL,sysinbox (),OP_READONLY|OP_SILENT))) {
  312.     status.messages += systream->nmsgs;
  313.     status.recent += systream->recent;
  314.     if (flags & SA_UNSEEN) /* must search to get unseen messages */
  315.       for (i = 1; i <= systream->nmsgs; i++)
  316. if (!mail_elt (systream,i)->seen) status.unseen++;
  317. /* kludge but probably good enough */
  318.     status.uidnext += systream->nmsgs;
  319.   }
  320. /* pass status to main program */
  321.   mm_status (stream,mbx,&status);
  322.   if (tstream) mail_close (tstream);
  323.   if (systream) mail_close (systream);
  324.   return T; /* success */
  325. }
  327. /* MTX mail open
  328.  * Accepts: stream to open
  329.  * Returns: stream on success, NIL on failure
  330.  */
  332. MAILSTREAM *mtx_open (MAILSTREAM *stream)
  333. {
  334.   int fd,ld;
  335.   char tmp[MAILTMPLEN];
  336.   blocknotify_t bn = (blocknotify_t) mail_parameters (NIL,GET_BLOCKNOTIFY,NIL);
  337. /* return prototype for OP_PROTOTYPE call */
  338.   if (!stream) return user_flags (&mtxproto);
  339.   if (stream->local) fatal ("mtx recycle stream");
  340.   user_flags (stream); /* set up user flags */
  341.   if (stream->rdonly ||
  342.       (fd = open (mtx_file (tmp,stream->mailbox),O_RDWR,NIL)) < 0) {
  343.     if ((fd = open (mtx_file (tmp,stream->mailbox),O_RDONLY,NIL)) < 0) {
  344.       sprintf (tmp,"Can't open mailbox: %.80s",strerror (errno));
  345.       mm_log (tmp,ERROR);
  346.       return NIL;
  347.     }
  348.     else if (!stream->rdonly) { /* got it, but readonly */
  349.       mm_log ("Can't get write access to mailbox, access is readonly",WARN);
  350.       stream->rdonly = T;
  351.     }
  352.   }
  353.   stream->local = fs_get (sizeof (MTXLOCAL));
  354.   LOCAL->buf = (char *) fs_get (MAXMESSAGESIZE + 1);
  355.   LOCAL->buflen = MAXMESSAGESIZE;
  356. /* note if an INBOX or not */
  357.   stream->inbox = !strcmp(ucase (strcpy (LOCAL->buf,stream->mailbox)),"INBOX");
  358.   fs_give ((void **) &stream->mailbox);
  359.   stream->mailbox = cpystr (tmp);
  360. /* get shared parse permission */
  361.   if ((ld = lockfd (fd,tmp,LOCK_SH)) < 0) {
  362.     mm_log ("Unable to lock open mailbox",ERROR);
  363.     return NIL;
  364.   }
  365.   (*bn) (BLOCK_FILELOCK,NIL);
  366.   flock(LOCAL->fd = fd,LOCK_SH);/* bind and lock the file */
  367.   (*bn) (BLOCK_NONE,NIL);
  368.   unlockfd (ld,tmp); /* release shared parse permission */
  369.   LOCAL->filesize = 0; /* initialize parsed file size */
  370. /* time not set up yet */
  371.   LOCAL->lastsnarf = LOCAL->filetime = 0;
  372.   LOCAL->mustcheck = LOCAL->shouldcheck = NIL;
  373.   stream->sequence++; /* bump sequence number */
  374. /* parse mailbox */
  375.   stream->nmsgs = stream->recent = 0;
  376.   if (mtx_ping (stream) && !stream->nmsgs)
  377.     mm_log ("Mailbox is empty",(long) NIL);
  378.   if (!LOCAL) return NIL; /* failure if stream died */
  379.   stream->perm_seen = stream->perm_deleted =
  380.     stream->perm_flagged = stream->perm_answered = stream->perm_draft =
  381.       stream->rdonly ? NIL : T;
  382.   stream->perm_user_flags = stream->rdonly ? NIL : 0xffffffff;
  383.   return stream; /* return stream to caller */
  384. }
  386. /* MTX mail close
  387.  * Accepts: MAIL stream
  388.  *     close options
  389.  */
  391. void mtx_close (MAILSTREAM *stream,long options)
  392. {
  393.   if (stream && LOCAL) { /* only if a file is open */
  394.     int silent = stream->silent;
  395.     stream->silent = T; /* note this stream is dying */
  396.     if (options & CL_EXPUNGE) mtx_expunge (stream);
  397.     stream->silent = silent; /* restore previous status */
  398.     flock (LOCAL->fd,LOCK_UN); /* unlock local file */
  399.     close (LOCAL->fd); /* close the local file */
  400. /* free local text buffer */
  401.     if (LOCAL->buf) fs_give ((void **) &LOCAL->buf);
  402. /* nuke the local data */
  403.     fs_give ((void **) &stream->local);
  404.     stream->dtb = NIL; /* log out the DTB */
  405.   }
  406. }
  409. /* MTX mail fetch flags
  410.  * Accepts: MAIL stream
  411.  *     sequence
  412.  *     option flags
  413.  * Sniffs at file to see if some other process changed the flags
  414.  */
  416. void mtx_flags (MAILSTREAM *stream,char *sequence,long flags)
  417. {
  418.   unsigned long i;
  419.   if (mtx_ping (stream) &&  /* ping mailbox, get new status for messages */
  420.       ((flags & FT_UID) ? mail_uid_sequence (stream,sequence) :
  421.        mail_sequence (stream,sequence)))
  422.     for (i = 1; i <= stream->nmsgs; i++) 
  423.       if (mail_elt (stream,i)->sequence) mtx_elt (stream,i);
  424. }
  426. /* MTX mail fetch message header
  427.  * Accepts: MAIL stream
  428.  *     message # to fetch
  429.  *     pointer to returned header text length
  430.  *     option flags
  431.  * Returns: message header in RFC822 format
  432.  */
  434. char *mtx_header (MAILSTREAM *stream,unsigned long msgno,unsigned long *length,
  435.   long flags)
  436. {
  437.   *length = 0; /* default to empty */
  438.   if (flags & FT_UID) return "";/* UID call "impossible" */
  439. /* get to header position */
  440.   lseek (LOCAL->fd,mtx_hdrpos (stream,msgno,length),L_SET);
  441. /* is buffer big enough? */
  442.   if (*length > LOCAL->buflen) {
  443.     fs_give ((void **) &LOCAL->buf);
  444.     LOCAL->buf = (char *) fs_get ((LOCAL->buflen = *length) + 1);
  445.   }
  446.   LOCAL->buf[*length] = ''; /* tie off string */
  447. /* slurp the data */
  448.   read (LOCAL->fd,LOCAL->buf,*length);
  449.   return LOCAL->buf;
  450. }
  452. /* MTX mail fetch message text (body only)
  453.  * Accepts: MAIL stream
  454.  *     message # to fetch
  455.  *     pointer to returned header text length
  456.  *     option flags
  457.  * Returns: T, always
  458.  */
  460. long mtx_text (MAILSTREAM *stream,unsigned long msgno,STRING *bs,long flags)
  461. {
  462.   unsigned long i,j;
  463.   MESSAGECACHE *elt;
  464. /* UID call "impossible" */
  465.   if (flags & FT_UID) return NIL;
  466.   elt = mtx_elt (stream,msgno); /* get message status */
  467. /* if message not seen */
  468.   if (!(flags & FT_PEEK) && !elt->seen) {
  469.     elt->seen = T; /* mark message as seen */
  470. /* recalculate status */
  471.     mtx_update_status (stream,msgno,T);
  472.     mm_flags (stream,msgno);
  473.   }
  474. /* find header position */
  475.   i = mtx_hdrpos (stream,msgno,&j);
  476. /* go to text position */
  477.   lseek (LOCAL->fd,i + j,L_SET);
  478. /* is buffer big enough? */
  479.   if ((i = elt->rfc822_size - j) > LOCAL->buflen) {
  480.     fs_give ((void **) &LOCAL->buf);
  481.     LOCAL->buf = (char *) fs_get ((LOCAL->buflen = i) + 1);
  482.   }
  483.   read (LOCAL->fd,LOCAL->buf,i);/* slurp the data */
  484.   LOCAL->buf[i] = ''; /* tie off string */
  485. /* set up stringstruct */
  486.   INIT (bs,mail_string,LOCAL->buf,i);
  487.   return T; /* success */
  488. }
  490. /* MTX mail modify flags
  491.  * Accepts: MAIL stream
  492.  *     sequence
  493.  *     flag(s)
  494.  *     option flags
  495.  */
  497. void mtx_flag (MAILSTREAM *stream,char *sequence,char *flag,long flags)
  498. {
  499.   struct stat sbuf;
  500.   if (!stream->rdonly) { /* make sure the update takes */
  501.     fsync (LOCAL->fd);
  502.     fstat (LOCAL->fd,&sbuf); /* get current write time */
  503.     LOCAL->filetime = sbuf.st_mtime;
  504.   }
  505. }
  508. /* MTX mail per-message modify flags
  509.  * Accepts: MAIL stream
  510.  *     message cache element
  511.  */
  513. void mtx_flagmsg (MAILSTREAM *stream,MESSAGECACHE *elt)
  514. {
  515.   struct stat sbuf;
  516. /* maybe need to do a checkpoint? */
  517.   if (LOCAL->filetime && !LOCAL->shouldcheck) {
  518.     fstat (LOCAL->fd,&sbuf); /* get current write time */
  519.     if (LOCAL->filetime < sbuf.st_mtime) LOCAL->shouldcheck = T;
  520.     LOCAL->filetime = 0; /* don't do this test for any other messages */
  521.   }
  522. /* recalculate status */
  523.   mtx_update_status (stream,elt->msgno,NIL);
  524. }
  526. /* MTX mail ping mailbox
  527.  * Accepts: MAIL stream
  528.  * Returns: T if stream still alive, NIL if not
  529.  */
  531. long mtx_ping (MAILSTREAM *stream)
  532. {
  533.   unsigned long i = 1;
  534.   long r = T;
  535.   int ld;
  536.   char lock[MAILTMPLEN];
  537.   struct stat sbuf;
  538.   if (stream && LOCAL) { /* only if stream already open */
  539.     fstat (LOCAL->fd,&sbuf); /* get current file poop */
  540.     if (LOCAL->filetime && !(LOCAL->mustcheck || LOCAL->shouldcheck) &&
  541. (LOCAL->filetime < sbuf.st_mtime)) LOCAL->shouldcheck = T;
  542. /* check for changed message status */
  543.     if (LOCAL->mustcheck || LOCAL->shouldcheck) {
  544.       if (LOCAL->shouldcheck) /* babble when we do this unilaterally */
  545. mm_notify (stream,"[CHECK] Checking for flag updates",NIL);
  546.       while (i <= stream->nmsgs) mtx_elt (stream,i++);
  547.       LOCAL->mustcheck = LOCAL->shouldcheck = NIL;
  548.     }
  549. /* get shared parse/append permission */
  550.     if ((sbuf.st_size != LOCAL->filesize) &&
  551. ((ld = lockfd (LOCAL->fd,lock,LOCK_SH)) >= 0)) {
  552. /* parse resulting mailbox */
  553.       r = (mtx_parse (stream)) ? T : NIL;
  554.       unlockfd (ld,lock); /* release shared parse/append permission */
  555.     }
  556.     if (LOCAL) { /* stream must still be alive */
  557. /* snarf if this is a read-write inbox */
  558.       if (stream->inbox && !stream->rdonly) {
  559. mtx_snarf (stream);
  560. fstat (LOCAL->fd,&sbuf);/* see if file changed now */
  561. if ((sbuf.st_size != LOCAL->filesize) &&
  562.     ((ld = lockfd (LOCAL->fd,lock,LOCK_SH)) >= 0)) {
  563. /* parse resulting mailbox */
  564.   r = (mtx_parse (stream)) ? T : NIL;
  565.   unlockfd (ld,lock); /* release shared parse/append permission */
  566. }
  567.       }
  568.       else if ((sbuf.st_ctime > sbuf.st_atime) ||
  569.        (sbuf.st_ctime > sbuf.st_mtime)) {
  570. time_t tp[2]; /* whack the times if necessary */
  571. LOCAL->filetime = tp[0] = tp[1] = time (0);
  572. utime (stream->mailbox,tp);
  573.       }
  574.     }
  575.   }
  576.   return r; /* return result of the parse */
  577. }
  580. /* MTX mail check mailbox (reparses status too)
  581.  * Accepts: MAIL stream
  582.  */
  584. void mtx_check (MAILSTREAM *stream)
  585. {
  586. /* mark that a check is desired */
  587.   if (LOCAL) LOCAL->mustcheck = T;
  588.   if (mtx_ping (stream)) mm_log ("Check completed",(long) NIL);
  589. }
  591. /* MTX mail snarf messages from system inbox
  592.  * Accepts: MAIL stream
  593.  */
  595. void mtx_snarf (MAILSTREAM *stream)
  596. {
  597.   unsigned long i = 0;
  598.   unsigned long j,r,hdrlen,txtlen;
  599.   struct stat sbuf;
  600.   char *hdr,*txt,lock[MAILTMPLEN],tmp[MAILTMPLEN];
  601.   MESSAGECACHE *elt;
  602.   MAILSTREAM *sysibx = NIL;
  603.   int ld;
  604. /* give up if can't get exclusive permission */
  605.   if ((time (0) < (LOCAL->lastsnarf + 30)) ||
  606.       (!strcmp (sysinbox (),stream->mailbox)) ||
  607.       ((ld = lockfd (LOCAL->fd,lock,LOCK_EX)) < 0)) return;
  608.   mm_critical (stream); /* go critical */
  609. /* see if anything there */
  610.   if (!stat (sysinbox (),&sbuf) && sbuf.st_size) {
  611.     fstat (LOCAL->fd,&sbuf); /* yes, get current file size */
  612. /* sizes match and can get sysibx mailbox? */
  613.     if ((sbuf.st_size == LOCAL->filesize) && 
  614. (sysibx = mail_open (sysibx,sysinbox (),OP_SILENT)) &&
  615. (!sysibx->rdonly) && (r = sysibx->nmsgs)) {
  616. /* yes, go to end of file in our mailbox */
  617.       lseek (LOCAL->fd,sbuf.st_size,L_SET);
  618. /* for each message in sysibx mailbox */
  619.       while (r && (++i <= sysibx->nmsgs)) {
  620. /* snarf message from system INBOX */
  621. hdr = cpystr (mail_fetchheader_full (sysibx,i,NIL,&hdrlen,NIL));
  622. txt = mail_fetchtext_full (sysibx,i,&txtlen,FT_PEEK);
  623. if (j = hdrlen + txtlen) {
  624. /* calculate header line */
  625.   mail_date (LOCAL->buf,elt = mail_elt (sysibx,i));
  626.   sprintf (LOCAL->buf + strlen (LOCAL->buf),
  627.    ",%lu;0000000000%02o1512",j,(unsigned)
  628.    ((fSEEN * elt->seen) + (fDELETED * elt->deleted) +
  629.     (fFLAGGED * elt->flagged) + (fANSWERED * elt->answered) +
  630.     (fDRAFT * elt->draft)));
  631. /* copy message */
  632.   if ((write (LOCAL->fd,LOCAL->buf,strlen (LOCAL->buf)) < 0) ||
  633.       (write (LOCAL->fd,hdr,hdrlen) < 0) ||
  634.       (write (LOCAL->fd,txt,txtlen) < 0)) r = 0;
  635. }
  636. fs_give ((void **) &hdr);
  637.       }
  638. /* make sure all the updates take */
  639.       if (fsync (LOCAL->fd)) r = 0;
  640.       if (r) { /* delete all the messages we copied */
  641. if (r == 1) strcpy (tmp,"1");
  642. else sprintf (tmp,"1:%lu",r);
  643. mail_flag (sysibx,tmp,"\Deleted",ST_SET);
  644. mail_expunge (sysibx); /* now expunge all those messages */
  645.       }
  646.       else {
  647. sprintf (LOCAL->buf,"Can't copy new mail: %s",strerror (errno));
  648. mm_log (LOCAL->buf,ERROR);
  649. ftruncate (LOCAL->fd,sbuf.st_size);
  650.       }
  651.       fstat (LOCAL->fd,&sbuf); /* yes, get current file size */
  652.       LOCAL->filetime = sbuf.st_mtime;
  653.     }
  654.     if (sysibx) mail_close (sysibx);
  655.   }
  656.   mm_nocritical (stream); /* release critical */
  657.   unlockfd (ld,lock); /* release exclusive parse/append permission */
  658.   LOCAL->lastsnarf = time (0); /* note time of last snarf */
  659. }
  661. /* MTX mail expunge mailbox
  662.  * Accepts: MAIL stream
  663.  */
  665. void mtx_expunge (MAILSTREAM *stream)
  666. {
  667.   struct stat sbuf;
  668.   off_t pos = 0;
  669.   int ld;
  670.   unsigned long i = 1;
  671.   unsigned long j,k,m,recent;
  672.   unsigned long n = 0;
  673.   unsigned long delta = 0;
  674.   char lock[MAILTMPLEN];
  675.   MESSAGECACHE *elt;
  676.   blocknotify_t bn = (blocknotify_t) mail_parameters (NIL,GET_BLOCKNOTIFY,NIL);
  677. /* do nothing if stream dead */
  678.   if (!mtx_ping (stream)) return;
  679.   if (stream->rdonly) { /* won't do on readonly files! */
  680.     mm_log ("Expunge ignored on readonly mailbox",WARN);
  681.     return;
  682.   }
  683.   if (LOCAL->filetime && !LOCAL->shouldcheck) {
  684.     fstat (LOCAL->fd,&sbuf); /* get current write time */
  685.     if (LOCAL->filetime < sbuf.st_mtime) LOCAL->shouldcheck = T;
  686.   }
  687.   /* The cretins who designed flock() created a window of vulnerability in
  688.    * upgrading locks from shared to exclusive or downgrading from exclusive
  689.    * to shared.  Rather than maintain the lock at shared status at a minimum,
  690.    * flock() actually *releases* the former lock.  Obviously they never talked
  691.    * to any database guys.  Fortunately, we have the parse/append permission
  692.    * lock.  If we require this lock before going exclusive on the mailbox,
  693.    * another process can not sneak in and steal the exclusive mailbox lock on
  694.    * us, because it will block on trying to get parse/append permission first.
  695.    */
  696. /* get exclusive parse/append permission */
  697.   if ((ld = lockfd (LOCAL->fd,lock,LOCK_EX)) < 0) {
  698.     mm_log ("Unable to lock expunge mailbox",ERROR);
  699.     return;
  700.   }
  701. /* get exclusive access */
  702.   if (flock (LOCAL->fd,LOCK_EX|LOCK_NB)) {
  703.     (*bn) (BLOCK_FILELOCK,NIL);
  704.     flock (LOCAL->fd,LOCK_SH); /* recover previous lock */
  705.     (*bn) (BLOCK_NONE,NIL);
  706.     mm_log("Can't expunge because mailbox is in use by another process",ERROR);
  707.     unlockfd (ld,lock); /* release exclusive parse/append permission */
  708.     return;
  709.   }
  711.   mm_critical (stream); /* go critical */
  712.   recent = stream->recent; /* get recent now that pinged and locked */
  713.   while (i <= stream->nmsgs) { /* for each message */
  714.     elt = mtx_elt (stream,i); /* get cache element */
  715. /* number of bytes to smash or preserve */
  716.     k = elt->private.special.text.size + elt->rfc822_size;
  717.     if (elt->deleted) { /* if deleted */
  718.       if (elt->recent) --recent;/* if recent, note one less recent message */
  719.       delta += k; /* number of bytes to delete */
  720.       mail_expunged (stream,i); /* notify upper levels */
  721.       n++; /* count up one more expunged message */
  722.     }
  723.     else if (i++ && delta) { /* preserved message */
  724. /* first byte to preserve */
  725.       j = elt->private.special.offset;
  726.       do { /* read from source position */
  727. m = min (k,LOCAL->buflen);
  728. lseek (LOCAL->fd,j,L_SET);
  729. read (LOCAL->fd,LOCAL->buf,m);
  730. pos = j - delta; /* write to destination position */
  731. lseek (LOCAL->fd,pos,L_SET);
  732. while (T) {
  733.   lseek (LOCAL->fd,pos,L_SET);
  734.   if (write (LOCAL->fd,LOCAL->buf,m) > 0) break;
  735.   mm_notify (stream,strerror (errno),WARN);
  736.   mm_diskerror (stream,errno,T);
  737. }
  738. pos += m; /* new position */
  739. j += m; /* next chunk, perhaps */
  740.       } while (k -= m); /* until done */
  741. /* note the new address of this text */
  742.       elt->private.special.offset -= delta;
  743.     }
  744. /* preserved but no deleted messages */
  745.     else pos = elt->private.special.offset + k;
  746.   }
  747.   if (n) { /* truncate file after last message */
  748.     if (pos != (LOCAL->filesize -= delta)) {
  749.       sprintf (LOCAL->buf,"Calculated size mismatch %lu != %lu, delta = %lu",
  750.        (unsigned long) pos,(unsigned long) LOCAL->filesize,delta);
  751.       mm_log (LOCAL->buf,WARN);
  752.       LOCAL->filesize = pos; /* fix it then */
  753.     }
  754.     ftruncate (LOCAL->fd,LOCAL->filesize);
  755.     sprintf (LOCAL->buf,"Expunged %lu messages",n);
  756. /* output the news */
  757.     mm_log (LOCAL->buf,(long) NIL);
  758.   }
  759.   else mm_log ("No messages deleted, so no update needed",(long) NIL);
  760.   fsync (LOCAL->fd); /* force disk update */
  761.   fstat (LOCAL->fd,&sbuf); /* get new write time */
  762.   LOCAL->filetime = sbuf.st_mtime;
  763.   mm_nocritical (stream); /* release critical */
  764. /* notify upper level of new mailbox size */
  765.   mail_exists (stream,stream->nmsgs);
  766.   mail_recent (stream,recent);
  767.   (*bn) (BLOCK_FILELOCK,NIL);
  768.   flock (LOCAL->fd,LOCK_SH); /* allow sharers again */
  769.   (*bn) (BLOCK_NONE,NIL);
  770.   unlockfd (ld,lock); /* release exclusive parse/append permission */
  771. }
  773. /* MTX mail copy message(s)
  774.  * Accepts: MAIL stream
  775.  *     sequence
  776.  *     destination mailbox
  777.  *     copy options
  778.  * Returns: T if success, NIL if failed
  779.  */
  781. long mtx_copy (MAILSTREAM *stream,char *sequence,char *mailbox,long options)
  782. {
  783.   struct stat sbuf;
  784.   time_t tp[2];
  785.   MESSAGECACHE *elt;
  786.   unsigned long i,j,k;
  787.   long ret = LONGT;
  788.   int fd,ld;
  789.   char file[MAILTMPLEN],lock[MAILTMPLEN];
  790.   mailproxycopy_t pc =
  791.     (mailproxycopy_t) mail_parameters (stream,GET_MAILPROXYCOPY,NIL);
  792. /* make sure valid mailbox */
  793.   if (!mtx_isvalid (mailbox,LOCAL->buf)) switch (errno) {
  794.   case ENOENT: /* no such file? */
  795.     mm_notify (stream,"[TRYCREATE] Must create mailbox before copy",NIL);
  796.     return NIL;
  797.   case 0: /* merely empty file? */
  798.     break;
  799.   case EINVAL:
  800.     if (pc) return (*pc) (stream,sequence,mailbox,options);
  801.     sprintf (LOCAL->buf,"Invalid MTX-format mailbox name: %.80s",mailbox);
  802.     mm_log (LOCAL->buf,ERROR);
  803.     return NIL;
  804.   default:
  805.     if (pc) return (*pc) (stream,sequence,mailbox,options);
  806.     sprintf (LOCAL->buf,"Not a MTX-format mailbox: %.80s",mailbox);
  807.     mm_log (LOCAL->buf,ERROR);
  808.     return NIL;
  809.   }
  810.   if (!((options & CP_UID) ? mail_uid_sequence (stream,sequence) :
  811. mail_sequence (stream,sequence))) return NIL;
  812. /* got file? */  
  813.   if ((fd=  open (mtx_file (file,mailbox),O_RDWR|O_CREAT,S_IREAD|S_IWRITE))<0){
  814.     sprintf (LOCAL->buf,"Unable to open copy mailbox: %s",strerror (errno));
  815.     mm_log (LOCAL->buf,ERROR);
  816.     return NIL;
  817.   }
  818.   mm_critical (stream); /* go critical */
  819. /* get exclusive parse/append permission */
  820.   if ((ld = lockfd (fd,lock,LOCK_EX)) < 0) {
  821.     mm_log ("Unable to lock copy mailbox",ERROR);
  822.     return NIL;
  823.   }
  824.   fstat (fd,&sbuf); /* get current file size */
  825.   lseek (fd,sbuf.st_size,L_SET);/* move to end of file */
  827. /* for each requested message */
  828.   for (i = 1; ret && (i <= stream->nmsgs); i++) 
  829.     if ((elt = mail_elt (stream,i))->sequence) {
  830.       lseek (LOCAL->fd,elt->private.special.offset,L_SET);
  831. /* number of bytes to copy */
  832.       k = elt->private.special.text.size + elt->rfc822_size;
  833.       do { /* read from source position */
  834. j = min (k,LOCAL->buflen);
  835. read (LOCAL->fd,LOCAL->buf,j);
  836. if (write (fd,LOCAL->buf,j) < 0) ret = NIL;
  837.       } while (ret && (k -= j));/* until done */
  838.     }
  839. /* make sure all the updates take */
  840.   if (!(ret && (ret = !fsync (fd)))) {
  841.     sprintf (LOCAL->buf,"Unable to write message: %s",strerror (errno));
  842.     mm_log (LOCAL->buf,ERROR);
  843.     ftruncate (fd,sbuf.st_size);
  844.   }
  845.   tp[0] = sbuf.st_atime; /* preserve atime and mtime */
  846.   tp[1] = sbuf.st_mtime;
  847.   utime (file,tp); /* set the times */
  848.   close (fd); /* close the file */
  849.   unlockfd (ld,lock); /* release exclusive parse/append permission */
  850.   mm_nocritical (stream); /* release critical */
  851. /* delete all requested messages */
  852.   if (ret && (options & CP_MOVE)) {
  853.     for (i = 1; i <= stream->nmsgs; i++)
  854.       if ((elt = mtx_elt (stream,i))->sequence) {
  855. elt->deleted = T; /* mark message deleted */
  856. /* recalculate status */
  857. mtx_update_status (stream,i,NIL);
  858.       }
  859.     if (!stream->rdonly) { /* make sure the update takes */
  860.       fsync (LOCAL->fd);
  861.       fstat (LOCAL->fd,&sbuf); /* get current write time */
  862.       LOCAL->filetime = sbuf.st_mtime;
  863.     }
  864.   }
  865.   return ret;
  866. }
  868. /* MTX mail append message from stringstruct
  869.  * Accepts: MAIL stream
  870.  *     destination mailbox
  871.  *     stringstruct of messages to append
  872.  * Returns: T if append successful, else NIL
  873.  */
  875. long mtx_append (MAILSTREAM *stream,char *mailbox,char *flags,char *date,
  876.  STRING *message)
  877. {
  878.   struct stat sbuf;
  879.   int fd,ld;
  880.   char *s,tmp[MAILTMPLEN],file[MAILTMPLEN],lock[MAILTMPLEN];
  881.   time_t tp[2];
  882.   MESSAGECACHE elt;
  883.   long i = 0;
  884.   long size = SIZE (message);
  885.   long ret = LONGT;
  886.   unsigned long uf = 0,j;
  887.   long f = mail_parse_flags (stream ? stream : user_flags (&mtxproto),
  888.      flags,&j);
  889. /* reverse bits (dontcha wish we had CIRC?) */
  890.   while (j) uf |= 1 << (29 - find_rightmost_bit (&j));
  891.   if (date) { /* want to preserve date? */
  892. /* yes, parse date into an elt */
  893.     if (!mail_parse_date (&elt,date)) {
  894.       sprintf (tmp,"Bad date in append: %.80s",date);
  895.       mm_log (tmp,ERROR);
  896.       return NIL;
  897.     }
  898.   }
  899. /* N.B.: can't use LOCAL->buf for tmp */
  900. /* make sure valid mailbox */
  901.   if (!mtx_isvalid (mailbox,tmp)) switch (errno) {
  902.   case ENOENT: /* no such file? */
  903.     if (((mailbox[0] == 'I') || (mailbox[0] == 'i')) &&
  904. ((mailbox[1] == 'N') || (mailbox[1] == 'n')) &&
  905. ((mailbox[2] == 'B') || (mailbox[2] == 'b')) &&
  906. ((mailbox[3] == 'O') || (mailbox[3] == 'o')) &&
  907. ((mailbox[4] == 'X') || (mailbox[4] == 'x')) && !mailbox[5])
  908.       dummy_create (NIL,"INBOX.MTX");
  909.     else {
  910.       mm_notify (stream,"[TRYCREATE] Must create mailbox before append",NIL);
  911.       return NIL;
  912.     }
  913. /* falls through */
  914.   case 0: /* merely empty file? */
  915.     break;
  916.   case EINVAL:
  917.     sprintf (tmp,"Invalid MTX-format mailbox name: %.80s",mailbox);
  918.     mm_log (tmp,ERROR);
  919.     return NIL;
  920.   default:
  921.     sprintf (tmp,"Not a MTX-format mailbox: %.80s",mailbox);
  922.     mm_log (tmp,ERROR);
  923.     return NIL;
  924.   }
  925.   if ((fd = open (mtx_file (file,mailbox),O_RDWR|O_CREAT,
  926.   S_IREAD|S_IWRITE)) < 0) {
  927.     sprintf (tmp,"Can't open append mailbox: %s",strerror (errno));
  928.     mm_log (tmp,ERROR);
  929.     return NIL;
  930.   }
  931. /* get exclusive parse/append permission */
  932.   if ((ld = lockfd (fd,lock,LOCK_EX)) < 0) {
  933.     mm_log ("Unable to lock append mailbox",ERROR);
  934.     return NIL;
  935.   }
  937.   mm_critical (stream); /* go critical */
  938.   fstat (fd,&sbuf); /* get current file size */
  939.   lseek (fd,sbuf.st_size,L_SET);/* move to end of file */
  940.   if (date) mail_date(tmp,&elt);/* write preseved date */
  941.   else internal_date (tmp); /* get current date in IMAP format */
  942. /* add remainder of header */
  943.   sprintf (tmp+26,",%ld;%010lo%02o1512",size,uf,(unsigned) f);
  944.   size += (i = strlen (tmp)); /* size of buffer */
  945.   s = (char *) fs_get (size); /* get buffer for message */
  946.   strncpy (s,tmp,i); /* copy message */
  947.   while (i < size) s[i++] = SNX (message);
  948. /* write message */
  949.   if ((write (fd,s,size) < 0) || fsync (fd)) {
  950.     sprintf (tmp,"Message append failed: %s",strerror (errno));
  951.     mm_log (tmp,ERROR);
  952.     ftruncate (fd,sbuf.st_size);
  953.     ret = NIL;
  954.   }
  955.   tp[0] = sbuf.st_atime; /* preserve atime and mtime */
  956.   tp[1] = sbuf.st_mtime;
  957.   utime (file,tp); /* set the times */
  958.   close (fd); /* close the file */
  959.   unlockfd (ld,lock); /* release exclusive parse/append permission */
  960.   mm_nocritical (stream); /* release critical */
  961.   fs_give ((void **) &s); /* flush the buffer */
  962.   return ret;
  963. }
  965. /* Internal routines */
  968. /* MTX mail generate file string
  969.  * Accepts: temporary buffer to write into
  970.  *     mailbox name string
  971.  * Returns: local file string or NIL if failure
  972.  */
  974. char *mtx_file (char *dst,char *name)
  975. {
  976.   char tmp[MAILTMPLEN];
  977.   char *s = mailboxfile (dst,name);
  978. /* return our standard inbox */
  979.   return (s && !*s) ? mailboxfile (dst,mtx_isvalid ("~/INBOX",tmp) ?
  980.    "~/INBOX" : "INBOX.MTX") : s;
  981. }
  983. /* MTX mail parse mailbox
  984.  * Accepts: MAIL stream
  985.  * Returns: T if parse OK
  986.  *     NIL if failure, stream aborted
  987.  */
  989. long mtx_parse (MAILSTREAM *stream)
  990. {
  991.   struct stat sbuf;
  992.   MESSAGECACHE *elt = NIL;
  993.   char c,*s,*t,*x;
  994.   char tmp[MAILTMPLEN];
  995.   unsigned long i,j;
  996.   long curpos = LOCAL->filesize;
  997.   long nmsgs = stream->nmsgs;
  998.   long recent = stream->recent;
  999.   short silent = stream->silent;
  1000.   fstat (LOCAL->fd,&sbuf); /* get status */
  1001.   if (sbuf.st_size < curpos) { /* sanity check */
  1002.     sprintf (tmp,"Mailbox shrank from %ld to %ld!",curpos,sbuf.st_size);
  1003.     mm_log (tmp,ERROR);
  1004.     mtx_close (stream,NIL);
  1005.     return NIL;
  1006.   }
  1007.   stream->silent = T; /* don't pass up mm_exists() events yet */
  1008.   while (sbuf.st_size - curpos){/* while there is stuff to parse */
  1009. /* get to that position in the file */
  1010.     lseek (LOCAL->fd,curpos,L_SET);
  1011.     if ((i = read (LOCAL->fd,LOCAL->buf,64)) <= 0) {
  1012.       sprintf (tmp,"Unable to read internal header at %lu, size = %lu: %s",
  1013.        (unsigned long) curpos,(unsigned long) sbuf.st_size,
  1014.        i ? strerror (errno) : "no data read");
  1015.       mm_log (tmp,ERROR);
  1016.       mtx_close (stream,NIL);
  1017.       return NIL;
  1018.     }
  1019.     LOCAL->buf[i] = ''; /* tie off buffer just in case */
  1020.     if (!((s = strchr (LOCAL->buf,'15')) && (s[1] == '12'))) {
  1021.       sprintf (tmp,"Unable to find CRLF at %lu in %lu bytes, text: %s",
  1022.        (unsigned long) curpos,i,LOCAL->buf);
  1023.       mm_log (tmp,ERROR);
  1024.       mtx_close (stream,NIL);
  1025.       return NIL;
  1026.     }
  1027.     *s = ''; /* tie off header line */
  1028.     i = (s + 2) - LOCAL->buf; /* note start of text offset */
  1029.     if (!((s = strchr (LOCAL->buf,',')) && (t = strchr (s+1,';')))) {
  1030.       sprintf (tmp,"Unable to parse internal header at %lu: %s",
  1031.        (unsigned long) curpos,LOCAL->buf);
  1032.       mm_log (tmp,ERROR);
  1033.       mtx_close (stream,NIL);
  1034.       return NIL;
  1035.     }
  1036.     *s++ = ''; *t++ = ''; /* tie off fields */
  1038. /* swell the cache */
  1039.     mail_exists (stream,++nmsgs);
  1040. /* instantiate an elt for this message */
  1041.     (elt = mail_elt (stream,nmsgs))->valid = T;
  1042.     elt->private.uid = ++stream->uid_last;
  1043. /* note file offset of header */
  1044.     elt->private.special.offset = curpos;
  1045. /* in case error */
  1046.     elt->private.special.text.size = 0;
  1047. /* header size not known yet */
  1048.     elt->private.msg.header.text.size = 0;
  1049.     x = s; /* parse the header components */
  1050.     if (mail_parse_date (elt,LOCAL->buf) &&
  1051. (elt->rfc822_size = strtoul (s,&s,10)) && (!(s && *s)) &&
  1052. isdigit (t[0]) && isdigit (t[1]) && isdigit (t[2]) &&
  1053. isdigit (t[3]) && isdigit (t[4]) && isdigit (t[5]) &&
  1054. isdigit (t[6]) && isdigit (t[7]) && isdigit (t[8]) &&
  1055. isdigit (t[9]) && isdigit (t[10]) && isdigit (t[11]) && !t[12])
  1056.       elt->private.special.text.size = i;
  1057.     if (elt->private.special.text.size) elt->private.msg.header.offset =
  1058.       elt->private.msg.text.offset = 
  1059. elt->private.special.offset + elt->private.special.text.size;
  1060.     else { /* oops */
  1061.       sprintf (tmp,"Unable to parse internal header elements at %ld: %s,%s;%s",
  1062.        curpos,LOCAL->buf,x,t);
  1063.       mm_log (tmp,ERROR);
  1064.       mtx_close (stream,NIL);
  1065.       return NIL;
  1066.     }
  1067. /* make sure didn't run off end of file */
  1068.     if ((curpos += (elt->rfc822_size + i)) > sbuf.st_size) {
  1069.       sprintf (tmp,"Last message (at %lu) runs past end of file (%lu > %lu)",
  1070.        elt->private.special.offset,(unsigned long) curpos,
  1071.        (unsigned long) sbuf.st_size);
  1072.       mm_log (tmp,ERROR);
  1073.       mtx_close (stream,NIL);
  1074.       return NIL;
  1075.     }
  1076.     c = t[10]; /* remember first system flags byte */
  1077.     t[10] = ''; /* tie off flags */
  1078.     j = strtoul (t,NIL,8); /* get user flags value */
  1079.     t[10] = c; /* restore first system flags byte */
  1080. /* set up all valid user flags (reversed!) */
  1081.     while (j) if (((i = 29 - find_rightmost_bit (&j)) < NUSERFLAGS) &&
  1082.   stream->user_flags[i]) elt->user_flags |= 1 << i;
  1083. /* calculate system flags */
  1084.     if ((j = ((t[10]-'0') * 8) + t[11]-'0') & fSEEN) elt->seen = T;
  1085.     if (j & fDELETED) elt->deleted = T;
  1086.     if (j & fFLAGGED) elt->flagged = T;
  1087.     if (j & fANSWERED) elt->answered = T;
  1088.     if (j & fDRAFT) elt->draft = T;
  1089.     if (!(j & fOLD)) { /* newly arrived message? */
  1090.       elt->recent = T;
  1091.       recent++; /* count up a new recent message */
  1092. /* mark it as old */
  1093.       mtx_update_status (stream,nmsgs,NIL);
  1094.     }
  1095.   }
  1096.   fsync (LOCAL->fd); /* make sure all the fOLD flags take */
  1097. /* update parsed file size and time */
  1098.   LOCAL->filesize = sbuf.st_size;
  1099.   fstat (LOCAL->fd,&sbuf); /* get status again to ensure time is right */
  1100.   LOCAL->filetime = sbuf.st_mtime;
  1101.   stream->silent = silent; /* can pass up events now */
  1102.   mail_exists (stream,nmsgs); /* notify upper level of new mailbox size */
  1103.   mail_recent (stream,recent); /* and of change in recent messages */
  1104.   return LONGT; /* return the winnage */
  1105. }
  1107. /* MTX get cache element with status updating from file
  1108.  * Accepts: MAIL stream
  1109.  *     message number
  1110.  * Returns: cache element
  1111.  */
  1113. MESSAGECACHE *mtx_elt (MAILSTREAM *stream,unsigned long msgno)
  1114. {
  1115.   MESSAGECACHE *elt = mail_elt (stream,msgno);
  1116.   struct { /* old flags */
  1117.     unsigned int seen : 1;
  1118.     unsigned int deleted : 1;
  1119.     unsigned int flagged : 1;
  1120.     unsigned int answered : 1;
  1121.     unsigned int draft : 1;
  1122.     unsigned long user_flags;
  1123.   } old;
  1124.   old.seen = elt->seen; old.deleted = elt->deleted; old.flagged = elt->flagged;
  1125.   old.answered = elt->answered; old.draft = elt->draft;
  1126.   old.user_flags = elt->user_flags;
  1127.   mtx_read_flags (stream,elt);
  1128.   if ((old.seen != elt->seen) || (old.deleted != elt->deleted) ||
  1129.       (old.flagged != elt->flagged) || (old.answered != elt->answered) ||
  1130.       (old.draft != elt->draft) || (old.user_flags != elt->user_flags))
  1131.     mm_flags (stream,msgno); /* let top level know */
  1132.   return elt;
  1133. }
  1135. /* MTX read flags from file
  1136.  * Accepts: MAIL stream
  1137.  * Returns: cache element
  1138.  */
  1140. void mtx_read_flags (MAILSTREAM *stream,MESSAGECACHE *elt)
  1141. {
  1142.   unsigned long i,j;
  1143. /* noop if readonly and have valid flags */
  1144.   if (stream->rdonly && elt->valid) return;
  1145. /* set the seek pointer */
  1146.   lseek (LOCAL->fd,(off_t) elt->private.special.offset +
  1147.  elt->private.special.text.size - 14,L_SET);
  1148. /* read the new flags */
  1149.   if (read (LOCAL->fd,LOCAL->buf,12) < 0) {
  1150.     sprintf (LOCAL->buf,"Unable to read new status: %s",strerror (errno));
  1151.     fatal (LOCAL->buf);
  1152.   }
  1153. /* calculate system flags */
  1154.   i = (((LOCAL->buf[10]-'0') * 8) + LOCAL->buf[11]-'0');
  1155.   elt->seen = i & fSEEN ? T : NIL; elt->deleted = i & fDELETED ? T : NIL;
  1156.   elt->flagged = i & fFLAGGED ? T : NIL;
  1157.   elt->answered = i & fANSWERED ? T : NIL; elt->draft = i & fDRAFT ? T : NIL;
  1158.   LOCAL->buf[10] = ''; /* tie off flags */
  1159.   j = strtoul(LOCAL->buf,NIL,8);/* get user flags value */
  1160. /* set up all valid user flags (reversed!) */
  1161.   while (j) if (((i = 29 - find_rightmost_bit (&j)) < NUSERFLAGS) &&
  1162. stream->user_flags[i]) elt->user_flags |= 1 << i;
  1163.   elt->valid = T; /* have valid flags now */
  1164. }
  1166. /* MTX update status string
  1167.  * Accepts: MAIL stream
  1168.  *     message number
  1169.  *     flag saying whether or not to sync
  1170.  */
  1172. void mtx_update_status (MAILSTREAM *stream,unsigned long msgno,long syncflag)
  1173. {
  1174.   MESSAGECACHE *elt = mail_elt (stream,msgno);
  1175.   struct stat sbuf;
  1176.   unsigned long j,k = 0;
  1177. /* readonly */
  1178.   if (stream->rdonly || !elt->valid) mtx_read_flags (stream,elt);
  1179.   else { /* readwrite */
  1180.     j = elt->user_flags; /* get user flags */
  1181. /* reverse bits (dontcha wish we had CIRC?) */
  1182.     while (j) k |= 1 << (29 - find_rightmost_bit (&j));
  1183. /* print new flag string */
  1184.     sprintf (LOCAL->buf,"%010lo%02o",k,(unsigned)
  1185.      (fOLD + (fSEEN * elt->seen) + (fDELETED * elt->deleted) +
  1186.       (fFLAGGED * elt->flagged) + (fANSWERED * elt->answered) +
  1187.       (fDRAFT * elt->draft)));
  1188. /* get to that place in the file */
  1189.     lseek (LOCAL->fd,(off_t) elt->private.special.offset +
  1190.    elt->private.special.text.size - 14,L_SET);
  1191. /* write new flags */
  1192.     write (LOCAL->fd,LOCAL->buf,12);
  1193.     if (syncflag) { /* sync if requested */
  1194.       fsync (LOCAL->fd);
  1195.       fstat (LOCAL->fd,&sbuf); /* get new write time */
  1196.       LOCAL->filetime = sbuf.st_mtime;
  1197.     }
  1198.   }
  1199. }
  1201. /* MTX locate header for a message
  1202.  * Accepts: MAIL stream
  1203.  *     message number
  1204.  *     pointer to returned header size
  1205.  * Returns: position of header in file
  1206.  */
  1208. unsigned long mtx_hdrpos (MAILSTREAM *stream,unsigned long msgno,
  1209.   unsigned long *size)
  1210. {
  1211.   unsigned long siz;
  1212.   long i = 0;
  1213.   int q = 0;
  1214.   char *s,tmp[MAILTMPLEN];
  1215.   MESSAGECACHE *elt = mtx_elt (stream,msgno);
  1216. /* is header size known? */
  1217.   if (!(*size = elt->private.msg.header.text.size)) {
  1218. /* get to header position */
  1219.     lseek (LOCAL->fd,elt->private.msg.header.offset,L_SET);
  1220. /* search message for CRLF CRLF */
  1221.     for (siz = 1,s = tmp; siz <= elt->rfc822_size; siz++) {
  1222. /* read another buffer as necessary */
  1223.       if (--i <= 0) /* buffer empty? */
  1224. if (read (LOCAL->fd,s = tmp,
  1225.   i = min (elt->rfc822_size - siz,(long) MAILTMPLEN)) < 0)
  1226. /* I/O error? */
  1227.   return elt->private.msg.header.offset;
  1228.       switch (q) { /* sniff at buffer */
  1229.       case 0: /* first character */
  1230. q = (*s++ == '15') ? 1 : 0;
  1231. break;
  1232.       case 1: /* second character */
  1233. q = (*s++ == '12') ? 2 : 0;
  1234. break;
  1235.       case 2: /* third character */
  1236. q = (*s++ == '15') ? 3 : 0;
  1237. break;
  1238.       case 3: /* fourth character */
  1239. if (*s++ == '12') { /* have the sequence? */
  1240. /* yes, note for later */
  1241.   elt->private.msg.header.text.size = *size = siz;
  1242.   return elt->private.msg.header.offset;
  1243. }
  1244. q = 0; /* lost... */
  1245. break;
  1246.       }
  1247.     }
  1248. /* header consumes entire message */
  1249.     elt->private.msg.header.text.size = *size = elt->rfc822_size;
  1250.   }
  1251.   return elt->private.msg.header.offset;
  1252. }