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

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

网络编程

开发平台：

Unix_Linux

mh.c：源码内容
  1. /*
  2.  * Program: MH 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: 23 February 1992
  13.  * Last Edited: 19 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.  */
  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 "mh.h"
  46. #include "misc.h"
  47. #include "dummy.h"
  49. /* MH mail routines */
  52. /* Driver dispatch used by MAIL */
  54. DRIVER mhdriver = {
  55.   "mh", /* driver name */
  56. /* driver flags */
  57.   DR_MAIL|DR_LOCAL|DR_NOFAST|DR_NAMESPACE|DR_NOSTICKY,
  58.   (DRIVER *) NIL, /* next driver */
  59.   mh_valid, /* mailbox is valid for us */
  60.   mh_parameters, /* manipulate parameters */
  61.   mh_scan, /* scan mailboxes */
  62.   mh_list, /* find mailboxes */
  63.   mh_lsub, /* find subscribed mailboxes */
  64.   mh_subscribe, /* subscribe to mailbox */
  65.   mh_unsubscribe, /* unsubscribe from mailbox */
  66.   mh_create, /* create mailbox */
  67.   mh_delete, /* delete mailbox */
  68.   mh_rename, /* rename mailbox */
  69.   NIL, /* status of mailbox */
  70.   mh_open, /* open mailbox */
  71.   mh_close, /* close mailbox */
  72.   mh_fast, /* fetch message "fast" attributes */
  73.   NIL, /* fetch message flags */
  74.   NIL, /* fetch overview */
  75.   NIL, /* fetch message envelopes */
  76.   mh_header, /* fetch message header */
  77.   mh_text, /* fetch message body */
  78.   NIL, /* fetch partial message text */
  79.   NIL, /* unique identifier */
  80.   NIL, /* message number */
  81.   NIL, /* modify flags */
  82.   NIL, /* per-message modify flags */
  83.   NIL, /* search for message based on criteria */
  84.   NIL, /* sort messages */
  85.   NIL, /* thread messages */
  86.   mh_ping, /* ping mailbox to see if still alive */
  87.   mh_check, /* check for new messages */
  88.   mh_expunge, /* expunge deleted messages */
  89.   mh_copy, /* copy messages to another mailbox */
  90.   mh_append, /* append string message to mailbox */
  91.   NIL /* garbage collect stream */
  92. };
  94. /* prototype stream */
  95. MAILSTREAM mhproto = {&mhdriver};
  98. /* MH mail validate mailbox
  99.  * Accepts: mailbox name
  100.  * Returns: our driver if name is valid, NIL otherwise
  101.  */
  103. DRIVER *mh_valid (char *name)
  104. {
  105.   char tmp[MAILTMPLEN];
  106.   return mh_isvalid (name,tmp,T) ? &mhdriver : NIL;
  107. }
  109. /* MH mail test for valid mailbox
  110.  * Accepts: mailbox name
  111.  *     temporary buffer to use
  112.  *     syntax only test flag
  113.  * Returns: T if valid, NIL otherwise
  114.  */
  116. static char *mh_profile = NIL; /* holds MH profile */
  117. static char *mh_path = NIL; /* holds MH path name */
  118. static long mh_once = 0; /* already through this code */
  120. int mh_isvalid (char *name,char *tmp,long synonly)
  121. {
  122.   struct stat sbuf;
  123. /* name must be #MHINBOX or #mh/... */
  124.   if (strcmp (ucase (strcpy (tmp,name)),"#MHINBOX") &&
  125.       !(tmp[0] == '#' && tmp[1] == 'M' && tmp[2] == 'H' && tmp[3] == '/')) {
  126.     errno = EINVAL; /* bogus name */
  127.     return NIL;
  128.   }
  129.   if (!mh_path) { /* have MH path yet? */
  130.     char *s,*t,*v;
  131.     int fd;
  132.     if (mh_once++) return NIL; /* only do this code once */
  133.     if (!mh_profile) { /* have MH profile? */
  134.       sprintf (tmp,"%s/%s",myhomedir (),MHPROFILE);
  135.       mh_profile = cpystr (tmp);
  136.     }
  137.     if ((fd = open (tmp,O_RDONLY,NIL)) < 0) {
  138.       strcat (tmp," not found, mh format names disabled");
  139.       mm_log (tmp,WARN);
  140.       return NIL;
  141.     }
  142.     fstat (fd,&sbuf); /* yes, get size and read file */
  143.     read (fd,(t = (char *) fs_get (sbuf.st_size + 1)),sbuf.st_size);
  144.     close (fd); /* don't need the file any more */
  145.     t[sbuf.st_size] = ''; /* tie it off */
  146. /* parse profile file */
  147.     for (s = strtok (t,"rn"); s && *s; s = strtok (NIL,"rn")) {
  148. /* found space in line? */
  149.       if (v = strpbrk (s," t")) {
  150. *v++ = ''; /* tie off, is keyword "Path:"? */
  151. if (!strcmp (lcase (s),"path:")) {
  152. /* skip whitespace */
  153.   while ((*v == ' ') || (*v == 't')) ++v;
  154.   if (*v == '/') s = v; /* absolute path? */
  155.   else sprintf (s = tmp,"%s/%s",myhomedir (),v);
  156.   mh_path = cpystr (s); /* copy name */
  157.   break; /* don't need to look at rest of file */
  158. }
  159.       }
  160.     }
  161.     fs_give ((void **) &t); /* flush profile text */
  162.     if (!mh_path) { /* default path if not in the profile */
  163.       sprintf (tmp,"%s/%s",myhomedir (),MHPATH);
  164.       mh_path = cpystr (tmp);
  165.     }
  166.   }
  167.   if (synonly) return T; /* all done if syntax only check */
  168.   errno = NIL; /* zap error */
  169. /* validate name as directory */
  170.   return ((stat (mh_file (tmp,name),&sbuf) == 0) &&
  171.   (sbuf.st_mode & S_IFMT) == S_IFDIR);
  172. }
  174. /* MH manipulate driver parameters
  175.  * Accepts: function code
  176.  *     function-dependent value
  177.  * Returns: function-dependent return value
  178.  */
  180. void *mh_parameters (long function,void *value)
  181. {
  182.   switch ((int) function) {
  183.   case SET_MHPROFILE:
  184.     if (mh_profile) fs_give ((void **) &mh_profile);
  185.     mh_profile = cpystr ((char *) value);
  186.     break;
  187.   case GET_MHPROFILE:
  188.     value = (void *) mh_profile;
  189.     break;
  190.   case SET_MHPATH:
  191.     if (mh_path) fs_give ((void **) &mh_path);
  192.     mh_path = cpystr ((char *) value);
  193.     break;
  194.   case GET_MHPATH:
  195.     value = (void *) mh_path;
  196.     break;
  197.   default:
  198.     value = NIL; /* error case */
  199.     break;
  200.   }
  201.   return NIL;
  202. }
  204. /* MH scan mailboxes
  205.  * Accepts: mail stream
  206.  *     reference
  207.  *     pattern to search
  208.  *     string to scan
  209.  */
  211. void mh_scan (MAILSTREAM *stream,char *ref,char *pat,char *contents)
  212. {
  213.   char tmp[MAILTMPLEN];
  214.   if (mh_canonicalize (tmp,ref,pat))
  215.     mm_log ("Scan not valid for mh mailboxes",ERROR);
  216. }
  219. /* MH list mailboxes
  220.  * Accepts: mail stream
  221.  *     reference
  222.  *     pattern to search
  223.  */
  225. void mh_list (MAILSTREAM *stream,char *ref,char *pat)
  226. {
  227.   char *s,test[MAILTMPLEN],file[MAILTMPLEN];
  228.   long i = 0;
  229.   if (!pat || !*pat) { /* empty pattern? */
  230.     if (mh_canonicalize (test,ref,"*")) {
  231. /* tie off name at root */
  232.       if (s = strchr (test,'/')) *++s = '';
  233.       else test[0] = '';
  234.       mm_list (stream,'/',test,LATT_NOSELECT);
  235.     }
  236.   }
  237. /* get canonical form of name */
  238.   else if (mh_canonicalize (test,ref,pat)) {
  239.     if (test[3] == '/') { /* looking down levels? */
  240. /* yes, found any wildcards? */
  241.       if (s = strpbrk (test,"%*")) {
  242. /* yes, copy name up to that point */
  243. strncpy (file,test+4,i = s - (test+4));
  244. file[i] = ''; /* tie off */
  245.       }
  246.       else strcpy (file,test+4);/* use just that name then */
  247. /* find directory name */
  248.       if (s = strrchr (file,'/')) {
  249. *s = ''; /* found, tie off at that point */
  250. s = file;
  251.       }
  252. /* do the work */
  253.       mh_list_work (stream,s,test,0);
  254.     }
  255. /* always an INBOX */
  256.     if (pmatch ("#MHINBOX",ucase (test)))
  257.       mm_list (stream,NIL,"#MHINBOX",LATT_NOINFERIORS);
  258.   }
  259. }
  261. /* MH list subscribed mailboxes
  262.  * Accepts: mail stream
  263.  *     reference
  264.  *     pattern to search
  265.  */
  267. void mh_lsub (MAILSTREAM *stream,char *ref,char *pat)
  268. {
  269.   void *sdb = NIL;
  270.   char *s,test[MAILTMPLEN];
  271. /* get canonical form of name */
  272.   if (mh_canonicalize (test,ref,pat) && (s = sm_read (&sdb))) {
  273.     do if (pmatch_full (s,test,'/')) mm_lsub (stream,'/',s,NIL);
  274.     while (s = sm_read (&sdb)); /* until no more subscriptions */
  275.   }
  276. }
  278. /* MH list mailboxes worker routine
  279.  * Accepts: mail stream
  280.  *     directory name to search
  281.  *     search pattern
  282.  *     search level
  283.  */
  285. void mh_list_work (MAILSTREAM *stream,char *dir,char *pat,long level)
  286. {
  287.   DIR *dp;
  288.   struct direct *d;
  289.   struct stat sbuf;
  290.   char *cp,*np,curdir[MAILTMPLEN],name[MAILTMPLEN];
  291. /* build MH name to search */
  292.   if (dir) sprintf (name,"#mh/%s/",dir);
  293.   else strcpy (name,"#mh/");
  294. /* make directory name, punt if bogus */
  295.   if (!mh_file (curdir,name)) return;
  296.   cp = curdir + strlen (curdir);/* end of directory name */
  297.   np = name + strlen (name); /* end of MH name */
  298.   if (dp = opendir (curdir)) { /* open directory */
  299.     while (d = readdir (dp)) /* scan, ignore . and numeric names */
  300.       if ((d->d_name[0] != '.') && !mh_select (d)) {
  301. strcpy (cp,d->d_name); /* make directory name */
  302. if (!stat (curdir,&sbuf) && ((sbuf.st_mode &= S_IFMT) == S_IFDIR)) {
  303.   strcpy (np,d->d_name);/* make mh name of directory name */
  304. /* yes, an MH name if full match */
  305.   if (pmatch_full (name,pat,'/')) mm_list (stream,'/',name,NIL);
  306. /* check if should recurse */
  307.   if (dmatch (name,pat,'/') &&
  308.       (level < (long) mail_parameters (NIL,GET_LISTMAXLEVEL,NIL)))
  309.     mh_list_work (stream,name+4,pat,level+1);
  310. }
  311.       }
  312.     closedir (dp); /* all done, flush directory */
  313.   }
  314. }
  316. /* MH mail subscribe to mailbox
  317.  * Accepts: mail stream
  318.  *     mailbox to add to subscription list
  319.  * Returns: T on success, NIL on failure
  320.  */
  322. long mh_subscribe (MAILSTREAM *stream,char *mailbox)
  323. {
  324.   return sm_subscribe (mailbox);
  325. }
  328. /* MH mail unsubscribe to mailbox
  329.  * Accepts: mail stream
  330.  *     mailbox to delete from subscription list
  331.  * Returns: T on success, NIL on failure
  332.  */
  334. long mh_unsubscribe (MAILSTREAM *stream,char *mailbox)
  335. {
  336.   return sm_unsubscribe (mailbox);
  337. }
  339. /* MH mail create mailbox
  340.  * Accepts: mail stream
  341.  *     mailbox name to create
  342.  * Returns: T on success, NIL on failure
  343.  */
  345. long mh_create (MAILSTREAM *stream,char *mailbox)
  346. {
  347.   char *s,tmp[MAILTMPLEN];
  348. /* assume error */
  349.   sprintf (tmp,"Can't create mailbox %.80s: invalid MH-format name",mailbox);
  350.   if (mailbox[0] == '#' && (mailbox[1] == 'm' || mailbox[1] == 'M') &&
  351.       (mailbox[2] == 'h' || mailbox[2] == 'H') && mailbox[3] == '/')
  352. /* make sure valid name */
  353.     for (s = mailbox + 4; s && *s;) {
  354.       if (isdigit (*s)) s++; /* digit, check this node further... */
  355. /* all digit node, barf */
  356.       else if (*s == '/') s = NIL;
  357. /* non-digit in node, skip to next node */
  358.       else if (s = strchr (s+1,'/')) s++;
  359.       else tmp[0] = NIL; /* no more nodes, good name */
  360.     }
  361.   if (tmp[0]) { /* was there an error in the name? */
  362.     mm_log (tmp,ERROR); /* yes, log it */
  363.     return NIL;
  364.   }
  365. /* must not already exist */
  366.   if (mh_isvalid (mailbox,tmp,NIL)) {
  367.     sprintf (tmp,"Can't create mailbox %.80s: mailbox already exists",mailbox);
  368.     mm_log (tmp,ERROR);
  369.     return NIL;
  370.   }
  371.   if (!mh_path) return NIL; /* sorry */
  372. /* try to make it */
  373.   if (!(mh_file (tmp,mailbox) && dummy_create_path (stream,strcat (tmp,"/")))){
  374.     sprintf (tmp,"Can't create mailbox %.80s: %s",mailbox,strerror (errno));
  375.     mm_log (tmp,ERROR);
  376.     return NIL;
  377.   }
  378.   return T; /* return success */
  379. }
  381. /* MH mail delete mailbox
  382.  *     mailbox name to delete
  383.  * Returns: T on success, NIL on failure
  384.  */
  386. long mh_delete (MAILSTREAM *stream,char *mailbox)
  387. {
  388.   DIR *dirp;
  389.   struct direct *d;
  390.   int i;
  391.   char tmp[MAILTMPLEN];
  392.   if (!(mailbox[0] == '#' && (mailbox[1] == 'm' || mailbox[1] == 'M') &&
  393. (mailbox[2] == 'h' || mailbox[2] == 'H') && mailbox[3] == '/')) {
  394.     sprintf (tmp,"Can't delete mailbox %.80s: invalid MH-format name",mailbox);
  395.     mm_log (tmp,ERROR);
  396.     return NIL;
  397.   }
  398. /* is mailbox valid? */
  399.   if (!mh_isvalid (mailbox,tmp,NIL)){
  400.     sprintf (tmp,"Can't delete mailbox %.80s: no such mailbox",mailbox);
  401.     mm_log (tmp,ERROR);
  402.     return NIL;
  403.   }
  404. /* get name of directory */
  405.   i = strlen (mh_file (tmp,mailbox));
  406.   if (dirp = opendir (tmp)) { /* open directory */
  407.     tmp[i++] = '/'; /* now apply trailing delimiter */
  408.     while (d = readdir (dirp)) /* massacre all numeric or comma files */
  409.       if (mh_select (d) || (*d->d_name == ',') ||
  410.   !strcmp (d->d_name,MHSEQUENCE)) {
  411. strcpy (tmp + i,d->d_name);
  412. unlink (tmp); /* sayonara */
  413.       }
  414.     closedir (dirp); /* flush directory */
  415.   }
  416. /* try to remove the directory */
  417.   if (rmdir (mh_file (tmp,mailbox))) {
  418.     sprintf (tmp,"Can't delete mailbox %.80s: %s",mailbox,strerror (errno));
  419.     mm_log (tmp,ERROR);
  420.     return NIL;
  421.   }
  422.   return T; /* return success */
  423. }
  425. /* MH mail rename mailbox
  426.  * Accepts: MH mail stream
  427.  *     old mailbox name
  428.  *     new mailbox name
  429.  * Returns: T on success, NIL on failure
  430.  */
  432. long mh_rename (MAILSTREAM *stream,char *old,char *newname)
  433. {
  434.   char c,*s,tmp[MAILTMPLEN],tmp1[MAILTMPLEN];
  435.   struct stat sbuf;
  436.   if (!(old[0] == '#' && (old[1] == 'm' || old[1] == 'M') &&
  437. (old[2] == 'h' || old[2] == 'H') && old[3] == '/'))
  438.     sprintf (tmp,"Can't delete mailbox %.80s: invalid MH-format name",old);
  439. /* old mailbox name must be valid */
  440.   else if (!mh_isvalid (old,tmp,NIL))
  441.     sprintf (tmp,"Can't rename mailbox %.80s: no such mailbox",old);
  442.   else if (!(newname[0] == '#' && (newname[1] == 'm' || newname[1] == 'M') &&
  443. (newname[2] == 'h' || newname[2] == 'H') && newname[3] == '/'))
  444.     sprintf (tmp,"Can't rename to mailbox %.80s: invalid MH-format name",
  445.      newname);
  446. /* new mailbox name must not be valid */
  447.   else if (mh_isvalid (newname,tmp,NIL))
  448.     sprintf (tmp,"Can't rename to mailbox %.80s: destination already exists",
  449.      newname);
  450. /* success if can rename the directory */
  451.   else { /* found superior to destination name? */
  452.     if (s = strrchr (mh_file (tmp1,newname),'/')) {
  453.       c = *++s; /* remember first character of inferior */
  454.       *s = ''; /* tie off to get just superior */
  455. /* name doesn't exist, create it */
  456.       if ((stat (tmp1,&sbuf) || ((sbuf.st_mode & S_IFMT) != S_IFDIR)) &&
  457.   !dummy_create (stream,tmp1)) return NIL;
  458.       *s = c; /* restore full name */
  459.     }
  460.     if (!rename (mh_file (tmp,old),tmp1)) return T;
  461.     sprintf (tmp,"Can't rename mailbox %.80s to %.80s: %s",
  462.      old,newname,strerror (errno));
  463.   }
  464.   mm_log (tmp,ERROR); /* something failed */
  465.   return NIL;
  466. }
  468. /* MH mail open
  469.  * Accepts: stream to open
  470.  * Returns: stream on success, NIL on failure
  471.  */
  473. MAILSTREAM *mh_open (MAILSTREAM *stream)
  474. {
  475.   char tmp[MAILTMPLEN];
  476.   if (!stream) return &mhproto; /* return prototype for OP_PROTOTYPE call */
  477.   if (stream->local) fatal ("mh recycle stream");
  478.   stream->local = fs_get (sizeof (MHLOCAL));
  479. /* note if an INBOX or not */
  480.   stream->inbox = !strcmp (ucase (strcpy (tmp,stream->mailbox)),"#MHINBOX");
  481.   mh_file (tmp,stream->mailbox);/* get directory name */
  482.   LOCAL->dir = cpystr (tmp); /* copy directory name for later */
  483. /* make temporary buffer */
  484.   LOCAL->buf = (char *) fs_get ((LOCAL->buflen = MAXMESSAGESIZE) + 1);
  485.   LOCAL->scantime = 0; /* not scanned yet */
  486.   LOCAL->cachedtexts = 0; /* no cached texts */
  487.   stream->sequence++; /* bump sequence number */
  488. /* parse mailbox */
  489.   stream->nmsgs = stream->recent = 0;
  490.   if (!mh_ping (stream)) return NIL;
  491.   if (!(stream->nmsgs || stream->silent))
  492.     mm_log ("Mailbox is empty",(long) NIL);
  493.   return stream; /* return stream to caller */
  494. }
  496. /* MH mail close
  497.  * Accepts: MAIL stream
  498.  *     close options
  499.  */
  501. void mh_close (MAILSTREAM *stream,long options)
  502. {
  503.   if (LOCAL) { /* only if a file is open */
  504.     int silent = stream->silent;
  505.     stream->silent = T; /* note this stream is dying */
  506.     if (options & CL_EXPUNGE) mh_expunge (stream);
  507.     if (LOCAL->dir) fs_give ((void **) &LOCAL->dir);
  508. /* free local scratch buffer */
  509.     if (LOCAL->buf) fs_give ((void **) &LOCAL->buf);
  510. /* nuke the local data */
  511.     fs_give ((void **) &stream->local);
  512.     stream->dtb = NIL; /* log out the DTB */
  513.     stream->silent = silent; /* reset silent state */
  514.   }
  515. }
  518. /* MH mail fetch fast information
  519.  * Accepts: MAIL stream
  520.  *     sequence
  521.  *     option flags
  522.  */
  524. void mh_fast (MAILSTREAM *stream,char *sequence,long flags)
  525. {
  526.   unsigned long i,j;
  527. /* ugly and slow */
  528.   if (stream && LOCAL && ((flags & FT_UID) ?
  529.   mail_uid_sequence (stream,sequence) :
  530.   mail_sequence (stream,sequence)))
  531.     for (i = 1; i <= stream->nmsgs; i++)
  532.       if (mail_elt (stream,i)->sequence) mh_header (stream,i,&j,NIL);
  533. }
  535. /* MH mail fetch message header
  536.  * Accepts: MAIL stream
  537.  *     message # to fetch
  538.  *     pointer to returned header text length
  539.  *     option flags
  540.  * Returns: message header in RFC822 format
  541.  */
  543. char *mh_header (MAILSTREAM *stream,unsigned long msgno,unsigned long *length,
  544.  long flags)
  545. {
  546.   unsigned long i,hdrsize;
  547.   int fd;
  548.   char *t;
  549.   struct stat sbuf;
  550.   struct tm *tm;
  551.   MESSAGECACHE *elt;
  552.   *length = 0; /* default to empty */
  553.   if (flags & FT_UID) return "";/* UID call "impossible" */
  554.   elt = mail_elt (stream,msgno);/* get elt */
  555.   if (!elt->private.msg.header.text.data) {
  556. /* purge cache if too big */
  557.     if (LOCAL->cachedtexts > max (stream->nmsgs * 4096,2097152)) {
  558.       mail_gc (stream,GC_TEXTS);/* just can't keep that much */
  559.       LOCAL->cachedtexts = 0;
  560.     }
  561. /* build message file name */
  562.     sprintf (LOCAL->buf,"%s/%lu",LOCAL->dir,elt->private.uid);
  563.     if ((fd = open (LOCAL->buf,O_RDONLY,NIL)) < 0) return "";
  564.     fstat (fd,&sbuf); /* get size of message */
  565. /* make plausible IMAPish date string */
  566.     tm = gmtime (&sbuf.st_mtime);
  567.     elt->day = tm->tm_mday; elt->month = tm->tm_mon + 1;
  568.     elt->year = tm->tm_year + 1900 - BASEYEAR;
  569.     elt->hours = tm->tm_hour; elt->minutes = tm->tm_min;
  570.     elt->seconds = tm->tm_sec;
  571.     elt->zhours = 0; elt->zminutes = 0;
  572. /* is buffer big enough? */
  573.     if (sbuf.st_size > LOCAL->buflen) {
  574.       fs_give ((void **) &LOCAL->buf);
  575.       LOCAL->buf = (char *) fs_get ((LOCAL->buflen = sbuf.st_size) + 1);
  576.     }
  577. /* slurp message */
  578.     read (fd,LOCAL->buf,sbuf.st_size);
  579. /* tie off file */
  580.     LOCAL->buf[sbuf.st_size] = '';
  581.     close (fd); /* flush message file */
  582. /* find end of header */
  583.     for (i = 0,t = LOCAL->buf; *t && !(i && (*t == 'n')); i = (*t++ == 'n'));
  584. /* number of header bytes */
  585.     hdrsize = (*t ? ++t : t) - LOCAL->buf;
  586.     elt->rfc822_size = /* size of entire message in CRLF form */
  587.       (elt->private.msg.header.text.size =
  588.        strcrlfcpy ((char **) &elt->private.msg.header.text.data,&i,LOCAL->buf,
  589.    hdrsize)) +
  590.  (elt->private.msg.text.text.size =
  591.   strcrlfcpy ((char **) &elt->private.msg.text.text.data,&i,t,
  592.       sbuf.st_size - hdrsize));
  593. /* add to cached size */
  594.     LOCAL->cachedtexts += elt->rfc822_size;
  595.   }
  596.   *length = elt->private.msg.header.text.size;
  597.   return (char *) elt->private.msg.header.text.data;
  598. }
  600. /* MH mail fetch message text (body only)
  601.  * Accepts: MAIL stream
  602.  *     message # to fetch
  603.  *     pointer to returned stringstruct
  604.  *     option flags
  605.  * Returns: T on success, NIL on failure
  606.  */
  608. long mh_text (MAILSTREAM *stream,unsigned long msgno,STRING *bs,long flags)
  609. {
  610.   unsigned long i;
  611.   MESSAGECACHE *elt;
  612. /* UID call "impossible" */
  613.   if (flags & FT_UID) return NIL;
  614.   elt = mail_elt (stream,msgno);/* get elt */
  615. /* snarf message if don't have it yet */
  616.   if (!elt->private.msg.text.text.data) {
  617.     mh_header (stream,msgno,&i,flags);
  618.     if (!elt->private.msg.text.text.data) return NIL;
  619.   }
  620.   if (!(flags & FT_PEEK)) { /* mark as seen */
  621.     mail_elt (stream,msgno)->seen = T;
  622.     mm_flags (stream,msgno);
  623.   }
  624.   if (!elt->private.msg.text.text.data) return NIL;
  625.   INIT (bs,mail_string,elt->private.msg.text.text.data,
  626. elt->private.msg.text.text.size);
  627.   return T;
  628. }
  630. /* MH mail ping mailbox
  631.  * Accepts: MAIL stream
  632.  * Returns: T if stream alive, else NIL
  633.  */
  635. long mh_ping (MAILSTREAM *stream)
  636. {
  637.   MAILSTREAM *sysibx = NIL;
  638.   MESSAGECACHE *elt,*selt;
  639.   struct stat sbuf;
  640.   char *s,tmp[MAILTMPLEN];
  641.   int fd;
  642.   unsigned long i,j,r,old;
  643.   long nmsgs = stream->nmsgs;
  644.   long recent = stream->recent;
  645.   int silent = stream->silent;
  646.   if (stat (LOCAL->dir,&sbuf)) { /* directory exists? */
  647.     if (stream->inbox) return T;
  648.     sprintf (tmp,"Can't open mailbox %.80s: no such mailbox",stream->mailbox);
  649.     mm_log (tmp,ERROR);
  650.     return NIL;
  651.   }
  652.   stream->silent = T; /* don't pass up mm_exists() events yet */
  653.   if (sbuf.st_ctime != LOCAL->scantime) {
  654.     struct direct **names = NIL;
  655.     long nfiles = scandir (LOCAL->dir,&names,mh_select,mh_numsort);
  656.     if (nfiles < 0) nfiles = 0; /* in case error */
  657.     old = stream->uid_last;
  658. /* note scanned now */
  659.     LOCAL->scantime = sbuf.st_ctime;
  660. /* scan directory */
  661.     for (i = 0; i < nfiles; ++i) {
  662. /* if newly seen, add to list */
  663.       if ((j = atoi (names[i]->d_name)) > old) {
  664. mail_exists (stream,++nmsgs);
  665. stream->uid_last = (elt = mail_elt (stream,nmsgs))->private.uid = j;
  666. elt->valid = T; /* note valid flags */
  667. if (old) { /* other than the first pass? */
  668.   elt->recent = T; /* yup, mark as recent */
  669.   recent++; /* bump recent count */
  670. }
  671. else { /* see if already read */
  672.   sprintf (tmp,"%s/%s",LOCAL->dir,names[i]->d_name);
  673.   stat (tmp,&sbuf); /* get inode poop */
  674.   if (sbuf.st_atime > sbuf.st_mtime) elt->seen = T;
  675. }
  676.       }
  677.       fs_give ((void **) &names[i]);
  678.     }
  679. /* free directory */
  680.     if (s = (void *) names) fs_give ((void **) &s);
  681.   }
  683. /* if INBOX, snarf from system INBOX  */
  684.   if (stream->inbox && strcmp (sysinbox (),stream->mailbox)) {
  685.     old = stream->uid_last;
  686.     mm_critical (stream); /* go critical */
  687.     stat (sysinbox (),&sbuf); /* see if anything there */
  688. /* can get sysinbox mailbox? */
  689.     if (sbuf.st_size && (sysibx = mail_open (sysibx,sysinbox (),OP_SILENT))
  690. && (!sysibx->rdonly) && (r = sysibx->nmsgs)) {
  691.       for (i = 1; i <= r; ++i) {/* for each message in sysinbox mailbox */
  692. /* build file name we will use */
  693. sprintf (LOCAL->buf,"%s/%lu",LOCAL->dir,++old);
  694. /* snarf message from Berkeley mailbox */
  695. selt = mail_elt (sysibx,i);
  696. if (((fd = open (LOCAL->buf,O_WRONLY|O_CREAT|O_EXCL,
  697.  S_IREAD|S_IWRITE)) >= 0) &&
  698.     (s = mail_fetchheader_full (sysibx,i,NIL,&j,FT_INTERNAL)) &&
  699.     (write (fd,s,j) == j) &&
  700.     (s = mail_fetchtext_full (sysibx,i,&j,FT_INTERNAL|FT_PEEK)) &&
  701.     (write (fd,s,j) == j) && !fsync (fd) && !close (fd)) {
  702. /* swell the cache */
  703.   mail_exists (stream,++nmsgs);
  704.   stream->uid_last = /* create new elt, note its file number */
  705.     (elt = mail_elt (stream,nmsgs))->private.uid = old;
  706.   recent++; /* bump recent count */
  707. /* set up initial flags and date */
  708.   elt->valid = elt->recent = T;
  709.   elt->seen = selt->seen;
  710.   elt->deleted = selt->deleted;
  711.   elt->flagged = selt->flagged;
  712.   elt->answered = selt->answered;
  713.   elt->draft = selt->draft;
  714.   elt->day = selt->day;elt->month = selt->month;elt->year = selt->year;
  715.   elt->hours = selt->hours;elt->minutes = selt->minutes;
  716.   elt->seconds = selt->seconds;
  717.   elt->zhours = selt->zhours; elt->zminutes = selt->zminutes;
  718.   mh_setdate (LOCAL->buf,elt);
  719. }
  721. else { /* failed to snarf */
  722.   if (fd) { /* did it ever get opened? */
  723.     mm_log ("Message copy to MH mailbox failed",ERROR);
  724.     close (fd); /* close descriptor */
  725.     unlink (LOCAL->buf);/* flush this file */
  726.   }
  727.   else {
  728.     sprintf (tmp,"Can't add message: %s",strerror (errno));
  729.     mm_log (tmp,ERROR);
  730.   }
  731.   stream->silent = silent;
  732.   return NIL; /* note that something is badly wrong */
  733. }
  734. sprintf (tmp,"%lu",i); /* delete it from the sysinbox */
  735. mail_flag (sysibx,tmp,"\Deleted",ST_SET);
  736.       }
  737.       stat (LOCAL->dir,&sbuf); /* update scan time */
  738.       LOCAL->scantime = sbuf.st_ctime;      
  739.       mail_expunge (sysibx); /* now expunge all those messages */
  740.     }
  741.     if (sysibx) mail_close (sysibx);
  742.     mm_nocritical (stream); /* release critical */
  743.   }
  744.   stream->silent = silent; /* can pass up events now */
  745.   mail_exists (stream,nmsgs); /* notify upper level of mailbox size */
  746.   mail_recent (stream,recent);
  747.   return T; /* return that we are alive */
  748. }
  750. /* MH mail check mailbox
  751.  * Accepts: MAIL stream
  752.  */
  754. void mh_check (MAILSTREAM *stream)
  755. {
  756.   /* Perhaps in the future this will preserve flags */
  757.   if (mh_ping (stream)) mm_log ("Check completed",(long) NIL);
  758. }
  761. /* MH mail expunge mailbox
  762.  * Accepts: MAIL stream
  763.  */
  765. void mh_expunge (MAILSTREAM *stream)
  766. {
  767.   MESSAGECACHE *elt;
  768.   unsigned long i = 1;
  769.   unsigned long n = 0;
  770.   unsigned long recent = stream->recent;
  771.   mm_critical (stream); /* go critical */
  772.   while (i <= stream->nmsgs) { /* for each message */
  773. /* if deleted, need to trash it */
  774.     if ((elt = mail_elt (stream,i))->deleted) {
  775.       sprintf (LOCAL->buf,"%s/%lu",LOCAL->dir,elt->private.uid);
  776.       if (unlink (LOCAL->buf)) {/* try to delete the message */
  777. sprintf (LOCAL->buf,"Expunge of message %lu failed, aborted: %s",i,
  778.  strerror (errno));
  779. mm_log (LOCAL->buf,(long) NIL);
  780. break;
  781.       }
  782. /* note uncached */
  783.       LOCAL->cachedtexts -= ((elt->private.msg.header.text.data ?
  784.       elt->private.msg.header.text.size : 0) +
  785.      (elt->private.msg.text.text.data ?
  786.       elt->private.msg.text.text.size : 0));
  787.       mail_gc_msg (&elt->private.msg,GC_ENV | GC_TEXTS);
  788.       if (elt->recent) --recent;/* if recent, note one less recent message */
  789.       mail_expunged (stream,i); /* notify upper levels */
  790.       n++; /* count up one more expunged message */
  791.     }
  792.     else i++; /* otherwise try next message */
  793.   }
  794.   if (n) { /* output the news if any expunged */
  795.     sprintf (LOCAL->buf,"Expunged %lu messages",n);
  796.     mm_log (LOCAL->buf,(long) NIL);
  797.   }
  798.   else mm_log ("No messages deleted, so no update needed",(long) NIL);
  799.   mm_nocritical (stream); /* release critical */
  800. /* notify upper level of new mailbox size */
  801.   mail_exists (stream,stream->nmsgs);
  802.   mail_recent (stream,recent);
  803. }
  805. /* MH mail copy message(s)
  806.  * Accepts: MAIL stream
  807.  *     sequence
  808.  *     destination mailbox
  809.  *     copy options
  810.  * Returns: T if copy successful, else NIL
  811.  */
  813. long mh_copy (MAILSTREAM *stream,char *sequence,char *mailbox,long options)
  814. {
  815.   STRING st;
  816.   MESSAGECACHE *elt;
  817.   struct stat sbuf;
  818.   int fd;
  819.   unsigned long i;
  820.   char flags[MAILTMPLEN],date[MAILTMPLEN];
  821. /* copy the messages */
  822.   if ((options & CP_UID) ? mail_uid_sequence (stream,sequence) :
  823.       mail_sequence (stream,sequence))
  824.     for (i = 1; i <= stream->nmsgs; i++) 
  825.       if ((elt = mail_elt (stream,i))->sequence) {
  826. sprintf (LOCAL->buf,"%s/%lu",LOCAL->dir,elt->private.uid);
  827. if ((fd = open (LOCAL->buf,O_RDONLY,NIL)) < 0) return NIL;
  828. fstat (fd,&sbuf); /* get size of message */
  829. if (!elt->day) { /* make plausible IMAPish date string */
  830.   struct tm *tm = gmtime (&sbuf.st_mtime);
  831.   elt->day = tm->tm_mday; elt->month = tm->tm_mon + 1;
  832.   elt->year = tm->tm_year + 1900 - BASEYEAR;
  833.   elt->hours = tm->tm_hour; elt->minutes = tm->tm_min;
  834.   elt->seconds = tm->tm_sec;
  835.   elt->zhours = 0; elt->zminutes = 0;
  836. }
  837. /* is buffer big enough? */
  838. if (sbuf.st_size > LOCAL->buflen) {
  839.   fs_give ((void **) &LOCAL->buf);
  840.   LOCAL->buf = (char *) fs_get ((LOCAL->buflen = sbuf.st_size) + 1);
  841. }
  842. /* slurp message */
  843. read (fd,LOCAL->buf,sbuf.st_size);
  844. /* tie off file */
  845. LOCAL->buf[sbuf.st_size] = '';
  846. close (fd); /* flush message file */
  847. INIT (&st,mail_string,(void *) LOCAL->buf,sbuf.st_size);
  848. /* init flag string */
  849. flags[0] = flags[1] = '';
  850. if (elt->seen) strcat (flags," \Seen");
  851. if (elt->deleted) strcat (flags," \Deleted");
  852. if (elt->flagged) strcat (flags," \Flagged");
  853. if (elt->answered) strcat (flags," \Answered");
  854. if (elt->draft) strcat (flags," \Draft");
  855. flags[0] = '('; /* open list */
  856. strcat (flags,")"); /* close list */
  857. mail_date (date,elt); /* generate internal date */
  858. if (!mail_append_full (NIL,mailbox,flags,date,&st)) return NIL;
  859. if (options & CP_MOVE) elt->deleted = T;
  860.       }
  861.   return T; /* return success */
  862. }
  864. /* MH mail append message from stringstruct
  865.  * Accepts: MAIL stream
  866.  *     destination mailbox
  867.  *     stringstruct of messages to append
  868.  * Returns: T if append successful, else NIL
  869.  */
  871. long mh_append (MAILSTREAM *stream,char *mailbox,char *flags,char *date,
  872. STRING *message)
  873. {
  874.   struct direct **names;
  875.   int fd;
  876.   char c,*s,tmp[MAILTMPLEN];
  877.   MESSAGECACHE elt;
  878.   long i,last,nfiles;
  879.   long size = 0;
  880.   long ret = LONGT;
  881.   unsigned long uf;
  882.   /* short f = */ mail_parse_flags (stream ? stream : &mhproto,flags,&uf);
  883.   if (date) { /* want to preserve date? */
  884. /* yes, parse date into an elt */
  885.     if (!mail_parse_date (&elt,date)) {
  886.       sprintf (tmp,"Bad date in append: %.80s",date);
  887.       mm_log (tmp,ERROR);
  888.       return NIL;
  889.     }
  890.   }
  891. /* N.B.: can't use LOCAL->buf for tmp */
  892. /* make sure valid mailbox */
  893.   if (!mh_isvalid (mailbox,tmp,NIL)) switch (errno) {
  894.   case ENOENT: /* no such file? */
  895.     if ((mailbox[0] == '#') && ((mailbox[1] == 'M') || (mailbox[1] == 'm')) &&
  896. ((mailbox[2] == 'H') || (mailbox[2] == 'h')) &&
  897. ((mailbox[3] == 'I') || (mailbox[3] == 'i')) &&
  898. ((mailbox[4] == 'N') || (mailbox[4] == 'n')) &&
  899. ((mailbox[5] == 'B') || (mailbox[5] == 'b')) &&
  900. ((mailbox[6] == 'O') || (mailbox[6] == 'o')) &&
  901. ((mailbox[7] == 'X') || (mailbox[7] == 'x')) && !mailbox[8])
  902.       mh_create (NIL,"INBOX");
  903.     else {
  904.       mm_notify (stream,"[TRYCREATE] Must create mailbox before append",NIL);
  905.       return NIL;
  906.     }
  907. /* falls through */
  908.   case 0: /* merely empty file? */
  909.     break;
  910.   case EINVAL:
  911.     sprintf (tmp,"Invalid MH-format mailbox name: %.80s",mailbox);
  912.     mm_log (tmp,ERROR);
  913.     return NIL;
  914.   default:
  915.     sprintf (tmp,"Not a MH-format mailbox: %.80s",mailbox);
  916.     mm_log (tmp,ERROR);
  917.     return NIL;
  918.   }
  919.   mh_file (tmp,mailbox); /* build file name we will use */
  920.   if ((nfiles = scandir (tmp,&names,mh_select,mh_numsort)) > 0) {
  921. /* largest number */
  922.     last = atoi (names[nfiles-1]->d_name);    
  923.     for (i = 0; i < nfiles; ++i) /* free directory */
  924.       fs_give ((void **) &names[i]);
  925.   }
  926.   else last = 0; /* no messages here yet */
  927.   if (s = (void *) names) fs_give ((void **) &s);
  929.   sprintf (tmp + strlen (tmp),"/%ld",++last);
  930.   if ((fd = open (tmp,O_WRONLY|O_CREAT|O_EXCL,S_IREAD|S_IWRITE)) < 0) {
  931.     sprintf (tmp,"Can't open append message: %s",strerror (errno));
  932.     mm_log (tmp,ERROR);
  933.     return NIL;
  934.   }
  935.   i = SIZE (message); /* get size of message */
  936.   s = (char *) fs_get (i + 1); /* get space for the data */
  937. /* copy the data w/o CR's */
  938.   while (i--) if ((c = SNX (message)) != '15') s[size++] = c;
  939.   mm_critical (stream); /* go critical */
  940. /* write the data */
  941.   if ((write (fd,s,size) < 0) || fsync (fd)) {
  942.     unlink (tmp); /* delete message */
  943.     sprintf (tmp,"Message append failed: %s",strerror (errno));
  944.     mm_log (tmp,ERROR);
  945.     ret = NIL;
  946.   }
  947.   close (fd); /* close the file */
  948. /* set the date for this message */
  949.   if (date) mh_setdate (tmp,&elt);
  951.   mm_nocritical (stream); /* release critical */
  952.   fs_give ((void **) &s); /* flush the buffer */
  953.   return ret;
  954. }
  956. /* Internal routines */
  959. /* MH file name selection test
  960.  * Accepts: candidate directory entry
  961.  * Returns: T to use file name, NIL to skip it
  962.  */
  964. int mh_select (struct direct *name)
  965. {
  966.   char c;
  967.   char *s = name->d_name;
  968.   while (c = *s++) if (!isdigit (c)) return NIL;
  969.   return T;
  970. }
  973. /* MH file name comparision
  974.  * Accepts: first candidate directory entry
  975.  *     second candidate directory entry
  976.  * Returns: negative if d1 < d2, 0 if d1 == d2, postive if d1 > d2
  977.  */
  979. int mh_numsort (const void *d1,const void *d2)
  980. {
  981.   return atoi ((*(struct direct **) d1)->d_name) -
  982.     atoi ((*(struct direct **) d2)->d_name);
  983. }
  986. /* MH mail build file name
  987.  * Accepts: destination string
  988.  *          source
  989.  * Returns: destination
  990.  */
  992. char *mh_file (char *dst,char *name)
  993. {
  994.   char *s,tmp[MAILTMPLEN];
  995. /* build composite name */
  996.   sprintf (dst,"%s/%.900s",mh_path,
  997.    strcmp (ucase (strcpy (tmp,name)),"#MHINBOX") ? name + 4 : "inbox");
  998. /* tie off unnecessary trailing / */
  999.   if ((s = strrchr (dst,'/')) && !s[1] && (s[-1] == '/')) *s = '';
  1000.   return dst;
  1001. }
  1004. /* MH canonicalize name
  1005.  * Accepts: buffer to write name
  1006.  *     reference
  1007.  *     pattern
  1008.  * Returns: T if success, NIL if failure
  1009.  */
  1011. long mh_canonicalize (char *pattern,char *ref,char *pat)
  1012. {
  1013.   char tmp[MAILTMPLEN];
  1014.   if (ref && *ref) { /* have a reference */
  1015.     strcpy (pattern,ref); /* copy reference to pattern */
  1016. /* # overrides mailbox field in reference */
  1017.     if (*pat == '#') strcpy (pattern,pat);
  1018. /* pattern starts, reference ends, with / */
  1019.     else if ((*pat == '/') && (pattern[strlen (pattern) - 1] == '/'))
  1020.       strcat (pattern,pat + 1); /* append, omitting one of the period */
  1021.     else strcat (pattern,pat); /* anything else is just appended */
  1022.   }
  1023.   else strcpy (pattern,pat); /* just have basic name */
  1024.   return (mh_isvalid (pattern,tmp,T));
  1025. }
  1027. /* Set date for message
  1028.  * Accepts: file name
  1029.  *     elt containing date
  1030.  */
  1032. void mh_setdate (char *file,MESSAGECACHE *elt)
  1033. {
  1034.   time_t tp[2];
  1035.   tp[0] = time (0); /* atime is now */
  1036.   tp[1] = mail_longdate (elt); /* modification time */
  1037.   utime (file,tp); /* set the times */
  1038. }