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

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

网络编程

开发平台：

Unix_Linux

unix.c：源码内容
  1. /*
  2.  * Program: UNIX 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: 20 December 1989
  13.  * Last Edited: 14 October 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. /* DEDICATION
  38.  *
  39.  *  This file is dedicated to my dog, Unix, also known as Yun-chan and
  40.  * Unix J. Terwilliker Jehosophat Aloysius Monstrosity Animal Beast.  Unix
  41.  * passed away at the age of 11 1/2 on September 14, 1996, 12:18 PM PDT, after
  42.  * a two-month bout with cirrhosis of the liver.
  43.  *
  44.  *  He was a dear friend, and I miss him terribly.
  45.  *
  46.  *  Lift a leg, Yunie.  Luv ya forever!!!!
  47.  */
  49. #include <stdio.h>
  50. #include <ctype.h>
  51. #include <errno.h>
  52. extern int errno; /* just in case */
  53. #include <signal.h>
  54. #include "mail.h"
  55. #include "osdep.h"
  56. #include <time.h>
  57. #include <sys/stat.h>
  58. #include "unix.h"
  59. #include "pseudo.h"
  60. #include "fdstring.h"
  61. #include "misc.h"
  62. #include "dummy.h"
  64. /* UNIX mail routines */
  67. /* Driver dispatch used by MAIL */
  69. DRIVER unixdriver = {
  70.   "unix", /* driver name */
  71.   DR_LOCAL|DR_MAIL, /* driver flags */
  72.   (DRIVER *) NIL, /* next driver */
  73.   unix_valid, /* mailbox is valid for us */
  74.   unix_parameters, /* manipulate parameters */
  75.   unix_scan, /* scan mailboxes */
  76.   unix_list, /* list mailboxes */
  77.   unix_lsub, /* list subscribed mailboxes */
  78.   NIL, /* subscribe to mailbox */
  79.   NIL, /* unsubscribe from mailbox */
  80.   unix_create, /* create mailbox */
  81.   unix_delete, /* delete mailbox */
  82.   unix_rename, /* rename mailbox */
  83.   NIL, /* status of mailbox */
  84.   unix_open, /* open mailbox */
  85.   unix_close, /* close mailbox */
  86.   NIL, /* fetch message "fast" attributes */
  87.   NIL, /* fetch message flags */
  88.   NIL, /* fetch overview */
  89.   NIL, /* fetch message envelopes */
  90.   unix_header, /* fetch message header */
  91.   unix_text, /* fetch message text */
  92.   NIL, /* fetch partial message text */
  93.   NIL, /* unique identifier */
  94.   NIL, /* message number */
  95.   NIL, /* modify flags */
  96.   unix_flagmsg, /* per-message modify flags */
  97.   NIL, /* search for message based on criteria */
  98.   NIL, /* sort messages */
  99.   NIL, /* thread messages */
  100.   unix_ping, /* ping mailbox to see if still alive */
  101.   unix_check, /* check for new messages */
  102.   unix_expunge, /* expunge deleted messages */
  103.   unix_copy, /* copy messages to another mailbox */
  104.   unix_append, /* append string message to mailbox */
  105.   NIL /* garbage collect stream */
  106. };
  108. /* prototype stream */
  109. MAILSTREAM unixproto = {&unixdriver};
  111. /* driver parameters */
  112. static long unix_fromwidget = T;
  114. /* UNIX mail validate mailbox
  115.  * Accepts: mailbox name
  116.  * Returns: our driver if name is valid, NIL otherwise
  117.  */
  119. DRIVER *unix_valid (char *name)
  120. {
  121.   int fd;
  122.   DRIVER *ret = NIL;
  123.   char *t,file[MAILTMPLEN];
  124.   struct stat sbuf;
  125.   time_t tp[2];
  126.   errno = EINVAL; /* assume invalid argument */
  127. /* must be non-empty file */
  128.   if ((t = dummy_file (file,name)) && !stat (t,&sbuf)) {
  129.     if (!sbuf.st_size)errno = 0;/* empty file */
  130.     else if ((fd = open (file,O_RDONLY,NIL)) >= 0) {
  131. /* OK if mailbox format good */
  132.       if (unix_isvalid_fd (fd)) ret = &unixdriver;
  133.       else errno = -1; /* invalid format */
  134.       close (fd); /* close the file */
  135.       tp[0] = sbuf.st_atime; /* preserve atime and mtime */
  136.       tp[1] = sbuf.st_mtime;
  137.       utime (file,tp); /* set the times */
  138.     }
  139.   }
  140. /* in case INBOX but not unix format */
  141.   else if ((errno == ENOENT) && ((name[0] == 'I') || (name[0] == 'i')) &&
  142.    ((name[1] == 'N') || (name[1] == 'n')) &&
  143.    ((name[2] == 'B') || (name[2] == 'b')) &&
  144.    ((name[3] == 'O') || (name[3] == 'o')) &&
  145.    ((name[4] == 'X') || (name[4] == 'x')) && !name[5]) errno = -1;
  146.   return ret; /* return what we should */
  147. }
  149. /* UNIX mail test for valid mailbox
  150.  * Accepts: file descriptor
  151.  *     scratch buffer
  152.  * Returns: T if valid, NIL otherwise
  153.  */
  155. long unix_isvalid_fd (int fd)
  156. {
  157.   int zn;
  158.   int ret = NIL;
  159.   char tmp[MAILTMPLEN],*s,*t,c = 'n';
  160.   memset (tmp,'',MAILTMPLEN);
  161.   if (read (fd,tmp,MAILTMPLEN-1) >= 0) {
  162.     for (s = tmp; (*s == 'r') || (*s == 'n') || (*s == ' ') || (*s == 't');)
  163.       c = *s++;
  164.     if (c == 'n') VALID (s,t,ret,zn);
  165.   }
  166.   return ret; /* return what we should */
  167. }
  170. /* UNIX manipulate driver parameters
  171.  * Accepts: function code
  172.  *     function-dependent value
  173.  * Returns: function-dependent return value
  174.  */
  176. void *unix_parameters (long function,void *value)
  177. {
  178.   switch ((int) function) {
  179.   case SET_FROMWIDGET:
  180.     unix_fromwidget = (long) value;
  181.     break;
  182.   case GET_FROMWIDGET:
  183.     value = (void *) unix_fromwidget;
  184.     break;
  185.   default:
  186.     value = NIL; /* error case */
  187.     break;
  188.   }
  189.   return value;
  190. }
  192. /* UNIX mail scan mailboxes
  193.  * Accepts: mail stream
  194.  *     reference
  195.  *     pattern to search
  196.  *     string to scan
  197.  */
  199. void unix_scan (MAILSTREAM *stream,char *ref,char *pat,char *contents)
  200. {
  201.   if (stream) dummy_scan (NIL,ref,pat,contents);
  202. }
  205. /* UNIX mail list mailboxes
  206.  * Accepts: mail stream
  207.  *     reference
  208.  *     pattern to search
  209.  */
  211. void unix_list (MAILSTREAM *stream,char *ref,char *pat)
  212. {
  213.   if (stream) dummy_list (NIL,ref,pat);
  214. }
  217. /* UNIX mail list subscribed mailboxes
  218.  * Accepts: mail stream
  219.  *     reference
  220.  *     pattern to search
  221.  */
  223. void unix_lsub (MAILSTREAM *stream,char *ref,char *pat)
  224. {
  225.   if (stream) dummy_lsub (NIL,ref,pat);
  226. }
  228. /* UNIX mail create mailbox
  229.  * Accepts: MAIL stream
  230.  *     mailbox name to create
  231.  * Returns: T on success, NIL on failure
  232.  */
  234. long unix_create (MAILSTREAM *stream,char *mailbox)
  235. {
  236.   char *s,mbx[MAILTMPLEN],tmp[MAILTMPLEN];
  237.   long ret = NIL;
  238.   int i,fd;
  239.   time_t ti = time (0);
  240.   if (!(s = dummy_file (mbx,mailbox))) {
  241.     sprintf (tmp,"Can't create %.80s: invalid name",mailbox);
  242.     mm_log (tmp,ERROR);
  243.   }
  244. /* create underlying file */
  245.   else if (dummy_create_path (stream,s)) {
  246. /* done if made directory */
  247.     if ((s = strrchr (s,'/')) && !s[1]) return T;
  248.     if ((fd = open (mbx,O_WRONLY,
  249.     (int) mail_parameters (NIL,GET_MBXPROTECTION,NIL))) < 0) {
  250.       sprintf (tmp,"Can't reopen mailbox node %.80s: %s",mbx,strerror (errno));
  251.       mm_log (tmp,ERROR);
  252.       unlink (mbx); /* delete the file */
  253.     }
  254. /* in case a whiner with no life */
  255.     else if (mail_parameters (NIL,GET_USERHASNOLIFE,NIL)) ret = T;
  256.     else { /* initialize header */
  257.       memset (tmp,'',MAILTMPLEN);
  258.       sprintf (tmp,"From %s %sDate: ",pseudo_from,ctime (&ti));
  259.       rfc822_fixed_date (s = tmp + strlen (tmp));
  260. /* write the pseudo-header */
  261.       sprintf (s += strlen (s),
  262.        "nFrom: %s <%s@%s>nSubject: %snX-IMAP: %010lu 0000000000",
  263.        pseudo_name,pseudo_from,mylocalhost (),pseudo_subject,
  264.        (unsigned long) ti);
  265.       for (i = 0; i < NUSERFLAGS; ++i) if (default_user_flag (i))
  266. sprintf (s += strlen (s)," %s",default_user_flag (i));
  267.       sprintf (s += strlen (s),"nStatus: ROnn%snn",pseudo_msg);
  268.       if ((write (fd,tmp,strlen (tmp)) < 0) || close (fd)) {
  269. sprintf (tmp,"Can't initialize mailbox node %.80s: %s",mbx,
  270.  strerror (errno));
  271. mm_log (tmp,ERROR);
  272. unlink (mbx); /* delete the file */
  273.       }
  274.       else ret = T; /* success */
  275.     }
  276.     close (fd); /* close file, set proper protections */
  277.   }
  278.   return ret ? set_mbx_protections (mailbox,mbx) : NIL;
  279. }
  282. /* UNIX mail delete mailbox
  283.  * Accepts: MAIL stream
  284.  *     mailbox name to delete
  285.  * Returns: T on success, NIL on failure
  286.  */
  288. long unix_delete (MAILSTREAM *stream,char *mailbox)
  289. {
  290.   return unix_rename (stream,mailbox,NIL);
  291. }
  293. /* UNIX mail rename mailbox
  294.  * Accepts: MAIL stream
  295.  *     old mailbox name
  296.  *     new mailbox name (or NIL for delete)
  297.  * Returns: T on success, NIL on failure
  298.  */
  300. long unix_rename (MAILSTREAM *stream,char *old,char *newname)
  301. {
  302.   long ret = NIL;
  303.   char c,*s = NIL;
  304.   char tmp[MAILTMPLEN],file[MAILTMPLEN],lock[MAILTMPLEN];
  305.   DOTLOCK lockx;
  306.   int fd,ld;
  307.   long i;
  308.   struct stat sbuf;
  309.   mm_critical (stream); /* get the c-client lock */
  310.   if (newname && !((s = dummy_file (tmp,newname)) && *s))
  311.     sprintf (tmp,"Can't rename mailbox %.80s to %.80s: invalid name",
  312.      old,newname);
  313. /* lock out other c-clients */
  314.   else if ((ld = lockname (lock,dummy_file (file,old),LOCK_EX|LOCK_NB,&i)) < 0)
  315.     sprintf (tmp,"Mailbox %.80s is in use by another process",old);
  316.   else {
  317.     if ((fd = unix_lock (file,O_RDWR,S_IREAD|S_IWRITE,&lockx,LOCK_EX)) < 0)
  318.       sprintf (tmp,"Can't lock mailbox %.80s: %s",old,strerror (errno));
  319.     else {
  320.       if (newname) { /* want rename? */
  321. /* found superior to destination name? */
  322. if (s = strrchr (s,'/')) {
  323.   c = *++s; /* remember first character of inferior */
  324.   *s = ''; /* tie off to get just superior */
  325. /* name doesn't exist, create it */
  326.   if ((stat (tmp,&sbuf) || ((sbuf.st_mode & S_IFMT) != S_IFDIR)) &&
  327.       !dummy_create (stream,tmp)) {
  328.     unix_unlock (fd,NIL,&lockx);
  329.     unix_unlock (ld,NIL,NIL);
  330.     unlink (lock);
  331.     mm_nocritical (stream);
  332.     return ret; /* return success or failure */
  333.   }
  334.   *s = c; /* restore full name */
  335. }
  336. if (rename (file,tmp))
  337.   sprintf (tmp,"Can't rename mailbox %.80s to %.80s: %s",old,newname,
  338.    strerror (errno));
  339. else ret = T; /* set success */
  340.       }
  341.       else if (unlink (file))
  342. sprintf (tmp,"Can't delete mailbox %.80s: %s",old,strerror (errno));
  343.       else ret = T; /* set success */
  344.       unix_unlock (fd,NIL,&lockx);
  345.     }
  346.     unix_unlock (ld,NIL,NIL); /* flush the lock */
  347.     unlink (lock);
  348.   }
  349.   mm_nocritical (stream); /* no longer critical */
  350.   if (!ret) mm_log (tmp,ERROR); /* log error */
  351.   return ret; /* return success or failure */
  352. }
  354. /* UNIX mail open
  355.  * Accepts: Stream to open
  356.  * Returns: Stream on success, NIL on failure
  357.  */
  359. MAILSTREAM *unix_open (MAILSTREAM *stream)
  360. {
  361.   long i;
  362.   int fd;
  363.   char tmp[MAILTMPLEN];
  364.   DOTLOCK lock;
  365.   long retry;
  366. /* return prototype for OP_PROTOTYPE call */
  367.   if (!stream) return user_flags (&unixproto);
  368.   retry = stream->silent ? 1 : KODRETRY;
  369.   if (stream->local) fatal ("unix recycle stream");
  370.   stream->local = memset (fs_get (sizeof (UNIXLOCAL)),0,sizeof (UNIXLOCAL));
  371. /* note if an INBOX or not */
  372.   stream->inbox = !strcmp (ucase (strcpy (tmp,stream->mailbox)),"INBOX");
  373. /* canonicalize the stream mailbox name */
  374.   dummy_file (tmp,stream->mailbox);
  375. /* flush old name */
  376.   fs_give ((void **) &stream->mailbox);
  377. /* save canonical name */
  378.   stream->mailbox = cpystr (tmp);
  379.   LOCAL->fd = LOCAL->ld = -1; /* no file or state locking yet */
  380.   LOCAL->buf = (char *) fs_get ((LOCAL->buflen = CHUNK) + 1);
  381.   stream->sequence++; /* bump sequence number */
  383. /* make lock for read/write access */
  384.   if (!stream->rdonly) while (retry) {
  385. /* try to lock file */
  386.     if ((fd = lockname (tmp,stream->mailbox,LOCK_EX|LOCK_NB,&i)) < 0) {
  387.       if (retry-- == KODRETRY) {/* no, first time through? */
  388. if (i) { /* learned the other guy's PID? */
  389.   kill ((int) i,SIGUSR2);
  390.   sprintf (tmp,"Trying to get mailbox lock from process %ld",i);
  391.   mm_log (tmp,WARN);
  392. }
  393. else retry = 0; /* give up */
  394.       }
  395.       if (!stream->silent) { /* nothing if silent stream */
  396. if (retry) sleep (1); /* wait a second before trying again */
  397. else mm_log ("Mailbox is open by another process, access is readonly",
  398.      WARN);
  399.       }
  400.     }
  401.     else { /* got the lock, nobody else can alter state */
  402.       LOCAL->ld = fd; /* note lock's fd and name */
  403.       LOCAL->lname = cpystr (tmp);
  404. /* make sure mode OK (don't use fchmod()) */
  405.       chmod (LOCAL->lname,(int) mail_parameters (NIL,GET_LOCKPROTECTION,NIL));
  406.       if (stream->silent) i = 0;/* silent streams won't accept KOD */
  407.       else { /* note our PID in the lock */
  408. sprintf (tmp,"%d",getpid ());
  409. write (fd,tmp,(i = strlen (tmp))+1);
  410.       }
  411.       ftruncate (fd,i); /* make sure tied off */
  412.       fsync (fd); /* make sure it's available */
  413.       retry = 0; /* no more need to try */
  414.     }
  415.   }
  417. /* parse mailbox */
  418.   stream->nmsgs = stream->recent = 0;
  419. /* will we be able to get write access? */
  420.   if ((LOCAL->ld >= 0) && access (stream->mailbox,W_OK) && (errno == EACCES)) {
  421.     mm_log ("Can't get write access to mailbox, access is readonly",WARN);
  422.     flock (LOCAL->ld,LOCK_UN); /* release the lock */
  423.     close (LOCAL->ld); /* close the lock file */
  424.     LOCAL->ld = -1; /* no more lock fd */
  425.     unlink (LOCAL->lname); /* delete it */
  426.   }
  427. /* reset UID validity */
  428.   stream->uid_validity = stream->uid_last = 0;
  429.   if (stream->silent && !stream->rdonly && (LOCAL->ld < 0))
  430.     unix_abort (stream); /* abort if can't get RW silent stream */
  431. /* parse mailbox */
  432.   else if (unix_parse (stream,&lock,LOCK_SH)) {
  433.     unix_unlock (LOCAL->fd,stream,&lock);
  434.     mail_unlock (stream);
  435.     mm_nocritical (stream); /* done with critical */
  436.   }
  437.   if (!LOCAL) return NIL; /* failure if stream died */
  438. /* make sure upper level knows readonly */
  439.   stream->rdonly = (LOCAL->ld < 0);
  440. /* notify about empty mailbox */
  441.   if (!(stream->nmsgs || stream->silent)) mm_log ("Mailbox is empty",NIL);
  442.   if (!stream->rdonly) { /* flags stick if readwrite */
  443.     stream->perm_seen = stream->perm_deleted =
  444.       stream->perm_flagged = stream->perm_answered = stream->perm_draft = T;
  445.     if (!stream->uid_nosticky) {/* users with lives get permanent keywords */
  446.       stream->perm_user_flags = 0xffffffff;
  447. /* and maybe can create them too! */
  448.       stream->kwd_create = stream->user_flags[NUSERFLAGS-1] ? NIL : T;
  449.     }
  450.   }
  451.   return stream; /* return stream alive to caller */
  452. }
  455. /* UNIX mail close
  456.  * Accepts: MAIL stream
  457.  *     close options
  458.  */
  460. void unix_close (MAILSTREAM *stream,long options)
  461. {
  462.   int silent = stream->silent;
  463.   stream->silent = T; /* go silent */
  464. /* expunge if requested */
  465.   if (options & CL_EXPUNGE) unix_expunge (stream);
  466. /* else dump final checkpoint */
  467.   else if (LOCAL->dirty) unix_check (stream);
  468.   stream->silent = silent; /* restore old silence state */
  469.   unix_abort (stream); /* now punt the file and local data */
  470. }
  472. /* UNIX mail fetch message header
  473.  * Accepts: MAIL stream
  474.  *     message # to fetch
  475.  *     pointer to returned header text length
  476.  *     option flags
  477.  * Returns: message header in RFC822 format
  478.  */
  480. /* lines to filter from header */
  481. static STRINGLIST *unix_hlines = NIL;
  483. char *unix_header (MAILSTREAM *stream,unsigned long msgno,
  484.    unsigned long *length,long flags)
  485. {
  486.   MESSAGECACHE *elt;
  487.   char *s;
  488.   *length = 0; /* default to empty */
  489.   if (flags & FT_UID) return "";/* UID call "impossible" */
  490.   elt = mail_elt (stream,msgno);/* get cache */
  491.   if (!unix_hlines) { /* once only code */
  492.     STRINGLIST *lines = unix_hlines = mail_newstringlist ();
  493.     lines->text.size = strlen ((char *) (lines->text.data =
  494.  (unsigned char *) "Status"));
  495.     lines = lines->next = mail_newstringlist ();
  496.     lines->text.size = strlen ((char *) (lines->text.data =
  497.  (unsigned char *) "X-Status"));
  498.     lines = lines->next = mail_newstringlist ();
  499.     lines->text.size = strlen ((char *) (lines->text.data =
  500.  (unsigned char *) "X-Keywords"));
  501.     lines = lines->next = mail_newstringlist ();
  502.     lines->text.size = strlen ((char *) (lines->text.data =
  503.  (unsigned char *) "X-UID"));
  504.   }
  505. /* go to header position */
  506.   lseek (LOCAL->fd,elt->private.special.offset +
  507.  elt->private.msg.header.offset,L_SET);
  509.   if (flags & FT_INTERNAL) { /* initial data OK? */
  510.     if (elt->private.msg.header.text.size > LOCAL->buflen) {
  511.       fs_give ((void **) &LOCAL->buf);
  512.       LOCAL->buf = (char *) fs_get ((LOCAL->buflen =
  513.      elt->private.msg.header.text.size) + 1);
  514.     }
  515. /* read message */
  516.     read (LOCAL->fd,LOCAL->buf,elt->private.msg.header.text.size);
  517. /* got text, tie off string */
  518.     LOCAL->buf[*length = elt->private.msg.header.text.size] = '';
  519. /* squeeze out CRs (in case from PC) */
  520.     if (s = strchr (LOCAL->buf,'r')) {
  521.       char *t,*tl;
  522.       for (t = s,tl = LOCAL->buf + *length; t <= tl; t++)
  523. if ((*t != 'r') || (t[1] != 'n')) *s++ = *t;
  524. /* adjust length */
  525.       LOCAL->buf[*length = s - LOCAL->buf - 1] = '';
  526.     }
  527.   }
  528.   else { /* need to make a CRLF version */
  529.     read (LOCAL->fd,s = (char *) fs_get (elt->private.msg.header.text.size+1),
  530.   elt->private.msg.header.text.size);
  531. /* tie off string, and convert to CRLF */
  532.     s[elt->private.msg.header.text.size] = '';
  533.     *length = strcrlfcpy (&LOCAL->buf,&LOCAL->buflen,s,
  534.   elt->private.msg.header.text.size);
  535.     fs_give ((void **) &s); /* free readin buffer */
  536.   }
  537.   *length = mail_filter (LOCAL->buf,*length,unix_hlines,FT_NOT);
  538.   return LOCAL->buf; /* return processed copy */
  539. }
  541. /* UNIX mail fetch message text
  542.  * Accepts: MAIL stream
  543.  *     message # to fetch
  544.  *     pointer to returned stringstruct
  545.  *     option flags
  546.  * Returns: T on success, NIL if failure
  547.  */
  549. long unix_text (MAILSTREAM *stream,unsigned long msgno,STRING *bs,long flags)
  550. {
  551.   char *s;
  552.   unsigned long i;
  553.   MESSAGECACHE *elt;
  554. /* UID call "impossible" */
  555.   if (flags & FT_UID) return NIL;
  556.   elt = mail_elt (stream,msgno);/* get cache element */
  557. /* if message not seen */
  558.   if (!(flags & FT_PEEK) && !elt->seen) {
  559. /* mark message seen and dirty */
  560.     elt->seen = elt->private.dirty = LOCAL->dirty = T;
  561.     mm_flags (stream,msgno);
  562.   }
  563.   s = unix_text_work (stream,elt,&i,flags);
  564.   INIT (bs,mail_string,s,i); /* set up stringstruct */
  565.   return T; /* success */
  566. }
  568. /* UNIX mail fetch message text worker routine
  569.  * Accepts: MAIL stream
  570.  *     message cache element
  571.  *     pointer to returned header text length
  572.  *     option flags
  573.  */
  575. char *unix_text_work (MAILSTREAM *stream,MESSAGECACHE *elt,
  576.       unsigned long *length,long flags)
  577. {
  578.   FDDATA d;
  579.   STRING bs;
  580.   char *s,tmp[CHUNK];
  581. /* go to text position */
  582.   lseek (LOCAL->fd,elt->private.special.offset +
  583.  elt->private.msg.text.offset,L_SET);
  584.   if (flags & FT_INTERNAL) { /* initial data OK? */
  585.     if (elt->private.msg.text.text.size > LOCAL->buflen) {
  586.       fs_give ((void **) &LOCAL->buf);
  587.       LOCAL->buf = (char *) fs_get ((LOCAL->buflen =
  588.      elt->private.msg.text.text.size) + 1);
  589.     }
  590. /* read message */
  591.     read (LOCAL->fd,LOCAL->buf,elt->private.msg.text.text.size);
  592. /* got text, tie off string */
  593.     LOCAL->buf[*length = elt->private.msg.text.text.size] = '';
  594. /* squeeze out CRs (in case from PC) */
  595.     if (s = strchr (LOCAL->buf,'r')) {
  596.       char *t,*tl;
  597.       for (t = s,tl = LOCAL->buf + *length; t <= tl; t++)
  598. if ((*t != 'r') || (t[1] != 'n')) *s++ = *t;
  599. /* adjust length */
  600.       *length = s - LOCAL->buf - 1;
  601.     }
  602.   }
  604.   else { /* need to make a CRLF version */
  605.     if (elt->rfc822_size > LOCAL->buflen) {
  606.       /* excessively conservative, but the right thing is too hard to do */
  607.       fs_give ((void **) &LOCAL->buf);
  608.       LOCAL->buf = (char *) fs_get ((LOCAL->buflen = elt->rfc822_size) + 1);
  609.     }
  610.     d.fd = LOCAL->fd; /* yes, set up file descriptor */
  611.     d.pos = elt->private.special.offset + elt->private.msg.text.offset;
  612.     d.chunk = tmp; /* initial buffer chunk */
  613.     d.chunksize = CHUNK; /* file chunk size */
  614.     INIT (&bs,fd_string,&d,elt->private.msg.text.text.size);
  615.     for (s = LOCAL->buf; SIZE (&bs);) switch (CHR (&bs)) {
  616.     case 'r': /* carriage return seen */
  617.       *s++ = SNX (&bs); /* copy it and any succeeding LF */
  618.       if (SIZE (&bs) && (CHR (&bs) == 'n')) *s++ = SNX (&bs);
  619.       break;
  620.     case 'n':
  621.       *s++ = 'r'; /* insert a CR */
  622.     default:
  623.       *s++ = SNX (&bs); /* copy characters */
  624.     }
  625.     *s = ''; /* tie off buffer */
  626.     *length = s - LOCAL->buf; /* calculate length */
  627.   }
  628.   return LOCAL->buf;
  629. }
  631. /* UNIX per-message modify flag
  632.  * Accepts: MAIL stream
  633.  *     message cache element
  634.  */
  636. void unix_flagmsg (MAILSTREAM *stream,MESSAGECACHE *elt)
  637. {
  638. /* only after finishing */
  639.   if (elt->valid) elt->private.dirty = LOCAL->dirty = T;
  640. }
  643. /* UNIX mail ping mailbox
  644.  * Accepts: MAIL stream
  645.  * Returns: T if stream alive, else NIL
  646.  */
  648. long unix_ping (MAILSTREAM *stream)
  649. {
  650.   DOTLOCK lock;
  651.   struct stat sbuf;
  652. /* big no-op if not readwrite */
  653.   if (LOCAL && (LOCAL->ld >= 0) && !stream->lock) {
  654.     if (stream->rdonly) { /* does he want to give up readwrite? */
  655. /* checkpoint if we changed something */
  656.       if (LOCAL->dirty) unix_check (stream);
  657.       flock (LOCAL->ld,LOCK_UN);/* release readwrite lock */
  658.       close (LOCAL->ld); /* close the readwrite lock file */
  659.       LOCAL->ld = -1; /* no more readwrite lock fd */
  660.       unlink (LOCAL->lname); /* delete the readwrite lock file */
  661.     }
  662.     else { /* get current mailbox size */
  663.       if (LOCAL->fd >= 0) fstat (LOCAL->fd,&sbuf);
  664.       else stat (stream->mailbox,&sbuf);
  665. /* parse if mailbox changed */
  666.       if ((sbuf.st_size != LOCAL->filesize) &&
  667.   unix_parse (stream,&lock,LOCK_SH)) {
  668. /* unlock mailbox */
  669. unix_unlock (LOCAL->fd,stream,&lock);
  670. mail_unlock (stream); /* and stream */
  671. mm_nocritical (stream); /* done with critical */
  672.       }
  673.     }
  674.   }
  675.   return LOCAL ? LONGT : NIL; /* return if still alive */
  676. }
  678. /* UNIX mail check mailbox
  679.  * Accepts: MAIL stream
  680.  */
  682. void unix_check (MAILSTREAM *stream)
  683. {
  684.   DOTLOCK lock;
  685. /* parse and lock mailbox */
  686.   if (LOCAL && (LOCAL->ld >= 0) && !stream->lock &&
  687.       unix_parse (stream,&lock,LOCK_EX)) {
  688. /* any unsaved changes? */
  689.     if (LOCAL->dirty && unix_rewrite (stream,NIL,&lock)) {
  690.       if (!stream->silent) mm_log ("Checkpoint completed",NIL);
  691.     }
  692. /* no checkpoint needed, just unlock */
  693.     else unix_unlock (LOCAL->fd,stream,&lock);
  694.     mail_unlock (stream); /* unlock the stream */
  695.     mm_nocritical (stream); /* done with critical */
  696.   }
  697. }
  700. /* UNIX mail expunge mailbox
  701.  * Accepts: MAIL stream
  702.  */
  704. void unix_expunge (MAILSTREAM *stream)
  705. {
  706.   unsigned long i;
  707.   DOTLOCK lock;
  708.   char *msg = NIL;
  709. /* parse and lock mailbox */
  710.   if (LOCAL && (LOCAL->ld >= 0) && !stream->lock &&
  711.       unix_parse (stream,&lock,LOCK_EX)) {
  712. /* count expunged messages if not dirty */
  713.     if (!LOCAL->dirty) for (i = 1; i <= stream->nmsgs; i++)
  714.       if (mail_elt (stream,i)->deleted) LOCAL->dirty = T;
  715.     if (!LOCAL->dirty) { /* not dirty and no expunged messages */
  716.       unix_unlock (LOCAL->fd,stream,&lock);
  717.       msg = "No messages deleted, so no update needed";
  718.     }
  719.     else if (unix_rewrite (stream,&i,&lock)) {
  720.       if (i) sprintf (msg = LOCAL->buf,"Expunged %lu messages",i);
  721.       else msg = "Mailbox checkpointed, but no messages expunged";
  722.     }
  723. /* rewrite failed */
  724.     else unix_unlock (LOCAL->fd,stream,&lock);
  725.     mail_unlock (stream); /* unlock the stream */
  726.     mm_nocritical (stream); /* done with critical */
  727.     if (msg && !stream->silent) mm_log (msg,NIL);
  728.   }
  729.   else if (!stream->silent) mm_log("Expunge ignored on readonly mailbox",WARN);
  730. }
  732. /* UNIX mail copy message(s)
  733.  * Accepts: MAIL stream
  734.  *     sequence
  735.  *     destination mailbox
  736.  *     copy options
  737.  * Returns: T if copy successful, else NIL
  738.  */
  740. long unix_copy (MAILSTREAM *stream,char *sequence,char *mailbox,long options)
  741. {
  742.   struct stat sbuf;
  743.   int fd;
  744.   char *s,file[MAILTMPLEN];
  745.   DOTLOCK lock;
  746.   time_t tp[2];
  747.   unsigned long i,j;
  748.   MESSAGECACHE *elt;
  749.   long ret = T;
  750.   mailproxycopy_t pc =
  751.     (mailproxycopy_t) mail_parameters (stream,GET_MAILPROXYCOPY,NIL);
  752.   if (!((options & CP_UID) ? mail_uid_sequence (stream,sequence) :
  753. mail_sequence (stream,sequence))) return NIL;
  754. /* make sure valid mailbox */
  755.   if (!unix_valid (mailbox)) switch (errno) {
  756.   case ENOENT: /* no such file? */
  757.     mm_notify (stream,"[TRYCREATE] Must create mailbox before copy",NIL);
  758.     return NIL;
  759.   case 0: /* merely empty file? */
  760.     break;
  761.   case EINVAL:
  762.     if (pc) return (*pc) (stream,sequence,mailbox,options);
  763.     sprintf (LOCAL->buf,"Invalid UNIX-format mailbox name: %.80s",mailbox);
  764.     mm_log (LOCAL->buf,ERROR);
  765.     return NIL;
  766.   default:
  767.     if (pc) return (*pc) (stream,sequence,mailbox,options);
  768.     sprintf (LOCAL->buf,"Not a UNIX-format mailbox: %.80s",mailbox);
  769.     mm_log (LOCAL->buf,ERROR);
  770.     return NIL;
  771.   }
  772.   LOCAL->buf[0] = '';
  773.   mm_critical (stream); /* go critical */
  774.   if ((fd = unix_lock (dummy_file (file,mailbox),O_WRONLY|O_APPEND|O_CREAT,
  775.        S_IREAD|S_IWRITE,&lock,LOCK_EX)) < 0) {
  776.     mm_nocritical (stream); /* done with critical */
  777.     sprintf (LOCAL->buf,"Can't open destination mailbox: %s",strerror (errno));
  778.     mm_log (LOCAL->buf,ERROR); /* log the error */
  779.     return NIL; /* failed */
  780.   }
  781.   fstat (fd,&sbuf); /* get current file size */
  783. /* write all requested messages to mailbox */
  784.   for (i = 1; ret && (i <= stream->nmsgs); i++)
  785.     if ((elt = mail_elt (stream,i))->sequence) {
  786.       lseek (LOCAL->fd,elt->private.special.offset,L_SET);
  787.       read (LOCAL->fd,LOCAL->buf,elt->private.special.text.size);
  788.       if (write (fd,LOCAL->buf,elt->private.special.text.size) < 0) ret = NIL;
  789.       else { /* internal header succeeded */
  790. s = unix_header (stream,i,&j,FT_INTERNAL);
  791. /* header size, sans trailing newline */
  792. if (j && (s[j - 2] == 'n')) j--;
  793. if (write (fd,s,j) < 0) ret = NIL;
  794. else { /* message header succeeded */
  795.   j = unix_xstatus (stream,LOCAL->buf,elt,NIL);
  796.   if (write (fd,LOCAL->buf,j) < 0) ret = NIL;
  797.   else { /* message status succeeded */
  798.     s = unix_text_work (stream,elt,&j,FT_INTERNAL);
  799.     if ((write (fd,s,j) < 0) || (write (fd,"n",1) < 0)) ret = NIL;
  800.   }
  801. }
  802.       }
  803.     }
  804.   if (!ret || fsync (fd)) { /* force out the update */
  805.     sprintf (LOCAL->buf,"Message copy failed: %s",strerror (errno));
  806.     ftruncate (fd,sbuf.st_size);
  807.     ret = NIL;
  808.   }
  809.   tp[0] = sbuf.st_atime; /* preserve atime */
  810.   tp[1] = time (0); /* set mtime to now */
  811.   utime (file,tp); /* set the times */
  812.   unix_unlock (fd,NIL,&lock); /* unlock and close mailbox */
  813.   mm_nocritical (stream); /* release critical */
  814. /* log the error */
  815.   if (!ret) mm_log (LOCAL->buf,ERROR);
  816. /* delete if requested message */
  817.   else if (options & CP_MOVE) for (i = 1; i <= stream->nmsgs; i++)
  818.     if ((elt = mail_elt (stream,i))->sequence)
  819.       elt->deleted = elt->private.dirty = LOCAL->dirty = T;
  820.   return ret;
  821. }
  823. /* UNIX mail append message from stringstruct
  824.  * Accepts: MAIL stream
  825.  *     destination mailbox
  826.  *     initial flags
  827.  *     internal date
  828.  *     stringstruct of messages to append
  829.  * Returns: T if append successful, else NIL
  830.  */
  832. #define BUFLEN 8*MAILTMPLEN
  834. long unix_append (MAILSTREAM *stream,char *mailbox,char *flags,char *date,
  835.   STRING *message)
  836. {
  837.   MESSAGECACHE elt;
  838.   struct stat sbuf;
  839.   int fd,ti,zn;
  840.   long f,i,ok;
  841.   unsigned long j,n,uf,size;
  842.   char c,*x,buf[BUFLEN],tmp[MAILTMPLEN],file[MAILTMPLEN];
  843.   DOTLOCK lock;
  844.   time_t tp[2];
  845. /* default stream to prototype */
  846.   if (!stream) stream = user_flags (&unixproto);
  847. /* get flags */
  848.   f = mail_parse_flags (stream,flags,&uf);
  849. /* parse date */
  850.   if (!date) rfc822_date (date = tmp);
  851.   if (!mail_parse_date (&elt,date)) {
  852.     sprintf (buf,"Bad date in append: %.80s",date);
  853.     mm_log (buf,ERROR);
  854.     return NIL;
  855.   }
  856. /* make sure valid mailbox */
  857.   if (!unix_valid (mailbox)) switch (errno) {
  858.   case ENOENT: /* no such file? */
  859.     if (((mailbox[0] == 'I') || (mailbox[0] == 'i')) &&
  860. ((mailbox[1] == 'N') || (mailbox[1] == 'n')) &&
  861. ((mailbox[2] == 'B') || (mailbox[2] == 'b')) &&
  862. ((mailbox[3] == 'O') || (mailbox[3] == 'o')) &&
  863. ((mailbox[4] == 'X') || (mailbox[4] == 'x')) && !mailbox[5])
  864.       unix_create (NIL,"INBOX");
  865.     else {
  866.       mm_notify (stream,"[TRYCREATE] Must create mailbox before append",NIL);
  867.       return NIL;
  868.     }
  869. /* falls through */
  870.   case 0: /* INBOX ENOENT or empty file? */
  871.     break;
  872.   case EINVAL:
  873.     sprintf (buf,"Invalid UNIX-format mailbox name: %.80s",mailbox);
  874.     mm_log (buf,ERROR);
  875.     return NIL;
  876.   default:
  877.     sprintf (buf,"Not a UNIX-format mailbox: %.80s",mailbox);
  878.     mm_log (buf,ERROR);
  879.     return NIL;
  880.   }
  882.   mm_critical (stream); /* go critical */
  883.   if ((fd = unix_lock (dummy_file (file,mailbox),O_WRONLY|O_APPEND|O_CREAT,
  884.        S_IREAD|S_IWRITE,&lock,LOCK_EX)) < 0) {
  885.     mm_nocritical (stream); /* done with critical */
  886.     sprintf (buf,"Can't open append mailbox: %s",strerror (errno));
  887.     mm_log (buf,ERROR);
  888.     return NIL;
  889.   }
  890.   fstat (fd,&sbuf); /* get current file size */
  891.   sprintf (buf,"From %s@%s ",myusername (),mylocalhost ());
  892. /* user wants to suppress time zones? */
  893.   if (mail_parameters (NIL,GET_NOTIMEZONES,NIL)) {
  894.     time_t when = mail_longdate (&elt);
  895.     strcat (buf,ctime (&when));
  896.   }
  897. /* write the date given */
  898.   else mail_cdate (buf + strlen (buf),&elt);
  899.   sprintf (buf + strlen (buf),"Status: %snX-Status: %s%s%s%snX-Keywords:",
  900.    f&fSEEN ? "R" : "",f&fDELETED ? "D" : "",f&fFLAGGED ? "F" : "",
  901.    f&fANSWERED ? "A" : "",f&fDRAFT ? "T" : "");
  902.   while (uf) /* write user flags */
  903.     sprintf(buf+strlen(buf)," %s",stream->user_flags[find_rightmost_bit(&uf)]);
  904.   strcat (buf,"n"); /* tie off flags */
  905. /* copy text, tossing out CRs */
  906.   for (i = strlen (buf), ok = T, size = SIZE (message); ok && size; ) {
  907.     for (j = 0, c = ''; size && (c != 'n') && (j < MAILTMPLEN); size--)
  908.       if (((c = SNX (message)) != 'r') || !(SIZE (message)) ||
  909.   (CHR (message) != 'n')) tmp[j++] = c;
  910. /* possible "From " line? */
  911.     if ((j > 4) && (tmp[0] == 'F') && (tmp[1] == 'r') && (tmp[2] == 'o') &&
  912. (tmp[3] == 'm') && (tmp[4] == ' ')) {
  913. /* see if need to write a widget */
  914.       if (!(ti = unix_fromwidget || (c != 'n'))) VALID (tmp,x,ti,zn);
  915.       if (ti) ok = unix_append_putc (fd,buf,&i,'>');
  916.     }
  917. /* write the line */
  918.     for (n = 0; ok && (n < j); n++) ok = unix_append_putc (fd,buf,&i,tmp[n]);
  919. /* handle pathologically long line */
  920.     if (ok && (c != 'n') && size) do {
  921.       if (((c = SNX (message)) != 'r') || !(SIZE (message)) ||
  922.   (CHR (message) != 'n')) ok = unix_append_putc (fd,buf,&i,c);
  923.     } while (ok && --size && (c != 'n'));
  924.   }
  925. /* write trailing newline */
  926.   if (!(ok && (ok = unix_append_putc (fd,buf,&i,'n') &&
  927.        (i ? (write (fd,buf,i) >= 0) : T) && !fsync (fd)))) {
  928.     sprintf (buf,"Message append failed: %s",strerror (errno));
  929.     mm_log (buf,ERROR);
  930.     ftruncate (fd,sbuf.st_size);
  931.   }
  932.   tp[0] = sbuf.st_atime; /* preserve atime */
  933.   tp[1] = time (0); /* set mtime to now */
  934.   utime (file,tp); /* set the times */
  935.   unix_unlock (fd,NIL,&lock); /* unlock and close mailbox */
  936.   mm_nocritical (stream); /* release critical */
  937.   return ok; /* return success */
  938. }
  940. /* UNIX mail append character
  941.  * Accepts: file descriptor
  942.  *     output buffer
  943.  *     pointer to current size of output buffer
  944.  *     character to append
  945.  * Returns: T if append successful, else NIL
  946.  */
  948. long unix_append_putc (int fd,char *s,long *i,char c)
  949. {
  950.   s[(*i)++] = c;
  951.   if (*i == BUFLEN) { /* dump if buffer filled */
  952.     if (write (fd,s,*i) < 0) return NIL;
  953.     *i = 0; /* reset */
  954.   }
  955.   return T;
  956. }
  958. /* Internal routines */
  961. /* UNIX mail abort stream
  962.  * Accepts: MAIL stream
  963.  */
  965. void unix_abort (MAILSTREAM *stream)
  966. {
  967.   if (LOCAL) { /* only if a file is open */
  968.     if (LOCAL->fd >= 0) close (LOCAL->fd);
  969.     if (LOCAL->ld >= 0) { /* have a mailbox lock? */
  970.       flock (LOCAL->ld,LOCK_UN);/* yes, release the lock */
  971.       close (LOCAL->ld); /* close the lock file */
  972.       unlink (LOCAL->lname); /* and delete it */
  973.     }
  974.     if (LOCAL->lname) fs_give ((void **) &LOCAL->lname);
  975. /* free local text buffers */
  976.     if (LOCAL->buf) fs_give ((void **) &LOCAL->buf);
  977.     if (LOCAL->line) fs_give ((void **) &LOCAL->line);
  978. /* nuke the local data */
  979.     fs_give ((void **) &stream->local);
  980.     stream->dtb = NIL; /* log out the DTB */
  981.   }
  982. }
  984. /* UNIX open and lock mailbox
  985.  * Accepts: file name to open/lock
  986.  *     file open mode
  987.  *     destination buffer for lock file name
  988.  *     type of locking operation (LOCK_SH or LOCK_EX)
  989.  */
  991. int unix_lock (char *file,int flags,int mode,DOTLOCK *lock,int op)
  992. {
  993.   int fd;
  994.   blocknotify_t bn = (blocknotify_t) mail_parameters (NIL,GET_BLOCKNOTIFY,NIL);
  995.   (*bn) (BLOCK_FILELOCK,NIL);
  996. /* open file */
  997.   if ((fd = open (file,flags,mode)) >= 0) {
  998.     flock (fd,op); /* lock the file */
  999.     dotlock_lock (file,lock,fd);/* make a dot lock file */
  1000.   }
  1001.   (*bn) (BLOCK_NONE,NIL);
  1002.   return fd;
  1003. }
  1006. /* UNIX unlock and close mailbox
  1007.  * Accepts: file descriptor
  1008.  *     (optional) mailbox stream to check atime/mtime
  1009.  *     (optional) lock file name
  1010.  */
  1012. void unix_unlock (int fd,MAILSTREAM *stream,DOTLOCK *lock)
  1013. {
  1014.   struct stat sbuf;
  1015.   time_t tp[2];
  1016.   fstat (fd,&sbuf); /* get file times */
  1017. /* if stream and csh would think new mail */
  1018.   if (stream && (sbuf.st_atime <= sbuf.st_mtime)) {
  1019.     tp[0] = time (0); /* set atime to now */
  1020. /* set mtime to (now - 1) if necessary */
  1021.     tp[1] = tp[0] > sbuf.st_mtime ? sbuf.st_mtime : tp[0] - 1;
  1022. /* set the times, note change */
  1023.     if (!utime (stream->mailbox,tp)) LOCAL->filetime = tp[1];
  1024.   }
  1025.   flock (fd,LOCK_UN); /* release flock'ers */
  1026.   if (!stream) close (fd); /* close the file if no stream */
  1027.   dotlock_unlock (lock); /* flush the lock file if any */
  1028. }
  1030. /* UNIX mail parse and lock mailbox
  1031.  * Accepts: MAIL stream
  1032.  *     space to write lock file name
  1033.  *     type of locking operation
  1034.  * Returns: T if parse OK, critical & mailbox is locked shared; NIL if failure
  1035.  */
  1037. int unix_parse (MAILSTREAM *stream,DOTLOCK *lock,int op)
  1038. {
  1039.   int zn;
  1040.   unsigned long i,j,k,m;
  1041.   char c,*s,*t,*u,tmp[MAILTMPLEN],date[30];
  1042.   int ti = 0,pseudoseen = NIL;
  1043.   unsigned long nmsgs = stream->nmsgs;
  1044.   unsigned long prevuid = nmsgs ? mail_elt (stream,nmsgs)->private.uid : 0;
  1045.   unsigned long recent = stream->recent;
  1046.   unsigned long oldnmsgs = stream->nmsgs;
  1047.   short silent = stream->silent;
  1048.   struct stat sbuf;
  1049.   STRING bs;
  1050.   FDDATA d;
  1051.   MESSAGECACHE *elt;
  1052.   mail_lock (stream); /* guard against recursion or pingers */
  1053. /* toss out previous descriptor */
  1054.   if (LOCAL->fd >= 0) close (LOCAL->fd);
  1055.   mm_critical (stream); /* open and lock mailbox (shared OK) */
  1056.   if ((LOCAL->fd = unix_lock (stream->mailbox,(LOCAL->ld >= 0) ?
  1057.       O_RDWR : O_RDONLY,NIL,lock,op)) < 0) {
  1058.     sprintf (tmp,"Mailbox open failed, aborted: %s",strerror (errno));
  1059.     mm_log (tmp,ERROR);
  1060.     unix_abort (stream);
  1061.     mail_unlock (stream);
  1062.     mm_nocritical (stream); /* done with critical */
  1063.     return NIL;
  1064.   }
  1065.   fstat (LOCAL->fd,&sbuf); /* get status */
  1066. /* validate change in size */
  1067.   if (sbuf.st_size < LOCAL->filesize) {
  1068.     sprintf (tmp,"Mailbox shrank from %lu to %lu bytes, aborted",
  1069.      (unsigned long) LOCAL->filesize,(unsigned long) sbuf.st_size);
  1070.     mm_log (tmp,ERROR); /* this is pretty bad */
  1071.     unix_unlock (LOCAL->fd,stream,lock);
  1072.     unix_abort (stream);
  1073.     mail_unlock (stream);
  1074.     mm_nocritical (stream); /* done with critical */
  1075.     return NIL;
  1076.   }
  1078. /* new data? */
  1079.   else if (i = sbuf.st_size - LOCAL->filesize) {
  1080.     d.fd = LOCAL->fd; /* yes, set up file descriptor */
  1081.     d.pos = LOCAL->filesize; /* get to that position in the file */
  1082.     d.chunk = LOCAL->buf; /* initial buffer chunk */
  1083.     d.chunksize = CHUNK; /* file chunk size */
  1084.     INIT (&bs,fd_string,&d,i); /* initialize stringstruct */
  1085. /* skip leading whitespace for broken MTAs */
  1086.     while (((c = CHR (&bs)) == 'n') || (c == 'r') ||
  1087.    (c == ' ') || (c == 't')) SNX (&bs);
  1088.     if (SIZE (&bs)) { /* read new data */
  1089. /* remember internal header position */
  1090.       j = LOCAL->filesize + GETPOS (&bs);
  1091.       s = unix_mbxline (stream,&bs,&i);
  1092.       t = NIL,zn = 0;
  1093.       if (i) VALID (s,t,ti,zn); /* see if valid From line */
  1094.       if (!ti) { /* someone pulled the rug from under us */
  1095. sprintf(tmp,"Unexpected changes to mailbox (try restarting): %.20s",s);
  1096. mm_log (tmp,ERROR);
  1097. unix_unlock (LOCAL->fd,stream,lock);
  1098. unix_abort (stream);
  1099. mail_unlock (stream);
  1100. mm_nocritical (stream); /* done with critical */
  1101. return NIL;
  1102.       }
  1103.       stream->silent = T; /* quell main program new message events */
  1104.       do { /* found a message */
  1105. /* instantiate first new message */
  1106. mail_exists (stream,++nmsgs);
  1107. (elt = mail_elt (stream,nmsgs))->valid = T;
  1108. recent++; /* assume recent by default */
  1109. elt->recent = T;
  1110. /* note position/size of internal header */
  1111. elt->private.special.offset = j;
  1112. elt->private.msg.header.offset = elt->private.special.text.size = i;
  1114. /* generate plausible IMAPish date string */
  1115. date[2] = date[6] = date[20] = '-'; date[11] = ' ';
  1116. date[14] = date[17] = ':';
  1117. /* dd */
  1118. date[0] = t[ti - 2]; date[1] = t[ti - 1];
  1119. /* mmm */
  1120. date[3] = t[ti - 6]; date[4] = t[ti - 5]; date[5] = t[ti - 4];
  1121. /* hh */
  1122. date[12] = t[ti + 1]; date[13] = t[ti + 2];
  1123. /* mm */
  1124. date[15] = t[ti + 4]; date[16] = t[ti + 5];
  1125. if (t[ti += 6] == ':') {/* ss */
  1126.   date[18] = t[++ti]; date[19] = t[++ti];
  1127.   ti++; /* move to space */
  1128. }
  1129. else date[18] = date[19] = '0';
  1130. /* yy -- advance over timezone if necessary */
  1131. if (zn == ti) ti += (((t[zn+1] == '+') || (t[zn+1] == '-')) ? 6 : 4);
  1132. date[7] = t[ti + 1]; date[8] = t[ti + 2];
  1133. date[9] = t[ti + 3]; date[10] = t[ti + 4];
  1134. /* zzz */
  1135. t = zn ? (t + zn + 1) : "LCL";
  1136. date[21] = *t++; date[22] = *t++; date[23] = *t++;
  1137. if ((date[21] != '+') && (date[21] != '-')) date[24] = '';
  1138. else { /* numeric time zone */
  1139.   date[24] = *t++; date[25] = *t++;
  1140.   date[26] = ''; date[20] = ' ';
  1141. }
  1142. /* set internal date */
  1143. if (!mail_parse_date (elt,date)) {
  1144.   sprintf (tmp,"Unable to parse internal date: %s",date);
  1145.   mm_log (tmp,WARN);
  1146. }
  1148. do { /* look for message body */
  1149.   s = t = unix_mbxline (stream,&bs,&i);
  1150.   if (i) switch (*s) { /* check header lines */
  1151.   case 'X': /* possible X-???: line */
  1152.     if (s[1] == '-') { /* must be immediately followed by hyphen */
  1153. /* X-Status: becomes Status: in S case */
  1154.       if (s[2] == 'S' && s[3] == 't' && s[4] == 'a' && s[5] == 't' &&
  1155.   s[6] == 'u' && s[7] == 's' && s[8] == ':') s += 2;
  1156. /* possible X-Keywords */
  1157.       else if (s[2] == 'K' && s[3] == 'e' && s[4] == 'y' &&
  1158.        s[5] == 'w' && s[6] == 'o' && s[7] == 'r' &&
  1159.        s[8] == 'd' && s[9] == 's' && s[10] == ':') {
  1160. char uf[MAILTMPLEN];
  1161. s += 11; /* flush leading whitespace */
  1162. while (*s && (*s != 'n') && (*s != 'r')) {
  1163.   while (*s == ' ') s++;
  1164. /* find end of keyword */
  1165.   if (!(u = strpbrk (s," nr"))) u = s + strlen (s);
  1166. /* got a keyword? */
  1167.   if ((k = (u - s)) && (k < MAILTMPLEN)) {
  1168. /* copy keyword */
  1169.     strncpy (uf,s,k);
  1170.     uf[k] = ''; /* make sure tied off */
  1171.     ucase (uf); /* coerce upper case */
  1172.     for (j = 0; (j<NUSERFLAGS) && stream->user_flags[j]; ++j)
  1173.       if (!strcmp(uf,
  1174.   ucase (strcpy(tmp,stream->user_flags[j])))) {
  1175. elt->user_flags |= ((long) 1) << j;
  1176. break;
  1177.       }
  1178. /* need to create it? */
  1179.     if (!stream->rdonly && (j < NUSERFLAGS) &&
  1180. !stream->user_flags[j]) {
  1181. /* set the bit */
  1182.       *uf |= 1 << j;
  1183.       stream->user_flags[j] = (char *) fs_get (k + 1);
  1184.       strncpy (stream->user_flags[j],s,k);
  1185.       stream->user_flags[j][k] = '';
  1186. /* if now out of user flags */
  1187.       if (j == NUSERFLAGS - 1) stream->kwd_create = NIL;
  1188.     }
  1189.   }
  1190.   s = u; /* advance to next keyword */
  1191. }
  1192. break;
  1193.       }
  1195. /* possible X-IMAP */
  1196.       else if ((nmsgs == 1) && !stream->uid_validity &&
  1197.        (s[2] == 'I') && (s[3] == 'M') && (s[4] == 'A') &&
  1198.        (s[5] == 'P') && (s[6] == ':')) {
  1199. s += 7; /* advance to data */
  1200. /* flush whitespace */
  1201. while (*s == ' ') s++;
  1202. j = 0; /* slurp UID validity */
  1203. /* found a digit? */
  1204. while (isdigit (*s)) {
  1205.   j *= 10; /* yes, add it in */
  1206.   j += *s++ - '0';
  1207. }
  1208. if (!j) break; /* punt if invalid UID validity */
  1209. stream->uid_validity = j;
  1210. /* flush whitespace */
  1211. while (*s == ' ') s++;
  1212. /* must have UID last too */
  1213. if (isdigit (*s)) {
  1214.   j = 0; /* slurp UID last */
  1215.   while (isdigit (*s)) {
  1216.     j *= 10; /* yes, add it in */
  1217.     j += *s++ - '0';
  1218.   }
  1219.   stream->uid_last = j;
  1220. /* process keywords */
  1221.   for (j = 0; (*s != 'n') && (*s != 'r'); j++) {
  1222. /* flush leading whitespace */
  1223.     while (*s == ' ') s++;
  1224.     u = strpbrk (s," nr");
  1225. /* got a keyword? */
  1226.     if ((k = (u - s)) && j < NUSERFLAGS) {
  1227.       if (stream->user_flags[j])
  1228. fs_give ((void **) &stream->user_flags[j]);
  1229.       stream->user_flags[j] = (char *) fs_get (k + 1);
  1230.       strncpy (stream->user_flags[j],s,k);
  1231.       stream->user_flags[j][k] = '';
  1232.     }
  1233.     s = u; /* advance to next keyword */
  1234.   }
  1235. /* pseudo-header seen */
  1236.   pseudoseen = T;
  1237. }
  1238. break;
  1239.       }
  1241. /* possible X-UID */
  1242.       else if (s[2] == 'U' && s[3] == 'I' && s[4] == 'D' &&
  1243.        s[5] == ':') {
  1244. /* only believe if have a UID validity */
  1245. if (stream->uid_validity && (nmsgs > 1)) {
  1246.   s += 6; /* advance to UID value */
  1247. /* flush whitespace */
  1248.   while (*s == ' ') s++;
  1249.   j = 0;
  1250. /* found a digit? */
  1251.   while (isdigit (*s)) {
  1252.     j *= 10; /* yes, add it in */
  1253.     j += *s++ - '0';
  1254.   }
  1255. /* flush remainder of line */
  1256.   while (*s != 'n') s++;
  1257. /* make sure not duplicated */
  1258.   if (elt->private.uid)
  1259.     sprintf (tmp,"Message %lu UID %lu already has UID %lu",
  1260.      pseudoseen ? elt->msgno - 1 : elt->msgno,
  1261.      j,elt->private.uid);
  1262. /* make sure UID doesn't go backwards */
  1263.   else if (j <= prevuid)
  1264.     sprintf (tmp,"Message %lu UID %lu less than %lu",
  1265.      pseudoseen ? elt->msgno - 1 : elt->msgno,
  1266.      j,prevuid + 1);
  1267. /* or skip by mailbox's recorded last */
  1268.   else if (j > stream->uid_last)
  1269.     sprintf (tmp,"Message %lu UID %lu greater than last %lu",
  1270.      pseudoseen ? elt->msgno - 1 : elt->msgno,
  1271.      j,stream->uid_last);
  1272.   else { /* normal UID case */
  1273.     prevuid = elt->private.uid = j;
  1274.     break; /* exit this cruft */
  1275.   }
  1276.   mm_log (tmp,WARN);
  1277. /* invalidate UID validity */
  1278.   stream->uid_validity = 0;
  1279.   elt->private.uid = 0;
  1280. }
  1281. break;
  1282.       }
  1283.     }
  1284. /* otherwise fall into S case */
  1286.   case 'S': /* possible Status: line */
  1287.     if (s[0] == 'S' && s[1] == 't' && s[2] == 'a' && s[3] == 't' &&
  1288. s[4] == 'u' && s[5] == 's' && s[6] == ':') {
  1289.       s += 6; /* advance to status flags */
  1290.       do switch (*s++) {/* parse flags */
  1291.       case 'R': /* message read */
  1292. elt->seen = T;
  1293. break;
  1294.       case 'O': /* message old */
  1295. if (elt->recent) {
  1296.   elt->recent = NIL;
  1297.   recent--; /* it really wasn't recent */
  1298. }
  1299. break;
  1300.       case 'D': /* message deleted */
  1301. elt->deleted = T;
  1302. break;
  1303.       case 'F': /* message flagged */
  1304. elt->flagged = T;
  1305. break;
  1306.       case 'A': /* message answered */
  1307. elt->answered = T;
  1308. break;
  1309.       case 'T': /* message is a draft */
  1310. elt->draft = T;
  1311. break;
  1312.       default: /* some other crap */
  1313. break;
  1314.       } while (*s && (*s != 'n') && (*s != 'r'));
  1315.       break; /* all done */
  1316.     }
  1317. /* otherwise fall into default case */
  1318.   default: /* ordinary header line */
  1319. /* line length in LF format newline */
  1320.     k =  i - (((i >= 2) && (s[i - 2] == 'r')) ? 1 : 0);
  1321. /* "internal" header size */
  1322.     elt->private.data += k;
  1323. /* message size */
  1324.     elt->rfc822_size += k + 1;
  1325.     break;
  1326.   }
  1327. } while (i && (*t != 'n') && (*t != 'r'));
  1328. /* "internal" header sans trailing newline */
  1329. if (i) elt->private.data--;
  1330. /* assign a UID if none found */
  1331. if (((nmsgs > 1) || !pseudoseen) && !elt->private.uid) {
  1332.   prevuid = elt->private.uid = ++stream->uid_last;
  1333.   elt->private.dirty = T;
  1334. }
  1335. else elt->private.dirty = elt->recent;
  1337. /* note size of header, location of text */
  1338. elt->private.msg.header.text.size = 
  1339.   (elt->private.msg.text.offset =
  1340.    (LOCAL->filesize + GETPOS (&bs)) - elt->private.special.offset) -
  1341.      elt->private.special.text.size;
  1342. k = m = 0; /* no previous line size yet */
  1343. /* note current position */
  1344. j = LOCAL->filesize + GETPOS (&bs);
  1345. if (i) do { /* look for next message */
  1346.   s = unix_mbxline (stream,&bs,&i);
  1347.   if (i) { /* got new data? */
  1348.     VALID (s,t,ti,zn); /* yes, parse line */
  1349.     if (!ti) { /* not a header line, add it to message */
  1350.       elt->rfc822_size += 
  1351. k = i + (m = (((i < 2) || s[i - 2] != 'r') ? 1 : 0));
  1352. /* update current position */
  1353.       j = LOCAL->filesize + GETPOS (&bs);
  1354.     }
  1355.   }
  1356. } while (i && !ti); /* until found a header */
  1357. elt->private.msg.text.text.size = j -
  1358.   (elt->private.special.offset + elt->private.msg.text.offset);
  1359. if (k == 2) { /* last line was blank? */
  1360.   elt->private.msg.text.text.size -= (m ? 1 : 2);
  1361.   elt->rfc822_size -= 2;
  1362. }
  1363.       } while (i); /* until end of buffer */
  1364.       if (pseudoseen) { /* flush pseudo-message if present */
  1365. /* decrement recent count */
  1366. if (mail_elt (stream,1)->recent) recent--;
  1367. /* and the exists count */
  1368. mail_exists (stream,nmsgs--);
  1369. mail_expunged(stream,1);/* fake an expunge of that message */
  1370.       }
  1371. /* need to start a new UID validity? */
  1372.       if (!stream->uid_validity) {
  1373. stream->uid_validity = time (0);
  1374. /* in case a whiner with no life */
  1375. if (mail_parameters (NIL,GET_USERHASNOLIFE,NIL))
  1376.   stream->uid_nosticky = T;
  1377. else LOCAL->dirty = T; /* make dirty to create pseudo-message */
  1378.       }
  1379.       stream->nmsgs = oldnmsgs; /* whack it back down */
  1380.       stream->silent = silent; /* restore old silent setting */
  1381. /* notify upper level of new mailbox sizes */
  1382.       mail_exists (stream,nmsgs);
  1383.       mail_recent (stream,recent);
  1384. /* mark dirty so O flags are set */
  1385.       if (recent) LOCAL->dirty = T;
  1386.     }
  1387.   }
  1388. /* no change, don't babble if never got time */
  1389.   else if (LOCAL->filetime && LOCAL->filetime != sbuf.st_mtime)
  1390.     mm_log ("New mailbox modification time but apparently no changes",WARN);
  1391. /* update parsed file size and time */
  1392.   LOCAL->filesize = sbuf.st_size;
  1393.   LOCAL->filetime = sbuf.st_mtime;
  1394.   return T; /* return the winnage */
  1395. }
  1397. /* UNIX read line from mailbox
  1398.  * Accepts: mail stream
  1399.  *     stringstruct
  1400.  *     pointer to line size
  1401.  * Returns: pointer to input line
  1402.  */
  1404. char *unix_mbxline (MAILSTREAM *stream,STRING *bs,unsigned long *size)
  1405. {
  1406.   unsigned long i,j,k,m;
  1407.   char *s,*t,*te,p1[CHUNK];
  1408.   char *ret = "";
  1409. /* flush old buffer */
  1410.   if (LOCAL->line) fs_give ((void **) &LOCAL->line);
  1411. /* if buffer needs refreshing */
  1412.   if (!bs->cursize) SETPOS (bs,GETPOS (bs));
  1413.   if (SIZE (bs)) { /* find newline */
  1414. /* end of fast scan */
  1415.     te = (t = (s = bs->curpos) + bs->cursize) - 12;
  1416.     while (s < te) if ((*s++ == 'n') || (*s++ == 'n') || (*s++ == 'n') ||
  1417.        (*s++ == 'n') || (*s++ == 'n') || (*s++ == 'n') ||
  1418.        (*s++ == 'n') || (*s++ == 'n') || (*s++ == 'n') ||
  1419.        (*s++ == 'n') || (*s++ == 'n') || (*s++ == 'n')) {
  1420.       --s; /* back up */
  1421.       break; /* exit loop */
  1422.     }
  1423. /* final character-at-a-time scan */
  1424.     while ((s < t) && (*s != 'n')) ++s;
  1425. /* difficult case if line spans buffer */
  1426.     if ((i = s - bs->curpos) == bs->cursize) {
  1427.       memcpy (p1,bs->curpos,i); /* remember what we have so far */
  1428. /* load next buffer */
  1429.       SETPOS (bs,k = GETPOS (bs) + i);
  1430. /* end of fast scan */
  1431.       te = (t = (s = bs->curpos) + bs->cursize) - 12;
  1432. /* fast scan in overlap buffer */
  1433.       while (s < te) if ((*s++ == 'n') || (*s++ == 'n') || (*s++ == 'n') ||
  1434.  (*s++ == 'n') || (*s++ == 'n') || (*s++ == 'n') ||
  1435.  (*s++ == 'n') || (*s++ == 'n') || (*s++ == 'n') ||
  1436.  (*s++ == 'n') || (*s++ == 'n') || (*s++ == 'n')) {
  1437. --s; /* back up */
  1438. break; /* exit loop */
  1439.       }
  1440. /* final character-at-a-time scan */
  1441.       while ((s < t) && (*s != 'n')) ++s;
  1442. /* huge line? */
  1443.       if ((j = s - bs->curpos) == bs->cursize) {
  1444. SETPOS (bs,GETPOS (bs) + j);
  1445. /* look for end of line (s-l-o-w!!) */
  1446. for (m = SIZE (bs); m && (SNX (bs) != 'n'); --m,++j);
  1447. SETPOS (bs,k); /* go back to where it started */
  1448.       }
  1450. /* got size of data, make buffer for return */
  1451.       ret = LOCAL->line = (char *) fs_get (i + j + 2);
  1452.       memcpy (ret,p1,i); /* copy first chunk */
  1453.       while (j) { /* copy remainder */
  1454. if (!bs->cursize) SETPOS (bs,GETPOS (bs));
  1455. memcpy (ret + i,bs->curpos,k = min (j,bs->cursize));
  1456. i += k; /* account for this much read in */
  1457. j -= k;
  1458. bs->curpos += k; /* increment new position */
  1459. bs->cursize -= k; /* eat that many bytes */
  1460.       }
  1461.       if (SIZE (bs)) SNX (bs); /* skip over newline if one seen */
  1462.       ret[i++] = 'n'; /* make sure newline at end */
  1463.       ret[i] = ''; /* makes debugging easier */
  1464.     }
  1465.     else { /* this is easy */
  1466.       ret = bs->curpos; /* string it at this position */
  1467.       bs->curpos += ++i; /* increment new position */
  1468.       bs->cursize -= i; /* eat that many bytes */
  1469.     }
  1470.     *size = i; /* return that to user */
  1471.   }
  1472.   else *size = 0; /* end of data, return empty */
  1473.   return ret;
  1474. }
  1476. /* UNIX make pseudo-header
  1477.  * Accepts: MAIL stream
  1478.  *     buffer to write pseudo-header
  1479.  * Returns: length of pseudo-header
  1480.  */
  1482. unsigned long unix_pseudo (MAILSTREAM *stream,char *hdr)
  1483. {
  1484.   int i;
  1485.   char *s,tmp[MAILTMPLEN];
  1486.   time_t now = time (0);
  1487.   rfc822_fixed_date (tmp);
  1488.   sprintf (hdr,"From %s %.24snDate: %snFrom: %s <%s@%.80s>nSubject: %snMessage-ID: <%lu@%.80s>nX-IMAP: %010lu %010lu",
  1489.    pseudo_from,ctime (&now),
  1490.    tmp,pseudo_name,pseudo_from,mylocalhost (),pseudo_subject,
  1491.    (unsigned long) now,mylocalhost (),stream->uid_validity,
  1492.    stream->uid_last);
  1493.   for (s = hdr,i = 0; i < NUSERFLAGS; ++i) if (stream->user_flags[i])
  1494.     sprintf (s += strlen (s)," %s",stream->user_flags[i]);
  1495.   sprintf (s += strlen (s),"nStatus: ROnn%snn",pseudo_msg);
  1496.   return strlen (hdr); /* return header length */
  1497. }
  1499. /* UNIX make status string
  1500.  * Accepts: MAIL stream
  1501.  *     destination string to write
  1502.  *     message cache entry
  1503.  *     non-zero flag to write UID as well
  1504.  * Returns: length of string
  1505.  */
  1507. unsigned long unix_xstatus (MAILSTREAM *stream,char *status,MESSAGECACHE *elt,
  1508.     long flag)
  1509. {
  1510.   char *t;
  1511.   char *s = status;
  1512.   unsigned long n = elt->user_flags;
  1513.   /* This used to be an sprintf(), but thanks to certain cretinous C libraries
  1514.      with horribly slow implementations of sprintf() I had to change it to this
  1515.      mess.  At least it should be fast. */
  1516.   *s++ = 'S'; *s++ = 't'; *s++ = 'a'; *s++ = 't'; *s++ = 'u'; *s++ = 's';
  1517.   *s++ = ':'; *s++ = ' ';
  1518.   if (elt->seen) *s++ = 'R';
  1519.   *s++ = 'O'; *s++ = 'n';
  1520.   *s++ = 'X'; *s++ = '-'; *s++ = 'S'; *s++ = 't'; *s++ = 'a'; *s++ = 't';
  1521.   *s++ = 'u'; *s++ = 's'; *s++ = ':'; *s++ = ' ';
  1522.   if (elt->deleted) *s++ = 'D';
  1523.   if (elt->flagged) *s++ = 'F';
  1524.   if (elt->answered) *s++ = 'A';
  1525.   if (elt->draft) *s++ = 'T';
  1526.   *s++ = 'n';
  1527.   if (!stream->uid_nosticky) { /* cretins with no life can't use this */
  1528.     *s++ = 'X'; *s++ = '-'; *s++ = 'K'; *s++ = 'e'; *s++ = 'y'; *s++ = 'w';
  1529.     *s++ = 'o'; *s++ = 'r'; *s++ = 'd'; *s++ = 's'; *s++ = ':';
  1530.     if (n) do {
  1531.       *s++ = ' ';
  1532.       for (t = stream->user_flags[find_rightmost_bit (&n)]; *t; *s++ = *t++);
  1533.     } while (n);
  1534. /* pad X-Keywords to make size constant */
  1535.     else for (n = 50 - (s - status); n > 0; --n) *s++ = ' ';
  1536.     *s++ = 'n';
  1537.     if (flag) { /* want to include UID? */
  1538.       char stack[64];
  1539.       char *p = stack;
  1540.       n = elt->private.uid; /* push UID digits on the stack */
  1541.       do *p++ = (char) (n % 10) + '0';
  1542.       while (n /= 10);
  1543.       *s++ = 'X'; *s++ = '-'; *s++ = 'U'; *s++ = 'I'; *s++ = 'D'; *s++ = ':';
  1544.       *s++ = ' ';
  1545. /* pop UID from stack */
  1546.       while (p > stack) *s++ = *--p;
  1547.       *s++ = 'n';
  1548.     }
  1549.   }
  1550.   *s++ = 'n'; *s = ''; /* end of extended message status */
  1551.   return s - status; /* return size of resulting string */
  1552. }
  1554. /* Rewrite mailbox file
  1555.  * Accepts: MAIL stream, must be critical and locked
  1556.  *     return pointer to number of expunged messages if want expunge
  1557.  *     lock file name
  1558.  * Returns: T if success and mailbox unlocked, NIL if failure
  1559.  */
  1561. int unix_old_algorithm = NIL; /* non-zero to use old algorithm */
  1563. long unix_rewrite (MAILSTREAM *stream,unsigned long *nexp,DOTLOCK *lock)
  1564. {
  1565.   time_t tp[2];
  1566.   unsigned long size = 0;
  1567.   unsigned long recent = stream->recent;
  1568.   long ret;
  1569.   if (nexp) *nexp = 0; /* initially nothing expunged */
  1570.   if (ret = unix_old_algorithm ? /* rewrite using selected algorithm */
  1571.       unix_rewrite_old (stream,nexp,&size,&recent) :
  1572.       unix_rewrite_new (stream,nexp,&size,&recent)) {
  1573. /* make sure tied off */
  1574.     ftruncate (LOCAL->fd,LOCAL->filesize = size);
  1575.     fsync (LOCAL->fd); /* make sure the updates take */
  1576.     LOCAL->dirty = NIL; /* no longer dirty */
  1577.    /* notify upper level of new mailbox sizes */
  1578.     mail_exists (stream,stream->nmsgs);
  1579.     mail_recent (stream,recent);
  1580. /* set atime to now, mtime a second earlier */
  1581.     tp[1] = (tp[0] = time (0)) - 1;
  1582. /* set the times, note change */
  1583.     if (!utime (stream->mailbox,tp)) LOCAL->filetime = tp[1];
  1584.     close (LOCAL->fd); /* close and reopen file */
  1585.     if ((LOCAL->fd = open (stream->mailbox,O_RDWR,NIL)) < 0) {
  1586.       sprintf (LOCAL->buf,"Mailbox open failed, aborted: %s",strerror (errno));
  1587.       mm_log (LOCAL->buf,ERROR);
  1588.       unix_abort (stream);
  1589.     }
  1590.     dotlock_unlock (lock); /* flush the lock file */
  1591.   }
  1592.   return ret; /* return state from algorithm */
  1593. }
  1595. /* Extend UNIX mailbox file
  1596.  * Accepts: MAIL stream
  1597.  *     new desired size
  1598.  * Return: T if success, else NIL
  1599.  */
  1601. long unix_extend (MAILSTREAM *stream,unsigned long size)
  1602. {
  1603.   unsigned long i = (size > LOCAL->filesize) ? size - LOCAL->filesize : 0;
  1604.   if (i) { /* does the mailbox need to grow? */
  1605.     if (i > LOCAL->buflen) { /* make sure have enough space */
  1606. /* this user won the lottery all right */
  1607.       fs_give ((void **) &LOCAL->buf);
  1608.       LOCAL->buf = (char *) fs_get ((LOCAL->buflen = i) + 1);
  1609.     }
  1610.     memset (LOCAL->buf,'',i); /* get a block of nulls */
  1611.     while (T) { /* until write successful or punt */
  1612.       lseek (LOCAL->fd,LOCAL->filesize,L_SET);
  1613.       if ((write (LOCAL->fd,LOCAL->buf,i) >= 0) && !fsync (LOCAL->fd)) break;
  1614.       else {
  1615. long e = errno; /* note error before doing ftruncate */
  1616. ftruncate (LOCAL->fd,LOCAL->filesize);
  1617. if (mm_diskerror (stream,e,NIL)) {
  1618.   fsync (LOCAL->fd); /* user chose to punt */
  1619.   sprintf (LOCAL->buf,"Unable to extend mailbox: %s",strerror (e));
  1620.   mm_log (LOCAL->buf,ERROR);
  1621.   return NIL;
  1622. }
  1623.       }
  1624.     }
  1625.   }
  1626.   return LONGT;
  1627. }
  1629. /* Rewrite mailbox file (new, fast, dangerous algorithm)
  1630.  * Accepts: MAIL stream, must be critical and locked
  1631.  *     return pointer to number of expunged messages if want expunge
  1632.  *     return pointer to size of mailbox
  1633.  *     return pointer to number of recent messages
  1634.  * Returns: T if success, NIL if failure
  1635.  */
  1637. #define OVERFLOWBUFLEN 8192 /* initial overflow buffer length */
  1639. long unix_rewrite_new (MAILSTREAM *stream,unsigned long *nexp,
  1640.        unsigned long *size,unsigned long *recent)
  1641. {
  1642.   MESSAGECACHE *elt;
  1643.   UNIXFILE f;
  1644.   char *s;
  1645.   unsigned long i,j;
  1646. /* size of mailbox starts with pseudo */
  1647.   *size = stream->uid_nosticky ? 0 : unix_pseudo (stream,LOCAL->buf);
  1648. /* calculate size of mailbox after rewrite */
  1649.   for (i = 1; i <= stream->nmsgs; i++)
  1650.     if (!(elt = mail_elt (stream,i))->deleted || !nexp) {
  1651. /* add RFC822 size of this message */
  1652.       *size += elt->private.special.text.size + elt->private.data +
  1653. unix_xstatus (stream,LOCAL->buf,elt,T) +
  1654.   elt->private.msg.text.text.size + 1;
  1655.     }
  1656. /* extend the file as necessary */
  1657.   if (!unix_extend (stream,*size)) return NIL;
  1658.   /* Set up buffered I/O file structure
  1659.    * curpos current position being written through buffering
  1660.    * filepos current position being written physically to the disk
  1661.    * bufpos current position being written in the buffer
  1662.    * protect current maximum position that can be written to the disk
  1663.    * before buffering is forced
  1664.    * The code tries to buffer so that that disk is written in multiples of
  1665.    * OVERBLOWBUFLEN bytes.
  1666.    */
  1667.   f.stream = stream; /* note mail stream */
  1668.   f.curpos = f.filepos = 0; /* start of file */
  1669.   f.protect = stream->nmsgs ? /* initial protection pointer */
  1670.     mail_elt (stream,1)->private.special.offset : 8192;
  1671.   f.bufpos = f.buf = (char *) fs_get (f.buflen = OVERFLOWBUFLEN);
  1672.   if (!stream->uid_nosticky) /* write pseudo-header */
  1673.     unix_write (&f,LOCAL->buf,unix_pseudo (stream,LOCAL->buf));
  1675. /* loop through all messages */
  1676.   for (i = 1; i <= stream->nmsgs;) {
  1677.     elt = mail_elt (stream,i); /* get cache */
  1678.     if (nexp && elt->deleted) { /* expunge this message? */
  1679.       if (elt->recent)--*recent;/* one less recent message */
  1680.       mail_expunged (stream,i); /* notify upper levels */
  1681.       ++*nexp; /* count up one more expunged message */
  1682.     }
  1683.     else { /* preserve this message */
  1684.       i++; /* advance to next message */
  1685. /* need to rewrite message? */
  1686.       if (elt->private.dirty || (f.curpos != elt->private.special.offset) ||
  1687.   (elt->private.msg.header.text.size !=
  1688.    (elt->private.data + unix_xstatus (stream,LOCAL->buf,elt,T)))) {
  1689. unsigned long newoffset = f.curpos;
  1690. /* yes, seek to internal header */
  1691. lseek (LOCAL->fd,elt->private.special.offset,L_SET);
  1692. read (LOCAL->fd,LOCAL->buf,elt->private.special.text.size);
  1693. /* see if need to squeeze out a CR */
  1694. if (LOCAL->buf[elt->private.special.text.size - 2] == 'r') {
  1695.   LOCAL->buf[--elt->private.special.text.size - 1] = 'n';
  1696.   --*size; /* squeezed out a CR from PC */
  1697. }
  1698. /* protection pointer moves to RFC822 header */
  1699. f.protect = elt->private.special.offset +
  1700.   elt->private.msg.header.offset;
  1701. /* write internal header */
  1702. unix_write (&f,LOCAL->buf,elt->private.special.text.size);
  1703. /* get RFC822 header */
  1704. s = unix_header (stream,elt->msgno,&j,FT_INTERNAL);
  1705. /* in case this got decremented */
  1706. elt->private.msg.header.offset = elt->private.special.text.size;
  1707. /* header size, sans trailing newline */
  1708. if ((j < 2) || (s[j - 2] == 'n')) j--;
  1709. if (j != elt->private.data) fatal ("header size inconsistant");
  1710. /* protection pointer moves to RFC822 text */
  1711. f.protect = elt->private.special.offset + elt->private.msg.text.offset;
  1712. unix_write (&f,s,j); /* write RFC822 header */
  1713. /* write status and UID */
  1714. unix_write (&f,LOCAL->buf,j = unix_xstatus (stream,LOCAL->buf,elt,T));
  1715. /* new file header size */
  1716. elt->private.msg.header.text.size = elt->private.data + j;
  1718. /* did text move? */
  1719. if (f.curpos != f.protect) {
  1720. /* get message text */
  1721.   s = unix_text_work (stream,elt,&j,FT_INTERNAL);
  1722. /* this can happen if CRs were squeezed */
  1723.   if (j < elt->private.msg.text.text.size) {
  1724. /* so fix up counts */
  1725.     *size -= elt->private.msg.text.text.size - j;
  1726.     elt->private.msg.text.text.size = j;
  1727.   }
  1728. /* can't happen it says here */
  1729.   else if (j > elt->private.msg.text.text.size)
  1730.     fatal ("text size inconsistant");
  1731. /* new text offset, status/UID may change it */
  1732.   elt->private.msg.text.offset = f.curpos - newoffset;
  1733. /* protection pointer moves to next message */
  1734.   f.protect = (i <= stream->nmsgs) ?
  1735.     mail_elt (stream,i)->private.special.offset : (f.curpos + j + 1);
  1736.   unix_write (&f,s,j); /* write text */
  1737. /* write trailing newline */
  1738.   unix_write (&f,"n",1);
  1739. }
  1740. else { /* tie off header and status */
  1741.   unix_write (&f,NIL,NIL);
  1742.   f.curpos = f.protect =/* restart everything at end of message */
  1743.     f.filepos += elt->private.msg.text.text.size + 1;
  1744. }
  1745. /* new internal header offset */
  1746. elt->private.special.offset = newoffset;
  1747. elt->private.dirty =NIL;/* message is now clean */
  1748.       }
  1749.       else { /* no need to rewrite */
  1750. unix_write (&f,NIL,NIL);/* tie off previous message if needed */
  1751. f.curpos = f.protect = /* restart everything at end of message */
  1752.   f.filepos += elt->private.special.text.size +
  1753.     elt->private.msg.header.text.size +
  1754.       elt->private.msg.text.text.size + 1;
  1755.       }
  1756.     }
  1757.   }
  1758.   unix_write (&f,NIL,NIL); /* tie off final message */
  1759.   if (*size != f.filepos) fatal ("file size inconsistant");
  1760.   fs_give ((void **) &f.buf); /* free buffer */
  1761.   return LONGT; /* looks good */
  1762. }
  1764. /* Write data to buffered file
  1765.  * Accepts: buffered file pointer
  1766.  *     file data or NIL to indicate "flush buffer"
  1767.  *     date size (ignored for "flush buffer")
  1768.  * Does not return until success
  1769.  */
  1771. void unix_write (UNIXFILE *f,char *buf,unsigned long size)
  1772. {
  1773.   unsigned long i,j,k;
  1774.   if (buf) { /* doing buffered write? */
  1775.     i = f->bufpos - f->buf; /* yes, get size of current buffer data */
  1776. /* yes, have space in current buffer chunk? */
  1777.     if (j = i ? ((f->buflen - i) % OVERFLOWBUFLEN) : f->buflen) {
  1778. /* yes, fill up buffer as much as we can */
  1779.       memcpy (f->bufpos,buf,k = min (j,size));
  1780.       f->bufpos += k; /* new buffer position */
  1781.       f->curpos += k; /* new current position */
  1782.       if (j -= k) return; /* all done if still have buffer free space */
  1783.       buf += k; /* full, get new unwritten data pointer */
  1784.       size -= k; /* new data size */
  1785.       i += k; /* new buffer data size */
  1786.     }
  1787.     /* This chunk of the buffer is full.  See if can make some space by
  1788.      * writing to the disk, if there's enough unprotected space to do so.
  1789.      * Try to fill out any unaligned chunk, along with any subsequent full
  1790.      * chunks that will fit in unprotected space.
  1791.      */
  1792. /* any unprotected space we can write to? */
  1793.     if (j = min (i,f->protect - f->filepos)) {
  1794. /* yes, filepos not at chunk boundary? */
  1795.       if ((k = f->filepos % OVERFLOWBUFLEN) && ((k = OVERFLOWBUFLEN - k) < j))
  1796. j -= k; /* yes, and can write out partial chunk */
  1797.       else k = 0; /* no partial chunk to write */
  1798. /* if at least a chunk free, write that too */
  1799.       if (j > OVERFLOWBUFLEN) k += j - (j % OVERFLOWBUFLEN);
  1800.       if (k) { /* write data if there is anything we can */
  1801. unix_phys_write (f,f->buf,k);
  1802. /* slide buffer */
  1803. if (i -= k) memmove (f->buf,f->buf + k,i);
  1804. f->bufpos = f->buf + i; /* new end of buffer */
  1805.       }
  1806.     }
  1808.     /* Have flushed the buffer as best as possible.  All done if no more
  1809.      * data to write.  Otherwise, if the buffer is empty AND if the unwritten
  1810.      * data is larger than a chunk AND the unprotected space is also larger
  1811.      * than a chunk, then write as many chunks as we can directly from the
  1812.      * data.  Buffer the rest, expanding the buffer as needed.
  1813.      */
  1814.     if (size) { /* have more data that we need to buffer? */
  1815. /* can write any of it to disk instead? */
  1816.       if ((f->bufpos == f->buf) && 
  1817.   ((j = min (f->protect - f->filepos,size)) > OVERFLOWBUFLEN)) {
  1818. /* write as much as we can right now */
  1819. unix_phys_write (f,buf,j -= (j % OVERFLOWBUFLEN));
  1820. buf += j; /* new data pointer */
  1821. size -= j; /* new data size */
  1822. f->curpos += j; /* advance current pointer */
  1823.       }
  1824.       if (size) { /* still have data that we need to buffer? */
  1825. /* yes, need to expand the buffer? */
  1826. if ((i = ((f->bufpos + size) - f->buf)) > f->buflen) {
  1827. /* note current position in buffer */
  1828.   j = f->bufpos - f->buf;
  1829.   i += OVERFLOWBUFLEN; /* yes, grow another chunk */
  1830.   fs_resize ((void **) &f->buf,f->buflen = i - (i % OVERFLOWBUFLEN));
  1831. /* in case buffer relocated */
  1832.   f->bufpos = f->buf + j;
  1833. }
  1834. /* buffer remaining data */
  1835. memcpy (f->bufpos,buf,size);
  1836. f->bufpos += size; /* new end of buffer */
  1837. f->curpos += size; /* advance current pointer */
  1838.       }
  1839.     }
  1840.   }
  1841.   else { /* flush buffer to disk */
  1842.     unix_phys_write (f,f->buf,i = f->bufpos - f->buf);
  1843.     f->bufpos = f->buf; /* reset buffer */
  1844. /* update positions */
  1845.     f->curpos = f->protect = f->filepos;
  1846.   }
  1847. }
  1849. /* Physical disk write
  1850.  * Accepts: buffered file pointer
  1851.  *     buffer address
  1852.  *     buffer size
  1853.  * Does not return until success
  1854.  */
  1856. void unix_phys_write (UNIXFILE *f,char *buf,size_t size)
  1857. {
  1858.   MAILSTREAM *stream = f->stream;
  1859. /* write data at desired position */
  1860.   while (size && ((lseek (LOCAL->fd,f->filepos,L_SET) < 0) ||
  1861.   (write (LOCAL->fd,buf,size) < 0))) {
  1862.     int e;
  1863.     char tmp[MAILTMPLEN];
  1864.     sprintf (tmp,"Unable to write to mailbox: %s",strerror (e = errno));
  1865.     mm_log (tmp,ERROR);
  1866.     mm_diskerror (NIL,e,T); /* serious problem, must retry */
  1867.   }
  1868.   f->filepos += size; /* update file position */
  1869. }
  1871. /* Rewrite mailbox file (old, slow, safe algorithm)
  1872.  * Accepts: MAIL stream, must be critical and locked
  1873.  *     return pointer to number of expunged messages if want expunge
  1874.  *     return pointer to size of mailbox
  1875.  *     return pointer to number of recent messages
  1876.  * Returns: T if success, NIL if failure
  1877.  */
  1879. long unix_rewrite_old (MAILSTREAM *stream,unsigned long *nexp,
  1880.        unsigned long *size,unsigned long *recent)
  1881. {
  1882.   unsigned long i,j;
  1883.   int e,retry;
  1884.   struct stat sbuf;
  1885.   FILE *f;
  1886.   MESSAGECACHE *elt;
  1887. /* open scratch file */
  1888.   if (!(f = tmpfile ())) return unix_punt_scratch (NIL);
  1889.   if (!(stream->uid_nosticky || /* write pseudo-header */
  1890. unix_fwrite (f,LOCAL->buf,unix_pseudo (stream,LOCAL->buf),size)))
  1891.     return unix_punt_scratch (f);
  1892.   if (nexp) { /* expunging */
  1893.     for (i = 1; i <= stream->nmsgs; i++)
  1894.       if (!(elt = mail_elt (stream,i))->deleted &&
  1895.   !unix_write_message (f,stream,elt,size))
  1896. return unix_punt_scratch (f);
  1897.   }
  1898.   else for (i = 1; i <= stream->nmsgs; i++)
  1899.     if (!unix_write_message (f,stream,mail_elt (stream,i),size))
  1900.       return unix_punt_scratch (f);
  1901. /* write remaining data */
  1902.   if (fflush (f) || fstat (fileno (f),&sbuf)) return unix_punt_scratch (f);
  1903.   if (*size != sbuf.st_size) { /* make damn sure stdio isn't lying */
  1904.     char tmp[MAILTMPLEN];
  1905.     sprintf (tmp,"Checkpoint file size mismatch (%lu != %lu)",
  1906.      (unsigned long) size,(unsigned long) sbuf.st_size);
  1907.     mm_log (tmp,ERROR);
  1908.     fclose (f); /* flush the output file */
  1909.     return NIL;
  1910.   }
  1912. /* extend the file as necessary */
  1913.   if (!unix_extend (stream,*size)) return NIL;
  1914. /* update the cache */
  1915.   for (i = 1; i <= stream->nmsgs;) {
  1916.     elt = mail_elt (stream,i); /* get cache */
  1917.     if (nexp && elt->deleted) { /* expunge this message? */
  1918.       if (elt->recent)--*recent;/* one less recent message */
  1919.       mail_expunged (stream,i); /* notify upper levels */
  1920.       ++*nexp; /* count up one more expunged message */
  1921.     }
  1922.     else { /* update file pointers from kludgey places */
  1923.       elt->private.special.offset = elt->private.msg.full.offset;
  1924.       elt->private.msg.text.offset = elt->private.msg.full.text.size;
  1925. /* in case header grew */
  1926.       elt->private.msg.header.text.size = elt->private.msg.text.offset -
  1927. elt->private.msg.header.offset;
  1928. /* stomp on these two kludges */
  1929.       elt->private.msg.full.offset = elt->private.msg.full.text.size = 0;
  1930.       i++; /* preserved message */
  1931.     }
  1932.   }
  1933.   do { /* restart point if failure */
  1934.     retry = NIL; /* no need to retry yet */
  1935.     fseek (f,0,L_SET); /* rewind files */
  1936.     lseek (LOCAL->fd,0,L_SET);
  1937.     for (i = *size; i; i -= j)
  1938.       if (!((j = fread (LOCAL->buf,1,min ((long) CHUNK,i),f)) &&
  1939.     (write (LOCAL->fd,LOCAL->buf,j) >= 0))) {
  1940. sprintf (LOCAL->buf,"Mailbox rewrite error: %s",strerror (e = errno));
  1941. mm_notify (stream,LOCAL->buf,WARN);
  1942. mm_diskerror (stream,e,T);
  1943. retry = T; /* must retry */
  1944. break;
  1945.       }
  1946.   } while (retry); /* in case need to retry */
  1947.   fclose (f); /* finished with scratch file */
  1948.   return LONGT;
  1949. }
  1951. /* Write message (old algorithm)
  1952.  * Accepts: destination file
  1953.  *     MAIL stream
  1954.  *     message number
  1955.  *     pointer to current filesize tally
  1956.  * Returns: T if success, NIL if failure
  1957.  */
  1959. long unix_write_message (FILE *f,MAILSTREAM *stream,MESSAGECACHE *elt,
  1960.  unsigned long *size)
  1961. {
  1962.   char *s;
  1963.   unsigned long i;
  1964. /* (kludge alert) note new message offset */
  1965.   elt->private.msg.full.offset = *size;
  1966. /* internal header */
  1967.   lseek (LOCAL->fd,elt->private.special.offset,L_SET);
  1968.   read (LOCAL->fd,LOCAL->buf,elt->private.special.text.size);
  1969.   if (unix_fwrite (f,LOCAL->buf,elt->private.special.text.size,size)) {
  1970. /* get header */
  1971.     s = unix_header (stream,elt->msgno,&i,FT_INTERNAL);
  1972. /* header size, sans trailing newline */
  1973.     if (i && (s[i - 2] == 'n')) i--;
  1974. /* write header */
  1975.     if (unix_fwrite (f,s,i,size) &&
  1976. unix_fwrite (f,LOCAL->buf,unix_xstatus(stream,LOCAL->buf,elt,T),size)){
  1977. /* (kludge alert) note new text offset */
  1978.       elt->private.msg.full.text.size = *size - elt->private.msg.full.offset;
  1979. /* get text */
  1980.       s = unix_text_work (stream,elt,&i,FT_INTERNAL);
  1981. /* write text and trailing newline */
  1982.       if (unix_fwrite (f,s,i,size) && unix_fwrite (f,"n",1,size)) return T;
  1983.     }
  1984.   }
  1985.   return NIL; /* failed */
  1986. }
  1988. /* Safely write buffer (old algorithm)
  1989.  * Accepts: destination file
  1990.  *     buffer pointer
  1991.  *     number of octets
  1992.  *     pointer to current filesize tally
  1993.  * Returns: T if successful, NIL if failure
  1994.  */
  1996. long unix_fwrite (FILE *f,char *s,unsigned long i,unsigned long *size)
  1997. {
  1998.   unsigned long j;
  1999.   while (i && ((j = fwrite (s,1,i,f)) || (errno == EINTR))) {
  2000.     *size += j;
  2001.     s += j;
  2002.     i -= j;
  2003.   }
  2004.   return i ? NIL : T; /* success if wrote all requested data */
  2005. }
  2008. /* Punt scratch file (old algorithm)
  2009.  * Accepts: file pointer
  2010.  * Returns: NIL, always
  2011.  */
  2013. long unix_punt_scratch (FILE *f)
  2014. {
  2015.   char tmp[MAILTMPLEN];
  2016.   sprintf (tmp,"Checkpoint file failure: %s",strerror (errno));
  2017.   mm_log (tmp,ERROR);
  2018.   if (f) fclose (f); /* flush the output file */
  2019.   return NIL;
  2020. }