diff options
author | Eduardo Chappa <echappa@gmx.com> | 2013-02-03 00:59:38 -0700 |
---|---|---|
committer | Eduardo Chappa <echappa@gmx.com> | 2013-02-03 00:59:38 -0700 |
commit | 094ca96844842928810f14844413109fc6cdd890 (patch) | |
tree | e60efbb980f38ba9308ccb4fb2b77b87bbc115f3 /imap/src/c-client/mail.c | |
download | alpine-094ca96844842928810f14844413109fc6cdd890.tar.xz |
Initial Alpine Version
Diffstat (limited to 'imap/src/c-client/mail.c')
-rw-r--r-- | imap/src/c-client/mail.c | 6337 |
1 files changed, 6337 insertions, 0 deletions
diff --git a/imap/src/c-client/mail.c b/imap/src/c-client/mail.c new file mode 100644 index 00000000..d80a01f6 --- /dev/null +++ b/imap/src/c-client/mail.c @@ -0,0 +1,6337 @@ +/* ======================================================================== + * Copyright 1988-2008 University of Washington + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * + * ======================================================================== + */ + +/* + * Program: Mailbox Access routines + * + * Author: Mark Crispin + * UW Technology + * University of Washington + * Seattle, WA 98195 + * Internet: MRC@Washington.EDU + * + * Date: 22 November 1989 + * Last Edited: 15 April 2008 + */ + + +#include <ctype.h> +#include <stdio.h> +#include <time.h> +#include "c-client.h" + +char *UW_copyright = "Copyright 1988-2007 University of Washington\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n"; + +/* c-client global data */ + + /* version of this library */ +static char *mailcclientversion = CCLIENTVERSION; + /* list of mail drivers */ +static DRIVER *maildrivers = NIL; + /* list of authenticators */ +static AUTHENTICATOR *mailauthenticators = NIL; + /* SSL driver pointer */ +static NETDRIVER *mailssldriver = NIL; + /* pointer to alternate gets function */ +static mailgets_t mailgets = NIL; + /* pointer to read progress function */ +static readprogress_t mailreadprogress = NIL; + /* mail cache manipulation function */ +static mailcache_t mailcache = mm_cache; + /* RFC-822 output generator */ +static rfc822out_t mail822out = NIL; + /* RFC-822 output generator (new style) */ +static rfc822outfull_t mail822outfull = NIL; + /* SMTP verbose callback */ +static smtpverbose_t mailsmtpverbose = mm_dlog; + /* proxy copy routine */ +static mailproxycopy_t mailproxycopy = NIL; + /* RFC-822 external line parse */ +static parseline_t mailparseline = NIL; + /* RFC-822 external phrase parser */ +static parsephrase_t mailparsephrase = NIL; +static kinit_t mailkinit = NIL; /* application kinit callback */ + /* note network sent command */ +static sendcommand_t mailsendcommand = NIL; + /* newsrc file name decision function */ +static newsrcquery_t mailnewsrcquery = NIL; + /* ACL results callback */ +static getacl_t mailaclresults = NIL; + /* list rights results callback */ +static listrights_t maillistrightsresults = NIL; + /* my rights results callback */ +static myrights_t mailmyrightsresults = NIL; + /* quota results callback */ +static quota_t mailquotaresults = NIL; + /* quota root results callback */ +static quotaroot_t mailquotarootresults = NIL; + /* sorted results callback */ +static sortresults_t mailsortresults = NIL; + /* threaded results callback */ +static threadresults_t mailthreadresults = NIL; + /* COPY UID results */ +static copyuid_t mailcopyuid = NIL; + /* APPEND UID results */ +static appenduid_t mailappenduid = NIL; + /* free elt extra stuff callback */ +static freeeltsparep_t mailfreeeltsparep = NIL; + /* free envelope extra stuff callback */ +static freeenvelopesparep_t mailfreeenvelopesparep = NIL; + /* free body extra stuff callback */ +static freebodysparep_t mailfreebodysparep = NIL; + /* free stream extra stuff callback */ +static freestreamsparep_t mailfreestreamsparep = NIL; + /* SSL start routine */ +static sslstart_t mailsslstart = NIL; + /* SSL certificate query */ +static sslcertificatequery_t mailsslcertificatequery = NIL; + /* SSL client certificate */ +static sslclientcert_t mailsslclientcert = NIL; + /* SSL client private key */ +static sslclientkey_t mailsslclientkey = NIL; + /* SSL failure notify */ +static sslfailure_t mailsslfailure = NIL; + /* snarf interval */ +static long mailsnarfinterval = 60; + /* snarf preservation */ +static long mailsnarfpreserve = NIL; + /* newsrc name uses canonical host */ +static long mailnewsrccanon = LONGT; + + /* supported threaders */ +static THREADER mailthreadordsub = { + "ORDEREDSUBJECT",mail_thread_orderedsubject,NIL +}; +static THREADER mailthreadlist = { + "REFERENCES",mail_thread_references,&mailthreadordsub +}; + + /* server name */ +static char *servicename = "unknown"; + /* server externally-set authentication ID */ +static char *externalauthid = NIL; +static int expungeatping = T; /* mail_ping() may call mm_expunged() */ +static int trysslfirst = NIL; /* always try SSL first */ +static int notimezones = NIL; /* write timezones in "From " header */ +static int trustdns = T; /* do DNS canonicalization */ +static int saslusesptrname = T; /* SASL uses name from DNS PTR lookup */ + /* trustdns also must be set */ +static int debugsensitive = NIL;/* debug telemetry includes sensitive data */ + +/* Default mail cache handler + * Accepts: pointer to cache handle + * message number + * caching function + * Returns: cache data + */ + +void *mm_cache (MAILSTREAM *stream,unsigned long msgno,long op) +{ + size_t n; + void *ret = NIL; + unsigned long i; + switch ((int) op) { /* what function? */ + case CH_INIT: /* initialize cache */ + if (stream->cache) { /* flush old cache contents */ + while (stream->cachesize) { + mm_cache (stream,stream->cachesize,CH_FREE); + mm_cache (stream,stream->cachesize--,CH_FREESORTCACHE); + } + fs_give ((void **) &stream->cache); + fs_give ((void **) &stream->sc); + stream->nmsgs = 0; /* can't have any messages now */ + } + break; + case CH_SIZE: /* (re-)size the cache */ + if (!stream->cache) { /* have a cache already? */ + /* no, create new cache */ + n = (stream->cachesize = msgno + CACHEINCREMENT) * sizeof (void *); + stream->cache = (MESSAGECACHE **) memset (fs_get (n),0,n); + stream->sc = (SORTCACHE **) memset (fs_get (n),0,n); + } + /* is existing cache size large neough */ + else if (msgno > stream->cachesize) { + i = stream->cachesize; /* remember old size */ + n = (stream->cachesize = msgno + CACHEINCREMENT) * sizeof (void *); + fs_resize ((void **) &stream->cache,n); + fs_resize ((void **) &stream->sc,n); + while (i < stream->cachesize) { + stream->cache[i] = NIL; + stream->sc[i++] = NIL; + } + } + break; + + case CH_MAKEELT: /* return elt, make if necessary */ + if (!stream->cache[msgno - 1]) + stream->cache[msgno - 1] = mail_new_cache_elt (msgno); + /* falls through */ + case CH_ELT: /* return elt */ + ret = (void *) stream->cache[msgno - 1]; + break; + case CH_SORTCACHE: /* return sortcache entry, make if needed */ + if (!stream->sc[msgno - 1]) stream->sc[msgno - 1] = + (SORTCACHE *) memset (fs_get (sizeof (SORTCACHE)),0,sizeof (SORTCACHE)); + ret = (void *) stream->sc[msgno - 1]; + break; + case CH_FREE: /* free elt */ + mail_free_elt (&stream->cache[msgno - 1]); + break; + case CH_FREESORTCACHE: + if (stream->sc[msgno - 1]) { + if (stream->sc[msgno - 1]->from) + fs_give ((void **) &stream->sc[msgno - 1]->from); + if (stream->sc[msgno - 1]->to) + fs_give ((void **) &stream->sc[msgno - 1]->to); + if (stream->sc[msgno - 1]->cc) + fs_give ((void **) &stream->sc[msgno - 1]->cc); + if (stream->sc[msgno - 1]->subject) + fs_give ((void **) &stream->sc[msgno - 1]->subject); + if (stream->sc[msgno - 1]->unique && + (stream->sc[msgno - 1]->unique != stream->sc[msgno - 1]->message_id)) + fs_give ((void **) &stream->sc[msgno - 1]->unique); + if (stream->sc[msgno - 1]->message_id) + fs_give ((void **) &stream->sc[msgno - 1]->message_id); + if (stream->sc[msgno - 1]->references) + mail_free_stringlist (&stream->sc[msgno - 1]->references); + fs_give ((void **) &stream->sc[msgno - 1]); + } + break; + case CH_EXPUNGE: /* expunge cache slot */ + for (i = msgno - 1; msgno < stream->nmsgs; i++,msgno++) { + if (stream->cache[i] = stream->cache[msgno]) + stream->cache[i]->msgno = msgno; + stream->sc[i] = stream->sc[msgno]; + } + stream->cache[i] = NIL; /* top of cache goes away */ + stream->sc[i] = NIL; + break; + default: + fatal ("Bad mm_cache op"); + break; + } + return ret; +} + +/* Dummy string driver for complete in-memory strings */ + +static void mail_string_init (STRING *s,void *data,unsigned long size); +static char mail_string_next (STRING *s); +static void mail_string_setpos (STRING *s,unsigned long i); + +STRINGDRIVER mail_string = { + mail_string_init, /* initialize string structure */ + mail_string_next, /* get next byte in string structure */ + mail_string_setpos /* set position in string structure */ +}; + + +/* Initialize mail string structure for in-memory string + * Accepts: string structure + * pointer to string + * size of string + */ + +static void mail_string_init (STRING *s,void *data,unsigned long size) +{ + /* set initial string pointers */ + s->chunk = s->curpos = (char *) (s->data = data); + /* and sizes */ + s->size = s->chunksize = s->cursize = size; + s->data1 = s->offset = 0; /* never any offset */ +} + + +/* Get next character from string + * Accepts: string structure + * Returns: character, string structure chunk refreshed + */ + +static char mail_string_next (STRING *s) +{ + return *s->curpos++; /* return the last byte */ +} + + +/* Set string pointer position + * Accepts: string structure + * new position + */ + +static void mail_string_setpos (STRING *s,unsigned long i) +{ + s->curpos = s->chunk + i; /* set new position */ + s->cursize = s->chunksize - i;/* and new size */ +} + +/* Mail routines + * + * mail_xxx routines are the interface between this module and the outside + * world. Only these routines should be referenced by external callers. + * + * Note that there is an important difference between a "sequence" and a + * "message #" (msgno). A sequence is a string representing a sequence in + * {"n", "n:m", or combination separated by commas} format, whereas a msgno + * is a single integer. + * + */ + +/* Mail version check + * Accepts: version + */ + +void mail_versioncheck (char *version) +{ + /* attempt to protect again wrong .h */ + if (strcmp (version,mailcclientversion)) { + char tmp[MAILTMPLEN]; + sprintf (tmp,"c-client library version skew, app=%.100s library=%.100s", + version,mailcclientversion); + fatal (tmp); + } +} + + +/* Mail link driver + * Accepts: driver to add to list + */ + +void mail_link (DRIVER *driver) +{ + DRIVER **d = &maildrivers; + while (*d) d = &(*d)->next; /* find end of list of drivers */ + *d = driver; /* put driver at the end */ + driver->next = NIL; /* this driver is the end of the list */ +} + +/* Mail manipulate driver parameters + * Accepts: mail stream + * function code + * function-dependent value + * Returns: function-dependent return value + */ + +void *mail_parameters (MAILSTREAM *stream,long function,void *value) +{ + void *r,*ret = NIL; + DRIVER *d; + AUTHENTICATOR *a; + switch ((int) function) { + case SET_INBOXPATH: + fatal ("SET_INBOXPATH not permitted"); + case GET_INBOXPATH: + if ((stream || (stream = mail_open (NIL,"INBOX",OP_PROTOTYPE))) && + stream->dtb) ret = (*stream->dtb->parameters) (function,value); + break; + case SET_THREADERS: + fatal ("SET_THREADERS not permitted"); + case GET_THREADERS: /* use stream dtb instead of global */ + ret = (stream && stream->dtb) ? + /* KLUDGE ALERT: note stream passed as value */ + (*stream->dtb->parameters) (function,stream) : (void *) &mailthreadlist; + break; + case SET_NAMESPACE: + fatal ("SET_NAMESPACE not permitted"); + break; + case SET_NEWSRC: /* too late on open stream */ + if (stream && stream->dtb && (stream != ((*stream->dtb->open) (NIL)))) + fatal ("SET_NEWSRC not permitted"); + else ret = env_parameters (function,value); + break; + case GET_NAMESPACE: + case GET_NEWSRC: /* use stream dtb instead of environment */ + ret = (stream && stream->dtb) ? + /* KLUDGE ALERT: note stream passed as value */ + (*stream->dtb->parameters) (function,stream) : + env_parameters (function,value); + break; + case ENABLE_DEBUG: + fatal ("ENABLE_DEBUG not permitted"); + case DISABLE_DEBUG: + fatal ("DISABLE_DEBUG not permitted"); + case SET_DIRFMTTEST: + fatal ("SET_DIRFMTTEST not permitted"); + case GET_DIRFMTTEST: + if (!(stream && stream->dtb && + (ret = (*stream->dtb->parameters) (function,NIL)))) + fatal ("GET_DIRFMTTEST not permitted"); + break; + + case SET_DRIVERS: + fatal ("SET_DRIVERS not permitted"); + case GET_DRIVERS: /* always return global */ + ret = (void *) maildrivers; + break; + case SET_DRIVER: + fatal ("SET_DRIVER not permitted"); + case GET_DRIVER: + for (d = maildrivers; d && compare_cstring (d->name,(char *) value); + d = d->next); + ret = (void *) d; + break; + case ENABLE_DRIVER: + for (d = maildrivers; d && compare_cstring (d->name,(char *) value); + d = d->next); + if (ret = (void *) d) d->flags &= ~DR_DISABLE; + break; + case DISABLE_DRIVER: + for (d = maildrivers; d && compare_cstring (d->name,(char *) value); + d = d->next); + if (ret = (void *) d) d->flags |= DR_DISABLE; + break; + case ENABLE_AUTHENTICATOR: + for (a = mailauthenticators;/* scan authenticators */ + a && compare_cstring (a->name,(char *) value); a = a->next); + if (ret = (void *) a) a->flags &= ~AU_DISABLE; + break; + case DISABLE_AUTHENTICATOR: + for (a = mailauthenticators;/* scan authenticators */ + a && compare_cstring (a->name,(char *) value); a = a->next); + if (ret = (void *) a) a->flags |= AU_DISABLE; + break; + case UNHIDE_AUTHENTICATOR: + for (a = mailauthenticators;/* scan authenticators */ + a && compare_cstring (a->name,(char *) value); a = a->next); + if (ret = (void *) a) a->flags &= ~AU_HIDE; + break; + case HIDE_AUTHENTICATOR: + for (a = mailauthenticators;/* scan authenticators */ + a && compare_cstring (a->name,(char *) value); a = a->next); + if (ret = (void *) a) a->flags |= AU_HIDE; + break; + case SET_EXTERNALAUTHID: + if (value) { /* setting external authentication ID */ + externalauthid = cpystr ((char *) value); + mail_parameters (NIL,UNHIDE_AUTHENTICATOR,"EXTERNAL"); + } + else { /* clearing external authentication ID */ + if (externalauthid) fs_give ((void **) &externalauthid); + mail_parameters (NIL,HIDE_AUTHENTICATOR,"EXTERNAL"); + } + case GET_EXTERNALAUTHID: + ret = (void *) externalauthid; + break; + + case SET_GETS: + mailgets = (mailgets_t) value; + case GET_GETS: + ret = (void *) mailgets; + break; + case SET_READPROGRESS: + mailreadprogress = (readprogress_t) value; + case GET_READPROGRESS: + ret = (void *) mailreadprogress; + break; + case SET_CACHE: + mailcache = (mailcache_t) value; + case GET_CACHE: + ret = (void *) mailcache; + break; + case SET_RFC822OUTPUT: + mail822out = (rfc822out_t) value; + case GET_RFC822OUTPUT: + ret = (void *) mail822out; + break; + case SET_RFC822OUTPUTFULL: + mail822outfull = (rfc822outfull_t) value; + case GET_RFC822OUTPUTFULL: + ret = (void *) mail822outfull; + break; + case SET_SMTPVERBOSE: + mailsmtpverbose = (smtpverbose_t) value; + case GET_SMTPVERBOSE: + ret = (void *) mailsmtpverbose; + break; + case SET_MAILPROXYCOPY: + mailproxycopy = (mailproxycopy_t) value; + case GET_MAILPROXYCOPY: + ret = (void *) mailproxycopy; + break; + case SET_PARSELINE: + mailparseline = (parseline_t) value; + case GET_PARSELINE: + ret = (void *) mailparseline; + break; + case SET_PARSEPHRASE: + mailparsephrase = (parsephrase_t) value; + case GET_PARSEPHRASE: + ret = (void *) mailparsephrase; + break; + case SET_NEWSRCQUERY: + mailnewsrcquery = (newsrcquery_t) value; + case GET_NEWSRCQUERY: + ret = (void *) mailnewsrcquery; + break; + case SET_NEWSRCCANONHOST: + mailnewsrccanon = (long) value; + case GET_NEWSRCCANONHOST: + ret = (void *) mailnewsrccanon; + break; + + case SET_COPYUID: + mailcopyuid = (copyuid_t) value; + case GET_COPYUID: + ret = (void *) mailcopyuid; + break; + case SET_APPENDUID: + mailappenduid = (appenduid_t) value; + case GET_APPENDUID: + ret = (void *) mailappenduid; + break; + case SET_FREEENVELOPESPAREP: + mailfreeenvelopesparep = (freeenvelopesparep_t) value; + case GET_FREEENVELOPESPAREP: + ret = (void *) mailfreeenvelopesparep; + break; + case SET_FREEELTSPAREP: + mailfreeeltsparep = (freeeltsparep_t) value; + case GET_FREEELTSPAREP: + ret = (void *) mailfreeeltsparep; + break; + case SET_FREESTREAMSPAREP: + mailfreestreamsparep = (freestreamsparep_t) value; + case GET_FREESTREAMSPAREP: + ret = (void *) mailfreestreamsparep; + break; + case SET_FREEBODYSPAREP: + mailfreebodysparep = (freebodysparep_t) value; + case GET_FREEBODYSPAREP: + ret = (void *) mailfreebodysparep; + break; + + case SET_SSLSTART: + mailsslstart = (sslstart_t) value; + case GET_SSLSTART: + ret = (void *) mailsslstart; + break; + case SET_SSLCERTIFICATEQUERY: + mailsslcertificatequery = (sslcertificatequery_t) value; + case GET_SSLCERTIFICATEQUERY: + ret = (void *) mailsslcertificatequery; + break; + case SET_SSLCLIENTCERT: + mailsslclientcert = (sslclientcert_t) value; + case GET_SSLCLIENTCERT: + ret = (void *) mailsslclientcert; + break; + case SET_SSLCLIENTKEY: + mailsslclientkey = (sslclientkey_t) value; + case GET_SSLCLIENTKEY: + ret = (void *) mailsslclientkey; + break; + case SET_SSLFAILURE: + mailsslfailure = (sslfailure_t) value; + case GET_SSLFAILURE: + ret = (void *) mailsslfailure; + break; + case SET_KINIT: + mailkinit = (kinit_t) value; + case GET_KINIT: + ret = (void *) mailkinit; + break; + case SET_SENDCOMMAND: + mailsendcommand = (sendcommand_t) value; + case GET_SENDCOMMAND: + ret = (void *) mailsendcommand; + break; + + case SET_SERVICENAME: + servicename = (char *) value; + case GET_SERVICENAME: + ret = (void *) servicename; + break; + case SET_EXPUNGEATPING: + expungeatping = (value ? T : NIL); + case GET_EXPUNGEATPING: + ret = (void *) (expungeatping ? VOIDT : NIL); + break; + case SET_SORTRESULTS: + mailsortresults = (sortresults_t) value; + case GET_SORTRESULTS: + ret = (void *) mailsortresults; + break; + case SET_THREADRESULTS: + mailthreadresults = (threadresults_t) value; + case GET_THREADRESULTS: + ret = (void *) mailthreadresults; + break; + case SET_SSLDRIVER: + mailssldriver = (NETDRIVER *) value; + case GET_SSLDRIVER: + ret = (void *) mailssldriver; + break; + case SET_TRYSSLFIRST: + trysslfirst = (value ? T : NIL); + case GET_TRYSSLFIRST: + ret = (void *) (trysslfirst ? VOIDT : NIL); + break; + case SET_NOTIMEZONES: + notimezones = (value ? T : NIL); + case GET_NOTIMEZONES: + ret = (void *) (notimezones ? VOIDT : NIL); + break; + case SET_TRUSTDNS: + trustdns = (value ? T : NIL); + case GET_TRUSTDNS: + ret = (void *) (trustdns ? VOIDT : NIL); + break; + case SET_SASLUSESPTRNAME: + saslusesptrname = (value ? T : NIL); + case GET_SASLUSESPTRNAME: + ret = (void *) (saslusesptrname ? VOIDT : NIL); + break; + case SET_DEBUGSENSITIVE: + debugsensitive = (value ? T : NIL); + case GET_DEBUGSENSITIVE: + ret = (void *) (debugsensitive ? VOIDT : NIL); + break; + + case SET_ACL: + mailaclresults = (getacl_t) value; + case GET_ACL: + ret = (void *) mailaclresults; + break; + case SET_LISTRIGHTS: + maillistrightsresults = (listrights_t) value; + case GET_LISTRIGHTS: + ret = (void *) maillistrightsresults; + break; + case SET_MYRIGHTS: + mailmyrightsresults = (myrights_t) value; + case GET_MYRIGHTS: + ret = (void *) mailmyrightsresults; + break; + case SET_QUOTA: + mailquotaresults = (quota_t) value; + case GET_QUOTA: + ret = (void *) mailquotaresults; + break; + case SET_QUOTAROOT: + mailquotarootresults = (quotaroot_t) value; + case GET_QUOTAROOT: + ret = (void *) mailquotarootresults; + break; + case SET_SNARFINTERVAL: + mailsnarfinterval = (long) value; + case GET_SNARFINTERVAL: + ret = (void *) mailsnarfinterval; + break; + case SET_SNARFPRESERVE: + mailsnarfpreserve = (long) value; + case GET_SNARFPRESERVE: + ret = (void *) mailsnarfpreserve; + break; + case SET_SNARFMAILBOXNAME: + if (stream) { /* have a stream? */ + if (stream->snarf.name) fs_give ((void **) &stream->snarf.name); + stream->snarf.name = cpystr ((char *) value); + } + else fatal ("SET_SNARFMAILBOXNAME with no stream"); + case GET_SNARFMAILBOXNAME: + if (stream) ret = (void *) stream->snarf.name; + break; + default: + if (r = smtp_parameters (function,value)) ret = r; + if (r = env_parameters (function,value)) ret = r; + if (r = tcp_parameters (function,value)) ret = r; + if (stream && stream->dtb) {/* if have stream, do for its driver only */ + if (r = (*stream->dtb->parameters) (function,value)) ret = r; + } + /* else do all drivers */ + else for (d = maildrivers; d; d = d->next) + if (r = (d->parameters) (function,value)) ret = r; + break; + } + return ret; +} + +/* Mail validate mailbox name + * Accepts: MAIL stream + * mailbox name + * purpose string for error message + * Return: driver factory on success, NIL on failure + */ + +DRIVER *mail_valid (MAILSTREAM *stream,char *mailbox,char *purpose) +{ + char tmp[MAILTMPLEN]; + DRIVER *factory = NIL; + /* never allow names with newlines */ + if (strpbrk (mailbox,"\015\012")) { + if (purpose) { /* if want an error message */ + sprintf (tmp,"Can't %s with such a name",purpose); + MM_LOG (tmp,ERROR); + } + return NIL; + } + /* validate name, find driver factory */ + if (strlen (mailbox) < (NETMAXHOST+(NETMAXUSER*2)+NETMAXMBX+NETMAXSRV+50)) + for (factory = maildrivers; factory && + ((factory->flags & DR_DISABLE) || + ((factory->flags & DR_LOCAL) && (*mailbox == '{')) || + !(*factory->valid) (mailbox)); + factory = factory->next); + /* validate factory against non-dummy stream */ + if (factory && stream && stream->dtb && (stream->dtb != factory) && + strcmp (stream->dtb->name,"dummy")) + /* factory invalid; if dummy, use stream */ + factory = strcmp (factory->name,"dummy") ? NIL : stream->dtb; + if (!factory && purpose) { /* if want an error message */ + sprintf (tmp,"Can't %s %.80s: %s",purpose,mailbox,(*mailbox == '{') ? + "invalid remote specification" : "no such mailbox"); + MM_LOG (tmp,ERROR); + } + return factory; /* return driver factory */ +} + +/* Mail validate network mailbox name + * Accepts: mailbox name + * mailbox driver to validate against + * pointer to where to return host name if non-NIL + * pointer to where to return mailbox name if non-NIL + * Returns: driver on success, NIL on failure + */ + +DRIVER *mail_valid_net (char *name,DRIVER *drv,char *host,char *mailbox) +{ + NETMBX mb; + if (!mail_valid_net_parse (name,&mb) || strcmp (mb.service,drv->name)) + return NIL; + if (host) strcpy (host,mb.host); + if (mailbox) strcpy (mailbox,mb.mailbox); + return drv; +} + + +/* Mail validate network mailbox name + * Accepts: mailbox name + * NETMBX structure to return values + * Returns: T on success, NIL on failure + */ + +long mail_valid_net_parse (char *name,NETMBX *mb) +{ + return mail_valid_net_parse_work (name,mb,"imap"); +} + +/* Mail validate network mailbox name worker routine + * Accepts: mailbox name + * NETMBX structure to return values + * default service + * Returns: T on success, NIL on failure + */ + +long mail_valid_net_parse_work (char *name,NETMBX *mb,char *service) +{ + int i,j; + char c,*s,*t,*v,tmp[MAILTMPLEN],arg[MAILTMPLEN]; + /* initialize structure */ + memset (mb,'\0',sizeof (NETMBX)); + /* must have host specification */ + if (*name++ != '{') return NIL; + if (*name == '[') { /* if domain literal, find its ending */ + if (!((v = strpbrk (name,"]}")) && (*v++ == ']'))) return NIL; + } + /* find end of host name */ + else if (!(v = strpbrk (name,"/:}"))) return NIL; + /* validate length, find mailbox part */ + if (!((i = v - name) && (i < NETMAXHOST) && (t = strchr (v,'}')) && + ((j = t - v) < MAILTMPLEN) && (strlen (t+1) < (size_t) NETMAXMBX))) + return NIL; /* invalid mailbox */ + strncpy (mb->host,name,i); /* set host name */ + strncpy (mb->orighost,name,i); + mb->host[i] = mb->orighost[i] = '\0'; + strcpy (mb->mailbox,t+1); /* set mailbox name */ + if (t - v) { /* any switches or port specification? */ + strncpy (t = tmp,v,j); /* copy it */ + tmp[j] = '\0'; /* tie it off */ + c = *t++; /* get first delimiter */ + do switch (c) { /* act based upon the character */ + case ':': /* port specification */ + if (mb->port || !(mb->port = strtoul (t,&t,10))) return NIL; + c = t ? *t++ : '\0'; /* get delimiter, advance pointer */ + break; + case '/': /* switch */ + /* find delimiter */ + if (t = strpbrk (s = t,"/:=")) { + c = *t; /* remember delimiter for later */ + *t++ = '\0'; /* tie off switch name */ + } + else c = '\0'; /* no delimiter */ + if (c == '=') { /* parse switches which take arguments */ + if (*t == '"') { /* quoted string? */ + for (v = arg,i = 0,++t; (c = *t++) != '"';) { + if (!c) return NIL; /* unterminated string */ + /* quote next character */ + if (c == '\\') c = *t++; + if (!c) return NIL; /* can't quote NUL either */ + arg[i++] = c; + } + c = *t++; /* remember delimiter for later */ + arg[i] = '\0'; /* tie off argument */ + } + else { /* non-quoted argument */ + if (t = strpbrk (v = t,"/:")) { + c = *t; /* remember delimiter for later */ + *t++ = '\0'; /* tie off switch name */ + } + else c = '\0'; /* no delimiter */ + i = strlen (v); /* length of argument */ + } + if (!compare_cstring (s,"service") && (i < NETMAXSRV) && !*mb->service) + lcase (strcpy (mb->service,v)); + else if (!compare_cstring (s,"user") && (i < NETMAXUSER) && !*mb->user) + strcpy (mb->user,v); + else if (!compare_cstring (s,"authuser") && (i < NETMAXUSER) && + !*mb->authuser) strcpy (mb->authuser,v); + else return NIL; + } + + else { /* non-argument switch */ + if (!compare_cstring (s,"anonymous")) mb->anoflag = T; + else if (!compare_cstring (s,"debug")) mb->dbgflag = T; + else if (!compare_cstring (s,"readonly")) mb->readonlyflag = T; + else if (!compare_cstring (s,"secure")) mb->secflag = T; + else if (!compare_cstring (s,"norsh")) mb->norsh = T; + else if (!compare_cstring (s,"loser")) mb->loser = T; + else if (!compare_cstring (s,"tls") && !mb->notlsflag) + mb->tlsflag = T; + else if (!compare_cstring (s,"tls-sslv23") && !mb->notlsflag) + mb->tlssslv23 = mb->tlsflag = T; + else if (!compare_cstring (s,"notls") && !mb->tlsflag) + mb->notlsflag = T; + else if (!compare_cstring (s,"tryssl")) + mb->trysslflag = mailssldriver? T : NIL; + else if (mailssldriver && !compare_cstring (s,"ssl") && !mb->tlsflag) + mb->sslflag = mb->notlsflag = T; + else if (mailssldriver && !compare_cstring (s,"novalidate-cert")) + mb->novalidate = T; + /* hack for compatibility with the past */ + else if (mailssldriver && !compare_cstring (s,"validate-cert")); + /* service switches below here */ + else if (*mb->service) return NIL; + else if (!compare_cstring (s,"imap") || + !compare_cstring (s,"nntp") || + !compare_cstring (s,"pop3") || + !compare_cstring (s,"smtp") || + !compare_cstring (s,"submit")) + lcase (strcpy (mb->service,s)); + else if (!compare_cstring (s,"imap2") || + !compare_cstring (s,"imap2bis") || + !compare_cstring (s,"imap4") || + !compare_cstring (s,"imap4rev1")) + strcpy (mb->service,"imap"); + else if (!compare_cstring (s,"pop")) + strcpy (mb->service,"pop3"); + else return NIL; /* invalid non-argument switch */ + } + break; + default: /* anything else is bogus */ + return NIL; + } while (c); /* see if anything more to parse */ + } + /* default mailbox name */ + if (!*mb->mailbox) strcpy (mb->mailbox,"INBOX"); + /* default service name */ + if (!*mb->service) strcpy (mb->service,service); + /* /norsh only valid if imap */ + if (mb->norsh && strcmp (mb->service,"imap")) return NIL; + return T; +} + +/* Mail scan mailboxes for string + * Accepts: mail stream + * reference + * pattern to search + * contents to search + */ + +void mail_scan (MAILSTREAM *stream,char *ref,char *pat,char *contents) +{ + int remote = ((*pat == '{') || (ref && *ref == '{')); + DRIVER *d; + if (ref && (strlen (ref) > NETMAXMBX)) { + char tmp[MAILTMPLEN]; + sprintf (tmp,"Invalid LIST reference specification: %.80s",ref); + MM_LOG (tmp,ERROR); + return; + } + if (strlen (pat) > NETMAXMBX) { + char tmp[MAILTMPLEN]; + sprintf (tmp,"Invalid LIST pattern specification: %.80s",pat); + MM_LOG (tmp,ERROR); + return; + } + if (*pat == '{') ref = NIL; /* ignore reference if pattern is remote */ + if (stream) { /* if have a stream, do it for that stream */ + if ((d = stream->dtb) && d->scan && + !(((d->flags & DR_LOCAL) && remote))) + (*d->scan) (stream,ref,pat,contents); + } + /* otherwise do for all DTB's */ + else for (d = maildrivers; d; d = d->next) + if (d->scan && !((d->flags & DR_DISABLE) || + ((d->flags & DR_LOCAL) && remote))) + (d->scan) (NIL,ref,pat,contents); +} + +/* Mail list mailboxes + * Accepts: mail stream + * reference + * pattern to search + */ + +void mail_list (MAILSTREAM *stream,char *ref,char *pat) +{ + int remote = ((*pat == '{') || (ref && *ref == '{')); + DRIVER *d = maildrivers; + if (ref && (strlen (ref) > NETMAXMBX)) { + char tmp[MAILTMPLEN]; + sprintf (tmp,"Invalid LIST reference specification: %.80s",ref); + MM_LOG (tmp,ERROR); + return; + } + if (strlen (pat) > NETMAXMBX) { + char tmp[MAILTMPLEN]; + sprintf (tmp,"Invalid LIST pattern specification: %.80s",pat); + MM_LOG (tmp,ERROR); + return; + } + if (*pat == '{') ref = NIL; /* ignore reference if pattern is remote */ + if (stream && stream->dtb) { /* if have a stream, do it for that stream */ + if (!(((d = stream->dtb)->flags & DR_LOCAL) && remote)) + (*d->list) (stream,ref,pat); + } + /* otherwise do for all DTB's */ + else do if (!((d->flags & DR_DISABLE) || + ((d->flags & DR_LOCAL) && remote))) + (d->list) (NIL,ref,pat); + while (d = d->next); /* until at the end */ +} + +/* Mail list subscribed mailboxes + * Accepts: mail stream + * pattern to search + */ + +void mail_lsub (MAILSTREAM *stream,char *ref,char *pat) +{ + int remote = ((*pat == '{') || (ref && *ref == '{')); + DRIVER *d = maildrivers; + if (ref && (strlen (ref) > NETMAXMBX)) { + char tmp[MAILTMPLEN]; + sprintf (tmp,"Invalid LSUB reference specification: %.80s",ref); + MM_LOG (tmp,ERROR); + return; + } + if (strlen (pat) > NETMAXMBX) { + char tmp[MAILTMPLEN]; + sprintf (tmp,"Invalid LSUB pattern specification: %.80s",pat); + MM_LOG (tmp,ERROR); + return; + } + if (*pat == '{') ref = NIL; /* ignore reference if pattern is remote */ + if (stream && stream->dtb) { /* if have a stream, do it for that stream */ + if (!(((d = stream->dtb)->flags & DR_LOCAL) && remote)) + (*d->lsub) (stream,ref,pat); + } + /* otherwise do for all DTB's */ + else do if (!((d->flags & DR_DISABLE) || + ((d->flags & DR_LOCAL) && remote))) + (d->lsub) (NIL,ref,pat); + while (d = d->next); /* until at the end */ +} + +/* Mail subscribe to mailbox + * Accepts: mail stream + * mailbox to add to subscription list + * Returns: T on success, NIL on failure + */ + +long mail_subscribe (MAILSTREAM *stream,char *mailbox) +{ + DRIVER *factory = mail_valid (stream,mailbox,"subscribe to mailbox"); + return factory ? + (factory->subscribe ? + (*factory->subscribe) (stream,mailbox) : sm_subscribe (mailbox)) : NIL; +} + + +/* Mail unsubscribe to mailbox + * Accepts: mail stream + * mailbox to delete from subscription list + * Returns: T on success, NIL on failure + */ + +long mail_unsubscribe (MAILSTREAM *stream,char *mailbox) +{ + DRIVER *factory = mail_valid (stream,mailbox,NIL); + return (factory && factory->unsubscribe) ? + (*factory->unsubscribe) (stream,mailbox) : sm_unsubscribe (mailbox); +} + +/* Mail create mailbox + * Accepts: mail stream + * mailbox name to create + * Returns: T on success, NIL on failure + */ + +long mail_create (MAILSTREAM *stream,char *mailbox) +{ + MAILSTREAM *ts; + char *s,*t,tmp[MAILTMPLEN]; + size_t i; + DRIVER *d; + /* never allow names with newlines */ + if (s = strpbrk (mailbox,"\015\012")) { + MM_LOG ("Can't create mailbox with such a name",ERROR); + return NIL; + } + if (strlen (mailbox) >= (NETMAXHOST+(NETMAXUSER*2)+NETMAXMBX+NETMAXSRV+50)) { + sprintf (tmp,"Can't create %.80s: %s",mailbox,(*mailbox == '{') ? + "invalid remote specification" : "no such mailbox"); + MM_LOG (tmp,ERROR); + return NIL; + } + /* create of INBOX invalid */ + if (!compare_cstring (mailbox,"INBOX")) { + MM_LOG ("Can't create INBOX",ERROR); + return NIL; + } + /* validate name */ + if (s = mail_utf7_valid (mailbox)) { + sprintf (tmp,"Can't create %s: %.80s",s,mailbox); + MM_LOG (tmp,ERROR); + return NIL; + } + + /* see if special driver hack */ + if ((mailbox[0] == '#') && ((mailbox[1] == 'd') || (mailbox[1] == 'D')) && + ((mailbox[2] == 'r') || (mailbox[2] == 'R')) && + ((mailbox[3] == 'i') || (mailbox[3] == 'I')) && + ((mailbox[4] == 'v') || (mailbox[4] == 'V')) && + ((mailbox[5] == 'e') || (mailbox[5] == 'E')) && + ((mailbox[6] == 'r') || (mailbox[6] == 'R')) && (mailbox[7] == '.')) { + /* copy driver until likely delimiter */ + if ((s = strpbrk (t = mailbox+8,"/\\:")) && (i = s - t)) { + strncpy (tmp,t,i); + tmp[i] = '\0'; + } + else { + sprintf (tmp,"Can't create mailbox %.80s: bad driver syntax",mailbox); + MM_LOG (tmp,ERROR); + return NIL; + } + for (d = maildrivers; d && strcmp (d->name,tmp); d = d->next); + if (d) mailbox = ++s; /* skip past driver specification */ + else { + sprintf (tmp,"Can't create mailbox %.80s: unknown driver",mailbox); + MM_LOG (tmp,ERROR); + return NIL; + } + } + /* use stream if one given or deterministic */ + else if ((stream && stream->dtb) || + (((*mailbox == '{') || (*mailbox == '#')) && + (stream = mail_open (NIL,mailbox,OP_PROTOTYPE | OP_SILENT)))) + d = stream->dtb; + else if ((*mailbox != '{') && (ts = default_proto (NIL))) d = ts->dtb; + else { /* failed utterly */ + sprintf (tmp,"Can't create mailbox %.80s: indeterminate format",mailbox); + MM_LOG (tmp,ERROR); + return NIL; + } + return (*d->create) (stream,mailbox); +} + +/* Mail delete mailbox + * Accepts: mail stream + * mailbox name to delete + * Returns: T on success, NIL on failure + */ + +long mail_delete (MAILSTREAM *stream,char *mailbox) +{ + DRIVER *dtb = mail_valid (stream,mailbox,"delete mailbox"); + if (!dtb) return NIL; + if (((mailbox[0] == 'I') || (mailbox[0] == 'i')) && + ((mailbox[1] == 'N') || (mailbox[1] == 'n')) && + ((mailbox[2] == 'B') || (mailbox[2] == 'b')) && + ((mailbox[3] == 'O') || (mailbox[3] == 'o')) && + ((mailbox[4] == 'X') || (mailbox[4] == 'x')) && !mailbox[5]) { + MM_LOG ("Can't delete INBOX",ERROR); + return NIL; + } + return SAFE_DELETE (dtb,stream,mailbox); +} + + +/* Mail rename mailbox + * Accepts: mail stream + * old mailbox name + * new mailbox name + * Returns: T on success, NIL on failure + */ + +long mail_rename (MAILSTREAM *stream,char *old,char *newname) +{ + char *s,tmp[MAILTMPLEN]; + DRIVER *dtb = mail_valid (stream,old,"rename mailbox"); + if (!dtb) return NIL; + /* validate name */ + if (s = mail_utf7_valid (newname)) { + sprintf (tmp,"Can't rename to %s: %.80s",s,newname); + MM_LOG (tmp,ERROR); + return NIL; + } + if ((*old != '{') && (*old != '#') && mail_valid (NIL,newname,NIL)) { + sprintf (tmp,"Can't rename %.80s: mailbox %.80s already exists", + old,newname); + MM_LOG (tmp,ERROR); + return NIL; + } + return SAFE_RENAME (dtb,stream,old,newname); +} + +/* Validate mailbox as Modified UTF-7 + * Accepts: candidate mailbox name + * Returns: error string if error, NIL if valid + */ + +char *mail_utf7_valid (char *mailbox) +{ + char *s; + for (s = mailbox; *s; s++) { /* make sure valid name */ + /* reserved for future use with UTF-8 */ + if (*s & 0x80) return "mailbox name with 8-bit octet"; + /* validate modified UTF-7 */ + else if (*s == '&') while (*++s != '-') switch (*s) { + case '\0': + return "unterminated modified UTF-7 name"; + case '+': /* valid modified BASE64 */ + case ',': + break; /* all OK so far */ + default: /* must be alphanumeric */ + if (!isalnum (*s)) return "invalid modified UTF-7 name"; + break; + } + } + return NIL; /* all OK */ +} + +/* Mail status of mailbox + * Accepts: mail stream if open on this mailbox + * mailbox name + * status flags + * Returns: T on success, NIL on failure + */ + +long mail_status (MAILSTREAM *stream,char *mbx,long flags) +{ + DRIVER *dtb = mail_valid (stream,mbx,"get status of mailbox"); + if (!dtb) return NIL; /* only if valid */ + if (stream && ((dtb != stream->dtb) || + ((dtb->flags & DR_LOCAL) && strcmp (mbx,stream->mailbox) && + strcmp (mbx,stream->original_mailbox)))) + stream = NIL; /* stream not suitable */ + return SAFE_STATUS (dtb,stream,mbx,flags); +} + + +/* Mail status of mailbox default handler + * Accepts: mail stream + * mailbox name + * status flags + * Returns: T on success, NIL on failure + */ + +long mail_status_default (MAILSTREAM *stream,char *mbx,long flags) +{ + MAILSTATUS status; + unsigned long i; + MAILSTREAM *tstream = NIL; + /* make temporary stream (unless this mbx) */ + if (!stream && !(stream = tstream = + mail_open (NIL,mbx,OP_READONLY|OP_SILENT))) return NIL; + status.flags = flags; /* return status values */ + status.messages = stream->nmsgs; + status.recent = stream->recent; + if (flags & SA_UNSEEN) /* must search to get unseen messages */ + for (i = 1,status.unseen = 0; i <= stream->nmsgs; i++) + if (!mail_elt (stream,i)->seen) status.unseen++; + status.uidnext = stream->uid_last + 1; + status.uidvalidity = stream->uid_validity; + MM_STATUS(stream,mbx,&status);/* pass status to main program */ + if (tstream) mail_close (tstream); + return T; /* success */ +} + +/* Mail open + * Accepts: candidate stream for recycling + * mailbox name + * open options + * Returns: stream to use on success, NIL on failure + */ + +MAILSTREAM *mail_open (MAILSTREAM *stream,char *name,long options) +{ + int i; + char c,*s,tmp[MAILTMPLEN]; + NETMBX mb; + DRIVER *d; + switch (name[0]) { /* see if special handling */ + case '#': /* possible special hacks */ + if (((name[1] == 'M') || (name[1] == 'm')) && + ((name[2] == 'O') || (name[2] == 'o')) && + ((name[3] == 'V') || (name[3] == 'v')) && + ((name[4] == 'E') || (name[4] == 'e')) && (c = name[5]) && + (s = strchr (name+6,c)) && (i = s - (name + 6)) && (i < MAILTMPLEN)) { + if (stream = mail_open (stream,s+1,options)) { + strncpy (tmp,name+6,i); /* copy snarf mailbox name */ + tmp[i] = '\0'; /* tie off name */ + mail_parameters (stream,SET_SNARFMAILBOXNAME,(void *) tmp); + stream->snarf.options = options; + mail_ping (stream); /* do initial snarf */ + /* punt if can't do initial snarf */ + if (!stream->snarf.time) stream = mail_close (stream); + } + return stream; + } + /* special POP hack */ + else if (((name[1] == 'P') || (name[1] == 'p')) && + ((name[2] == 'O') || (name[2] == 'o')) && + ((name[3] == 'P') || (name[3] == 'p')) && + mail_valid_net_parse_work (name+4,&mb,"pop3") && + !strcmp (mb.service,"pop3") && !mb.anoflag && !mb.readonlyflag) { + if (stream = mail_open (stream,mb.mailbox,options)) { + sprintf (tmp,"{%.255s",mb.host); + if (mb.port) sprintf (tmp + strlen (tmp),":%lu",mb.port); + if (mb.user[0]) sprintf (tmp + strlen (tmp),"/user=%.64s",mb.user); + if (mb.dbgflag) strcat (tmp,"/debug"); + if (mb.secflag) strcat (tmp,"/secure"); + if (mb.tlsflag) strcat (tmp,"/tls"); + if (mb.notlsflag) strcat (tmp,"/notls"); + if (mb.sslflag) strcat (tmp,"/ssl"); + if (mb.trysslflag) strcat (tmp,"/tryssl"); + if (mb.novalidate) strcat (tmp,"/novalidate-cert"); + strcat (tmp,"/pop3/loser}"); + mail_parameters (stream,SET_SNARFMAILBOXNAME,(void *) tmp); + mail_ping (stream); /* do initial snarf */ + } + return stream; /* return local mailbox stream */ + } + + else if ((options & OP_PROTOTYPE) && + ((name[1] == 'D') || (name[1] == 'd')) && + ((name[2] == 'R') || (name[2] == 'r')) && + ((name[3] == 'I') || (name[3] == 'i')) && + ((name[4] == 'V') || (name[4] == 'v')) && + ((name[5] == 'E') || (name[5] == 'e')) && + ((name[6] == 'R') || (name[6] == 'r')) && (name[7] == '.')) { + sprintf (tmp,"%.80s",name+8); + /* tie off name at likely delimiter */ + if (s = strpbrk (tmp,"/\\:")) *s++ = '\0'; + else { + sprintf (tmp,"Can't resolve mailbox %.80s: bad driver syntax",name); + MM_LOG (tmp,ERROR); + return mail_close (stream); + } + for (d = maildrivers; d && compare_cstring (d->name,tmp); d = d->next); + if (d) return (*d->open) (NIL); + sprintf (tmp,"Can't resolve mailbox %.80s: unknown driver",name); + MM_LOG (tmp,ERROR); + return mail_close (stream); + } + /* fall through to default case */ + default: /* not special hack (but could be # name */ + d = mail_valid (NIL,name,(options & OP_SILENT) ? + (char *) NIL : "open mailbox"); + } + return d ? mail_open_work (d,stream,name,options) : stream; +} + +/* Mail open worker routine + * Accepts: factory + * candidate stream for recycling + * mailbox name + * open options + * Returns: stream to use on success, NIL on failure + */ + +MAILSTREAM *mail_open_work (DRIVER *d,MAILSTREAM *stream,char *name, + long options) +{ + int i; + char tmp[MAILTMPLEN]; + NETMBX mb; + if (options & OP_PROTOTYPE) return (*d->open) (NIL); + /* name is copied here in case the caller does a re-open using + * stream->mailbox or stream->original_mailbox as the argument. + */ + name = cpystr (name); /* make copy of name */ + if (stream) { /* recycling requested? */ + if ((stream->dtb == d) && (d->flags & DR_RECYCLE) && + ((d->flags & DR_HALFOPEN) || !(options & OP_HALFOPEN)) && + mail_usable_network_stream (stream,name)) { + /* yes, checkpoint if needed */ + if (d->flags & DR_XPOINT) mail_check (stream); + mail_free_cache (stream); /* clean up stream */ + if (stream->mailbox) fs_give ((void **) &stream->mailbox); + if (stream->original_mailbox) + fs_give ((void **) &stream->original_mailbox); + /* flush user flags */ + for (i = 0; i < NUSERFLAGS; i++) + if (stream->user_flags[i]) fs_give ((void **) &stream->user_flags[i]); + } + else { /* stream not recycleable, babble if net */ + if (!stream->silent && stream->dtb && !(stream->dtb->flags&DR_LOCAL) && + mail_valid_net_parse (stream->mailbox,&mb)) { + sprintf (tmp,"Closing connection to %.80s",mb.host); + MM_LOG (tmp,(long) NIL); + } + /* flush the old stream */ + stream = mail_close (stream); + } + } + /* check if driver does not support halfopen */ + else if ((options & OP_HALFOPEN) && !(d->flags & DR_HALFOPEN)) { + fs_give ((void **) &name); + return NIL; + } + + /* instantiate new stream if not recycling */ + if (!stream) (*mailcache) (stream = (MAILSTREAM *) + memset (fs_get (sizeof (MAILSTREAM)),0, + sizeof (MAILSTREAM)),(long) 0,CH_INIT); + stream->dtb = d; /* set dispatch */ + /* set mailbox name */ + stream->mailbox = cpystr (stream->original_mailbox = name); + /* initialize stream flags */ + stream->inbox = stream->lock = NIL; + stream->debug = (options & OP_DEBUG) ? T : NIL; + stream->rdonly = (options & OP_READONLY) ? T : NIL; + stream->anonymous = (options & OP_ANONYMOUS) ? T : NIL; + stream->scache = (options & OP_SHORTCACHE) ? T : NIL; + stream->silent = (options & OP_SILENT) ? T : NIL; + stream->halfopen = (options & OP_HALFOPEN) ? T : NIL; + stream->secure = (options & OP_SECURE) ? T : NIL; + stream->tryssl = (options & OP_TRYSSL) ? T : NIL; + stream->mulnewsrc = (options & OP_MULNEWSRC) ? T : NIL; + stream->nokod = (options & OP_NOKOD) ? T : NIL; + stream->sniff = (options & OP_SNIFF) ? T : NIL; + stream->perm_seen = stream->perm_deleted = stream->perm_flagged = + stream->perm_answered = stream->perm_draft = stream->kwd_create = NIL; + stream->uid_nosticky = (d->flags & DR_NOSTICKY) ? T : NIL; + stream->uid_last = 0; /* default UID validity */ + stream->uid_validity = (unsigned long) time (0); + /* have driver open, flush if failed */ + return ((*d->open) (stream)) ? stream : mail_close (stream); +} + +/* Mail close + * Accepts: mail stream + * close options + * Returns: NIL, always + */ + +MAILSTREAM *mail_close_full (MAILSTREAM *stream,long options) +{ + int i; + if (stream) { /* make sure argument given */ + /* do the driver's close action */ + if (stream->dtb) (*stream->dtb->close) (stream,options); + stream->dtb = NIL; /* resign driver */ + if (stream->mailbox) fs_give ((void **) &stream->mailbox); + if (stream->original_mailbox) + fs_give ((void **) &stream->original_mailbox); + if (stream->snarf.name) fs_give ((void **) &stream->snarf.name); + stream->sequence++; /* invalidate sequence */ + /* flush user flags */ + for (i = 0; i < NUSERFLAGS; i++) + if (stream->user_flags[i]) fs_give ((void **) &stream->user_flags[i]); + mail_free_cache (stream); /* finally free the stream's storage */ + if (mailfreestreamsparep && stream->sparep) + (*mailfreestreamsparep) (&stream->sparep); + if (!stream->use) fs_give ((void **) &stream); + } + return NIL; +} + +/* Mail make handle + * Accepts: mail stream + * Returns: handle + * + * Handles provide a way to have multiple pointers to a stream yet allow the + * stream's owner to nuke it or recycle it. + */ + +MAILHANDLE *mail_makehandle (MAILSTREAM *stream) +{ + MAILHANDLE *handle = (MAILHANDLE *) fs_get (sizeof (MAILHANDLE)); + handle->stream = stream; /* copy stream */ + /* and its sequence */ + handle->sequence = stream->sequence; + stream->use++; /* let stream know another handle exists */ + return handle; +} + + +/* Mail release handle + * Accepts: Mail handle + */ + +void mail_free_handle (MAILHANDLE **handle) +{ + MAILSTREAM *s; + if (*handle) { /* only free if exists */ + /* resign stream, flush unreferenced zombies */ + if ((!--(s = (*handle)->stream)->use) && !s->dtb) fs_give ((void **) &s); + fs_give ((void **) handle); /* now flush the handle */ + } +} + + +/* Mail get stream handle + * Accepts: Mail handle + * Returns: mail stream or NIL if stream gone + */ + +MAILSTREAM *mail_stream (MAILHANDLE *handle) +{ + MAILSTREAM *s = handle->stream; + return (s->dtb && (handle->sequence == s->sequence)) ? s : NIL; +} + +/* Mail fetch cache element + * Accepts: mail stream + * message # to fetch + * Returns: cache element of this message + * Can also be used to create cache elements for new messages. + */ + +MESSAGECACHE *mail_elt (MAILSTREAM *stream,unsigned long msgno) +{ + if (msgno < 1 || msgno > stream->nmsgs) { + char tmp[MAILTMPLEN]; + sprintf (tmp,"Bad msgno %lu in mail_elt, nmsgs = %lu, mbx=%.80s", + msgno,stream->nmsgs,stream->mailbox ? stream->mailbox : "???"); + fatal (tmp); + } + return (MESSAGECACHE *) (*mailcache) (stream,msgno,CH_MAKEELT); +} + + +/* Mail fetch fast information + * Accepts: mail stream + * sequence + * option flags + * + * Generally, mail_fetch_structure is preferred + */ + +void mail_fetch_fast (MAILSTREAM *stream,char *sequence,long flags) +{ + /* do the driver's action */ + if (stream->dtb && stream->dtb->fast) + (*stream->dtb->fast) (stream,sequence,flags); +} + + +/* Mail fetch flags + * Accepts: mail stream + * sequence + * option flags + */ + +void mail_fetch_flags (MAILSTREAM *stream,char *sequence,long flags) +{ + /* do the driver's action */ + if (stream->dtb && stream->dtb->msgflags) + (*stream->dtb->msgflags) (stream,sequence,flags); +} + +/* Mail fetch message overview + * Accepts: mail stream + * UID sequence to fetch + * pointer to overview return function + */ + +void mail_fetch_overview (MAILSTREAM *stream,char *sequence,overview_t ofn) +{ + if (stream->dtb && mail_uid_sequence (stream,sequence) && + !(stream->dtb->overview && (*stream->dtb->overview) (stream,ofn)) && + mail_ping (stream)) + mail_fetch_overview_default (stream,ofn); +} + + +/* Mail fetch message overview using sequence numbers instead of UIDs + * Accepts: mail stream + * sequence to fetch + * pointer to overview return function + */ + +void mail_fetch_overview_sequence (MAILSTREAM *stream,char *sequence, + overview_t ofn) +{ + if (stream->dtb && mail_sequence (stream,sequence) && + !(stream->dtb->overview && (*stream->dtb->overview) (stream,ofn)) && + mail_ping (stream)) + mail_fetch_overview_default (stream,ofn); +} + + +/* Mail fetch message overview default handler + * Accepts: mail stream with sequence bits lit + * pointer to overview return function + */ + +void mail_fetch_overview_default (MAILSTREAM *stream,overview_t ofn) +{ + MESSAGECACHE *elt; + ENVELOPE *env; + OVERVIEW ov; + unsigned long i; + ov.optional.lines = 0; + ov.optional.xref = NIL; + for (i = 1; i <= stream->nmsgs; i++) + if (((elt = mail_elt (stream,i))->sequence) && + (env = mail_fetch_structure (stream,i,NIL,NIL)) && ofn) { + ov.subject = env->subject; + ov.from = env->from; + ov.date = env->date; + ov.message_id = env->message_id; + ov.references = env->references; + ov.optional.octets = elt->rfc822_size; + (*ofn) (stream,mail_uid (stream,i),&ov,i); + } +} + +/* Mail fetch message structure + * Accepts: mail stream + * message # to fetch + * pointer to return body + * option flags + * Returns: envelope of this message, body returned in body value + * + * Fetches the "fast" information as well + */ + +ENVELOPE *mail_fetch_structure (MAILSTREAM *stream,unsigned long msgno, + BODY **body,long flags) +{ + ENVELOPE **env; + BODY **b; + MESSAGECACHE *elt; + char c,*s,*hdr; + unsigned long hdrsize; + STRING bs; + /* do the driver's action if specified */ + if (stream->dtb && stream->dtb->structure) + return (*stream->dtb->structure) (stream,msgno,body,flags); + if (flags & FT_UID) { /* UID form of call */ + if (msgno = mail_msgno (stream,msgno)) flags &= ~FT_UID; + else return NIL; /* must get UID/msgno map first */ + } + elt = mail_elt (stream,msgno);/* get elt for real message number */ + if (stream->scache) { /* short caching */ + if (msgno != stream->msgno){/* garbage collect if not same message */ + mail_gc (stream,GC_ENV | GC_TEXTS); + stream->msgno = msgno; /* this is the current message now */ + } + env = &stream->env; /* get pointers to envelope and body */ + b = &stream->body; + } + else { /* get pointers to elt envelope and body */ + env = &elt->private.msg.env; + b = &elt->private.msg.body; + } + + if (stream->dtb && ((body && !*b) || !*env || (*env)->incomplete)) { + mail_free_envelope (env); /* flush old envelope and body */ + mail_free_body (b); + /* see if need to fetch the whole thing */ + if (body || !elt->rfc822_size) { + s = (*stream->dtb->header) (stream,msgno,&hdrsize,flags & ~FT_INTERNAL); + /* make copy in case body fetch smashes it */ + hdr = (char *) memcpy (fs_get ((size_t) hdrsize+1),s,(size_t) hdrsize); + hdr[hdrsize] = '\0'; /* tie off header */ + (*stream->dtb->text) (stream,msgno,&bs,(flags & ~FT_INTERNAL) | FT_PEEK); + if (!elt->rfc822_size) elt->rfc822_size = hdrsize + SIZE (&bs); + if (body) /* only parse body if requested */ + rfc822_parse_msg (env,b,hdr,hdrsize,&bs,BADHOST,stream->dtb->flags); + else + rfc822_parse_msg (env,NIL,hdr,hdrsize,NIL,BADHOST,stream->dtb->flags); + fs_give ((void **) &hdr); /* flush header */ + } + else { /* can save memory doing it this way */ + hdr = (*stream->dtb->header) (stream,msgno,&hdrsize,flags | FT_INTERNAL); + if (hdrsize) { /* in case null header */ + c = hdr[hdrsize]; /* preserve what's there */ + hdr[hdrsize] = '\0'; /* tie off header */ + rfc822_parse_msg (env,NIL,hdr,hdrsize,NIL,BADHOST,stream->dtb->flags); + hdr[hdrsize] = c; /* restore in case cached data */ + } + else *env = mail_newenvelope (); + } + } + /* if need date, have date in envelope? */ + if (!elt->day && *env && (*env)->date) mail_parse_date (elt,(*env)->date); + /* sigh, fill in bogus default */ + if (!elt->day) elt->day = elt->month = 1; + if (body) *body = *b; /* return the body */ + return *env; /* return the envelope */ +} + +/* Mail mark single message (internal use only) + * Accepts: mail stream + * elt to mark + * fetch flags + */ + +static void markseen (MAILSTREAM *stream,MESSAGECACHE *elt,long flags) +{ + unsigned long i; + char sequence[20]; + MESSAGECACHE *e; + /* non-peeking and needs to set \Seen? */ + if (!(flags & FT_PEEK) && !elt->seen) { + if (stream->dtb->flagmsg){ /* driver wants per-message call? */ + elt->valid = NIL; /* do pre-alteration driver call */ + (*stream->dtb->flagmsg) (stream,elt); + /* set seen, do post-alteration driver call */ + elt->seen = elt->valid = T; + (*stream->dtb->flagmsg) (stream,elt); + } + if (stream->dtb->flag) { /* driver wants one-time call? */ + /* better safe than sorry, save seq bits */ + for (i = 1; i <= stream->nmsgs; i++) { + e = mail_elt (stream,i); + e->private.sequence = e->sequence; + } + /* call driver to set the message */ + sprintf (sequence,"%lu",elt->msgno); + (*stream->dtb->flag) (stream,sequence,"\\Seen",ST_SET); + /* restore sequence bits */ + for (i = 1; i <= stream->nmsgs; i++) { + e = mail_elt (stream,i); + e->sequence = e->private.sequence; + } + } + /* notify mail program of flag change */ + MM_FLAGS (stream,elt->msgno); + } +} + +/* Mail fetch message + * Accepts: mail stream + * message # to fetch + * pointer to returned length + * flags + * Returns: message text + */ + +char *mail_fetch_message (MAILSTREAM *stream,unsigned long msgno, + unsigned long *len,long flags) +{ + GETS_DATA md; + SIZEDTEXT *t; + STRING bs; + MESSAGECACHE *elt; + char *s,*u; + unsigned long i,j; + if (len) *len = 0; /* default return size */ + if (flags & FT_UID) { /* UID form of call */ + if (msgno = mail_msgno (stream,msgno)) flags &= ~FT_UID; + else return ""; /* must get UID/msgno map first */ + } + /* initialize message data identifier */ + INIT_GETS (md,stream,msgno,"",0,0); + /* is data already cached? */ + if ((t = &(elt = mail_elt (stream,msgno))->private.msg.full.text)->data) { + markseen (stream,elt,flags);/* mark message seen */ + return mail_fetch_text_return (&md,t,len); + } + if (!stream->dtb) return ""; /* not in cache, must have live driver */ + if (stream->dtb->msgdata) return + ((*stream->dtb->msgdata) (stream,msgno,"",0,0,NIL,flags) && t->data) ? + mail_fetch_text_return (&md,t,len) : ""; + /* ugh, have to do this the crufty way */ + u = mail_fetch_header (stream,msgno,NIL,NIL,&i,flags); + /* copy in case text method stomps on it */ + s = (char *) memcpy (fs_get ((size_t) i),u,(size_t) i); + if ((*stream->dtb->text) (stream,msgno,&bs,flags)) { + t = &stream->text; /* build combined copy */ + if (t->data) fs_give ((void **) &t->data); + t->data = (unsigned char *) fs_get ((t->size = i + SIZE (&bs)) + 1); + if (!elt->rfc822_size) elt->rfc822_size = t->size; + else if (elt->rfc822_size != t->size) { + char tmp[MAILTMPLEN]; + sprintf (tmp,"Calculated RFC822.SIZE (%lu) != reported size (%lu)", + t->size,elt->rfc822_size); + mm_log (tmp,WARN); /* bug trap */ + } + memcpy (t->data,s,(size_t) i); + for (u = (char *) t->data + i, j = SIZE (&bs); j;) { + memcpy (u,bs.curpos,bs.cursize); + u += bs.cursize; /* update text */ + j -= bs.cursize; + bs.curpos += (bs.cursize -1); + bs.cursize = 0; + (*bs.dtb->next) (&bs); /* advance to next buffer's worth */ + } + *u = '\0'; /* tie off data */ + u = mail_fetch_text_return (&md,t,len); + } + else u = ""; + fs_give ((void **) &s); /* finished with copy of header */ + return u; +} + +/* Mail fetch message header + * Accepts: mail stream + * message # to fetch + * MIME section specifier (#.#.#...#) + * list of lines to fetch + * pointer to returned length + * flags + * Returns: message header in RFC822 format + * + * Note: never calls a mailgets routine + */ + +char *mail_fetch_header (MAILSTREAM *stream,unsigned long msgno,char *section, + STRINGLIST *lines,unsigned long *len,long flags) +{ + STRING bs; + BODY *b = NIL; + SIZEDTEXT *t = NIL,rt; + MESSAGE *m = NIL; + MESSAGECACHE *elt; + char tmp[MAILTMPLEN]; + if (len) *len = 0; /* default return size */ + if (section && (strlen (section) > (MAILTMPLEN - 20))) return ""; + if (flags & FT_UID) { /* UID form of call */ + if (msgno = mail_msgno (stream,msgno)) flags &= ~FT_UID; + else return ""; /* must get UID/msgno map first */ + } + elt = mail_elt (stream,msgno);/* get cache data */ + if (section && *section) { /* nested body header wanted? */ + if (!((b = mail_body (stream,msgno,section)) && + (b->type == TYPEMESSAGE) && !strcmp (b->subtype,"RFC822"))) + return ""; /* lose if no body or not MESSAGE/RFC822 */ + m = b->nested.msg; /* point to nested message */ + } + /* else top-level message header wanted */ + else m = &elt->private.msg; + if (m->header.text.data && mail_match_lines (lines,m->lines,flags)) { + if (lines) textcpy (t = &stream->text,&m->header.text); + else t = &m->header.text; /* in cache, and cache is valid */ + markseen (stream,elt,flags);/* mark message seen */ + } + + else if (stream->dtb) { /* not in cache, has live driver? */ + if (stream->dtb->msgdata) { /* has driver section fetch? */ + /* build driver section specifier */ + if (section && *section) sprintf (tmp,"%s.HEADER",section); + else strcpy (tmp,"HEADER"); + if ((*stream->dtb->msgdata) (stream,msgno,tmp,0,0,lines,flags)) { + t = &m->header.text; /* fetch data */ + /* don't need to postprocess lines */ + if (m->lines) lines = NIL; + else if (lines) textcpy (t = &stream->text,&m->header.text); + } + } + else if (b) { /* nested body wanted? */ + if (stream->private.search.text) { + rt.data = (unsigned char *) stream->private.search.text + + b->nested.msg->header.offset; + rt.size = b->nested.msg->header.text.size; + t = &rt; + } + else if ((*stream->dtb->text) (stream,msgno,&bs,flags & ~FT_INTERNAL)) { + if ((bs.dtb->next == mail_string_next) && !lines) { + rt.data = (unsigned char *) bs.curpos + b->nested.msg->header.offset; + rt.size = b->nested.msg->header.text.size; + if (stream->private.search.string) + stream->private.search.text = bs.curpos; + t = &rt; /* special hack to avoid extra copy */ + } + else textcpyoffstring (t = &stream->text,&bs, + b->nested.msg->header.offset, + b->nested.msg->header.text.size); + } + } + else { /* top-level header fetch */ + /* mark message seen */ + markseen (stream,elt,flags); + if (rt.data = (unsigned char *) + (*stream->dtb->header) (stream,msgno,&rt.size,flags)) { + /* make a safe copy if need to filter */ + if (lines) textcpy (t = &stream->text,&rt); + else t = &rt; /* top level header */ + } + } + } + if (!t || !t->data) return "";/* error if no string */ + /* filter headers if requested */ + if (lines) t->size = mail_filter ((char *) t->data,t->size,lines,flags); + if (len) *len = t->size; /* return size if requested */ + return (char *) t->data; /* and text */ +} + +/* Mail fetch message text + * Accepts: mail stream + * message # to fetch + * MIME section specifier (#.#.#...#) + * pointer to returned length + * flags + * Returns: message text + */ + +char *mail_fetch_text (MAILSTREAM *stream,unsigned long msgno,char *section, + unsigned long *len,long flags) +{ + GETS_DATA md; + PARTTEXT *p; + STRING bs; + MESSAGECACHE *elt; + BODY *b = NIL; + char tmp[MAILTMPLEN]; + unsigned long i; + if (len) *len = 0; /* default return size */ + memset (&stream->private.string,NIL,sizeof (STRING)); + if (section && (strlen (section) > (MAILTMPLEN - 20))) return ""; + if (flags & FT_UID) { /* UID form of call */ + if (msgno = mail_msgno (stream,msgno)) flags &= ~FT_UID; + else return ""; /* must get UID/msgno map first */ + } + elt = mail_elt (stream,msgno);/* get cache data */ + if (section && *section) { /* nested body text wanted? */ + if (!((b = mail_body (stream,msgno,section)) && + (b->type == TYPEMESSAGE) && !strcmp (b->subtype,"RFC822"))) + return ""; /* lose if no body or not MESSAGE/RFC822 */ + p = &b->nested.msg->text; /* point at nested message */ + /* build IMAP-format section specifier */ + sprintf (tmp,"%s.TEXT",section); + flags &= ~FT_INTERNAL; /* can't win with this set */ + } + else { /* top-level message text wanted */ + p = &elt->private.msg.text; + strcpy (tmp,"TEXT"); + } + /* initialize message data identifier */ + INIT_GETS (md,stream,msgno,section,0,0); + if (p->text.data) { /* is data already cached? */ + markseen (stream,elt,flags);/* mark message seen */ + return mail_fetch_text_return (&md,&p->text,len); + } + if (!stream->dtb) return ""; /* not in cache, must have live driver */ + if (stream->dtb->msgdata) return + ((*stream->dtb->msgdata) (stream,msgno,tmp,0,0,NIL,flags) && p->text.data)? + mail_fetch_text_return (&md,&p->text,len) : ""; + if (!(*stream->dtb->text) (stream,msgno,&bs,flags)) return ""; + if (section && *section) { /* nested is more complex */ + SETPOS (&bs,p->offset); + i = p->text.size; /* just want this much */ + } + else i = SIZE (&bs); /* want entire text */ + return mail_fetch_string_return (&md,&bs,i,len,flags); +} + +/* Mail fetch message body part MIME headers + * Accepts: mail stream + * message # to fetch + * MIME section specifier (#.#.#...#) + * pointer to returned length + * flags + * Returns: message text + */ + +char *mail_fetch_mime (MAILSTREAM *stream,unsigned long msgno,char *section, + unsigned long *len,long flags) +{ + PARTTEXT *p; + STRING bs; + BODY *b; + char tmp[MAILTMPLEN]; + if (len) *len = 0; /* default return size */ + if (section && (strlen (section) > (MAILTMPLEN - 20))) return ""; + if (flags & FT_UID) { /* UID form of call */ + if (msgno = mail_msgno (stream,msgno)) flags &= ~FT_UID; + else return ""; /* must get UID/msgno map first */ + } + flags &= ~FT_INTERNAL; /* can't win with this set */ + if (!(section && *section && (b = mail_body (stream,msgno,section)))) + return ""; /* not valid section */ + /* in cache? */ + if ((p = &b->mime)->text.data) { + /* mark message seen */ + markseen (stream,mail_elt (stream,msgno),flags); + if (len) *len = p->text.size; + return (char *) p->text.data; + } + if (!stream->dtb) return ""; /* not in cache, must have live driver */ + if (stream->dtb->msgdata) { /* has driver fetch? */ + /* build driver section specifier */ + sprintf (tmp,"%s.MIME",section); + if ((*stream->dtb->msgdata) (stream,msgno,tmp,0,0,NIL,flags) && + p->text.data) { + if (len) *len = p->text.size; + return (char *) p->text.data; + } + else return ""; + } + if (len) *len = b->mime.text.size; + if (!b->mime.text.size) { /* empty MIME header -- mark seen anyway */ + markseen (stream,mail_elt (stream,msgno),flags); + return ""; + } + /* have to get it from offset */ + if (stream->private.search.text) + return stream->private.search.text + b->mime.offset; + if (!(*stream->dtb->text) (stream,msgno,&bs,flags)) { + if (len) *len = 0; + return ""; + } + if (bs.dtb->next == mail_string_next) { + if (stream->private.search.string) stream->private.search.text = bs.curpos; + return bs.curpos + b->mime.offset; + } + return textcpyoffstring (&stream->text,&bs,b->mime.offset,b->mime.text.size); +} + +/* Mail fetch message body part + * Accepts: mail stream + * message # to fetch + * MIME section specifier (#.#.#...#) + * pointer to returned length + * flags + * Returns: message body + */ + +char *mail_fetch_body (MAILSTREAM *stream,unsigned long msgno,char *section, + unsigned long *len,long flags) +{ + GETS_DATA md; + PARTTEXT *p; + STRING bs; + BODY *b; + SIZEDTEXT *t; + char *s,tmp[MAILTMPLEN]; + memset (&stream->private.string,NIL,sizeof (STRING)); + if (!(section && *section)) /* top-level text wanted? */ + return mail_fetch_message (stream,msgno,len,flags); + else if (strlen (section) > (MAILTMPLEN - 20)) return ""; + flags &= ~FT_INTERNAL; /* can't win with this set */ + /* initialize message data identifier */ + INIT_GETS (md,stream,msgno,section,0,0); + /* kludge for old section 0 header */ + if (!strcmp (s = strcpy (tmp,section),"0") || + ((s = strstr (tmp,".0")) && !s[2])) { + SIZEDTEXT ht; + *s = '\0'; /* tie off section */ + /* this silly way so it does mailgets */ + ht.data = (unsigned char *) mail_fetch_header (stream,msgno, + tmp[0] ? tmp : NIL,NIL, + &ht.size,flags); + /* may have UIDs here */ + md.flags = (flags & FT_UID) ? MG_UID : NIL; + return mail_fetch_text_return (&md,&ht,len); + } + if (len) *len = 0; /* default return size */ + if (flags & FT_UID) { /* UID form of call */ + if (msgno = mail_msgno (stream,msgno)) flags &= ~FT_UID; + else return ""; /* must get UID/msgno map first */ + } + /* must have body */ + if (!(b = mail_body (stream,msgno,section))) return ""; + /* have cached text? */ + if ((t = &(p = &b->contents)->text)->data) { + /* mark message seen */ + markseen (stream,mail_elt (stream,msgno),flags); + return mail_fetch_text_return (&md,t,len); + } + if (!stream->dtb) return ""; /* not in cache, must have live driver */ + if (stream->dtb->msgdata) return + ((*stream->dtb->msgdata)(stream,msgno,section,0,0,NIL,flags) && t->data) ? + mail_fetch_text_return (&md,t,len) : ""; + if (len) *len = t->size; + if (!t->size) { /* empty body part -- mark seen anyway */ + markseen (stream,mail_elt (stream,msgno),flags); + return ""; + } + /* copy body from stringstruct offset */ + if (stream->private.search.text) + return stream->private.search.text + p->offset; + if (!(*stream->dtb->text) (stream,msgno,&bs,flags)) { + if (len) *len = 0; + return ""; + } + if (bs.dtb->next == mail_string_next) { + if (stream->private.search.string) stream->private.search.text = bs.curpos; + return bs.curpos + p->offset; + } + SETPOS (&bs,p->offset); + return mail_fetch_string_return (&md,&bs,t->size,len,flags); +} + +/* Mail fetch partial message text + * Accepts: mail stream + * message # to fetch + * MIME section specifier (#.#.#...#) + * offset of first designed byte or 0 to start at beginning + * maximum number of bytes or 0 for all bytes + * flags + * Returns: T if successful, else NIL + */ + +long mail_partial_text (MAILSTREAM *stream,unsigned long msgno,char *section, + unsigned long first,unsigned long last,long flags) +{ + GETS_DATA md; + PARTTEXT *p = NIL; + MESSAGECACHE *elt; + STRING bs; + BODY *b; + char tmp[MAILTMPLEN]; + unsigned long i; + if (!mailgets) fatal ("mail_partial_text() called without a mailgets!"); + if (section && (strlen (section) > (MAILTMPLEN - 20))) return NIL; + if (flags & FT_UID) { /* UID form of call */ + if (msgno = mail_msgno (stream,msgno)) flags &= ~FT_UID; + else return NIL; /* must get UID/msgno map first */ + } + elt = mail_elt (stream,msgno);/* get cache data */ + flags &= ~FT_INTERNAL; /* bogus if this is set */ + if (section && *section) { /* nested body text wanted? */ + if (!((b = mail_body (stream,msgno,section)) && + (b->type == TYPEMESSAGE) && !strcmp (b->subtype,"RFC822"))) + return NIL; /* lose if no body or not MESSAGE/RFC822 */ + p = &b->nested.msg->text; /* point at nested message */ + /* build IMAP-format section specifier */ + sprintf (tmp,"%s.TEXT",section); + } + else { /* else top-level message text wanted */ + p = &elt->private.msg.text; + strcpy (tmp,"TEXT"); + } + + /* initialize message data identifier */ + INIT_GETS (md,stream,msgno,tmp,first,last); + if (p->text.data) { /* is data already cached? */ + INIT (&bs,mail_string,p->text.data,i = p->text.size); + markseen (stream,elt,flags);/* mark message seen */ + } + else { /* else get data from driver */ + if (!stream->dtb) return NIL; + if (stream->dtb->msgdata) /* driver will handle this */ + return (*stream->dtb->msgdata) (stream,msgno,tmp,first,last,NIL,flags); + if (!(*stream->dtb->text) (stream,msgno,&bs,flags)) return NIL; + if (section && *section) { /* nexted if more complex */ + SETPOS (&bs,p->offset); /* offset stringstruct to data */ + i = p->text.size; /* maximum size of data */ + } + else i = SIZE (&bs); /* just want this much */ + } + if (i <= first) i = first = 0;/* first byte is beyond end of text */ + /* truncate as needed */ + else { /* offset and truncate */ + SETPOS (&bs,first + GETPOS (&bs)); + i -= first; /* reduced size */ + if (last && (i > last)) i = last; + } + /* do the mailgets thing */ + (*mailgets) (mail_read,&bs,i,&md); + return T; /* success */ +} + +/* Mail fetch partial message body part + * Accepts: mail stream + * message # to fetch + * MIME section specifier (#.#.#...#) + * offset of first designed byte or 0 to start at beginning + * maximum number of bytes or 0 for all bytes + * flags + * Returns: T if successful, else NIL + */ + +long mail_partial_body (MAILSTREAM *stream,unsigned long msgno,char *section, + unsigned long first,unsigned long last,long flags) +{ + GETS_DATA md; + PARTTEXT *p; + STRING bs; + BODY *b; + SIZEDTEXT *t; + unsigned long i; + if (!(section && *section)) /* top-level text wanted? */ + return mail_partial_text (stream,msgno,NIL,first,last,flags); + if (!mailgets) fatal ("mail_partial_body() called without a mailgets!"); + if (flags & FT_UID) { /* UID form of call */ + if (msgno = mail_msgno (stream,msgno)) flags &= ~FT_UID; + else return NIL; /* must get UID/msgno map first */ + } + /* must have body */ + if (!(b = mail_body (stream,msgno,section))) return NIL; + flags &= ~FT_INTERNAL; /* bogus if this is set */ + + /* initialize message data identifier */ + INIT_GETS (md,stream,msgno,section,first,last); + /* have cached text? */ + if ((t = &(p = &b->contents)->text)->data) { + /* mark message seen */ + markseen (stream,mail_elt (stream,msgno),flags); + INIT (&bs,mail_string,t->data,i = t->size); + } + else { /* else get data from driver */ + if (!stream->dtb) return NIL; + if (stream->dtb->msgdata) /* driver will handle this */ + return (*stream->dtb->msgdata) (stream,msgno,section,first,last,NIL, + flags); + if (!(*stream->dtb->text) (stream,msgno,&bs,flags)) return NIL; + if (section && *section) { /* nexted if more complex */ + SETPOS (&bs,p->offset); /* offset stringstruct to data */ + i = t->size; /* maximum size of data */ + } + else i = SIZE (&bs); /* just want this much */ + } + if (i <= first) i = first = 0;/* first byte is beyond end of text */ + else { /* offset and truncate */ + SETPOS (&bs,first + GETPOS (&bs)); + i -= first; /* reduced size */ + if (last && (i > last)) i = last; + } + /* do the mailgets thing */ + (*mailgets) (mail_read,&bs,i,&md); + return T; /* success */ +} + +/* Mail return message text + * Accepts: identifier data + * sized text + * pointer to returned length + * Returns: text + */ + +char *mail_fetch_text_return (GETS_DATA *md,SIZEDTEXT *t,unsigned long *len) +{ + STRING bs; + if (len) *len = t->size; /* return size */ + if (t->size && mailgets) { /* have to do the mailgets thing? */ + /* silly but do it anyway for consistency */ + INIT (&bs,mail_string,t->data,t->size); + return (*mailgets) (mail_read,&bs,t->size,md); + } + return t->size ? (char *) t->data : ""; +} + + +/* Mail return message string + * Accepts: identifier data + * stringstruct + * text length + * pointer to returned length + * flags + * Returns: text, or NIL if stringstruct returned + */ + +char *mail_fetch_string_return (GETS_DATA *md,STRING *bs,unsigned long i, + unsigned long *len,long flags) +{ + char *ret = NIL; + if (len) *len = i; /* return size */ + /* return stringstruct hack */ + if (flags & FT_RETURNSTRINGSTRUCT) { + memcpy (&md->stream->private.string,bs,sizeof (STRING)); + SETPOS (&md->stream->private.string,GETPOS (&md->stream->private.string)); + } + /* have to do the mailgets thing? */ + else if (mailgets) ret = (*mailgets) (mail_read,bs,i,md); + /* special hack to avoid extra copy */ + else if (bs->dtb->next == mail_string_next) ret = bs->curpos; + /* make string copy in memory */ + else ret = textcpyoffstring (&md->stream->text,bs,GETPOS (bs),i); + return ret; +} + +/* Read data from stringstruct + * Accepts: stringstruct + * size of data to read + * buffer to read into + * Returns: T, always, stringstruct updated + */ + +long mail_read (void *stream,unsigned long size,char *buffer) +{ + unsigned long i; + STRING *s = (STRING *) stream; + while (size) { /* until satisfied */ + memcpy (buffer,s->curpos,i = min (s->cursize,size)); + buffer += i; /* update buffer */ + size -= i; /* note that we read this much */ + s->curpos += --i; /* advance that many spaces minus 1 */ + s->cursize -= i; + SNX (s); /* now use SNX to advance the last byte */ + } + return T; +} + +/* Mail fetch UID + * Accepts: mail stream + * message number + * Returns: UID or zero if dead stream + */ + +unsigned long mail_uid (MAILSTREAM *stream,unsigned long msgno) +{ + unsigned long uid = mail_elt (stream,msgno)->private.uid; + return uid ? uid : + (stream->dtb && stream->dtb->uid) ? (*stream->dtb->uid) (stream,msgno) : 0; +} + + +/* Mail fetch msgno from UID + * Accepts: mail stream + * UID + * Returns: msgno or zero if failed + */ + +unsigned long mail_msgno (MAILSTREAM *stream,unsigned long uid) +{ + unsigned long msgno,delta,first,firstuid,last,lastuid,middle,miduid; + if (stream->dtb) { /* active stream? */ + if (stream->dtb->msgno) /* direct way */ + return (*stream->dtb->msgno) (stream,uid); + else if (stream->dtb->uid) {/* indirect way */ + /* Placeholder for now, since currently there are no drivers which + * have a uid method but not a msgno method + */ + for (msgno = 1; msgno <= stream->nmsgs; msgno++) + if ((*stream->dtb->uid) (stream,msgno) == uid) return msgno; + } + /* binary search since have full map */ + else for (first = 1,last = stream->nmsgs, delta = (first <= last) ? 1 : 0; + delta && + (uid >= (firstuid = mail_elt (stream,first)->private.uid)) && + (uid <= (lastuid = mail_elt (stream,last)->private.uid));) { + /* done if match at an endpoint */ + if (uid == firstuid) return first; + if (uid == lastuid) return last; + /* have anything between endpoints? */ + if (delta = ((last - first) / 2)) { + if ((miduid = mail_elt (stream,middle = first + delta)->private.uid) + == uid) + return middle; /* found match in middle */ + else if (uid < miduid) last = middle - 1; + else first = middle + 1; + } + } + } + else { /* dead stream, do linear search for UID */ + for (msgno = 1; msgno <= stream->nmsgs; msgno++) + if (mail_elt (stream,msgno)->private.uid == uid) return msgno; + } + return 0; /* didn't find the UID anywhere */ +} + +/* Mail fetch From string for menu + * Accepts: destination string + * mail stream + * message # to fetch + * desired string length + * Returns: string of requested length + */ + +void mail_fetchfrom (char *s,MAILSTREAM *stream,unsigned long msgno, + long length) +{ + char *t; + char tmp[MAILTMPLEN]; + ENVELOPE *env = mail_fetchenvelope (stream,msgno); + ADDRESS *adr = env ? env->from : NIL; + memset (s,' ',(size_t)length);/* fill it with spaces */ + s[length] = '\0'; /* tie off with null */ + /* get first from address from envelope */ + while (adr && !adr->host) adr = adr->next; + if (adr) { /* if a personal name exists use it */ + if (!(t = adr->personal)) + sprintf (t = tmp,"%.256s@%.256s",adr->mailbox,adr->host); + memcpy (s,t,(size_t) min (length,(long) strlen (t))); + } +} + + +/* Mail fetch Subject string for menu + * Accepts: destination string + * mail stream + * message # to fetch + * desired string length + * Returns: string of no more than requested length + */ + +void mail_fetchsubject (char *s,MAILSTREAM *stream,unsigned long msgno, + long length) +{ + ENVELOPE *env = mail_fetchenvelope (stream,msgno); + memset (s,'\0',(size_t) length+1); + /* copy subject from envelope */ + if (env && env->subject) strncpy (s,env->subject,(size_t) length); + else *s = ' '; /* if no subject then just a space */ +} + +/* Mail modify flags + * Accepts: mail stream + * sequence + * flag(s) + * option flags + */ + +void mail_flag (MAILSTREAM *stream,char *sequence,char *flag,long flags) +{ + MESSAGECACHE *elt; + unsigned long i,uf; + long f; + short nf; + if (!stream->dtb) return; /* no-op if no stream */ + if ((stream->dtb->flagmsg || !stream->dtb->flag) && + ((flags & ST_UID) ? mail_uid_sequence (stream,sequence) : + mail_sequence (stream,sequence)) && + ((f = mail_parse_flags (stream,flag,&uf)) || uf)) + for (i = 1,nf = (flags & ST_SET) ? T : NIL; i <= stream->nmsgs; i++) + if ((elt = mail_elt (stream,i))->sequence) { + struct { /* old flags */ + unsigned int valid : 1; + unsigned int seen : 1; + unsigned int deleted : 1; + unsigned int flagged : 1; + unsigned int answered : 1; + unsigned int draft : 1; + unsigned long user_flags; + } old; + old.valid = elt->valid; old.seen = elt->seen; + old.deleted = elt->deleted; old.flagged = elt->flagged; + old.answered = elt->answered; old.draft = elt->draft; + old.user_flags = elt->user_flags; + elt->valid = NIL; /* prepare for flag alteration */ + if (stream->dtb->flagmsg) (*stream->dtb->flagmsg) (stream,elt); + if (f&fSEEN) elt->seen = nf; + if (f&fDELETED) elt->deleted = nf; + if (f&fFLAGGED) elt->flagged = nf; + if (f&fANSWERED) elt->answered = nf; + if (f&fDRAFT) elt->draft = nf; + /* user flags */ + if (flags & ST_SET) elt->user_flags |= uf; + else elt->user_flags &= ~uf; + elt->valid = T; /* flags now altered */ + if ((old.valid != elt->valid) || (old.seen != elt->seen) || + (old.deleted != elt->deleted) || (old.flagged != elt->flagged) || + (old.answered != elt->answered) || (old.draft != elt->draft) || + (old.user_flags != elt->user_flags)) + MM_FLAGS (stream,elt->msgno); + if (stream->dtb->flagmsg) (*stream->dtb->flagmsg) (stream,elt); + } + /* call driver once */ + if (stream->dtb->flag) (*stream->dtb->flag) (stream,sequence,flag,flags); +} + +/* Mail search for messages + * Accepts: mail stream + * character set + * search program + * option flags + * Returns: T if successful, NIL if dead stream, NIL searchpgm or bad charset + */ + +long mail_search_full (MAILSTREAM *stream,char *charset,SEARCHPGM *pgm, + long flags) +{ + unsigned long i; + long ret = NIL; + if (!(flags & SE_RETAIN)) /* clear search vector unless retaining */ + for (i = 1; i <= stream->nmsgs; ++i) mail_elt (stream,i)->searched = NIL; + if (pgm && stream->dtb) /* must have a search program and driver */ + ret = (*(stream->dtb->search ? stream->dtb->search : mail_search_default)) + (stream,charset,pgm,flags); + /* flush search program if requested */ + if (flags & SE_FREE) mail_free_searchpgm (&pgm); + return ret; +} + + +/* Mail search for messages default handler + * Accepts: mail stream + * character set + * search program + * option flags + * Returns: T if successful, NIL if bad charset + */ + +long mail_search_default (MAILSTREAM *stream,char *charset,SEARCHPGM *pgm, + long flags) +{ + unsigned long i; + char *msg; + /* make sure that charset is good */ + if (msg = utf8_badcharset (charset)) { + MM_LOG (msg,ERROR); /* output error */ + fs_give ((void **) &msg); + return NIL; + } + utf8_searchpgm (pgm,charset); + for (i = 1; i <= stream->nmsgs; ++i) + if (mail_search_msg (stream,i,NIL,pgm)) { + if (flags & SE_UID) mm_searched (stream,mail_uid (stream,i)); + else { /* mark as searched, notify mail program */ + mail_elt (stream,i)->searched = T; + if (!stream->silent) mm_searched (stream,i); + } + } + return LONGT; /* search completed */ +} + +/* Mail ping mailbox + * Accepts: mail stream + * Returns: stream if still open else NIL + */ + +long mail_ping (MAILSTREAM *stream) +{ + unsigned long i,n,uf,len; + char *s,*f,tmp[MAILTMPLEN],flags[MAILTMPLEN]; + MAILSTREAM *snarf; + MESSAGECACHE *elt; + STRING bs; + long ret; + /* do driver action */ + if ((ret = ((stream && stream->dtb) ? (stream->dtb->ping) (stream) : NIL)) && + stream->snarf.name && /* time to snarf? */ + /* prohibit faster than once/min */ + (time (0) > (time_t) (stream->snarf.time + min(60,mailsnarfinterval))) && + (snarf = mail_open (NIL,stream->snarf.name, + stream->snarf.options | OP_SILENT))) { + if ((n = snarf->nmsgs) && /* yes, have messages to snarf? */ + mail_search_full (snarf,NIL,mail_criteria ("UNDELETED"),SE_FREE)) { + for (i = 1; ret && (i <= n); i++) /* for each message */ + if ((elt = mail_elt (snarf,i))->searched && + (s = mail_fetch_message (snarf,i,&len,FT_PEEK)) && len) { + INIT (&bs,mail_string,s,len); + if (mailsnarfpreserve) { + /* yes, make sure have fast data */ + if (!elt->valid || !elt->day) { + sprintf (tmp,"%lu",n); + mail_fetch_fast (snarf,tmp,NIL); + } + /* initialize flag string */ + memset (flags,0,MAILTMPLEN); + /* output system flags except \Deleted */ + if (elt->seen) strcat (flags," \\Seen"); + if (elt->flagged) strcat (flags," \\Flagged"); + if (elt->answered) strcat (flags," \\Answered"); + if (elt->draft) strcat (flags," \\Draft"); + /* any user flags? */ + for (uf = elt->user_flags,s = flags + strlen (flags); + uf && (f = stream->user_flags[find_rightmost_bit (&uf)]) && + ((MAILTMPLEN - (s - tmp)) > (long) (2 + strlen (f))); + s += strlen (s)) sprintf (s," %s",f); + ret = mail_append_full (stream,stream->mailbox,flags + 1, + mail_date (tmp,elt),&bs); + } + else ret = mail_append (stream,stream->mailbox,&bs); + + if (ret) { /* did snarf succeed? */ + /* driver has per-message (or no) flag call */ + if (snarf->dtb->flagmsg || !snarf->dtb->flag) { + elt->valid = NIL; /* prepare for flag alteration */ + if (snarf->dtb->flagmsg) (*snarf->dtb->flagmsg) (snarf,elt); + /* flags now altered */ + elt->deleted = elt->seen = elt->valid = T; + if (snarf->dtb->flagmsg) (*snarf->dtb->flagmsg) (snarf,elt); + } + /* driver has one-time flag call */ + if (snarf->dtb->flag) { + sprintf (tmp,"%lu",i); + (*snarf->dtb->flag) (snarf,tmp,"\\Deleted \\Seen",ST_SET); + } + } + else { /* copy failed */ + sprintf (tmp,"Unable to move message %lu from %s mailbox", + i,snarf->dtb->name); + mm_log (tmp,WARN); + } + } + } + /* expunge the messages */ + mail_close_full (snarf,n ? CL_EXPUNGE : NIL); + stream->snarf.time = (unsigned long) time (0); + /* Even if the snarf failed, we don't want to return NIL if the stream + * is still alive. Or at least that's what we currently think. + */ + /* redo the driver's action */ + ret = stream->dtb ? (*stream->dtb->ping) (stream) : NIL; + } + return ret; +} + +/* Mail check mailbox + * Accepts: mail stream + */ + +void mail_check (MAILSTREAM *stream) +{ + /* do the driver's action */ + if (stream->dtb) (*stream->dtb->check) (stream); +} + + +/* Mail expunge mailbox + * Accepts: mail stream + * sequence to expunge if non-NIL + * expunge options + * Returns: T on success, NIL on failure + */ + +long mail_expunge_full (MAILSTREAM *stream,char *sequence,long options) +{ + /* do the driver's action */ + return stream->dtb ? (*stream->dtb->expunge) (stream,sequence,options) : NIL; +} + + +/* Mail copy message(s) + * Accepts: mail stream + * sequence + * destination mailbox + * flags + */ + +long mail_copy_full (MAILSTREAM *stream,char *sequence,char *mailbox, + long options) +{ + return stream->dtb ? + SAFE_COPY (stream->dtb,stream,sequence,mailbox,options) : NIL; +} + +/* Append data package to use for old single-message mail_append() interface */ + +typedef struct mail_append_package { + char *flags; /* initial flags */ + char *date; /* message internal date */ + STRING *message; /* stringstruct of message */ +} APPENDPACKAGE; + + +/* Single append message string + * Accepts: mail stream + * package pointer (cast as a void *) + * pointer to return initial flags + * pointer to return message internal date + * pointer to return stringstruct of message to append + * Returns: T, always + */ + +static long mail_append_single (MAILSTREAM *stream,void *data,char **flags, + char **date,STRING **message) +{ + APPENDPACKAGE *ap = (APPENDPACKAGE *) data; + *flags = ap->flags; /* get desired data from the package */ + *date = ap->date; + *message = ap->message; + ap->message = NIL; /* so next callback puts a stop to it */ + return LONGT; /* always return success */ +} + + +/* Mail append message string + * Accepts: mail stream + * destination mailbox + * initial flags + * message internal date + * stringstruct of message to append + * Returns: T on success, NIL on failure + */ + +long mail_append_full (MAILSTREAM *stream,char *mailbox,char *flags,char *date, + STRING *message) +{ + APPENDPACKAGE ap; + ap.flags = flags; /* load append package */ + ap.date = date; + ap.message = message; + return mail_append_multiple (stream,mailbox,mail_append_single,(void *) &ap); +} + +/* Mail append message(s) + * Accepts: mail stream + * destination mailbox + * append data callback + * arbitrary data for callback use + * Returns: T on success, NIL on failure + */ + +long mail_append_multiple (MAILSTREAM *stream,char *mailbox,append_t af, + void *data) +{ + char *s,tmp[MAILTMPLEN]; + DRIVER *d = NIL; + long ret = NIL; + /* never allow names with newlines */ + if (strpbrk (mailbox,"\015\012")) + MM_LOG ("Can't append to mailbox with such a name",ERROR); + else if (strlen (mailbox) >= + (NETMAXHOST+(NETMAXUSER*2)+NETMAXMBX+NETMAXSRV+50)) { + sprintf (tmp,"Can't append %.80s: %s",mailbox,(*mailbox == '{') ? + "invalid remote specification" : "no such mailbox"); + MM_LOG (tmp,ERROR); + } + /* special driver hack? */ + else if (!strncmp (lcase (strcpy (tmp,mailbox)),"#driver.",8)) { + /* yes, tie off name at likely delimiter */ + if (!(s = strpbrk (tmp+8,"/\\:"))) { + sprintf (tmp,"Can't append to mailbox %.80s: bad driver syntax",mailbox); + MM_LOG (tmp,ERROR); + return NIL; + } + *s++ = '\0'; /* tie off at delimiter */ + if (!(d = (DRIVER *) mail_parameters (NIL,GET_DRIVER,tmp+8))) { + sprintf (tmp,"Can't append to mailbox %.80s: unknown driver",mailbox); + MM_LOG (tmp,ERROR); + } + else ret = SAFE_APPEND (d,stream,mailbox + (s - tmp),af,data); + } + else if (d = mail_valid (stream,mailbox,NIL)) + ret = SAFE_APPEND (d,stream,mailbox,af,data); + /* No driver, try for TRYCREATE if no stream. Note that we use the + * createProto here, not the appendProto, since the dummy driver already + * took care of the appendProto case. Otherwise, if appendProto is set to + * NIL, we won't get a TRYCREATE. + */ + else if (!stream && (stream = default_proto (NIL)) && stream->dtb && + SAFE_APPEND (stream->dtb,stream,mailbox,af,data)) + /* timing race? */ + MM_NOTIFY (stream,"Append validity confusion",WARN); + /* generate error message */ + else mail_valid (stream,mailbox,"append to mailbox"); + return ret; +} + +/* Mail garbage collect stream + * Accepts: mail stream + * garbage collection flags + */ + +void mail_gc (MAILSTREAM *stream,long gcflags) +{ + MESSAGECACHE *elt; + unsigned long i; + /* do the driver's action first */ + if (stream->dtb && stream->dtb->gc) (*stream->dtb->gc) (stream,gcflags); + stream->msgno = 0; /* nothing cached now */ + if (gcflags & GC_ENV) { /* garbage collect envelopes? */ + if (stream->env) mail_free_envelope (&stream->env); + if (stream->body) mail_free_body (&stream->body); + } + if (gcflags & GC_TEXTS) { /* free texts */ + if (stream->text.data) fs_give ((void **) &stream->text.data); + stream->text.size = 0; + } + /* garbage collect per-message stuff */ + for (i = 1; i <= stream->nmsgs; i++) + if (elt = (MESSAGECACHE *) (*mailcache) (stream,i,CH_ELT)) + mail_gc_msg (&elt->private.msg,gcflags); +} + + +/* Mail garbage collect message + * Accepts: message structure + * garbage collection flags + */ + +void mail_gc_msg (MESSAGE *msg,long gcflags) +{ + if (gcflags & GC_ENV) { /* garbage collect envelopes? */ + mail_free_envelope (&msg->env); + mail_free_body (&msg->body); + } + if (gcflags & GC_TEXTS) { /* garbage collect texts */ + if (msg->full.text.data) fs_give ((void **) &msg->full.text.data); + if (msg->header.text.data) { + mail_free_stringlist (&msg->lines); + fs_give ((void **) &msg->header.text.data); + } + if (msg->text.text.data) fs_give ((void **) &msg->text.text.data); + /* now GC all body components */ + if (msg->body) mail_gc_body (msg->body); + } +} + +/* Mail garbage collect texts in BODY structure + * Accepts: BODY structure + */ + +void mail_gc_body (BODY *body) +{ + PART *part; + switch (body->type) { /* free contents */ + case TYPEMULTIPART: /* multiple part */ + for (part = body->nested.part; part; part = part->next) + mail_gc_body (&part->body); + break; + case TYPEMESSAGE: /* encapsulated message */ + if (body->subtype && !strcmp (body->subtype,"RFC822")) { + mail_free_stringlist (&body->nested.msg->lines); + mail_gc_msg (body->nested.msg,GC_TEXTS); + } + break; + default: + break; + } + if (body->mime.text.data) fs_give ((void **) &body->mime.text.data); + if (body->contents.text.data) fs_give ((void **) &body->contents.text.data); +} + +/* Mail get body part + * Accepts: mail stream + * message number + * section specifier + * Returns: pointer to body + */ + +BODY *mail_body (MAILSTREAM *stream,unsigned long msgno,unsigned char *section) +{ + BODY *b = NIL; + PART *pt; + unsigned long i; + /* make sure have a body */ + if (section && *section && mail_fetchstructure (stream,msgno,&b) && b) + while (*section) { /* find desired section */ + if (isdigit (*section)) { /* get section specifier */ + /* make sure what follows is valid */ + if (!(i = strtoul (section,(char **) §ion,10)) || + (*section && ((*section++ != '.') || !*section))) return NIL; + /* multipart content? */ + if (b->type == TYPEMULTIPART) { + /* yes, find desired part */ + if (pt = b->nested.part) while (--i && (pt = pt->next)); + if (!pt) return NIL; /* bad specifier */ + b = &pt->body; /* note new body */ + } + /* otherwise must be section 1 */ + else if (i != 1) return NIL; + /* need to go down further? */ + if (*section) switch (b->type) { + case TYPEMULTIPART: /* multipart */ + break; + case TYPEMESSAGE: /* embedded message */ + if (!strcmp (b->subtype,"RFC822")) { + b = b->nested.msg->body; + break; + } + default: /* bogus subpart specification */ + return NIL; + } + } + else return NIL; /* unknown section specifier */ + } + return b; +} + +/* Mail output date from elt fields + * Accepts: character string to write into + * elt to get data data from + * Returns: the character string + */ + +const char *days[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"}; + +const char *months[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", + "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}; + +char *mail_date (char *string,MESSAGECACHE *elt) +{ + sprintf (string,"%2d-%s-%d %02d:%02d:%02d %c%02d%02d", + elt->day ? elt->day : 1, + months[elt->month ? (elt->month - 1) : 0], + elt->year + BASEYEAR,elt->hours,elt->minutes,elt->seconds, + elt->zoccident ? '-' : '+',elt->zhours,elt->zminutes); + return string; +} + + +/* Mail output extended-ctime format date from elt fields + * Accepts: character string to write into + * elt to get data data from + * Returns: the character string + */ + +char *mail_cdate (char *string,MESSAGECACHE *elt) +{ + char *fmt = "%s %s %2d %02d:%02d:%02d %4d %s%02d%02d\n"; + int d = elt->day ? elt->day : 1; + int m = elt->month ? (elt->month - 1) : 0; + int y = elt->year + BASEYEAR; + const char *s = months[m]; + if (m < 2) { /* if before March, */ + m += 10; /* January = month 10 of previous year */ + y--; + } + else m -= 2; /* March is month 0 */ + sprintf (string,fmt,days[(int) (d + 2 + ((7 + 31 * m) / 12) +#ifndef USEJULIANCALENDAR +#ifndef USEORTHODOXCALENDAR /* Gregorian calendar */ + + (y / 400) +#ifdef Y4KBUGFIX + - (y / 4000) +#endif +#else /* Orthodox calendar */ + + (2 * (y / 900)) + ((y % 900) >= 200) + + ((y % 900) >= 600) +#endif + - (y / 100) +#endif + + y + (y / 4)) % 7], + s,d,elt->hours,elt->minutes,elt->seconds,elt->year + BASEYEAR, + elt->zoccident ? "-" : "+",elt->zhours,elt->zminutes); + return string; +} + +/* Mail parse date into elt fields + * Accepts: elt to write into + * date string to parse + * Returns: T if parse successful, else NIL + * This routine parses dates as follows: + * . leading three alphas followed by comma and space are ignored + * . date accepted in format: mm/dd/yy, mm/dd/yyyy, dd-mmm-yy, dd-mmm-yyyy, + * dd mmm yy, dd mmm yyyy, yyyy-mm-dd, yyyymmdd + * . two and three digit years interpreted according to RFC 2822 rules + * . mandatory end of string if yyyy-mm-dd or yyyymmdd; otherwise optional + * space followed by time: + * . time accepted in format hh:mm:ss or hh:mm + * . end of string accepted + * . timezone accepted: hyphen followed by symbolic timezone, or space + * followed by signed numeric timezone or symbolic timezone + * Examples of normal input: + * . IMAP date-only (SEARCH): + * dd-mmm-yyyy + * . IMAP date-time (INTERNALDATE): + * dd-mmm-yyyy hh:mm:ss +zzzz + * . RFC-822: + * www, dd mmm yy hh:mm:ss zzz + * . RFC-2822: + * www, dd mmm yyyy hh:mm:ss +zzzz + */ + +long mail_parse_date (MESSAGECACHE *elt,unsigned char *s) +{ + unsigned long d,m,y; + int mi,ms; + struct tm *t; + time_t tn; + char tmp[MAILTMPLEN]; + static unsigned long maxyear = 0; + if (!maxyear) { /* know the end of time yet? */ + MESSAGECACHE tmpelt; + memset (&tmpelt,0xff,sizeof (MESSAGECACHE)); + maxyear = BASEYEAR + tmpelt.year; + } + /* clear elt */ + elt->zoccident = elt->zhours = elt->zminutes = + elt->hours = elt->minutes = elt->seconds = + elt->day = elt->month = elt->year = 0; + /* make a writeable uppercase copy */ + if (s && *s && (strlen (s) < (size_t)MAILTMPLEN)) s = ucase (strcpy (tmp,s)); + else return NIL; + /* skip over possible day of week */ + if (isalpha (*s) && isalpha (s[1]) && isalpha (s[2]) && (s[3] == ',') && + (s[4] == ' ')) s += 5; + while (*s == ' ') s++; /* parse first number (probable month) */ + if (!(m = strtoul (s,(char **) &s,10))) return NIL; + + switch (*s) { /* different parse based on delimiter */ + case '/': /* mm/dd/yy format */ + if (isdigit (*++s) && (d = strtoul (s,(char **) &s,10)) && + (*s == '/') && isdigit (*++s)) { + y = strtoul (s,(char **) &s,10); + if (*s == '\0') break; /* must end here */ + } + return NIL; /* bogon */ + case ' ': /* dd mmm yy format */ + while (s[1] == ' ') s++; /* slurp extra whitespace */ + case '-': + if (isdigit (s[1])) { /* possible ISO 8601 date format? */ + y = m; /* yes, first number is year */ + /* get month and day */ + if ((m = strtoul (s+1,(char **) &s,10)) && (*s++ == '-') && + (d = strtoul (s,(char **) &s,10)) && !*s) break; + return NIL; /* syntax error or time present */ + } + d = m; /* dd-mmm-yy[yy], so first number is a day */ + /* make sure string long enough! */ + if (strlen (s) < (size_t) 5) return NIL; + /* Some compilers don't allow `<<' and/or longs in case statements. */ + /* slurp up the month string */ + ms = ((s[1] - 'A') * 1024) + ((s[2] - 'A') * 32) + (s[3] - 'A'); + switch (ms) { /* determine the month */ + case (('J'-'A') * 1024) + (('A'-'A') * 32) + ('N'-'A'): m = 1; break; + case (('F'-'A') * 1024) + (('E'-'A') * 32) + ('B'-'A'): m = 2; break; + case (('M'-'A') * 1024) + (('A'-'A') * 32) + ('R'-'A'): m = 3; break; + case (('A'-'A') * 1024) + (('P'-'A') * 32) + ('R'-'A'): m = 4; break; + case (('M'-'A') * 1024) + (('A'-'A') * 32) + ('Y'-'A'): m = 5; break; + case (('J'-'A') * 1024) + (('U'-'A') * 32) + ('N'-'A'): m = 6; break; + case (('J'-'A') * 1024) + (('U'-'A') * 32) + ('L'-'A'): m = 7; break; + case (('A'-'A') * 1024) + (('U'-'A') * 32) + ('G'-'A'): m = 8; break; + case (('S'-'A') * 1024) + (('E'-'A') * 32) + ('P'-'A'): m = 9; break; + case (('O'-'A') * 1024) + (('C'-'A') * 32) + ('T'-'A'): m = 10; break; + case (('N'-'A') * 1024) + (('O'-'A') * 32) + ('V'-'A'): m = 11; break; + case (('D'-'A') * 1024) + (('E'-'A') * 32) + ('C'-'A'): m = 12; break; + default: return NIL; /* unknown month */ + } + if (s[4] == *s) s += 5; /* advance to year */ + else { /* first three were OK, possibly full name */ + mi = *s; /* note delimiter, skip alphas */ + for (s += 4; isalpha (*s); s++); + /* error if delimiter not here */ + if (mi != *s++) return NIL; + } + while (*s == ' ') s++; /* parse year */ + if (isdigit (*s)) { /* must be a digit here */ + y = strtoul (s,(char **) &s,10); + if (*s == '\0' || *s == ' ') break; + } + case '\0': /* ISO 8601 compact date */ + if (m < (BASEYEAR * 10000)) return NIL; + y = m / 10000; /* get year */ + d = (m %= 10000) % 100; /* get day */ + m /= 100; /* and month */ + break; + default: + return NIL; /* unknown date format */ + } + + /* minimal validity check of date */ + if ((d > 31) || (m > 12)) return NIL; + if (y < 49) y += 2000; /* RFC 2282 rules for two digit years 00-49 */ + else if (y < 999) y += 1900; /* 2-digit years 50-99 and 3-digit years */ + /* reject prehistoric and far future years */ + if ((y < BASEYEAR) || (y > maxyear)) return NIL; + /* set values in elt */ + elt->day = d; elt->month = m; elt->year = y - BASEYEAR; + ms = '\0'; /* initially no time zone string */ + if (*s) { /* time specification present? */ + /* parse time */ + d = strtoul (s+1,(char **) &s,10); + if (*s != ':') return NIL; + m = strtoul (++s,(char **) &s,10); + y = (*s == ':') ? strtoul (++s,(char **) &s,10) : 0; + /* validity check time */ + if ((d > 23) || (m > 59) || (y > 60)) return NIL; + /* set values in elt */ + elt->hours = d; elt->minutes = m; elt->seconds = y; + switch (*s) { /* time zone specifier? */ + case ' ': /* numeric time zone */ + while (s[1] == ' ') s++; /* slurp extra whitespace */ + if (!isalpha (s[1])) { /* treat as '-' case if alphabetic */ + /* test for sign character */ + if ((elt->zoccident = (*++s == '-')) || (*s == '+')) s++; + /* validate proper timezone */ + if (isdigit(*s) && isdigit(s[1]) && isdigit(s[2]) && (s[2] < '6') && + isdigit(s[3])) { + elt->zhours = (*s - '0') * 10 + (s[1] - '0'); + elt->zminutes = (s[2] - '0') * 10 + (s[3] - '0'); + } + return T; /* all done! */ + } + /* falls through */ + case '-': /* symbolic time zone */ + if (!(ms = *++s)) ms = 'Z'; + else if (*++s) { /* multi-character? */ + ms -= 'A'; ms *= 1024; /* yes, make compressed three-byte form */ + ms += ((*s++ - 'A') * 32); + if (*s) ms += *s++ - 'A'; + if (*s) ms = '\0'; /* more than three characters */ + } + default: /* ignore anything else */ + break; + } + } + + /* This is not intended to be a comprehensive list of all possible + * timezone strings. Such a list would be impractical. Rather, this + * listing is intended to incorporate all military, North American, and + * a few special cases such as Japan and the major European zone names, + * such as what might be expected to be found in a Tenex format mailbox + * and spewed from an IMAP server. The trend is to migrate to numeric + * timezones which lack the flavor but also the ambiguity of the names. + * + * RFC-822 only recognizes UT, GMT, 1-letter military timezones, and the + * 4 CONUS timezones and their summer time variants. [Sorry, Canadian + * Atlantic Provinces, Alaska, and Hawaii.] + */ + switch (ms) { /* determine the timezone */ + /* Universal */ + case (('U'-'A')*1024)+(('T'-'A')*32): +#ifndef STRICT_RFC822_TIMEZONES + case (('U'-'A')*1024)+(('T'-'A')*32)+'C'-'A': +#endif + /* Greenwich */ + case (('G'-'A')*1024)+(('M'-'A')*32)+'T'-'A': + case 'Z': elt->zhours = 0; break; + + /* oriental (from Greenwich) timezones */ +#ifndef STRICT_RFC822_TIMEZONES + /* Middle Europe */ + case (('M'-'A')*1024)+(('E'-'A')*32)+'T'-'A': +#endif +#ifdef BRITISH_SUMMER_TIME + /* British Summer */ + case (('B'-'A')*1024)+(('S'-'A')*32)+'T'-'A': +#endif + case 'A': elt->zhours = 1; break; +#ifndef STRICT_RFC822_TIMEZONES + /* Eastern Europe */ + case (('E'-'A')*1024)+(('E'-'A')*32)+'T'-'A': +#endif + case 'B': elt->zhours = 2; break; + case 'C': elt->zhours = 3; break; + case 'D': elt->zhours = 4; break; + case 'E': elt->zhours = 5; break; + case 'F': elt->zhours = 6; break; + case 'G': elt->zhours = 7; break; + case 'H': elt->zhours = 8; break; +#ifndef STRICT_RFC822_TIMEZONES + /* Japan */ + case (('J'-'A')*1024)+(('S'-'A')*32)+'T'-'A': +#endif + case 'I': elt->zhours = 9; break; + case 'K': elt->zhours = 10; break; + case 'L': elt->zhours = 11; break; + case 'M': elt->zhours = 12; break; + + /* occidental (from Greenwich) timezones */ + case 'N': elt->zoccident = 1; elt->zhours = 1; break; + case 'O': elt->zoccident = 1; elt->zhours = 2; break; +#ifndef STRICT_RFC822_TIMEZONES + case (('A'-'A')*1024)+(('D'-'A')*32)+'T'-'A': +#endif + case 'P': elt->zoccident = 1; elt->zhours = 3; break; +#ifdef NEWFOUNDLAND_STANDARD_TIME + /* Newfoundland */ + case (('N'-'A')*1024)+(('S'-'A')*32)+'T'-'A': + elt->zoccident = 1; elt->zhours = 3; elt->zminutes = 30; break; +#endif +#ifndef STRICT_RFC822_TIMEZONES + /* Atlantic */ + case (('A'-'A')*1024)+(('S'-'A')*32)+'T'-'A': +#endif + /* CONUS */ + case (('E'-'A')*1024)+(('D'-'A')*32)+'T'-'A': + case 'Q': elt->zoccident = 1; elt->zhours = 4; break; + /* Eastern */ + case (('E'-'A')*1024)+(('S'-'A')*32)+'T'-'A': + case (('C'-'A')*1024)+(('D'-'A')*32)+'T'-'A': + case 'R': elt->zoccident = 1; elt->zhours = 5; break; + /* Central */ + case (('C'-'A')*1024)+(('S'-'A')*32)+'T'-'A': + case (('M'-'A')*1024)+(('D'-'A')*32)+'T'-'A': + case 'S': elt->zoccident = 1; elt->zhours = 6; break; + /* Mountain */ + case (('M'-'A')*1024)+(('S'-'A')*32)+'T'-'A': + case (('P'-'A')*1024)+(('D'-'A')*32)+'T'-'A': + case 'T': elt->zoccident = 1; elt->zhours = 7; break; + /* Pacific */ + case (('P'-'A')*1024)+(('S'-'A')*32)+'T'-'A': +#ifndef STRICT_RFC822_TIMEZONES + case (('Y'-'A')*1024)+(('D'-'A')*32)+'T'-'A': +#endif + case 'U': elt->zoccident = 1; elt->zhours = 8; break; +#ifndef STRICT_RFC822_TIMEZONES + /* Yukon */ + case (('Y'-'A')*1024)+(('S'-'A')*32)+'T'-'A': +#endif + case 'V': elt->zoccident = 1; elt->zhours = 9; break; +#ifndef STRICT_RFC822_TIMEZONES + /* Hawaii */ + case (('H'-'A')*1024)+(('S'-'A')*32)+'T'-'A': +#endif + case 'W': elt->zoccident = 1; elt->zhours = 10; break; + /* Nome/Bering/Samoa */ +#ifdef NOME_STANDARD_TIME + case (('N'-'A')*1024)+(('S'-'A')*32)+'T'-'A': +#endif +#ifdef BERING_STANDARD_TIME + case (('B'-'A')*1024)+(('S'-'A')*32)+'T'-'A': +#endif +#ifdef SAMOA_STANDARD_TIME + case (('S'-'A')*1024)+(('S'-'A')*32)+'T'-'A': +#endif + case 'X': elt->zoccident = 1; elt->zhours = 11; break; + case 'Y': elt->zoccident = 1; elt->zhours = 12; break; + + default: /* unknown time zones treated as local */ + tn = time (0); /* time now... */ + t = localtime (&tn); /* get local minutes since midnight */ + mi = t->tm_hour * 60 + t->tm_min; + ms = t->tm_yday; /* note Julian day */ + if (t = gmtime (&tn)) { /* minus UTC minutes since midnight */ + mi -= t->tm_hour * 60 + t->tm_min; + /* ms can be one of: + * 36x local time is December 31, UTC is January 1, offset -24 hours + * 1 local time is 1 day ahead of UTC, offset +24 hours + * 0 local time is same day as UTC, no offset + * -1 local time is 1 day behind UTC, offset -24 hours + * -36x local time is January 1, UTC is December 31, offset +24 hours + */ + if (ms -= t->tm_yday) /* correct offset if different Julian day */ + mi += ((ms < 0) == (abs (ms) == 1)) ? -24*60 : 24*60; + if (mi < 0) { /* occidental? */ + mi = abs (mi); /* yup, make positive number */ + elt->zoccident = 1; /* and note west of UTC */ + } + elt->zhours = mi / 60; /* now break into hours and minutes */ + elt->zminutes = mi % 60; + } + break; + } + return T; +} + +/* Mail n messages exist + * Accepts: mail stream + * number of messages + */ + +void mail_exists (MAILSTREAM *stream,unsigned long nmsgs) +{ + char tmp[MAILTMPLEN]; + if (nmsgs > MAXMESSAGES) { + sprintf (tmp,"Mailbox has more messages (%lu) exist than maximum (%lu)", + nmsgs,MAXMESSAGES); + mm_log (tmp,ERROR); + nmsgs = MAXMESSAGES; /* cap to maximum */ + /* probably will crash in mail_elt() soon enough... */ + } + /* make sure cache is large enough */ + (*mailcache) (stream,nmsgs,CH_SIZE); + stream->nmsgs = nmsgs; /* update stream status */ + /* notify main program of change */ + if (!stream->silent) MM_EXISTS (stream,nmsgs); +} + + +/* Mail n messages are recent + * Accepts: mail stream + * number of recent messages + */ + +void mail_recent (MAILSTREAM *stream,unsigned long recent) +{ + char tmp[MAILTMPLEN]; + if (recent <= stream->nmsgs) stream->recent = recent; + else { + sprintf (tmp,"Non-existent recent message(s) %lu, nmsgs=%lu", + recent,stream->nmsgs); + mm_log (tmp,ERROR); + } +} + + +/* Mail message n is expunged + * Accepts: mail stream + * message # + */ + +void mail_expunged (MAILSTREAM *stream,unsigned long msgno) +{ + char tmp[MAILTMPLEN]; + MESSAGECACHE *elt; + if (msgno > stream->nmsgs) { + sprintf (tmp,"Expunge of non-existent message %lu, nmsgs=%lu", + msgno,stream->nmsgs); + mm_log (tmp,ERROR); + } + else { + elt = (MESSAGECACHE *) (*mailcache) (stream,msgno,CH_ELT); + /* notify main program of change */ + if (!stream->silent) MM_EXPUNGED (stream,msgno); + if (elt) { /* if an element is there */ + elt->msgno = 0; /* invalidate its message number and free */ + (*mailcache) (stream,msgno,CH_FREE); + (*mailcache) (stream,msgno,CH_FREESORTCACHE); + } + /* expunge the slot */ + (*mailcache) (stream,msgno,CH_EXPUNGE); + --stream->nmsgs; /* update stream status */ + if (stream->msgno) { /* have stream pointers? */ + /* make sure the short cache is nuked */ + if (stream->scache) mail_gc (stream,GC_ENV | GC_TEXTS); + else stream->msgno = 0; /* make sure invalidated in any case */ + } + } +} + +/* Mail stream status routines */ + + +/* Mail lock stream + * Accepts: mail stream + */ + +void mail_lock (MAILSTREAM *stream) +{ + if (stream->lock) { + char tmp[MAILTMPLEN]; + sprintf (tmp,"Lock when already locked, mbx=%.80s", + stream->mailbox ? stream->mailbox : "???"); + fatal (tmp); + } + else stream->lock = T; /* lock stream */ +} + + +/* Mail unlock stream + * Accepts: mail stream + */ + +void mail_unlock (MAILSTREAM *stream) +{ + if (!stream->lock) fatal ("Unlock when not locked"); + else stream->lock = NIL; /* unlock stream */ +} + + +/* Mail turn on debugging telemetry + * Accepts: mail stream + */ + +void mail_debug (MAILSTREAM *stream) +{ + stream->debug = T; /* turn on debugging telemetry */ + if (stream->dtb) (*stream->dtb->parameters) (ENABLE_DEBUG,stream); +} + + +/* Mail turn off debugging telemetry + * Accepts: mail stream + */ + +void mail_nodebug (MAILSTREAM *stream) +{ + stream->debug = NIL; /* turn off debugging telemetry */ + if (stream->dtb) (*stream->dtb->parameters) (DISABLE_DEBUG,stream); +} + + +/* Mail log to debugging telemetry + * Accepts: message + * flag that data is "sensitive" + */ + +void mail_dlog (char *string,long flag) +{ + mm_dlog ((debugsensitive || !flag) ? string : "<suppressed>"); +} + +/* Mail parse UID sequence + * Accepts: mail stream + * sequence to parse + * Returns: T if parse successful, else NIL + */ + +long mail_uid_sequence (MAILSTREAM *stream,unsigned char *sequence) +{ + unsigned long i,j,k,x,y; + for (i = 1; i <= stream->nmsgs; i++) mail_elt (stream,i)->sequence = NIL; + while (sequence && *sequence){/* while there is something to parse */ + if (*sequence == '*') { /* maximum message */ + i = stream->nmsgs ? mail_uid (stream,stream->nmsgs) : stream->uid_last; + sequence++; /* skip past * */ + } + /* parse and validate message number */ + /* parse and validate message number */ + else if (!isdigit (*sequence)) { + MM_LOG ("Syntax error in sequence",ERROR); + return NIL; + } + else if (!(i = strtoul (sequence,(char **) &sequence,10))) { + MM_LOG ("UID may not be zero",ERROR); + return NIL; + } + switch (*sequence) { /* see what the delimiter is */ + case ':': /* sequence range */ + if (*++sequence == '*') { /* maximum message */ + j = stream->nmsgs ? mail_uid (stream,stream->nmsgs) : stream->uid_last; + sequence++; /* skip past * */ + } + /* parse end of range */ + else if (!(j = strtoul (sequence,(char **) &sequence,10))) { + MM_LOG ("UID sequence range invalid",ERROR); + return NIL; + } + if (*sequence && *sequence++ != ',') { + MM_LOG ("UID sequence range syntax error",ERROR); + return NIL; + } + if (i > j) { /* swap the range if backwards */ + x = i; i = j; j = x; + } + x = mail_msgno (stream,i);/* get msgnos */ + y = mail_msgno (stream,j);/* for both UIDS (don't && it) */ + /* easy if both UIDs valid */ + if (x && y) while (x <= y) mail_elt (stream,x++)->sequence = T; + /* start UID valid, end is not */ + else if (x) while ((x <= stream->nmsgs) && (mail_uid (stream,x) <= j)) + mail_elt (stream,x++)->sequence = T; + /* end UID valid, start is not */ + else if (y) for (x = 1; x <= y; x++) { + if (mail_uid (stream,x) >= i) mail_elt (stream,x)->sequence = T; + } + /* neither is valid, ugh */ + else for (x = 1; x <= stream->nmsgs; x++) + if (((k = mail_uid (stream,x)) >= i) && (k <= j)) + mail_elt (stream,x)->sequence = T; + break; + case ',': /* single message */ + ++sequence; /* skip the delimiter, fall into end case */ + case '\0': /* end of sequence, mark this message */ + if (x = mail_msgno (stream,i)) mail_elt (stream,x)->sequence = T; + break; + default: /* anything else is a syntax error! */ + MM_LOG ("UID sequence syntax error",ERROR); + return NIL; + } + } + return T; /* successfully parsed sequence */ +} + +/* Mail see if line list matches that in cache + * Accepts: candidate line list + * cached line list + * matching flags + * Returns: T if match, NIL if no match + */ + +long mail_match_lines (STRINGLIST *lines,STRINGLIST *msglines,long flags) +{ + unsigned long i; + unsigned char *s,*t; + STRINGLIST *m; + if (!msglines) return T; /* full header is in cache */ + /* need full header but filtered in cache */ + if ((flags & FT_NOT) || !lines) return NIL; + do { /* make sure all present & accounted for */ + for (m = msglines; m; m = m->next) if (lines->text.size == m->text.size) { + for (s = lines->text.data,t = m->text.data,i = lines->text.size; + i && !compare_uchar (*s,*t); s++,t++,i--); + if (!i) break; /* this line matches */ + } + if (!m) return NIL; /* didn't find in the list */ + } + while (lines = lines->next); + return T; /* all lines found */ +} + +/* Mail filter text by header lines + * Accepts: text to filter, with trailing null + * length of text + * list of lines + * fetch flags + * Returns: new text size, text overwritten + */ + +unsigned long mail_filter (char *text,unsigned long len,STRINGLIST *lines, + long flags) +{ + STRINGLIST *hdrs; + int notfound; + unsigned long i; + char c,*s,*e,*t,tmp[MAILTMPLEN]; + char *src = text; + char *dst = src; + char *end = text + len; + text[len] = '\012'; /* guard against running off buffer */ + while (src < end) { /* process header */ + /* slurp header line name */ + for (s = src,e = s + MAILTMPLEN - 1,e = (e < end ? e : end),t = tmp; + (s < e) && ((c = (*s ? *s : (*s = ' '))) != ':') && + ((c > ' ') || + ((c != ' ') && (c != '\t') && (c != '\015') && (c != '\012'))); + *t++ = *s++); + *t = '\0'; /* tie off */ + notfound = T; /* not found yet */ + if (i = t - tmp) /* see if found in header */ + for (hdrs = lines; hdrs && notfound; hdrs = hdrs->next) + if ((hdrs->text.size == i) && !compare_csizedtext (tmp,&hdrs->text)) + notfound = NIL; + /* skip header line if not wanted */ + if (i && ((flags & FT_NOT) ? !notfound : notfound)) + while (((*src++ != '\012') && (*src++ != '\012') && (*src++ != '\012') && + (*src++ != '\012') && (*src++ != '\012') && (*src++ != '\012') && + (*src++ != '\012') && (*src++ != '\012') && (*src++ != '\012') && + (*src++ != '\012')) || ((*src == ' ') || (*src == '\t'))); + else if (src == dst) { /* copy to self */ + while (((*src++ != '\012') && (*src++ != '\012') && (*src++ != '\012') && + (*src++ != '\012') && (*src++ != '\012') && (*src++ != '\012') && + (*src++ != '\012') && (*src++ != '\012') && (*src++ != '\012') && + (*src++ != '\012')) || ((*src == ' ') || (*src == '\t'))); + dst = src; /* update destination */ + } + else { /* copy line and any continuation line */ + while ((((*dst++ = *src++) != '\012') && ((*dst++ = *src++) != '\012') && + ((*dst++ = *src++) != '\012') && ((*dst++ = *src++) != '\012') && + ((*dst++ = *src++) != '\012') && ((*dst++ = *src++) != '\012') && + ((*dst++ = *src++) != '\012') && ((*dst++ = *src++) != '\012') && + ((*dst++ = *src++) != '\012') && ((*dst++ = *src++) != '\012'))|| + ((*src == ' ') || (*src == '\t'))); + /* in case hit the guard LF */ + if (src > end) dst -= (src - end); + } + } + *dst = '\0'; /* tie off destination */ + return dst - text; +} + +/* Local mail search message + * Accepts: MAIL stream + * message number + * optional section specification + * search program + * Returns: T if found, NIL otherwise + */ + +long mail_search_msg (MAILSTREAM *stream,unsigned long msgno,char *section, + SEARCHPGM *pgm) +{ + unsigned short d; + char tmp[MAILTMPLEN]; + MESSAGECACHE *elt = mail_elt (stream,msgno); + SEARCHHEADER *hdr; + SEARCHOR *or; + SEARCHPGMLIST *not; + unsigned long now = (unsigned long) time (0); + if (pgm->msgno || pgm->uid) { /* message set searches */ + SEARCHSET *set; + /* message sequences */ + if (pgm->msgno) { /* inside this message sequence set */ + for (set = pgm->msgno; set; set = set->next) + if (set->last ? ((set->first <= set->last) ? + ((msgno >= set->first) && (msgno <= set->last)) : + ((msgno >= set->last) && (msgno <= set->first))) : + msgno == set->first) break; + if (!set) return NIL; /* not found within sequence */ + } + if (pgm->uid) { /* inside this unique identifier set */ + unsigned long uid = mail_uid (stream,msgno); + for (set = pgm->uid; set; set = set->next) + if (set->last ? ((set->first <= set->last) ? + ((uid >= set->first) && (uid <= set->last)) : + ((uid >= set->last) && (uid <= set->first))) : + uid == set->first) break; + if (!set) return NIL; /* not found within sequence */ + } + } + + /* Fast data searches */ + /* need to fetch fast data? */ + if ((!elt->rfc822_size && (pgm->larger || pgm->smaller)) || + (!elt->year && (pgm->before || pgm->on || pgm->since || + pgm->older || pgm->younger)) || + (!elt->valid && (pgm->answered || pgm->unanswered || + pgm->deleted || pgm->undeleted || + pgm->draft || pgm->undraft || + pgm->flagged || pgm->unflagged || + pgm->recent || pgm->old || + pgm->seen || pgm->unseen || + pgm->keyword || pgm->unkeyword))) { + unsigned long i; + MESSAGECACHE *ielt; + for (i = elt->msgno; /* find last unloaded message in range */ + (i < stream->nmsgs) && (ielt = mail_elt (stream,i+1)) && + ((!ielt->rfc822_size && (pgm->larger || pgm->smaller)) || + (!ielt->year && (pgm->before || pgm->on || pgm->since || + pgm->older || pgm->younger)) || + (!ielt->valid && (pgm->answered || pgm->unanswered || + pgm->deleted || pgm->undeleted || + pgm->draft || pgm->undraft || + pgm->flagged || pgm->unflagged || + pgm->recent || pgm->old || + pgm->seen || pgm->unseen || + pgm->keyword || pgm->unkeyword))); ++i); + if (i == elt->msgno) sprintf (tmp,"%lu",elt->msgno); + else sprintf (tmp,"%lu:%lu",elt->msgno,i); + mail_fetch_fast (stream,tmp,NIL); + } + /* size ranges */ + if ((pgm->larger && (elt->rfc822_size <= pgm->larger)) || + (pgm->smaller && (elt->rfc822_size >= pgm->smaller))) return NIL; + /* message flags */ + if ((pgm->answered && !elt->answered) || + (pgm->unanswered && elt->answered) || + (pgm->deleted && !elt->deleted) || + (pgm->undeleted && elt->deleted) || + (pgm->draft && !elt->draft) || + (pgm->undraft && elt->draft) || + (pgm->flagged && !elt->flagged) || + (pgm->unflagged && elt->flagged) || + (pgm->recent && !elt->recent) || + (pgm->old && elt->recent) || + (pgm->seen && !elt->seen) || + (pgm->unseen && elt->seen)) return NIL; + /* keywords */ + if ((pgm->keyword && !mail_search_keyword (stream,elt,pgm->keyword,LONGT)) || + (pgm->unkeyword && !mail_search_keyword (stream,elt,pgm->unkeyword,NIL))) + return NIL; + /* internal date ranges */ + if (pgm->before || pgm->on || pgm->since) { + d = mail_shortdate (elt->year,elt->month,elt->day); + if (pgm->before && (d >= pgm->before)) return NIL; + if (pgm->on && (d != pgm->on)) return NIL; + if (pgm->since && (d < pgm->since)) return NIL; + } + if (pgm->older || pgm->younger) { + unsigned long msgd = mail_longdate (elt); + if (pgm->older && msgd > (now - pgm->older)) return NIL; + if (pgm->younger && msgd < (now - pgm->younger)) return NIL; + } + + /* envelope searches */ + if (pgm->sentbefore || pgm->senton || pgm->sentsince || + pgm->bcc || pgm->cc || pgm->from || pgm->to || pgm->subject || + pgm->return_path || pgm->sender || pgm->reply_to || pgm->in_reply_to || + pgm->message_id || pgm->newsgroups || pgm->followup_to || + pgm->references) { + ENVELOPE *env; + MESSAGECACHE delt; + if (section) { /* use body part envelope */ + BODY *body = mail_body (stream,msgno,section); + env = (body && (body->type == TYPEMESSAGE) && body->subtype && + !strcmp (body->subtype,"RFC822")) ? body->nested.msg->env : NIL; + } + else { /* use top level envelope if no section */ + if (pgm->header && !stream->scache && !(stream->dtb->flags & DR_LOCAL)) + mail_fetch_header(stream,msgno,NIL,NIL,NIL,FT_PEEK|FT_SEARCHLOOKAHEAD); + env = mail_fetchenvelope (stream,msgno); + } + if (!env) return NIL; /* no envelope obtained */ + /* sent date ranges */ + if ((pgm->sentbefore || pgm->senton || pgm->sentsince) && + (!mail_parse_date (&delt,env->date) || + !(d = mail_shortdate (delt.year,delt.month,delt.day)) || + (pgm->sentbefore && (d >= pgm->sentbefore)) || + (pgm->senton && (d != pgm->senton)) || + (pgm->sentsince && (d < pgm->sentsince)))) return NIL; + /* search headers */ + if ((pgm->bcc && !mail_search_addr (env->bcc,pgm->bcc)) || + (pgm->cc && !mail_search_addr (env->cc,pgm->cc)) || + (pgm->from && !mail_search_addr (env->from,pgm->from)) || + (pgm->to && !mail_search_addr (env->to,pgm->to)) || + (pgm->subject && !mail_search_header_text (env->subject,pgm->subject))) + return NIL; + /* These criteria are not supported by IMAP and have to be emulated */ + if ((pgm->return_path && + !mail_search_addr (env->return_path,pgm->return_path)) || + (pgm->sender && !mail_search_addr (env->sender,pgm->sender)) || + (pgm->reply_to && !mail_search_addr (env->reply_to,pgm->reply_to)) || + (pgm->in_reply_to && + !mail_search_header_text (env->in_reply_to,pgm->in_reply_to)) || + (pgm->message_id && + !mail_search_header_text (env->message_id,pgm->message_id)) || + (pgm->newsgroups && + !mail_search_header_text (env->newsgroups,pgm->newsgroups)) || + (pgm->followup_to && + !mail_search_header_text (env->followup_to,pgm->followup_to)) || + (pgm->references && + !mail_search_header_text (env->references,pgm->references))) + return NIL; + } + + /* search header lines */ + for (hdr = pgm->header; hdr; hdr = hdr->next) { + char *t,*e,*v; + SIZEDTEXT s; + STRINGLIST sth,stc; + sth.next = stc.next = NIL; /* only one at a time */ + sth.text.data = hdr->line.data; + sth.text.size = hdr->line.size; + /* get the header text */ + if ((t = mail_fetch_header (stream,msgno,NIL,&sth,&s.size, + FT_INTERNAL | FT_PEEK | + (section ? NIL : FT_SEARCHLOOKAHEAD))) && + strchr (t,':')) { + if (hdr->text.size) { /* anything matches empty search string */ + /* non-empty, copy field data */ + s.data = (unsigned char *) fs_get (s.size + 1); + /* for each line */ + for (v = (char *) s.data, e = t + s.size; t < e;) switch (*t) { + default: /* non-continuation, skip leading field name */ + while ((t < e) && (*t++ != ':')); + if ((t < e) && (*t == ':')) t++; + case '\t': case ' ': /* copy field data */ + while ((t < e) && (*t != '\015') && (*t != '\012')) *v++ = *t++; + *v++ = '\n'; /* tie off line */ + while (((*t == '\015') || (*t == '\012')) && (t < e)) t++; + } + /* calculate true size */ + s.size = v - (char *) s.data; + *v = '\0'; /* tie off results */ + stc.text.data = hdr->text.data; + stc.text.size = hdr->text.size; + /* search header */ + if (mail_search_header (&s,&stc)) fs_give ((void **) &s.data); + else { /* search failed */ + fs_give ((void **) &s.data); + return NIL; + } + } + } + else return NIL; /* no matching header text */ + } + /* search strings */ + if ((pgm->text && !mail_search_text (stream,msgno,section,pgm->text,LONGT))|| + (pgm->body && !mail_search_text (stream,msgno,section,pgm->body,NIL))) + return NIL; + /* logical conditions */ + for (or = pgm->or; or; or = or->next) + if (!(mail_search_msg (stream,msgno,section,or->first) || + mail_search_msg (stream,msgno,section,or->second))) return NIL; + for (not = pgm->not; not; not = not->next) + if (mail_search_msg (stream,msgno,section,not->pgm)) return NIL; + return T; +} + +/* Mail search message header null-terminated text + * Accepts: header text + * strings to search + * Returns: T if search found a match + */ + +long mail_search_header_text (char *s,STRINGLIST *st) +{ + SIZEDTEXT h; + /* have any text? */ + if (h.data = (unsigned char *) s) { + h.size = strlen (s); /* yes, get its size */ + return mail_search_header (&h,st); + } + return NIL; +} + + +/* Mail search message header + * Accepts: header as sized text + * strings to search + * Returns: T if search found a match + */ + +long mail_search_header (SIZEDTEXT *hdr,STRINGLIST *st) +{ + SIZEDTEXT h; + long ret = LONGT; + /* make UTF-8 version of header */ + utf8_mime2text (hdr,&h,U8T_CANONICAL); + while (h.size && ((h.data[h.size-1]=='\015') || (h.data[h.size-1]=='\012'))) + --h.size; /* slice off trailing newlines */ + do if (h.size ? /* search non-empty string */ + !ssearch (h.data,h.size,st->text.data,st->text.size) : st->text.size) + ret = NIL; + while (ret && (st = st->next)); + if (h.data != hdr->data) fs_give ((void **) &h.data); + return ret; +} + +/* Mail search message body + * Accepts: MAIL stream + * message number + * optional section specification + * string list + * flags + * Returns: T if search found a match + */ + +long mail_search_text (MAILSTREAM *stream,unsigned long msgno,char *section, + STRINGLIST *st,long flags) +{ + BODY *body; + long ret = NIL; + STRINGLIST *s = mail_newstringlist (); + mailgets_t omg = mailgets; + if (stream->dtb->flags & DR_LOWMEM) mailgets = mail_search_gets; + /* strings to search */ + for (stream->private.search.string = s; st;) { + s->text.data = st->text.data; + s->text.size = st->text.size; + if (st = st->next) s = s->next = mail_newstringlist (); + } + stream->private.search.text = NIL; + if (flags) { /* want header? */ + SIZEDTEXT s,t; + s.data = (unsigned char *) + mail_fetch_header (stream,msgno,section,NIL,&s.size,FT_INTERNAL|FT_PEEK); + utf8_mime2text (&s,&t,U8T_CANONICAL); + ret = mail_search_string_work (&t,&stream->private.search.string); + if (t.data != s.data) fs_give ((void **) &t.data); + } + if (!ret) { /* still looking for match? */ + /* no section, get top-level body */ + if (!section) mail_fetchstructure (stream,msgno,&body); + /* get body of nested message */ + else if ((body = mail_body (stream,msgno,section)) && + (body->type == TYPEMULTIPART) && body->subtype && + !strcmp (body->subtype,"RFC822")) body = body->nested.msg->body; + if (body) ret = mail_search_body (stream,msgno,body,NIL,1,flags); + } + mailgets = omg; /* restore former gets routine */ + /* clear searching */ + for (s = stream->private.search.string; s; s = s->next) s->text.data = NIL; + mail_free_stringlist (&stream->private.search.string); + stream->private.search.text = NIL; + return ret; +} + +/* Mail search message body text parts + * Accepts: MAIL stream + * message number + * current body pointer + * hierarchical level prefix + * position at current hierarchical level + * string list + * flags + * Returns: T if search found a match + */ + +long mail_search_body (MAILSTREAM *stream,unsigned long msgno,BODY *body, + char *prefix,unsigned long section,long flags) +{ + long ret = NIL; + unsigned long i; + char *s,*t,sect[MAILTMPLEN]; + SIZEDTEXT st,h; + PART *part; + PARAMETER *param; + if (prefix && (strlen (prefix) > (MAILTMPLEN - 20))) return NIL; + sprintf (sect,"%s%lu",prefix ? prefix : "",section++); + if (flags && prefix) { /* want to search MIME header too? */ + st.data = (unsigned char *) mail_fetch_mime (stream,msgno,sect,&st.size, + FT_INTERNAL | FT_PEEK); + if (stream->dtb->flags & DR_LOWMEM) ret = stream->private.search.result; + else { + /* make UTF-8 version of header */ + utf8_mime2text (&st,&h,U8T_CANONICAL); + ret = mail_search_string_work (&h,&stream->private.search.string); + if (h.data != st.data) fs_give ((void **) &h.data); + } + } + if (!ret) switch (body->type) { + case TYPEMULTIPART: + /* extend prefix if not first time */ + s = prefix ? strcat (sect,".") : ""; + for (i = 1,part = body->nested.part; part && !ret; i++,part = part->next) + ret = mail_search_body (stream,msgno,&part->body,s,i,flags); + break; + case TYPEMESSAGE: + if (!strcmp (body->subtype,"RFC822")) { + if (flags) { /* want to search nested message header? */ + st.data = (unsigned char *) + mail_fetch_header (stream,msgno,sect,NIL,&st.size, + FT_INTERNAL | FT_PEEK); + if (stream->dtb->flags & DR_LOWMEM) ret =stream->private.search.result; + else { + /* make UTF-8 version of header */ + utf8_mime2text (&st,&h,U8T_CANONICAL); + ret = mail_search_string_work (&h,&stream->private.search.string); + if (h.data != st.data) fs_give ((void **) &h.data); + } + } + if (body = body->nested.msg->body) + ret = (body->type == TYPEMULTIPART) ? + mail_search_body (stream,msgno,body,(prefix ? prefix : ""), + section - 1,flags) : + mail_search_body (stream,msgno,body,strcat (sect,"."),1,flags); + break; + } + /* non-MESSAGE/RFC822 falls into text case */ + + case TYPETEXT: + s = mail_fetch_body (stream,msgno,sect,&i,FT_INTERNAL | FT_PEEK); + if (stream->dtb->flags & DR_LOWMEM) ret = stream->private.search.result; + else { + for (t = NIL,param = body->parameter; param && !t; param = param->next) + if (!strcmp (param->attribute,"CHARSET")) t = param->value; + switch (body->encoding) { /* what encoding? */ + case ENCBASE64: + if (st.data = (unsigned char *) + rfc822_base64 ((unsigned char *) s,i,&st.size)) { + ret = mail_search_string (&st,t,&stream->private.search.string); + fs_give ((void **) &st.data); + } + break; + case ENCQUOTEDPRINTABLE: + if (st.data = rfc822_qprint ((unsigned char *) s,i,&st.size)) { + ret = mail_search_string (&st,t,&stream->private.search.string); + fs_give ((void **) &st.data); + } + break; + default: + st.data = (unsigned char *) s; + st.size = i; + ret = mail_search_string (&st,t,&stream->private.search.string); + break; + } + } + break; + } + return ret; +} + +/* Mail search text + * Accepts: sized text to search + * character set of sized text + * string list of search keys + * Returns: T if search found a match + */ + +long mail_search_string (SIZEDTEXT *s,char *charset,STRINGLIST **st) +{ + SIZEDTEXT u; + long ret; + STRINGLIST **sc = st; + /* convert to UTF-8 as best we can */ + if (!utf8_text (s,charset,&u,U8T_CANONICAL)) + utf8_text (s,NIL,&u,U8T_CANONICAL); + ret = mail_search_string_work (&u,st); + if (u.data != s->data) fs_give ((void **) &u.data); + return ret; +} + + +/* Mail search text worker routine + * Accepts: sized text to search + * string list of search keys + * Returns: T if search found a match + */ + +long mail_search_string_work (SIZEDTEXT *s,STRINGLIST **st) +{ + void *t; + STRINGLIST **sc = st; + while (*sc) { /* run down criteria list */ + if (ssearch (s->data,s->size,(*sc)->text.data,(*sc)->text.size)) { + t = (void *) (*sc); /* found one, need to flush this */ + *sc = (*sc)->next; /* remove it from the list */ + fs_give (&t); /* flush the buffer */ + } + else sc = &(*sc)->next; /* move to next in list */ + } + return *st ? NIL : LONGT; +} + + +/* Mail search keyword + * Accepts: MAIL stream + * elt to get flags from + * keyword list + * T for keyword search, NIL for unkeyword search + * Returns: T if search found a match + */ + +long mail_search_keyword (MAILSTREAM *stream,MESSAGECACHE *elt,STRINGLIST *st, + long flag) +{ + int i,j; + unsigned long f = 0; + unsigned long tf; + do { + for (i = 0; (j = (i < NUSERFLAGS) && stream->user_flags[i]); ++i) + if (!compare_csizedtext (stream->user_flags[i],&st->text)) { + f |= (1 << i); + break; + } + if (flag && !j) return NIL; + } while (st = st->next); + tf = elt->user_flags & f; /* get set flags which match */ + return flag ? (f == tf) : !tf; +} + +/* Mail search an address list + * Accepts: address list + * string list + * Returns: T if search found a match + */ + +#define SEARCHBUFLEN (size_t) 2000 +#define SEARCHBUFSLOP (size_t) 5 + +long mail_search_addr (ADDRESS *adr,STRINGLIST *st) +{ + ADDRESS *a,tadr; + SIZEDTEXT txt; + char tmp[SENDBUFLEN + 1]; + size_t i = SEARCHBUFLEN; + size_t k; + long ret = NIL; + if (adr) { + txt.data = (unsigned char *) fs_get (i + SEARCHBUFSLOP); + /* never an error or next */ + tadr.error = NIL,tadr.next = NIL; + /* write address list */ + for (txt.size = 0,a = adr; a; a = a->next) { + k = (tadr.mailbox = a->mailbox) ? 4 + 2*strlen (a->mailbox) : 3; + if (tadr.personal = a->personal) k += 3 + 2*strlen (a->personal); + if (tadr.adl = a->adl) k += 3 + 2*strlen (a->adl); + if (tadr.host = a->host) k += 3 + 2*strlen (a->host); + if (tadr.personal || tadr.adl) k += 2; + if (k < (SENDBUFLEN-10)) {/* ignore ridiculous addresses */ + tmp[0] = '\0'; + rfc822_write_address (tmp,&tadr); + /* resize buffer if necessary */ + if (((k = strlen (tmp)) + txt.size) > i) + fs_resize ((void **) &txt.data,SEARCHBUFSLOP + (i += SEARCHBUFLEN)); + /* add new address */ + memcpy (txt.data + txt.size,tmp,k); + txt.size += k; + /* another address follows */ + if (a->next) txt.data[txt.size++] = ','; + } + } + txt.data[txt.size] = '\0'; /* tie off string */ + ret = mail_search_header (&txt,st); + fs_give ((void **) &txt.data); + } + return ret; +} + +/* Get string for low-memory searching + * Accepts: readin function pointer + * stream to use + * number of bytes + * gets data packet + + * mail stream + * message number + * descriptor string + * option flags + * Returns: NIL, always + */ + +#define SEARCHSLOP 128 + +char *mail_search_gets (readfn_t f,void *stream,unsigned long size, + GETS_DATA *md) +{ + unsigned long i; + char tmp[MAILTMPLEN+SEARCHSLOP+1]; + SIZEDTEXT st; + /* better not be called unless searching */ + if (!md->stream->private.search.string) { + sprintf (tmp,"Search botch, mbx = %.80s, %s = %lu[%.80s]", + md->stream->mailbox, + (md->flags & FT_UID) ? "UID" : "msg",md->msgno,md->what); + fatal (tmp); + } + /* initially no match for search */ + md->stream->private.search.result = NIL; + /* make sure buffer clear */ + memset (st.data = (unsigned char *) tmp,'\0', + (size_t) MAILTMPLEN+SEARCHSLOP+1); + /* read first buffer */ + (*f) (stream,st.size = i = min (size,(long) MAILTMPLEN),tmp); + /* search for text */ + if (mail_search_string (&st,NIL,&md->stream->private.search.string)) + md->stream->private.search.result = T; + else if (size -= i) { /* more to do, blat slop down */ + memmove (tmp,tmp+MAILTMPLEN-SEARCHSLOP,(size_t) SEARCHSLOP); + do { /* read subsequent buffers one at a time */ + (*f) (stream,i = min (size,(long) MAILTMPLEN),tmp+SEARCHSLOP); + st.size = i + SEARCHSLOP; + if (mail_search_string (&st,NIL,&md->stream->private.search.string)) + md->stream->private.search.result = T; + else memmove (tmp,tmp+MAILTMPLEN,(size_t) SEARCHSLOP); + } + while ((size -= i) && !md->stream->private.search.result); + } + if (size) { /* toss out everything after that */ + do (*f) (stream,i = min (size,(long) MAILTMPLEN),tmp); + while (size -= i); + } + return NIL; +} + +/* Mail parse search criteria + * Accepts: criteria + * Returns: search program if parse successful, else NIL + */ + +SEARCHPGM *mail_criteria (char *criteria) +{ + SEARCHPGM *pgm = NIL; + char *criterion,*r,tmp[MAILTMPLEN]; + int f; + if (criteria) { /* only if criteria defined */ + /* make writeable copy of criteria */ + criteria = cpystr (criteria); + /* for each criterion */ + for (pgm = mail_newsearchpgm (), criterion = strtok_r (criteria," ",&r); + criterion; (criterion = strtok_r (NIL," ",&r))) { + f = NIL; /* init then scan the criterion */ + switch (*ucase (criterion)) { + case 'A': /* possible ALL, ANSWERED */ + if (!strcmp (criterion+1,"LL")) f = T; + else if (!strcmp (criterion+1,"NSWERED")) f = pgm->answered = T; + break; + case 'B': /* possible BCC, BEFORE, BODY */ + if (!strcmp (criterion+1,"CC")) + f = mail_criteria_string (&pgm->bcc,&r); + else if (!strcmp (criterion+1,"EFORE")) + f = mail_criteria_date (&pgm->before,&r); + else if (!strcmp (criterion+1,"ODY")) + f = mail_criteria_string (&pgm->body,&r); + break; + case 'C': /* possible CC */ + if (!strcmp (criterion+1,"C")) f = mail_criteria_string (&pgm->cc,&r); + break; + case 'D': /* possible DELETED */ + if (!strcmp (criterion+1,"ELETED")) f = pgm->deleted = T; + break; + case 'F': /* possible FLAGGED, FROM */ + if (!strcmp (criterion+1,"LAGGED")) f = pgm->flagged = T; + else if (!strcmp (criterion+1,"ROM")) + f = mail_criteria_string (&pgm->from,&r); + break; + case 'K': /* possible KEYWORD */ + if (!strcmp (criterion+1,"EYWORD")) + f = mail_criteria_string (&pgm->keyword,&r); + break; + + case 'N': /* possible NEW */ + if (!strcmp (criterion+1,"EW")) f = pgm->recent = pgm->unseen = T; + break; + case 'O': /* possible OLD, ON */ + if (!strcmp (criterion+1,"LD")) f = pgm->old = T; + else if (!strcmp (criterion+1,"N")) + f = mail_criteria_date (&pgm->on,&r); + break; + case 'R': /* possible RECENT */ + if (!strcmp (criterion+1,"ECENT")) f = pgm->recent = T; + break; + case 'S': /* possible SEEN, SINCE, SUBJECT */ + if (!strcmp (criterion+1,"EEN")) f = pgm->seen = T; + else if (!strcmp (criterion+1,"INCE")) + f = mail_criteria_date (&pgm->since,&r); + else if (!strcmp (criterion+1,"UBJECT")) + f = mail_criteria_string (&pgm->subject,&r); + break; + case 'T': /* possible TEXT, TO */ + if (!strcmp (criterion+1,"EXT")) + f = mail_criteria_string (&pgm->text,&r); + else if (!strcmp (criterion+1,"O")) + f = mail_criteria_string (&pgm->to,&r); + break; + case 'U': /* possible UN* */ + if (criterion[1] == 'N') { + if (!strcmp (criterion+2,"ANSWERED")) f = pgm->unanswered = T; + else if (!strcmp (criterion+2,"DELETED")) f = pgm->undeleted = T; + else if (!strcmp (criterion+2,"FLAGGED")) f = pgm->unflagged = T; + else if (!strcmp (criterion+2,"KEYWORD")) + f = mail_criteria_string (&pgm->unkeyword,&r); + else if (!strcmp (criterion+2,"SEEN")) f = pgm->unseen = T; + } + break; + default: /* we will barf below */ + break; + } + if (!f) { /* if can't identify criterion */ + sprintf (tmp,"Unknown search criterion: %.30s",criterion); + MM_LOG (tmp,ERROR); + mail_free_searchpgm (&pgm); + break; + } + } + /* no longer need copy of criteria */ + fs_give ((void **) &criteria); + } + return pgm; +} + +/* Parse a date + * Accepts: pointer to date integer to return + * pointer to strtok state + * Returns: T if successful, else NIL + */ + +int mail_criteria_date (unsigned short *date,char **r) +{ + STRINGLIST *s = NIL; + MESSAGECACHE elt; + /* parse the date and return fn if OK */ + int ret = (mail_criteria_string (&s,r) && + mail_parse_date (&elt,(char *) s->text.data) && + (*date = mail_shortdate (elt.year,elt.month,elt.day))) ? + T : NIL; + if (s) mail_free_stringlist (&s); + return ret; +} + +/* Calculate shortdate from elt values + * Accepts: year (0 = BASEYEAR) + * month (1 = January) + * day + * Returns: shortdate + */ + +unsigned short mail_shortdate (unsigned int year,unsigned int month, + unsigned int day) +{ + return (year << 9) + (month << 5) + day; +} + +/* Parse a string + * Accepts: pointer to stringlist + * pointer to strtok state + * Returns: T if successful, else NIL + */ + +int mail_criteria_string (STRINGLIST **s,char **r) +{ + unsigned long n; + char e,*d,*end = " ",*c = strtok_r (NIL,"",r); + if (!c) return NIL; /* missing argument */ + switch (*c) { /* see what the argument is */ + case '{': /* literal string */ + n = strtoul (c+1,&d,10); /* get its length */ + if ((*d++ == '}') && (*d++ == '\015') && (*d++ == '\012') && + (!(*(c = d + n)) || (*c == ' '))) { + e = *--c; /* store old delimiter */ + *c = '\377'; /* make sure not a space */ + strtok_r (c," ",r); /* reset the strtok mechanism */ + *c = e; /* put character back */ + break; + } + case '\0': /* catch bogons */ + case ' ': + return NIL; + case '"': /* quoted string */ + if (strchr (c+1,'"')) end = "\""; + else return NIL; /* falls through */ + default: /* atomic string */ + if (d = strtok_r (c,end,r)) n = strlen (d); + else return NIL; + break; + } + while (*s) s = &(*s)->next; /* find tail of list */ + *s = mail_newstringlist (); /* make new entry */ + /* return the data */ + (*s)->text.data = (unsigned char *) cpystr (d); + (*s)->text.size = n; + return T; +} + +/* Mail parse set from string + * Accepts: string to parse + * pointer to updated string pointer for return + * Returns: set with pointer updated, or NIL if error + */ + +SEARCHSET *mail_parse_set (char *s,char **ret) +{ + SEARCHSET *cur; + SEARCHSET *set = NIL; + while (isdigit (*s)) { + if (!set) cur = set = mail_newsearchset (); + else cur = cur->next = mail_newsearchset (); + /* parse value */ + if (!(cur->first = strtoul (s,&s,10)) || + ((*s == ':') && !(isdigit (*++s) && (cur->last = strtoul (s,&s,10))))) + break; /* bad value or range */ + if (*s == ',') ++s; /* point to next value if more */ + else { /* end of set */ + *ret = s; /* set return pointer */ + return set; /* return set */ + } + } + mail_free_searchset (&set); /* failure, punt partial set */ + return NIL; +} + + +/* Mail append to set + * Accepts: head of search set or NIL to do nothing + * message to add + * Returns: tail of search set or NIL if did nothing + */ + +SEARCHSET *mail_append_set (SEARCHSET *set,unsigned long msgno) +{ + if (set) { /* find tail */ + while (set->next) set = set->next; + /* start of set if no first member */ + if (!set->first) set->first = msgno; + else if (msgno == (set->last ? set->last : set->first) + 1) + set->last = msgno; /* extend range if 1 past current */ + else (set = set->next = mail_newsearchset ())->first = msgno; + } + return set; +} + +/* Mail sort messages + * Accepts: mail stream + * character set + * search program + * sort program + * option flags + * Returns: vector of sorted message sequences or NIL if error + */ + +unsigned long *mail_sort (MAILSTREAM *stream,char *charset,SEARCHPGM *spg, + SORTPGM *pgm,long flags) +{ + unsigned long *ret = NIL; + if (stream->dtb) /* do the driver's action */ + ret = (*(stream->dtb->sort ? stream->dtb->sort : mail_sort_msgs)) + (stream,charset,spg,pgm,flags); + /* flush search/sort programs if requested */ + if (spg && (flags & SE_FREE)) mail_free_searchpgm (&spg); + if (flags & SO_FREE) mail_free_sortpgm (&pgm); + return ret; +} + +/* Mail sort messages work routine + * Accepts: mail stream + * character set + * search program + * sort program + * option flags + * Returns: vector of sorted message sequences or NIL if error + */ + +unsigned long *mail_sort_msgs (MAILSTREAM *stream,char *charset,SEARCHPGM *spg, + SORTPGM *pgm,long flags) +{ + unsigned long i; + SORTCACHE **sc; + unsigned long *ret = NIL; + if (spg) { /* only if a search needs to be done */ + int silent = stream->silent; + stream->silent = T; /* don't pass up mm_searched() events */ + /* search for messages */ + mail_search_full (stream,charset,spg,NIL); + stream->silent = silent; /* restore silence state */ + } + /* initialize progress counters */ + pgm->nmsgs = pgm->progress.cached = 0; + /* pass 1: count messages to sort */ + for (i = 1; i <= stream->nmsgs; ++i) + if (mail_elt (stream,i)->searched) pgm->nmsgs++; + if (pgm->nmsgs) { /* pass 2: sort cache */ + sc = mail_sort_loadcache (stream,pgm); + /* pass 3: sort messages */ + if (!pgm->abort) ret = mail_sort_cache (stream,pgm,sc,flags); + fs_give ((void **) &sc); /* don't need sort vector any more */ + } + /* empty sort results */ + else ret = (unsigned long *) memset (fs_get (sizeof (unsigned long)),0, + sizeof (unsigned long)); + /* also return via callback if requested */ + if (mailsortresults) (*mailsortresults) (stream,ret,pgm->nmsgs); + return ret; /* return sort results */ +} + +/* Mail sort sortcache vector + * Accepts: mail stream + * sort program + * sortcache vector + * option flags + * Returns: vector of sorted message sequences or NIL if error + */ + +unsigned long *mail_sort_cache (MAILSTREAM *stream,SORTPGM *pgm,SORTCACHE **sc, + long flags) +{ + unsigned long i,*ret; + /* pass 3: sort messages */ + qsort ((void *) sc,pgm->nmsgs,sizeof (SORTCACHE *),mail_sort_compare); + /* optional post sorting */ + if (pgm->postsort) (*pgm->postsort) ((void *) sc); + /* pass 4: return results */ + ret = (unsigned long *) fs_get ((pgm->nmsgs+1) * sizeof (unsigned long)); + if (flags & SE_UID) /* UID or msgno? */ + for (i = 0; i < pgm->nmsgs; i++) ret[i] = mail_uid (stream,sc[i]->num); + else for (i = 0; i < pgm->nmsgs; i++) ret[i] = sc[i]->num; + ret[pgm->nmsgs] = 0; /* tie off message list */ + return ret; +} + +/* Mail load sortcache + * Accepts: mail stream, already searched + * sort program + * Returns: vector of sortcache pointers matching search + */ + +static STRINGLIST maildateline = {{(unsigned char *) "date",4},NIL}; +static STRINGLIST mailrnfromline = {{(unsigned char *) ">from",5},NIL}; +static STRINGLIST mailfromline = {{(unsigned char *) "from",4}, + &mailrnfromline}; +static STRINGLIST mailtonline = {{(unsigned char *) "to",2},NIL}; +static STRINGLIST mailccline = {{(unsigned char *) "cc",2},NIL}; +static STRINGLIST mailsubline = {{(unsigned char *) "subject",7},NIL}; + +SORTCACHE **mail_sort_loadcache (MAILSTREAM *stream,SORTPGM *pgm) +{ + char *t,*v,*x,tmp[MAILTMPLEN]; + SORTPGM *pg; + SORTCACHE *s,**sc; + MESSAGECACHE *elt,telt; + ENVELOPE *env; + ADDRESS *adr = NIL; + unsigned long i = (pgm->nmsgs) * sizeof (SORTCACHE *); + sc = (SORTCACHE **) memset (fs_get ((size_t) i),0,(size_t) i); + /* see what needs to be loaded */ + for (i = 1; !pgm->abort && (i <= stream->nmsgs); i++) + if ((elt = mail_elt (stream,i))->searched) { + sc[pgm->progress.cached++] = + s = (SORTCACHE *) (*mailcache) (stream,i,CH_SORTCACHE); + s->pgm = pgm; /* note sort program */ + s->num = i; + /* get envelope if cached */ + if (stream->scache) env = (i == stream->msgno) ? stream->env : NIL; + else env = elt->private.msg.env; + for (pg = pgm; pg; pg = pg->next) switch (pg->function) { + case SORTARRIVAL: /* sort by arrival date */ + if (!s->arrival) { + /* internal date unknown but can get? */ + if (!elt->day && !(stream->dtb->flags & DR_NOINTDATE)) { + sprintf (tmp,"%lu",i); + mail_fetch_fast (stream,tmp,NIL); + } + /* wrong thing before 3-Jan-1970 */ + s->arrival = elt->day ? mail_longdate (elt) : 1; + s->dirty = T; + } + break; + case SORTSIZE: /* sort by message size */ + if (!s->size) { + if (!elt->rfc822_size) { + sprintf (tmp,"%lu",i); + mail_fetch_fast (stream,tmp,NIL); + } + s->size = elt->rfc822_size ? elt->rfc822_size : 1; + s->dirty = T; + } + break; + + case SORTDATE: /* sort by date */ + if (!s->date) { + if (env) t = env->date; + else if ((t = mail_fetch_header (stream,i,NIL,&maildateline,NIL, + FT_INTERNAL | FT_PEEK)) && + (t = strchr (t,':'))) + for (x = ++t; x = strpbrk (x,"\012\015"); x++) + switch (*(v = ((*x == '\015') && (x[1] == '\012')) ? x+2 : x+1)){ + case ' ': /* erase continuation newlines */ + case '\t': + memmove (x,v,strlen (v)); + break; + default: /* tie off extraneous text */ + *x = x[1] = '\0'; + } + /* skip leading whitespace */ + if (t) while ((*t == ' ') || (*t == '\t')) t++; + /* parse date from Date: header */ + if (!(t && mail_parse_date (&telt,t) && + (s->date = mail_longdate (&telt)))) { + /* failed, use internal date */ + if (!(s->date = s->arrival)) { + /* internal date unknown but can get? */ + if (!elt->day && !(stream->dtb->flags & DR_NOINTDATE)) { + sprintf (tmp,"%lu",i); + mail_fetch_fast (stream,tmp,NIL); + } + /* wrong thing before 3-Jan-1970 */ + s->date = (s->arrival = elt->day ? mail_longdate (elt) : 1); + } + } + s->dirty = T; + } + break; + + case SORTFROM: /* sort by first from */ + if (!s->from) { + if (env) s->from = env->from && env->from->mailbox ? + cpystr (env->from->mailbox) : NIL; + else if ((t = mail_fetch_header (stream,i,NIL,&mailfromline,NIL, + FT_INTERNAL | FT_PEEK)) && + (t = strchr (t,':'))) { + for (x = ++t; x = strpbrk (x,"\012\015"); x++) + switch (*(v = ((*x == '\015') && (x[1] == '\012')) ? x+2 : x+1)){ + case ' ': /* erase continuation newlines */ + case '\t': + memmove (x,v,strlen (v)); + break; + case 'f': /* continuation but with extra "From:" */ + case 'F': + if (v = strchr (v,':')) { + memmove (x,v+1,strlen (v+1)); + break; + } + default: /* tie off extraneous text */ + *x = x[1] = '\0'; + } + if (adr = rfc822_parse_address (&adr,adr,&t,BADHOST,0)) { + s->from = adr->mailbox; + adr->mailbox = NIL; + mail_free_address (&adr); + } + } + if (!s->from) s->from = cpystr (""); + s->dirty = T; + } + break; + + case SORTTO: /* sort by first to */ + if (!s->to) { + if (env) s->to = env->to && env->to->mailbox ? + cpystr (env->to->mailbox) : NIL; + else if ((t = mail_fetch_header (stream,i,NIL,&mailtonline,NIL, + FT_INTERNAL | FT_PEEK)) && + (t = strchr (t,':'))) { + for (x = ++t; x = strpbrk (x,"\012\015"); x++) + switch (*(v = ((*x == '\015') && (x[1] == '\012')) ? x+2 : x+1)){ + case ' ': /* erase continuation newlines */ + case '\t': + memmove (x,v,strlen (v)); + break; + case 't': /* continuation but with extra "To:" */ + case 'T': + if (v = strchr (v,':')) { + memmove (x,v+1,strlen (v+1)); + break; + } + default: /* tie off extraneous text */ + *x = x[1] = '\0'; + } + if (adr = rfc822_parse_address (&adr,adr,&t,BADHOST,0)) { + s->to = adr->mailbox; + adr->mailbox = NIL; + mail_free_address (&adr); + } + } + if (!s->to) s->to = cpystr (""); + s->dirty = T; + } + break; + + case SORTCC: /* sort by first cc */ + if (!s->cc) { + if (env) s->cc = env->cc && env->cc->mailbox ? + cpystr (env->cc->mailbox) : NIL; + else if ((t = mail_fetch_header (stream,i,NIL,&mailccline,NIL, + FT_INTERNAL | FT_PEEK)) && + (t = strchr (t,':'))) { + for (x = ++t; x = strpbrk (x,"\012\015"); x++) + switch (*(v = ((*x == '\015') && (x[1] == '\012')) ? x+2 : x+1)){ + case ' ': /* erase continuation newlines */ + case '\t': + memmove (x,v,strlen (v)); + break; + case 't': /* continuation but with extra "To:" */ + case 'T': + if (v = strchr (v,':')) { + memmove (x,v+1,strlen (v+1)); + break; + } + default: /* tie off extraneous text */ + *x = x[1] = '\0'; + } + if (adr = rfc822_parse_address (&adr,adr,&t,BADHOST,0)) { + s->cc = adr->mailbox; + adr->mailbox = NIL; + mail_free_address (&adr); + } + } + if (!s->cc) s->cc = cpystr (""); + s->dirty = T; + } + break; + + case SORTSUBJECT: /* sort by subject */ + if (!s->subject) { + /* get subject from envelope if have one */ + if (env) t = env->subject ? env->subject : ""; + /* otherwise snarf from header text */ + else if ((t = mail_fetch_header (stream,i,NIL,&mailsubline, + NIL,FT_INTERNAL | FT_PEEK)) && + (t = strchr (t,':'))) + for (x = ++t; x = strpbrk (x,"\012\015"); x++) + switch (*(v = ((*x == '\015') && (x[1] == '\012')) ? x+2 : x+1)){ + case ' ': /* erase continuation newlines */ + case '\t': + memmove (x,v,strlen (v)); + break; + default: /* tie off extraneous text */ + *x = x[1] = '\0'; + } + else t = ""; /* empty subject */ + /* strip and cache subject */ + s->refwd = mail_strip_subject (t,&s->subject); + s->dirty = T; + } + break; + default: + fatal ("Unknown sort function"); + } + } + return sc; +} + +/* Strip subjects of extra spaces and leading and trailing cruft for sorting + * Accepts: unstripped subject + * pointer to return stripped subject, in cpystr form + * Returns: T if subject had a re/fwd, NIL otherwise + */ + +unsigned int mail_strip_subject (char *t,char **ret) +{ + SIZEDTEXT src,dst; + unsigned long i,slen; + char c,*s,*x; + unsigned int refwd = NIL; + if (src.size = strlen (t)) { /* have non-empty subject? */ + src.data = (unsigned char *) t; + /* Step 1 */ + /* make copy, convert MIME2 if needed */ + *ret = s = (utf8_mime2text (&src,&dst,U8T_CANONICAL) && + (src.data != dst.data)) ? (char *) dst.data : cpystr (t); + /* convert spaces to tab, strip extra spaces */ + for (x = t = s, c = 'x'; *t; t++) { + if (c != ' ') c = *x++ = ((*t == '\t') ? ' ' : *t); + else if ((*t != '\t') && (*t != ' ')) c = *x++ = *t; + } + *x = '\0'; /* tie off string */ + /* Step 2 */ + for (slen = dst.size; s; slen = strlen (s)) { + for (t = s + slen; t > s; ) switch (t[-1]) { + case ' ': case '\t': /* WSP */ + *--t = '\0'; /* just remove it */ + break; + case ')': /* possible "(fwd)" */ + if ((t >= (s + 5)) && (t[-5] == '(') && + ((t[-4] == 'F') || (t[-4] == 'f')) && + ((t[-3] == 'W') || (t[-3] == 'w')) && + ((t[-2] == 'D') || (t[-2] == 'd'))) { + *(t -= 5) = '\0'; /* remove "(fwd)" */ + refwd = T; /* note a re/fwd */ + break; + } + default: /* not a subj-trailer */ + t = s; + break; + } + /* Steps 3-5 */ + for (t = s; t; ) switch (*s) { + case ' ': case '\t': /* WSP */ + s = t = mail_strip_subject_wsp (s + 1); + break; + case 'r': case 'R': /* possible "re" */ + if (((s[1] == 'E') || (s[1] == 'e')) && + (t = mail_strip_subject_wsp (s + 2)) && + (t = mail_strip_subject_blob (t)) && (*t == ':')) { + s = ++t; /* found "re" */ + refwd = T; /* definitely a re/fwd at this point */ + } + else t = NIL; /* found subj-middle */ + break; + case 'f': case 'F': /* possible "fw" or "fwd" */ + if (((s[1] == 'w') || (s[1] == 'W')) && + (((s[2] == 'd') || (s[2] == 'D')) ? + (t = mail_strip_subject_wsp (s + 3)) : + (t = mail_strip_subject_wsp (s + 2))) && + (t = mail_strip_subject_blob (t)) && (*t == ':')) { + s = ++t; /* found "fwd" */ + refwd = T; /* definitely a re/fwd at this point */ + } + else t = NIL; /* found subj-middle */ + break; + case '[': /* possible subj-blob */ + if ((t = mail_strip_subject_blob (s)) && *t) s = t; + else t = NIL; /* found subj-middle */ + break; + default: + t = NIL; /* found subj-middle */ + break; + } + /* Step 6 */ + /* Netscape-style "[Fwd: ...]"? */ + if ((*s == '[') && ((s[1] == 'F') || (s[1] == 'f')) && + ((s[2] == 'W') || (s[2] == 'w')) && + ((s[3] == 'D') || (s[3] == 'd')) && (s[4] == ':') && + (s[i = strlen (s) - 1] == ']')) { + s[i] = '\0'; /* flush closing "]" */ + s += 5; /* and leading "[Fwd:" */ + refwd = T; /* definitely a re/fwd at this point */ + } + else break; /* don't need to loop back to step 2 */ + } + if (s != (t = *ret)) { /* removed leading text? */ + s = *ret = cpystr (s); /* yes, make a fresh return copy */ + fs_give ((void **) &t); /* flush old copy */ + } + } + else *ret = cpystr (""); /* empty subject */ + return refwd; /* return re/fwd state */ +} + +/* Strip subject wsp helper routine + * Accepts: text + * Returns: pointer to text after blob + */ + +char *mail_strip_subject_wsp (char *s) +{ + while ((*s == ' ') || (*s == '\t')) s++; + return s; +} + + +/* Strip subject blob helper routine + * Accepts: text + * Returns: pointer to text after any blob, NIL if blob-like but not blob + */ + +char *mail_strip_subject_blob (char *s) +{ + if (*s != '[') return s; /* not a blob, ignore */ + /* search for end of blob */ + while (*++s != ']') if ((*s == '[') || !*s) return NIL; + return mail_strip_subject_wsp (s + 1); +} + +/* Sort compare messages + * Accept: first message sort cache element + * second message sort cache element + * Returns: -1 if a1 < a2, 0 if a1 == a2, 1 if a1 > a2 + */ + +int mail_sort_compare (const void *a1,const void *a2) +{ + int i = 0; + SORTCACHE *s1 = *(SORTCACHE **) a1; + SORTCACHE *s2 = *(SORTCACHE **) a2; + SORTPGM *pgm = s1->pgm; + if (!s1->sorted) { /* this one sorted yet? */ + s1->sorted = T; + pgm->progress.sorted++; /* another sorted message */ + } + if (!s2->sorted) { /* this one sorted yet? */ + s2->sorted = T; + pgm->progress.sorted++; /* another sorted message */ + } + do { + switch (pgm->function) { /* execute search program */ + case SORTDATE: /* sort by date */ + i = compare_ulong (s1->date,s2->date); + break; + case SORTARRIVAL: /* sort by arrival date */ + i = compare_ulong (s1->arrival,s2->arrival); + break; + case SORTSIZE: /* sort by message size */ + i = compare_ulong (s1->size,s2->size); + break; + case SORTFROM: /* sort by first from */ + i = compare_cstring (s1->from,s2->from); + break; + case SORTTO: /* sort by first to */ + i = compare_cstring (s1->to,s2->to); + break; + case SORTCC: /* sort by first cc */ + i = compare_cstring (s1->cc,s2->cc); + break; + case SORTSUBJECT: /* sort by subject */ + i = compare_cstring (s1->subject,s2->subject); + break; + } + if (pgm->reverse) i = -i; /* flip results if necessary */ + } + while (pgm = i ? NIL : pgm->next); + /* return result, avoid 0 if at all possible */ + return i ? i : compare_ulong (s1->num,s2->num); +} + +/* Return message date as an unsigned long seconds since time began + * Accepts: message cache pointer + * Returns: unsigned long of date + * + * This routine, like most UNIX systems, is clueless about leap seconds. + * Thus, it treats 23:59:60 as equivalent to 00:00:00 the next day. + * + * This routine forces any early hours on 1-Jan-1970 in oriental timezones + * to be 1-Jan-1970 00:00:00 UTC, so as to avoid negative longdates. + */ + +unsigned long mail_longdate (MESSAGECACHE *elt) +{ + unsigned long m = elt->month ? elt->month : 1; + unsigned long yr = elt->year + BASEYEAR; + /* number of days since time began */ + unsigned long ret = (elt->day ? (elt->day - 1) : 0) + + 30 * (m - 1) + ((m + (m > 8)) / 2) +#ifndef USEJULIANCALENDAR +#ifndef USEORTHODOXCALENDAR /* Gregorian calendar */ + + ((yr / 400) - (BASEYEAR / 400)) - ((yr / 100) - (BASEYEAR / 100)) +#ifdef Y4KBUGFIX + - ((yr / 4000) - (BASEYEAR / 4000)) +#endif + - ((m < 3) ? + !(yr % 4) && ((yr % 100) || (!(yr % 400) +#ifdef Y4KBUGFIX + && (yr % 4000) +#endif + )) : 2) +#else /* Orthodox calendar */ + + ((2*(yr / 900)) - (2*(BASEYEAR / 900))) + + (((yr % 900) >= 200) - ((BASEYEAR % 900) >= 200)) + + (((yr % 900) >= 600) - ((BASEYEAR % 900) >= 600)) + - ((yr / 100) - (BASEYEAR / 100)) + - ((m < 3) ? + !(yr % 4) && ((yr % 100) || ((yr % 900) == 200) || ((yr % 900) == 600)) + : 2) +#endif +#endif + + elt->year * 365 + (((unsigned long) (elt->year + (BASEYEAR % 4))) / 4); + ret *= 24; ret += elt->hours; /* date value in hours */ + ret *= 60; ret +=elt->minutes;/* date value in minutes */ + yr = (elt->zhours * 60) + elt->zminutes; + if (elt->zoccident) ret += yr;/* occidental timezone, make UTC */ + else if (ret < yr) return 0; /* still 31-Dec-1969 in UTC */ + else ret -= yr; /* oriental timezone, make UTC */ + ret *= 60; ret += elt->seconds; + return ret; +} + +/* Mail thread messages + * Accepts: mail stream + * thread type + * character set + * search program + * option flags + * Returns: thread node tree or NIL if error + */ + +THREADNODE *mail_thread (MAILSTREAM *stream,char *type,char *charset, + SEARCHPGM *spg,long flags) +{ + THREADNODE *ret = NIL; + if (stream->dtb) /* must have a live driver */ + ret = stream->dtb->thread ? /* do driver's action if available */ + (*stream->dtb->thread) (stream,type,charset,spg,flags) : + mail_thread_msgs (stream,type,charset,spg,flags,mail_sort_msgs); + /* flush search/sort programs if requested */ + if (spg && (flags & SE_FREE)) mail_free_searchpgm (&spg); + return ret; +} + + +/* Mail thread messages + * Accepts: mail stream + * thread type + * character set + * search program + * option flags + * sorter routine + * Returns: thread node tree or NIL if error + */ + +THREADNODE *mail_thread_msgs (MAILSTREAM *stream,char *type,char *charset, + SEARCHPGM *spg,long flags,sorter_t sorter) +{ + THREADER *t; + for (t = &mailthreadlist; t; t = t->next) + if (!compare_cstring (type,t->name)) { + THREADNODE *ret = (*t->dispatch) (stream,charset,spg,flags,sorter); + if (mailthreadresults) (*mailthreadresults) (stream,ret); + return ret; + } + MM_LOG ("No such thread type",ERROR); + return NIL; +} + +/* Mail thread ordered subject + * Accepts: mail stream + * character set + * search program + * option flags + * sorter routine + * Returns: thread node tree + */ + +THREADNODE *mail_thread_orderedsubject (MAILSTREAM *stream,char *charset, + SEARCHPGM *spg,long flags, + sorter_t sorter) +{ + THREADNODE *thr = NIL; + THREADNODE *cur,*top,**tc; + SORTPGM pgm,pgm2; + SORTCACHE *s; + unsigned long i,j,*lst,*ls; + /* sort by subject+date */ + memset (&pgm,0,sizeof (SORTPGM)); + memset (&pgm2,0,sizeof (SORTPGM)); + pgm.function = SORTSUBJECT; + pgm.next = &pgm2; + pgm2.function = SORTDATE; + if (lst = (*sorter) (stream,charset,spg,&pgm,flags & ~(SE_FREE | SE_UID))){ + if (*(ls = lst)) { /* create thread */ + /* note first subject */ + cur = top = thr = mail_newthreadnode + ((SORTCACHE *) (*mailcache) (stream,*ls++,CH_SORTCACHE)); + /* note its number */ + cur->num = (flags & SE_UID) ? mail_uid (stream,*lst) : *lst; + i = 1; /* number of threads */ + while (*ls) { /* build tree */ + /* subjects match? */ + s = (SORTCACHE *) (*mailcache) (stream,*ls++,CH_SORTCACHE); + if (compare_cstring (top->sc->subject,s->subject)) { + i++; /* have a new thread */ + top = top->branch = cur = mail_newthreadnode (s); + } + /* start a child of the top */ + else if (cur == top) cur = cur->next = mail_newthreadnode (s); + /* sibling of child */ + else cur = cur->branch = mail_newthreadnode (s); + /* set to msgno or UID as needed */ + cur->num = (flags & SE_UID) ? mail_uid (stream,s->num) : s->num; + } + /* make threadnode cache */ + tc = (THREADNODE **) fs_get (i * sizeof (THREADNODE *)); + /* load threadnode cache */ + for (j = 0, cur = thr; cur; cur = cur->branch) tc[j++] = cur; + if (i != j) fatal ("Threadnode cache confusion"); + qsort ((void *) tc,i,sizeof (THREADNODE *),mail_thread_compare_date); + for (j = 0, --i; j < i; j++) tc[j]->branch = tc[j+1]; + tc[j]->branch = NIL; /* end of root */ + thr = tc[0]; /* head of data */ + fs_give ((void **) &tc); + } + fs_give ((void **) &lst); + } + return thr; +} + +/* Mail thread references + * Accepts: mail stream + * character set + * search program + * option flags + * sorter routine + * Returns: thread node tree + */ + +#define REFHASHSIZE 1009 /* arbitrary prime for hash table size */ + +/* Reference threading container, as described in Jamie Zawinski's web page + * (http://www.jwz.org/doc/threading.html) for this algorithm. These are + * stored as extended data in the hash table (called "id_table" in JWZ's + * document) and are maintained by the hash table routines. The hash table + * routines implement extended data as additional void* words at the end of + * each bucket, hence these strange macros instead of a struct which would + * have been more straightforward. + */ + +#define THREADLINKS 3 /* number of thread links */ + +#define CACHE(data) ((SORTCACHE *) (data)[0]) +#define PARENT(data) ((container_t) (data)[1]) +#define SETPARENT(data,value) ((container_t) (data[1] = value)) +#define SIBLING(data) ((container_t) (data)[2]) +#define SETSIBLING(data,value) ((container_t) (data[2] = value)) +#define CHILD(data) ((container_t) (data)[3]) +#define SETCHILD(data,value) ((container_t) (data[3] = value)) + +THREADNODE *mail_thread_references (MAILSTREAM *stream,char *charset, + SEARCHPGM *spg,long flags,sorter_t sorter) +{ + MESSAGECACHE *elt,telt; + ENVELOPE *env; + SORTCACHE *s; + STRINGLIST *st; + HASHENT *he; + THREADNODE **tc,*cur,*lst,*nxt,*sis,*msg; + container_t con,nxc,prc,sib; + void **sub; + char *t,tmp[MAILTMPLEN]; + unsigned long j,nmsgs; + unsigned long i = stream->nmsgs * sizeof (SORTCACHE *); + SORTCACHE **sc = (SORTCACHE **) memset (fs_get ((size_t) i),0,(size_t) i); + HASHTAB *ht = hash_create (REFHASHSIZE); + THREADNODE *root = NIL; + if (spg) { /* only if a search needs to be done */ + int silent = stream->silent; + stream->silent = T; /* don't pass up mm_searched() events */ + /* search for messages */ + mail_search_full (stream,charset,spg,NIL); + stream->silent = silent; /* restore silence state */ + } + + /* create SORTCACHE vector of requested msgs */ + for (i = 1, nmsgs = 0; i <= stream->nmsgs; ++i) + if (mail_elt (stream,i)->searched) + (sc[nmsgs++] = (SORTCACHE *)(*mailcache)(stream,i,CH_SORTCACHE))->num =i; + /* separate pass so can do overview fetch lookahead */ + for (i = 0; i < nmsgs; ++i) { /* for each requested message */ + /* is anything missing in its SORTCACHE? */ + if (!((s = sc[i])->date && s->subject && s->message_id && s->references)) { + /* driver has an overview mechanism? */ + if (stream->dtb && stream->dtb->overview) { + /* yes, find following unloaded entries */ + for (j = i + 1; (j < nmsgs) && !sc[j]->references; ++j); + sprintf (tmp,"%lu",mail_uid (stream,s->num)); + if (i != --j) /* end of range different? */ + sprintf (tmp + strlen (tmp),":%lu",mail_uid (stream,sc[j]->num)); + /* load via overview mechanism */ + mail_fetch_overview (stream,tmp,mail_thread_loadcache); + } + /* still missing data? */ + if (!s->date || !s->subject || !s->message_id || !s->references) { + /* try to load data from envelope */ + if (env = mail_fetch_structure (stream,s->num,NIL,NIL)) { + if (!s->date && env->date && mail_parse_date (&telt,env->date)) + s->date = mail_longdate (&telt); + if (!s->subject && env->subject) + s->refwd = + mail_strip_subject (env->subject,&s->subject); + if (!s->message_id && env->message_id && *env->message_id) + s->message_id = mail_thread_parse_msgid (env->message_id,NIL); + if (!s->references && /* use References: or In-Reply-To: */ + !(s->references = + mail_thread_parse_references (env->references,T))) + s->references = mail_thread_parse_references(env->in_reply_to,NIL); + } + /* last resort */ + if (!s->date && !(s->date = s->arrival)) { + /* internal date unknown but can get? */ + if (!(elt = mail_elt (stream,s->num))->day && + !(stream->dtb->flags & DR_NOINTDATE)) { + sprintf (tmp,"%lu",s->num); + mail_fetch_fast (stream,tmp,NIL); + } + /* wrong thing before 3-Jan-1970 */ + s->date = (s->arrival = elt->day ? mail_longdate (elt) : 1); + } + if (!s->subject) s->subject = cpystr (""); + if (!s->references) s->references = mail_newstringlist (); + s->dirty = T; + } + } + + /* Step 1 (preliminary) */ + /* generate unique string */ + sprintf (tmp,"%s.%lx.%lx@%s",stream->mailbox,stream->uid_validity, + mail_uid (stream,s->num),mylocalhost ()); + /* flush old unique string if not message-id */ + if (s->unique && (s->unique != s->message_id)) + fs_give ((void **) &s->unique); + s->unique = s->message_id ? /* don't permit Message ID duplicates */ + (hash_lookup (ht,s->message_id) ? cpystr (tmp) : s->message_id) : + (s->message_id = cpystr (tmp)); + /* add unique string to hash table */ + hash_add (ht,s->unique,s,THREADLINKS); + } + /* Step 1 */ + for (i = 0; i < nmsgs; ++i) { /* for each message in sortcache */ + /* Step 1A */ + if ((st = (s = sc[i])->references) && st->text.data) + for (con = hash_lookup_and_add (ht,(char *) st->text.data,NIL, + THREADLINKS); st = st->next; con = nxc) { + nxc = hash_lookup_and_add (ht,(char *) st->text.data,NIL,THREADLINKS); + /* only if no parent & won't introduce loop */ + if (!PARENT (nxc) && !mail_thread_check_child (con,nxc)) { + SETPARENT (nxc,con); /* establish parent/child link */ + /* other children become sibling of this one */ + SETSIBLING (nxc,CHILD (con)); + SETCHILD (con,nxc); /* set as child of parent */ + } + } + else con = NIL; /* else message has no ancestors */ + /* Step 1B */ + if ((prc = PARENT ((nxc = hash_lookup (ht,s->unique)))) && + (prc != con)) { /* break links if have a different parent */ + SETPARENT (nxc,NIL); /* easy if direct child */ + if (nxc == CHILD (prc)) SETCHILD (prc,SIBLING (nxc)); + else { /* otherwise hunt through sisters */ + for (sib = CHILD (prc); nxc != SIBLING (sib); sib = SIBLING (sib)); + SETSIBLING (sib,SIBLING (nxc)); + } + SETSIBLING (nxc,NIL); /* no more little sisters either */ + prc = NIL; /* no more parent set */ + } + /* need to set parent, and parent is good? */ + if (!prc && !mail_thread_check_child (con,nxc)) { + SETPARENT (nxc,con); /* establish parent/child link */ + if (con) { /* if non-root parent, set parent's child */ + if (CHILD (con)) { /* have a child already */ + /* find youngest daughter */ + for (con = CHILD (con); SIBLING (con); con = SIBLING (con)); + SETSIBLING (con,nxc); /* add new baby sister */ + } + else SETCHILD (con,nxc);/* set as only child */ + } + } + } + fs_give ((void **) &sc); /* finished with sortcache vector */ + + /* Step 2 */ + /* search hash table for parentless messages */ + for (i = 0, prc = con = NIL; i < ht->size; i++) + for (he = ht->table[i]; he; he = he->next) + if (!PARENT ((nxc = he->data))) { + /* sibling of previous parentless message */ + if (con) con = SETSIBLING (con,nxc); + else prc = con = nxc; /* first parentless message */ + } + /* Once the dummy containers are pruned, we no longer need the parent + * information, so we can convert the containers to THREADNODEs. Since + * we don't need the id_table any more either, we can reset the hash table + * and reuse it as a subject_table. Resetting the hash table will also + * destroy the containers. + */ + /* Step 3 */ + /* prune dummies, convert to threadnode */ + root = mail_thread_c2node (stream,mail_thread_prune_dummy (prc,NIL),flags); + /* Step 4 */ + /* make buffer for sorting */ + tc = (THREADNODE **) fs_get (nmsgs * sizeof (THREADNODE *)); + /* load threadcache and count nodes to sort */ + for (i = 0, cur = root; cur ; cur = cur->branch) tc[i++] = cur; + if (i > 1) { /* only if need to sort */ + qsort ((void *) tc,i,sizeof (THREADNODE *),mail_thread_compare_date); + /* relink siblings */ + for (j = 0, --i; j < i; j++) tc[j]->branch = tc[j+1]; + tc[j]->branch = NIL; /* end of root */ + root = tc[0]; /* establish new root */ + } + /* Step 5A */ + hash_reset (ht); /* discard containers, reset ht */ + /* Step 5B */ + for (cur = root; cur; cur = cur->branch) + if ((t = (nxt = (cur->sc ? cur : cur->next))->sc->subject) && *t) { + /* add new subject to hash table */ + if (!(sub = hash_lookup (ht,t))) hash_add (ht,t,cur,0); + /* if one in table not dummy and */ + else if ((s = (lst = (THREADNODE *) sub[0])->sc) && + /* current dummy, or not re/fwd and table is */ + (!cur->sc || (!nxt->sc->refwd && s->refwd))) + sub[0] = (void *) cur; /* replace with this message */ + } + + /* Step 5C */ + for (cur = root, sis = NIL; cur; cur = msg) { + /* do nothing if current message or no sub */ + if (!(t = (cur->sc ? cur : cur->next)->sc->subject) || !*t || + ((lst = (THREADNODE *) (sub = hash_lookup (ht,t))[0]) == cur)) + msg = (sis = cur)->branch; + else if (!lst->sc) { /* is message in the table a dummy? */ + /* find youngest daughter of msg in table */ + for (msg = lst->next; msg->branch; msg = msg->branch); + if (!cur->sc) { /* current message a dummy? */ + msg->branch = cur->next;/* current's daughter now dummy's youngest */ + msg = cur->branch; /* continue scan at younger sister */ + /* now delete this node */ + cur->branch = cur->next = NIL; + mail_free_threadnode (&cur); + } + else { /* current message not a dummy */ + msg->branch = cur; /* append as youngest daughter */ + msg = cur->branch; /* continue scan at younger sister */ + cur->branch = NIL; /* lose our younger sisters */ + } + } + else { /* no dummies, is current re/fwd, table not? */ + if (cur->sc->refwd && !lst->sc->refwd) { + if (lst->next) { /* find youngest daughter of msg in table */ + for (msg = lst->next; msg->branch; msg = msg->branch); + msg->branch = cur; /* append as youngest daughter */ + } + else lst->next = cur; /* no children, so make the eldest daughter */ + } + + else { /* no re/fwd, create a new dummy */ + msg = mail_newthreadnode (NIL); + if (lst == root) { /* msg in table is root? */ + root = lst->branch; /* younger sister becomes new root */ + /* no longer older sister either */ + if (lst == sis) sis = NIL; + } + else { /* find older sister of msg in table */ + for (nxt = root; lst != nxt->branch; nxt = nxt->branch); + /* remove from older sister */ + nxt->branch = lst->branch; + } + msg->next = lst; /* msg in table becomes child */ + lst->branch = cur; /* current now little sister of msg in table */ + if (sis) { /* have an elder sister? */ + if (sis == lst) /* rescan if lost her */ + for (sis = root; cur != sis->branch; sis = sis->branch); + sis->branch = msg; /* make dummy younger sister of big sister */ + } + else root = msg; /* otherwise this is the new root */ + sub[0] = sis = msg; /* set new msg in table and new big sister */ + } + msg = cur->branch; /* continue scan at younger sister */ + cur->branch = NIL; /* lose our younger sisters */ + } + if (sis) sis->branch = msg; /* older sister gets this as younger sister */ + else root = msg; /* otherwise this is the new root */ + } + hash_destroy (&ht); /* finished with hash table */ + /* Step 6 */ + /* sort threads */ + root = mail_thread_sort (root,tc); + fs_give ((void **) &tc); /* finished with sort buffer */ + return root; /* return sorted list */ +} + +/* Fetch overview callback to load sortcache for threading + * Accepts: MAIL stream + * UID of this message + * overview of this message + * msgno of this message + */ + +void mail_thread_loadcache (MAILSTREAM *stream,unsigned long uid,OVERVIEW *ov, + unsigned long msgno) +{ + if (msgno && ov) { /* just in case */ + MESSAGECACHE telt, *elt; + ENVELOPE *env; + SORTCACHE *s = (SORTCACHE *) (*mailcache) (stream,msgno,CH_SORTCACHE); + if (!s->subject && ov->subject) { + s->refwd = mail_strip_subject (ov->subject,&s->subject); + s->dirty = T; + } + if (!s->from && ov->from && ov->from->mailbox) { + s->from = cpystr (ov->from->mailbox); + s->dirty = T; + } + if (!s->date && ov->date && mail_parse_date (&telt,ov->date)) { + s->date = mail_longdate (&telt); + s->dirty = T; + } + if (!s->message_id && ov->message_id) { + s->message_id = mail_thread_parse_msgid (ov->message_id,NIL); + s->dirty = T; + } + if (!s->references && + !(s->references = mail_thread_parse_references (ov->references,T)) + && stream->dtb && !strcmp(stream->dtb->name, "imap") + && (elt = mail_elt (stream, msgno)) != NULL + && (env = elt->private.msg.env) != NULL + && env->in_reply_to + && !(s->references = mail_thread_parse_references(env->in_reply_to, NIL))) { + /* don't do In-Reply-To with NNTP mailboxes */ + s->references = mail_newstringlist (); + s->dirty = T; + } + if (!s->size && ov->optional.octets) { + s->size = ov->optional.octets; + s->dirty = T; + } + } +} + +/* Thread parse Message ID + * Accepts: pointer to purported Message ID + * pointer to return pointer + * Returns: Message ID or NIL, return pointer updated + */ + +char *mail_thread_parse_msgid (char *s,char **ss) +{ + char *ret = NIL; + char *t = NIL; + ADDRESS *adr; + if (s) { /* only for non-NIL strings */ + rfc822_skipws (&s); /* skip whitespace */ + /* ignore phrases */ + if (((*s == '<') || (s = rfc822_parse_phrase (s))) && + (adr = rfc822_parse_routeaddr (s,&t,BADHOST))) { + /* make return msgid */ + if (adr->mailbox && adr->host) + sprintf (ret = (char *) fs_get (strlen (adr->mailbox) + + strlen (adr->host) + 2),"%s@%s", + adr->mailbox,adr->host); + mail_free_address (&adr); /* don't need temporary address */ + } + } + if (ss) *ss = t; /* update return pointer */ + return ret; +} + + +/* Thread parse references + * Accepts: pointer to purported references + * parse multiple references flag + * Returns: references or NIL + */ + +STRINGLIST *mail_thread_parse_references (char *s,long flag) +{ + char *t; + STRINGLIST *ret = NIL; + STRINGLIST *cur; + /* found first reference? */ + if (t = mail_thread_parse_msgid (s,&s)) { + (ret = mail_newstringlist ())->text.data = (unsigned char *) t; + ret->text.size = strlen (t); + if (flag) /* parse subsequent references */ + for (cur = ret; t = mail_thread_parse_msgid (s,&s); cur = cur->next) { + (cur->next = mail_newstringlist ())->text.data = (unsigned char *) t; + cur->next->text.size = strlen (t); + } + } + return ret; +} + +/* Prune dummy messages + * Accepts: candidate container to prune + * older sibling of container, if any + * Returns: container in this position, possibly pruned + * All children and younger siblings are also pruned + */ + +container_t mail_thread_prune_dummy (container_t msg,container_t ane) +{ + /* prune container and children */ + container_t ret = msg ? mail_thread_prune_dummy_work (msg,ane) : NIL; + /* prune all younger sisters */ + if (ret) for (ane = ret; ane && (msg = SIBLING (ane)); ane = msg) + msg = mail_thread_prune_dummy_work (msg,ane); + return ret; +} + + +/* Prune dummy messages worker routine + * Accepts: candidate container to prune + * older sibling of container, if any + * Returns: container in this position, possibly pruned + * All children are also pruned + */ + +container_t mail_thread_prune_dummy_work (container_t msg,container_t ane) +{ + container_t cur; + /* get children, if any */ + container_t nxt = mail_thread_prune_dummy (CHILD (msg),NIL); + /* just update children if container has msg */ + if (CACHE (msg)) SETCHILD (msg,nxt); + else if (!nxt) { /* delete dummy with no children */ + nxt = SIBLING (msg); /* get younger sister */ + if (ane) SETSIBLING (ane,nxt); + /* prune younger sister if exists */ + msg = nxt ? mail_thread_prune_dummy_work (nxt,ane) : NIL; + } + /* not if parent root & multiple children */ + else if ((cur = PARENT (msg)) || !SIBLING (nxt)) { + /* OK to promote, try younger sister of aunt */ + if (ane) SETSIBLING (ane,nxt); + /* otherwise promote to child of grandmother */ + else if (cur) SETCHILD (cur,nxt); + SETPARENT (nxt,cur); /* set parent as well */ + /* look for end of siblings in new container */ + for (cur = nxt; SIBLING (cur); cur = SIBLING (cur)); + /* reattach deleted container's siblings */ + SETSIBLING (cur,SIBLING (msg)); + /* prune and return new container */ + msg = mail_thread_prune_dummy_work (nxt,ane); + } + else SETCHILD (msg,nxt); /* in case child pruned */ + return msg; /* return this message */ +} + +/* Test that purported mother is not a child of purported daughter + * Accepts: mother + * purported daugher + * Returns: T if circular parentage exists, else NIL + */ + +long mail_thread_check_child (container_t mother,container_t daughter) +{ + if (mother) { /* only if mother non-NIL */ + if (mother == daughter) return T; + for (daughter = CHILD (daughter); daughter; daughter = SIBLING (daughter)) + if (mail_thread_check_child (mother,daughter)) return T; + } + return NIL; +} + + +/* Generate threadnodes from containers + * Accepts: Mail stream + * container + * flags + * Return: threadnode list + */ + +THREADNODE *mail_thread_c2node (MAILSTREAM *stream,container_t con,long flags) +{ + THREADNODE *ret,*cur; + SORTCACHE *s; + container_t nxt; + /* for each container */ + for (ret = cur = NIL; con; con = SIBLING (con)) { + s = CACHE (con); /* yes, get its sortcache */ + /* create node for it */ + if (ret) cur = cur->branch = mail_newthreadnode (s); + else ret = cur = mail_newthreadnode (s); + /* attach sequence or UID for non-dummy */ + if (s) cur->num = (flags & SE_UID) ? mail_uid (stream,s->num) : s->num; + /* attach the children */ + if (nxt = CHILD (con)) cur->next = mail_thread_c2node (stream,nxt,flags); + } + return ret; +} + +/* Sort thread tree by date + * Accepts: thread tree to sort + * qsort vector to sort + * Returns: sorted thread tree + */ + +THREADNODE *mail_thread_sort (THREADNODE *thr,THREADNODE **tc) +{ + unsigned long i,j; + THREADNODE *cur; + /* sort children of each thread */ + for (cur = thr; cur; cur = cur->branch) + if (cur->next) cur->next = mail_thread_sort (cur->next,tc); + /* Must do this in a separate pass since recursive call will clobber tc */ + /* load threadcache and count nodes to sort */ + for (i = 0, cur = thr; cur; cur = cur->branch) tc[i++] = cur; + if (i > 1) { /* only if need to sort */ + qsort ((void *) tc,i,sizeof (THREADNODE *),mail_thread_compare_date); + /* relink root siblings */ + for (j = 0, --i; j < i; j++) tc[j]->branch = tc[j+1]; + tc[j]->branch = NIL; /* end of root */ + } + return i ? tc[0] : NIL; /* return new head of list */ +} + + +/* Thread compare date + * Accept: first message sort cache element + * second message sort cache element + * Returns: -1 if a1 < a2, 1 if a1 > a2 + * + * This assumes that a sort cache element is either a message (with a + * sortcache entry) or a dummy with a message (with sortcache entry) child. + * This is true of both the ORDEREDSUBJECT (no dummies) and REFERENCES + * (dummies only at top-level, and with non-dummy children). + * + * If a new algorithm allows a dummy parent to have a dummy child, this + * routine must be changed if it is to be used by that algorithm. + * + * Messages with bogus dates are always sorted at the top. + */ + +int mail_thread_compare_date (const void *a1,const void *a2) +{ + THREADNODE *t1 = *(THREADNODE **) a1; + THREADNODE *t2 = *(THREADNODE **) a2; + SORTCACHE *s1 = t1->sc ? t1->sc : t1->next->sc; + SORTCACHE *s2 = t2->sc ? t2->sc : t2->next->sc; + int ret = compare_ulong (s1->date,s2->date); + /* use number as final tie-breaker */ + return ret ? ret : compare_ulong (s1->num,s2->num); +} + +/* Mail parse sequence + * Accepts: mail stream + * sequence to parse + * Returns: T if parse successful, else NIL + */ + +long mail_sequence (MAILSTREAM *stream,unsigned char *sequence) +{ + unsigned long i,j,x; + for (i = 1; i <= stream->nmsgs; i++) mail_elt (stream,i)->sequence = NIL; + while (sequence && *sequence){/* while there is something to parse */ + if (*sequence == '*') { /* maximum message */ + if (stream->nmsgs) i = stream->nmsgs; + else { + MM_LOG ("No messages, so no maximum message number",ERROR); + return NIL; + } + sequence++; /* skip past * */ + } + /* parse and validate message number */ + else if (!isdigit (*sequence)) { + MM_LOG ("Syntax error in sequence",ERROR); + return NIL; + } + else if (!(i = strtoul (sequence,(char **) &sequence,10)) || + (i > stream->nmsgs)) { + MM_LOG ("Sequence out of range",ERROR); + return NIL; + } + switch (*sequence) { /* see what the delimiter is */ + case ':': /* sequence range */ + if (*++sequence == '*') { /* maximum message */ + if (stream->nmsgs) j = stream->nmsgs; + else { + MM_LOG ("No messages, so no maximum message number",ERROR); + return NIL; + } + sequence++; /* skip past * */ + } + /* parse end of range */ + else if (!(j = strtoul (sequence,(char **) &sequence,10)) || + (j > stream->nmsgs)) { + MM_LOG ("Sequence range invalid",ERROR); + return NIL; + } + if (*sequence && *sequence++ != ',') { + MM_LOG ("Sequence range syntax error",ERROR); + return NIL; + } + if (i > j) { /* swap the range if backwards */ + x = i; i = j; j = x; + } + /* mark each item in the sequence */ + while (i <= j) mail_elt (stream,j--)->sequence = T; + break; + case ',': /* single message */ + ++sequence; /* skip the delimiter, fall into end case */ + case '\0': /* end of sequence, mark this message */ + mail_elt (stream,i)->sequence = T; + break; + default: /* anything else is a syntax error! */ + MM_LOG ("Sequence syntax error",ERROR); + return NIL; + } + } + return T; /* successfully parsed sequence */ +} + +/* Parse flag list + * Accepts: MAIL stream + * flag list as a character string + * pointer to user flags to return + * Returns: system flags + */ + +long mail_parse_flags (MAILSTREAM *stream,char *flag,unsigned long *uf) +{ + char *t,*n,*s,tmp[MAILTMPLEN],msg[MAILTMPLEN]; + short f = 0; + long i,j; + *uf = 0; /* initially no user flags */ + if (flag && *flag) { /* no-op if no flag string */ + /* check if a list and make sure valid */ + if (((i = (*flag == '(')) ^ (flag[strlen (flag)-1] == ')')) || + (strlen (flag) >= MAILTMPLEN)) { + MM_LOG ("Bad flag list",ERROR); + return NIL; + } + /* copy the flag string w/o list construct */ + strncpy (n = tmp,flag+i,(j = strlen (flag) - (2*i))); + tmp[j] = '\0'; + while ((t = n) && *t) { /* parse the flags */ + /* find end of flag */ + if (n = strchr (t,' ')) *n++ = '\0'; + if (*t == '\\') { /* system flag? */ + if (!compare_cstring (t+1,"SEEN")) f |= fSEEN; + else if (!compare_cstring (t+1,"DELETED")) f |= fDELETED; + else if (!compare_cstring (t+1,"FLAGGED")) f |= fFLAGGED; + else if (!compare_cstring (t+1,"ANSWERED")) f |= fANSWERED; + else if (!compare_cstring (t+1,"DRAFT")) f |= fDRAFT; + else { + sprintf (msg,"Unsupported system flag: %.80s",t); + MM_LOG (msg,WARN); + } + } + + else { /* keyword flag */ + for (i = j = 0; /* user flag, search through table */ + !i && (j < NUSERFLAGS) && (s = stream->user_flags[j]); ++j) + if (!compare_cstring (t,s)) *uf |= i = 1 << j; + if (!i) { /* flag not found, can it be created? */ + if (stream->kwd_create && (j < NUSERFLAGS) && *t && + (strlen (t) <= MAXUSERFLAG)) { + for (s = t; t && *s; s++) switch (*s) { + default: /* all other characters */ + /* SPACE, CTL, or not CHAR */ + if ((*s > ' ') && (*s < 0x7f)) break; + case '*': case '%': /* list_wildcards */ + case '"': case '\\':/* quoted-specials */ + /* atom_specials */ + case '(': case ')': case '{': + case ']': /* resp-specials */ + sprintf (msg,"Invalid flag: %.80s",t); + MM_LOG (msg,WARN); + t = NIL; + } + if (t) { /* only if valid */ + *uf |= 1 << j; /* set the bit */ + stream->user_flags[j] = cpystr (t); + /* if out of user flags */ + if (j == NUSERFLAGS - 1) stream->kwd_create = NIL; + } + } + else { + if (*t) sprintf (msg,"Unknown flag: %.80s",t); + else strcpy (msg,"Empty flag invalid"); + MM_LOG (msg,WARN); + } + } + } + } + } + return f; +} + +/* Mail check network stream for usability with new name + * Accepts: MAIL stream + * candidate new name + * Returns: T if stream can be used, NIL otherwise + */ + +long mail_usable_network_stream (MAILSTREAM *stream,char *name) +{ + NETMBX smb,nmb,omb; + return (stream && stream->dtb && !(stream->dtb->flags & DR_LOCAL) && + mail_valid_net_parse (name,&nmb) && + mail_valid_net_parse (stream->mailbox,&smb) && + mail_valid_net_parse (stream->original_mailbox,&omb) && + ((!compare_cstring (smb.host, + trustdns ? tcp_canonical (nmb.host) : nmb.host)&& + !strcmp (smb.service,nmb.service) && + (!nmb.port || (smb.port == nmb.port)) && + (nmb.anoflag == stream->anonymous) && + (!nmb.user[0] || !strcmp (smb.user,nmb.user))) || + (!compare_cstring (omb.host,nmb.host) && + !strcmp (omb.service,nmb.service) && + (!nmb.port || (omb.port == nmb.port)) && + (nmb.anoflag == stream->anonymous) && + (!nmb.user[0] || !strcmp (omb.user,nmb.user))))) ? LONGT : NIL; +} + +/* Mail data structure instantiation routines */ + + +/* Mail instantiate cache elt + * Accepts: initial message number + * Returns: new cache elt + */ + +MESSAGECACHE *mail_new_cache_elt (unsigned long msgno) +{ + MESSAGECACHE *elt = (MESSAGECACHE *) memset (fs_get (sizeof (MESSAGECACHE)), + 0,sizeof (MESSAGECACHE)); + elt->lockcount = 1; /* initially only cache references it */ + elt->msgno = msgno; /* message number */ + return elt; +} + + +/* Mail instantiate envelope + * Returns: new envelope + */ + +ENVELOPE *mail_newenvelope (void) +{ + return (ENVELOPE *) memset (fs_get (sizeof (ENVELOPE)),0,sizeof (ENVELOPE)); +} + + +/* Mail instantiate address + * Returns: new address + */ + +ADDRESS *mail_newaddr (void) +{ + return (ADDRESS *) memset (fs_get (sizeof (ADDRESS)),0,sizeof (ADDRESS)); +} + +/* Mail instantiate body + * Returns: new body + */ + +BODY *mail_newbody (void) +{ + return mail_initbody ((BODY *) fs_get (sizeof (BODY))); +} + + +/* Mail initialize body + * Accepts: body + * Returns: body + */ + +BODY *mail_initbody (BODY *body) +{ + memset ((void *) body,0,sizeof (BODY)); + body->type = TYPETEXT; /* content type */ + body->encoding = ENC7BIT; /* content encoding */ + return body; +} + + +/* Mail instantiate body parameter + * Returns: new body part + */ + +PARAMETER *mail_newbody_parameter (void) +{ + return (PARAMETER *) memset (fs_get (sizeof(PARAMETER)),0,sizeof(PARAMETER)); +} + + +/* Mail instantiate body part + * Returns: new body part + */ + +PART *mail_newbody_part (void) +{ + PART *part = (PART *) memset (fs_get (sizeof (PART)),0,sizeof (PART)); + mail_initbody (&part->body); /* initialize the body */ + return part; +} + + +/* Mail instantiate body message part + * Returns: new body message part + */ + +MESSAGE *mail_newmsg (void) +{ + return (MESSAGE *) memset (fs_get (sizeof (MESSAGE)),0,sizeof (MESSAGE)); +} + +/* Mail instantiate string list + * Returns: new string list + */ + +STRINGLIST *mail_newstringlist (void) +{ + return (STRINGLIST *) memset (fs_get (sizeof (STRINGLIST)),0, + sizeof (STRINGLIST)); +} + + +/* Mail instantiate new search program + * Returns: new search program + */ + +SEARCHPGM *mail_newsearchpgm (void) +{ + return (SEARCHPGM *) memset (fs_get (sizeof(SEARCHPGM)),0,sizeof(SEARCHPGM)); +} + + +/* Mail instantiate new search program + * Accepts: header line name + * Returns: new search program + */ + +SEARCHHEADER *mail_newsearchheader (char *line,char *text) +{ + SEARCHHEADER *hdr = (SEARCHHEADER *) memset (fs_get (sizeof (SEARCHHEADER)), + 0,sizeof (SEARCHHEADER)); + hdr->line.size = strlen ((char *) (hdr->line.data = + (unsigned char *) cpystr (line))); + hdr->text.size = strlen ((char *) (hdr->text.data = + (unsigned char *) cpystr (text))); + return hdr; +} + + +/* Mail instantiate new search set + * Returns: new search set + */ + +SEARCHSET *mail_newsearchset (void) +{ + return (SEARCHSET *) memset (fs_get (sizeof(SEARCHSET)),0,sizeof(SEARCHSET)); +} + + +/* Mail instantiate new search or + * Returns: new search or + */ + +SEARCHOR *mail_newsearchor (void) +{ + SEARCHOR *or = (SEARCHOR *) memset (fs_get (sizeof (SEARCHOR)),0, + sizeof (SEARCHOR)); + or->first = mail_newsearchpgm (); + or->second = mail_newsearchpgm (); + return or; +} + +/* Mail instantiate new searchpgmlist + * Returns: new searchpgmlist + */ + +SEARCHPGMLIST *mail_newsearchpgmlist (void) +{ + SEARCHPGMLIST *pgl = (SEARCHPGMLIST *) + memset (fs_get (sizeof (SEARCHPGMLIST)),0,sizeof (SEARCHPGMLIST)); + pgl->pgm = mail_newsearchpgm (); + return pgl; +} + + +/* Mail instantiate new sortpgm + * Returns: new sortpgm + */ + +SORTPGM *mail_newsortpgm (void) +{ + return (SORTPGM *) memset (fs_get (sizeof (SORTPGM)),0,sizeof (SORTPGM)); +} + + +/* Mail instantiate new threadnode + * Accepts: sort cache for thread node + * Returns: new threadnode + */ + +THREADNODE *mail_newthreadnode (SORTCACHE *sc) +{ + THREADNODE *thr = (THREADNODE *) memset (fs_get (sizeof (THREADNODE)),0, + sizeof (THREADNODE)); + if (sc) thr->sc = sc; /* initialize sortcache */ + return thr; +} + + +/* Mail instantiate new acllist + * Returns: new acllist + */ + +ACLLIST *mail_newacllist (void) +{ + return (ACLLIST *) memset (fs_get (sizeof (ACLLIST)),0,sizeof (ACLLIST)); +} + + +/* Mail instantiate new quotalist + * Returns: new quotalist + */ + +QUOTALIST *mail_newquotalist (void) +{ + return (QUOTALIST *) memset (fs_get (sizeof (QUOTALIST)),0, + sizeof (QUOTALIST)); +} + +/* Mail garbage collection routines */ + + +/* Mail garbage collect body + * Accepts: pointer to body pointer + */ + +void mail_free_body (BODY **body) +{ + if (*body) { /* only free if exists */ + mail_free_body_data (*body);/* free its data */ + fs_give ((void **) body); /* return body to free storage */ + } +} + + +/* Mail garbage collect body data + * Accepts: body pointer + */ + +void mail_free_body_data (BODY *body) +{ + switch (body->type) { /* free contents */ + case TYPEMULTIPART: /* multiple part */ + mail_free_body_part (&body->nested.part); + break; + case TYPEMESSAGE: /* encapsulated message */ + if (body->subtype && !strcmp (body->subtype,"RFC822")) { + mail_free_stringlist (&body->nested.msg->lines); + mail_gc_msg (body->nested.msg,GC_ENV | GC_TEXTS); + } + if (body->nested.msg) fs_give ((void **) &body->nested.msg); + break; + default: + break; + } + if (body->subtype) fs_give ((void **) &body->subtype); + mail_free_body_parameter (&body->parameter); + if (body->id) fs_give ((void **) &body->id); + if (body->description) fs_give ((void **) &body->description); + if (body->disposition.type) fs_give ((void **) &body->disposition.type); + if (body->disposition.parameter) + mail_free_body_parameter (&body->disposition.parameter); + if (body->language) mail_free_stringlist (&body->language); + if (body->location) fs_give ((void **) &body->location); + if (body->mime.text.data) fs_give ((void **) &body->mime.text.data); + if (body->contents.text.data) fs_give ((void **) &body->contents.text.data); + if (body->md5) fs_give ((void **) &body->md5); + if (mailfreebodysparep && body->sparep) + (*mailfreebodysparep) (&body->sparep); +} + +/* Mail garbage collect body parameter + * Accepts: pointer to body parameter pointer + */ + +void mail_free_body_parameter (PARAMETER **parameter) +{ + if (*parameter) { /* only free if exists */ + if ((*parameter)->attribute) fs_give ((void **) &(*parameter)->attribute); + if ((*parameter)->value) fs_give ((void **) &(*parameter)->value); + /* run down the list as necessary */ + mail_free_body_parameter (&(*parameter)->next); + /* return body part to free storage */ + fs_give ((void **) parameter); + } +} + + +/* Mail garbage collect body part + * Accepts: pointer to body part pointer + */ + +void mail_free_body_part (PART **part) +{ + if (*part) { /* only free if exists */ + mail_free_body_data (&(*part)->body); + /* run down the list as necessary */ + mail_free_body_part (&(*part)->next); + fs_give ((void **) part); /* return body part to free storage */ + } +} + +/* Mail garbage collect message cache + * Accepts: mail stream + * + * The message cache is set to NIL when this function finishes. + */ + +void mail_free_cache (MAILSTREAM *stream) +{ + /* do driver specific stuff first */ + mail_gc (stream,GC_ELT | GC_ENV | GC_TEXTS); + /* flush the cache */ + (*mailcache) (stream,(long) 0,CH_INIT); +} + + +/* Mail garbage collect cache element + * Accepts: pointer to cache element pointer + */ + +void mail_free_elt (MESSAGECACHE **elt) +{ + /* only free if exists and no sharers */ + if (*elt && !--(*elt)->lockcount) { + mail_gc_msg (&(*elt)->private.msg,GC_ENV | GC_TEXTS); + if (mailfreeeltsparep && (*elt)->sparep) + (*mailfreeeltsparep) (&(*elt)->sparep); + fs_give ((void **) elt); + } + else *elt = NIL; /* else simply drop pointer */ +} + +/* Mail garbage collect envelope + * Accepts: pointer to envelope pointer + */ + +void mail_free_envelope (ENVELOPE **env) +{ + if (*env) { /* only free if exists */ + if ((*env)->remail) fs_give ((void **) &(*env)->remail); + mail_free_address (&(*env)->return_path); + if ((*env)->date) fs_give ((void **) &(*env)->date); + mail_free_address (&(*env)->from); + mail_free_address (&(*env)->sender); + mail_free_address (&(*env)->reply_to); + if ((*env)->subject) fs_give ((void **) &(*env)->subject); + mail_free_address (&(*env)->to); + mail_free_address (&(*env)->cc); + mail_free_address (&(*env)->bcc); + if ((*env)->in_reply_to) fs_give ((void **) &(*env)->in_reply_to); + if ((*env)->message_id) fs_give ((void **) &(*env)->message_id); + if ((*env)->newsgroups) fs_give ((void **) &(*env)->newsgroups); + if ((*env)->followup_to) fs_give ((void **) &(*env)->followup_to); + if ((*env)->references) fs_give ((void **) &(*env)->references); + if (mailfreeenvelopesparep && (*env)->sparep) + (*mailfreeenvelopesparep) (&(*env)->sparep); + fs_give ((void **) env); /* return envelope to free storage */ + } +} + + +/* Mail garbage collect address + * Accepts: pointer to address pointer + */ + +void mail_free_address (ADDRESS **address) +{ + if (*address) { /* only free if exists */ + if ((*address)->personal) fs_give ((void **) &(*address)->personal); + if ((*address)->adl) fs_give ((void **) &(*address)->adl); + if ((*address)->mailbox) fs_give ((void **) &(*address)->mailbox); + if ((*address)->host) fs_give ((void **) &(*address)->host); + if ((*address)->error) fs_give ((void **) &(*address)->error); + if ((*address)->orcpt.type) fs_give ((void **) &(*address)->orcpt.type); + if ((*address)->orcpt.addr) fs_give ((void **) &(*address)->orcpt.addr); + mail_free_address (&(*address)->next); + fs_give ((void **) address);/* return address to free storage */ + } +} + + +/* Mail garbage collect stringlist + * Accepts: pointer to stringlist pointer + */ + +void mail_free_stringlist (STRINGLIST **string) +{ + if (*string) { /* only free if exists */ + if ((*string)->text.data) fs_give ((void **) &(*string)->text.data); + mail_free_stringlist (&(*string)->next); + fs_give ((void **) string); /* return string to free storage */ + } +} + +/* Mail garbage collect searchpgm + * Accepts: pointer to searchpgm pointer + */ + +void mail_free_searchpgm (SEARCHPGM **pgm) +{ + if (*pgm) { /* only free if exists */ + mail_free_searchset (&(*pgm)->msgno); + mail_free_searchset (&(*pgm)->uid); + mail_free_searchor (&(*pgm)->or); + mail_free_searchpgmlist (&(*pgm)->not); + mail_free_searchheader (&(*pgm)->header); + mail_free_stringlist (&(*pgm)->bcc); + mail_free_stringlist (&(*pgm)->body); + mail_free_stringlist (&(*pgm)->cc); + mail_free_stringlist (&(*pgm)->from); + mail_free_stringlist (&(*pgm)->keyword); + mail_free_stringlist (&(*pgm)->subject); + mail_free_stringlist (&(*pgm)->text); + mail_free_stringlist (&(*pgm)->to); + fs_give ((void **) pgm); /* return program to free storage */ + } +} + + +/* Mail garbage collect searchheader + * Accepts: pointer to searchheader pointer + */ + +void mail_free_searchheader (SEARCHHEADER **hdr) +{ + if (*hdr) { /* only free if exists */ + if ((*hdr)->line.data) fs_give ((void **) &(*hdr)->line.data); + if ((*hdr)->text.data) fs_give ((void **) &(*hdr)->text.data); + mail_free_searchheader (&(*hdr)->next); + fs_give ((void **) hdr); /* return header to free storage */ + } +} + + +/* Mail garbage collect searchset + * Accepts: pointer to searchset pointer + */ + +void mail_free_searchset (SEARCHSET **set) +{ + if (*set) { /* only free if exists */ + mail_free_searchset (&(*set)->next); + fs_give ((void **) set); /* return set to free storage */ + } +} + +/* Mail garbage collect searchor + * Accepts: pointer to searchor pointer + */ + +void mail_free_searchor (SEARCHOR **orl) +{ + if (*orl) { /* only free if exists */ + mail_free_searchpgm (&(*orl)->first); + mail_free_searchpgm (&(*orl)->second); + mail_free_searchor (&(*orl)->next); + fs_give ((void **) orl); /* return searchor to free storage */ + } +} + + +/* Mail garbage collect search program list + * Accepts: pointer to searchpgmlist pointer + */ + +void mail_free_searchpgmlist (SEARCHPGMLIST **pgl) +{ + if (*pgl) { /* only free if exists */ + mail_free_searchpgm (&(*pgl)->pgm); + mail_free_searchpgmlist (&(*pgl)->next); + fs_give ((void **) pgl); /* return searchpgmlist to free storage */ + } +} + + +/* Mail garbage collect namespace + * Accepts: poiner to namespace + */ + +void mail_free_namespace (NAMESPACE **n) +{ + if (*n) { + fs_give ((void **) &(*n)->name); + mail_free_namespace (&(*n)->next); + mail_free_body_parameter (&(*n)->param); + fs_give ((void **) n); /* return namespace to free storage */ + } +} + +/* Mail garbage collect sort program + * Accepts: pointer to sortpgm pointer + */ + +void mail_free_sortpgm (SORTPGM **pgm) +{ + if (*pgm) { /* only free if exists */ + mail_free_sortpgm (&(*pgm)->next); + fs_give ((void **) pgm); /* return sortpgm to free storage */ + } +} + + +/* Mail garbage collect thread node + * Accepts: pointer to threadnode pointer + */ + +void mail_free_threadnode (THREADNODE **thr) +{ + if (*thr) { /* only free if exists */ + mail_free_threadnode (&(*thr)->branch); + mail_free_threadnode (&(*thr)->next); + fs_give ((void **) thr); /* return threadnode to free storage */ + } +} + + +/* Mail garbage collect acllist + * Accepts: pointer to acllist pointer + */ + +void mail_free_acllist (ACLLIST **al) +{ + if (*al) { /* only free if exists */ + if ((*al)->identifier) fs_give ((void **) &(*al)->identifier); + if ((*al)->rights) fs_give ((void **) &(*al)->rights); + mail_free_acllist (&(*al)->next); + fs_give ((void **) al); /* return acllist to free storage */ + } +} + + +/* Mail garbage collect quotalist + * Accepts: pointer to quotalist pointer + */ + +void mail_free_quotalist (QUOTALIST **ql) +{ + if (*ql) { /* only free if exists */ + if ((*ql)->name) fs_give ((void **) &(*ql)->name); + mail_free_quotalist (&(*ql)->next); + fs_give ((void **) ql); /* return quotalist to free storage */ + } +} + +/* Link authenicator + * Accepts: authenticator to add to list + */ + +void auth_link (AUTHENTICATOR *auth) +{ + if (!auth->valid || (*auth->valid) ()) { + AUTHENTICATOR **a = &mailauthenticators; + while (*a) a = &(*a)->next; /* find end of list of authenticators */ + *a = auth; /* put authenticator at the end */ + auth->next = NIL; /* this authenticator is the end of the list */ + } +} + + +/* Authenticate access + * Accepts: mechanism name + * responder function + * argument count + * argument vector + * Returns: authenticated user name or NIL + */ + +char *mail_auth (char *mechanism,authresponse_t resp,int argc,char *argv[]) +{ + AUTHENTICATOR *auth; + for (auth = mailauthenticators; auth; auth = auth->next) + if (auth->server && !compare_cstring (auth->name,mechanism)) + return (!(auth->flags & AU_DISABLE) && + ((auth->flags & AU_SECURE) || + !mail_parameters (NIL,GET_DISABLEPLAINTEXT,NIL))) ? + (*auth->server) (resp,argc,argv) : NIL; + return NIL; /* no authenticator found */ +} + +/* Lookup authenticator index + * Accepts: authenticator index + * Returns: authenticator, or 0 if not found + */ + +AUTHENTICATOR *mail_lookup_auth (unsigned long i) +{ + AUTHENTICATOR *auth = mailauthenticators; + while (auth && --i) auth = auth->next; + return auth; +} + + +/* Lookup authenticator name + * Accepts: authenticator name + * required authenticator flags + * Returns: index in authenticator chain, or 0 if not found + */ + +unsigned int mail_lookup_auth_name (char *mechanism,long flags) +{ + int i; + AUTHENTICATOR *auth; + for (i = 1, auth = mailauthenticators; auth; i++, auth = auth->next) + if (auth->client && !(flags & ~auth->flags) && + !(auth->flags & AU_DISABLE) && !compare_cstring (auth->name,mechanism)) + return i; + return 0; +} + +/* Standard TCP/IP network driver */ + +static NETDRIVER tcpdriver = { + tcp_open, /* open connection */ + tcp_aopen, /* open preauthenticated connection */ + tcp_getline, /* get a line */ + tcp_getbuffer, /* get a buffer */ + tcp_soutr, /* output pushed data */ + tcp_sout, /* output string */ + tcp_close, /* close connection */ + tcp_host, /* return host name */ + tcp_remotehost, /* return remote host name */ + tcp_port, /* return port number */ + tcp_localhost /* return local host name */ +}; + + +/* Network open + * Accepts: NETMBX specifier to open + * default network driver + * default port + * SSL driver + * SSL service name + * SSL driver port + * Returns: Network stream if success, else NIL + */ + +NETSTREAM *net_open (NETMBX *mb,NETDRIVER *dv,unsigned long port, + NETDRIVER *ssld,char *ssls,unsigned long sslp) +{ + NETSTREAM *stream = NIL; + char tmp[MAILTMPLEN]; + unsigned long flags = mb->novalidate ? NET_NOVALIDATECERT : 0; + if (strlen (mb->host) >= NETMAXHOST) { + sprintf (tmp,"Invalid host name: %.80s",mb->host); + MM_LOG (tmp,ERROR); + } + /* use designated driver if given */ + else if (dv) stream = net_open_work (dv,mb->host,mb->service,port,mb->port, + flags); + else if (mb->sslflag && ssld) /* use ssl if sslflag lit */ + stream = net_open_work (ssld,mb->host,ssls,sslp,mb->port,flags); + /* if trysslfirst and can open ssl... */ + else if ((mb->trysslflag || trysslfirst) && ssld && + (stream = net_open_work (ssld,mb->host,ssls,sslp,mb->port, + flags | NET_SILENT | NET_TRYSSL))) { + if (net_sout (stream,"",0)) mb->sslflag = T; + else { + net_close (stream); /* flush fake SSL stream */ + stream = NIL; + } + } + /* default to TCP driver */ + else stream = net_open_work (&tcpdriver,mb->host,mb->service,port,mb->port, + flags); + return stream; +} + +/* Network open worker routine + * Accepts: network driver + * host name + * service name to look up port + * port number if service name not found + * port number to override service name + * flags (passed on top of port) + * Returns: Network stream if success, else NIL + */ + +NETSTREAM *net_open_work (NETDRIVER *dv,char *host,char *service, + unsigned long port,unsigned long portoverride, + unsigned long flags) +{ + NETSTREAM *stream = NIL; + void *tstream; + if (service && (*service == '*')) { + flags |= NET_NOOPENTIMEOUT; /* mark that no timeout is desired */ + ++service; /* no longer need the no timeout indicator */ + } + if (portoverride) { /* explicit port number? */ + service = NIL; /* yes, override service name */ + port = portoverride; /* use that instead of default port */ + } + if (tstream = (*dv->open) (host,service,port | flags)) { + stream = (NETSTREAM *) fs_get (sizeof (NETSTREAM)); + stream->stream = tstream; + stream->dtb = dv; + } + return stream; +} + + +/* Network authenticated open + * Accepts: network driver + * NETMBX specifier + * service specifier + * return user name buffer + * Returns: Network stream if success else NIL + */ + +NETSTREAM *net_aopen (NETDRIVER *dv,NETMBX *mb,char *service,char *user) +{ + NETSTREAM *stream = NIL; + void *tstream; + if (!dv) dv = &tcpdriver; /* default to TCP driver */ + if (tstream = (*dv->aopen) (mb,service,user)) { + stream = (NETSTREAM *) fs_get (sizeof (NETSTREAM)); + stream->stream = tstream; + stream->dtb = dv; + } + return stream; +} + +/* Network receive line + * Accepts: Network stream + * Returns: text line string or NIL if failure + */ + +char *net_getline (NETSTREAM *stream) +{ + return (*stream->dtb->getline) (stream->stream); +} + + +/* Network receive buffer + * Accepts: Network stream (must be void * for use as readfn_t) + * size in bytes + * buffer to read into + * Returns: T if success, NIL otherwise + */ + +long net_getbuffer (void *st,unsigned long size,char *buffer) +{ + NETSTREAM *stream = (NETSTREAM *) st; + return (*stream->dtb->getbuffer) (stream->stream,size,buffer); +} + + +/* Network send null-terminated string + * Accepts: Network stream + * string pointer + * Returns: T if success else NIL + */ + +long net_soutr (NETSTREAM *stream,char *string) +{ + return (*stream->dtb->soutr) (stream->stream,string); +} + + +/* Network send string + * Accepts: Network stream + * string pointer + * byte count + * Returns: T if success else NIL + */ + +long net_sout (NETSTREAM *stream,char *string,unsigned long size) +{ + return (*stream->dtb->sout) (stream->stream,string,size); +} + +/* Network close + * Accepts: Network stream + */ + +void net_close (NETSTREAM *stream) +{ + if (stream->stream) (*stream->dtb->close) (stream->stream); + fs_give ((void **) &stream); +} + + +/* Network get host name + * Accepts: Network stream + * Returns: host name for this stream + */ + +char *net_host (NETSTREAM *stream) +{ + return (*stream->dtb->host) (stream->stream); +} + + +/* Network get remote host name + * Accepts: Network stream + * Returns: host name for this stream + */ + +char *net_remotehost (NETSTREAM *stream) +{ + return (*stream->dtb->remotehost) (stream->stream); +} + +/* Network return port for this stream + * Accepts: Network stream + * Returns: port number for this stream + */ + +unsigned long net_port (NETSTREAM *stream) +{ + return (*stream->dtb->port) (stream->stream); +} + + +/* Network get local host name + * Accepts: Network stream + * Returns: local host name + */ + +char *net_localhost (NETSTREAM *stream) +{ + return (*stream->dtb->localhost) (stream->stream); +} |