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

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

网络编程

开发平台：

Unix_Linux

mail.c：源码内容
  1. /*
  2.  * Program: Mailbox Access routines
  3.  *
  4.  * Author: Mark Crispin
  5.  * Networks and Distributed Computing
  6.  * Computing & Communications
  7.  * University of Washington
  8.  * Administration Building, AG-44
  9.  * Seattle, WA  98195
  10.  * Internet: MRC@CAC.Washington.EDU
  11.  *
  12.  * Date: 22 November 1989
  13.  * Last Edited: 1 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.  */
  37. #include <ctype.h>
  38. #include <stdio.h>
  39. #include "mail.h"
  40. #include "osdep.h"
  41. #include <time.h>
  42. #include "misc.h"
  43. #include "rfc822.h"
  44. #include "utf8.h"
  45. #include "smtp.h"
  47. /* c-client global data */
  49. /* list of mail drivers */
  50. static DRIVER *maildrivers = NIL;
  51. /* list of authenticators */
  52. static AUTHENTICATOR *mailauthenticators = NIL;
  53. /* alternative network driver pointer */
  54. static NETDRIVER *mailaltdriver = NIL;
  55. /* alternative network driver name */
  56. static char *mailaltdrivername = NIL;
  57. /* pointer to alternate gets function */
  58. static mailgets_t mailgets = NIL;
  59. /* pointer to read progress function */
  60. static readprogress_t mailreadprogress = NIL;
  61. /* mail cache manipulation function */
  62. static mailcache_t mailcache = mm_cache;
  63. /* RFC-822 output generator */
  64. static rfc822out_t mail822out = NIL;
  65. /* SMTP verbose callback */
  66. static smtpverbose_t mailsmtpverbose = mm_dlog;
  67. /* proxy copy routine */
  68. static mailproxycopy_t mailproxycopy = NIL;
  69. /* RFC-822 external line parse */
  70. static parseline_t mailparseline = NIL;
  71. /* RFC-822 external phrase parser */
  72. static parsephrase_t mailparsephrase = NIL;
  73. /* sorted results callback */
  74. static sortresults_t mailsortresults = NIL;
  75. /* threaded results callback */
  76. static threadresults_t mailthreadresults = NIL;
  77. /* supported threaders */
  78. static THREADER mailthreadlist = {
  79.   "ORDEREDSUBJECT",
  80.   mail_thread_orderedsubject,
  81.   NIL
  82. };
  83. /* server name */
  84. static char *servicename = "unknown";
  85. static int expungeatping = T; /* mail_ping() may call mm_expunged() */
  86. static int tryaltfirst = NIL; /* always try alt driver first */
  87. static int notimezones = NIL; /* write timezones in "From " header */
  89. /* Default mail cache handler
  90.  * Accepts: pointer to cache handle
  91.  *     message number
  92.  *     caching function
  93.  * Returns: cache data
  94.  */
  96. void *mm_cache (MAILSTREAM *stream,unsigned long msgno,long op)
  97. {
  98.   size_t n;
  99.   void *ret = NIL;
  100.   unsigned long i;
  101.   switch ((int) op) { /* what function? */
  102.   case CH_INIT: /* initialize cache */
  103.     if (stream->cache) { /* flush old cache contents */
  104.       while (stream->cachesize) {
  105. mm_cache (stream,stream->cachesize,CH_FREE);
  106. mm_cache (stream,stream->cachesize--,CH_FREESORTCACHE);
  107.       }
  108.       fs_give ((void **) &stream->cache);
  109.       fs_give ((void **) &stream->sc);
  110.       stream->nmsgs = 0; /* can't have any messages now */
  111.     }
  112.     break;
  113.   case CH_SIZE: /* (re-)size the cache */
  114.     if (!stream->cache) { /* have a cache already? */
  115. /* no, create new cache */
  116.       n = (stream->cachesize = msgno + CACHEINCREMENT) * sizeof (void *);
  117.       stream->cache = (MESSAGECACHE **) memset (fs_get (n),0,n);
  118.       stream->sc = (SORTCACHE **) memset (fs_get (n),0,n);
  119.     }
  120. /* is existing cache size large neough */
  121.     else if (msgno > stream->cachesize) {
  122.       i = stream->cachesize; /* remember old size */
  123.       n = (stream->cachesize = msgno + CACHEINCREMENT) * sizeof (void *);
  124.       fs_resize ((void **) &stream->cache,n);
  125.       fs_resize ((void **) &stream->sc,n);
  126.       while (i < stream->cachesize) {
  127. stream->cache[i] = NIL;
  128. stream->sc[i++] = NIL;
  129.       }
  130.     }
  131.     break;
  133.   case CH_MAKEELT: /* return elt, make if necessary */
  134.     if (!stream->cache[msgno - 1])
  135.       stream->cache[msgno - 1] = mail_new_cache_elt (msgno);
  136. /* falls through */
  137.   case CH_ELT: /* return elt */
  138.     ret = (void *) stream->cache[msgno - 1];
  139.     break;
  140.   case CH_SORTCACHE: /* return sortcache entry, make if needed */
  141.     if (!stream->sc[msgno - 1]) stream->sc[msgno - 1] =
  142.       (SORTCACHE *) memset (fs_get (sizeof (SORTCACHE)),0,sizeof (SORTCACHE));
  143.     ret = (void *) stream->sc[msgno - 1];
  144.     break;
  145.   case CH_FREE: /* free elt */
  146.     mail_free_elt (&stream->cache[msgno - 1]);
  147.     break;
  148.   case CH_FREESORTCACHE:
  149.     if (stream->sc[msgno - 1]) {
  150.       if (stream->sc[msgno - 1]->from)
  151. fs_give ((void **) &stream->sc[msgno - 1]->from);
  152.       if (stream->sc[msgno - 1]->to)
  153. fs_give ((void **) &stream->sc[msgno - 1]->to);
  154.       if (stream->sc[msgno - 1]->cc)
  155. fs_give ((void **) &stream->sc[msgno - 1]->cc);
  156.       if (stream->sc[msgno - 1]->subject)
  157. fs_give ((void **) &stream->sc[msgno - 1]->subject);
  158.       fs_give ((void **) &stream->sc[msgno - 1]);
  159.     }
  160.     break;
  161.   case CH_EXPUNGE: /* expunge cache slot */
  162.     for (i = msgno - 1; msgno < stream->nmsgs; i++,msgno++) {
  163.       if (stream->cache[i] = stream->cache[msgno])
  164. stream->cache[i]->msgno = msgno;
  165.       stream->sc[i] = stream->sc[msgno];
  166.     }
  167.     stream->cache[i] = NIL; /* top of cache goes away */
  168.     stream->sc[i] = NIL;
  169.     break;
  170.   default:
  171.     fatal ("Bad mm_cache op");
  172.     break;
  173.   }
  174.   return ret;
  175. }
  177. /* Dummy string driver for complete in-memory strings */
  179. STRINGDRIVER mail_string = {
  180.   mail_string_init, /* initialize string structure */
  181.   mail_string_next, /* get next byte in string structure */
  182.   mail_string_setpos /* set position in string structure */
  183. };
  186. /* Initialize mail string structure for in-memory string
  187.  * Accepts: string structure
  188.  *     pointer to string
  189.  *     size of string
  190.  */
  192. void mail_string_init (STRING *s,void *data,unsigned long size)
  193. {
  194. /* set initial string pointers */
  195.   s->chunk = s->curpos = (char *) (s->data = data);
  196. /* and sizes */
  197.   s->size = s->chunksize = s->cursize = size;
  198.   s->data1 = s->offset = 0; /* never any offset */
  199. }
  202. /* Get next character from string
  203.  * Accepts: string structure
  204.  * Returns: character, string structure chunk refreshed
  205.  */
  207. char mail_string_next (STRING *s)
  208. {
  209.   return *s->curpos++; /* return the last byte */
  210. }
  213. /* Set string pointer position
  214.  * Accepts: string structure
  215.  *     new position
  216.  */
  218. void mail_string_setpos (STRING *s,unsigned long i)
  219. {
  220.   s->curpos = s->chunk + i; /* set new position */
  221.   s->cursize = s->chunksize - i;/* and new size */
  222. }
  224. /* Mail routines
  225.  *
  226.  *  mail_xxx routines are the interface between this module and the outside
  227.  * world.  Only these routines should be referenced by external callers.
  228.  *
  229.  *  Note that there is an important difference between a "sequence" and a
  230.  * "message #" (msgno).  A sequence is a string representing a sequence in
  231.  * {"n", "n:m", or combination separated by commas} format, whereas a msgno
  232.  * is a single integer.
  233.  *
  234.  */
  236. /* Mail link driver
  237.  * Accepts: driver to add to list
  238.  */
  240. void mail_link (DRIVER *driver)
  241. {
  242.   DRIVER **d = &maildrivers;
  243.   while (*d) d = &(*d)->next; /* find end of list of drivers */
  244.   *d = driver; /* put driver at the end */
  245.   driver->next = NIL; /* this driver is the end of the list */
  246. }
  248. /* Mail manipulate driver parameters
  249.  * Accepts: mail stream
  250.  *     function code
  251.  *     function-dependent value
  252.  * Returns: function-dependent return value
  253.  */
  255. void *mail_parameters (MAILSTREAM *stream,long function,void *value)
  256. {
  257.   void *r,*ret = NIL;
  258.   DRIVER *d;
  259.   AUTHENTICATOR *a;
  260.   switch ((int) function) {
  261.   case SET_THREADERS:
  262.     fatal ("SET_THREADERS not permitted");
  263.   case GET_THREADERS:
  264.     ret = (stream && stream->dtb) ?
  265.       (*stream->dtb->parameters) (function,stream) : (void *) &mailthreadlist;
  266.     break;
  267.   case SET_NAMESPACE:
  268.     fatal ("SET_NAMESPACE not permitted");
  269.   case GET_NAMESPACE:
  270.     ret = (stream && stream->dtb) ?
  271.       (*stream->dtb->parameters) (function,stream) :
  272. env_parameters (function,stream);
  273.     break;
  274.   case SET_DRIVERS:
  275.     fatal ("SET_DRIVERS not permitted");
  276.   case GET_DRIVERS:
  277.     ret = (void *) maildrivers;
  278.     break;
  279.   case SET_DRIVER:
  280.     fatal ("SET_DRIVER not permitted");
  281.   case GET_DRIVER:
  282.     for (d = maildrivers; d && strcmp (d->name,(char *) value); d = d->next);
  283.     ret = (void *) d;
  284.     break;
  285.   case ENABLE_DRIVER:
  286.     for (d = maildrivers; d && strcmp (d->name,(char *) value); d = d->next);
  287.     if (ret = (void *) d) d->flags &= ~DR_DISABLE;
  288.     break;
  289.   case DISABLE_DRIVER:
  290.     for (d = maildrivers; d && strcmp (d->name,(char *) value); d = d->next);
  291.     if (ret = (void *) d) d->flags |= DR_DISABLE;
  292.     break;
  293.   case ENABLE_AUTHENTICATOR: /* punt on this for the nonce */
  294.     fatal ("ENABLE_AUTHENTICATOR not permitted");
  295.   case DISABLE_AUTHENTICATOR:
  296.     for (a = mailauthenticators;/* scan authenticators */
  297.  a && strcmp (a->name,(char *) value); a = a->next);
  298.     if (a) { /* if authenticator name found */
  299.       a->client = NIL; /* blow it away */
  300.       a->server = NIL;
  301.     }
  302.     break;
  304.   case SET_GETS:
  305.     mailgets = (mailgets_t) value;
  306.   case GET_GETS:
  307.     ret = (void *) mailgets;
  308.     break;
  309.   case SET_READPROGRESS:
  310.     mailreadprogress = (readprogress_t) value;
  311.   case GET_READPROGRESS:
  312.     ret = (void *) mailreadprogress;
  313.     break;
  314.   case SET_CACHE:
  315.     mailcache = (mailcache_t) value;
  316.   case GET_CACHE:
  317.     ret = (void *) mailcache;
  318.     break;
  319.   case SET_RFC822OUTPUT:
  320.     mail822out = (rfc822out_t) value;
  321.   case GET_RFC822OUTPUT:
  322.     ret = (void *) mail822out;
  323.     break;
  324.   case SET_SMTPVERBOSE:
  325.     mailsmtpverbose = (smtpverbose_t) value;
  326.   case GET_SMTPVERBOSE:
  327.     ret = (void *) mailsmtpverbose;
  328.     break;
  329.   case SET_MAILPROXYCOPY:
  330.     mailproxycopy = (mailproxycopy_t) value;
  331.   case GET_MAILPROXYCOPY:
  332.     ret = (void *) mailproxycopy;
  333.     break;
  334.   case SET_PARSELINE:
  335.     mailparseline = (parseline_t) value;
  336.   case GET_PARSELINE:
  337.     ret = (void *) mailparseline;
  338.     break;
  339.   case SET_PARSEPHRASE:
  340.     mailparsephrase = (parsephrase_t) value;
  341.   case GET_PARSEPHRASE:
  342.     ret = (void *) mailparsephrase;
  343.     break;
  344.   case SET_SERVICENAME:
  345.     servicename = (char *) value;
  346.   case GET_SERVICENAME:
  347.     ret = (void *) servicename;
  348.     break;
  349.   case SET_EXPUNGEATPING:
  350.     expungeatping = (int) value;
  351.   case GET_EXPUNGEATPING:
  352.     value = (void *) expungeatping;
  353.     break;
  354.   case SET_SORTRESULTS:
  355.     mailsortresults = (sortresults_t) value;
  356.   case GET_SORTRESULTS:
  357.     ret = (void *) mailsortresults;
  358.     break;
  359.   case SET_THREADRESULTS:
  360.     mailthreadresults = (threadresults_t) value;
  361.   case GET_THREADRESULTS:
  362.     ret = (void *) mailthreadresults;
  363.     break;
  365.   case SET_ALTDRIVER:
  366.     mailaltdriver = (NETDRIVER *) value;
  367.   case GET_ALTDRIVER:
  368.     ret = (void *) mailaltdriver;
  369.     break;
  370.   case SET_ALTDRIVERNAME:
  371.     mailaltdrivername = (char *) value;
  372.   case GET_ALTDRIVERNAME:
  373.     ret = (void *) mailaltdrivername;
  374.     break;
  375.   case SET_TRYALTFIRST:
  376.     tryaltfirst = (int) value;
  377.   case GET_TRYALTFIRST:
  378.     ret = (void *) tryaltfirst;
  379.     break;
  380.   case SET_NOTIMEZONES:
  381.     notimezones = (int) value;
  382.   case GET_NOTIMEZONES:
  383.     ret = (void *) notimezones;
  384.     break;
  386.   default:
  387.     if (stream && stream->dtb) /* if have stream, do for its driver only */
  388.       ret = (*stream->dtb->parameters) (function,value);
  389. /* else do all drivers */
  390.     else for (d = maildrivers; d; d = d->next)
  391.       if (r = (d->parameters) (function,value)) ret = r;
  392. /* then do global values */
  393.     if (r = smtp_parameters (function,value)) ret = r;
  394.     if (r = env_parameters (function,value)) ret = r;
  395.     if (r = tcp_parameters (function,value)) ret = r;
  396.     break;
  397.   }
  398.   return ret;
  399. }
  401. /* Mail validate mailbox name
  402.  * Accepts: MAIL stream
  403.  *     mailbox name
  404.  *     purpose string for error message
  405.  * Return: driver factory on success, NIL on failure
  406.  */
  408. DRIVER *mail_valid (MAILSTREAM *stream,char *mailbox,char *purpose)
  409. {
  410.   char tmp[MAILTMPLEN];
  411.   DRIVER *factory = NIL;
  412.   if (strlen (mailbox) < (NETMAXHOST+NETMAXUSER+NETMAXMBX+NETMAXSRV+50))
  413.     for (factory = maildrivers; factory && 
  414.  ((factory->flags & DR_DISABLE) ||
  415.   ((factory->flags & DR_LOCAL) && (*mailbox == '{')) ||
  416.   !(*factory->valid) (mailbox));
  417.  factory = factory->next);
  418. /* must match stream if not dummy */
  419.   if (factory && stream && (stream->dtb != factory))
  420.     factory = strcmp (factory->name,"dummy") ? NIL : stream->dtb;
  421.   if (!factory && purpose) { /* if want an error message */
  422.     sprintf (tmp,"Can't %s %.80s: %s",purpose,mailbox,(*mailbox == '{') ?
  423.      "invalid remote specification" : "no such mailbox");
  424.     mm_log (tmp,ERROR);
  425.   }
  426.   return factory; /* return driver factory */
  427. }
  429. /* Mail validate network mailbox name
  430.  * Accepts: mailbox name
  431.  *     mailbox driver to validate against
  432.  *     pointer to where to return host name if non-NIL
  433.  *     pointer to where to return mailbox name if non-NIL
  434.  * Returns: driver on success, NIL on failure
  435.  */
  437. DRIVER *mail_valid_net (char *name,DRIVER *drv,char *host,char *mailbox)
  438. {
  439.   NETMBX mb;
  440.   if (!mail_valid_net_parse (name,&mb) || strcmp (mb.service,drv->name))
  441.     return NIL;
  442.   if (host) strcpy (host,mb.host);
  443.   if (mailbox) strcpy (mailbox,mb.mailbox);
  444.   return drv;
  445. }
  448. /* Mail validate network mailbox name
  449.  * Accepts: mailbox name
  450.  *     NETMBX structure to return values
  451.  * Returns: T on success, NIL on failure
  452.  */
  454. long mail_valid_net_parse (char *name,NETMBX *mb)
  455. {
  456.   int i,j;
  457.   char c,*s,*t,*v,tmp[MAILTMPLEN],arg[MAILTMPLEN];
  458. /* initialize structure */
  459.   memset (mb,'',sizeof (NETMBX));
  460. /* have host specification? */
  461.   if (!((*name++ == '{') && (v = strpbrk (name,"/:}")) && (i = v - name) &&
  462. (i < NETMAXHOST) && (t = strchr (v,'}')) && ((j = t - v)<MAILTMPLEN) &&
  463. (strlen (t+1) < (size_t) NETMAXMBX))) return NIL;
  464.   strncpy (mb->host,name,i); /* set host name */
  465.   strncpy (mb->orighost,name,i);
  466.   mb->host[i] = mb->orighost[i] = '';
  467.   strcpy (mb->mailbox,t+1); /* set mailbox name */
  468.   if (t - v) { /* any switches or port specification? */
  469.     strncpy (t = tmp,v,j); /* copy it */
  470.     tmp[j] = ''; /* tie it off */
  471.     c = *t++; /* get first delimiter */
  472.     do switch (c) { /* act based upon the character */
  473.     case ':': /* port specification */
  474.       if (mb->port || !(mb->port = strtoul (t,&t,10))) return NIL;
  475.       c = t ? *t++ : ''; /* get delimiter, advance pointer */
  476.       break;
  478.     case '/': /* switch */
  479. /* find delimiter */
  480.       if (t = strpbrk (s = t,"/:=")) {
  481. c = *t; /* remember delimiter for later */
  482. *t++ = ''; /* tie off switch name */
  483.       }
  484.       else c = ''; /* no delimiter */
  485.       lcase (s); /* coerce switch name to lower case */
  486.       if (c == '=') { /* parse switches which take arguments */
  487. if (*t == '"') { /* quoted string? */
  488.   for (v = arg,i = 0,++t; (c = *t++) != '"';) {
  489. /* quote next character */
  490.     if (c == '\') c = *t++;
  491.     arg[i++] = c;
  492.   }
  493.   c = *t++; /* remember delimiter for later */
  494.   arg[i] = ''; /* tie off argument */
  495. }
  496. else { /* non-quoted argument */
  497.   if (t = strpbrk (v = t,"/:")) {
  498.     c = *t; /* remember delimiter for later */
  499.     *t++ = ''; /* tie off switch name */
  500.   }
  501.   else c = ''; /* no delimiter */
  502.   i = strlen (v); /* length of argument */
  503. }
  504. if (!strcmp (s,"service") && (i < NETMAXSRV)) {
  505.   if (*mb->service) return NIL;
  506.   else strcpy (mb->service,lcase (v));
  507. }
  508. else if (!strcmp (s,"user") && (i < NETMAXUSER)) {
  509.   if (*mb->user) return NIL;
  510.   else strcpy (mb->user,v);
  511. }
  512. else return NIL; /* invalid argument switch */
  513.       }
  515.       else { /* non-argument switch */
  516. if (!strcmp (s,"anonymous")) mb->anoflag = T;
  517. else if (!strcmp (s,"debug")) mb->dbgflag = T;
  518. else if (!strcmp (s,"secure")) mb->secflag = T;
  519. else if (!strcmp (s,"alt")) mb->altflag = mailaltdriver ? T : NIL;
  520. else if (mailaltdriver && mailaltdrivername &&
  521.  !strcmp (s,mailaltdrivername)) mb->altflag = T;
  522. /* service switches below here */
  523. else if (*mb->service) return NIL;
  524. else if (!strncmp (s,"imap",4) &&
  525.  (!s[4] || !strcmp (s+4,"2") || !strcmp (s+4,"2bis") ||
  526.   !strcmp (s+4,"4") || !strcmp (s+4,"4rev1")))
  527.   strcpy (mb->service,"imap");
  528. else if (!strncmp (s,"pop",3) && (!s[3] || !strcmp (s+3,"3")))
  529.   strcpy (mb->service,"pop3");
  530. else if (!strcmp (s,"nntp") || !strcmp (s,"smtp"))
  531.   strcpy (mb->service,s);
  532. else return NIL; /* invalid non-argument switch */
  533.       }
  534.       break;
  535.     default: /* anything else is bogus */
  536.       return NIL;
  537.     } while (c); /* see if anything more to parse */
  538.   }
  539. /* default mailbox name */
  540.   if (!*mb->mailbox) strcpy (mb->mailbox,"INBOX");
  541. /* default service name */
  542.   if (!*mb->service) strcpy (mb->service,"imap");
  543.   return T;
  544. }
  546. /* Mail scan mailboxes for string
  547.  * Accepts: mail stream
  548.  *     reference
  549.  *     pattern to search
  550.  *     contents to search
  551.  */
  553. void mail_scan (MAILSTREAM *stream,char *ref,char *pat,char *contents)
  554. {
  555.   int remote = ((*pat == '{') || (ref && *ref == '{'));
  556.   DRIVER *d;
  557.   if (*pat == '{') ref = NIL; /* ignore reference if pattern is remote */
  558.   if (stream) { /* if have a stream, do it for that stream */
  559.     if ((d = stream->dtb) && d->scan &&
  560. !(((d->flags & DR_LOCAL) && remote)))
  561.       (*d->scan) (stream,ref,pat,contents);
  562.   }
  563. /* otherwise do for all DTB's */
  564.   else for (d = maildrivers; d; d = d->next)
  565.     if (d->scan && !((d->flags & DR_DISABLE) ||
  566.      ((d->flags & DR_LOCAL) && remote)))
  567.       (d->scan) (NIL,ref,pat,contents);
  568. }
  570. /* Mail list mailboxes
  571.  * Accepts: mail stream
  572.  *     reference
  573.  *     pattern to search
  574.  */
  576. void mail_list (MAILSTREAM *stream,char *ref,char *pat)
  577. {
  578.   int remote = ((*pat == '{') || (ref && *ref == '{'));
  579.   DRIVER *d = maildrivers;
  580.   if (*pat == '{') ref = NIL; /* ignore reference if pattern is remote */
  581.   if (stream && stream->dtb) { /* if have a stream, do it for that stream */
  582.     if (!(((d = stream->dtb)->flags & DR_LOCAL) && remote))
  583.       (*d->list) (stream,ref,pat);
  584.   }
  585. /* otherwise do for all DTB's */
  586.   else do if (!((d->flags & DR_DISABLE) ||
  587. ((d->flags & DR_LOCAL) && remote)))
  588.     (d->list) (NIL,ref,pat);
  589.   while (d = d->next); /* until at the end */
  590. }
  593. /* Mail list subscribed mailboxes
  594.  * Accepts: mail stream
  595.  *     pattern to search
  596.  */
  598. void mail_lsub (MAILSTREAM *stream,char *ref,char *pat)
  599. {
  600.   int remote = ((*pat == '{') || (ref && *ref == '{'));
  601.   DRIVER *d = maildrivers;
  602.   if (*pat == '{') ref = NIL; /* ignore reference if pattern is remote */
  603.   if (stream && stream->dtb) { /* if have a stream, do it for that stream */
  604.     if (!(((d = stream->dtb)->flags & DR_LOCAL) && remote))
  605.       (*d->lsub) (stream,ref,pat);
  606.   }
  607. /* otherwise do for all DTB's */
  608.   else do if (!((d->flags & DR_DISABLE) ||
  609. ((d->flags & DR_LOCAL) && remote)))
  610.     (d->lsub) (NIL,ref,pat);
  611.   while (d = d->next); /* until at the end */
  612. }
  614. /* Mail subscribe to mailbox
  615.  * Accepts: mail stream
  616.  *     mailbox to add to subscription list
  617.  * Returns: T on success, NIL on failure
  618.  */
  620. long mail_subscribe (MAILSTREAM *stream,char *mailbox)
  621. {
  622.   DRIVER *factory = mail_valid (stream,mailbox,"subscribe to mailbox");
  623.   return factory ?
  624.     (factory->subscribe ?
  625.      (*factory->subscribe) (stream,mailbox) : sm_subscribe (mailbox)) : NIL;
  626. }
  629. /* Mail unsubscribe to mailbox
  630.  * Accepts: mail stream
  631.  *     mailbox to delete from subscription list
  632.  * Returns: T on success, NIL on failure
  633.  */
  635. long mail_unsubscribe (MAILSTREAM *stream,char *mailbox)
  636. {
  637.   DRIVER *factory = mail_valid (stream,mailbox,NIL);
  638.   return (factory && factory->unsubscribe) ?
  639.     (*factory->unsubscribe) (stream,mailbox) : sm_unsubscribe (mailbox);
  640. }
  642. /* Mail create mailbox
  643.  * Accepts: mail stream
  644.  *     mailbox name to create
  645.  * Returns: T on success, NIL on failure
  646.  */
  648. long mail_create (MAILSTREAM *stream,char *mailbox)
  649. {
  650.   MAILSTREAM *ts;
  651.   char *s,tmp[MAILTMPLEN];
  652.   DRIVER *d;
  653.   if (strlen (mailbox) >= (NETMAXHOST+NETMAXUSER+NETMAXMBX+NETMAXSRV+50)) {
  654.     sprintf (tmp,"Can't create %.80s: %s",mailbox,(*mailbox == '{') ?
  655.      "invalid remote specification" : "no such mailbox");
  656.     mm_log (tmp,ERROR);
  657.     return NIL;
  658.   }
  659. /* create of INBOX invalid */
  660.   if (!strcmp (lcase (strcpy (tmp,mailbox)),"inbox")) {
  661.     mm_log ("Can't create INBOX",ERROR);
  662.     return NIL;
  663.   }
  664.   for (s = mailbox; *s; s++) { /* make sure valid name */
  665.     if (*s & 0x80) { /* reserved for future use with UTF-8 */
  666.       mm_log ("Can't create mailbox name with 8-bit character",ERROR);
  667.       return NIL;
  668.     }
  669. /* validate modified UTF-7 */
  670.     else if (*s == '&') while (*++s != '-') switch (*s) {
  671.       case '':
  672. sprintf (tmp,"Can't create unterminated modified UTF-7 name: %.80s",
  673.  mailbox);
  674. mm_log (tmp,ERROR);
  675. return NIL;
  676.       default: /* must be alphanumeric */
  677. if (!isalnum (*s)) {
  678.   sprintf (tmp,"Can't create invalid modified UTF-7 name: %.80s",
  679.    mailbox);
  680.   mm_log (tmp,ERROR);
  681.   return NIL;
  682. }
  683.       case '+': /* valid modified BASE64 */
  684.       case ',':
  685. break; /* all OK so far */
  686.       }
  687.   }
  689. /* see if special driver hack */
  690.   if (!strncmp (tmp,"#driver.",8)) {
  691. /* tie off name at likely delimiter */
  692.     if (s = strpbrk (tmp+8,"/\:")) *s++ = '';
  693.     else {
  694.       sprintf (tmp,"Can't create mailbox %.80s: bad driver syntax",mailbox);
  695.       mm_log (tmp,ERROR);
  696.       return NIL;
  697.     }
  698.     for (d = maildrivers; d && strcmp (d->name,tmp+8); d = d->next);
  699.     if (d) mailbox += s - tmp; /* skip past driver specification */
  700.     else {
  701.       sprintf (tmp,"Can't create mailbox %.80s: unknown driver",mailbox);
  702.       mm_log (tmp,ERROR);
  703.       return NIL;
  704.     }
  705.   }
  706. /* use stream if one given or deterministic */
  707.   else if ((stream && stream->dtb) ||
  708.    (((*mailbox == '{') || (*mailbox == '#')) &&
  709.     (stream = mail_open (NIL,mailbox,OP_PROTOTYPE | OP_SILENT))))
  710.     d = stream->dtb;
  711.   else if ((*mailbox != '{') && (ts = default_proto (NIL))) d = ts->dtb;
  712.   else { /* failed utterly */
  713.     sprintf (tmp,"Can't create mailbox %.80s: indeterminate format",mailbox);
  714.     mm_log (tmp,ERROR);
  715.     return NIL;
  716.   }
  717.   return (*d->create) (stream,mailbox);
  718. }
  720. /* Mail delete mailbox
  721.  * Accepts: mail stream
  722.  *     mailbox name to delete
  723.  * Returns: T on success, NIL on failure
  724.  */
  726. long mail_delete (MAILSTREAM *stream,char *mailbox)
  727. {
  728.   long ret = NIL;
  729.   DRIVER *dtb = mail_valid (stream,mailbox,"delete mailbox");
  730.   if (((mailbox[0] == 'I') || (mailbox[0] == 'i')) &&
  731.       ((mailbox[1] == 'N') || (mailbox[1] == 'n')) &&
  732.       ((mailbox[2] == 'B') || (mailbox[2] == 'b')) &&
  733.       ((mailbox[3] == 'O') || (mailbox[3] == 'o')) &&
  734.       ((mailbox[4] == 'X') || (mailbox[4] == 'x')) && !mailbox[5]) {
  735.     mm_log ("Can't delete INBOX",ERROR);
  736.   }
  737.   else SAFE_DISPATCH (dtb,ret,mbxdel,(stream,mailbox))
  738.   return ret;
  739. }
  742. /* Mail rename mailbox
  743.  * Accepts: mail stream
  744.  *     old mailbox name
  745.  *     new mailbox name
  746.  * Returns: T on success, NIL on failure
  747.  */
  749. long mail_rename (MAILSTREAM *stream,char *old,char *newname)
  750. {
  751.   long ret = NIL;
  752.   char tmp[MAILTMPLEN];
  753.   DRIVER *dtb = mail_valid (stream,old,"rename mailbox");
  754.   if ((*old != '{') && (*old != '#') && mail_valid (NIL,newname,NIL)) {
  755.     sprintf (tmp,"Can't rename to mailbox %.80s: mailbox already exists",
  756.      newname);
  757.     mm_log (tmp,ERROR);
  758.   }
  759.   else SAFE_DISPATCH (dtb,ret,mbxren,(stream,old,newname))
  760.   return ret;
  761. }
  763. /* Mail status of mailbox
  764.  * Accepts: mail stream
  765.  *     mailbox name
  766.  *     status flags
  767.  * Returns: T on success, NIL on failure
  768.  */
  770. long mail_status (MAILSTREAM *stream,char *mbx,long flags)
  771. {
  772.   long ret = NIL;
  773.   DRIVER *factory = mail_valid (stream,mbx,"get status of mailbox");
  774.   if (factory) { /* use driver's routine if have one */
  775.     if (factory->status) return (*factory->status) (stream,mbx,flags);
  776. /* foolish status of selected mbx? */
  777.     if (stream && !strcmp (mbx,stream->mailbox))
  778.       ret = mail_status_default (stream,mbx,flags);
  779.     else SAFE_FUNCTION (factory,ret,mail_status_default,(stream,mbx,flags))
  780.   }
  781.   return ret;
  782. }
  785. /* Mail status of mailbox default handler
  786.  * Accepts: mail stream
  787.  *     mailbox name
  788.  *     status flags
  789.  * Returns: T on success, NIL on failure
  790.  */
  792. long mail_status_default (MAILSTREAM *stream,char *mbx,long flags)
  793. {
  794.   MAILSTATUS status;
  795.   unsigned long i;
  796.   MAILSTREAM *tstream = NIL;
  797. /* make temporary stream (unless this mbx) */
  798.   if (!stream && !(stream = tstream =
  799.    mail_open (NIL,mbx,OP_READONLY|OP_SILENT))) return NIL;
  800.   status.flags = flags; /* return status values */
  801.   status.messages = stream->nmsgs;
  802.   status.recent = stream->recent;
  803.   if (flags & SA_UNSEEN) /* must search to get unseen messages */
  804.     for (i = 1,status.unseen = 0; i <= stream->nmsgs; i++)
  805.       if (!mail_elt (stream,i)->seen) status.unseen++;
  806.   status.uidnext = stream->uid_last + 1;
  807.   status.uidvalidity = stream->uid_validity;
  808. /* pass status to main program */
  809.   mm_status (stream,mbx,&status);
  810.   if (tstream) mail_close (tstream);
  811.   return T; /* success */
  812. }
  814. /* Mail open
  815.  * Accepts: candidate stream for recycling
  816.  *     mailbox name
  817.  *     open options
  818.  * Returns: stream to use on success, NIL on failure
  819.  */
  821. MAILSTREAM *mail_open (MAILSTREAM *stream,char *name,long options)
  822. {
  823.   int i;
  824.   char *s,tmp[MAILTMPLEN];
  825.   NETMBX mb;
  826.   DRIVER *d;
  827. /* see if special driver hack */
  828.   if ((options & OP_PROTOTYPE) && (name[0] == '#') &&
  829.       ((name[1] == 'D') || (name[1] == 'd')) &&
  830.       ((name[2] == 'R') || (name[2] == 'r')) &&
  831.       ((name[3] == 'I') || (name[3] == 'i')) &&
  832.       ((name[4] == 'V') || (name[4] == 'v')) &&
  833.       ((name[5] == 'E') || (name[5] == 'e')) &&
  834.       ((name[6] == 'R') || (name[6] == 'r')) && (name[7] == '.')) {
  835.     sprintf (tmp,"%.80s",name+8);
  836. /* tie off name at likely delimiter */
  837.     if (s = strpbrk (lcase (tmp),"/\:")) *s++ = '';
  838.     else {
  839.       sprintf (tmp,"Can't resolve mailbox %.80s: bad driver syntax",name);
  840.       mm_log (tmp,ERROR);
  841.       return NIL;
  842.     }
  843.     for (d = maildrivers; d && strcmp (d->name,tmp); d = d->next);
  844.     if (d) return (*d->open) (NIL);
  845.     else {
  846.       sprintf (tmp,"Can't resolve mailbox %.80s: unknown driver",name);
  847.       mm_log (tmp,ERROR);
  848.       return NIL;
  849.     }
  850.   }
  851.   else d = mail_valid (NIL,name,(options & OP_SILENT) ?
  852.        (char *) NIL : "open mailbox");
  854.   if (d) { /* must have a factory */
  855.     if (options & OP_PROTOTYPE) return (*d->open) (NIL);
  856.     if (stream) { /* recycling requested? */
  857. /* yes, recycleable stream? */
  858.       if ((stream->dtb == d) && (d->flags & DR_RECYCLE) &&
  859.   mail_usable_network_stream (stream,name)) {
  860. mail_free_cache(stream);/* yes, clean up stream */
  861. if (stream->mailbox) fs_give ((void **) &stream->mailbox);
  862. /* flush user flags */
  863. for (i = 0; i < NUSERFLAGS; i++)
  864.   if (stream->user_flags[i]) fs_give ((void **)&stream->user_flags[i]);
  865.       }
  866.       else { /* stream not recycleable, babble if net */
  867. if (!stream->silent && stream->dtb && !(stream->dtb->flags&DR_LOCAL) &&
  868.     mail_valid_net_parse (stream->mailbox,&mb)) {
  869.   sprintf (tmp,"Closing connection to %.80s",mb.host);
  870.   mm_log (tmp,(long) NIL);
  871. }
  872. /* flush the old stream */
  873. stream = mail_close (stream);
  874.       }
  875.     }
  876. /* instantiate new stream if not recycling */
  877.     if (!stream) (*mailcache) (stream = (MAILSTREAM *)
  878.        memset (fs_get (sizeof (MAILSTREAM)),0,
  879.        sizeof (MAILSTREAM)),(long) 0,CH_INIT);
  880.     stream->dtb = d; /* set dispatch */
  881. /* set mailbox name */
  882.     stream->mailbox = cpystr (name);
  883. /* initialize stream flags */
  884.     stream->inbox = stream->lock = NIL;
  885.     stream->debug = (options & OP_DEBUG) ? T : NIL;
  886.     stream->rdonly = (options & OP_READONLY) ? T : NIL;
  887.     stream->anonymous = (options & OP_ANONYMOUS) ? T : NIL;
  888.     stream->scache = (options & OP_SHORTCACHE) ? T : NIL;
  889.     stream->silent = (options & OP_SILENT) ? T : NIL;
  890.     stream->halfopen = (options & OP_HALFOPEN) ? T : NIL;
  891.     stream->secure = (options & OP_SECURE) ? T : NIL;
  892.     stream->tryalt = (options & OP_TRYALT) ? T : NIL;
  893.     stream->perm_seen = stream->perm_deleted = stream->perm_flagged =
  894.       stream->perm_answered = stream->perm_draft = stream->kwd_create = NIL;
  895.     stream->uid_nosticky = (d->flags & DR_NOSTICKY) ? T : NIL;
  896.     stream->uid_last = 0; /* default UID validity */
  897.     stream->uid_validity = time (0);
  898. /* have driver open, flush if failed */
  899.     if (!(*d->open) (stream)) stream = mail_close (stream);
  900.   }
  901.   return stream; /* return the stream */
  902. }
  904. /* Mail close
  905.  * Accepts: mail stream
  906.  *     close options
  907.  * Returns: NIL, always
  908.  */
  910. MAILSTREAM *mail_close_full (MAILSTREAM *stream,long options)
  911. {
  912.   int i;
  913.   if (stream) { /* make sure argument given */
  914. /* do the driver's close action */
  915.     if (stream->dtb) (*stream->dtb->close) (stream,options);
  916.     if (stream->mailbox) fs_give ((void **) &stream->mailbox);
  917.     stream->sequence++; /* invalidate sequence */
  918. /* flush user flags */
  919.     for (i = 0; i < NUSERFLAGS; i++)
  920.       if (stream->user_flags[i]) fs_give ((void **) &stream->user_flags[i]);
  921.     mail_free_cache (stream); /* finally free the stream's storage */
  922.     if (!stream->use) fs_give ((void **) &stream);
  924.   }
  925.   return NIL;
  926. }
  928. /* Mail make handle
  929.  * Accepts: mail stream
  930.  * Returns: handle
  931.  *
  932.  *  Handles provide a way to have multiple pointers to a stream yet allow the
  933.  * stream's owner to nuke it or recycle it.
  934.  */
  936. MAILHANDLE *mail_makehandle (MAILSTREAM *stream)
  937. {
  938.   MAILHANDLE *handle = (MAILHANDLE *) fs_get (sizeof (MAILHANDLE));
  939.   handle->stream = stream; /* copy stream */
  940. /* and its sequence */
  941.   handle->sequence = stream->sequence;
  942.   stream->use++; /* let stream know another handle exists */
  943.   return handle;
  944. }
  947. /* Mail release handle
  948.  * Accepts: Mail handle
  949.  */
  951. void mail_free_handle (MAILHANDLE **handle)
  952. {
  953.   MAILSTREAM *s;
  954.   if (*handle) { /* only free if exists */
  955. /* resign stream, flush unreferenced zombies */
  956.     if ((!--(s = (*handle)->stream)->use) && !s->dtb) fs_give ((void **) &s);
  957.     fs_give ((void **) handle); /* now flush the handle */
  958.   }
  959. }
  962. /* Mail get stream handle
  963.  * Accepts: Mail handle
  964.  * Returns: mail stream or NIL if stream gone
  965.  */
  967. MAILSTREAM *mail_stream (MAILHANDLE *handle)
  968. {
  969.   MAILSTREAM *s = handle->stream;
  970.   return (s->dtb && (handle->sequence == s->sequence)) ? s : NIL;
  971. }
  973. /* Mail fetch cache element
  974.  * Accepts: mail stream
  975.  *     message # to fetch
  976.  * Returns: cache element of this message
  977.  * Can also be used to create cache elements for new messages.
  978.  */
  980. MESSAGECACHE *mail_elt (MAILSTREAM *stream,unsigned long msgno)
  981. {
  982.   if (msgno < 1 || msgno > stream->nmsgs) {
  983.     char tmp[MAILTMPLEN];
  984.     sprintf (tmp,"Bad msgno %lu in mail_elt, nmsgs = %lu",msgno,stream->nmsgs);
  985.     fatal (tmp);
  986.   }
  987.   return (MESSAGECACHE *) (*mailcache) (stream,msgno,CH_MAKEELT);
  988. }
  991. /* Mail fetch fast information
  992.  * Accepts: mail stream
  993.  *     sequence
  994.  *     option flags
  995.  *
  996.  * Generally, mail_fetch_structure is preferred
  997.  */
  999. void mail_fetch_fast (MAILSTREAM *stream,char *sequence,long flags)
  1000. {
  1001.    /* do the driver's action */
  1002.   if (stream->dtb && stream->dtb->fast)
  1003.     (*stream->dtb->fast) (stream,sequence,flags);
  1004. }
  1007. /* Mail fetch flags
  1008.  * Accepts: mail stream
  1009.  *     sequence
  1010.  *     option flags
  1011.  */
  1013. void mail_fetch_flags (MAILSTREAM *stream,char *sequence,long flags)
  1014. {
  1015.    /* do the driver's action */
  1016.   if (stream->dtb && stream->dtb->msgflags)
  1017.     (*stream->dtb->msgflags) (stream,sequence,flags);
  1018. }
  1020. /* Mail fetch message overview
  1021.  * Accepts: mail stream
  1022.  *     UID sequence to fetch
  1023.  *     pointer to overview return function
  1024.  */
  1026. void mail_fetch_overview (MAILSTREAM *stream,char *sequence,overview_t ofn)
  1027. {
  1028.   if (stream->dtb && !(stream->dtb->overview &&
  1029.        (*stream->dtb->overview) (stream,sequence,ofn)) &&
  1030.       mail_uid_sequence (stream,sequence) && mail_ping (stream)) {
  1031.     MESSAGECACHE *elt;
  1032.     ENVELOPE *env;
  1033.     OVERVIEW ov;
  1034.     unsigned long i;
  1035.     ov.optional.lines = 0;
  1036.     ov.optional.xref = NIL;
  1037.     for (i = 1; i <= stream->nmsgs; i++)
  1038.       if (((elt = mail_elt (stream,i))->sequence) &&
  1039.   (env = mail_fetch_structure (stream,i,NIL,NIL)) && ofn) {
  1040. ov.subject = env->subject;
  1041. ov.from = env->from;
  1042. ov.date = env->date;
  1043. ov.message_id = env->message_id;
  1044. ov.references = env->references;
  1045. ov.optional.octets = elt->rfc822_size;
  1046. (*ofn) (stream,mail_uid (stream,i),&ov);
  1047.       }
  1048.   }
  1049. }
  1051. /* Mail fetch message structure
  1052.  * Accepts: mail stream
  1053.  *     message # to fetch
  1054.  *     pointer to return body
  1055.  *     option flags
  1056.  * Returns: envelope of this message, body returned in body value
  1057.  *
  1058.  * Fetches the "fast" information as well
  1059.  */
  1061. ENVELOPE *mail_fetch_structure (MAILSTREAM *stream,unsigned long msgno,
  1062. BODY **body,long flags)
  1063. {
  1064.   ENVELOPE **env;
  1065.   BODY **b;
  1066.   MESSAGECACHE *elt;
  1067.   char c,*s,*hdr;
  1068.   unsigned long hdrsize;
  1069.   STRING bs;
  1070. /* do the driver's action if specified */
  1071.   if (stream->dtb && stream->dtb->structure)
  1072.     return (*stream->dtb->structure) (stream,msgno,body,flags);
  1073.   if (flags & FT_UID) { /* UID form of call */
  1074.     if (msgno = mail_msgno (stream,msgno)) flags &= ~FT_UID;
  1075.     else return NIL; /* must get UID/msgno map first */
  1076.   }
  1077.   elt = mail_elt (stream,msgno);/* get elt for real message number */
  1078.   if (stream->scache) { /* short caching */
  1079.     if (msgno != stream->msgno){/* garbage collect if not same message */
  1080.       mail_gc (stream,GC_ENV | GC_TEXTS);
  1081.       stream->msgno = msgno; /* this is the current message now */
  1082.     }
  1083.     env = &stream->env; /* get pointers to envelope and body */
  1084.     b = &stream->body;
  1085.   }
  1086.   else { /* get pointers to elt envelope and body */
  1087.     env = &elt->private.msg.env;
  1088.     b = &elt->private.msg.body;
  1089.   }
  1091.   if (stream->dtb && ((body && !*b) || !*env || (*env)->incomplete)) {
  1092.     mail_free_envelope (env); /* flush old envelope and body */
  1093.     mail_free_body (b);
  1094. /* see if need to fetch the whole thing */
  1095.     if (body || !elt->rfc822_size) {
  1096.       s = (*stream->dtb->header) (stream,msgno,&hdrsize,flags & ~FT_INTERNAL);
  1097. /* make copy in case body fetch smashes it */
  1098.       hdr = (char *) memcpy (fs_get ((size_t) hdrsize+1),s,(size_t) hdrsize);
  1099.       hdr[hdrsize] = ''; /* tie off header */
  1100.       (*stream->dtb->text) (stream,msgno,&bs,(flags & ~FT_INTERNAL) | FT_PEEK);
  1101.       if (!elt->rfc822_size) elt->rfc822_size = hdrsize + SIZE (&bs);
  1102.       if (body) /* only parse body if requested */
  1103. rfc822_parse_msg (env,b,hdr,hdrsize,&bs,BADHOST,stream->dtb->flags);
  1104.       else
  1105. rfc822_parse_msg (env,NIL,hdr,hdrsize,NIL,BADHOST,stream->dtb->flags);
  1106.       fs_give ((void **) &hdr); /* flush header */
  1107.     }
  1108.     else { /* can save memory doing it this way */
  1109.       hdr = (*stream->dtb->header) (stream,msgno,&hdrsize,flags | FT_INTERNAL);
  1110.       c = hdr[hdrsize]; /* preserve what's there */
  1111.       hdr[hdrsize] = ''; /* tie off header */
  1112.       rfc822_parse_msg (env,NIL,hdr,hdrsize,NIL,BADHOST,stream->dtb->flags);
  1113.       hdr[hdrsize] = c; /* restore in case cached data */
  1114.     }
  1115.   }
  1116. /* if need date, have date in envelope? */
  1117.   if (!elt->day && *env && (*env)->date) mail_parse_date (elt,(*env)->date);
  1118. /* sigh, fill in bogus default */
  1119.   if (!elt->day) elt->day = elt->month = 1;
  1120.   if (body) *body = *b; /* return the body */
  1121.   return *env; /* return the envelope */
  1122. }
  1124. /* Mail mark single message (internal use only)
  1125.  * Accepts: mail stream
  1126.  *     elt to mark
  1127.  *     fetch flags
  1128.  */
  1130. static void markseen (MAILSTREAM *stream,MESSAGECACHE *elt,long flags)
  1131. {
  1132.   unsigned long i;
  1133.   char sequence[20];
  1134.   MESSAGECACHE *e;
  1135. /* non-peeking and needs to set Seen? */
  1136.   if (!(flags & FT_PEEK) && !elt->seen) {
  1137.     if (stream->dtb->flagmsg){ /* driver wants per-message call? */
  1138.       elt->valid = NIL; /* do pre-alteration driver call */
  1139.       (*stream->dtb->flagmsg) (stream,elt);
  1140. /* set seen, do post-alteration driver call */
  1141.       elt->seen = elt->valid = T;
  1142.       (*stream->dtb->flagmsg) (stream,elt);
  1143.     }
  1144.     if (stream->dtb->flag) { /* driver wants one-time call?  */
  1145. /* better safe than sorry, save seq bits */
  1146.       for (i = 1; i <= stream->nmsgs; i++) {
  1147. e = mail_elt (stream,i);
  1148. e->private.sequence = e->sequence;
  1149.       }
  1150. /* call driver to set the message */
  1151.       sprintf (sequence,"%lu",elt->msgno);
  1152.       (*stream->dtb->flag) (stream,sequence,"\Seen",ST_SET);
  1153. /* restore sequence bits */
  1154.       for (i = 1; i <= stream->nmsgs; i++) {
  1155. e = mail_elt (stream,i);
  1156. e->sequence = e->private.sequence;
  1157.       }
  1158.     }
  1159.     mm_flags(stream,elt->msgno);/* notify mail program of flag change */
  1160.   }
  1161. }
  1163. /* Mail fetch message
  1164.  * Accepts: mail stream
  1165.  *     message # to fetch
  1166.  *     pointer to returned length
  1167.  *     flags
  1168.  * Returns: message text
  1169.  */
  1171. char *mail_fetch_message (MAILSTREAM *stream,unsigned long msgno,
  1172.   unsigned long *len,long flags)
  1173. {
  1174.   GETS_DATA md;
  1175.   SIZEDTEXT *t;
  1176.   STRING bs;
  1177.   MESSAGECACHE *elt;
  1178.   char *s,*u;
  1179.   unsigned long i,j;
  1180.   if (len) *len = 0; /* default return size */
  1181.   if (flags & FT_UID) { /* UID form of call */
  1182.     if (msgno = mail_msgno (stream,msgno)) flags &= ~FT_UID;
  1183.     else return ""; /* must get UID/msgno map first */
  1184.   }
  1185. /* initialize message data identifier */
  1186.   INIT_GETS (md,stream,msgno,"",0,0);
  1187. /* is data already cached? */
  1188.   if ((t = &(elt = mail_elt (stream,msgno))->private.msg.full.text)->data) {
  1189.     markseen (stream,elt,flags);/* mark message seen */
  1190.     return mail_fetch_text_return (&md,t,len);
  1191.   }
  1192.   if (!stream->dtb) return ""; /* not in cache, must have live driver */
  1193.   if (stream->dtb->msgdata) return
  1194.     ((*stream->dtb->msgdata) (stream,msgno,"",0,0,NIL,flags) && t->data) ?
  1195.       mail_fetch_text_return (&md,t,len) : "";
  1196. /* ugh, have to do this the crufty way */
  1197.   u = mail_fetch_header (stream,msgno,NIL,NIL,&i,flags);
  1198. /* copy in case text method stomps on it */
  1199.   s = (char *) memcpy (fs_get ((size_t) i),u,(size_t) i);
  1200.   if ((*stream->dtb->text) (stream,msgno,&bs,flags)) {
  1201.     t = &stream->text; /* build combined copy */
  1202.     if (t->data) fs_give ((void **) &t->data);
  1203.     t->data = (unsigned char *) fs_get ((t->size = i + SIZE (&bs)) + 1);
  1204.     memcpy (t->data,s,(size_t) i);
  1205.     for (j = i; j < t->size; j++) t->data[j] = SNX (&bs);
  1206.     t->data[j] = ''; /* tie off data */
  1207.     u = mail_fetch_text_return (&md,t,len);
  1208.   }
  1209.   else u = "";
  1210.   fs_give ((void **) &s); /* finished with copy of header */
  1211.   return u;
  1212. }
  1214. /* Mail fetch message header
  1215.  * Accepts: mail stream
  1216.  *     message # to fetch
  1217.  *     MIME section specifier (#.#.#...#)
  1218.  *     list of lines to fetch
  1219.  *     pointer to returned length
  1220.  *     flags
  1221.  * Returns: message header in RFC822 format
  1222.  *
  1223.  * Note: never calls a mailgets routine
  1224.  */
  1226. char *mail_fetch_header (MAILSTREAM *stream,unsigned long msgno,char *section,
  1227.  STRINGLIST *lines,unsigned long *len,long flags)
  1228. {
  1229.   STRING bs;
  1230.   BODY *b = NIL;
  1231.   SIZEDTEXT *t = NIL,rt;
  1232.   MESSAGE *m = NIL;
  1233.   MESSAGECACHE *elt;
  1234.   char tmp[MAILTMPLEN];
  1235.   if (len) *len = 0; /* default return size */
  1236.   if (section && (strlen (section) > (MAILTMPLEN - 20))) return "";
  1237.   if (flags & FT_UID) { /* UID form of call */
  1238.     if (msgno = mail_msgno (stream,msgno)) flags &= ~FT_UID;
  1239.     else return ""; /* must get UID/msgno map first */
  1240.   }
  1241.   elt = mail_elt (stream,msgno);/* get cache data */
  1242.   if (section && *section) { /* nested body header wanted? */
  1243.     if (!((b = mail_body (stream,msgno,section)) &&
  1244.   (b->type == TYPEMESSAGE) && !strcmp (b->subtype,"RFC822")))
  1245.       return ""; /* lose if no body or not MESSAGE/RFC822 */
  1246.     m = b->nested.msg; /* point to nested message */
  1247.   }
  1248. /* else top-level message header wanted */
  1249.   else m = &elt->private.msg;
  1250.   if (m->header.text.data && mail_match_lines (lines,m->lines,flags)) {
  1251.     if (lines) textcpy (t = &stream->text,&m->header.text);
  1252.     else t = &m->header.text; /* in cache, and cache is valid */
  1253.     markseen (stream,elt,flags);/* mark message seen */
  1254.   }
  1256.   else if (stream->dtb) { /* not in cache, has live driver? */
  1257.     if (stream->dtb->msgdata) { /* has driver section fetch? */
  1258. /* build driver section specifier */
  1259.       if (section && *section) sprintf (tmp,"%s.HEADER",section);
  1260.       else strcpy (tmp,"HEADER");
  1261.       if ((*stream->dtb->msgdata) (stream,msgno,tmp,0,0,lines,flags)) {
  1262. t = &m->header.text; /* fetch data */
  1263. /* don't need to postprocess lines */
  1264. if (m->lines) lines = NIL;
  1265. else if (lines) textcpy (t = &stream->text,&m->header.text);
  1266.       }
  1267.     }
  1268.     else if (b) { /* nested body wanted? */
  1269.       if (stream->private.search.text) {
  1270. rt.data = (unsigned char *) stream->private.search.text +
  1271.   b->nested.msg->header.offset;
  1272. rt.size = b->nested.msg->header.text.size;
  1273. t = &rt;
  1274.       }
  1275.       else if ((*stream->dtb->text) (stream,msgno,&bs,flags & ~FT_INTERNAL)) {
  1276. if ((bs.dtb->next == mail_string_next) && !lines) {
  1277.   rt.data = (unsigned char *) bs.curpos + b->nested.msg->header.offset;
  1278.   rt.size = b->nested.msg->header.text.size;
  1279.   if (stream->private.search.string)
  1280.     stream->private.search.text = bs.curpos;
  1281.   t = &rt; /* special hack to avoid extra copy */
  1282. }
  1283. else textcpyoffstring (t = &stream->text,&bs,
  1284.        b->nested.msg->header.offset,
  1285.        b->nested.msg->header.text.size);
  1286.       }
  1287.     }
  1288.     else { /* top-level header fetch */
  1289. /* mark message seen */
  1290.       markseen (stream,elt,flags);
  1291.       if (rt.data = (unsigned char *)
  1292.   (*stream->dtb->header) (stream,msgno,&rt.size,flags)) {
  1293. /* make a safe copy if need to filter */
  1294. if (lines) textcpy (t = &stream->text,&rt);
  1295. else t = &rt; /* top level header */
  1296.       }
  1297.     }
  1298.   }
  1299.   if (!t || !t->data) return "";/* error if no string */
  1300. /* filter headers if requested */
  1301.   if (lines) t->size = mail_filter ((char *) t->data,t->size,lines,flags);
  1302.   if (len) *len = t->size; /* return size if requested */
  1303.   return (char *) t->data; /* and text */
  1304. }
  1306. /* Mail fetch message text
  1307.  * Accepts: mail stream
  1308.  *     message # to fetch
  1309.  *     MIME section specifier (#.#.#...#)
  1310.  *     pointer to returned length
  1311.  *     flags
  1312.  * Returns: message text
  1313.  */
  1315. char *mail_fetch_text (MAILSTREAM *stream,unsigned long msgno,char *section,
  1316.        unsigned long *len,long flags)
  1317. {
  1318.   GETS_DATA md;
  1319.   PARTTEXT *p;
  1320.   STRING bs;
  1321.   MESSAGECACHE *elt;
  1322.   BODY *b = NIL;
  1323.   char tmp[MAILTMPLEN];
  1324.   unsigned long i;
  1325.   if (len) *len = 0; /* default return size */
  1326.   if (section && (strlen (section) > (MAILTMPLEN - 20))) return "";
  1327.   if (flags & FT_UID) { /* UID form of call */
  1328.     if (msgno = mail_msgno (stream,msgno)) flags &= ~FT_UID;
  1329.     else return ""; /* must get UID/msgno map first */
  1330.   }
  1331.   elt = mail_elt (stream,msgno);/* get cache data */
  1332.   if (section && *section) { /* nested body text wanted? */
  1333.     if (!((b = mail_body (stream,msgno,section)) &&
  1334.   (b->type == TYPEMESSAGE) && !strcmp (b->subtype,"RFC822")))
  1335.       return ""; /* lose if no body or not MESSAGE/RFC822 */
  1336.     p = &b->nested.msg->text; /* point at nested message */
  1337. /* build IMAP-format section specifier */
  1338.     sprintf (tmp,"%s.TEXT",section);
  1339.     flags &= ~FT_INTERNAL; /* can't win with this set */
  1340.   }
  1341.   else { /* top-level message text wanted */
  1342.     p = &elt->private.msg.text;
  1343.     strcpy (tmp,"TEXT");
  1344.   }
  1345. /* initialize message data identifier */
  1346.   INIT_GETS (md,stream,msgno,section,0,0);
  1347.   if (p->text.data) { /* is data already cached? */
  1348.     markseen (stream,elt,flags);/* mark message seen */
  1349.     return mail_fetch_text_return (&md,&p->text,len);
  1350.   }
  1351.   if (!stream->dtb) return ""; /* not in cache, must have live driver */
  1352.   if (stream->dtb->msgdata) return
  1353.     ((*stream->dtb->msgdata) (stream,msgno,tmp,0,0,NIL,flags) && p->text.data)?
  1354.       mail_fetch_text_return (&md,&p->text,len) : "";
  1355.   if (!(*stream->dtb->text) (stream,msgno,&bs,flags)) return "";
  1356.   if (section && *section) { /* nested is more complex */
  1357.     SETPOS (&bs,p->offset);
  1358.     i = p->text.size; /* just want this much */
  1359.   }
  1360.   else i = SIZE (&bs); /* want entire text */
  1361.   return mail_fetch_string_return (&md,&bs,i,len);
  1362. }
  1364. /* Mail fetch message body part MIME headers
  1365.  * Accepts: mail stream
  1366.  *     message # to fetch
  1367.  *     MIME section specifier (#.#.#...#)
  1368.  *     pointer to returned length
  1369.  *     flags
  1370.  * Returns: message text
  1371.  */
  1373. char *mail_fetch_mime (MAILSTREAM *stream,unsigned long msgno,char *section,
  1374.        unsigned long *len,long flags)
  1375. {
  1376.   PARTTEXT *p;
  1377.   STRING bs;
  1378.   BODY *b;
  1379.   char tmp[MAILTMPLEN];
  1380.   if (len) *len = 0; /* default return size */
  1381.   if (section && (strlen (section) > (MAILTMPLEN - 20))) return "";
  1382.   if (flags & FT_UID) { /* UID form of call */
  1383.     if (msgno = mail_msgno (stream,msgno)) flags &= ~FT_UID;
  1384.     else return ""; /* must get UID/msgno map first */
  1385.   }
  1386.   flags &= ~FT_INTERNAL; /* can't win with this set */
  1387.   if (!(section && *section && (b = mail_body (stream,msgno,section))))
  1388.     return ""; /* not valid section */
  1389. /* in cache? */
  1390.   if ((p = &b->mime)->text.data) {
  1391. /* mark message seen */
  1392.     markseen (stream,mail_elt (stream,msgno),flags);
  1393.     if (len) *len = p->text.size;
  1394.     return (char *) p->text.data;
  1395.   }
  1396.   if (!stream->dtb) return ""; /* not in cache, must have live driver */
  1397.   if (stream->dtb->msgdata) { /* has driver fetch? */
  1398. /* build driver section specifier */
  1399.     sprintf (tmp,"%s.MIME",section);
  1400.     if ((*stream->dtb->msgdata) (stream,msgno,tmp,0,0,NIL,flags) &&
  1401. p->text.data) {
  1402.       if (len) *len = p->text.size;
  1403.       return (char *) p->text.data;
  1404.     }
  1405.     else return "";
  1406.   }
  1407.   if (len) *len = b->mime.text.size;
  1408.   if (!b->mime.text.size) { /* empty MIME header -- mark seen anyway */
  1409.     markseen (stream,mail_elt (stream,msgno),flags);
  1410.     return "";
  1411.   }
  1412. /* have to get it from offset */
  1413.   if (stream->private.search.text)
  1414.     return stream->private.search.text + b->mime.offset;
  1415.   if (!(*stream->dtb->text) (stream,msgno,&bs,flags)) {
  1416.     if (len) *len = 0;
  1417.     return "";
  1418.   }
  1419.   if (bs.dtb->next == mail_string_next) {
  1420.     if (stream->private.search.string) stream->private.search.text = bs.curpos;
  1421.     return bs.curpos + b->mime.offset;
  1422.   }
  1423.   return textcpyoffstring (&stream->text,&bs,b->mime.offset,b->mime.text.size);
  1424. }
  1426. /* Mail fetch message body part
  1427.  * Accepts: mail stream
  1428.  *     message # to fetch
  1429.  *     MIME section specifier (#.#.#...#)
  1430.  *     pointer to returned length
  1431.  *     flags
  1432.  * Returns: message body
  1433.  */
  1435. char *mail_fetch_body (MAILSTREAM *stream,unsigned long msgno,char *section,
  1436.        unsigned long *len,long flags)
  1437. {
  1438.   GETS_DATA md;
  1439.   PARTTEXT *p;
  1440.   STRING bs;
  1441.   BODY *b;
  1442.   SIZEDTEXT *t;
  1443.   char *s,tmp[MAILTMPLEN];
  1444.   if (!(section && *section)) /* top-level text wanted? */
  1445.     return mail_fetch_message (stream,msgno,len,flags);
  1446.   else if (strlen (section) > (MAILTMPLEN - 20)) return "";
  1447.   flags &= ~FT_INTERNAL; /* can't win with this set */
  1448. /* initialize message data identifier */
  1449.   INIT_GETS (md,stream,msgno,section,0,0);
  1450. /* kludge for old section 0 header */
  1451.   if (!strcmp (s = strcpy (tmp,section),"0") ||
  1452.       ((s = strstr (tmp,".0")) && !s[2])) {
  1453.     SIZEDTEXT ht;
  1454.     *s = ''; /* tie off section */
  1455. /* this silly way so it does mailgets */
  1456.     ht.data = (unsigned char *) mail_fetch_header (stream,msgno,
  1457.    tmp[0] ? tmp : NIL,NIL,
  1458.    &ht.size,flags);
  1459. /* may have UIDs here */
  1460.     md.flags = (flags & FT_UID) ? MG_UID : NIL;
  1461.     return mail_fetch_text_return (&md,&ht,len);
  1462.   }
  1463.   if (len) *len = 0; /* default return size */
  1464.   if (flags & FT_UID) { /* UID form of call */
  1465.     if (msgno = mail_msgno (stream,msgno)) flags &= ~FT_UID;
  1466.     else return ""; /* must get UID/msgno map first */
  1467.   }
  1468. /* must have body */
  1469.   if (!(b = mail_body (stream,msgno,section))) return "";
  1470. /* have cached text? */
  1471.   if ((t = &(p = &b->contents)->text)->data) {
  1472. /* mark message seen */
  1473.     markseen (stream,mail_elt (stream,msgno),flags);
  1474.     return mail_fetch_text_return (&md,t,len);
  1475.   }
  1476.   if (!stream->dtb) return ""; /* not in cache, must have live driver */
  1477.   if (stream->dtb->msgdata) return
  1478.     ((*stream->dtb->msgdata)(stream,msgno,section,0,0,NIL,flags) && t->data) ?
  1479.       mail_fetch_text_return (&md,t,len) : "";
  1480.   if (len) *len = t->size;
  1481.   if (!t->size) { /* empty body part -- mark seen anyway */
  1482.     markseen (stream,mail_elt (stream,msgno),flags);
  1483.     return "";
  1484.   }
  1485. /* copy body from stringstruct offset */
  1486.   if (stream->private.search.text)
  1487.     return stream->private.search.text + p->offset;
  1488.   if (!(*stream->dtb->text) (stream,msgno,&bs,flags)) {
  1489.     if (len) *len = 0;
  1490.     return "";
  1491.   }
  1492.   if (bs.dtb->next == mail_string_next) {
  1493.     if (stream->private.search.string) stream->private.search.text = bs.curpos;
  1494.     return bs.curpos + p->offset;
  1495.   }
  1496.   SETPOS (&bs,p->offset);
  1497.   return mail_fetch_string_return (&md,&bs,t->size,len);
  1498. }
  1500. /* Mail fetch partial message text
  1501.  * Accepts: mail stream
  1502.  *     message # to fetch
  1503.  *     MIME section specifier (#.#.#...#)
  1504.  *     offset of first designed byte or 0 to start at beginning
  1505.  *     maximum number of bytes or 0 for all bytes
  1506.  *     flags
  1507.  * Returns: T if successful, else NIL
  1508.  */
  1510. long mail_partial_text (MAILSTREAM *stream,unsigned long msgno,char *section,
  1511. unsigned long first,unsigned long last,long flags)
  1512. {
  1513.   GETS_DATA md;
  1514.   PARTTEXT *p = NIL;
  1515.   MESSAGECACHE *elt;
  1516.   STRING bs;
  1517.   BODY *b;
  1518.   char tmp[MAILTMPLEN];
  1519.   unsigned long i;
  1520.   if (!mailgets) fatal ("mail_partial_text() called without a mailgets!");
  1521.   if (section && (strlen (section) > (MAILTMPLEN - 20))) return NIL;
  1522.   if (flags & FT_UID) { /* UID form of call */
  1523.     if (msgno = mail_msgno (stream,msgno)) flags &= ~FT_UID;
  1524.     else return NIL; /* must get UID/msgno map first */
  1525.   }
  1526.   elt = mail_elt (stream,msgno);/* get cache data */
  1527.   flags &= ~FT_INTERNAL; /* bogus if this is set */
  1528.   if (section && *section) { /* nested body text wanted? */
  1529.     if (!((b = mail_body (stream,msgno,section)) &&
  1530.   (b->type == TYPEMESSAGE) && !strcmp (b->subtype,"RFC822")))
  1531.       return NIL; /* lose if no body or not MESSAGE/RFC822 */
  1532.     p = &b->nested.msg->text; /* point at nested message */
  1533. /* build IMAP-format section specifier */
  1534.     sprintf (tmp,"%s.TEXT",section);
  1535.   }
  1536.   else { /* else top-level message text wanted */
  1537.     p = &elt->private.msg.text;
  1538.     strcpy (tmp,"TEXT");
  1539.   }
  1541. /* initialize message data identifier */
  1542.   INIT_GETS (md,stream,msgno,tmp,first,last);
  1543.   if (p->text.data) { /* is data already cached? */
  1544.     INIT (&bs,mail_string,p->text.data,i = p->text.size);
  1545.     markseen (stream,elt,flags);/* mark message seen */
  1546.   }
  1547.   else { /* else get data from driver */
  1548.     if (!stream->dtb) return NIL;
  1549.     if (stream->dtb->msgdata) /* driver will handle this */
  1550.       return (*stream->dtb->msgdata) (stream,msgno,tmp,first,last,NIL,flags);
  1551.     if (!(*stream->dtb->text) (stream,msgno,&bs,flags)) return NIL;
  1552.     if (section && *section) { /* nexted if more complex */
  1553.       SETPOS (&bs,p->offset); /* offset stringstruct to data */
  1554.       i = p->text.size; /* maximum size of data */
  1555.     }
  1556.     else i = SIZE (&bs); /* just want this much */
  1557.   }
  1558.   if (i <= first) i = first = 0;/* first byte is beyond end of text */
  1559. /* truncate as needed */
  1560.   else { /* offset and truncate */
  1561.     SETPOS (&bs,first + GETPOS (&bs));
  1562.     i -= first; /* reduced size */
  1563.     if (last && (i > last)) i = last;
  1564.   }
  1565. /* do the mailgets thing */
  1566.   (*mailgets) (mail_read,&bs,i,&md);
  1567.   return T; /* success */
  1568. }
  1570. /* Mail fetch partial message body part
  1571.  * Accepts: mail stream
  1572.  *     message # to fetch
  1573.  *     MIME section specifier (#.#.#...#)
  1574.  *     offset of first designed byte or 0 to start at beginning
  1575.  *     maximum number of bytes or 0 for all bytes
  1576.  *     flags
  1577.  * Returns: T if successful, else NIL
  1578.  */
  1580. long mail_partial_body (MAILSTREAM *stream,unsigned long msgno,char *section,
  1581. unsigned long first,unsigned long last,long flags)
  1582. {
  1583.   GETS_DATA md;
  1584.   PARTTEXT *p;
  1585.   STRING bs;
  1586.   BODY *b;
  1587.   SIZEDTEXT *t;
  1588.   unsigned long i;
  1589.   if (!(section && *section)) /* top-level text wanted? */
  1590.     return mail_partial_text (stream,msgno,NIL,first,last,flags);
  1591.   if (!mailgets) fatal ("mail_partial_body() called without a mailgets!");
  1592.   if (flags & FT_UID) { /* UID form of call */
  1593.     if (msgno = mail_msgno (stream,msgno)) flags &= ~FT_UID;
  1594.     else return NIL; /* must get UID/msgno map first */
  1595.   }
  1596. /* must have body */
  1597.   if (!(b = mail_body (stream,msgno,section))) return NIL;
  1598.   flags &= ~FT_INTERNAL; /* bogus if this is set */
  1600. /* initialize message data identifier */
  1601.   INIT_GETS (md,stream,msgno,section,first,last);
  1602. /* have cached text? */
  1603.   if ((t = &(p = &b->contents)->text)->data) {
  1604. /* mark message seen */
  1605.     markseen (stream,mail_elt (stream,msgno),flags);
  1606.     INIT (&bs,mail_string,t->data,i = t->size);
  1607.   }
  1608.   else { /* else get data from driver */
  1609.     if (!stream->dtb) return NIL;
  1610.     if (stream->dtb->msgdata) /* driver will handle this */
  1611.       return (*stream->dtb->msgdata) (stream,msgno,section,first,last,NIL,
  1612.       flags);
  1613.     if (!(*stream->dtb->text) (stream,msgno,&bs,flags)) return NIL;
  1614.     if (section && *section) { /* nexted if more complex */
  1615.       SETPOS (&bs,p->offset); /* offset stringstruct to data */
  1616.       i = t->size; /* maximum size of data */
  1617.     }
  1618.     else i = SIZE (&bs); /* just want this much */
  1619.   }
  1620.   if (i <= first) i = first = 0;/* first byte is beyond end of text */
  1621.   else { /* offset and truncate */
  1622.     SETPOS (&bs,first + GETPOS (&bs));
  1623.     i -= first; /* reduced size */
  1624.     if (last && (i > last)) i = last;
  1625.   }
  1626. /* do the mailgets thing */
  1627.   (*mailgets) (mail_read,&bs,i,&md);
  1628.   return T; /* success */
  1629. }
  1631. /* Mail return message text
  1632.  * Accepts: identifier data
  1633.  *     sized text
  1634.  *     pointer to returned length
  1635.  * Returns: text
  1636.  */
  1638. char *mail_fetch_text_return (GETS_DATA *md,SIZEDTEXT *t,unsigned long *len)
  1639. {
  1640.   STRING bs;
  1641.   if (len) *len = t->size; /* return size */
  1642.   if (t->size && mailgets) { /* have to do the mailgets thing? */
  1643. /* silly but do it anyway for consistency */
  1644.     INIT (&bs,mail_string,t->data,t->size);
  1645.     return (*mailgets) (mail_read,&bs,t->size,md);
  1646.   }
  1647.   return t->size ? (char *) t->data : "";
  1648. }
  1651. /* Mail return message string
  1652.  * Accepts: identifier data
  1653.  *     stringstruct
  1654.  *     text length
  1655.  *     pointer to returned length
  1656.  * Returns: text
  1657.  */
  1659. char *mail_fetch_string_return (GETS_DATA *md,STRING *bs,unsigned long i,
  1660. unsigned long *len)
  1661. {
  1662.   if (len) *len = i; /* return size */
  1663. /* have to do the mailgets thing? */
  1664.   if (mailgets) return (*mailgets) (mail_read,bs,i,md);
  1665. /* special hack to avoid extra copy */
  1666.   if (bs->dtb->next == mail_string_next) return bs->curpos;
  1667. /* make string copy in memory */
  1668.   return textcpyoffstring (&md->stream->text,bs,GETPOS (bs),i);
  1669. }
  1672. /* Read data from stringstruct
  1673.  * Accepts: stringstruct
  1674.  *     size of data to read
  1675.  *     buffer to read into
  1676.  * Returns: T, always, stringstruct updated
  1677.  */
  1679. long mail_read (void *stream,unsigned long size,char *buffer)
  1680. {
  1681.   STRING *s = (STRING *) stream;
  1682.   while (size--) *buffer++ = SNX (s);
  1683.   return T;
  1684. }
  1686. /* Mail fetch UID
  1687.  * Accepts: mail stream
  1688.  *     message number
  1689.  * Returns: UID or zero if dead stream
  1690.  */
  1692. unsigned long mail_uid (MAILSTREAM *stream,unsigned long msgno)
  1693. {
  1694.   unsigned long uid = mail_elt (stream,msgno)->private.uid;
  1695.   return uid ? uid :
  1696.     (stream->dtb && stream->dtb->uid) ? (*stream->dtb->uid) (stream,msgno) : 0;
  1697. }
  1700. /* Mail fetch msgno from UID (for internal use only)
  1701.  * Accepts: mail stream
  1702.  *     UID
  1703.  * Returns: msgno or zero if failed
  1704.  */
  1706. unsigned long mail_msgno (MAILSTREAM *stream,unsigned long uid)
  1707. {
  1708.   unsigned long msgno;
  1709. /* scan cache for UID */
  1710.   for (msgno = 1; msgno <= stream->nmsgs; msgno++)
  1711.     if (mail_elt (stream,msgno)->private.uid == uid) return msgno;
  1712.   if (stream->dtb) { /* else get it from driver if possible */
  1713. /* direct way */
  1714.     if (stream->dtb->msgno) return (*stream->dtb->msgno) (stream,uid);
  1715.     if (stream->dtb->uid) /* indirect way */
  1716.       for (msgno = 1; msgno <= stream->nmsgs; msgno++)
  1717. if ((*stream->dtb->uid) (stream,msgno) == uid) return msgno;
  1718.   }
  1719.   return 0; /* didn't find the UID anywhere */
  1720. }
  1722. /* Mail fetch From string for menu
  1723.  * Accepts: destination string
  1724.  *     mail stream
  1725.  *     message # to fetch
  1726.  *     desired string length
  1727.  * Returns: string of requested length
  1728.  */
  1730. void mail_fetchfrom (char *s,MAILSTREAM *stream,unsigned long msgno,
  1731.      long length)
  1732. {
  1733.   char *t;
  1734.   char tmp[MAILTMPLEN];
  1735.   ENVELOPE *env = mail_fetchenvelope (stream,msgno);
  1736.   ADDRESS *adr = env ? env->from : NIL;
  1737.   memset (s,' ',(size_t)length);/* fill it with spaces */
  1738.   s[length] = ''; /* tie off with null */
  1739. /* get first from address from envelope */
  1740.   while (adr && !adr->host) adr = adr->next;
  1741.   if (adr) { /* if a personal name exists use it */
  1742.     if (!(t = adr->personal))
  1743.       sprintf (t = tmp,"%.256s@%.256s",adr->mailbox,adr->host);
  1744.     memcpy (s,t,(size_t) min (length,(long) strlen (t)));
  1745.   }
  1746. }
  1749. /* Mail fetch Subject string for menu
  1750.  * Accepts: destination string
  1751.  *     mail stream
  1752.  *     message # to fetch
  1753.  *     desired string length
  1754.  * Returns: string of no more than requested length
  1755.  */
  1757. void mail_fetchsubject (char *s,MAILSTREAM *stream,unsigned long msgno,
  1758. long length)
  1759. {
  1760.   ENVELOPE *env = mail_fetchenvelope (stream,msgno);
  1761.   memset (s,'',(size_t) length+1);
  1762. /* copy subject from envelope */
  1763.   if (env && env->subject) strncpy (s,env->subject,(size_t) length);
  1764.   else *s = ' '; /* if no subject then just a space */
  1765. }
  1767. /* Mail modify flags
  1768.  * Accepts: mail stream
  1769.  *     sequence
  1770.  *     flag(s)
  1771.  *     option flags
  1772.  */
  1774. void mail_flag (MAILSTREAM *stream,char *sequence,char *flag,long flags)
  1775. {
  1776.   MESSAGECACHE *elt;
  1777.   unsigned long i,uf;
  1778.   long f;
  1779.   short nf;
  1780.   if (!stream->dtb) return; /* no-op if no stream */
  1781.   if ((stream->dtb->flagmsg || !stream->dtb->flag) &&
  1782.       ((f = mail_parse_flags (stream,flag,&uf)) || uf) &&
  1783.       ((flags & ST_UID) ? mail_uid_sequence (stream,sequence) :
  1784.        mail_sequence (stream,sequence)))
  1785.     for (i = 1,nf = (flags & ST_SET) ? T : NIL; i <= stream->nmsgs; i++)
  1786.       if ((elt = mail_elt (stream,i))->sequence) {
  1787. struct { /* old flags */
  1788.   unsigned int valid : 1;
  1789.   unsigned int seen : 1;
  1790.   unsigned int deleted : 1;
  1791.   unsigned int flagged : 1;
  1792.   unsigned int answered : 1;
  1793.   unsigned int draft : 1;
  1794.   unsigned long user_flags;
  1795. } old;
  1796. old.valid = elt->valid; old.seen = elt->seen;
  1797. old.deleted = elt->deleted; old.flagged = elt->flagged;
  1798. old.answered = elt->answered; old.draft = elt->draft;
  1799. old.user_flags = elt->user_flags;
  1800. elt->valid = NIL; /* prepare for flag alteration */
  1801. if (stream->dtb->flagmsg) (*stream->dtb->flagmsg) (stream,elt);
  1802. if (f&fSEEN) elt->seen = nf;
  1803. if (f&fDELETED) elt->deleted = nf;
  1804. if (f&fFLAGGED) elt->flagged = nf;
  1805. if (f&fANSWERED) elt->answered = nf;
  1806. if (f&fDRAFT) elt->draft = nf;
  1807. /* user flags */
  1808. if (flags & ST_SET) elt->user_flags |= uf;
  1809. else elt->user_flags &= ~uf;
  1810. elt->valid = T; /* flags now altered */
  1811. if ((old.valid != elt->valid) || (old.seen != elt->seen) ||
  1812.     (old.deleted != elt->deleted) || (old.flagged != elt->flagged) ||
  1813.     (old.answered != elt->answered) || (old.draft != elt->draft) ||
  1814.     (old.user_flags != elt->user_flags)) mm_flags(stream,elt->msgno);
  1815. if (stream->dtb->flagmsg) (*stream->dtb->flagmsg) (stream,elt);
  1816.       }
  1817. /* call driver once */
  1818.   if (stream->dtb->flag) (*stream->dtb->flag) (stream,sequence,flag,flags);
  1819. }
  1821. /* Mail search for messages
  1822.  * Accepts: mail stream
  1823.  *     character set
  1824.  *     search program
  1825.  *     option flags
  1826.  */
  1828. void mail_search_full (MAILSTREAM *stream,char *charset,SEARCHPGM *pgm,
  1829.        long flags)
  1830. {
  1831.   unsigned long i;
  1832.   if (!(flags & SE_RETAIN)) /* clear search vector unless retaining */
  1833.     for (i = 1; i <= stream->nmsgs; ++i) mail_elt (stream,i)->searched = NIL;
  1834.   if (pgm && stream->dtb) { /* must have a search program and driver */
  1835. /* do the driver's action if requested */
  1836.     if (!(flags & SO_NOSERVER) && stream->dtb->search)
  1837.       (*stream->dtb->search) (stream,charset,pgm,flags);
  1838.     else mail_search_default (stream,charset,pgm,flags);
  1839.   }
  1840. /* flush search program if requested */
  1841.   if (flags & SE_FREE) mail_free_searchpgm (&pgm);
  1842. }
  1845. /* Mail search for messages default handler
  1846.  * Accepts: mail stream
  1847.  *     character set
  1848.  *     search program
  1849.  *     option flags
  1850.  */
  1852. void mail_search_default (MAILSTREAM *stream,char *charset,SEARCHPGM *pgm,
  1853.   long flags)
  1854. {
  1855.   unsigned long i;
  1856.   if (charset && *charset && /* convert if charset not US-ASCII or UTF-8 */
  1857.       !(((charset[0] == 'U') || (charset[0] == 'u')) &&
  1858. ((((charset[1] == 'S') || (charset[1] == 's')) &&
  1859.   (charset[2] == '-') &&
  1860.   ((charset[3] == 'A') || (charset[3] == 'a')) &&
  1861.   ((charset[4] == 'S') || (charset[4] == 's')) &&
  1862.   ((charset[5] == 'C') || (charset[5] == 'c')) &&
  1863.   ((charset[6] == 'I') || (charset[6] == 'i')) &&
  1864.   ((charset[7] == 'I') || (charset[7] == 'i')) && !charset[8]) ||
  1865.  (((charset[1] == 'T') || (charset[1] == 't')) &&
  1866.   ((charset[2] == 'F') || (charset[2] == 'f')) &&
  1867.   (charset[3] == '-') && (charset[4] == '8') && !charset[5])))) {
  1868.     if (utf8_text (NIL,charset,NIL,T)) utf8_searchpgm (pgm,charset);
  1869.     else return; /* charset unknown */
  1870.   }
  1871.   for (i = 1; i <= stream->nmsgs; ++i) if (mail_search_msg (stream,i,NIL,pgm)){
  1872.     if (flags & SE_UID) mm_searched (stream,mail_uid (stream,i));
  1873.     else { /* mark as searched, notify mail program */
  1874.       mail_elt (stream,i)->searched = T;
  1875.       if (!stream->silent) mm_searched (stream,i);
  1876.     }
  1877.   }
  1878. }
  1880. /* Mail ping mailbox
  1881.  * Accepts: mail stream
  1882.  * Returns: stream if still open else NIL
  1883.  */
  1885. long mail_ping (MAILSTREAM *stream)
  1886. {
  1887.    /* do the driver's action */
  1888.   return stream->dtb ? (*stream->dtb->ping) (stream) : NIL;
  1889. }
  1892. /* Mail check mailbox
  1893.  * Accepts: mail stream
  1894.  */
  1896. void mail_check (MAILSTREAM *stream)
  1897. {
  1898.    /* do the driver's action */
  1899.   if (stream->dtb) (*stream->dtb->check) (stream);
  1900. }
  1903. /* Mail expunge mailbox
  1904.  * Accepts: mail stream
  1905.  */
  1907. void mail_expunge (MAILSTREAM *stream)
  1908. {
  1909.    /* do the driver's action */
  1910.   if (stream->dtb) (*stream->dtb->expunge) (stream);
  1911. }
  1914. /* Mail copy message(s)
  1915.  * Accepts: mail stream
  1916.  *     sequence
  1917.  *     destination mailbox
  1918.  *     flags
  1919.  */
  1921. long mail_copy_full (MAILSTREAM *stream,char *sequence,char *mailbox,
  1922.      long options)
  1923. {
  1924.   long ret = NIL;
  1925.   SAFE_DISPATCH (stream->dtb,ret,copy,(stream,sequence,mailbox,options))
  1926.   return ret;
  1927. }
  1929. /* Mail append message string
  1930.  * Accepts: mail stream
  1931.  *     destination mailbox
  1932.  *     initial flags
  1933.  *     message internal date
  1934.  *     stringstruct of message to append
  1935.  * Returns: T on success, NIL on failure
  1936.  */
  1938. long mail_append_full (MAILSTREAM *stream,char *mailbox,char *flags,char *date,
  1939.        STRING *message)
  1940. {
  1941.   long ret = NIL;
  1942.   char *s,tmp[MAILTMPLEN];
  1943.   DRIVER *d = NIL;
  1944.   if (strlen (mailbox) >= (NETMAXHOST+NETMAXUSER+NETMAXMBX+NETMAXSRV+50)) {
  1945.     sprintf (tmp,"Can't append %.80s: %s",mailbox,(*mailbox == '{') ?
  1946.      "invalid remote specification" : "no such mailbox");
  1947.     mm_log (tmp,ERROR);
  1948.     return NIL;
  1949.   }
  1950. /* see if special driver hack */
  1951.   if (strncmp (lcase (strcpy (tmp,mailbox)),"#driver.",8))
  1952.     d = mail_valid (stream,mailbox,NIL);
  1953.   else { /* it is, tie off name at likely delimiter */
  1954.     if (!(s = strpbrk (tmp+8,"/\:"))) {
  1955.       sprintf (tmp,"Can't append to mailbox %.80s: bad driver syntax",mailbox);
  1956.       mm_log (tmp,ERROR);
  1957.     }
  1958.     else { /* found delimiter */
  1959.       *s++ = '';
  1960.       for (d = maildrivers; d && strcmp (d->name,tmp+8); d = d->next);
  1961.       if (d) mailbox += s - tmp;/* skip past driver specification */
  1962.       else {
  1963. sprintf (tmp,"Can't append to mailbox %.80s: unknown driver",mailbox);
  1964. mm_log (tmp,ERROR);
  1965.       }
  1966.     }
  1967.   }
  1968. /* do append if have a driver */
  1969.   SAFE_DISPATCH (d,ret,append,(stream,mailbox,flags,date,message))
  1970.   else { /* failed, try for TRYCREATE if no stream */
  1971.     if (!stream && (stream = default_proto (T)))
  1972.       SAFE_FUNCTION (stream->dtb,ret,(*stream->dtb->append),
  1973.      (stream,mailbox,flags,date,message))
  1974. /* timing race? */
  1975.     if (ret) mm_notify (stream,"Append validity confusion",WARN);
  1976. /* now generate error message */
  1977.     else mail_valid (stream,mailbox,"append to mailbox");
  1978.   }
  1979.   return ret;
  1980. }
  1982. /* Mail garbage collect stream
  1983.  * Accepts: mail stream
  1984.  *     garbage collection flags
  1985.  */
  1987. void mail_gc (MAILSTREAM *stream,long gcflags)
  1988. {
  1989.   MESSAGECACHE *elt;
  1990.   unsigned long i;
  1991.    /* do the driver's action first */
  1992.   if (stream->dtb && stream->dtb->gc) (*stream->dtb->gc) (stream,gcflags);
  1993.   stream->msgno = 0; /* nothing cached now */
  1994.   if (gcflags & GC_ENV) { /* garbage collect envelopes? */
  1995.     if (stream->env) mail_free_envelope (&stream->env);
  1996.     if (stream->body) mail_free_body (&stream->body);
  1997.   }
  1998.   if (gcflags & GC_TEXTS) { /* free texts */
  1999.     if (stream->text.data) fs_give ((void **) &stream->text.data);
  2000.     stream->text.size = 0;
  2001.   }
  2002. /* garbage collect per-message stuff */
  2003.   for (i = 1; i <= stream->nmsgs; i++) 
  2004.     if (elt = (MESSAGECACHE *) (*mailcache) (stream,i,CH_ELT))
  2005.       mail_gc_msg (&elt->private.msg,gcflags);
  2006. }
  2009. /* Mail garbage collect message
  2010.  * Accepts: message structure
  2011.  *     garbage collection flags
  2012.  */
  2014. void mail_gc_msg (MESSAGE *msg,long gcflags)
  2015. {
  2016.   if (gcflags & GC_ENV) { /* garbage collect envelopes? */
  2017.     mail_free_envelope (&msg->env);
  2018.     mail_free_body (&msg->body);
  2019.   }
  2020.   if (gcflags & GC_TEXTS) { /* garbage collect texts */
  2021.     if (msg->full.text.data) fs_give ((void **) &msg->full.text.data);
  2022.     if (msg->header.text.data) {
  2023.       mail_free_stringlist (&msg->lines);
  2024.       fs_give ((void **) &msg->header.text.data);
  2025.     }
  2026.     if (msg->text.text.data) fs_give ((void **) &msg->text.text.data);
  2027. /* now GC all body components */
  2028.     if (msg->body) mail_gc_body (msg->body);
  2029.   }
  2030. }
  2032. /* Mail garbage collect texts in BODY structure
  2033.  * Accepts: BODY structure
  2034.  */
  2036. void mail_gc_body (BODY *body)
  2037. {
  2038.   PART *part;
  2039.   switch (body->type) { /* free contents */
  2040.   case TYPEMULTIPART: /* multiple part */
  2041.     for (part = body->nested.part; part; part = part->next)
  2042.       mail_gc_body (&part->body);
  2043.     break;
  2044.   case TYPEMESSAGE: /* encapsulated message */
  2045.     if (body->subtype && !strcmp (body->subtype,"RFC822")) {
  2046.       mail_free_stringlist (&body->nested.msg->lines);
  2047.       mail_gc_msg (body->nested.msg,GC_TEXTS);
  2048.     }
  2049.     break;
  2050.   default:
  2051.     break;
  2052.   }
  2053.   if (body->mime.text.data) fs_give ((void **) &body->mime.text.data);
  2054.   if (body->contents.text.data) fs_give ((void **) &body->contents.text.data);
  2055. }
  2057. /* Mail get body part
  2058.  * Accepts: mail stream
  2059.  *     message number
  2060.  *     section specifier
  2061.  * Returns: pointer to body
  2062.  */
  2064. BODY *mail_body (MAILSTREAM *stream,unsigned long msgno,char *section)
  2065. {
  2066.   BODY *b;
  2067.   PART *pt;
  2068.   unsigned long i;
  2069.   char tmp[MAILTMPLEN];
  2070. /* make sure have a body */
  2071.   if (!(section && *section && (strlen (section) < (MAILTMPLEN - 20)) &&
  2072. mail_fetchstructure (stream,msgno,&b) && b)) return NIL;
  2073. /* find desired section */
  2074.   if (section) for (section = ucase (strcpy (tmp,section)); *section;) {
  2075.     if (isdigit (*section)) { /* get section specifier */
  2076. /* make sure what follows is valid */
  2077.       if (!(i = strtoul (section,&section,10)) ||
  2078.   (*section && ((*section++ != '.') || !*section))) return NIL;
  2079. /* multipart content? */
  2080.       if (b->type == TYPEMULTIPART) {
  2081. /* yes, find desired part */
  2082. if (pt = b->nested.part) while (--i && (pt = pt->next));
  2083. if (!pt) return NIL; /* bad specifier */
  2084. b = &pt->body; /* note new body */
  2085.       }
  2086. /* otherwise must be section 1 */
  2087.       else if (i != 1) return NIL;
  2088. /* need to go down further? */
  2089.       if (*section) switch (b->type) {
  2090.       case TYPEMULTIPART: /* multipart */
  2091. break;
  2092.       case TYPEMESSAGE: /* embedded message */
  2093. if (!strcmp (b->subtype,"RFC822")) {
  2094.   b = b->nested.msg->body;
  2095.   break;
  2096. }
  2097.       default: /* bogus subpart specification */
  2098. return NIL;
  2099.       }
  2100.     }
  2101.     else return NIL; /* unknown section specifier */
  2102.   }
  2103.   return b;
  2104. }  
  2106. /* Mail output date from elt fields
  2107.  * Accepts: character string to write into
  2108.  *     elt to get data data from
  2109.  * Returns: the character string
  2110.  */
  2112. const char *days[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
  2114. const char *months[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
  2115. "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
  2117. char *mail_date (char *string,MESSAGECACHE *elt)
  2118. {
  2119.   const char *s = (elt->month && elt->month < 13) ?
  2120.     months[elt->month - 1] : (const char *) "???";
  2121.   sprintf (string,"%2d-%s-%d %02d:%02d:%02d %c%02d%02d",
  2122.    elt->day,s,elt->year + BASEYEAR,
  2123.    elt->hours,elt->minutes,elt->seconds,
  2124.    elt->zoccident ? '-' : '+',elt->zhours,elt->zminutes);
  2125.   return string;
  2126. }
  2129. /* Mail output cdate format date from elt fields
  2130.  * Accepts: character string to write into
  2131.  *     elt to get data data from
  2132.  * Returns: the character string
  2133.  */
  2135. char *mail_cdate (char *string,MESSAGECACHE *elt)
  2136. {
  2137.   char *fmt = "%s %s %2d %02d:%02d:%02d %4d %s%02d%02dn";
  2138.   const char *s = (elt->month && elt->month < 13) ?
  2139.     months[elt->month - 1] : (const char *) "???";
  2140.   int m = elt->month;
  2141.   int y = elt->year + BASEYEAR;
  2142.   if (elt->month <= 2) { /* if before March, */
  2143.     m = elt->month + 9; /* January = month 10 of previous year */
  2144.     y--;
  2145.   }
  2146.   else m = elt->month - 3; /* March is month 0 */
  2147.   sprintf (string,fmt,days[(int)(elt->day+2+((7+31*m)/12)+y+(y/4)
  2148. #ifndef USEORTHODOXCALENDAR /* Gregorian calendar */
  2149.       +(y / 400) - (y / 100)
  2150. #ifdef Y4KBUGFIX
  2151.       - (y / 4000)
  2152. #endif
  2153. #else /* Orthodox calendar */
  2154.       +(2*(y/900))+((y%900) >= 200)+((y%900) >= 600) - (y/100)
  2155. #endif
  2156.       ) % 7],s,
  2157.    elt->day,elt->hours,elt->minutes,elt->seconds,elt->year + BASEYEAR,
  2158.    elt->zoccident ? "-" : "+",elt->zhours,elt->zminutes);
  2159.   return string;
  2160. }
  2162. /* Mail parse date into elt fields
  2163.  * Accepts: elt to write into
  2164.  *     date string to parse
  2165.  * Returns: T if parse successful, else NIL 
  2166.  * This routine parses dates as follows:
  2167.  * . leading three alphas followed by comma and space are ignored
  2168.  * . date accepted in format: mm/dd/yy, mm/dd/yyyy, dd-mmm-yy, dd-mmm-yyyy,
  2169.  *    dd mmm yy, dd mmm yyyy
  2170.  * . space or end of string required
  2171.  * . time accepted in format hh:mm:ss or hh:mm
  2172.  * . end of string accepted
  2173.  * . timezone accepted: hyphen followed by symbolic timezone, or space
  2174.  *    followed by signed numeric timezone or symbolic timezone
  2175.  * Examples of normal input:
  2176.  * . IMAP date-only (SEARCH): dd-mmm-yy, dd-mmm-yyyy, mm/dd/yy, mm/dd/yyyy
  2177.  * . IMAP date-time (INTERNALDATE):
  2178.  *    dd-mmm-yy hh:mm:ss-zzz
  2179.  *    dd-mmm-yyyy hh:mm:ss +zzzz
  2180.  * . RFC-822:
  2181.  *    www, dd mmm yy hh:mm:ss zzz
  2182.  *    www, dd mmm yyyy hh:mm:ss +zzzz
  2183.  */
  2185. long mail_parse_date (MESSAGECACHE *elt,char *s)
  2186. {
  2187.   unsigned long d,m,y;
  2188.   int mi,ms;
  2189.   struct tm *t;
  2190.   time_t tn;
  2191.   char tmp[MAILTMPLEN];
  2192. /* clear elt */
  2193.   elt->zoccident = elt->zhours = elt->zminutes =
  2194.     elt->hours = elt->minutes = elt->seconds =
  2195.       elt->day = elt->month = elt->year = 0;
  2196. /* make a writeable uppercase copy */
  2197.   if (s && *s && (strlen (s) < (size_t)MAILTMPLEN)) s = ucase (strcpy (tmp,s));
  2198.   else return NIL;
  2199. /* skip over possible day of week */
  2200.   if (isalpha (*s) && isalpha (s[1]) && isalpha (s[2]) && (s[3] == ',') &&
  2201.       (s[4] == ' ')) s += 5;
  2202.   while (*s == ' ') s++; /* parse first number (probable month) */
  2203.   if (!(m = strtoul ((const char *) s,&s,10))) return NIL;
  2205.   switch (*s) { /* different parse based on delimiter */
  2206.   case '/': /* mm/dd/yy format */
  2207.     if (!((d = strtoul ((const char *) ++s,&s,10)) && *s == '/' &&
  2208.   (y = strtoul ((const char *) ++s,&s,10)) && *s == '')) return NIL;
  2209.     break;
  2210.   case ' ': /* dd mmm yy format */
  2211.     while (s[1] == ' ') s++; /* slurp extra whitespace */
  2212.   case '-': /* dd-mmm-yy format */
  2213.     d = m; /* so the number we got is a day */
  2214. /* make sure string long enough! */
  2215.     if (strlen (s) < (size_t) 5) return NIL;
  2216.     /* Some compilers don't allow `<<' and/or longs in case statements. */
  2217. /* slurp up the month string */
  2218.     ms = ((s[1] - 'A') * 1024) + ((s[2] - 'A') * 32) + (s[3] - 'A');
  2219.     switch (ms) { /* determine the month */
  2220.     case (('J'-'A') * 1024) + (('A'-'A') * 32) + ('N'-'A'): m = 1; break;
  2221.     case (('F'-'A') * 1024) + (('E'-'A') * 32) + ('B'-'A'): m = 2; break;
  2222.     case (('M'-'A') * 1024) + (('A'-'A') * 32) + ('R'-'A'): m = 3; break;
  2223.     case (('A'-'A') * 1024) + (('P'-'A') * 32) + ('R'-'A'): m = 4; break;
  2224.     case (('M'-'A') * 1024) + (('A'-'A') * 32) + ('Y'-'A'): m = 5; break;
  2225.     case (('J'-'A') * 1024) + (('U'-'A') * 32) + ('N'-'A'): m = 6; break;
  2226.     case (('J'-'A') * 1024) + (('U'-'A') * 32) + ('L'-'A'): m = 7; break;
  2227.     case (('A'-'A') * 1024) + (('U'-'A') * 32) + ('G'-'A'): m = 8; break;
  2228.     case (('S'-'A') * 1024) + (('E'-'A') * 32) + ('P'-'A'): m = 9; break;
  2229.     case (('O'-'A') * 1024) + (('C'-'A') * 32) + ('T'-'A'): m = 10; break;
  2230.     case (('N'-'A') * 1024) + (('O'-'A') * 32) + ('V'-'A'): m = 11; break;
  2231.     case (('D'-'A') * 1024) + (('E'-'A') * 32) + ('C'-'A'): m = 12; break;
  2232.     default: return NIL; /* unknown month */
  2233.     }
  2234.     if (s[4] == *s) s += 5; /* advance to year */
  2235.     else { /* first three were OK, possibly full name */
  2236.       mi = *s; /* note delimiter, skip alphas */
  2237.       for (s += 4; isalpha (*s); s++);
  2238. /* error if delimiter not here */
  2239.       if (mi != *s++) return NIL;
  2240.     }
  2241.     if ((y = strtoul ((const char *) s,&s,10)) && (*s == '' || *s == ' '))
  2242.       break; /* successfully parsed year */
  2243.   default: return NIL; /* unknown date format */
  2244.   }
  2245. /* minimal validity check of date */
  2246.   if ((d > 31) || (m > 12)) return NIL; 
  2247. /* two digit year */
  2248.   if (y < 100) y += (y >= (BASEYEAR - 1900)) ? 1900 : 2000;
  2249. /* set values in elt */
  2250.   elt->day = d; elt->month = m; elt->year = y - BASEYEAR;
  2252.   ms = ''; /* initially no time zone string */
  2253.   if (*s) { /* time specification present? */
  2254. /* parse time */
  2255.     d = strtoul ((const char *) s+1,&s,10);
  2256.     if (*s != ':') return NIL;
  2257.     m = strtoul ((const char *) ++s,&s,10);
  2258.     y = (*s == ':') ? strtoul ((const char *) ++s,&s,10) : 0;
  2259. /* validity check time */
  2260.     if ((d > 23) || (m > 59) || (y > 59)) return NIL; 
  2261. /* set values in elt */
  2262.     elt->hours = d; elt->minutes = m; elt->seconds = y;
  2263.     switch (*s) { /* time zone specifier? */
  2264.     case ' ': /* numeric time zone */
  2265.       while (s[1] == ' ') s++; /* slurp extra whitespace */
  2266.       if (!isalpha (s[1])) { /* treat as '-' case if alphabetic */
  2267. /* test for sign character */
  2268. if ((elt->zoccident = (*++s == '-')) || (*s == '+')) s++;
  2269. /* validate proper timezone */
  2270. if (isdigit(*s) && isdigit(s[1]) && isdigit(s[2]) && isdigit(s[3])) {
  2271.   elt->zhours = (*s - '0') * 10 + (s[1] - '0');
  2272.   elt->zminutes = (s[2] - '0') * 10 + (s[3] - '0');
  2273. }
  2274. return T; /* all done! */
  2275.       }
  2276. /* falls through */
  2277.     case '-': /* symbolic time zone */
  2278.       if (!(ms = *++s)) ms = 'Z';
  2279.       else if (*++s) { /* multi-character? */
  2280. ms -= 'A'; ms *= 1024; /* yes, make compressed three-byte form */
  2281. ms += ((*s++ - 'A') * 32);
  2282. if (*s) ms += *s++ - 'A';
  2283. if (*s) ms = ''; /* more than three characters */
  2284.       }
  2285.     default: /* ignore anything else */
  2286.       break;
  2287.     }
  2288.   }
  2290.   /*  This is not intended to be a comprehensive list of all possible
  2291.    * timezone strings.  Such a list would be impractical.  Rather, this
  2292.    * listing is intended to incorporate all military, North American, and
  2293.    * a few special cases such as Japan and the major European zone names,
  2294.    * such as what might be expected to be found in a Tenex format mailbox
  2295.    * and spewed from an IMAP server.  The trend is to migrate to numeric
  2296.    * timezones which lack the flavor but also the ambiguity of the names.
  2297.    *
  2298.    *  RFC-822 only recognizes UT, GMT, 1-letter military timezones, and the
  2299.    * 4 CONUS timezones and their summer time variants.  [Sorry, Canadian
  2300.    * Atlantic Provinces, Alaska, and Hawaii.]
  2301.    */
  2302.   switch (ms) { /* determine the timezone */
  2303. /* Universal */
  2304.   case (('U'-'A')*1024)+(('T'-'A')*32):
  2305. #ifndef STRICT_RFC822_TIMEZONES
  2306.   case (('U'-'A')*1024)+(('T'-'A')*32)+'C'-'A':
  2307. #endif
  2308. /* Greenwich */
  2309.   case (('G'-'A')*1024)+(('M'-'A')*32)+'T'-'A':
  2310.   case 'Z': elt->zhours = 0; break;
  2312.     /* oriental (from Greenwich) timezones */
  2313. #ifndef STRICT_RFC822_TIMEZONES
  2314. /* Middle Europe */
  2315.   case (('M'-'A')*1024)+(('E'-'A')*32)+'T'-'A':
  2316. #endif
  2317. #ifdef BRITISH_SUMMER_TIME
  2318. /* British Summer */
  2319.   case (('B'-'A')*1024)+(('S'-'A')*32)+'T'-'A':
  2320. #endif
  2321.   case 'A': elt->zhours = 1; break;
  2322. #ifndef STRICT_RFC822_TIMEZONES
  2323. /* Eastern Europe */
  2324.   case (('E'-'A')*1024)+(('E'-'A')*32)+'T'-'A':
  2325. #endif
  2326.   case 'B': elt->zhours = 2; break;
  2327.   case 'C': elt->zhours = 3; break;
  2328.   case 'D': elt->zhours = 4; break;
  2329.   case 'E': elt->zhours = 5; break;
  2330.   case 'F': elt->zhours = 6; break;
  2331.   case 'G': elt->zhours = 7; break;
  2332.   case 'H': elt->zhours = 8; break;
  2333. #ifndef STRICT_RFC822_TIMEZONES
  2334. /* Japan */
  2335.   case (('J'-'A')*1024)+(('S'-'A')*32)+'T'-'A':
  2336. #endif
  2337.   case 'I': elt->zhours = 9; break;
  2338.   case 'K': elt->zhours = 10; break;
  2339.   case 'L': elt->zhours = 11; break;
  2340.   case 'M': elt->zhours = 12; break;
  2342. /* occidental (from Greenwich) timezones */
  2343.   case 'N': elt->zoccident = 1; elt->zhours = 1; break;
  2344.   case 'O': elt->zoccident = 1; elt->zhours = 2; break;
  2345. #ifndef STRICT_RFC822_TIMEZONES
  2346.   case (('A'-'A')*1024)+(('D'-'A')*32)+'T'-'A':
  2347. #endif
  2348.   case 'P': elt->zoccident = 1; elt->zhours = 3; break;
  2349. #ifdef NEWFOUNDLAND_STANDARD_TIME
  2350. /* Newfoundland */
  2351.   case (('N'-'A')*1024)+(('S'-'A')*32)+'T'-'A':
  2352.     elt->zoccident = 1; elt->zhours = 3; elt->zminutes = 30; break;
  2353. #endif
  2354. #ifndef STRICT_RFC822_TIMEZONES
  2355. /* Atlantic */
  2356.   case (('A'-'A')*1024)+(('S'-'A')*32)+'T'-'A':
  2357. #endif
  2358. /* CONUS */
  2359.   case (('E'-'A')*1024)+(('D'-'A')*32)+'T'-'A':
  2360.   case 'Q': elt->zoccident = 1; elt->zhours = 4; break;
  2361. /* Eastern */
  2362.   case (('E'-'A')*1024)+(('S'-'A')*32)+'T'-'A':
  2363.   case (('C'-'A')*1024)+(('D'-'A')*32)+'T'-'A':
  2364.   case 'R': elt->zoccident = 1; elt->zhours = 5; break;
  2365. /* Central */
  2366.   case (('C'-'A')*1024)+(('S'-'A')*32)+'T'-'A':
  2367.   case (('M'-'A')*1024)+(('D'-'A')*32)+'T'-'A':
  2368.   case 'S': elt->zoccident = 1; elt->zhours = 6; break;
  2369. /* Mountain */
  2370.   case (('M'-'A')*1024)+(('S'-'A')*32)+'T'-'A':
  2371.   case (('P'-'A')*1024)+(('D'-'A')*32)+'T'-'A':
  2372.   case 'T': elt->zoccident = 1; elt->zhours = 7; break;
  2373. /* Pacific */
  2374.   case (('P'-'A')*1024)+(('S'-'A')*32)+'T'-'A':
  2375. #ifndef STRICT_RFC822_TIMEZONES
  2376.   case (('Y'-'A')*1024)+(('D'-'A')*32)+'T'-'A':
  2377. #endif
  2378.   case 'U': elt->zoccident = 1; elt->zhours = 8; break;
  2379. #ifndef STRICT_RFC822_TIMEZONES
  2380. /* Yukon */
  2381.   case (('Y'-'A')*1024)+(('S'-'A')*32)+'T'-'A':
  2382. #endif
  2383.   case 'V': elt->zoccident = 1; elt->zhours = 9; break;
  2384. #ifndef STRICT_RFC822_TIMEZONES
  2385. /* Hawaii */
  2386.   case (('H'-'A')*1024)+(('S'-'A')*32)+'T'-'A':
  2387. #endif
  2388.   case 'W': elt->zoccident = 1; elt->zhours = 10; break;
  2389. /* Nome/Bering/Samoa */
  2390. #ifndef NOME_STANDARD_TIME
  2391.   case (('N'-'A')*1024)+(('S'-'A')*32)+'T'-'A':
  2392. #endif
  2393. #ifndef BERING_STANDARD_TIME
  2394.   case (('B'-'A')*1024)+(('S'-'A')*32)+'T'-'A':
  2395. #endif
  2396. #ifndef SAMOA_STANDARD_TIME
  2397.   case (('S'-'A')*1024)+(('S'-'A')*32)+'T'-'A':
  2398. #endif
  2399.   case 'X': elt->zoccident = 1; elt->zhours = 11; break;
  2400.   case 'Y': elt->zoccident = 1; elt->zhours = 12; break;
  2402.   default: /* unknown time zones treated as local */
  2403.     tn = time (0); /* time now... */
  2404.     t = localtime (&tn); /* get local minutes since midnight */
  2405.     mi = t->tm_hour * 60 + t->tm_min;
  2406.     ms = t->tm_yday; /* note Julian day */
  2407.     if (t = gmtime (&tn)) { /* minus UTC minutes since midnight */
  2408.       mi -= t->tm_hour * 60 + t->tm_min;
  2409. /* ms can be one of:
  2410.  *  36x  local time is December 31, UTC is January 1, offset -24 hours
  2411.  *    1  local time is 1 day ahead of UTC, offset +24 hours
  2412.  *    0  local time is same day as UTC, no offset
  2413.  *   -1  local time is 1 day behind UTC, offset -24 hours
  2414.  * -36x  local time is January 1, UTC is December 31, offset +24 hours
  2415.  */
  2416.       if (ms -= t->tm_yday) /* correct offset if different Julian day */
  2417. mi += ((ms < 0) == (abs (ms) == 1)) ? -24*60 : 24*60;
  2418.       if (mi < 0) { /* occidental? */
  2419. mi = abs (mi); /* yup, make positive number */
  2420. elt->zoccident = 1; /* and note west of UTC */
  2421.       }
  2422.       elt->zhours = mi / 60; /* now break into hours and minutes */
  2423.       elt->zminutes = mi % 60;
  2424.     }
  2425.     break;
  2426.   }
  2427.   return T;
  2428. }
  2430. /* Mail n messages exist
  2431.  * Accepts: mail stream
  2432.  *     number of messages
  2433.  */
  2435. void mail_exists (MAILSTREAM *stream,unsigned long nmsgs)
  2436. {
  2437. /* make sure cache is large enough */
  2438.   (*mailcache) (stream,nmsgs,CH_SIZE);
  2439.   stream->nmsgs = nmsgs; /* update stream status */
  2440. /* notify main program of change */
  2441.   if (!stream->silent) mm_exists (stream,nmsgs);
  2442. }
  2445. /* Mail n messages are recent
  2446.  * Accepts: mail stream
  2447.  *     number of recent messages
  2448.  */
  2450. void mail_recent (MAILSTREAM *stream,unsigned long recent)
  2451. {
  2452.   stream->recent = recent; /* update stream status */