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

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

网络编程

开发平台：

Unix_Linux

mx.c：源码内容
  1. /*
  2.  * Program: MX mail routines
  3.  *
  4.  * Author(s): 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: 3 May 1996
  13.  * Last Edited: 12 November 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.  */
  36. #include <stdio.h>
  37. #include <ctype.h>
  38. #include <errno.h>
  39. extern int errno; /* just in case */
  40. #include "mail.h"
  41. #include "osdep.h"
  42. #include <pwd.h>
  43. #include <sys/stat.h>
  44. #include <sys/time.h>
  45. #include "mx.h"
  46. #include "misc.h"
  47. #include "dummy.h"
  49. /* MX mail routines */
  52. /* Driver dispatch used by MAIL */
  54. DRIVER mxdriver = {
  55.   "mx", /* driver name */
  56. /* driver flags */
  57.   DR_MAIL|DR_LOCAL|DR_NOFAST|DR_CRLF,
  58.   (DRIVER *) NIL, /* next driver */
  59.   mx_valid, /* mailbox is valid for us */
  60.   mx_parameters, /* manipulate parameters */
  61.   mx_scan, /* scan mailboxes */
  62.   mx_list, /* find mailboxes */
  63.   mx_lsub, /* find subscribed mailboxes */
  64.   mx_subscribe, /* subscribe to mailbox */
  65.   mx_unsubscribe, /* unsubscribe from mailbox */
  66.   mx_create, /* create mailbox */
  67.   mx_delete, /* delete mailbox */
  68.   mx_rename, /* rename mailbox */
  69.   NIL, /* status of mailbox */
  70.   mx_open, /* open mailbox */
  71.   mx_close, /* close mailbox */
  72.   mx_fast, /* fetch message "fast" attributes */
  73.   NIL, /* fetch message flags */
  74.   NIL, /* fetch overview */
  75.   NIL, /* fetch message envelopes */
  76.   mx_header, /* fetch message header only */
  77.   mx_text, /* fetch message body only */
  78.   NIL, /* fetch partial message test */
  79.   NIL, /* unique identifier */
  80.   NIL, /* message number */
  81.   mx_flag, /* modify flags */
  82.   mx_flagmsg, /* per-message modify flags */
  83.   NIL, /* search for message based on criteria */
  84.   NIL, /* sort messages */
  85.   NIL, /* thread messages */
  86.   mx_ping, /* ping mailbox to see if still alive */
  87.   mx_check, /* check for new messages */
  88.   mx_expunge, /* expunge deleted messages */
  89.   mx_copy, /* copy messages to another mailbox */
  90.   mx_append, /* append string message to mailbox */
  91.   NIL /* garbage collect stream */
  92. };
  94. /* prototype stream */
  95. MAILSTREAM mxproto = {&mxdriver};
  98. /* MX mail validate mailbox
  99.  * Accepts: mailbox name
  100.  * Returns: our driver if name is valid, NIL otherwise
  101.  */
  103. DRIVER *mx_valid (char *name)
  104. {
  105.   char tmp[MAILTMPLEN];
  106.   return mx_isvalid (name,tmp) ? &mxdriver : NIL;
  107. }
  109. /* MX mail test for valid mailbox
  110.  * Accepts: mailbox name
  111.  *     temporary buffer to use
  112.  * Returns: T if valid, NIL otherwise
  113.  */
  115. int mx_isvalid (char *name,char *tmp)
  116. {
  117.   struct stat sbuf;
  118.   errno = NIL; /* zap error */
  119. /* validate name as directory */
  120.   return (!stat (MXINDEX (tmp,name),&sbuf) &&
  121.   ((sbuf.st_mode & S_IFMT) == S_IFREG));
  122. }
  125. /* MX manipulate driver parameters
  126.  * Accepts: function code
  127.  *     function-dependent value
  128.  * Returns: function-dependent return value
  129.  */
  131. void *mx_parameters (long function,void *value)
  132. {
  133.   return NIL;
  134. }
  137. /* MX scan mailboxes
  138.  * Accepts: mail stream
  139.  *     reference
  140.  *     pattern to search
  141.  *     string to scan
  142.  */
  144. void mx_scan (MAILSTREAM *stream,char *ref,char *pat,char *contents)
  145. {
  146.   if (stream) mm_log ("Scan not valid for mx mailboxes",ERROR);
  147. }
  149. /* MX list mailboxes
  150.  * Accepts: mail stream
  151.  *     reference
  152.  *     pattern to search
  153.  */
  155. void mx_list (MAILSTREAM *stream,char *ref,char *pat)
  156. {
  157.   char *s,test[MAILTMPLEN],file[MAILTMPLEN];
  158.   long i = 0;
  159. /* get canonical form of name */
  160.   if (stream && dummy_canonicalize (test,ref,pat)) {
  161. /* found any wildcards? */
  162.     if (s = strpbrk (test,"%*")) {
  163. /* yes, copy name up to that point */
  164.       strncpy (file,test,i = s - test);
  165.       file[i] = ''; /* tie off */
  166.     }
  167.     else strcpy (file,test); /* use just that name then */
  168. /* find directory name */
  169.     if (s = strrchr (file,'/')) {
  170.       *s = ''; /* found, tie off at that point */
  171.       s = file;
  172.     }
  173. /* do the work */
  174.     mx_list_work (stream,s,test,0);
  175.   }
  176. }
  179. /* MX list subscribed mailboxes
  180.  * Accepts: mail stream
  181.  *     reference
  182.  *     pattern to search
  183.  */
  185. void mx_lsub (MAILSTREAM *stream,char *ref,char *pat)
  186. {
  187.   if (stream) dummy_lsub (NIL,ref,pat);
  188. }
  190. /* MX list mailboxes worker routine
  191.  * Accepts: mail stream
  192.  *     directory name to search
  193.  *     search pattern
  194.  *     search level
  195.  */
  197. void mx_list_work (MAILSTREAM *stream,char *dir,char *pat,long level)
  198. {
  199.   DIR *dp;
  200.   struct direct *d;
  201.   struct stat sbuf;
  202.   char *cp,*np,curdir[MAILTMPLEN],name[MAILTMPLEN];
  203. /* make mailbox and directory names */
  204.   if ((np = name + strlen (strcpy (name,dir ? dir : ""))) != name) *np++ = '/';
  205.   cp = curdir + strlen (strcat ((mx_file(curdir,dir ? dir:myhomedir())),"/"));
  206.   if (dp = opendir (curdir)) { /* open directory */
  207.     while (d = readdir (dp)) { /* scan, ignore . and numeric names */
  208.       if ((d->d_name[0] != '.') && !mx_select (d)) {
  209. if (level < (long) mail_parameters (NIL,GET_LISTMAXLEVEL,NIL)) {
  210.   strcpy (cp,d->d_name);/* make directory name */
  211.   strcpy (np,d->d_name);/* make mx name of directory name */
  212.   if (dmatch (name,pat,'/') && !stat (curdir,&sbuf) &&
  213.       ((sbuf.st_mode &= S_IFMT) == S_IFDIR))
  214.     mx_list_work (stream,name,pat,level+1);
  215. }
  216.       }
  217.       else if (!strcmp (d->d_name,MXINDEXNAME+1) && pmatch_full (dir,pat,'/'))
  218. mm_list (stream,'/',dir,NIL);
  219.     }
  220.     closedir (dp); /* all done, flush directory */
  221.   }
  222. }
  224. /* MX mail subscribe to mailbox
  225.  * Accepts: mail stream
  226.  *     mailbox to add to subscription list
  227.  * Returns: T on success, NIL on failure
  228.  */
  230. long mx_subscribe (MAILSTREAM *stream,char *mailbox)
  231. {
  232.   return sm_subscribe (mailbox);
  233. }
  236. /* MX mail unsubscribe to mailbox
  237.  * Accepts: mail stream
  238.  *     mailbox to delete from subscription list
  239.  * Returns: T on success, NIL on failure
  240.  */
  242. long mx_unsubscribe (MAILSTREAM *stream,char *mailbox)
  243. {
  244.   return sm_unsubscribe (mailbox);
  245. }
  247. /* MX mail create mailbox
  248.  * Accepts: mail stream
  249.  *     mailbox name to create
  250.  * Returns: T on success, NIL on failure
  251.  */
  253. long mx_create (MAILSTREAM *stream,char *mailbox)
  254. {
  255.   int fd;
  256.   char *s,tmp[MAILTMPLEN],mbx[MAILTMPLEN];
  257. /* assume error */
  258.   sprintf (tmp,"Can't create mailbox %.80s: invalid MX-format name",mailbox);
  259. /* make sure valid name */
  260.   for (s = mailbox; s && *s;) {
  261.     if (isdigit (*s)) s++; /* digit, check this node further... */
  262. /* all digit node, barf */
  263.     else if (*s == '/') s = NIL;
  264. /* non-digit in node, skip to next node */
  265.     else if (s = strchr (s+1,'/')) s++;
  266.     else tmp[0] = NIL; /* no more nodes, good name */
  267.   }
  268.   if (tmp[0]); /* was there an error in the name? */
  269. /* must not already exist */
  270.   else if (mx_isvalid (mailbox,tmp))
  271.     sprintf (tmp,"Can't create mailbox %.80s: mailbox already exists",mailbox);
  272. /* create directory */
  273.   else if (!dummy_create_path (stream,strcat (mx_file (mbx,mailbox),"/")))
  274.     sprintf (tmp,"Can't create mailbox leaf %.80s: %s",
  275.      mailbox,strerror (errno));
  276. /* create index file */
  277.   else if (((fd = open (MXINDEX (tmp,mailbox),O_WRONLY|O_CREAT|O_EXCL,
  278. (int) mail_parameters (NIL,GET_MBXPROTECTION,mailbox)))
  279.     <0 ) || close (fd))
  280.     sprintf (tmp,"Can't create mailbox index %.80s: %s",
  281.      mailbox,strerror (errno));
  282. /* success */
  283.   else return set_mbx_protections (mailbox,mbx) &&
  284.     set_mbx_protections (mailbox,tmp);
  285.   mm_log (tmp,ERROR); /* some error */
  286.   return NIL;
  287. }
  289. /* MX mail delete mailbox
  290.  *     mailbox name to delete
  291.  * Returns: T on success, NIL on failure
  292.  */
  294. long mx_delete (MAILSTREAM *stream,char *mailbox)
  295. {
  296.   DIR *dirp;
  297.   struct direct *d;
  298.   char *s;
  299.   char tmp[MAILTMPLEN];
  300.   if (!mx_isvalid (mailbox,tmp))
  301.     sprintf (tmp,"Can't delete mailbox %.80s: no such mailbox",mailbox);
  302. /* delete index */
  303.   else if (unlink (MXINDEX (tmp,mailbox)))
  304.     sprintf (tmp,"Can't delete mailbox %.80s index: %s",
  305.      mailbox,strerror (errno));
  306.   else { /* get directory name */
  307.     *(s = strrchr (tmp,'/')) = '';
  308.     if (dirp = opendir (tmp)) { /* open directory */
  309.       *s++ = '/'; /* restore delimiter */
  310. /* massacre messages */
  311.       while (d = readdir (dirp)) if (mx_select (d)) {
  312. strcpy (s,d->d_name); /* make path */
  313. unlink (tmp); /* sayonara */
  314.       }
  315.       closedir (dirp); /* flush directory */
  316.     }
  317. /* success if can remove the directory */
  318.     if (!rmdir (mx_file (tmp,mailbox))) return T;
  319.     sprintf (tmp,"Can't delete mailbox %.80s: %s",mailbox,strerror (errno));
  320.   }
  321.   mm_log (tmp,ERROR); /* something failed */
  322.   return NIL;
  323. }
  325. /* MX mail rename mailbox
  326.  * Accepts: MX mail stream
  327.  *     old mailbox name
  328.  *     new mailbox name
  329.  * Returns: T on success, NIL on failure
  330.  */
  332. long mx_rename (MAILSTREAM *stream,char *old,char *newname)
  333. {
  334.   char c,*s,tmp[MAILTMPLEN],tmp1[MAILTMPLEN];
  335.   struct stat sbuf;
  336.   if (!mx_isvalid (old,tmp))
  337.     sprintf (tmp,"Can't rename mailbox %.80s: no such mailbox",old);
  338. /* new mailbox name must not be valid */
  339.   else if (mx_isvalid (newname,tmp))
  340.     sprintf (tmp,"Can't rename to mailbox %.80s: destination already exists",
  341.      newname);
  342. /* success if can rename the directory */
  343.   else { /* found superior to destination name? */
  344.     if (s = strrchr (mx_file (tmp1,newname),'/')) {
  345.       c = *++s; /* remember first character of inferior */
  346.       *s = ''; /* tie off to get just superior */
  347. /* name doesn't exist, create it */
  348.       if ((stat (tmp1,&sbuf) || ((sbuf.st_mode & S_IFMT) != S_IFDIR)) &&
  349.   !dummy_create (stream,tmp1)) return NIL;
  350.       *s = c; /* restore full name */
  351.     }
  352.     if (!rename (mx_file (tmp,old),tmp1)) {
  353. /* recreate file if renamed INBOX */
  354.       if (!strcmp (ucase (strcpy (tmp,old)),"INBOX"))
  355. mx_create (NIL,"INBOX");
  356.       return T;
  357.     }
  358.     sprintf (tmp,"Can't rename mailbox %.80s to %.80s: %s",
  359.      old,newname,strerror (errno));
  360.   }
  361.   mm_log (tmp,ERROR); /* something failed */
  362.   return NIL;
  363. }
  365. /* MX mail open
  366.  * Accepts: stream to open
  367.  * Returns: stream on success, NIL on failure
  368.  */
  370. MAILSTREAM *mx_open (MAILSTREAM *stream)
  371. {
  372.   char tmp[MAILTMPLEN];
  373. /* return prototype for OP_PROTOTYPE call */
  374.   if (!stream) return user_flags (&mxproto);
  375.   if (stream->local) fatal ("mx recycle stream");
  376.   stream->local = fs_get (sizeof (MXLOCAL));
  377. /* note if an INBOX or not */
  378.   stream->inbox = !strcmp (ucase (strcpy (tmp,stream->mailbox)),"INBOX");
  379.   mx_file (tmp,stream->mailbox);/* get directory name */
  380.   LOCAL->dir = cpystr (tmp); /* copy directory name for later */
  381. /* make temporary buffer */
  382.   LOCAL->buf = (char *) fs_get ((LOCAL->buflen = MAXMESSAGESIZE) + 1);
  383.   LOCAL->scantime = 0; /* not scanned yet */
  384.   LOCAL->fd = -1; /* no index yet */
  385.   LOCAL->cachedtexts = 0; /* no cached texts */
  386.   stream->sequence++; /* bump sequence number */
  387. /* parse mailbox */
  388.   stream->nmsgs = stream->recent = 0;
  389.   if (mx_ping (stream) && !(stream->nmsgs || stream->silent))
  390.     mm_log ("Mailbox is empty",(long) NIL);
  391.   stream->perm_seen = stream->perm_deleted = stream->perm_flagged =
  392.     stream->perm_answered = stream->perm_draft = stream->rdonly ? NIL : T;
  393.   stream->perm_user_flags = stream->rdonly ? NIL : 0xffffffff;
  394.   stream->kwd_create = (stream->user_flags[NUSERFLAGS-1] || stream->rdonly) ?
  395.     NIL : T; /* can we create new user flags? */
  396.   return stream; /* return stream to caller */
  397. }
  399. /* MX mail close
  400.  * Accepts: MAIL stream
  401.  *     close options
  402.  */
  404. void mx_close (MAILSTREAM *stream,long options)
  405. {
  406.   if (LOCAL) { /* only if a file is open */
  407.     int silent = stream->silent;
  408.     stream->silent = T; /* note this stream is dying */
  409.     if (options & CL_EXPUNGE) mx_expunge (stream);
  410.     if (LOCAL->dir) fs_give ((void **) &LOCAL->dir);
  411. /* free local scratch buffer */
  412.     if (LOCAL->buf) fs_give ((void **) &LOCAL->buf);
  413. /* nuke the local data */
  414.     fs_give ((void **) &stream->local);
  415.     stream->dtb = NIL; /* log out the DTB */
  416.     stream->silent = silent; /* reset silent state */
  417.   }
  418. }
  420. /* MX mail fetch fast information
  421.  * Accepts: MAIL stream
  422.  *     sequence
  423.  *     option flags
  424.  */
  426. void mx_fast (MAILSTREAM *stream,char *sequence,long flags)
  427. {
  428.   unsigned long i;
  429.   MESSAGECACHE *elt;
  430.   if (stream && LOCAL &&
  431.       ((flags & FT_UID) ? mail_uid_sequence (stream,sequence) :
  432.        mail_sequence (stream,sequence)))
  433.     for (i = 1; i <= stream->nmsgs; i++)
  434.       if ((elt = mail_elt (stream,i))->sequence) mx_fast_work (stream,elt);
  435. }
  438. /* MX mail fetch fast information
  439.  * Accepts: MAIL stream
  440.  *     message cache element
  441.  * Returns: name of message file
  442.  */
  444. char *mx_fast_work (MAILSTREAM *stream,MESSAGECACHE *elt)
  445. {
  446.   struct stat sbuf;
  447.   struct tm *tm;
  448. /* build message file name */
  449.   sprintf (LOCAL->buf,"%s/%lu",LOCAL->dir,elt->private.uid);
  450.   if (!elt->rfc822_size) { /* have size yet? */
  451.     stat (LOCAL->buf,&sbuf); /* get size of message */
  452. /* make plausible IMAPish date string */
  453.     tm = gmtime (&sbuf.st_mtime);
  454.     elt->day = tm->tm_mday; elt->month = tm->tm_mon + 1;
  455.     elt->year = tm->tm_year + 1900 - BASEYEAR;
  456.     elt->hours = tm->tm_hour; elt->minutes = tm->tm_min;
  457.     elt->seconds = tm->tm_sec;
  458.     elt->zhours = 0; elt->zminutes = 0; elt->zoccident = 0;
  459.     elt->rfc822_size = sbuf.st_size;
  460.   }
  461.   return LOCAL->buf; /* return file name */
  462. }
  464. /* MX mail fetch message header
  465.  * Accepts: MAIL stream
  466.  *     message # to fetch
  467.  *     pointer to returned header text length
  468.  *     option flags
  469.  * Returns: message header in RFC822 format
  470.  */
  472. char *mx_header (MAILSTREAM *stream,unsigned long msgno,unsigned long *length,
  473.  long flags)
  474. {
  475.   unsigned long i;
  476.   int fd;
  477.   MESSAGECACHE *elt;
  478.   *length = 0; /* default to empty */
  479.   if (flags & FT_UID) return "";/* UID call "impossible" */
  480.   elt = mail_elt (stream,msgno);/* get elt */
  481.   if (!elt->private.msg.header.text.data) {
  482. /* purge cache if too big */
  483.     if (LOCAL->cachedtexts > max (stream->nmsgs * 4096,2097152)) {
  484.       mail_gc (stream,GC_TEXTS);/* just can't keep that much */
  485.       LOCAL->cachedtexts = 0;
  486.     }
  487.     if ((fd = open (mx_fast_work (stream,elt),O_RDONLY,NIL)) < 0) return "";
  488. /* is buffer big enough? */
  489.     if (elt->rfc822_size > LOCAL->buflen) {
  490.       fs_give ((void **) &LOCAL->buf);
  491.       LOCAL->buf = (char *) fs_get ((LOCAL->buflen = elt->rfc822_size) + 1);
  492.     }
  493. /* slurp message */
  494.     read (fd,LOCAL->buf,elt->rfc822_size);
  495. /* tie off file */
  496.     LOCAL->buf[elt->rfc822_size] = '';
  497.     close (fd); /* flush message file */
  498. /* find end of header */
  499.     if (elt->rfc822_size < 4) i = 0;
  500.     else for (i = 4; (i < elt->rfc822_size) &&
  501.       !((LOCAL->buf[i - 4] == '15') &&
  502. (LOCAL->buf[i - 3] == '12') &&
  503. (LOCAL->buf[i - 2] == '15') &&
  504. (LOCAL->buf[i - 1] == '12')); i++);
  505. /* copy header */
  506.     cpytxt (&elt->private.msg.header.text,LOCAL->buf,i);
  507.     cpytxt (&elt->private.msg.text.text,LOCAL->buf+i,elt->rfc822_size - i);
  508. /* add to cached size */
  509.     LOCAL->cachedtexts += elt->rfc822_size;
  510.   }
  511.   *length = elt->private.msg.header.text.size;
  512.   return (char *) elt->private.msg.header.text.data;
  513. }
  515. /* MX mail fetch message text (body only)
  516.  * Accepts: MAIL stream
  517.  *     message # to fetch
  518.  *     pointer to returned stringstruct
  519.  *     option flags
  520.  * Returns: T on success, NIL on failure
  521.  */
  523. long mx_text (MAILSTREAM *stream,unsigned long msgno,STRING *bs,long flags)
  524. {
  525.   unsigned long i;
  526.   MESSAGECACHE *elt;
  527. /* UID call "impossible" */
  528.   if (flags & FT_UID) return NIL;
  529.   elt = mail_elt (stream,msgno);
  530. /* snarf message if don't have it yet */
  531.   if (!elt->private.msg.text.text.data) {
  532.     mx_header (stream,msgno,&i,flags);
  533.     if (!elt->private.msg.text.text.data) return NIL;
  534.   }
  535. /* mark as seen */
  536.   if (!(flags & FT_PEEK) && mx_lockindex (stream)) {
  537.     elt->seen = T;
  538.     mx_unlockindex (stream);
  539.     mm_flags (stream,msgno);
  540.   }
  541.   INIT (bs,mail_string,elt->private.msg.text.text.data,
  542. elt->private.msg.text.text.size);
  543.   return T;
  544. }
  546. /* MX mail modify flags
  547.  * Accepts: MAIL stream
  548.  *     sequence
  549.  *     flag(s)
  550.  *     option flags
  551.  */
  553. void mx_flag (MAILSTREAM *stream,char *sequence,char *flag,long flags)
  554. {
  555.   mx_unlockindex (stream); /* finished with index */
  556. }
  559. /* MX per-message modify flags
  560.  * Accepts: MAIL stream
  561.  *     message cache element
  562.  */
  564. void mx_flagmsg (MAILSTREAM *stream,MESSAGECACHE *elt)
  565. {
  566.   mx_lockindex (stream); /* lock index if not already locked */
  567. }
  569. /* MX mail ping mailbox
  570.  * Accepts: MAIL stream
  571.  * Returns: T if stream alive, else NIL
  572.  */
  574. long mx_ping (MAILSTREAM *stream)
  575. {
  576.   MAILSTREAM *sysibx = NIL;
  577.   MESSAGECACHE *elt,*selt;
  578.   struct stat sbuf;
  579.   char *s,tmp[MAILTMPLEN];
  580.   int fd;
  581.   unsigned long i,j,r,old;
  582.   long nmsgs = stream->nmsgs;
  583.   long recent = stream->recent;
  584.   int silent = stream->silent;
  585.   if (stat (LOCAL->dir,&sbuf)) return NIL;
  586.   stream->silent = T; /* don't pass up mm_exists() events yet */
  587.   if (sbuf.st_ctime != LOCAL->scantime) {
  588.     struct direct **names = NIL;
  589.     long nfiles = scandir (LOCAL->dir,&names,mx_select,mx_numsort);
  590.     if (nfiles < 0) nfiles = 0; /* in case error */
  591.     old = stream->uid_last;
  592. /* note scanned now */
  593.     LOCAL->scantime = sbuf.st_ctime;
  594. /* scan directory */
  595.     for (i = 0; i < nfiles; ++i) {
  596. /* if newly seen, add to list */
  597.       if ((j = atoi (names[i]->d_name)) > old) {
  598. /* swell the cache */
  599. mail_exists (stream,++nmsgs);
  600. stream->uid_last = (elt = mail_elt (stream,nmsgs))->private.uid = j;
  601. elt->valid = T; /* note valid flags */
  602. if (old) { /* other than the first pass? */
  603.   elt->recent = T; /* yup, mark as recent */
  604.   recent++; /* bump recent count */
  605. }
  606.       }
  607.       fs_give ((void **) &names[i]);
  608.     }
  609. /* free directory */
  610.     if (s = (void *) names) fs_give ((void **) &s);
  611.   }
  612.   stream->nmsgs = nmsgs; /* don't upset mail_uid() */
  614. /* if INBOX, snarf from system INBOX  */
  615.   if (mx_lockindex (stream) && stream->inbox) {
  616.     old = stream->uid_last;
  617. /* paranoia check */
  618.     if (!strcmp (sysinbox (),stream->mailbox)) {
  619.       stream->silent = silent;
  620.       return NIL;
  621.     }
  622.     mm_critical (stream); /* go critical */
  623.     stat (sysinbox (),&sbuf); /* see if anything there */
  624. /* can get sysinbox mailbox? */
  625.     if (sbuf.st_size && (sysibx = mail_open (sysibx,sysinbox (),OP_SILENT))
  626. && (!sysibx->rdonly) && (r = sysibx->nmsgs)) {
  627.       for (i = 1; i <= r; ++i) {/* for each message in sysinbox mailbox */
  628. /* build file name we will use */
  629. sprintf (LOCAL->buf,"%s/%lu",LOCAL->dir,++old);
  630. /* snarf message from Berkeley mailbox */
  631. selt = mail_elt (sysibx,i);
  632. if (((fd = open (LOCAL->buf,O_WRONLY|O_CREAT|O_EXCL,
  633.  S_IREAD|S_IWRITE)) >= 0) &&
  634.     (s = mail_fetchheader_full (sysibx,i,NIL,&j,FT_PEEK)) &&
  635.     (write (fd,s,j) == j) &&
  636.     (s = mail_fetchtext_full (sysibx,i,&j,FT_PEEK)) &&
  637.     (write (fd,s,j) == j) && !fsync (fd) && !close (fd)) {
  638. /* swell the cache */
  639.   mail_exists (stream,++nmsgs);
  640.   stream->uid_last = /* create new elt, note its file number */
  641.     (elt = mail_elt (stream,nmsgs))->private.uid = old;
  642.   recent++; /* bump recent count */
  643. /* set up initial flags and date */
  644.   elt->valid = elt->recent = T;
  645.   elt->seen = selt->seen;
  646.   elt->deleted = selt->deleted;
  647.   elt->flagged = selt->flagged;
  648.   elt->answered = selt->answered;
  649.   elt->draft = selt->draft;
  650.   elt->day = selt->day;elt->month = selt->month;elt->year = selt->year;
  651.   elt->hours = selt->hours;elt->minutes = selt->minutes;
  652.   elt->seconds = selt->seconds;
  653.   elt->zhours = selt->zhours; elt->zminutes = selt->zminutes;
  654.   elt->zoccident = selt->zoccident;
  655.   mx_setdate (LOCAL->buf,elt);
  656. }
  657. else { /* failed to snarf */
  658.   if (fd) { /* did it ever get opened? */
  659.     close (fd); /* close descriptor */
  660.     unlink (LOCAL->buf);/* flush this file */
  661.   }
  662.   stream->silent = silent;
  663.   return NIL; /* note that something is badly wrong */
  664. }
  665. sprintf (tmp,"%lu",i); /* delete it from the sysinbox */
  666. mail_flag (sysibx,tmp,"\Deleted",ST_SET);
  667.       }
  668.       stat (LOCAL->dir,&sbuf); /* update scan time */
  669.       LOCAL->scantime = sbuf.st_ctime;      
  670.       mail_expunge (sysibx); /* now expunge all those messages */
  671.     }
  672.     if (sysibx) mail_close (sysibx);
  673.     mm_nocritical (stream); /* release critical */
  674.   }
  675.   mx_unlockindex (stream); /* done with index */
  676.   stream->silent = silent; /* can pass up events now */
  677.   mail_exists (stream,nmsgs); /* notify upper level of mailbox size */
  678.   mail_recent (stream,recent);
  679.   return T; /* return that we are alive */
  680. }
  682. /* MX mail check mailbox
  683.  * Accepts: MAIL stream
  684.  */
  686. void mx_check (MAILSTREAM *stream)
  687. {
  688.   if (mx_ping (stream)) mm_log ("Check completed",(long) NIL);
  689. }
  692. /* MX mail expunge mailbox
  693.  * Accepts: MAIL stream
  694.  */
  696. void mx_expunge (MAILSTREAM *stream)
  697. {
  698.   MESSAGECACHE *elt;
  699.   unsigned long i = 1;
  700.   unsigned long n = 0;
  701.   unsigned long recent = stream->recent;
  702.   if (mx_lockindex (stream)) { /* lock the index */
  703.     mm_critical (stream); /* go critical */
  704.     while (i <= stream->nmsgs) {/* for each message */
  705. /* if deleted, need to trash it */
  706.       if ((elt = mail_elt (stream,i))->deleted) {
  707. sprintf (LOCAL->buf,"%s/%lu",LOCAL->dir,elt->private.uid);
  708. if (unlink (LOCAL->buf)) {/* try to delete the message */
  709.   sprintf (LOCAL->buf,"Expunge of message %lu failed, aborted: %s",i,
  710.    strerror (errno));
  711.   mm_log (LOCAL->buf,(long) NIL);
  712.   break;
  713. }
  714. /* note uncached */
  715. LOCAL->cachedtexts -= ((elt->private.msg.header.text.data ?
  716. elt->private.msg.header.text.size : 0) +
  717.        (elt->private.msg.text.text.data ?
  718. elt->private.msg.text.text.size : 0));
  719. mail_gc_msg (&elt->private.msg,GC_ENV | GC_TEXTS);
  720. if(elt->recent)--recent;/* if recent, note one less recent message */
  721. mail_expunged(stream,i);/* notify upper levels */
  722. n++; /* count up one more expunged message */
  723.       }
  724.       else i++; /* otherwise try next message */
  725.     }
  726.     if (n) { /* output the news if any expunged */
  727.       sprintf (LOCAL->buf,"Expunged %lu messages",n);
  728.       mm_log (LOCAL->buf,(long) NIL);
  729.     }
  730.     else mm_log ("No messages deleted, so no update needed",(long) NIL);
  731.     mm_nocritical (stream); /* release critical */
  732.     mx_unlockindex (stream); /* finished with index */
  733.   }
  734. /* notify upper level of new mailbox size */
  735.   mail_exists (stream,stream->nmsgs);
  736.   mail_recent (stream,recent);
  737. }
  739. /* MX mail copy message(s)
  740.  * Accepts: MAIL stream
  741.  *     sequence
  742.  *     destination mailbox
  743.  *     copy options
  744.  * Returns: T if copy successful, else NIL
  745.  */
  747. long mx_copy (MAILSTREAM *stream,char *sequence,char *mailbox,long options)
  748. {
  749.   STRING st;
  750.   MESSAGECACHE *elt;
  751.   struct stat sbuf;
  752.   int fd;
  753.   unsigned long i,j;
  754.   char *t,flags[MAILTMPLEN],date[MAILTMPLEN];
  755. /* copy the messages */
  756.   if ((options & CP_UID) ? mail_uid_sequence (stream,sequence) :
  757.       mail_sequence (stream,sequence))
  758.     for (i = 1; i <= stream->nmsgs; i++) 
  759.       if ((elt = mail_elt (stream,i))->sequence) {
  760. if ((fd = open (mx_fast_work (stream,elt),O_RDONLY,NIL))<0) return NIL;
  761. fstat (fd,&sbuf); /* get size of message */
  762. /* is buffer big enough? */
  763. if (sbuf.st_size > LOCAL->buflen) {
  764.   fs_give ((void **) &LOCAL->buf);
  765.   LOCAL->buf = (char *) fs_get ((LOCAL->buflen = sbuf.st_size) + 1);
  766. }
  767. /* slurp message */
  768. read (fd,LOCAL->buf,sbuf.st_size);
  769. /* tie off file */
  770. LOCAL->buf[sbuf.st_size] = '';
  771. close (fd); /* flush message file */
  772. INIT (&st,mail_string,(void *) LOCAL->buf,sbuf.st_size);
  773. /* init flag string */
  774. flags[0] = flags[1] = '';
  775. if (j = elt->user_flags) do
  776.   if (t = stream->user_flags[find_rightmost_bit (&j)])
  777.     strcat (strcat (flags," "),t);
  778. while (j);
  779. if (elt->seen) strcat (flags," \Seen");
  780. if (elt->deleted) strcat (flags," \Deleted");
  781. if (elt->flagged) strcat (flags," \Flagged");
  782. if (elt->answered) strcat (flags," \Answered");
  783. if (elt->draft) strcat (flags," \Draft");
  784. flags[0] = '('; /* open list */
  785. strcat (flags,")"); /* close list */
  786. mail_date (date,elt); /* generate internal date */
  787. if (!mail_append_full (NIL,mailbox,flags,date,&st)) return NIL;
  788. if (options & CP_MOVE) elt->deleted = T;
  789.       }
  790.   return T; /* return success */
  791. }
  793. /* MX mail append message from stringstruct
  794.  * Accepts: MAIL stream
  795.  *     destination mailbox
  796.  *     stringstruct of messages to append
  797.  * Returns: T if append successful, else NIL
  798.  */
  800. long mx_append (MAILSTREAM *stream,char *mailbox,char *flags,char *date,
  801. STRING *message)
  802. {
  803.   MESSAGECACHE *elt,selt;
  804.   MAILSTREAM *astream;
  805.   int fd;
  806.   char *s,tmp[MAILTMPLEN];
  807.   long f;
  808.   long i = 0;
  809.   long size = SIZE (message);
  810.   long ret = LONGT;
  811.   unsigned long uf;
  812.   if (date) { /* want to preserve date? */
  813. /* yes, parse date into an elt */
  814.     if (!mail_parse_date (&selt,date)) {
  815.       sprintf (tmp,"Bad date in append: %.80s",date);
  816.       mm_log (tmp,ERROR);
  817.       return NIL;
  818.     }
  819.   }
  820. /* N.B.: can't use LOCAL->buf for tmp */
  821. /* make sure valid mailbox */
  822.   if (!mx_isvalid (mailbox,tmp)) switch (errno) {
  823.   case ENOENT: /* no such file? */
  824.     if (((mailbox[0] == 'I') || (mailbox[0] == 'i')) &&
  825. ((mailbox[1] == 'N') || (mailbox[1] == 'n')) &&
  826. ((mailbox[2] == 'B') || (mailbox[2] == 'b')) &&
  827. ((mailbox[3] == 'O') || (mailbox[3] == 'o')) &&
  828. ((mailbox[4] == 'X') || (mailbox[4] == 'x')) && !mailbox[5])
  829.       mx_create (NIL,"INBOX");
  830.     else {
  831.       mm_notify (stream,"[TRYCREATE] Must create mailbox before append",NIL);
  832.       return NIL;
  833.     }
  834. /* falls through */
  835.   case 0: /* merely empty file? */
  836.     break;
  837.   case EINVAL:
  838.     sprintf (tmp,"Invalid MX-format mailbox name: %.80s",mailbox);
  839.     mm_log (tmp,ERROR);
  840.     return NIL;
  841.   default:
  842.     sprintf (tmp,"Not a MX-format mailbox: %.80s",mailbox);
  843.     mm_log (tmp,ERROR);
  844.     return NIL;
  845.   }
  846.   if (!(astream = mail_open (NIL,mailbox,OP_SILENT))) {
  847.     sprintf (tmp,"Can't open append mailbox: %s",strerror (errno));
  848.     mm_log (tmp,ERROR);
  849.     return NIL;
  850.   }
  851. /* parse flags */
  852.   f = mail_parse_flags (astream,flags,&uf);
  854.   if (mx_lockindex (astream)) { /* lock the index */
  855.     mx_file (tmp,mailbox); /* make message name */
  856.     sprintf (tmp + strlen (tmp),"/%lu",++astream->uid_last);
  857.     if ((fd = open (tmp,O_WRONLY|O_CREAT|O_EXCL,S_IREAD|S_IWRITE)) < 0) {
  858.       sprintf (tmp,"Can't create append message: %s",strerror (errno));
  859.       mm_log (tmp,ERROR);
  860.       return NIL;
  861.     }
  862.     s = (char *) fs_get (size); /* copy message */
  863.     for (i = 0; i < size; s[i++] = SNX (message));
  864.     mm_critical (stream); /* go critical */
  865. /* write the data */
  866.     if ((write (fd,s,size) < 0) || fsync (fd)) {
  867.       unlink (tmp); /* delete mailbox */
  868.       sprintf (tmp,"Message append failed: %s",strerror (errno));
  869.       mm_log (tmp,ERROR);
  870.       ret = NIL;
  871.     }
  872.     close (fd); /* close the file */
  873. /* set the date for this message */
  874.     if (date) mx_setdate (tmp,&selt);
  875. /* swell the cache */
  876.     mail_exists (astream,++astream->nmsgs);
  877. /* copy flags */
  878.     (elt = mail_elt (astream,astream->nmsgs))->private.uid = astream->uid_last;
  879.     if (f&fSEEN) elt->seen = T;
  880.     if (f&fDELETED) elt->deleted = T;
  881.     if (f&fFLAGGED) elt->flagged = T;
  882.     if (f&fANSWERED) elt->answered = T;
  883.     if (f&fDRAFT) elt->draft = T;
  884.     elt->user_flags |= uf;
  885.     mx_unlockindex (astream); /* unlock index */
  886.   }
  887.   else {
  888.     mm_log ("Message append failed: unable to lock index",ERROR);
  889.     ret = NIL;
  890.   }
  891.   mm_nocritical (stream); /* release critical */
  892.   fs_give ((void **) &s); /* flush the buffer */
  893.   mail_close (astream);
  894.   return ret;
  895. }
  897. /* Internal routines */
  900. /* MX file name selection test
  901.  * Accepts: candidate directory entry
  902.  * Returns: T to use file name, NIL to skip it
  903.  */
  905. int mx_select (struct direct *name)
  906. {
  907.   char c;
  908.   char *s = name->d_name;
  909.   while (c = *s++) if (!isdigit (c)) return NIL;
  910.   return T;
  911. }
  914. /* MX file name comparision
  915.  * Accepts: first candidate directory entry
  916.  *     second candidate directory entry
  917.  * Returns: negative if d1 < d2, 0 if d1 == d2, postive if d1 > d2
  918.  */
  920. int mx_numsort (const void *d1,const void *d2)
  921. {
  922.   return atoi ((*(struct direct **) d1)->d_name) -
  923.     atoi ((*(struct direct **) d2)->d_name);
  924. }
  927. /* MX mail build file name
  928.  * Accepts: destination string
  929.  *          source
  930.  * Returns: destination
  931.  */
  933. char *mx_file (char *dst,char *name)
  934. {
  935.   char *s;
  936.   if (!(mailboxfile (dst,name) && *dst)) sprintf (dst,"%s/INBOX",myhomedir ());
  937. /* tie off unnecessary trailing / */
  938.   else if ((s = strrchr (dst,'/')) && !s[1]) *s = '';
  939.   return dst;
  940. }
  942. /* MX read and lock index
  943.  * Accepts: MAIL stream
  944.  * Returns: T if success, NIL if failure
  945.  */
  947. long mx_lockindex (MAILSTREAM *stream)
  948. {
  949.   unsigned long uf,sf,uid;
  950.   int k = 0;
  951.   unsigned long msgno = 1;
  952.   struct stat sbuf;
  953.   char *s,*t,*idx,tmp[MAILTMPLEN];
  954.   MESSAGECACHE *elt;
  955.   blocknotify_t bn = (blocknotify_t) mail_parameters (NIL,GET_BLOCKNOTIFY,NIL);
  956.   if ((LOCAL->fd < 0) && /* get index file, no-op if already have it */
  957.       (LOCAL->fd = open (strcat (strcpy (tmp,LOCAL->dir),MXINDEXNAME),
  958.  O_RDWR|O_CREAT,S_IREAD|S_IWRITE)) >= 0) {
  959.     (*bn) (BLOCK_FILELOCK,NIL);
  960.     flock (LOCAL->fd,LOCK_EX); /* get exclusive lock */
  961.     (*bn) (BLOCK_NONE,NIL);
  962.     fstat (LOCAL->fd,&sbuf); /* get size of index */
  963. /* slurp index */
  964.     read (LOCAL->fd,s = idx = (char *) fs_get (sbuf.st_size + 1),sbuf.st_size);
  965.     idx[sbuf.st_size] = ''; /* tie off index */
  966. /* parse index */
  967.     if (sbuf.st_size) while (s && *s) switch (*s) {
  968.     case 'V': /* UID validity record */
  969.       stream->uid_validity = strtoul (s+1,&s,16);
  970.       break;
  971.     case 'L': /* UID last record */
  972.       stream->uid_last = strtoul (s+1,&s,16);
  973.       break;
  974.     case 'K': /* keyword */
  975. /* find end of keyword */
  976.       if (s = strchr (t = ++s,'n')) {
  977. *s++ = ''; /* tie off keyword */
  978. /* copy keyword */
  979. if ((k < NUSERFLAGS) && !stream->user_flags[k])
  980.   stream->user_flags[k] = cpystr (t);
  981. k++; /* one more keyword */
  982.       }
  983.       break;
  985.     case 'M': /* message status record */
  986.       uid = strtoul (s+1,&s,16);/* get UID for this message */
  987.       if (*s == ';') { /* get user flags */
  988. uf = strtoul (s+1,&s,16);
  989. if (*s == '.') { /* get system flags */
  990.   sf = strtoul (s+1,&s,16);
  991.   while ((msgno <= stream->nmsgs) && (mail_uid (stream,msgno) < uid))
  992.     msgno++; /* find message number for this UID */
  993.   if ((msgno <= stream->nmsgs) && (mail_uid (stream,msgno) == uid)) {
  994.     (elt = mail_elt (stream,msgno))->valid = T;
  995.     elt->user_flags=uf; /* set user and system flags in elt */
  996.     if (sf & fSEEN) elt->seen = T;
  997.     if (sf & fDELETED) elt->deleted = T;
  998.     if (sf & fFLAGGED) elt->flagged = T;
  999.     if (sf & fANSWERED) elt->answered = T;
  1000.     if (sf & fDRAFT) elt->draft = T;
  1001.   }
  1002.   break;
  1003. }
  1004.       }
  1005.     default: /* bad news */
  1006.       sprintf (tmp,"Error in index: %.80s",s);
  1007.       mm_log (tmp,ERROR);
  1008.       *s = NIL; /* ignore remainder of index */
  1009.     }
  1010.     else { /* new index */
  1011.       stream->uid_validity = time (0);
  1012.       user_flags (stream); /* init stream with default user flags */
  1013.     }
  1014.     fs_give ((void **) &idx); /* flush index */
  1015.   }
  1016.   return (LOCAL->fd >= 0) ? T : NIL;
  1017. }
  1019. /* MX write and unlock index
  1020.  * Accepts: MAIL stream
  1021.  */
  1023. void mx_unlockindex (MAILSTREAM *stream)
  1024. {
  1025.   unsigned long i,j;
  1026.   off_t size = 0;
  1027.   char *s,tmp[MAILTMPLEN + 64];
  1028.   MESSAGECACHE *elt;
  1029.   if (LOCAL->fd >= 0) {
  1030.     lseek (LOCAL->fd,0,L_SET); /* rewind file */
  1031. /* write header */
  1032.     sprintf (s = tmp,"V%08lxL%08lx",stream->uid_validity,stream->uid_last);
  1033.     for (i = 0; (i < NUSERFLAGS) && stream->user_flags[i]; ++i)
  1034.       sprintf (s += strlen (s),"K%sn",stream->user_flags[i]);
  1035. /* write messages */
  1036.     for (i = 1; i <= stream->nmsgs; i++) {
  1037. /* filled buffer? */
  1038.       if (((s += strlen (s)) - tmp) > MAILTMPLEN) {
  1039. write (LOCAL->fd,tmp,j = s - tmp);
  1040. size += j;
  1041. *(s = tmp) = ''; /* dump out and restart buffer */
  1042.       }
  1043.       elt = mail_elt (stream,i);
  1044.       sprintf(s,"M%08lx;%08lx.%04x",elt->private.uid,elt->user_flags,(unsigned)
  1045.       ((fSEEN * elt->seen) + (fDELETED * elt->deleted) +
  1046.        (fFLAGGED * elt->flagged) + (fANSWERED * elt->answered) +
  1047.        (fDRAFT * elt->draft)));
  1048.     }
  1049. /* write tail end of buffer */
  1050.     if ((s += strlen (s)) != tmp) {
  1051.       write (LOCAL->fd,tmp,j = s - tmp);
  1052.       size += j;
  1053.     }
  1054.     ftruncate (LOCAL->fd,size);
  1055.     flock (LOCAL->fd,LOCK_UN); /* unlock the index */
  1056.     close (LOCAL->fd); /* finished with file */
  1057.     LOCAL->fd = -1; /* no index now */
  1058.   }
  1059. }
  1061. /* Set date for message
  1062.  * Accepts: file name
  1063.  *     elt containing date
  1064.  */
  1066. void mx_setdate (char *file,MESSAGECACHE *elt)
  1067. {
  1068.   time_t tp[2];
  1069.   tp[0] = time (0); /* atime is now */
  1070.   tp[1] = mail_longdate (elt); /* modification time */
  1071.   utime (file,tp); /* set the times */
  1072. }