Edit File: imap4r1.c
/* ======================================================================== * 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: Interactive Message Access Protocol 4rev1 (IMAP4R1) routines * * Author: Mark Crispin * UW Technology * University of Washington * Seattle, WA 98195 * Internet: MRC@CAC.Washington.EDU * * Date: 15 June 1988 * Last Edited: 8 May 2008 * * This original version of this file is * Copyright 1988 Stanford University * and was developed in the Symbolic Systems Resources Group of the Knowledge * Systems Laboratory at Stanford University in 1987-88, and was funded by the * Biomedical Research Technology Program of the National Institutes of Health * under grant number RR-00785. */ #include <ctype.h> #include <stdio.h> #include <time.h> #include "c-client.h" #include "imap4r1.h" /* Parameters */ #define IMAPLOOKAHEAD 20 /* envelope lookahead */ #define IMAPUIDLOOKAHEAD 1000 /* UID lookahead */ #define IMAPTCPPORT (long) 143 /* assigned TCP contact port */ #define IMAPSSLPORT (long) 993 /* assigned SSL TCP contact port */ #define MAXCOMMAND 1000 /* RFC 2683 guideline for cmd line length */ #define IDLETIMEOUT (long) 30 /* defined in RFC 3501 */ #define MAXSERVERLIT 0x7ffffffe /* maximum server literal size * must be smaller than 4294967295 */ /* Parsed reply message from imap_reply */ typedef struct imap_parsed_reply { unsigned char *line; /* original reply string pointer */ unsigned char *tag; /* command tag this reply is for */ unsigned char *key; /* reply keyword */ unsigned char *text; /* subsequent text */ } IMAPPARSEDREPLY; #define IMAPTMPLEN 16*MAILTMPLEN /* IMAP4 I/O stream local data */ typedef struct imap_local { NETSTREAM *netstream; /* TCP I/O stream */ IMAPPARSEDREPLY reply; /* last parsed reply */ MAILSTATUS *stat; /* status to fill in */ IMAPCAP cap; /* server capabilities */ char *appendmailbox; /* mailbox being appended to */ unsigned int uidsearch : 1; /* UID searching */ unsigned int byeseen : 1; /* saw a BYE response */ /* got implicit capabilities */ unsigned int gotcapability : 1; unsigned int sensitive : 1; /* sensitive data in progress */ unsigned int tlsflag : 1; /* TLS session */ unsigned int tlssslv23 : 1; /* TLS using SSLv23 client method */ unsigned int notlsflag : 1; /* TLS not used in session */ unsigned int sslflag : 1; /* SSL session */ unsigned int novalidate : 1; /* certificate not validated */ unsigned int filter : 1; /* filter SEARCH/SORT/THREAD results */ unsigned int loser : 1; /* server is a loser */ unsigned int saslcancel : 1; /* SASL cancelled by protocol */ long authflags; /* required flags for authenticators */ unsigned long sortsize; /* sort return data size */ unsigned long *sortdata; /* sort return data */ struct { unsigned long uid; /* last UID returned */ unsigned long msgno; /* last msgno returned */ } lastuid; NAMESPACE **namespace; /* namespace return data */ THREADNODE *threaddata; /* thread return data */ char *referral; /* last referral */ char *prefix; /* find prefix */ char *user; /* logged-in user */ char *reform; /* reformed sequence */ char tmp[IMAPTMPLEN]; /* temporary buffer */ SEARCHSET *lookahead; /* fetch lookahead */ } IMAPLOCAL; /* Convenient access to local data */ #define LOCAL ((IMAPLOCAL *) stream->local) /* Arguments to imap_send() */ typedef struct imap_argument { int type; /* argument type */ void *text; /* argument text */ } IMAPARG; /* imap_send() argument types */ #define ATOM 0 #define NUMBER 1 #define FLAGS 2 #define ASTRING 3 #define LITERAL 4 #define LIST 5 #define SEARCHPROGRAM 6 #define SORTPROGRAM 7 #define BODYTEXT 8 #define BODYPEEK 9 #define BODYCLOSE 10 #define SEQUENCE 11 #define LISTMAILBOX 12 #define MULTIAPPEND 13 #define SNLIST 14 #define MULTIAPPENDREDO 15 /* Append data */ typedef struct append_data { append_t af; void *data; char *flags; char *date; STRING *message; } APPENDDATA; /* Function prototypes */ DRIVER *imap_valid (char *name); void *imap_parameters (long function,void *value); void imap_scan (MAILSTREAM *stream,char *ref,char *pat,char *contents); void imap_list (MAILSTREAM *stream,char *ref,char *pat); void imap_lsub (MAILSTREAM *stream,char *ref,char *pat); void imap_list_work (MAILSTREAM *stream,char *cmd,char *ref,char *pat, char *contents); long imap_subscribe (MAILSTREAM *stream,char *mailbox); long imap_unsubscribe (MAILSTREAM *stream,char *mailbox); long imap_create (MAILSTREAM *stream,char *mailbox); long imap_delete (MAILSTREAM *stream,char *mailbox); long imap_rename (MAILSTREAM *stream,char *old,char *newname); long imap_manage (MAILSTREAM *stream,char *mailbox,char *command,char *arg2); long imap_status (MAILSTREAM *stream,char *mbx,long flags); MAILSTREAM *imap_open (MAILSTREAM *stream); IMAPPARSEDREPLY *imap_rimap (MAILSTREAM *stream,char *service,NETMBX *mb, char *usr,char *tmp); long imap_anon (MAILSTREAM *stream,char *tmp); long imap_auth (MAILSTREAM *stream,NETMBX *mb,char *tmp,char *usr); long imap_login (MAILSTREAM *stream,NETMBX *mb,char *pwd,char *usr); void *imap_challenge (void *stream,unsigned long *len); long imap_response (void *stream,char *s,unsigned long size); void imap_close (MAILSTREAM *stream,long options); void imap_fast (MAILSTREAM *stream,char *sequence,long flags); void imap_flags (MAILSTREAM *stream,char *sequence,long flags); long imap_overview (MAILSTREAM *stream,overview_t ofn); ENVELOPE *imap_structure (MAILSTREAM *stream,unsigned long msgno,BODY **body, long flags); long imap_msgdata (MAILSTREAM *stream,unsigned long msgno,char *section, unsigned long first,unsigned long last,STRINGLIST *lines, long flags); unsigned long imap_uid (MAILSTREAM *stream,unsigned long msgno); unsigned long imap_msgno (MAILSTREAM *stream,unsigned long uid); void imap_flag (MAILSTREAM *stream,char *sequence,char *flag,long flags); long imap_search (MAILSTREAM *stream,char *charset,SEARCHPGM *pgm,long flags); unsigned long *imap_sort (MAILSTREAM *stream,char *charset,SEARCHPGM *spg, SORTPGM *pgm,long flags); THREADNODE *imap_thread (MAILSTREAM *stream,char *type,char *charset, SEARCHPGM *spg,long flags); THREADNODE *imap_thread_work (MAILSTREAM *stream,char *type,char *charset, SEARCHPGM *spg,long flags); long imap_ping (MAILSTREAM *stream); void imap_check (MAILSTREAM *stream); long imap_expunge (MAILSTREAM *stream,char *sequence,long options); long imap_copy (MAILSTREAM *stream,char *sequence,char *mailbox,long options); long imap_append (MAILSTREAM *stream,char *mailbox,append_t af,void *data); long imap_append_referral (char *mailbox,char *tmp,append_t af,void *data, char *flags,char *date,STRING *message, APPENDDATA *map,long options); IMAPPARSEDREPLY *imap_append_single (MAILSTREAM *stream,char *mailbox, char *flags,char *date,STRING *message); void imap_gc (MAILSTREAM *stream,long gcflags); void imap_gc_body (BODY *body); void imap_capability (MAILSTREAM *stream); long imap_acl_work (MAILSTREAM *stream,char *command,IMAPARG *args[]); IMAPPARSEDREPLY *imap_send (MAILSTREAM *stream,char *cmd,IMAPARG *args[]); IMAPPARSEDREPLY *imap_sout (MAILSTREAM *stream,char *tag,char *base,char **s); long imap_soutr (MAILSTREAM *stream,char *string); IMAPPARSEDREPLY *imap_send_astring (MAILSTREAM *stream,char *tag,char **s, SIZEDTEXT *as,long wildok,char *limit); IMAPPARSEDREPLY *imap_send_literal (MAILSTREAM *stream,char *tag,char **s, STRING *st); IMAPPARSEDREPLY *imap_send_spgm (MAILSTREAM *stream,char *tag,char *base, char **s,SEARCHPGM *pgm,char *limit); char *imap_send_spgm_trim (char *base,char *s,char *text); IMAPPARSEDREPLY *imap_send_sset (MAILSTREAM *stream,char *tag,char *base, char **s,SEARCHSET *set,char *prefix, char *limit); IMAPPARSEDREPLY *imap_send_slist (MAILSTREAM *stream,char *tag,char *base, char **s,char *name,STRINGLIST *list, char *limit); void imap_send_sdate (char **s,char *name,unsigned short date); IMAPPARSEDREPLY *imap_reply (MAILSTREAM *stream,char *tag); IMAPPARSEDREPLY *imap_parse_reply (MAILSTREAM *stream,char *text); IMAPPARSEDREPLY *imap_fake (MAILSTREAM *stream,char *tag,char *text); long imap_OK (MAILSTREAM *stream,IMAPPARSEDREPLY *reply); void imap_parse_unsolicited (MAILSTREAM *stream,IMAPPARSEDREPLY *reply); void imap_parse_response (MAILSTREAM *stream,char *text,long errflg,long ntfy); NAMESPACE *imap_parse_namespace (MAILSTREAM *stream,unsigned char **txtptr, IMAPPARSEDREPLY *reply); THREADNODE *imap_parse_thread (MAILSTREAM *stream,unsigned char **txtptr); void imap_parse_header (MAILSTREAM *stream,ENVELOPE **env,SIZEDTEXT *hdr, STRINGLIST *stl); void imap_parse_envelope (MAILSTREAM *stream,ENVELOPE **env, unsigned char **txtptr,IMAPPARSEDREPLY *reply); ADDRESS *imap_parse_adrlist (MAILSTREAM *stream,unsigned char **txtptr, IMAPPARSEDREPLY *reply); ADDRESS *imap_parse_address (MAILSTREAM *stream,unsigned char **txtptr, IMAPPARSEDREPLY *reply); void imap_parse_flags (MAILSTREAM *stream,MESSAGECACHE *elt, unsigned char **txtptr); unsigned long imap_parse_user_flag (MAILSTREAM *stream,char *flag); unsigned char *imap_parse_astring (MAILSTREAM *stream,unsigned char **txtptr, IMAPPARSEDREPLY *reply,unsigned long *len); unsigned char *imap_parse_string (MAILSTREAM *stream,unsigned char **txtptr, IMAPPARSEDREPLY *reply,GETS_DATA *md, unsigned long *len,long flags); void imap_parse_body (GETS_DATA *md,char *seg,unsigned char **txtptr, IMAPPARSEDREPLY *reply); void imap_parse_body_structure (MAILSTREAM *stream,BODY *body, unsigned char **txtptr,IMAPPARSEDREPLY *reply); PARAMETER *imap_parse_body_parameter (MAILSTREAM *stream, unsigned char **txtptr, IMAPPARSEDREPLY *reply); void imap_parse_disposition (MAILSTREAM *stream,BODY *body, unsigned char **txtptr,IMAPPARSEDREPLY *reply); STRINGLIST *imap_parse_language (MAILSTREAM *stream,unsigned char **txtptr, IMAPPARSEDREPLY *reply); STRINGLIST *imap_parse_stringlist (MAILSTREAM *stream,unsigned char **txtptr, IMAPPARSEDREPLY *reply); void imap_parse_extension (MAILSTREAM *stream,unsigned char **txtptr, IMAPPARSEDREPLY *reply); void imap_parse_capabilities (MAILSTREAM *stream,char *t); IMAPPARSEDREPLY *imap_fetch (MAILSTREAM *stream,char *sequence,long flags); char *imap_reform_sequence (MAILSTREAM *stream,char *sequence,long flags); /* Driver dispatch used by MAIL */ DRIVER imapdriver = { "imap", /* driver name */ /* driver flags */ DR_MAIL|DR_NEWS|DR_NAMESPACE|DR_CRLF|DR_RECYCLE|DR_HALFOPEN, (DRIVER *) NIL, /* next driver */ imap_valid, /* mailbox is valid for us */ imap_parameters, /* manipulate parameters */ imap_scan, /* scan mailboxes */ imap_list, /* find mailboxes */ imap_lsub, /* find subscribed mailboxes */ imap_subscribe, /* subscribe to mailbox */ imap_unsubscribe, /* unsubscribe from mailbox */ imap_create, /* create mailbox */ imap_delete, /* delete mailbox */ imap_rename, /* rename mailbox */ imap_status, /* status of mailbox */ imap_open, /* open mailbox */ imap_close, /* close mailbox */ imap_fast, /* fetch message "fast" attributes */ imap_flags, /* fetch message flags */ imap_overview, /* fetch overview */ imap_structure, /* fetch message envelopes */ NIL, /* fetch message header */ NIL, /* fetch message body */ imap_msgdata, /* fetch partial message */ imap_uid, /* unique identifier */ imap_msgno, /* message number */ imap_flag, /* modify flags */ NIL, /* per-message modify flags */ imap_search, /* search for message based on criteria */ imap_sort, /* sort messages */ imap_thread, /* thread messages */ imap_ping, /* ping mailbox to see if still alive */ imap_check, /* check for new messages */ imap_expunge, /* expunge deleted messages */ imap_copy, /* copy messages to another mailbox */ imap_append, /* append string message to mailbox */ imap_gc /* garbage collect stream */ }; /* prototype stream */ MAILSTREAM imapproto = {&imapdriver}; /* driver parameters */ static unsigned long imap_maxlogintrials = MAXLOGINTRIALS; static long imap_lookahead = IMAPLOOKAHEAD; static long imap_uidlookahead = IMAPUIDLOOKAHEAD; static long imap_fetchlookaheadlimit = IMAPLOOKAHEAD; static long imap_defaultport = 0; static long imap_sslport = 0; static long imap_tryssl = NIL; static long imap_prefetch = IMAPLOOKAHEAD; static long imap_closeonerror = NIL; static imapenvelope_t imap_envelope = NIL; static imapreferral_t imap_referral = NIL; static char *imap_extrahdrs = NIL; /* constants */ static char *hdrheader[] = { "BODY.PEEK[HEADER.FIELDS (Newsgroups Content-MD5 Content-Disposition Content-Language Content-Location", "BODY.PEEK[HEADER.FIELDS (Newsgroups Content-Disposition Content-Language Content-Location", "BODY.PEEK[HEADER.FIELDS (Newsgroups Content-Language Content-Location", "BODY.PEEK[HEADER.FIELDS (Newsgroups Content-Location", "BODY.PEEK[HEADER.FIELDS (Newsgroups" }; static char *hdrtrailer ="Followup-To References)]"; /* IMAP validate mailbox * Accepts: mailbox name * Returns: our driver if name is valid, NIL otherwise */ DRIVER *imap_valid (char *name) { return mail_valid_net (name,&imapdriver,NIL,NIL); } /* IMAP manipulate driver parameters * Accepts: function code * function-dependent value * Returns: function-dependent return value */ void *imap_parameters (long function,void *value) { switch ((int) function) { case GET_NAMESPACE: if (((IMAPLOCAL *) ((MAILSTREAM *) value)->local)->cap.namespace && !((IMAPLOCAL *) ((MAILSTREAM *) value)->local)->namespace) imap_send (((MAILSTREAM *) value),"NAMESPACE",NIL); value = (void *) &((IMAPLOCAL *) ((MAILSTREAM *) value)->local)->namespace; break; case GET_THREADERS: value = (void *) ((IMAPLOCAL *) ((MAILSTREAM *) value)->local)->cap.threader; break; case SET_FETCHLOOKAHEAD: /* must use pointer from GET_FETCHLOOKAHEAD */ fatal ("SET_FETCHLOOKAHEAD not permitted"); case GET_FETCHLOOKAHEAD: value = (void *) &((IMAPLOCAL *) ((MAILSTREAM *) value)->local)->lookahead; break; case SET_MAXLOGINTRIALS: imap_maxlogintrials = (long) value; break; case GET_MAXLOGINTRIALS: value = (void *) imap_maxlogintrials; break; case SET_LOOKAHEAD: imap_lookahead = (long) value; break; case GET_LOOKAHEAD: value = (void *) imap_lookahead; break; case SET_UIDLOOKAHEAD: imap_uidlookahead = (long) value; break; case GET_UIDLOOKAHEAD: value = (void *) imap_uidlookahead; break; case SET_IMAPPORT: imap_defaultport = (long) value; break; case GET_IMAPPORT: value = (void *) imap_defaultport; break; case SET_SSLIMAPPORT: imap_sslport = (long) value; break; case GET_SSLIMAPPORT: value = (void *) imap_sslport; break; case SET_PREFETCH: imap_prefetch = (long) value; break; case GET_PREFETCH: value = (void *) imap_prefetch; break; case SET_CLOSEONERROR: imap_closeonerror = (long) value; break; case GET_CLOSEONERROR: value = (void *) imap_closeonerror; break; case SET_IMAPENVELOPE: imap_envelope = (imapenvelope_t) value; break; case GET_IMAPENVELOPE: value = (void *) imap_envelope; break; case SET_IMAPREFERRAL: imap_referral = (imapreferral_t) value; break; case GET_IMAPREFERRAL: value = (void *) imap_referral; break; case SET_IMAPEXTRAHEADERS: imap_extrahdrs = (char *) value; break; case GET_IMAPEXTRAHEADERS: value = (void *) imap_extrahdrs; break; case SET_IMAPTRYSSL: imap_tryssl = (long) value; break; case GET_IMAPTRYSSL: value = (void *) imap_tryssl; break; case SET_FETCHLOOKAHEADLIMIT: imap_fetchlookaheadlimit = (long) value; break; case GET_FETCHLOOKAHEADLIMIT: value = (void *) imap_fetchlookaheadlimit; break; case SET_IDLETIMEOUT: fatal ("SET_IDLETIMEOUT not permitted"); case GET_IDLETIMEOUT: value = (void *) IDLETIMEOUT; break; default: value = NIL; /* error case */ break; } return value; } /* IMAP scan mailboxes * Accepts: mail stream * reference * pattern to search * string to scan */ void imap_scan (MAILSTREAM *stream,char *ref,char *pat,char *contents) { imap_list_work (stream,"SCAN",ref,pat,contents); } /* IMAP list mailboxes * Accepts: mail stream * reference * pattern to search */ void imap_list (MAILSTREAM *stream,char *ref,char *pat) { imap_list_work (stream,"LIST",ref,pat,NIL); } /* IMAP list subscribed mailboxes * Accepts: mail stream * reference * pattern to search */ void imap_lsub (MAILSTREAM *stream,char *ref,char *pat) { void *sdb = NIL; char *s,mbx[MAILTMPLEN]; /* do it on the server */ imap_list_work (stream,"LSUB",ref,pat,NIL); if (*pat == '{') { /* if remote pattern, must be IMAP */ if (!imap_valid (pat)) return; ref = NIL; /* good IMAP pattern, punt reference */ } /* if remote reference, must be valid IMAP */ if (ref && (*ref == '{') && !imap_valid (ref)) return; /* kludgy application of reference */ if (ref && *ref) sprintf (mbx,"%s%s",ref,pat); else strcpy (mbx,pat); if (s = sm_read (&sdb)) do if (imap_valid (s) && pmatch (s,mbx)) mm_lsub (stream,NIL,s,NIL); while (s = sm_read (&sdb)); /* until no more subscriptions */ } /* IMAP find list of mailboxes * Accepts: mail stream * list command * reference * pattern to search * string to scan */ void imap_list_work (MAILSTREAM *stream,char *cmd,char *ref,char *pat, char *contents) { MAILSTREAM *st = stream; int pl; char *s,prefix[MAILTMPLEN],mbx[MAILTMPLEN]; IMAPARG *args[4],aref,apat,acont; if (ref && *ref) { /* have a reference? */ if (!(imap_valid (ref) && /* make sure valid IMAP name and open stream */ ((stream && LOCAL && LOCAL->netstream) || (stream = mail_open (NIL,ref,OP_HALFOPEN|OP_SILENT))))) return; /* calculate prefix length */ pl = strchr (ref,'}') + 1 - ref; strncpy (prefix,ref,pl); /* build prefix */ prefix[pl] = '\0'; /* tie off prefix */ ref += pl; /* update reference */ } else { if (!(imap_valid (pat) && /* make sure valid IMAP name and open stream */ ((stream && LOCAL && LOCAL->netstream) || (stream = mail_open (NIL,pat,OP_HALFOPEN|OP_SILENT))))) return; /* calculate prefix length */ pl = strchr (pat,'}') + 1 - pat; strncpy (prefix,pat,pl); /* build prefix */ prefix[pl] = '\0'; /* tie off prefix */ pat += pl; /* update reference */ } LOCAL->prefix = prefix; /* note prefix */ if (contents) { /* want to do a scan? */ if (LEVELSCAN (stream)) { /* make sure permitted */ args[0] = &aref; args[1] = &apat; args[2] = &acont; args[3] = NIL; aref.type = ASTRING; aref.text = (void *) (ref ? ref : ""); apat.type = LISTMAILBOX; apat.text = (void *) pat; acont.type = ASTRING; acont.text = (void *) contents; imap_send (stream,cmd,args); } else mm_log ("Scan not valid on this IMAP server",ERROR); } else if (LEVELIMAP4 (stream)){/* easy if IMAP4 */ args[0] = &aref; args[1] = &apat; args[2] = NIL; aref.type = ASTRING; aref.text = (void *) (ref ? ref : ""); apat.type = LISTMAILBOX; apat.text = (void *) pat; /* referrals armed? */ if (LOCAL->cap.mbx_ref && mail_parameters (stream,GET_IMAPREFERRAL,NIL)) { /* yes, convert LIST -> RLIST */ if (!compare_cstring (cmd,"LIST")) cmd = "RLIST"; /* and convert LSUB -> RLSUB */ else if (!compare_cstring (cmd,"LSUB")) cmd = "RLSUB"; } imap_send (stream,cmd,args); } else if (LEVEL1176 (stream)) {/* convert to IMAP2 format wildcard */ /* kludgy application of reference */ if (ref && *ref) sprintf (mbx,"%s%s",ref,pat); else strcpy (mbx,pat); for (s = mbx; *s; s++) if (*s == '%') *s = '*'; args[0] = &apat; args[1] = NIL; apat.type = LISTMAILBOX; apat.text = (void *) mbx; if (!(strstr (cmd,"LIST") &&/* if list, try IMAP2bis, then RFC-1176 */ strcmp (imap_send (stream,"FIND ALL.MAILBOXES",args)->key,"BAD")) && !strcmp (imap_send (stream,"FIND MAILBOXES",args)->key,"BAD")) LOCAL->cap.rfc1176 = NIL; /* must be RFC-1064 */ } LOCAL->prefix = NIL; /* no more prefix */ /* close temporary stream if we made one */ if (stream != st) mail_close (stream); } /* IMAP subscribe to mailbox * Accepts: mail stream * mailbox to add to subscription list * Returns: T on success, NIL on failure */ long imap_subscribe (MAILSTREAM *stream,char *mailbox) { MAILSTREAM *st = stream; long ret = ((stream && LOCAL && LOCAL->netstream) || (stream = mail_open (NIL,mailbox,OP_HALFOPEN|OP_SILENT))) ? imap_manage (stream,mailbox,LEVELIMAP4 (stream) ? "Subscribe" : "Subscribe Mailbox",NIL) : NIL; /* toss out temporary stream */ if (st != stream) mail_close (stream); return ret; } /* IMAP unsubscribe to mailbox * Accepts: mail stream * mailbox to delete from manage list * Returns: T on success, NIL on failure */ long imap_unsubscribe (MAILSTREAM *stream,char *mailbox) { MAILSTREAM *st = stream; long ret = ((stream && LOCAL && LOCAL->netstream) || (stream = mail_open (NIL,mailbox,OP_HALFOPEN|OP_SILENT))) ? imap_manage (stream,mailbox,LEVELIMAP4 (stream) ? "Unsubscribe" : "Unsubscribe Mailbox",NIL) : NIL; /* toss out temporary stream */ if (st != stream) mail_close (stream); return ret; } /* IMAP create mailbox * Accepts: mail stream * mailbox name to create * Returns: T on success, NIL on failure */ long imap_create (MAILSTREAM *stream,char *mailbox) { return imap_manage (stream,mailbox,"Create",NIL); } /* IMAP delete mailbox * Accepts: mail stream * mailbox name to delete * Returns: T on success, NIL on failure */ long imap_delete (MAILSTREAM *stream,char *mailbox) { return imap_manage (stream,mailbox,"Delete",NIL); } /* IMAP rename mailbox * Accepts: mail stream * old mailbox name * new mailbox name * Returns: T on success, NIL on failure */ long imap_rename (MAILSTREAM *stream,char *old,char *newname) { return imap_manage (stream,old,"Rename",newname); } /* IMAP manage a mailbox * Accepts: mail stream * mailbox to manipulate * command to execute * optional second argument * Returns: T on success, NIL on failure */ long imap_manage (MAILSTREAM *stream,char *mailbox,char *command,char *arg2) { MAILSTREAM *st = stream; IMAPPARSEDREPLY *reply; long ret = NIL; char mbx[MAILTMPLEN],mbx2[MAILTMPLEN]; IMAPARG *args[3],ambx,amb2; imapreferral_t ir = (imapreferral_t) mail_parameters (stream,GET_IMAPREFERRAL,NIL); ambx.type = amb2.type = ASTRING; ambx.text = (void *) mbx; amb2.text = (void *) mbx2; args[0] = &ambx; args[1] = args[2] = NIL; /* require valid names and open stream */ if (mail_valid_net (mailbox,&imapdriver,NIL,mbx) && (arg2 ? mail_valid_net (arg2,&imapdriver,NIL,mbx2) : &imapdriver) && ((stream && LOCAL && LOCAL->netstream) || (stream = mail_open (NIL,mailbox,OP_HALFOPEN|OP_SILENT)))) { if (arg2) args[1] = &amb2; /* second arg present? */ if (!(ret = (imap_OK (stream,reply = imap_send (stream,command,args)))) && ir && LOCAL->referral) { long code = -1; switch (*command) { /* which command was it? */ case 'S': code = REFSUBSCRIBE; break; case 'U': code = REFUNSUBSCRIBE; break; case 'C': code = REFCREATE; break; case 'D': code = REFDELETE; break; case 'R': code = REFRENAME; break; default: fatal ("impossible referral command"); } if ((code >= 0) && (mailbox = (*ir) (stream,LOCAL->referral,code))) ret = imap_manage (NIL,mailbox,command,(*command == 'R') ? (mailbox + strlen (mailbox) + 1) : NIL); } mm_log (reply->text,ret ? NIL : ERROR); /* toss out temporary stream */ if (st != stream) mail_close (stream); } return ret; } /* IMAP status * Accepts: mail stream * mailbox name * status flags * Returns: T on success, NIL on failure */ long imap_status (MAILSTREAM *stream,char *mbx,long flags) { IMAPARG *args[3],ambx,aflg; char tmp[MAILTMPLEN]; NETMBX mb; unsigned long i; long ret = NIL; MAILSTREAM *tstream = NIL; /* use given stream if (rev1 or halfopen) and right host */ if (!((stream && (LEVELIMAP4rev1 (stream) || stream->halfopen) && mail_usable_network_stream (stream,mbx)) || (stream = tstream = mail_open (NIL,mbx,OP_HALFOPEN|OP_SILENT)))) return NIL; /* parse mailbox name */ mail_valid_net_parse (mbx,&mb); args[0] = &ambx;args[1] = NIL;/* set up first argument as mailbox */ ambx.type = ASTRING; ambx.text = (void *) mb.mailbox; if (LEVELIMAP4rev1 (stream)) {/* have STATUS command? */ imapreferral_t ir; aflg.type = FLAGS; aflg.text = (void *) tmp; args[1] = &aflg; args[2] = NIL; tmp[0] = tmp[1] = '\0'; /* build flag list */ if (flags & SA_MESSAGES) strcat (tmp," MESSAGES"); if (flags & SA_RECENT) strcat (tmp," RECENT"); if (flags & SA_UNSEEN) strcat (tmp," UNSEEN"); if (flags & SA_UIDNEXT) strcat (tmp," UIDNEXT"); if (flags & SA_UIDVALIDITY) strcat (tmp," UIDVALIDITY"); tmp[0] = '('; strcat (tmp,")"); /* send "STATUS mailbox flag" */ if (imap_OK (stream,imap_send (stream,"STATUS",args))) ret = T; else if ((ir = (imapreferral_t) mail_parameters (stream,GET_IMAPREFERRAL,NIL)) && LOCAL->referral && (mbx = (*ir) (stream,LOCAL->referral,REFSTATUS))) ret = imap_status (NIL,mbx,flags | (stream->debug ? SA_DEBUG : NIL)); } /* IMAP2 way */ else if (imap_OK (stream,imap_send (stream,"EXAMINE",args))) { MAILSTATUS status; status.flags = flags & ~ (SA_UIDNEXT | SA_UIDVALIDITY); status.messages = stream->nmsgs; status.recent = stream->recent; status.unseen = 0; if (flags & SA_UNSEEN) { /* must search to get unseen messages */ /* clear search vector */ for (i = 1; i <= stream->nmsgs; ++i) mail_elt (stream,i)->searched = NIL; if (imap_OK (stream,imap_send (stream,"SEARCH UNSEEN",NIL))) for (i = 1,status.unseen = 0; i <= stream->nmsgs; i++) if (mail_elt (stream,i)->searched) status.unseen++; } strcpy (strchr (strcpy (tmp,stream->mailbox),'}') + 1,mb.mailbox); /* pass status to main program */ mm_status (stream,tmp,&status); ret = T; /* note success */ } if (tstream) mail_close (tstream); return ret; /* success */ } /* IMAP open * Accepts: stream to open * Returns: stream to use on success, NIL on failure */ MAILSTREAM *imap_open (MAILSTREAM *stream) { unsigned long i,j; char *s,tmp[MAILTMPLEN],usr[MAILTMPLEN]; NETMBX mb; IMAPPARSEDREPLY *reply = NIL; imapreferral_t ir = (imapreferral_t) mail_parameters (stream,GET_IMAPREFERRAL,NIL); /* return prototype for OP_PROTOTYPE call */ if (!stream) return &imapproto; mail_valid_net_parse (stream->mailbox,&mb); usr[0] = '\0'; /* initially no user name */ if (LOCAL) { /* if stream opened earlier by us */ /* recycle if still alive */ if (LOCAL->netstream && (!stream->halfopen || LOCAL->cap.unselect)) { i = stream->silent; /* temporarily mark silent */ stream->silent = T; /* don't give mm_exists() events */ j = imap_ping (stream); /* learn if stream still alive */ stream->silent = i; /* restore prior state */ if (j) { /* was stream still alive? */ sprintf (tmp,"Reusing connection to %s",net_host (LOCAL->netstream)); if (LOCAL->user) sprintf (tmp + strlen (tmp),"/user=\"%s\"", LOCAL->user); if (!stream->silent) mm_log (tmp,(long) NIL); /* unselect if now want halfopen */ if (stream->halfopen) imap_send (stream,"UNSELECT",NIL); } else imap_close (stream,NIL); } else imap_close (stream,NIL); } /* copy flags from name */ if (mb.dbgflag) stream->debug = T; if (mb.readonlyflag) stream->rdonly = T; if (mb.anoflag) stream->anonymous = T; if (mb.secflag) stream->secure = T; if (mb.trysslflag || imap_tryssl) stream->tryssl = T; if (!LOCAL) { /* open new connection if no recycle */ NETDRIVER *ssld = (NETDRIVER *) mail_parameters (NIL,GET_SSLDRIVER,NIL); unsigned long defprt = imap_defaultport ? imap_defaultport : IMAPTCPPORT; unsigned long sslport = imap_sslport ? imap_sslport : IMAPSSLPORT; stream->local = /* instantiate localdata */ (void *) memset (fs_get (sizeof (IMAPLOCAL)),0,sizeof (IMAPLOCAL)); /* assume IMAP2bis server */ LOCAL->cap.imap2bis = LOCAL->cap.rfc1176 = T; /* in case server is a loser */ if (mb.loser) LOCAL->loser = T; /* desirable authenticators */ LOCAL->authflags = (stream->secure ? AU_SECURE : NIL) | (mb.authuser[0] ? AU_AUTHUSER : NIL); /* IMAP connection open logic is more complex than net_open() normally * deals with, because of the simap and rimap hacks. * If the session is anonymous, a specific port is given, or if /ssl or * /tls is set, do net_open() since those conditions override everything * else. */ if (stream->anonymous || mb.port || mb.sslflag || mb.tlsflag) reply = (LOCAL->netstream = net_open (&mb,NIL,defprt,ssld,"*imaps", sslport)) ? imap_reply (stream,NIL) : NIL; /* * No overriding conditions, so get the best connection that we can. In * order, attempt to open via simap, tryssl, rimap, and finally TCP. */ /* try simap */ else if (reply = imap_rimap (stream,"*imap",&mb,usr,tmp)); else if (ssld && /* try tryssl if enabled */ (stream->tryssl || mail_parameters (NIL,GET_TRYSSLFIRST,NIL)) && (LOCAL->netstream = net_open_work (ssld,mb.host,"*imaps",sslport,mb.port, (mb.novalidate ? NET_NOVALIDATECERT : 0) | NET_SILENT | NET_TRYSSL))) { if (net_sout (LOCAL->netstream,"",0)) { mb.sslflag = T; reply = imap_reply (stream,NIL); } else { /* flush fake SSL stream */ net_close (LOCAL->netstream); LOCAL->netstream = NIL; } } /* try rimap first, then TCP */ else if (!(reply = imap_rimap (stream,"imap",&mb,usr,tmp)) && (LOCAL->netstream = net_open (&mb,NIL,defprt,NIL,NIL,NIL))) reply = imap_reply (stream,NIL); /* make sure greeting is good */ if (!reply || strcmp (reply->tag,"*") || (strcmp (reply->key,"OK") && strcmp (reply->key,"PREAUTH"))) { if (reply) mm_log (reply->text,ERROR); return NIL; /* lost during greeting */ } /* if connected and not preauthenticated */ if (LOCAL->netstream && strcmp (reply->key,"PREAUTH")) { sslstart_t stls = (sslstart_t) mail_parameters (NIL,GET_SSLSTART,NIL); /* get server capabilities */ if (!LOCAL->gotcapability) imap_capability (stream); if (LOCAL->netstream && /* does server support STARTTLS? */ stls && LOCAL->cap.starttls && !mb.sslflag && !mb.notlsflag && imap_OK (stream,imap_send (stream,"STARTTLS",NIL))) { mb.tlsflag = T; /* TLS OK, get into TLS at this end */ LOCAL->netstream->dtb = ssld; if (!(LOCAL->netstream->stream = (*stls) (LOCAL->netstream->stream,mb.host, (mb.tlssslv23 ? NIL : NET_TLSCLIENT) | (mb.novalidate ? NET_NOVALIDATECERT : NIL)))) { /* drat, drop this connection */ if (LOCAL->netstream) net_close (LOCAL->netstream); LOCAL->netstream = NIL; } /* get capabilities now that TLS in effect */ if (LOCAL->netstream) imap_capability (stream); } else if (mb.tlsflag) { /* user specified /tls but can't do it */ mm_log ("Unable to negotiate TLS with this server",ERROR); return NIL; } if (LOCAL->netstream) { /* still in the land of the living? */ if ((long) mail_parameters (NIL,GET_TRUSTDNS,NIL)) { /* remote name for authentication */ strncpy (mb.host,(long) mail_parameters(NIL,GET_SASLUSESPTRNAME,NIL)? net_remotehost (LOCAL->netstream) : net_host (LOCAL->netstream),NETMAXHOST-1); mb.host[NETMAXHOST-1] = '\0'; } /* need new capabilities after login */ LOCAL->gotcapability = NIL; if (!(stream->anonymous ? imap_anon (stream,tmp) : (LOCAL->cap.auth ? imap_auth (stream,&mb,tmp,usr) : imap_login (stream,&mb,tmp,usr)))) { /* failed, is there a referral? */ if (ir && LOCAL->referral && (s = (*ir) (stream,LOCAL->referral,REFAUTHFAILED))) { imap_close (stream,NIL); fs_give ((void **) &stream->mailbox); /* set as new mailbox name to open */ stream->mailbox = s; return imap_open (stream); } return NIL; /* authentication failed */ } else if (ir && LOCAL->referral && (s = (*ir) (stream,LOCAL->referral,REFAUTH))) { imap_close (stream,NIL); fs_give ((void **) &stream->mailbox); stream->mailbox = s; /* set as new mailbox name to open */ /* recurse to log in on real site */ return imap_open (stream); } } } /* get server capabilities again */ if (LOCAL->netstream && !LOCAL->gotcapability) imap_capability (stream); /* save state for future recycling */ if (mb.tlsflag) LOCAL->tlsflag = T; if (mb.tlssslv23) LOCAL->tlssslv23 = T; if (mb.notlsflag) LOCAL->notlsflag = T; if (mb.sslflag) LOCAL->sslflag = T; if (mb.novalidate) LOCAL->novalidate = T; if (mb.loser) LOCAL->loser = T; } if (LOCAL->netstream) { /* still have a connection? */ stream->perm_seen = stream->perm_deleted = stream->perm_answered = stream->perm_draft = LEVELIMAP4 (stream) ? NIL : T; stream->perm_user_flags = LEVELIMAP4 (stream) ? NIL : 0xffffffff; stream->sequence++; /* bump sequence number */ sprintf (tmp,"{%s",(long) mail_parameters (NIL,GET_TRUSTDNS,NIL) ? net_host (LOCAL->netstream) : mb.host); if (!((i = net_port (LOCAL->netstream)) & 0xffff0000)) sprintf (tmp + strlen (tmp),":%lu",i); strcat (tmp,"/imap"); if (LOCAL->tlsflag) strcat (tmp,"/tls"); if (LOCAL->tlssslv23) strcat (tmp,"/tls-sslv23"); if (LOCAL->notlsflag) strcat (tmp,"/notls"); if (LOCAL->sslflag) strcat (tmp,"/ssl"); if (LOCAL->novalidate) strcat (tmp,"/novalidate-cert"); if (LOCAL->loser) strcat (tmp,"/loser"); if (stream->secure) strcat (tmp,"/secure"); if (stream->rdonly) strcat (tmp,"/readonly"); if (stream->anonymous) strcat (tmp,"/anonymous"); else { /* record user name */ if (!LOCAL->user && usr[0]) LOCAL->user = cpystr (usr); if (LOCAL->user) sprintf (tmp + strlen (tmp),"/user=\"%s\"", LOCAL->user); } strcat (tmp,"}"); if (!stream->halfopen) { /* wants to open a mailbox? */ IMAPARG *args[2]; IMAPARG ambx; ambx.type = ASTRING; ambx.text = (void *) mb.mailbox; args[0] = &ambx; args[1] = NIL; stream->nmsgs = 0; if (imap_OK (stream,reply = imap_send (stream,stream->rdonly ? "EXAMINE": "SELECT",args))) { strcat (tmp,mb.mailbox);/* mailbox name */ if (!stream->nmsgs && !stream->silent) mm_log ("Mailbox is empty",(long) NIL); /* note if an INBOX or not */ stream->inbox = !compare_cstring (mb.mailbox,"INBOX"); } else if (ir && LOCAL->referral && (s = (*ir) (stream,LOCAL->referral,REFSELECT))) { imap_close (stream,NIL); fs_give ((void **) &stream->mailbox); stream->mailbox = s; /* set as new mailbox name to open */ return imap_open (stream); } else { mm_log (reply->text,ERROR); if (imap_closeonerror) return NIL; stream->halfopen = T; /* let him keep it half-open */ } } if (stream->halfopen) { /* half-open connection? */ strcat (tmp,"<no_mailbox>"); /* make sure dummy message counts */ mail_exists (stream,(long) 0); mail_recent (stream,(long) 0); } fs_give ((void **) &stream->mailbox); stream->mailbox = cpystr (tmp); } /* success if stream open */ return LOCAL->netstream ? stream : NIL; } /* IMAP rimap connect * Accepts: MAIL stream * NETMBX specification * service to use * user name * scratch buffer * Returns: parsed reply if success, else NIL */ IMAPPARSEDREPLY *imap_rimap (MAILSTREAM *stream,char *service,NETMBX *mb, char *usr,char *tmp) { unsigned long i; char c[2]; NETSTREAM *tstream; IMAPPARSEDREPLY *reply = NIL; /* try rimap open */ if (!mb->norsh && (tstream = net_aopen (NIL,mb,service,usr))) { /* if success, see if reasonable banner */ if (net_getbuffer (tstream,(long) 1,c) && (*c == '*')) { i = 0; /* copy to buffer */ do tmp[i++] = *c; while (net_getbuffer (tstream,(long) 1,c) && (*c != '\015') && (*c != '\012') && (i < (MAILTMPLEN-1))); tmp[i] = '\0'; /* tie off */ /* snarfed a valid greeting? */ if ((*c == '\015') && net_getbuffer (tstream,(long) 1,c) && (*c == '\012') && !strcmp ((reply = imap_parse_reply (stream,cpystr (tmp)))->tag,"*")){ /* parse line as IMAP */ imap_parse_unsolicited (stream,reply); /* make sure greeting is good */ if (!strcmp (reply->key,"OK") || !strcmp (reply->key,"PREAUTH")) { LOCAL->netstream = tstream; return reply; /* return success */ } } } net_close (tstream); /* failed, punt the temporary netstream */ } return NIL; } /* IMAP log in as anonymous * Accepts: stream to authenticate * scratch buffer * Returns: T on success, NIL on failure */ long imap_anon (MAILSTREAM *stream,char *tmp) { IMAPPARSEDREPLY *reply; char *s = net_localhost (LOCAL->netstream); if (LOCAL->cap.authanon) { char tag[16]; unsigned long i; char *broken = "[CLOSED] IMAP connection broken (anonymous auth)"; sprintf (tag,"%08lx",0xffffffff & (stream->gensym++)); /* build command */ sprintf (tmp,"%s AUTHENTICATE ANONYMOUS",tag); if (!imap_soutr (stream,tmp)) { mm_log (broken,ERROR); return NIL; } if (imap_challenge (stream,&i)) imap_response (stream,s,strlen (s)); /* get response */ if (!(reply = &LOCAL->reply)->tag) reply = imap_fake (stream,tag,broken); /* what we wanted? */ if (compare_cstring (reply->tag,tag)) { /* abort if don't have tagged response */ while (compare_cstring ((reply = imap_reply (stream,tag))->tag,tag)) imap_soutr (stream,"*"); } } else { IMAPARG *args[2]; IMAPARG ausr; ausr.type = ASTRING; ausr.text = (void *) s; args[0] = &ausr; args[1] = NIL; /* send "LOGIN anonymous <host>" */ reply = imap_send (stream,"LOGIN ANONYMOUS",args); } /* success if reply OK */ if (imap_OK (stream,reply)) return T; mm_log (reply->text,ERROR); return NIL; } /* IMAP authenticate * Accepts: stream to authenticate * parsed network mailbox structure * scratch buffer * place to return user name * Returns: T on success, NIL on failure */ long imap_auth (MAILSTREAM *stream,NETMBX *mb,char *tmp,char *usr) { unsigned long trial,ua; int ok; char tag[16]; char *lsterr = NIL; AUTHENTICATOR *at; IMAPPARSEDREPLY *reply; for (ua = LOCAL->cap.auth, LOCAL->saslcancel = NIL; LOCAL->netstream && ua && (at = mail_lookup_auth (find_rightmost_bit (&ua) + 1));) { if (lsterr) { /* previous authenticator failed? */ sprintf (tmp,"Retrying using %s authentication after %.80s", at->name,lsterr); mm_log (tmp,NIL); fs_give ((void **) &lsterr); } trial = 0; /* initial trial count */ tmp[0] = '\0'; /* no error */ do { /* gensym a new tag */ if (lsterr) { /* previous attempt with this one failed? */ sprintf (tmp,"Retrying %s authentication after %.80s",at->name,lsterr); mm_log (tmp,WARN); fs_give ((void **) &lsterr); } LOCAL->saslcancel = NIL; sprintf (tag,"%08lx",0xffffffff & (stream->gensym++)); /* build command */ sprintf (tmp,"%s AUTHENTICATE %s",tag,at->name); if (imap_soutr (stream,tmp)) { /* hide client authentication responses */ if (!(at->flags & AU_SECURE)) LOCAL->sensitive = T; ok = (*at->client) (imap_challenge,imap_response,"imap",mb,stream, &trial,usr); LOCAL->sensitive = NIL; /* unhide */ /* make sure have a response */ if (!(reply = &LOCAL->reply)->tag) reply = imap_fake (stream,tag, "[CLOSED] IMAP connection broken (authenticate)"); else if (compare_cstring (reply->tag,tag)) while (compare_cstring ((reply = imap_reply (stream,tag))->tag,tag)) imap_soutr (stream,"*"); /* good if SASL ok and success response */ if (ok && imap_OK (stream,reply)) return T; if (!trial) { /* if main program requested cancellation */ mm_log ("IMAP Authentication cancelled",ERROR); return NIL; } /* no error if protocol-initiated cancel */ lsterr = cpystr (reply->text); } } while (LOCAL->netstream && !LOCAL->byeseen && trial && (trial < imap_maxlogintrials)); } if (lsterr) { /* previous authenticator failed? */ if (!LOCAL->saslcancel) { /* don't do this if a cancel */ sprintf (tmp,"Can not authenticate to IMAP server: %.80s",lsterr); mm_log (tmp,ERROR); } fs_give ((void **) &lsterr); } return NIL; /* ran out of authenticators */ } /* IMAP login * Accepts: stream to login * parsed network mailbox structure * scratch buffer of length MAILTMPLEN * place to return user name * Returns: T on success, NIL on failure */ long imap_login (MAILSTREAM *stream,NETMBX *mb,char *pwd,char *usr) { unsigned long trial = 0; IMAPPARSEDREPLY *reply; IMAPARG *args[3]; IMAPARG ausr,apwd; long ret = NIL; if (stream->secure) /* never do LOGIN if want security */ mm_log ("Can't do secure authentication with this server",ERROR); /* never do LOGIN if server disabled it */ else if (LOCAL->cap.logindisabled) mm_log ("Server disables LOGIN, no recognized SASL authenticator",ERROR); else if (mb->authuser[0]) /* never do LOGIN with /authuser */ mm_log ("Can't do /authuser with this server",ERROR); else { /* OK to try login */ ausr.type = apwd.type = ASTRING; ausr.text = (void *) usr; apwd.text = (void *) pwd; args[0] = &ausr; args[1] = &apwd; args[2] = NIL; do { pwd[0] = 0; /* prompt user for password */ mm_login (mb,usr,pwd,trial++); if (pwd[0]) { /* send login command if have password */ LOCAL->sensitive = T; /* hide this command */ /* send "LOGIN usr pwd" */ if (imap_OK (stream,reply = imap_send (stream,"LOGIN",args))) ret = LONGT; /* success */ else { mm_log (reply->text,WARN); if (!LOCAL->referral && (trial == imap_maxlogintrials)) mm_log ("Too many login failures",ERROR); } LOCAL->sensitive = NIL; /* unhide */ } /* user refused to give password */ else mm_log ("Login aborted",ERROR); } while (!ret && pwd[0] && (trial < imap_maxlogintrials) && LOCAL->netstream && !LOCAL->byeseen && !LOCAL->referral); } memset (pwd,0,MAILTMPLEN); /* erase password */ return ret; } /* Get challenge to authenticator in binary * Accepts: stream * pointer to returned size * Returns: challenge or NIL if not challenge */ void *imap_challenge (void *s,unsigned long *len) { char tmp[MAILTMPLEN]; void *ret = NIL; MAILSTREAM *stream = (MAILSTREAM *) s; IMAPPARSEDREPLY *reply = NIL; /* get tagged response or challenge */ while (stream && LOCAL->netstream && (reply = imap_parse_reply (stream,net_getline (LOCAL->netstream))) && !strcmp (reply->tag,"*")) imap_parse_unsolicited (stream,reply); /* parse challenge if have one */ if (stream && LOCAL->netstream && reply && reply->tag && (*reply->tag == '+') && !reply->tag[1] && reply->text && !(ret = rfc822_base64 ((unsigned char *) reply->text, strlen (reply->text),len))) { sprintf (tmp,"IMAP SERVER BUG (invalid challenge): %.80s", (char *) reply->text); mm_log (tmp,ERROR); } return ret; } /* Send authenticator response in BASE64 * Accepts: MAIL stream * string to send * length of string * Returns: T if successful, else NIL */ long imap_response (void *s,char *response,unsigned long size) { MAILSTREAM *stream = (MAILSTREAM *) s; unsigned long i,j,ret; char *t,*u; if (response) { /* make CRLFless BASE64 string */ if (size) { for (t = (char *) rfc822_binary ((void *) response,size,&i),u = t,j = 0; j < i; j++) if (t[j] > ' ') *u++ = t[j]; *u = '\0'; /* tie off string for mm_dlog() */ if (stream->debug) mail_dlog (t,LOCAL->sensitive); /* append CRLF */ *u++ = '\015'; *u++ = '\012'; ret = net_sout (LOCAL->netstream,t,u - t); fs_give ((void **) &t); } else ret = imap_soutr (stream,""); } else { /* abort requested */ ret = imap_soutr (stream,"*"); LOCAL->saslcancel = T; /* mark protocol-requested SASL cancel */ } return ret; } /* IMAP close * Accepts: MAIL stream * option flags */ void imap_close (MAILSTREAM *stream,long options) { THREADER *thr,*t; IMAPPARSEDREPLY *reply; if (stream && LOCAL) { /* send "LOGOUT" */ if (!LOCAL->byeseen) { /* don't even think of doing it if saw a BYE */ /* expunge silently if requested */ if (options & CL_EXPUNGE) imap_send (stream,LEVELIMAP4 (stream) ? "CLOSE" : "EXPUNGE",NIL); if (LOCAL->netstream && !imap_OK (stream,reply = imap_send (stream,"LOGOUT",NIL))) mm_log (reply->text,WARN); } /* close NET connection if still open */ if (LOCAL->netstream) net_close (LOCAL->netstream); LOCAL->netstream = NIL; /* free up memory */ if (LOCAL->sortdata) fs_give ((void **) &LOCAL->sortdata); if (LOCAL->namespace) { mail_free_namespace (&LOCAL->namespace[0]); mail_free_namespace (&LOCAL->namespace[1]); mail_free_namespace (&LOCAL->namespace[2]); fs_give ((void **) &LOCAL->namespace); } if (LOCAL->threaddata) mail_free_threadnode (&LOCAL->threaddata); /* flush threaders */ if (thr = LOCAL->cap.threader) while (t = thr) { fs_give ((void **) &t->name); thr = t->next; fs_give ((void **) &t); } if (LOCAL->referral) fs_give ((void **) &LOCAL->referral); if (LOCAL->user) fs_give ((void **) &LOCAL->user); if (LOCAL->reply.line) fs_give ((void **) &LOCAL->reply.line); if (LOCAL->reform) fs_give ((void **) &LOCAL->reform); /* nuke the local data */ fs_give ((void **) &stream->local); } } /* IMAP fetch fast information * Accepts: MAIL stream * sequence * option flags * * Generally, imap_structure is preferred */ void imap_fast (MAILSTREAM *stream,char *sequence,long flags) { IMAPPARSEDREPLY *reply = imap_fetch (stream,sequence,flags & FT_UID); if (!imap_OK (stream,reply)) mm_log (reply->text,ERROR); } /* IMAP fetch flags * Accepts: MAIL stream * sequence * option flags */ void imap_flags (MAILSTREAM *stream,char *sequence,long flags) { /* send "FETCH sequence FLAGS" */ char *cmd = (LEVELIMAP4 (stream) && (flags & FT_UID)) ? "UID FETCH":"FETCH"; IMAPPARSEDREPLY *reply; IMAPARG *args[3],aseq,aatt; if (LOCAL->loser) sequence = imap_reform_sequence (stream,sequence, flags & FT_UID); aseq.type = SEQUENCE; aseq.text = (void *) sequence; aatt.type = ATOM; aatt.text = (void *) "FLAGS"; args[0] = &aseq; args[1] = &aatt; args[2] = NIL; if (!imap_OK (stream,reply = imap_send (stream,cmd,args))) mm_log (reply->text,ERROR); } /* IMAP fetch overview * Accepts: MAIL stream, sequence bits set * pointer to overview return function * Returns: T if successful, NIL otherwise */ long imap_overview (MAILSTREAM *stream,overview_t ofn) { MESSAGECACHE *elt; ENVELOPE *env; OVERVIEW ov; char *s,*t; unsigned long i,start,last,len,slen; if (!LOCAL->netstream) return NIL; /* build overview sequence */ for (i = 1,len = start = last = 0,s = t = NIL; i <= stream->nmsgs; ++i) if ((elt = mail_elt (stream,i))->sequence) { if (!elt->private.msg.env) { if (s) { /* continuing a sequence */ if (i == last + 1) last = i; else { /* end of range */ if (last != start) sprintf (t,":%lu,%lu",last,i); else sprintf (t,",%lu",i); if ((len - (slen = (t += strlen (t)) - s)) < 20) { fs_resize ((void **) &s,len += MAILTMPLEN); t = s + slen; /* relocate current pointer */ } start = last = i; /* begin a new range */ } } else { /* first time, start new buffer */ s = (char *) fs_get (len = MAILTMPLEN); sprintf (s,"%lu",start = last = i); t = s + strlen (s); /* end of buffer */ } } } /* last sequence */ if (last != start) sprintf (t,":%lu",last); if (s) { /* prefetch as needed */ imap_fetch (stream,s,FT_NEEDENV); fs_give ((void **) &s); } ov.optional.lines = 0; /* now overview each message */ ov.optional.xref = NIL; if (ofn) 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); } return LONGT; } /* IMAP fetch 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 *imap_structure (MAILSTREAM *stream,unsigned long msgno,BODY **body, long flags) { unsigned long i,j,k,x; char *s,seq[MAILTMPLEN],tmp[MAILTMPLEN]; MESSAGECACHE *elt; ENVELOPE **env; BODY **b; IMAPPARSEDREPLY *reply = NIL; IMAPARG *args[3],aseq,aatt; SEARCHSET *set = LOCAL->lookahead; LOCAL->lookahead = NIL; args[0] = &aseq; args[1] = &aatt; args[2] = NIL; aseq.type = SEQUENCE; aseq.text = (void *) seq; aatt.type = ATOM; aatt.text = NIL; if (flags & FT_UID) /* see if can find msgno from UID */ for (i = 1; i <= stream->nmsgs; i++) if ((elt = mail_elt (stream,i))->private.uid == msgno) { msgno = i; /* found msgno, use it from now on */ flags &= ~FT_UID; /* no longer a UID fetch */ } sprintf (s = seq,"%lu",msgno);/* initial sequence */ if (LEVELIMAP4 (stream) && (flags & FT_UID)) { /* UID fetching is requested and we can't map the UID to a message sequence * number. Assume that the message isn't cached at all. */ if (!imap_OK (stream,reply = imap_fetch (stream,seq,FT_NEEDENV + (body ? FT_NEEDBODY : NIL) + (flags & (FT_UID + FT_NOHDRS))))) mm_log (reply->text,ERROR); /* now hunt for this UID */ for (i = 1; i <= stream->nmsgs; i++) if ((elt = mail_elt (stream,i))->private.uid == msgno) { if (body) *body = elt->private.msg.body; return elt->private.msg.env; } if (body) *body = NIL; /* can't find the UID */ return NIL; } elt = mail_elt (stream,msgno);/* get cache pointer */ if (stream->scache) { /* short caching? */ env = &stream->env; /* use temporaries on the stream */ b = &stream->body; if (msgno != stream->msgno){/* flush old poop if a different message */ mail_free_envelope (env); mail_free_body (b); stream->msgno = msgno; /* this is now the current short cache msg */ } } else { /* normal cache */ env = &elt->private.msg.env;/* get envelope and body pointers */ b = &elt->private.msg.body; /* prefetch if don't have envelope */ if (!(flags & FT_NOLOOKAHEAD) && ((!*env || (*env)->incomplete) || (body && !*b && LEVELIMAP2bis (stream)))) { if (set) { /* have a lookahead list? */ MESSAGE *msg; for (k = imap_fetchlookaheadlimit; k && set && (((s += strlen (s)) - seq) < (MAXCOMMAND - 30)); set = set->next) { i = (set->first == 0xffffffff) ? stream->nmsgs : min (set->first,stream->nmsgs); if (j = (set->last == 0xffffffff) ? stream->nmsgs : min (set->last,stream->nmsgs)) { if (i > j) { /* swap the range if backwards */ x = i; i = j; j = x; } /* find first message not msgno or in cache */ while (((i == msgno) || ((msg = &(mail_elt (stream,i)->private.msg))->env && (!body || msg->body))) && (i++ < j)); /* until range or lookahead finished */ while (k && (i <= j)) { /* find first cached message in range */ for (x = i + 1; (x <= j) && !((msg = &(mail_elt (stream,x)->private.msg))->env && (!body || msg->body)); x++); if (i == --x) { /* only one message? */ sprintf (s += strlen (s),",%lu",i++); k--; /* prefetching one message */ } else { /* a range to prefetch */ sprintf (s += strlen (s),",%lu:%lu",i,x); i = 1 + x - i; /* number of messages in this range */ /* still can look ahead some more? */ if (k = (k > i) ? k - i : 0) /* yes, scan further in this range */ for (i = x + 2; (i <= j) && ((i == msgno) || ((msg = &(mail_elt (stream,i)->private.msg))->env && (!body || msg->body))); i++); } } } else if ((i != msgno) && !mail_elt (stream,i)->private.msg.env) { sprintf (s += strlen (s),",%lu",i); k--; /* prefetching one message */ } } } /* build message number list */ else for (i = msgno+1,k = imap_lookahead; k && (i <= stream->nmsgs); i++) if (!mail_elt (stream,i)->private.msg.env) { s += strlen (s); /* find string end, see if nearing end */ if ((s - seq) > (MAILTMPLEN - 20)) break; sprintf (s,",%lu",i); /* append message */ for (j = i + 1, k--; /* hunt for last message without an envelope */ k && (j <= stream->nmsgs) && !mail_elt (stream,j)->private.msg.env; j++, k--); /* if different, make a range */ if (i != --j) sprintf (s + strlen (s),":%lu",i = j); } } } if (!stream->lock) { /* no-op if stream locked */ /* Build the fetch attributes. Unlike imap_fetch(), this tries not to * fetch data that is already cached. However, since it is based on the * message requested and not on any of the prefetched messages, it can * goof, either by fetching data already cached or not prefetching data * that isn't cached (but was cached in the message requested). * Fortunately, no great harm is done. If it doesn't prefetch the data, * it will get it when the affected message(s) are requested. */ if (!elt->private.uid && LEVELIMAP4 (stream)) strcpy (tmp," UID"); else tmp[0] = '\0'; /* initialize command */ /* need envelope? */ if (!*env || (*env)->incomplete) { strcat (tmp," ENVELOPE"); /* yes, get it and possible extra poop */ if (!(flags & FT_NOHDRS) && LEVELIMAP4rev1 (stream)) { if (imap_extrahdrs) sprintf (tmp + strlen (tmp)," %s %s %s", hdrheader[LOCAL->cap.extlevel], imap_extrahdrs,hdrtrailer); else sprintf (tmp + strlen (tmp)," %s %s", hdrheader[LOCAL->cap.extlevel],hdrtrailer); } } /* need body? */ if (body && !*b && LEVELIMAP2bis (stream)) strcat (tmp,LEVELIMAP4 (stream) ? " BODYSTRUCTURE" : " BODY"); if (!elt->day) strcat (tmp," INTERNALDATE"); if (!elt->rfc822_size) strcat (tmp," RFC822.SIZE"); if (tmp[0]) { /* anything to do? */ tmp[0] = '('; /* make into a list */ strcat (tmp," FLAGS)"); /* always get current flags */ aatt.text = (void *) tmp; /* do the built command */ if (!imap_OK (stream,reply = imap_send (stream,"FETCH",args))) { /* failed, probably RFC-1176 server */ if (!LEVELIMAP4 (stream) && LEVELIMAP2bis (stream) && body && !*b){ aatt.text = (void *) "ALL"; if (imap_OK (stream,reply = imap_send (stream,"FETCH",args))) /* doesn't have body capabilities */ LOCAL->cap.imap2bis = NIL; else mm_log (reply->text,ERROR); } else mm_log (reply->text,ERROR); } } } if (body) { /* wants to return body */ if (!*b && !LEVELIMAP2bis (stream)) { /* simulate body structure fetch for IMAP2 */ *b = mail_initbody (mail_newbody ()); (*b)->subtype = cpystr (rfc822_default_subtype ((*b)->type)); ((*b)->parameter = mail_newbody_parameter ())->attribute = cpystr ("CHARSET"); (*b)->parameter->value = cpystr ("US-ASCII"); s = mail_fetch_text (stream,msgno,NIL,&i,flags); (*b)->size.bytes = i; while (i--) if (*s++ == '\n') (*b)->size.lines++; } *body = *b; /* return the body */ } return *env; /* return the envelope */ } /* IMAP fetch message data * Accepts: MAIL stream * message number * section specifier * offset of first designated byte or 0 to start at beginning * maximum number of bytes or 0 for all bytes * lines to fetch if header * flags * Returns: T on success, NIL on failure */ long imap_msgdata (MAILSTREAM *stream,unsigned long msgno,char *section, unsigned long first,unsigned long last,STRINGLIST *lines, long flags) { int i; char *t,tmp[MAILTMPLEN],partial[40],seq[40]; char *noextend,*nopartial,*nolines,*nopeek,*nononpeek; char *cmd = (LEVELIMAP4 (stream) && (flags & FT_UID)) ? "UID FETCH":"FETCH"; IMAPPARSEDREPLY *reply; IMAPARG *args[5],*auxargs[3],aseq,aatt,alns,acls,aflg; noextend = nopartial = nolines = nopeek = nononpeek = NIL; /* does searching desire a lookahead? */ if ((flags & FT_SEARCHLOOKAHEAD) && (msgno < stream->nmsgs) && !stream->scache) { sprintf (seq,"%lu:%lu",msgno, (unsigned long) min (msgno + IMAPLOOKAHEAD,stream->nmsgs)); aseq.type = SEQUENCE; aseq.text = (void *) seq; } else { /* no, do it the easy way */ aseq.type = NUMBER; aseq.text = (void *) msgno; } aatt.type = ATOM; /* assume atomic attribute */ alns.type = LIST; alns.text = (void *) lines; acls.type = BODYCLOSE; acls.text = (void *) partial; aflg.type = ATOM; aflg.text = (void *) "FLAGS"; args[0] = &aseq; args[1] = &aatt; args[2] = args[3] = args[4] = NIL; auxargs[0] = &aseq; auxargs[1] = &aflg; auxargs[2] = NIL; partial[0] = '\0'; /* initially no partial specifier */ if (LEVELIMAP4rev1 (stream)) {/* easy if IMAP4rev1 server */ /* HEADER fetching with special handling? */ if (!strcmp (section,"HEADER") && (lines || (flags & FT_PREFETCHTEXT))) { if (lines) { /* want specific header lines? */ aatt.type = (flags & FT_PEEK) ? BODYPEEK : BODYTEXT; aatt.text = (void *) ((flags & FT_NOT) ? "HEADER.FIELDS.NOT" : "HEADER.FIELDS"); args[2] = &alns; args[3] = &acls; } /* must be prefetching */ else aatt.text = (void *) ((flags & FT_PEEK) ? "(BODY.PEEK[HEADER] BODY.PEEK[TEXT])" : "(BODY[HEADER] BODY[TEXT])"); } else { /* simple case */ aatt.type = (flags & FT_PEEK) ? BODYPEEK : BODYTEXT; aatt.text = (void *) section; args[2] = &acls; } if (first || last) sprintf (partial,"<%lu.%lu>",first,last ? last:-1); } /* IMAP4 did not have: * . HEADER body part (can simulate with BODY[0] or BODY.PEEK[0]) * . TEXT body part (can simulate top-level with RFC822.TEXT or * RFC822.TEXT.PEEK) * . MIME body part * . (usable) partial fetching * . (usable) selective header line fetching */ else if (LEVEL1730 (stream)) {/* IMAP4 (RFC 1730) compatibility */ /* BODY[HEADER] becomes BODY.PEEK[0] */ if (!strcmp (section,"HEADER")) aatt.text = (void *) ((flags & FT_PREFETCHTEXT) ? ((flags & FT_PEEK) ? "(BODY.PEEK[0] RFC822.TEXT.PEEK)" : "(BODY[0] RFC822.TEXT)") : ((flags & FT_PEEK) ? "BODY.PEEK[0]" : "BODY[0]")); /* BODY[TEXT] becomes RFC822.TEXT */ else if (!strcmp (section,"TEXT")) aatt.text = (void *) ((flags & FT_PEEK) ? "RFC822.TEXT.PEEK" : "RFC822.TEXT"); else if (!section[0]) /* BODY[] becomes RFC822 */ aatt.text = (void *) ((flags & FT_PEEK) ? "RFC822.PEEK" : "RFC822"); /* nested header */ else if (t = strstr (section,".HEADER")) { aatt.type = (flags & FT_PEEK) ? BODYPEEK : BODYTEXT; args[2] = &acls; /* will need to close section */ aatt.text = (void *) tmp; /* convert .HEADER to .0 */ strncpy (tmp,section,t-section); strcpy (tmp+(t-section),".0"); } else { /* IMAP4 body part */ aatt.type = (flags & FT_PEEK) ? BODYPEEK : BODYTEXT; args[2] = &acls; /* will need to close section */ aatt.text = (void *) section; } if (strstr (section,".MIME") || strstr (section,".TEXT")) noextend = "4"; if (first || last) nopartial = "4"; if (lines) nolines = "4"; } /* IMAP2bis did not have: * . HEADER body part (can simulate peeking top-level with RFC822.HEADER) * . TEXT body part (can simulate non-peeking top-level with RFC822.TEXT) * . MIME body part * . partial fetching * . selective header line fetching * . non-peeking header fetching * . peeking body fetching */ /* IMAP2bis compatibility */ else if (LEVELIMAP2bis (stream)) { /* BODY[HEADER] becomes RFC822.HEADER */ if (!strcmp (section,"HEADER")) { aatt.text = (void *) ((flags & FT_PREFETCHTEXT) ? "(RFC822.HEADER RFC822.TEXT)" : "RFC822.HEADER"); if (flags & FT_PEEK) flags &= ~FT_PEEK; else nononpeek = "2bis"; } /* BODY[TEXT] becomes RFC822.TEXT */ else if (!strcmp (section,"TEXT")) aatt.text = (void *) "RFC822.TEXT"; /* BODY[] becomes RFC822 */ else if (!section[0]) aatt.text = (void *) "RFC822"; else { /* IMAP2bis body part */ aatt.type = BODYTEXT; args[2] = &acls; /* will need to close section */ aatt.text = (void *) section; } if (strstr (section,".HEADER") || strstr (section,".MIME") || strstr (section,".TEXT")) noextend = "2bis"; if (first || last) nopartial = "2bis"; if (lines) nolines = "2bis"; if (flags & FT_PEEK) nopeek = "2bis"; } /* IMAP2 did not have: * . HEADER body part (can simulate peeking top-level with RFC822.HEADER) * . TEXT body part (can simulate non-peeking top-level with RFC822.TEXT) * . MIME body part * . multiple body parts (can simulate BODY[1] with RFC822.TEXT) * . partial fetching * . selective header line fetching * . non-peeking header fetching * . peeking body fetching */ else { /* IMAP2 (RFC 1176/1064) compatibility */ /* BODY[HEADER] */ if (!strcmp (section,"HEADER")) { aatt.text = (void *) ((flags & FT_PREFETCHTEXT) ? "(RFC822.HEADER RFC822.TEXT)" : "RFC822.HEADER"); if (flags & FT_PEEK) flags &= ~FT_PEEK; nononpeek = "2"; } /* BODY[TEXT] becomes RFC822.TEXT */ else if (!strcmp (section,"TEXT")) aatt.text = (void *) "RFC822.TEXT"; /* BODY[1] treated like RFC822.TEXT */ else if (!strcmp (section,"1")) { SIZEDTEXT text; MESSAGECACHE *elt = mail_elt (stream,msgno); /* have a cached RFC822.TEXT? */ if (elt->private.msg.text.text.data) { text.size = elt->private.msg.text.text.size; /* should move instead of copy */ text.data = memcpy (fs_get (text.size+1), elt->private.msg.text.text.data,text.size); (t = (char *) text.data)[text.size] = '\0'; imap_cache (stream,msgno,"1",NIL,&text); return LONGT; /* don't have to do any fetches */ } /* otherwise do RFC822.TEXT */ aatt.text = (void *) "RFC822.TEXT"; } /* BODY[] becomes RFC822 */ else if (!section[0]) aatt.text = (void *) "RFC822"; else noextend = "2"; /* how did we get here? */ if (flags & FT_PEEK) nopeek = "2"; if (first || last) nopartial = "2"; if (lines) nolines = "2"; } /* Report unavailable functionalities. The application can use the helpful * LEVELIMAPREV1, LEVELIMAP4, and LEVELIMAP2bis operations provided in * imap4r1.h to avoid triggering these errors. There aren't any workarounds * for these restrictions. */ if (noextend) { sprintf (tmp,"[NOTIMAP4REV1] IMAP%s server can't do extended body fetch", noextend); mm_log (tmp,ERROR); return NIL; /* can't do anything close either */ } if (nopartial) { sprintf (tmp,"[NOTIMAP4REV1] IMAP%s server can't do partial fetch", nopartial); mm_notify (stream,tmp,WARN); } if (nolines) { sprintf(tmp,"[NOTIMAP4REV1] IMAP%s server can't do selective header fetch", nolines); mm_notify (stream,tmp,WARN); } /* trying to do unsupported peek behavior? */ if ((t = nopeek) || (t = nononpeek)) { /* get most recent \Seen setting */ if (!imap_OK (stream,reply = imap_send (stream,cmd,auxargs))) mm_log (reply->text,WARN); /* note current setting of \Seen flag */ if (!(i = mail_elt (stream,msgno)->seen)) { sprintf (tmp,nopeek ? /* only babble if \Seen not set */ "[NOTIMAP4] Simulating peeking fetch in IMAP%s" : "[NOTIMAP4] Simulating non-peeking header fetch in IMAP%s",t); mm_notify (stream,tmp,NIL); } /* send the fetch command */ if (!imap_OK (stream,reply = imap_send (stream,cmd,args))) { mm_log (reply->text,ERROR); return NIL; /* failure */ } /* send command if need to reset \Seen */ if (((nopeek && !i && mail_elt (stream,msgno)->seen && (aflg.text = "-FLAGS \\Seen")) || ((nononpeek && !mail_elt (stream,msgno)->seen) && (aflg.text = "+FLAGS \\Seen"))) && !imap_OK (stream,reply = imap_send (stream,"STORE",auxargs))) mm_log (reply->text,WARN); } /* simple case if traditional behavior */ else if (!imap_OK (stream,reply = imap_send (stream,cmd,args))) { mm_log (reply->text,ERROR); return NIL; /* failure */ } /* simulate BODY[1] return for RFC 1064/1176 */ if (!LEVELIMAP2bis (stream) && !strcmp (section,"1")) { SIZEDTEXT text; MESSAGECACHE *elt = mail_elt (stream,msgno); text.size = elt->private.msg.text.text.size; /* should move instead of copy */ text.data = memcpy (fs_get (text.size+1),elt->private.msg.text.text.data, text.size); (t = (char *) text.data)[text.size] = '\0'; imap_cache (stream,msgno,"1",NIL,&text); } return LONGT; } /* IMAP fetch UID * Accepts: MAIL stream * message number * Returns: UID */ unsigned long imap_uid (MAILSTREAM *stream,unsigned long msgno) { MESSAGECACHE *elt; IMAPPARSEDREPLY *reply; IMAPARG *args[3],aseq,aatt; char *s,seq[MAILTMPLEN]; unsigned long i,j,k; /* IMAP2 didn't have UIDs */ if (!LEVELIMAP4 (stream)) return msgno; /* do we know its UID yet? */ if (!(elt = mail_elt (stream,msgno))->private.uid) { aseq.type = SEQUENCE; aseq.text = (void *) seq; aatt.type = ATOM; aatt.text = (void *) "UID"; args[0] = &aseq; args[1] = &aatt; args[2] = NIL; sprintf (seq,"%lu",msgno); if (k = imap_uidlookahead) {/* build UID list */ for (i = msgno + 1, s = seq; k && (i <= stream->nmsgs); i++) if (!mail_elt (stream,i)->private.uid) { s += strlen (s); /* find string end, see if nearing end */ if ((s - seq) > (MAILTMPLEN - 20)) break; sprintf (s,",%lu",i); /* append message */ for (j = i + 1, k--; /* hunt for last message without a UID */ k && (j <= stream->nmsgs) && !mail_elt (stream,j)->private.uid; j++, k--); /* if different, make a range */ if (i != --j) sprintf (s + strlen (s),":%lu",i = j); } } /* send "FETCH msgno UID" */ if (!imap_OK (stream,reply = imap_send (stream,"FETCH",args))) mm_log (reply->text,ERROR); } return elt->private.uid; /* return our UID now */ } /* IMAP fetch message number from UID * Accepts: MAIL stream * UID * Returns: message number */ unsigned long imap_msgno (MAILSTREAM *stream,unsigned long uid) { IMAPPARSEDREPLY *reply; IMAPARG *args[3],aseq,aatt; char seq[MAILTMPLEN]; int holes = 0; unsigned long i,msgno; /* IMAP2 didn't have UIDs */ if (!LEVELIMAP4 (stream)) return uid; /* This really should be a binary search, but since there are likely to be * holes in the msgno->UID map it's hard to do. */ for (msgno = 1; msgno <= stream->nmsgs; msgno++) { if (!(i = mail_elt (stream,msgno)->private.uid)) holes = T; else if (i == uid) return msgno; } if (holes) { /* have holes in cache? */ /* yes, have server hunt for UID */ LOCAL->lastuid.uid = LOCAL->lastuid.msgno = 0; aseq.type = SEQUENCE; aseq.text = (void *) seq; aatt.type = ATOM; aatt.text = (void *) "UID"; args[0] = &aseq; args[1] = &aatt; args[2] = NIL; sprintf (seq,"%lu",uid); /* send "UID FETCH uid UID" */ if (!imap_OK (stream,reply = imap_send (stream,"UID FETCH",args))) mm_log (reply->text,ERROR); if (LOCAL->lastuid.uid) { /* got any results from FETCH? */ if ((LOCAL->lastuid.uid == uid) && /* what, me paranoid? */ (LOCAL->lastuid.msgno <= stream->nmsgs) && (mail_elt (stream,LOCAL->lastuid.msgno)->private.uid == uid)) /* got it the easy way */ return LOCAL->lastuid.msgno; /* sigh, do another linear search... */ 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 */ } /* IMAP modify flags * Accepts: MAIL stream * sequence * flag(s) * option flags */ void imap_flag (MAILSTREAM *stream,char *sequence,char *flag,long flags) { char *cmd = (LEVELIMAP4 (stream) && (flags & ST_UID)) ? "UID STORE":"STORE"; IMAPPARSEDREPLY *reply; IMAPARG *args[4],aseq,ascm,aflg; if (LOCAL->loser) sequence = imap_reform_sequence (stream,sequence, flags & ST_UID); aseq.type = SEQUENCE; aseq.text = (void *) sequence; ascm.type = ATOM; ascm.text = (void *) ((flags & ST_SET) ? ((LEVELIMAP4 (stream) && (flags & ST_SILENT)) ? "+Flags.silent" : "+Flags") : ((LEVELIMAP4 (stream) && (flags & ST_SILENT)) ? "-Flags.silent" : "-Flags")); aflg.type = FLAGS; aflg.text = (void *) flag; args[0] = &aseq; args[1] = &ascm; args[2] = &aflg; args[3] = NIL; /* send "STORE sequence +Flags flag" */ if (!imap_OK (stream,reply = imap_send (stream,cmd,args))) mm_log (reply->text,ERROR); } /* IMAP search for messages * Accepts: MAIL stream * character set * search program * option flags * Returns: T on success, NIL on failure */ long imap_search (MAILSTREAM *stream,char *charset,SEARCHPGM *pgm,long flags) { unsigned long i,j,k; char *s; IMAPPARSEDREPLY *reply; MESSAGECACHE *elt; if ((flags & SE_NOSERVER) || /* if want to do local search */ LOCAL->loser || /* or loser */ (!LEVELIMAP4 (stream) && /* or old server but new functions... */ (charset || (flags & SE_UID) || pgm->msgno || pgm->uid || pgm->or || pgm->not || pgm->header || pgm->larger || pgm->smaller || pgm->sentbefore || pgm->senton || pgm->sentsince || pgm->draft || pgm->undraft || pgm->return_path || pgm->sender || pgm->reply_to || pgm->message_id || pgm->in_reply_to || pgm->newsgroups || pgm->followup_to || pgm->references)) || (!LEVELWITHIN (stream) && (pgm->older || pgm->younger))) { if ((flags & SE_NOLOCAL) || !mail_search_default (stream,charset,pgm,flags | SE_NOSERVER)) return NIL; } /* do silly ALL or seq-only search locally */ else if (!(flags & (SE_NOLOCAL|SE_SILLYOK)) && !(pgm->uid || pgm->or || pgm->not || pgm->header || pgm->from || pgm->to || pgm->cc || pgm->bcc || pgm->subject || pgm->body || pgm->text || pgm->larger || pgm->smaller || pgm->sentbefore || pgm->senton || pgm->sentsince || pgm->before || pgm->on || pgm->since || 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 || pgm->return_path || pgm->sender || pgm->reply_to || pgm->in_reply_to || pgm->message_id || pgm->newsgroups || pgm->followup_to || pgm->references)) { if (!mail_search_default (stream,NIL,pgm,flags | SE_NOSERVER)) fatal ("impossible mail_search_default() failure"); } else { /* do server-based SEARCH */ char *cmd = (flags & SE_UID) ? "UID SEARCH" : "SEARCH"; IMAPARG *args[4],apgm,aatt,achs; SEARCHSET *ss,*set; args[1] = args[2] = args[3] = NIL; apgm.type = SEARCHPROGRAM; apgm.text = (void *) pgm; if (charset) { /* optional charset argument requested */ args[0] = &aatt; args[1] = &achs; args[2] = &apgm; aatt.type = ATOM; aatt.text = (void *) "CHARSET"; achs.type = ASTRING; achs.text = (void *) charset; } else args[0] = &apgm; /* no charset argument */ /* tell receiver that these will be UIDs */ LOCAL->uidsearch = (flags & SE_UID) ? T : NIL; reply = imap_send (stream,cmd,args); /* did server barf with that searchpgm? */ if (!(flags & SE_UID) && pgm && (ss = pgm->msgno) && !strcmp (reply->key,"BAD")) { LOCAL->filter = T; /* retry, filtering SEARCH results */ for (i = 1; i <= stream->nmsgs; i++) mail_elt (stream,i)->private.filter = NIL; for (set = ss; set; set = set->next) if (i = set->first) { /* single message becomes one-message range */ if (!(j = set->last)) j = i; else if (j < i) { /* swap reversed range */ i = set->last; j = set->first; } while (i <= j) mail_elt (stream,i++)->private.filter = T; } pgm->msgno = NIL; /* and without the searchset */ reply = imap_send (stream,cmd,args); pgm->msgno = ss; /* restore searchset */ LOCAL->filter = NIL; /* turn off filtering */ } LOCAL->uidsearch = NIL; /* do locally if server won't grok */ if (!strcmp (reply->key,"BAD")) { if ((flags & SE_NOLOCAL) || !mail_search_default (stream,charset,pgm,flags | SE_NOSERVER)) return NIL; } else if (!imap_OK (stream,reply)) { mm_log (reply->text,ERROR); return NIL; } } /* can never pre-fetch with a short cache */ if ((k = imap_prefetch) && !(flags & (SE_NOPREFETCH | SE_UID)) && !stream->scache) { /* only if prefetching permitted */ s = LOCAL->tmp; /* build sequence in temporary buffer */ *s = '\0'; /* initially nothing */ /* search through mailbox */ for (i = 1; k && (i <= stream->nmsgs); ++i) /* for searched messages with no envelope */ if ((elt = mail_elt (stream,i)) && elt->searched && !mail_elt (stream,i)->private.msg.env) { /* prepend with comma if not first time */ if (LOCAL->tmp[0]) *s++ = ','; sprintf (s,"%lu",j = i);/* output message number */ s += strlen (s); /* point at end of string */ k--; /* count one up */ /* search for possible end of range */ while (k && (i < stream->nmsgs) && (elt = mail_elt (stream,i+1))->searched && !elt->private.msg.env) i++,k--; if (i != j) { /* if a range */ sprintf (s,":%lu",i); /* output delimiter and end of range */ s += strlen (s); /* point at end of string */ } if ((s - LOCAL->tmp) > (IMAPTMPLEN - 50)) break; } if (LOCAL->tmp[0]) { /* anything to pre-fetch? */ /* pre-fetch envelopes for the first imap_prefetch number of messages */ if (!imap_OK (stream,reply = imap_fetch (stream,s = cpystr (LOCAL->tmp),FT_NEEDENV + ((flags & SE_NOHDRS) ? FT_NOHDRS : NIL) + ((flags & SE_NEEDBODY) ? FT_NEEDBODY : NIL)))) mm_log (reply->text,ERROR); fs_give ((void **) &s); /* flush copy of sequence */ } } return LONGT; } /* IMAP 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 *imap_sort (MAILSTREAM *stream,char *charset,SEARCHPGM *spg, SORTPGM *pgm,long flags) { unsigned long i,j,start,last; unsigned long *ret = NIL; pgm->nmsgs = 0; /* start off with no messages */ /* can use server-based sort? */ if (LEVELSORT (stream) && !(flags & SE_NOSERVER) && (!spg || (LEVELWITHIN (stream) || !(spg->older || spg->younger)))) { char *cmd = (flags & SE_UID) ? "UID SORT" : "SORT"; IMAPARG *args[4],apgm,achs,aspg; IMAPPARSEDREPLY *reply; SEARCHSET *ss = NIL; SEARCHPGM *tsp = NIL; apgm.type = SORTPROGRAM; apgm.text = (void *) pgm; achs.type = ASTRING; achs.text = (void *) (charset ? charset : "US-ASCII"); aspg.type = SEARCHPROGRAM; /* did he provide a searchpgm? */ if (!(aspg.text = (void *) spg)) { for (i = 1,start = last = 0; i <= stream->nmsgs; ++i) if (mail_elt (stream,i)->searched) { if (ss) { /* continuing a sequence */ if (i == last + 1) last = i; else { /* end of range */ if (last != start) ss->last = last; (ss = ss->next = mail_newsearchset ())->first = i; start = last = i; /* begin a new range */ } } else { /* first time, start new searchpgm */ (tsp = mail_newsearchpgm ())->msgno = ss = mail_newsearchset (); ss->first = start = last = i; } } /* nothing to sort if no messages */ if (!(aspg.text = (void *) tsp)) return NIL; /* else install last sequence */ if (last != start) ss->last = last; } args[0] = &apgm; args[1] = &achs; args[2] = &aspg; args[3] = NIL; /* ask server to do it */ reply = imap_send (stream,cmd,args); if (tsp) { /* was there a temporary searchpgm? */ aspg.text = NIL; /* yes, flush it */ mail_free_searchpgm (&tsp); /* did server barf with that searchpgm? */ if (!(flags & SE_UID) && !strcmp (reply->key,"BAD")) { LOCAL->filter = T; /* retry, filtering SORT/THREAD results */ reply = imap_send (stream,cmd,args); LOCAL->filter = NIL; /* turn off filtering */ } } /* do locally if server barfs */ if (!strcmp (reply->key,"BAD")) return (flags & SE_NOLOCAL) ? NIL : imap_sort (stream,charset,spg,pgm,flags | SE_NOSERVER); /* server sorted OK? */ else if (imap_OK (stream,reply)) { pgm->nmsgs = LOCAL->sortsize; ret = LOCAL->sortdata; LOCAL->sortdata = NIL; /* mail program is responsible for flushing */ } else mm_log (reply->text,ERROR); } /* not much can do if short caching */ else if (stream->scache) ret = mail_sort_msgs (stream,charset,spg,pgm,flags); else { /* try to be a bit more clever */ char *s,*t; unsigned long len; MESSAGECACHE *elt; SORTCACHE **sc; SORTPGM *sp; long ftflags = 0; /* see if need envelopes */ for (sp = pgm; sp && !ftflags; sp = sp->next) switch (sp->function) { case SORTDATE: case SORTFROM: case SORTSUBJECT: case SORTTO: case SORTCC: ftflags = FT_NEEDENV + ((flags & SE_NOHDRS) ? FT_NOHDRS : 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,flags & SE_NOSERVER); stream->silent = silent; /* restore silence state */ } /* initialize progress counters */ pgm->nmsgs = pgm->progress.cached = 0; /* pass 1: count messages to sort */ for (i = 1,len = start = last = 0,s = t = NIL; i <= stream->nmsgs; ++i) if ((elt = mail_elt (stream,i))->searched) { pgm->nmsgs++; if (ftflags ? !elt->private.msg.env : !elt->day) { if (s) { /* continuing a sequence */ if (i == last + 1) last = i; else { /* end of range */ if (last != start) sprintf (t,":%lu,%lu",last,i); else sprintf (t,",%lu",i); start = last = i; /* begin a new range */ if ((len - (j = ((t += strlen (t)) - s)) < 20)) { fs_resize ((void **) &s,len += MAILTMPLEN); t = s + j; /* relocate current pointer */ } } } else { /* first time, start new buffer */ s = (char *) fs_get (len = MAILTMPLEN); sprintf (s,"%lu",start = last = i); t = s + strlen (s); /* end of buffer */ } } } /* last sequence */ if (last != start) sprintf (t,":%lu",last); if (s) { /* load cache for all messages being sorted */ imap_fetch (stream,s,ftflags); fs_give ((void **) &s); } if (pgm->nmsgs) { /* pass 2: sort cache */ sortresults_t sr = (sortresults_t) mail_parameters (NIL,GET_SORTRESULTS,NIL); 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 */ /* also return via callback if requested */ if (sr) (*sr) (stream,ret,pgm->nmsgs); } } return ret; } /* IMAP thread messages * Accepts: mail stream * thread type * character set * search program * option flags * Returns: thread node tree or NIL if error */ THREADNODE *imap_thread (MAILSTREAM *stream,char *type,char *charset, SEARCHPGM *spg,long flags) { THREADER *thr; if (!(flags & SE_NOSERVER) && (!spg || (LEVELWITHIN (stream) || !(spg->older || spg->younger)))) /* does server have this threader type? */ for (thr = LOCAL->cap.threader; thr; thr = thr->next) if (!compare_cstring (thr->name,type)) return imap_thread_work (stream,type,charset,spg,flags); /* server doesn't support it, do locally */ return (flags & SE_NOLOCAL) ? NIL: mail_thread_msgs (stream,type,charset,spg,flags | SE_NOSERVER,imap_sort); } /* IMAP thread messages worker routine * Accepts: mail stream * thread type * character set * search program * option flags * Returns: thread node tree */ THREADNODE *imap_thread_work (MAILSTREAM *stream,char *type,char *charset, SEARCHPGM *spg,long flags) { unsigned long i,start,last; char *cmd = (flags & SE_UID) ? "UID THREAD" : "THREAD"; IMAPARG *args[4],apgm,achs,aspg; IMAPPARSEDREPLY *reply; THREADNODE *ret = NIL; SEARCHSET *ss = NIL; SEARCHPGM *tsp = NIL; apgm.type = ATOM; apgm.text = (void *) type; achs.type = ASTRING; achs.text = (void *) (charset ? charset : "US-ASCII"); aspg.type = SEARCHPROGRAM; /* did he provide a searchpgm? */ if (!(aspg.text = (void *) spg)) { for (i = 1,start = last = 0; i <= stream->nmsgs; ++i) if (mail_elt (stream,i)->searched) { if (ss) { /* continuing a sequence */ if (i == last + 1) last = i; else { /* end of range */ if (last != start) ss->last = last; (ss = ss->next = mail_newsearchset ())->first = i; start = last =i; /* begin a new range */ } } else { /* first time, start new searchpgm */ (tsp = mail_newsearchpgm ())->msgno = ss = mail_newsearchset (); ss->first = start = last = i; } } /* nothing to sort if no messages */ if (!(aspg.text = (void *) tsp)) return NIL; /* else install last sequence */ if (last != start) ss->last = last; } args[0] = &apgm; args[1] = &achs; args[2] = &aspg; args[3] = NIL; /* ask server to do it */ reply = imap_send (stream,cmd,args); if (tsp) { /* was there a temporary searchpgm? */ aspg.text = NIL; /* yes, flush it */ mail_free_searchpgm (&tsp); /* did server barf with that searchpgm? */ if (!(flags & SE_UID) && !strcmp (reply->key,"BAD")) { LOCAL->filter = T; /* retry, filtering SORT/THREAD results */ reply = imap_send (stream,cmd,args); LOCAL->filter = NIL; /* turn off filtering */ } } /* do locally if server barfs */ if (!strcmp (reply->key,"BAD")) ret = (flags & SE_NOLOCAL) ? NIL: mail_thread_msgs (stream,type,charset,spg,flags | SE_NOSERVER,imap_sort); /* server threaded OK? */ else if (imap_OK (stream,reply)) { ret = LOCAL->threaddata; LOCAL->threaddata = NIL; /* mail program is responsible for flushing */ } else mm_log (reply->text,ERROR); return ret; } /* IMAP ping mailbox * Accepts: MAIL stream * Returns: T if stream still alive, else NIL */ long imap_ping (MAILSTREAM *stream) { return (LOCAL->netstream && /* send "NOOP" */ imap_OK (stream,imap_send (stream,"NOOP",NIL))) ? T : NIL; } /* IMAP check mailbox * Accepts: MAIL stream */ void imap_check (MAILSTREAM *stream) { /* send "CHECK" */ IMAPPARSEDREPLY *reply = imap_send (stream,"CHECK",NIL); mm_log (reply->text,imap_OK (stream,reply) ? (long) NIL : ERROR); } /* IMAP expunge mailbox * Accepts: MAIL stream * sequence to expunge if non-NIL * expunge options * Returns: T if success, NIL if failure */ long imap_expunge (MAILSTREAM *stream,char *sequence,long options) { long ret = NIL; IMAPPARSEDREPLY *reply = NIL; if (sequence) { /* wants selective expunging? */ if (options & EX_UID) { /* UID EXPUNGE form? */ if (LEVELUIDPLUS (stream)) {/* server support UIDPLUS? */ IMAPARG *args[2],aseq; aseq.type = SEQUENCE; aseq.text = (void *) sequence; args[0] = &aseq; args[1] = NIL; ret = imap_OK (stream,reply = imap_send (stream,"UID EXPUNGE",args)); } else mm_log ("[NOTUIDPLUS] Can't do UID EXPUNGE with this server",ERROR); } /* otherwise try to make into UID EXPUNGE */ else if (mail_sequence (stream,sequence)) { unsigned long i,j; char *t = (char *) fs_get (IMAPTMPLEN); char *s = t; /* search through mailbox */ for (*s = '\0', i = 1; i <= stream->nmsgs; ++i) if (mail_elt (stream,i)->sequence) { if (t[0]) *s++ = ','; /* prepend with comma if not first time */ sprintf (s,"%lu",mail_uid (stream,j = i)); s += strlen (s); /* point at end of string */ /* search for possible end of range */ while ((i < stream->nmsgs) && mail_elt (stream,i+1)->sequence) i++; if (i != j) { /* output end of range */ sprintf (s,":%lu",mail_uid (stream,i)); s += strlen (s); /* point at end of string */ } if ((s - t) > (IMAPTMPLEN - 50)) { mm_log ("Excessively complex sequence",ERROR); return NIL; } } /* now do as UID EXPUNGE */ ret = imap_expunge (stream,t,EX_UID); fs_give ((void **) &t); } } /* ordinary EXPUNGE */ else ret = imap_OK (stream,reply = imap_send (stream,"EXPUNGE",NIL)); if (reply) mm_log (reply->text,ret ? (long) NIL : ERROR); return ret; } /* IMAP copy message(s) * Accepts: MAIL stream * sequence * destination mailbox * option flags * Returns: T if successful else NIL */ long imap_copy (MAILSTREAM *stream,char *sequence,char *mailbox,long flags) { char *cmd = (LEVELIMAP4 (stream) && (flags & CP_UID)) ? "UID COPY" : "COPY"; char *s; long ret = NIL; IMAPPARSEDREPLY *reply; IMAPARG *args[3],aseq,ambx; imapreferral_t ir = (imapreferral_t) mail_parameters (stream,GET_IMAPREFERRAL,NIL); mailproxycopy_t pc = (mailproxycopy_t) mail_parameters (stream,GET_MAILPROXYCOPY,NIL); if (LOCAL->loser) sequence = imap_reform_sequence (stream,sequence, flags & CP_UID); aseq.type = SEQUENCE; aseq.text = (void *) sequence; ambx.type = ASTRING; ambx.text = (void *) mailbox; args[0] = &aseq; args[1] = &ambx; args[2] = NIL; /* note mailbox in case APPENDUID */ LOCAL->appendmailbox = mailbox; /* send "COPY sequence mailbox" */ ret = imap_OK (stream,reply = imap_send (stream,cmd,args)); LOCAL->appendmailbox = NIL; /* no longer appending */ if (ret) { /* success, delete messages if move */ if (flags & CP_MOVE) imap_flag (stream,sequence,"\\Deleted", ST_SET + ((flags&CP_UID) ? ST_UID : NIL)); } /* failed, do referral action if any */ else if (ir && pc && LOCAL->referral && mail_sequence (stream,sequence) && (s = (*ir) (stream,LOCAL->referral,REFCOPY))) ret = (*pc) (stream,sequence,s,flags | (stream->debug ? CP_DEBUG : NIL)); /* otherwise issue error message */ else mm_log (reply->text,ERROR); return ret; } /* IMAP mail append message from stringstruct * Accepts: MAIL stream * destination mailbox * append callback * data for callback * Returns: T if append successful, else NIL */ long imap_append (MAILSTREAM *stream,char *mailbox,append_t af,void *data) { MAILSTREAM *st = stream; IMAPARG *args[3],ambx,amap; IMAPPARSEDREPLY *reply = NIL; APPENDDATA map; char tmp[MAILTMPLEN]; long debug = stream ? stream->debug : NIL; long ret = NIL; imapreferral_t ir = (imapreferral_t) mail_parameters (stream,GET_IMAPREFERRAL,NIL); /* mailbox must be good */ if (mail_valid_net (mailbox,&imapdriver,NIL,tmp)) { /* create a stream if given one no good */ if ((stream && LOCAL && LOCAL->netstream) || (stream = mail_open (NIL,mailbox,OP_HALFOPEN|OP_SILENT | (debug ? OP_DEBUG : NIL)))) { /* note mailbox in case APPENDUID */ LOCAL->appendmailbox = mailbox; /* use multi-append? */ if (LEVELMULTIAPPEND (stream)) { ambx.type = ASTRING; ambx.text = (void *) tmp; amap.type = MULTIAPPEND; amap.text = (void *) ↦ map.af = af; map.data = data; args[0] = &ambx; args[1] = &amap; args[2] = NIL; /* success if OK */ ret = imap_OK (stream,reply = imap_send (stream,"APPEND",args)); LOCAL->appendmailbox = NIL; } /* do succession of single appends */ else while ((*af) (stream,data,&map.flags,&map.date,&map.message) && map.message && (ret = imap_OK (stream,reply = imap_append_single (stream,tmp,map.flags, map.date,map.message)))); LOCAL->appendmailbox = NIL; /* don't do referrals if success or no reply */ if (ret || !reply) mailbox = NIL; /* otherwise generate referral */ else if (!(mailbox = (ir && LOCAL->referral) ? (*ir) (stream,LOCAL->referral,REFAPPEND) : NIL)) mm_log (reply->text,ERROR); /* close temporary stream */ if (st != stream) stream = mail_close (stream); if (mailbox) /* chase referral if any */ ret = imap_append_referral (mailbox,tmp,af,data,map.flags,map.date, map.message,&map,debug); } else mm_log ("Can't access server for append",ERROR); } return ret; /* return */ } /* IMAP mail append message referral retry * Accepts: destination mailbox * temporary buffer * append callback * data for callback * flags from previous attempt * date from previous attempt * message stringstruct from previous attempt * options (currently non-zero to set OP_DEBUG) * Returns: T if append successful, else NIL */ long imap_append_referral (char *mailbox,char *tmp,append_t af,void *data, char *flags,char *date,STRING *message, APPENDDATA *map,long options) { MAILSTREAM *stream; IMAPARG *args[3],ambx,amap; IMAPPARSEDREPLY *reply; imapreferral_t ir = (imapreferral_t) mail_parameters (NIL,GET_IMAPREFERRAL,NIL); /* barf if bad mailbox */ while (mailbox && mail_valid_net (mailbox,&imapdriver,NIL,tmp)) { /* create a stream if given one no good */ if (!(stream = mail_open (NIL,mailbox,OP_HALFOPEN|OP_SILENT | (options ? OP_DEBUG : NIL)))) { sprintf (tmp,"Can't access referral server: %.80s",mailbox); mm_log (tmp,ERROR); return NIL; } /* got referral server, use multi-append? */ if (LEVELMULTIAPPEND (stream)) { ambx.type = ASTRING; ambx.text = (void *) tmp; amap.type = MULTIAPPENDREDO; amap.text = (void *) map; args[0] = &ambx; args[1] = &amap; args[2] = NIL; /* do multiappend on referral site */ if (imap_OK (stream,reply = imap_send (stream,"APPEND",args))) { mail_close (stream); /* multiappend OK, close stream */ return LONGT; /* all done */ } } /* do multiple single appends */ else while (imap_OK (stream,reply = imap_append_single (stream,tmp,flags,date,message))) if (!((*af) (stream,data,&flags,&date,&message) && message)) { mail_close (stream); /* last message, close stream */ return LONGT; /* all done */ } /* generate error if no nested referral */ if (!(mailbox = (ir && LOCAL->referral) ? (*ir) (stream,LOCAL->referral,REFAPPEND) : NIL)) mm_log (reply->text,ERROR); mail_close (stream); /* close previous referral stream */ } return NIL; /* bogus mailbox */ } /* IMAP append single message * Accepts: mail stream * destination mailbox * initial flags * internal date * stringstruct of message to append * Returns: reply from append */ IMAPPARSEDREPLY *imap_append_single (MAILSTREAM *stream,char *mailbox, char *flags,char *date,STRING *message) { MESSAGECACHE elt; IMAPARG *args[5],ambx,aflg,adat,amsg; IMAPPARSEDREPLY *reply; char tmp[MAILTMPLEN]; int i; ambx.type = ASTRING; ambx.text = (void *) mailbox; args[i = 0] = &ambx; if (flags) { aflg.type = FLAGS; aflg.text = (void *) flags; args[++i] = &aflg; } if (date) { /* ensure date in INTERNALDATE format */ if (!mail_parse_date (&elt,date)) { /* flush previous reply */ if (LOCAL->reply.line) fs_give ((void **) &LOCAL->reply.line); /* build new fake reply */ LOCAL->reply.tag = LOCAL->reply.line = cpystr ("*"); LOCAL->reply.key = "BAD"; LOCAL->reply.text = "Bad date in append"; return &LOCAL->reply; } adat.type = ASTRING; adat.text = (void *) (date = mail_date (tmp,&elt)); args[++i] = &adat; } amsg.type = LITERAL; amsg.text = (void *) message; args[++i] = &amsg; args[++i] = NIL; /* easy if IMAP4[rev1] */ if (LEVELIMAP4 (stream)) reply = imap_send (stream,"APPEND",args); else { /* try the IMAP2bis way */ args[1] = &amsg; args[2] = NIL; reply = imap_send (stream,"APPEND",args); } return reply; } /* IMAP garbage collect stream * Accepts: Mail stream * garbage collection flags */ void imap_gc (MAILSTREAM *stream,long gcflags) { unsigned long i; MESSAGECACHE *elt; mailcache_t mc = (mailcache_t) mail_parameters (NIL,GET_CACHE,NIL); /* make sure the cache is large enough */ (*mc) (stream,stream->nmsgs,CH_SIZE); if (gcflags & GC_TEXTS) { /* garbage collect texts? */ if (!stream->scache) for (i = 1; i <= stream->nmsgs; ++i) if (elt = (MESSAGECACHE *) (*mc) (stream,i,CH_ELT)) imap_gc_body (elt->private.msg.body); imap_gc_body (stream->body); } /* gc cache if requested and unlocked */ if (gcflags & GC_ELT) for (i = 1; i <= stream->nmsgs; ++i) if ((elt = (MESSAGECACHE *) (*mc) (stream,i,CH_ELT)) && (elt->lockcount == 1)) (*mc) (stream,i,CH_FREE); } /* IMAP garbage collect body texts * Accepts: body to GC */ void imap_gc_body (BODY *body) { PART *part; if (body) { /* have a body? */ if (body->mime.text.data) /* flush MIME data */ fs_give ((void **) &body->mime.text.data); /* flush text contents */ if (body->contents.text.data) fs_give ((void **) &body->contents.text.data); body->mime.text.size = body->contents.text.size = 0; /* multipart? */ if (body->type == TYPEMULTIPART) for (part = body->nested.part; part; part = part->next) imap_gc_body (&part->body); /* MESSAGE/RFC822? */ else if ((body->type == TYPEMESSAGE) && !strcmp (body->subtype,"RFC822")) { imap_gc_body (body->nested.msg->body); if (body->nested.msg->full.text.data) fs_give ((void **) &body->nested.msg->full.text.data); if (body->nested.msg->header.text.data) fs_give ((void **) &body->nested.msg->header.text.data); if (body->nested.msg->text.text.data) fs_give ((void **) &body->nested.msg->text.text.data); body->nested.msg->full.text.size = body->nested.msg->header.text.size = body->nested.msg->text.text.size = 0; } } } /* IMAP get capabilities * Accepts: mail stream */ void imap_capability (MAILSTREAM *stream) { THREADER *thr,*t; LOCAL->gotcapability = NIL; /* flush any previous capabilities */ /* request new capabilities */ imap_send (stream,"CAPABILITY",NIL); if (!LOCAL->gotcapability) { /* did server get any? */ /* no, flush threaders just in case */ if (thr = LOCAL->cap.threader) while (t = thr) { fs_give ((void **) &t->name); thr = t->next; fs_give ((void **) &t); } /* zap most capabilities */ memset (&LOCAL->cap,0,sizeof (LOCAL->cap)); /* assume IMAP2bis server if failure */ LOCAL->cap.imap2bis = LOCAL->cap.rfc1176 = T; } } /* IMAP set ACL * Accepts: mail stream * mailbox name * authentication identifer * new access rights * Returns: T on success, NIL on failure */ long imap_setacl (MAILSTREAM *stream,char *mailbox,char *id,char *rights) { IMAPARG *args[4],ambx,aid,art; ambx.type = aid.type = art.type = ASTRING; ambx.text = (void *) mailbox; aid.text = (void *) id; art.text = (void *) rights; args[0] = &ambx; args[1] = &aid; args[2] = &art; args[3] = NIL; return imap_acl_work (stream,"SETACL",args); } /* IMAP delete ACL * Accepts: mail stream * mailbox name * authentication identifer * Returns: T on success, NIL on failure */ long imap_deleteacl (MAILSTREAM *stream,char *mailbox,char *id) { IMAPARG *args[3],ambx,aid; ambx.type = aid.type = ASTRING; ambx.text = (void *) mailbox; aid.text = (void *) id; args[0] = &ambx; args[1] = &aid; args[2] = NIL; return imap_acl_work (stream,"DELETEACL",args); } /* IMAP get ACL * Accepts: mail stream * mailbox name * Returns: T on success with data returned via callback, NIL on failure */ long imap_getacl (MAILSTREAM *stream,char *mailbox) { IMAPARG *args[2],ambx; ambx.type = ASTRING; ambx.text = (void *) mailbox; args[0] = &ambx; args[1] = NIL; return imap_acl_work (stream,"GETACL",args); } /* IMAP list rights * Accepts: mail stream * mailbox name * authentication identifer * Returns: T on success with data returned via callback, NIL on failure */ long imap_listrights (MAILSTREAM *stream,char *mailbox,char *id) { IMAPARG *args[3],ambx,aid; ambx.type = aid.type = ASTRING; ambx.text = (void *) mailbox; aid.text = (void *) id; args[0] = &ambx; args[1] = &aid; args[2] = NIL; return imap_acl_work (stream,"LISTRIGHTS",args); } /* IMAP my rights * Accepts: mail stream * mailbox name * Returns: T on success with data returned via callback, NIL on failure */ long imap_myrights (MAILSTREAM *stream,char *mailbox) { IMAPARG *args[2],ambx; ambx.type = ASTRING; ambx.text = (void *) mailbox; args[0] = &ambx; args[1] = NIL; return imap_acl_work (stream,"MYRIGHTS",args); } /* IMAP ACL worker routine * Accepts: mail stream * command * command arguments * Returns: T on success, NIL on failure */ long imap_acl_work (MAILSTREAM *stream,char *command,IMAPARG *args[]) { long ret = NIL; if (LEVELACL (stream)) { /* send command */ IMAPPARSEDREPLY *reply; if (imap_OK (stream,reply = imap_send (stream,command,args))) ret = LONGT; else mm_log (reply->text,ERROR); } else mm_log ("ACL not available on this IMAP server",ERROR); return ret; } /* IMAP set quota * Accepts: mail stream * quota root name * resource limit list as a stringlist * Returns: T on success with data returned via callback, NIL on failure */ long imap_setquota (MAILSTREAM *stream,char *qroot,STRINGLIST *limits) { long ret = NIL; if (LEVELQUOTA (stream)) { /* send "SETQUOTA" */ IMAPPARSEDREPLY *reply; IMAPARG *args[3],aqrt,alim; aqrt.type = ASTRING; aqrt.text = (void *) qroot; alim.type = SNLIST; alim.text = (void *) limits; args[0] = &aqrt; args[1] = &alim; args[2] = NIL; if (imap_OK (stream,reply = imap_send (stream,"SETQUOTA",args))) ret = LONGT; else mm_log (reply->text,ERROR); } else mm_log ("Quota not available on this IMAP server",ERROR); return ret; } /* IMAP get quota * Accepts: mail stream * quota root name * Returns: T on success with data returned via callback, NIL on failure */ long imap_getquota (MAILSTREAM *stream,char *qroot) { long ret = NIL; if (LEVELQUOTA (stream)) { /* send "GETQUOTA" */ IMAPPARSEDREPLY *reply; IMAPARG *args[2],aqrt; aqrt.type = ASTRING; aqrt.text = (void *) qroot; args[0] = &aqrt; args[1] = NIL; if (imap_OK (stream,reply = imap_send (stream,"GETQUOTA",args))) ret = LONGT; else mm_log (reply->text,ERROR); } else mm_log ("Quota not available on this IMAP server",ERROR); return ret; } /* IMAP get quota root * Accepts: mail stream * mailbox name * Returns: T on success with data returned via callback, NIL on failure */ long imap_getquotaroot (MAILSTREAM *stream,char *mailbox) { long ret = NIL; if (LEVELQUOTA (stream)) { /* send "GETQUOTAROOT" */ IMAPPARSEDREPLY *reply; IMAPARG *args[2],ambx; ambx.type = ASTRING; ambx.text = (void *) mailbox; args[0] = &ambx; args[1] = NIL; if (imap_OK (stream,reply = imap_send (stream,"GETQUOTAROOT",args))) ret = LONGT; else mm_log (reply->text,ERROR); } else mm_log ("Quota not available on this IMAP server",ERROR); return ret; } /* Internal routines */ /* IMAP send command * Accepts: MAIL stream * command * argument list * Returns: parsed reply */ #define CMDBASE LOCAL->tmp /* command base */ IMAPPARSEDREPLY *imap_send (MAILSTREAM *stream,char *cmd,IMAPARG *args[]) { IMAPPARSEDREPLY *reply; IMAPARG *arg,**arglst; SORTPGM *spg; STRINGLIST *list; SIZEDTEXT st; APPENDDATA *map; sendcommand_t sc = (sendcommand_t) mail_parameters (NIL,GET_SENDCOMMAND,NIL); size_t i; void *a; char c,*s,*t,tag[10]; stream->unhealthy = NIL; /* make stream healthy again */ /* gensym a new tag */ sprintf (tag,"%08lx",0xffffffff & (stream->gensym++)); if (!LOCAL->netstream) /* make sure have a session */ return imap_fake (stream,tag,"[CLOSED] IMAP connection lost"); mail_lock (stream); /* lock up the stream */ if (sc) /* tell client sending a command */ (*sc) (stream,cmd,((compare_cstring (cmd,"FETCH") && compare_cstring (cmd,"STORE") && compare_cstring (cmd,"SEARCH")) ? NIL : SC_EXPUNGEDEFERRED)); /* ignore referral from previous command */ if (LOCAL->referral) fs_give ((void **) &LOCAL->referral); sprintf (CMDBASE,"%s %s",tag,cmd); s = CMDBASE + strlen (CMDBASE); if (arglst = args) while (arg = *arglst++) { *s++ = ' '; /* delimit argument with space */ switch (arg->type) { case ATOM: /* atom */ for (t = (char *) arg->text; *t; *s++ = *t++); break; case NUMBER: /* number */ sprintf (s,"%lu",(unsigned long) arg->text); s += strlen (s); break; case FLAGS: /* flag list as a single string */ if (*(t = (char *) arg->text) != '(') { *s++ = '('; /* wrap parens around string */ while (*t) *s++ = *t++; *s++ = ')'; /* wrap parens around string */ } else while (*t) *s++ = *t++; break; case ASTRING: /* atom or string, must be literal? */ st.size = strlen ((char *) (st.data = (unsigned char *) arg->text)); if (reply = imap_send_astring (stream,tag,&s,&st,NIL,CMDBASE+MAXCOMMAND)) return reply; break; case LITERAL: /* literal, as a stringstruct */ if (reply = imap_send_literal (stream,tag,&s,arg->text)) return reply; break; case LIST: /* list of strings */ list = (STRINGLIST *) arg->text; c = '('; /* open paren */ do { /* for each list item */ *s++ = c; /* write prefix character */ if (reply = imap_send_astring (stream,tag,&s,&list->text,NIL, CMDBASE+MAXCOMMAND)) return reply; c = ' '; /* prefix character for subsequent strings */ } while (list = list->next); *s++ = ')'; /* close list */ break; case SEARCHPROGRAM: /* search program */ if (reply = imap_send_spgm (stream,tag,CMDBASE,&s,arg->text, CMDBASE+MAXCOMMAND)) return reply; break; case SORTPROGRAM: /* search program */ c = '('; /* open paren */ for (spg = (SORTPGM *) arg->text; spg; spg = spg->next) { *s++ = c; /* write prefix */ if (spg->reverse) for (t = "REVERSE "; *t; *s++ = *t++); switch (spg->function) { case SORTDATE: for (t = "DATE"; *t; *s++ = *t++); break; case SORTARRIVAL: for (t = "ARRIVAL"; *t; *s++ = *t++); break; case SORTFROM: for (t = "FROM"; *t; *s++ = *t++); break; case SORTSUBJECT: for (t = "SUBJECT"; *t; *s++ = *t++); break; case SORTTO: for (t = "TO"; *t; *s++ = *t++); break; case SORTCC: for (t = "CC"; *t; *s++ = *t++); break; case SORTSIZE: for (t = "SIZE"; *t; *s++ = *t++); break; default: fatal ("Unknown sort program function in imap_send()!"); } c = ' '; /* prefix character for subsequent items */ } *s++ = ')'; /* close list */ break; case BODYTEXT: /* body section */ for (t = "BODY["; *t; *s++ = *t++); for (t = (char *) arg->text; *t; *s++ = *t++); break; case BODYPEEK: /* body section */ for (t = "BODY.PEEK["; *t; *s++ = *t++); for (t = (char *) arg->text; *t; *s++ = *t++); break; case BODYCLOSE: /* close bracket and possible length */ s[-1] = ']'; /* no leading space */ for (t = (char *) arg->text; *t; *s++ = *t++); break; case SEQUENCE: /* sequence */ if ((i = strlen (t = (char *) arg->text)) <= (size_t) MAXCOMMAND) while (*t) *s++ = *t++; /* easy case */ else { mail_unlock (stream); /* unlock stream */ a = arg->text; /* save original sequence pointer */ arg->type = ATOM; /* make recursive call be faster */ do { /* break up into multiple commands */ if (i <= MAXCOMMAND) {/* final part? */ reply = imap_send (stream,cmd,args); i = 0; /* and mark as done */ } else { /* still needs to be split further */ if (!(t = strchr (t + MAXCOMMAND - 30,',')) || ((t - (char *) arg->text) > MAXCOMMAND)) fatal ("impossible over-long sequence"); *t = '\0'; /* tie off sequence at point of split*/ /* recurse to do this part */ reply = imap_send (stream,cmd,args); *t++ = ','; /* restore the comma in case something cares */ /* punt if error */ if (!imap_OK (stream,reply)) break; /* calculate size of remaining sequence */ i -= (t - (char *) arg->text); /* point to new remaining sequence */ arg->text = (void *) t; } } while (i); arg->type = SEQUENCE; /* restore in case something cares */ arg->text = a; return reply; /* return result */ } break; case LISTMAILBOX: /* astring with wildcards */ st.size = strlen ((char *) (st.data = (unsigned char *) arg->text)); if (reply = imap_send_astring (stream,tag,&s,&st,T,CMDBASE+MAXCOMMAND)) return reply; break; case MULTIAPPEND: /* append multiple messages */ /* get package pointer */ map = (APPENDDATA *) arg->text; if (!(*map->af) (stream,map->data,&map->flags,&map->date,&map->message)|| !map->message) { STRING es; INIT (&es,mail_string,"",0); return (reply = imap_send_literal (stream,tag,&s,&es)) ? reply : imap_fake (stream,tag,"Server zero-length literal error"); } case MULTIAPPENDREDO: /* redo multiappend */ /* get package pointer */ map = (APPENDDATA *) arg->text; do { /* make sure date valid if given */ char datetmp[MAILTMPLEN]; MESSAGECACHE elt; STRING es; if (!map->date || mail_parse_date (&elt,map->date)) { if (t = map->flags) { /* flags given? */ if (*t != '(') { *s++ = '('; /* wrap parens around string */ while (*t) *s++ = *t++; *s++ = ')'; /* wrap parens around string */ } else while (*t) *s++ = *t++; *s++ = ' '; /* delimit with space */ } if (map->date) { /* date given? */ st.size = strlen ((char *) (st.data = (unsigned char *) mail_date (datetmp,&elt))); if (reply = imap_send_astring (stream,tag,&s,&st,NIL, CMDBASE+MAXCOMMAND)) return reply; *s++ = ' '; /* delimit with space */ } if (reply = imap_send_literal (stream,tag,&s,map->message)) return reply; /* get next message */ if ((*map->af) (stream,map->data,&map->flags,&map->date, &map->message)) { /* have a message, delete next in command */ if (map->message) *s++ = ' '; continue; /* loop back for next message */ } } /* bad date or need to abort */ INIT (&es,mail_string,"",0); return (reply = imap_send_literal (stream,tag,&s,&es)) ? reply : imap_fake (stream,tag,"Server zero-length literal error"); break; /* exit the loop */ } while (map->message); break; case SNLIST: /* list of string/number pairs */ list = (STRINGLIST *) arg->text; c = '('; /* open paren */ do { /* for each list item */ *s++ = c; /* write prefix character */ if (list) { /* sigh, QUOTA has bizarre syntax! */ for (t = (char *) list->text.data; *t; *s++ = *t++); sprintf (s," %lu",list->text.size); s += strlen (s); c = ' '; /* prefix character for subsequent strings */ } } while (list = list->next); *s++ = ')'; /* close list */ break; default: fatal ("Unknown argument type in imap_send()!"); } } /* send the command */ reply = imap_sout (stream,tag,CMDBASE,&s); mail_unlock (stream); /* unlock stream */ return reply; } /* IMAP send atom-string * Accepts: MAIL stream * reply tag * pointer to current position pointer of output bigbuf * atom-string to output * flag if list_wildcards allowed * maximum to write as atom or qstring * Returns: error reply or NIL if success */ IMAPPARSEDREPLY *imap_send_astring (MAILSTREAM *stream,char *tag,char **s, SIZEDTEXT *as,long wildok,char *limit) { unsigned long j; char c; STRING st; /* default to atom unless empty or loser */ int qflag = (as->size && !LOCAL->loser) ? NIL : T; /* in case needed */ INIT (&st,mail_string,(void *) as->data,as->size); /* always write literal if no space */ if ((*s + as->size) > limit) return imap_send_literal (stream,tag,s,&st); for (j = 0; j < as->size; j++) switch (c = as->data[j]) { default: /* all other characters */ if (!(c & 0x80)) { /* must not be 8bit */ if (c <= ' ') qflag = T; /* must quote if a CTL */ break; } case '\0': /* not a CHAR */ case '\012': case '\015': /* not a TEXT-CHAR */ case '"': case '\\': /* quoted-specials (IMAP2 required this) */ return imap_send_literal (stream,tag,s,&st); case '*': case '%': /* list_wildcards */ if (wildok) break; /* allowed if doing the wild thing */ /* atom_specials */ case '(': case ')': case '{': case ' ': case 0x7f: #if 0 case '"': case '\\': /* quoted-specials (could work in IMAP4) */ #endif qflag = T; /* must use quoted string format */ break; } if (qflag) *(*s)++ = '"'; /* write open quote */ for (j = 0; j < as->size; j++) *(*s)++ = as->data[j]; if (qflag) *(*s)++ = '"'; /* write close quote */ return NIL; } /* IMAP send literal * Accepts: MAIL stream * reply tag * pointer to current position pointer of output bigbuf * literal to output as stringstruct * Returns: error reply or NIL if success */ IMAPPARSEDREPLY *imap_send_literal (MAILSTREAM *stream,char *tag,char **s, STRING *st) { IMAPPARSEDREPLY *reply; unsigned long i = SIZE (st); unsigned long j; sprintf (*s,"{%lu}",i); /* write literal count */ *s += strlen (*s); /* size of literal count */ /* send the command */ reply = imap_sout (stream,tag,CMDBASE,s); if (strcmp (reply->tag,"+")) {/* prompt for more data? */ mail_unlock (stream); /* no, give up */ return reply; } while (i) { /* dump the text */ if (st->cursize) { /* if text to do in this chunk */ /* RFC 3501 technically forbids NULs in literals. Normally, the * delivering MTA would take care of MIME converting the message text * so that it is NUL-free. If it doesn't, then we have the choice of * either violating IMAP by sending NULs, corrupting the data, or going * to lots of work to do MIME conversion in the IMAP server. * * No current stringstruct driver objects to having its buffer patched. * If this ever changes, it will be necessary to change this kludge. */ /* patch NULs to C1 control */ for (j = 0; j < st->cursize; ++j) if (!st->curpos[j]) st->curpos[j] = 0x80; if (!net_sout (LOCAL->netstream,st->curpos,st->cursize)) { mail_unlock (stream); return imap_fake (stream,tag,"[CLOSED] IMAP connection broken (data)"); } i -= st->cursize; /* note that we wrote out this much */ st->curpos += (st->cursize - 1); st->cursize = 0; } (*st->dtb->next) (st); /* advance to next buffer's worth */ } return NIL; /* success */ } /* IMAP send search program * Accepts: MAIL stream * reply tag * base pointer if trimming needed * pointer to current position pointer of output bigbuf * search program to output * pointer to limit guideline * Returns: error reply or NIL if success */ IMAPPARSEDREPLY *imap_send_spgm (MAILSTREAM *stream,char *tag,char *base, char **s,SEARCHPGM *pgm,char *limit) { IMAPPARSEDREPLY *reply; SEARCHHEADER *hdr; SEARCHOR *pgo; SEARCHPGMLIST *pgl; char *t; /* trim if called recursively */ if (base) *s = imap_send_spgm_trim (base,*s,NIL); base = *s; /* this is the new base */ /* default searchpgm */ for (t = "ALL"; *t; *(*s)++ = *t++); if (!pgm) return NIL; /* done if NIL searchpgm */ if ((pgm->msgno && /* message sequences */ (pgm->msgno->next || /* trim away first:last */ (pgm->msgno->first != 1) || (pgm->msgno->last != stream->nmsgs)) && (reply = imap_send_sset (stream,tag,base,s,pgm->msgno," ",limit))) || (pgm->uid && (reply = imap_send_sset (stream,tag,base,s,pgm->uid," UID ",limit)))) return reply; /* message sizes */ if (pgm->larger) { sprintf (*s," LARGER %lu",pgm->larger); *s += strlen (*s); } if (pgm->smaller) { sprintf (*s," SMALLER %lu",pgm->smaller); *s += strlen (*s); } /* message flags */ if (pgm->answered) for (t = " ANSWERED"; *t; *(*s)++ = *t++); if (pgm->unanswered) for (t =" UNANSWERED"; *t; *(*s)++ = *t++); if (pgm->deleted) for (t =" DELETED"; *t; *(*s)++ = *t++); if (pgm->undeleted) for (t =" UNDELETED"; *t; *(*s)++ = *t++); if (pgm->draft) for (t =" DRAFT"; *t; *(*s)++ = *t++); if (pgm->undraft) for (t =" UNDRAFT"; *t; *(*s)++ = *t++); if (pgm->flagged) for (t =" FLAGGED"; *t; *(*s)++ = *t++); if (pgm->unflagged) for (t =" UNFLAGGED"; *t; *(*s)++ = *t++); if (pgm->recent) for (t =" RECENT"; *t; *(*s)++ = *t++); if (pgm->old) for (t =" OLD"; *t; *(*s)++ = *t++); if (pgm->seen) for (t =" SEEN"; *t; *(*s)++ = *t++); if (pgm->unseen) for (t =" UNSEEN"; *t; *(*s)++ = *t++); if ((pgm->keyword && /* keywords */ (reply = imap_send_slist (stream,tag,base,s," KEYWORD ",pgm->keyword, limit))) || (pgm->unkeyword && (reply = imap_send_slist (stream,tag,base,s," UNKEYWORD ", pgm->unkeyword,limit)))) return reply; /* sent date ranges */ if (pgm->sentbefore) imap_send_sdate (s,"SENTBEFORE",pgm->sentbefore); if (pgm->senton) imap_send_sdate (s,"SENTON",pgm->senton); if (pgm->sentsince) imap_send_sdate (s,"SENTSINCE",pgm->sentsince); /* internal date ranges */ if (pgm->before) imap_send_sdate (s,"BEFORE",pgm->before); if (pgm->on) imap_send_sdate (s,"ON",pgm->on); if (pgm->since) imap_send_sdate (s,"SINCE",pgm->since); if (pgm->older) { sprintf (*s," OLDER %lu",pgm->older); *s += strlen (*s); } if (pgm->younger) { sprintf (*s," YOUNGER %lu",pgm->younger); *s += strlen (*s); } /* search texts */ if ((pgm->bcc && (reply = imap_send_slist (stream,tag,base,s," BCC ", pgm->bcc,limit))) || (pgm->cc && (reply = imap_send_slist (stream,tag,base,s," CC ",pgm->cc, limit))) || (pgm->from && (reply = imap_send_slist (stream,tag,base,s," FROM ", pgm->from,limit))) || (pgm->to && (reply = imap_send_slist (stream,tag,base,s," TO ",pgm->to, limit)))) return reply; if ((pgm->subject && (reply = imap_send_slist (stream,tag,base,s," SUBJECT ", pgm->subject,limit))) || (pgm->body && (reply = imap_send_slist (stream,tag,base,s," BODY ", pgm->body,limit))) || (pgm->text && (reply = imap_send_slist (stream,tag,base,s," TEXT ", pgm->text,limit)))) return reply; /* Note that these criteria are not supported by IMAP and have to be emulated */ if ((pgm->return_path && (reply = imap_send_slist (stream,tag,base,s," HEADER Return-Path ", pgm->return_path,limit))) || (pgm->sender && (reply = imap_send_slist (stream,tag,base,s," HEADER Sender ", pgm->sender,limit))) || (pgm->reply_to && (reply = imap_send_slist (stream,tag,base,s," HEADER Reply-To ", pgm->reply_to,limit))) || (pgm->in_reply_to && (reply = imap_send_slist (stream,tag,base,s," HEADER In-Reply-To ", pgm->in_reply_to,limit))) || (pgm->message_id && (reply = imap_send_slist (stream,tag,base,s," HEADER Message-ID ", pgm->message_id,limit))) || (pgm->newsgroups && (reply = imap_send_slist (stream,tag,base,s," HEADER Newsgroups ", pgm->newsgroups,limit))) || (pgm->followup_to && (reply = imap_send_slist (stream,tag,base,s," HEADER Followup-To ", pgm->followup_to,limit))) || (pgm->references && (reply = imap_send_slist (stream,tag,base,s," HEADER References ", pgm->references,limit)))) return reply; /* all other headers */ if (hdr = pgm->header) do { *s = imap_send_spgm_trim (base,*s," HEADER "); if (reply = imap_send_astring (stream,tag,s,&hdr->line,NIL,limit)) return reply; *(*s)++ = ' '; if (reply = imap_send_astring (stream,tag,s,&hdr->text,NIL,limit)) return reply; } while (hdr = hdr->next); for (pgo = pgm->or; pgo; pgo = pgo->next) { *s = imap_send_spgm_trim (base,*s," OR ("); if (reply = imap_send_spgm (stream,tag,base,s,pgo->first,limit)) return reply; for (t = ") ("; *t; *(*s)++ = *t++); if (reply = imap_send_spgm (stream,tag,base,s,pgo->second,limit)) return reply; *(*s)++ = ')'; } for (pgl = pgm->not; pgl; pgl = pgl->next) { *s = imap_send_spgm_trim (base,*s," NOT ("); if (reply = imap_send_spgm (stream,tag,base,s,pgl->pgm,limit)) return reply; *(*s)++ = ')'; } /* trim if needed */ *s = imap_send_spgm_trim (base,*s,NIL); return NIL; /* search program written OK */ } /* Write new text and trim extraneous "ALL" from searchpgm * Accepts: pointer to start of searchpgm or NIL * current end pointer * new text to write or NIL * Returns: new end pointer, trimmed if needed */ char *imap_send_spgm_trim (char *base,char *s,char *text) { char *t; /* write new text */ if (text) for (t = text; *t; *s++ = *t++); /* need to trim? */ if (base && (s > (t = (base + 4))) && (*base == 'A') && (base[1] == 'L') && (base[2] == 'L') && (base[3] == ' ')) { memmove (base,t,s - t); /* yes, blat down remaining text */ s -= 4; /* and reduce current pointer */ } return s; /* return new end pointer */ } /* IMAP send search set * Accepts: MAIL stream * current command tag * base pointer if trimming needed * pointer to current position pointer of output bigbuf * search set to output * message prefix * maximum output pointer * Returns: NIL if success, error reply if error */ IMAPPARSEDREPLY *imap_send_sset (MAILSTREAM *stream,char *tag,char *base, char **s,SEARCHSET *set,char *prefix, char *limit) { IMAPPARSEDREPLY *reply; STRING st; char c,*t; char *start = *s; /* trim and write prefix */ *s = imap_send_spgm_trim (base,*s,prefix); /* run down search list */ for (c = NIL; set && (*s < limit); set = set->next, c = ',') { if (c) *(*s)++ = c; /* write delimiter and first value */ if (set->first == 0xffffffff) *(*s)++ = '*'; else { sprintf (*s,"%lu",set->first); *s += strlen (*s); } /* have a second value? */ if (set->last && (set->first != set->last)) { *(*s)++ = ':'; /* write delimiter and second value */ if (set->last == 0xffffffff) *(*s)++ = '*'; else { sprintf (*s,"%lu",set->last); *s += strlen (*s); } } } if (set) { /* insert "OR" in front of incomplete set */ memmove (start + 3,start,*s - start); memcpy (start," OR",3); *s += 3; /* point to end of buffer */ /* write glue that is equivalent to ALL */ for (t =" ((OR BCC FOO NOT BCC "; *t; *(*s)++ = *t++); /* but broken by a literal */ INIT (&st,mail_string,(void *) "FOO",3); if (reply = imap_send_literal (stream,tag,s,&st)) return reply; *(*s)++ = ')'; /* close glue */ if (reply = imap_send_sset (stream,tag,NIL,s,set,prefix,limit)) return reply; *(*s)++ = ')'; /* close second OR argument */ } return NIL; } /* IMAP send search list * Accepts: MAIL stream * reply tag * base pointer if trimming needed * pointer to current position pointer of output bigbuf * name of search list * search list to output * maximum output pointer * Returns: NIL if success, error reply if error */ IMAPPARSEDREPLY *imap_send_slist (MAILSTREAM *stream,char *tag,char *base, char **s,char *name,STRINGLIST *list, char *limit) { IMAPPARSEDREPLY *reply; do { *s = imap_send_spgm_trim (base,*s,name); base = NIL; /* no longer need trimming */ reply = imap_send_astring (stream,tag,s,&list->text,NIL,limit); } while (!reply && (list = list->next)); return reply; } /* IMAP send search date * Accepts: pointer to current position pointer of output bigbuf * field name * search date to output */ void imap_send_sdate (char **s,char *name,unsigned short date) { sprintf (*s," %s %d-%s-%d",name,date & 0x1f, months[((date >> 5) & 0xf) - 1],BASEYEAR + (date >> 9)); *s += strlen (*s); } /* IMAP send buffered command to sender * Accepts: MAIL stream * reply tag * string * pointer to string tail pointer * Returns: reply */ IMAPPARSEDREPLY *imap_sout (MAILSTREAM *stream,char *tag,char *base,char **s) { IMAPPARSEDREPLY *reply; if (stream->debug) { /* output debugging telemetry */ **s = '\0'; mail_dlog (base,LOCAL->sensitive); } *(*s)++ = '\015'; /* append CRLF */ *(*s)++ = '\012'; **s = '\0'; reply = net_sout (LOCAL->netstream,base,*s - base) ? imap_reply (stream,tag) : imap_fake (stream,tag,"[CLOSED] IMAP connection broken (command)"); *s = base; /* restart buffer */ return reply; } /* IMAP send null-terminated string to sender * Accepts: MAIL stream * string * Returns: T if success, else NIL */ long imap_soutr (MAILSTREAM *stream,char *string) { long ret; unsigned long i; char *s; if (stream->debug) mm_dlog (string); sprintf (s = (char *) fs_get ((i = strlen (string) + 2) + 1), "%s\015\012",string); ret = net_sout (LOCAL->netstream,s,i); fs_give ((void **) &s); return ret; } /* IMAP get reply * Accepts: MAIL stream * tag to search or NIL if want a greeting * Returns: parsed reply, never NIL */ IMAPPARSEDREPLY *imap_reply (MAILSTREAM *stream,char *tag) { IMAPPARSEDREPLY *reply; while (LOCAL->netstream) { /* parse reply from server */ if (reply = imap_parse_reply (stream,net_getline (LOCAL->netstream))) { /* continuation ready? */ if (!strcmp (reply->tag,"+")) return reply; /* untagged data? */ else if (!strcmp (reply->tag,"*")) { imap_parse_unsolicited (stream,reply); if (!tag) return reply; /* return if just wanted greeting */ } else { /* tagged data */ if (tag && !compare_cstring (tag,reply->tag)) return reply; /* report bogon */ sprintf (LOCAL->tmp,"Unexpected tagged response: %.80s %.80s %.80s", (char *) reply->tag,(char *) reply->key,(char *) reply->text); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; } } } return imap_fake (stream,tag, "[CLOSED] IMAP connection broken (server response)"); } /* IMAP parse reply * Accepts: MAIL stream * text of reply * Returns: parsed reply, or NIL if can't parse at least a tag and key */ IMAPPARSEDREPLY *imap_parse_reply (MAILSTREAM *stream,char *text) { char *r; if (LOCAL->reply.line) fs_give ((void **) &LOCAL->reply.line); /* init fields in case error */ LOCAL->reply.key = LOCAL->reply.text = LOCAL->reply.tag = NIL; if (!(LOCAL->reply.line = text)) { /* NIL text means the stream died */ if (LOCAL->netstream) net_close (LOCAL->netstream); LOCAL->netstream = NIL; return NIL; } if (stream->debug) mm_dlog (LOCAL->reply.line); if (!(LOCAL->reply.tag = strtok_r (LOCAL->reply.line," ",&r))) { mm_notify (stream,"IMAP server sent a blank line",WARN); stream->unhealthy = T; return NIL; } /* non-continuation replies */ if (strcmp (LOCAL->reply.tag,"+")) { /* parse key */ if (!(LOCAL->reply.key = strtok_r (NIL," ",&r))) { /* determine what is missing */ sprintf (LOCAL->tmp,"Missing IMAP reply key: %.80s", (char *) LOCAL->reply.tag); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; return NIL; /* can't parse this text */ } ucase (LOCAL->reply.key); /* canonicalize key to upper */ /* get text as well, allow empty text */ if (!(LOCAL->reply.text = strtok_r (NIL,"\n",&r))) LOCAL->reply.text = LOCAL->reply.key + strlen (LOCAL->reply.key); } else { /* special handling of continuation */ LOCAL->reply.key = "BAD"; /* so it barfs if not expecting continuation */ if (!(LOCAL->reply.text = strtok_r (NIL,"\n",&r))) LOCAL->reply.text = ""; } return &LOCAL->reply; /* return parsed reply */ } /* IMAP fake reply when stream determined to be dead * Accepts: MAIL stream * tag * text of fake reply (must start with "[CLOSED]") * Returns: parsed reply */ IMAPPARSEDREPLY *imap_fake (MAILSTREAM *stream,char *tag,char *text) { mm_notify (stream,text,BYE); /* send bye alert */ if (LOCAL->netstream) net_close (LOCAL->netstream); LOCAL->netstream = NIL; /* farewell, dear NET stream... */ /* flush previous reply */ if (LOCAL->reply.line) fs_give ((void **) &LOCAL->reply.line); /* build new fake reply */ LOCAL->reply.tag = LOCAL->reply.line = cpystr (tag ? tag : "*"); LOCAL->reply.key = "NO"; LOCAL->reply.text = text; return &LOCAL->reply; /* return parsed reply */ } /* IMAP check for OK response in tagged reply * Accepts: MAIL stream * parsed reply * Returns: T if OK else NIL */ long imap_OK (MAILSTREAM *stream,IMAPPARSEDREPLY *reply) { long ret = NIL; /* OK - operation succeeded */ if (!strcmp (reply->key,"OK")) { imap_parse_response (stream,reply->text,NIL,NIL); ret = T; } /* NO - operation failed */ else if (!strcmp (reply->key,"NO")) imap_parse_response (stream,reply->text,WARN,NIL); else { /* BAD - operation rejected */ if (!strcmp (reply->key,"BAD")) { imap_parse_response (stream,reply->text,ERROR,NIL); sprintf (LOCAL->tmp,"IMAP protocol error: %.80s",(char *) reply->text); } /* bad protocol received */ else sprintf (LOCAL->tmp,"Unexpected IMAP response: %.80s %.80s", (char *) reply->key,(char *) reply->text); mm_log (LOCAL->tmp,ERROR); /* either way, this is not good */ } return ret; } /* IMAP parse and act upon unsolicited reply * Accepts: MAIL stream * parsed reply */ void imap_parse_unsolicited (MAILSTREAM *stream,IMAPPARSEDREPLY *reply) { unsigned long i = 0; unsigned long j,msgno; unsigned char *s,*t; char *r; /* see if key is a number */ if (isdigit (*reply->key)) { msgno = strtoul (reply->key,(char **) &s,10); if (*s) { /* better be nothing after number */ sprintf (LOCAL->tmp,"Unexpected untagged message: %.80s", (char *) reply->key); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; return; } if (!reply->text) { /* better be some data */ mm_notify (stream,"Missing message data",WARN); stream->unhealthy = T; return; } /* get message data type, canonicalize upper */ s = ucase (strtok_r (reply->text," ",&r)); /* and locate the text after it */ t = strtok_r (NIL,"\n",&r); /* now take the action */ /* change in size of mailbox */ if (!strcmp (s,"EXISTS") && (msgno >= stream->nmsgs)) mail_exists (stream,msgno); else if (!strcmp (s,"RECENT") && (msgno <= stream->nmsgs)) mail_recent (stream,msgno); else if (!strcmp (s,"EXPUNGE") && msgno && (msgno <= stream->nmsgs)) { mailcache_t mc = (mailcache_t) mail_parameters (NIL,GET_CACHE,NIL); MESSAGECACHE *elt = (MESSAGECACHE *) (*mc) (stream,msgno,CH_ELT); if (elt) imap_gc_body (elt->private.msg.body); /* notify upper level */ mail_expunged (stream,msgno); } else if ((!strcmp (s,"FETCH") || !strcmp (s,"STORE")) && msgno && (msgno <= stream->nmsgs)) { char *prop; GETS_DATA md; ENVELOPE **e; MESSAGECACHE *elt = mail_elt (stream,msgno); ENVELOPE *env = NIL; imapenvelope_t ie = (imapenvelope_t) mail_parameters (stream,GET_IMAPENVELOPE,NIL); ++t; /* skip past open parenthesis */ /* parse Lisp-form property list */ while (prop = (strtok_r (t," )",&r))) { t = strtok_r (NIL,"\n",&r); INIT_GETS (md,stream,elt->msgno,NIL,0,0); e = NIL; /* not pointing at any envelope yet */ /* canonicalize property, parse it */ if (!strcmp (ucase (prop),"FLAGS")) imap_parse_flags (stream,elt,&t); else if (!strcmp (prop,"INTERNALDATE") && (s = imap_parse_string (stream,&t,reply,NIL,NIL,LONGT))) { if (!mail_parse_date (elt,s)) { sprintf (LOCAL->tmp,"Bogus date: %.80s",(char *) s); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; /* slam in default so we don't try again */ mail_parse_date (elt,"01-Jan-1970 00:00:00 +0000"); } fs_give ((void **) &s); } /* unique identifier */ else if (!strcmp (prop,"UID")) { LOCAL->lastuid.uid = elt->private.uid = strtoul (t,(char **) &t,10); LOCAL->lastuid.msgno = elt->msgno; } else if (!strcmp (prop,"ENVELOPE")) { if (stream->scache) { /* short cache, flush old stuff */ mail_free_body (&stream->body); stream->msgno = elt->msgno; e = &stream->env; /* get pointer to envelope */ } else e = &elt->private.msg.env; imap_parse_envelope (stream,e,&t,reply); } else if (!strncmp (prop,"BODY",4)) { if (!prop[4] || !strcmp (prop+4,"STRUCTURE")) { BODY **body; if (stream->scache){/* short cache, flush old stuff */ if (stream->msgno != msgno) { mail_free_envelope (&stream->env); sprintf (LOCAL->tmp,"Body received for %lu but current is %lu", msgno,stream->msgno); stream->msgno = msgno; } /* get pointer to body */ body = &stream->body; } else body = &elt->private.msg.body; /* flush any prior body */ mail_free_body (body); /* instantiate and parse a new body */ imap_parse_body_structure (stream,*body = mail_newbody(),&t,reply); } else if (prop[4] == '[') { STRINGLIST *stl = NIL; SIZEDTEXT text; /* will want to return envelope data */ if (!strcmp (md.what = cpystr (prop + 5),"HEADER]") || !strcmp (md.what,"0]")) e = stream->scache ? &stream->env : &elt->private.msg.env; LOCAL->tmp[0] ='\0';/* no errors yet */ /* found end of section? */ if (!(s = strchr (md.what,']'))) { /* skip leading nesting */ for (s = md.what; *s && (isdigit (*s) || (*s == '.')); s++); /* better be one of these */ if (strncmp (s,"HEADER.FIELDS",13) && (!s[13] || strcmp (s+13,".NOT"))) sprintf (LOCAL->tmp,"Unterminated section: %.80s",md.what); /* get list of headers */ else if (!(stl = imap_parse_stringlist (stream,&t,reply))) sprintf (LOCAL->tmp,"Bogus header field list: %.80s", (char *) t); else if (*t != ']') sprintf (LOCAL->tmp,"Unterminated header section: %.80s", (char *) t); /* point after the text */ else if (t = strchr (s = t,' ')) *t++ = '\0'; } if (s && !LOCAL->tmp[0]) { *s++ = '\0'; /* tie off section specifier */ if (*s == '<') { /* partial specifier? */ md.first = strtoul (s+1,(char **) &s,10) + 1; if (*s++ != '>') /* make sure properly terminated */ sprintf (LOCAL->tmp,"Unterminated partial data: %.80s", (char *) s-1); } if (!LOCAL->tmp[0] && *s) sprintf (LOCAL->tmp,"Junk after section: %.80s",(char *) s); } if (LOCAL->tmp[0]) { /* got any errors? */ mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; mail_free_stringlist (&stl); } else { /* parse text from server */ text.data = (unsigned char *) imap_parse_string (stream,&t,reply, ((md.what[0] && (md.what[0] != 'H')) || md.first || md.last) ? &md : NIL, &text.size,NIL); /* all done if partial */ if (md.first || md.last) mail_free_stringlist (&stl); /* otherwise register it in the cache */ else imap_cache (stream,msgno,md.what,stl,&text); } fs_give ((void **) &md.what); } else { sprintf (LOCAL->tmp,"Unknown body message property: %.80s",prop); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; } } /* one of the RFC822 props? */ else if (!strncmp (prop,"RFC822",6) && (!prop[6] || (prop[6] == '.'))){ SIZEDTEXT text; if (!prop[6]) { /* cache full message */ md.what = ""; text.data = (unsigned char *) imap_parse_string (stream,&t,reply,&md,&text.size,NIL); imap_cache (stream,msgno,md.what,NIL,&text); } else if (!strcmp (prop+7,"SIZE")) elt->rfc822_size = strtoul (t,(char **) &t,10); /* legacy properties */ else if (!strcmp (prop+7,"HEADER")) { text.data = (unsigned char *) imap_parse_string (stream,&t,reply,NIL,&text.size,NIL); imap_cache (stream,msgno,"HEADER",NIL,&text); e = stream->scache ? &stream->env : &elt->private.msg.env; } else if (!strcmp (prop+7,"TEXT")) { md.what = "TEXT"; text.data = (unsigned char *) imap_parse_string (stream,&t,reply,&md,&text.size,NIL); imap_cache (stream,msgno,md.what,NIL,&text); } else { sprintf (LOCAL->tmp,"Unknown RFC822 message property: %.80s",prop); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; } } else { sprintf (LOCAL->tmp,"Unknown message property: %.80s",prop); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; } if (e && *e) env = *e; /* note envelope if we got one */ } /* do callback if requested */ if (ie && env) (*ie) (stream,msgno,env); } /* obsolete response to COPY */ else if (strcmp (s,"COPY")) { sprintf (LOCAL->tmp,"Unknown message data: %lu %.80s",msgno,(char *) s); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; } } else if (!strcmp (reply->key,"FLAGS") && reply->text && (*reply->text == '(') && (s = strtok_r (reply->text+1," )",&r))) do if (*s != '\\') { for (i = 0; (i < NUSERFLAGS) && stream->user_flags[i] && compare_cstring (s,stream->user_flags[i]); i++); if (i > NUSERFLAGS) { sprintf (LOCAL->tmp,"Too many server flags, discarding: %.80s", (char *) s); mm_notify (stream,LOCAL->tmp,WARN); } else if (!stream->user_flags[i]) stream->user_flags[i++] = cpystr (s); } while (s = strtok_r (NIL," )",&r)); else if (!strcmp (reply->key,"SEARCH")) { /* only do something if have text */ if (reply->text && (t = strtok_r (reply->text," ",&r))) do if (i = strtoul (t,NIL,10)) { /* UIDs always passed to main program */ if (LOCAL->uidsearch) mm_searched (stream,i); /* should be a msgno then */ else if ((i <= stream->nmsgs) && (!LOCAL->filter || mail_elt (stream,i)->private.filter)) { mail_elt (stream,i)->searched = T; if (!stream->silent) mm_searched (stream,i); } } while (t = strtok_r (NIL," ",&r)); } else if (!strcmp (reply->key,"SORT")) { sortresults_t sr = (sortresults_t) mail_parameters (NIL,GET_SORTRESULTS,NIL); LOCAL->sortsize = 0; /* initialize sort data */ if (LOCAL->sortdata) fs_give ((void **) &LOCAL->sortdata); LOCAL->sortdata = (unsigned long *) fs_get ((stream->nmsgs + 1) * sizeof (unsigned long)); /* only do something if have text */ if (reply->text && (t = strtok_r (reply->text," ",&r))) { do if ((i = atol (t)) && (LOCAL->filter ? mail_elt (stream,i)->searched : T)) LOCAL->sortdata[LOCAL->sortsize++] = i; while ((t = strtok_r (NIL," ",&r)) && (LOCAL->sortsize < stream->nmsgs)); } LOCAL->sortdata[LOCAL->sortsize] = 0; /* also return via callback if requested */ if (sr) (*sr) (stream,LOCAL->sortdata,LOCAL->sortsize); } else if (!strcmp (reply->key,"THREAD")) { threadresults_t tr = (threadresults_t) mail_parameters (NIL,GET_THREADRESULTS,NIL); if (LOCAL->threaddata) mail_free_threadnode (&LOCAL->threaddata); if (s = reply->text) { LOCAL->threaddata = imap_parse_thread (stream,&s); if (tr) (*tr) (stream,LOCAL->threaddata); if (s && *s) { sprintf (LOCAL->tmp,"Junk at end of thread: %.80s",(char *) s); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; } } } else if (!strcmp (reply->key,"STATUS") && reply->text) { MAILSTATUS status; unsigned char *txt = reply->text; if ((t = imap_parse_astring (stream,&txt,reply,&j)) && txt && (*txt++ == ' ') && (*txt++ == '(') && (s = strchr (txt,')')) && (s - txt) && !s[1]) { *s = '\0'; /* tie off status data */ /* initialize data block */ status.flags = status.messages = status.recent = status.unseen = status.uidnext = status.uidvalidity = 0; while (*txt && (s = strchr (txt,' '))) { *s++ = '\0'; /* tie off status attribute name */ /* get attribute value */ i = strtoul (s,(char **) &s,10); if (!compare_cstring (txt,"MESSAGES")) { status.flags |= SA_MESSAGES; status.messages = i; } else if (!compare_cstring (txt,"RECENT")) { status.flags |= SA_RECENT; status.recent = i; } else if (!compare_cstring (txt,"UNSEEN")) { status.flags |= SA_UNSEEN; status.unseen = i; } else if (!compare_cstring (txt,"UIDNEXT")) { status.flags |= SA_UIDNEXT; status.uidnext = i; } else if (!compare_cstring (txt,"UIDVALIDITY")) { status.flags |= SA_UIDVALIDITY; status.uidvalidity = i; } /* next attribute */ txt = (*s == ' ') ? s + 1 : s; } if (((i = 1 + strchr (stream->mailbox,'}') - stream->mailbox) + j) < IMAPTMPLEN) { strcpy (strncpy (LOCAL->tmp,stream->mailbox,i) + i,t); /* pass status to main program */ mm_status (stream,LOCAL->tmp,&status); } } if (t) fs_give ((void **) &t); } else if ((!strcmp (reply->key,"LIST") || !strcmp (reply->key,"LSUB")) && reply->text && (*reply->text == '(') && (s = strchr (reply->text,')')) && (s[1] == ' ')) { char delimiter = '\0'; *s++ = '\0'; /* tie off attribute list */ /* parse attribute list */ if (t = strtok_r (reply->text+1," ",&r)) do { if (!compare_cstring (t,"\\NoInferiors")) i |= LATT_NOINFERIORS; else if (!compare_cstring (t,"\\NoSelect")) i |= LATT_NOSELECT; else if (!compare_cstring (t,"\\Marked")) i |= LATT_MARKED; else if (!compare_cstring (t,"\\Unmarked")) i |= LATT_UNMARKED; else if (!compare_cstring (t,"\\HasChildren")) i |= LATT_HASCHILDREN; else if (!compare_cstring (t,"\\HasNoChildren")) i |= LATT_HASNOCHILDREN; /* ignore extension flags */ } while (t = strtok_r (NIL," ",&r)); switch (*++s) { /* process delimiter */ case 'N': /* NIL */ case 'n': s += 4; /* skip over NIL<space> */ break; case '"': /* have a delimiter */ delimiter = (*++s == '\\') ? *++s : *s; s += 3; /* skip over <delimiter><quote><space> */ } /* parse the mailbox name */ if (t = imap_parse_astring (stream,&s,reply,&j)) { /* prepend prefix if requested */ if (LOCAL->prefix && ((strlen (LOCAL->prefix) + j) < IMAPTMPLEN)) sprintf (s = LOCAL->tmp,"%s%s",LOCAL->prefix,(char *) t); else s = t; /* otherwise just mailbox name */ /* pass data to main program */ if (reply->key[1] == 'S') mm_lsub (stream,delimiter,s,i); else mm_list (stream,delimiter,s,i); fs_give ((void **) &t); /* flush mailbox name */ } } else if (!strcmp (reply->key,"NAMESPACE")) { if (LOCAL->namespace) { mail_free_namespace (&LOCAL->namespace[0]); mail_free_namespace (&LOCAL->namespace[1]); mail_free_namespace (&LOCAL->namespace[2]); } else LOCAL->namespace = (NAMESPACE **) fs_get (3 * sizeof (NAMESPACE *)); if (s = reply->text) { /* parse namespace results */ LOCAL->namespace[0] = imap_parse_namespace (stream,&s,reply); LOCAL->namespace[1] = imap_parse_namespace (stream,&s,reply); LOCAL->namespace[2] = imap_parse_namespace (stream,&s,reply); if (s && *s) { sprintf (LOCAL->tmp,"Junk after namespace list: %.80s",(char *) s); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; } } else { mm_notify (stream,"Missing namespace list",WARN); stream->unhealthy = T; } } else if (!strcmp (reply->key,"ACL") && (s = reply->text) && (t = imap_parse_astring (stream,&s,reply,NIL))) { getacl_t ar = (getacl_t) mail_parameters (NIL,GET_ACL,NIL); if (s && (*s++ == ' ')) { ACLLIST *al = mail_newacllist (); ACLLIST *ac = al; do if ((ac->identifier = imap_parse_astring (stream,&s,reply,NIL)) && s && (*s++ == ' ')) ac->rights = imap_parse_astring (stream,&s,reply,NIL); while (ac->rights && s && (*s == ' ') && s++ && (ac = ac->next = mail_newacllist ())); if (!ac->rights || (s && *s)) { sprintf (LOCAL->tmp,"Invalid ACL identifer/rights for %.80s", (char *) t); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; } else if (ar) (*ar) (stream,t,al); mail_free_acllist (&al); /* clean up */ } /* no optional rights */ else if (ar) (*ar) (stream,t,NIL); fs_give ((void **) &t); /* free mailbox name */ } else if (!strcmp (reply->key,"LISTRIGHTS") && (s = reply->text) && (t = imap_parse_astring (stream,&s,reply,NIL))) { listrights_t lr = (listrights_t) mail_parameters (NIL,GET_LISTRIGHTS,NIL); char *id,*r; if (s && (*s++ == ' ') && (id = imap_parse_astring (stream,&s,reply,NIL))){ if (s && (*s++ == ' ') && (r = imap_parse_astring (stream,&s,reply,NIL))) { if (s && (*s++ == ' ')) { STRINGLIST *rl = mail_newstringlist (); STRINGLIST *rc = rl; do rc->text.data = (unsigned char *) imap_parse_astring (stream,&s,reply,&rc->text.size); while (rc->text.data && s && (*s == ' ') && s++ && (rc = rc->next = mail_newstringlist ())); if (!rc->text.data || (s && *s)) { sprintf (LOCAL->tmp,"Invalid optional LISTRIGHTS for %.80s", (char *) t); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; } else if (lr) (*lr) (stream,t,id,r,rl); /* clean up */ mail_free_stringlist (&rl); } /* no optional rights */ else if (lr) (*lr) (stream,t,id,r,NIL); fs_give ((void **) &r); /* free rights */ } else { sprintf (LOCAL->tmp,"Missing LISTRIGHTS rights for %.80s",(char *) t); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; } fs_give ((void **) &id); /* free identifier */ } else { sprintf (LOCAL->tmp,"Missing LISTRIGHTS identifer for %.80s",(char *) t); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; } fs_give ((void **) &t); /* free mailbox name */ } else if (!strcmp (reply->key,"MYRIGHTS") && (s = reply->text) && (t = imap_parse_astring (stream,&s,reply,NIL))) { myrights_t mr = (myrights_t) mail_parameters (NIL,GET_MYRIGHTS,NIL); char *r; if (s && (*s++ == ' ') && (r = imap_parse_astring (stream,&s,reply,NIL))) { if (s && *s) { sprintf (LOCAL->tmp,"Junk after MYRIGHTS for %.80s",(char *) t); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; } else if (mr) (*mr) (stream,t,r); fs_give ((void **) &r); /* free rights */ } else { sprintf (LOCAL->tmp,"Missing MYRIGHTS for %.80s",(char *) t); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; } fs_give ((void **) &t); /* free mailbox name */ } /* this response has a bizarre syntax! */ else if (!strcmp (reply->key,"QUOTA") && (s = reply->text) && (t = imap_parse_astring (stream,&s,reply,NIL))) { /* in case error */ sprintf (LOCAL->tmp,"Bad quota resource list for %.80s",(char *) t); if (s && (*s++ == ' ') && (*s++ == '(') && *s && ((*s != ')') || !s[1])) { quota_t qt = (quota_t) mail_parameters (NIL,GET_QUOTA,NIL); QUOTALIST *ql = NIL; QUOTALIST *qc; /* parse non-empty quota resource list */ if (*s != ')') for (ql = qc = mail_newquotalist (); T; qc = qc->next = mail_newquotalist ()) { if ((qc->name = imap_parse_astring (stream,&s,reply,NIL)) && s && (*s++ == ' ') && (isdigit (*s) || (LOCAL->loser && (*s == '-')))) { if (isdigit (*s)) qc->usage = strtoul (s,(char **) &s,10); else if (t = strchr (s,' ')) t = s; if ((*s++ == ' ') && (isdigit (*s) || (LOCAL->loser &&(*s == '-')))){ if (isdigit (*s)) qc->limit = strtoul (s,(char **) &s,10); else if (t = strpbrk (s," )")) t = s; /* another resource follows? */ if (*s == ' ') continue; /* end of resource list? */ if ((*s == ')') && !s[1]) { if (qt) (*qt) (stream,t,ql); break; /* all done */ } } } /* something bad happened */ mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; break; /* parse failed */ } /* all done with quota resource list now */ if (ql) mail_free_quotalist (&ql); } else { mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; } fs_give ((void **) &t); /* free root name */ } else if (!strcmp (reply->key,"QUOTAROOT") && (s = reply->text) && (t = imap_parse_astring (stream,&s,reply,NIL))) { sprintf (LOCAL->tmp,"Bad quota root list for %.80s",(char *) t); if (s && (*s++ == ' ')) { quotaroot_t qr = (quotaroot_t) mail_parameters (NIL,GET_QUOTAROOT,NIL); STRINGLIST *rl = mail_newstringlist (); STRINGLIST *rc = rl; do rc->text.data = (unsigned char *) imap_parse_astring (stream,&s,reply,&rc->text.size); while (rc->text.data && *s && (*s++ == ' ') && (rc = rc->next = mail_newstringlist ())); if (!rc->text.data || (s && *s)) { mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; } else if (qr) (*qr) (stream,t,rl); /* clean up */ mail_free_stringlist (&rl); } else { mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; } fs_give ((void **) &t); } else if (!strcmp (reply->key,"OK") || !strcmp (reply->key,"PREAUTH")) imap_parse_response (stream,reply->text,NIL,T); else if (!strcmp (reply->key,"NO")) imap_parse_response (stream,reply->text,WARN,T); else if (!strcmp (reply->key,"BAD")) imap_parse_response (stream,reply->text,ERROR,T); else if (!strcmp (reply->key,"BYE")) { LOCAL->byeseen = T; /* note that a BYE seen */ imap_parse_response (stream,reply->text,BYE,T); } else if (!strcmp (reply->key,"CAPABILITY") && reply->text) imap_parse_capabilities (stream,reply->text); else if (!strcmp (reply->key,"MAILBOX") && reply->text) { if (LOCAL->prefix && ((strlen (LOCAL->prefix) + strlen (reply->text)) < IMAPTMPLEN)) sprintf (t = LOCAL->tmp,"%s%s",LOCAL->prefix,(char *) reply->text); else t = reply->text; mm_list (stream,NIL,t,NIL); } else { sprintf (LOCAL->tmp,"Unexpected untagged message: %.80s", (char *) reply->key); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; } } /* Parse human-readable response text * Accepts: mail stream * text * error level for mm_notify() * non-NIL if want mm_notify() event even if no response code */ void imap_parse_response (MAILSTREAM *stream,char *text,long errflg,long ntfy) { char *s,*t,*r; size_t i; unsigned long j; MESSAGECACHE *elt; copyuid_t cu; appenduid_t au; SEARCHSET *source = NIL; SEARCHSET *dest = NIL; if (text && (*text == '[') && (t = strchr (s = text + 1,']')) && ((i = t - s) < IMAPTMPLEN)) { LOCAL->tmp[i] = '\0'; /* make mungable copy of text code */ if (s = strchr (strncpy (t = LOCAL->tmp,s,i),' ')) *s++ = '\0'; if (s) { /* have argument? */ ntfy = NIL; /* suppress mm_notify if normal SELECT data */ if (!compare_cstring (t,"UIDVALIDITY") && ((j = strtoul (s,NIL,10)) != stream->uid_validity)) { mailcache_t mc = (mailcache_t) mail_parameters (NIL,GET_CACHE,NIL); stream->uid_validity = j; /* purge any UIDs in cache */ for (j = 1; j <= stream->nmsgs; j++) if (elt = (MESSAGECACHE *) (*mc) (stream,j,CH_ELT)) elt->private.uid = 0; } else if (!compare_cstring (t,"UIDNEXT")) stream->uid_last = strtoul (s,NIL,10) - 1; else if (!compare_cstring (t,"PERMANENTFLAGS") && (*s == '(') && (t[i-1] == ')')) { t[i-1] = '\0'; /* tie off flags */ stream->perm_seen = stream->perm_deleted = stream->perm_answered = stream->perm_draft = stream->kwd_create = NIL; stream->perm_user_flags = NIL; if (s = strtok_r (s+1," ",&r)) do { if (*s == '\\') { /* system flags */ if (!compare_cstring (s,"\\Seen")) stream->perm_seen = T; else if (!compare_cstring (s,"\\Deleted")) stream->perm_deleted = T; else if (!compare_cstring (s,"\\Flagged")) stream->perm_flagged = T; else if (!compare_cstring (s,"\\Answered")) stream->perm_answered = T; else if (!compare_cstring (s,"\\Draft")) stream->perm_draft = T; else if (!strcmp (s,"\\*")) stream->kwd_create = T; } else stream->perm_user_flags |= imap_parse_user_flag (stream,s); } while (s = strtok_r (NIL," ",&r)); } else if (!compare_cstring (t,"CAPABILITY")) imap_parse_capabilities (stream,s); else if ((j = LEVELUIDPLUS (stream) && LOCAL->appendmailbox) && !compare_cstring (t,"COPYUID") && (cu = (copyuid_t) mail_parameters (NIL,GET_COPYUID,NIL)) && isdigit (*s) && (j = strtoul (s,&s,10)) && (*s++ == ' ') && (source = mail_parse_set (s,&s)) && (*s++ == ' ') && (dest = mail_parse_set (s,&s)) && !*s) (*cu) (stream,LOCAL->appendmailbox,j,source,dest); else if (j && !compare_cstring (t,"APPENDUID") && (au = (appenduid_t) mail_parameters (NIL,GET_APPENDUID,NIL)) && isdigit (*s) && (j = strtoul (s,&s,10)) && (*s++ == ' ') && (dest = mail_parse_set (s,&s)) && !*s) (*au) (LOCAL->appendmailbox,j,dest); else { /* all other response code events */ ntfy = T; /* must mm_notify() */ if (!compare_cstring (t,"REFERRAL")) LOCAL->referral = cpystr (t + 9); } mail_free_searchset (&source); mail_free_searchset (&dest); } else { /* no arguments */ if (!compare_cstring (t,"UIDNOTSTICKY")) { ntfy = NIL; stream->uid_nosticky = T; } else if (!compare_cstring (t,"READ-ONLY")) stream->rdonly = T; else if (!compare_cstring (t,"READ-WRITE")) stream->rdonly = NIL; else if (!compare_cstring (t,"PARSE") && !errflg) errflg = PARSE; } } /* give event to main program */ if (ntfy && !stream->silent) mm_notify (stream,text ? text : "",errflg); } /* Parse a namespace * Accepts: mail stream * current text pointer * parsed reply * Returns: namespace list, text pointer updated */ NAMESPACE *imap_parse_namespace (MAILSTREAM *stream,unsigned char **txtptr, IMAPPARSEDREPLY *reply) { NAMESPACE *ret = NIL; NAMESPACE *nam = NIL; NAMESPACE *prev = NIL; PARAMETER *par = NIL; if (*txtptr) { /* only if argument given */ /* ignore leading space */ while (**txtptr == ' ') ++*txtptr; switch (**txtptr) { case 'N': /* if NIL */ case 'n': ++*txtptr; /* bump past "N" */ ++*txtptr; /* bump past "I" */ ++*txtptr; /* bump past "L" */ break; case '(': ++*txtptr; /* skip past open paren */ while (**txtptr == '(') { ++*txtptr; /* skip past open paren */ prev = nam; /* note previous if any */ nam = (NAMESPACE *) memset (fs_get (sizeof (NAMESPACE)),0, sizeof (NAMESPACE)); if (!ret) ret = nam; /* if first time note first namespace */ /* if previous link new block to it */ if (prev) prev->next = nam; nam->name = imap_parse_string (stream,txtptr,reply,NIL,NIL,NIL); /* ignore whitespace */ while (**txtptr == ' ') ++*txtptr; switch (**txtptr) { /* parse delimiter */ case 'N': case 'n': *txtptr += 3; /* bump past "NIL" */ break; case '"': if (*++*txtptr == '\\') nam->delimiter = *++*txtptr; else nam->delimiter = **txtptr; *txtptr += 2; /* bump past character and closing quote */ break; default: sprintf (LOCAL->tmp,"Missing delimiter in namespace: %.80s", (char *) *txtptr); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; *txtptr = NIL; /* stop parse */ return ret; } while (**txtptr == ' '){/* append new parameter to tail */ if (nam->param) par = par->next = mail_newbody_parameter (); else nam->param = par = mail_newbody_parameter (); if (!(par->attribute = imap_parse_string (stream,txtptr,reply,NIL, NIL,NIL))) { mm_notify (stream,"Missing namespace extension attribute",WARN); stream->unhealthy = T; par->attribute = cpystr ("UNKNOWN"); } /* skip space */ while (**txtptr == ' ') ++*txtptr; if (**txtptr == '(') {/* have value list? */ char *att = par->attribute; ++*txtptr; /* yes */ do { /* parse each value */ if (!(par->value = imap_parse_string (stream,txtptr,reply,NIL, NIL,LONGT))) { sprintf (LOCAL->tmp, "Missing value for namespace attribute %.80s",att); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; par->value = cpystr ("UNKNOWN"); } /* is there another value? */ if (**txtptr == ' ') par = par->next = mail_newbody_parameter (); } while (!par->value); } else { sprintf (LOCAL->tmp,"Missing values for namespace attribute %.80s", par->attribute); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; par->value = cpystr ("UNKNOWN"); } } if (**txtptr == ')') ++*txtptr; else { /* missing trailing paren */ sprintf (LOCAL->tmp,"Junk at end of namespace: %.80s", (char *) *txtptr); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; return ret; } } if (**txtptr == ')') { /* expected trailing paren? */ ++*txtptr; /* got it! */ break; } default: sprintf (LOCAL->tmp,"Not a namespace: %.80s",(char *) *txtptr); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; *txtptr = NIL; /* stop parse now */ break; } } return ret; } /* Parse a thread node list * Accepts: mail stream * current text pointer * Returns: thread node list, text pointer updated */ THREADNODE *imap_parse_thread (MAILSTREAM *stream,unsigned char **txtptr) { char *s; THREADNODE *ret = NIL; /* returned tree */ THREADNODE *last = NIL; /* last branch in this tree */ THREADNODE *parent = NIL; /* parent of current node */ THREADNODE *cur; /* current node */ while (**txtptr == '(') { /* see a thread? */ ++*txtptr; /* skip past open paren */ while (**txtptr != ')') { /* parse thread */ if (**txtptr == '(') { /* thread branch */ cur = imap_parse_thread (stream,txtptr); /* add to parent */ if (parent) parent = parent->next = cur; else { /* no parent, create dummy */ if (last) last = last->branch = mail_newthreadnode (NIL); /* new tree */ else ret = last = mail_newthreadnode (NIL); /* add to dummy parent */ last->next = parent = cur; } } /* threaded message number */ else if (isdigit (*(s = *txtptr)) && ((cur = mail_newthreadnode (NIL))->num = strtoul (*txtptr,(char **) txtptr,10))) { if (LOCAL->filter && !mail_elt (stream,cur->num)->searched) cur->num = NIL; /* make dummy if filtering and not searched */ /* add to parent */ if (parent) parent = parent->next = cur; /* no parent, start new thread */ else if (last) last = last->branch = parent = cur; /* create new tree */ else ret = last = parent = cur; } else { /* anything else is a bogon */ char tmp[MAILTMPLEN]; sprintf (tmp,"Bogus thread member: %.80s",s); mm_notify (stream,tmp,WARN); stream->unhealthy = T; return ret; } /* skip past any space */ if (**txtptr == ' ') ++*txtptr; } ++*txtptr; /* skip pase end of thread */ parent = NIL; /* close this thread */ } return ret; /* return parsed thread */ } /* Parse RFC822 message header * Accepts: MAIL stream * envelope to parse into * header as sized text * stringlist if partial header */ void imap_parse_header (MAILSTREAM *stream,ENVELOPE **env,SIZEDTEXT *hdr, STRINGLIST *stl) { ENVELOPE *nenv; /* parse what we can from this header */ rfc822_parse_msg (&nenv,NIL,(char *) hdr->data,hdr->size,NIL, net_host (LOCAL->netstream),stream->dtb->flags); if (*env) { /* need to merge this header into envelope? */ if (!(*env)->newsgroups) { /* need Newsgroups? */ (*env)->newsgroups = nenv->newsgroups; nenv->newsgroups = NIL; } if (!(*env)->followup_to) { /* need Followup-To? */ (*env)->followup_to = nenv->followup_to; nenv->followup_to = NIL; } if (!(*env)->references) { /* need References? */ (*env)->references = nenv->references; nenv->references = NIL; } if (!(*env)->sparep) { /* need spare pointer? */ (*env)->sparep = nenv->sparep; nenv->sparep = NIL; } mail_free_envelope (&nenv); (*env)->imapenvonly = NIL; /* have complete envelope now */ } /* otherwise set it to this envelope */ else (*env = nenv)->incomplete = stl ? T : NIL; } /* IMAP parse envelope * Accepts: MAIL stream * pointer to envelope pointer * current text pointer * parsed reply * * Updates text pointer */ void imap_parse_envelope (MAILSTREAM *stream,ENVELOPE **env, unsigned char **txtptr,IMAPPARSEDREPLY *reply) { ENVELOPE *oenv = *env; char c = *((*txtptr)++); /* grab first character */ /* ignore leading spaces */ while (c == ' ') c = *((*txtptr)++); switch (c) { /* dispatch on first character */ case '(': /* if envelope S-expression */ *env = mail_newenvelope (); /* parse the new envelope */ (*env)->date = imap_parse_string (stream,txtptr,reply,NIL,NIL,LONGT); (*env)->subject = imap_parse_string (stream,txtptr,reply,NIL,NIL,LONGT); (*env)->from = imap_parse_adrlist (stream,txtptr,reply); (*env)->sender = imap_parse_adrlist (stream,txtptr,reply); (*env)->reply_to = imap_parse_adrlist (stream,txtptr,reply); (*env)->to = imap_parse_adrlist (stream,txtptr,reply); (*env)->cc = imap_parse_adrlist (stream,txtptr,reply); (*env)->bcc = imap_parse_adrlist (stream,txtptr,reply); (*env)->in_reply_to = imap_parse_string (stream,txtptr,reply,NIL,NIL, LONGT); (*env)->message_id = imap_parse_string (stream,txtptr,reply,NIL,NIL,LONGT); if (oenv) { /* need to merge old envelope? */ (*env)->newsgroups = oenv->newsgroups; oenv->newsgroups = NIL; (*env)->followup_to = oenv->followup_to; oenv->followup_to = NIL; (*env)->references = oenv->references; oenv->references = NIL; mail_free_envelope(&oenv);/* free old envelope */ } /* have IMAP envelope components only */ else (*env)->imapenvonly = T; if (**txtptr != ')') { sprintf (LOCAL->tmp,"Junk at end of envelope: %.80s",(char *) *txtptr); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; } else ++*txtptr; /* skip past delimiter */ break; case 'N': /* if NIL */ case 'n': ++*txtptr; /* bump past "I" */ ++*txtptr; /* bump past "L" */ break; default: sprintf (LOCAL->tmp,"Not an envelope: %.80s",(char *) *txtptr); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; break; } } /* IMAP parse address list * Accepts: MAIL stream * current text pointer * parsed reply * Returns: address list, NIL on failure * * Updates text pointer */ ADDRESS *imap_parse_adrlist (MAILSTREAM *stream,unsigned char **txtptr, IMAPPARSEDREPLY *reply) { ADDRESS *adr = NIL; char c = **txtptr; /* sniff at first character */ /* ignore leading spaces */ while (c == ' ') c = *++*txtptr; ++*txtptr; /* skip past open paren */ switch (c) { case '(': /* if envelope S-expression */ adr = imap_parse_address (stream,txtptr,reply); if (**txtptr != ')') { sprintf (LOCAL->tmp,"Junk at end of address list: %.80s", (char *) *txtptr); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; } else ++*txtptr; /* skip past delimiter */ break; case 'N': /* if NIL */ case 'n': ++*txtptr; /* bump past "I" */ ++*txtptr; /* bump past "L" */ break; default: sprintf (LOCAL->tmp,"Not an address: %.80s",(char *) *txtptr); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; break; } return adr; } /* IMAP parse address * Accepts: MAIL stream * current text pointer * parsed reply * Returns: address, NIL on failure * * Updates text pointer */ ADDRESS *imap_parse_address (MAILSTREAM *stream,unsigned char **txtptr, IMAPPARSEDREPLY *reply) { long ingroup = 0; ADDRESS *adr = NIL; ADDRESS *ret = NIL; ADDRESS *prev = NIL; char c = **txtptr; /* sniff at first address character */ switch (c) { case '(': /* if envelope S-expression */ while (c == '(') { /* recursion dies on small stack machines */ ++*txtptr; /* skip past open paren */ if (adr) prev = adr; /* note previous if any */ adr = mail_newaddr (); /* instantiate address and parse its fields */ adr->personal = imap_parse_string (stream,txtptr,reply,NIL,NIL,LONGT); adr->adl = imap_parse_string (stream,txtptr,reply,NIL,NIL,LONGT); adr->mailbox = imap_parse_string (stream,txtptr,reply,NIL,NIL,LONGT); adr->host = imap_parse_string (stream,txtptr,reply,NIL,NIL,LONGT); if (**txtptr != ')') { /* handle trailing paren */ sprintf (LOCAL->tmp,"Junk at end of address: %.80s",(char *) *txtptr); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; } else ++*txtptr; /* skip past close paren */ c = **txtptr; /* set up for while test */ /* ignore leading spaces in front of next */ while (c == ' ') c = *++*txtptr; if (!adr->mailbox) { /* end of group? */ /* decrement group if all looks well */ if (ingroup && !(adr->personal || adr->adl || adr->host)) --ingroup; else { if (ingroup) { /* in a group? */ sprintf (LOCAL->tmp,/* yes, must be bad syntax */ "Junk in end of group: pn=%.80s al=%.80s dn=%.80s", adr->personal ? adr->personal : "", adr->adl ? adr->adl : "", adr->host ? adr->host : ""); mm_notify (stream,LOCAL->tmp,WARN); } else mm_notify (stream,"End of group encountered when not in group", WARN); stream->unhealthy = T; mail_free_address (&adr); adr = prev; prev = NIL; } } else if (!adr->host) { /* start of group? */ if (adr->personal || adr->adl) { sprintf (LOCAL->tmp,"Junk in start of group: pn=%.80s al=%.80s", adr->personal ? adr->personal : "", adr->adl ? adr->adl : ""); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; mail_free_address (&adr); adr = prev; prev = NIL; } else ++ingroup; /* in a group now */ } if (adr) { /* good address */ if (!ret) ret = adr; /* if first time note first adr */ /* if previous link new block to it */ if (prev) prev->next = adr; /* flush bogus personal name */ if (LOCAL->loser && adr->personal && strchr (adr->personal,'@')) fs_give ((void **) &adr->personal); } } break; case 'N': /* if NIL */ case 'n': *txtptr += 3; /* bump past NIL */ break; default: sprintf (LOCAL->tmp,"Not an address: %.80s",(char *) *txtptr); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; break; } return ret; } /* IMAP parse flags * Accepts: current message cache * current text pointer * * Updates text pointer */ void imap_parse_flags (MAILSTREAM *stream,MESSAGECACHE *elt, unsigned char **txtptr) { char *flag; char c = '\0'; 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 = T; /* mark have valid flags now */ elt->user_flags = NIL; /* zap old flag values */ elt->seen = elt->deleted = elt->flagged = elt->answered = elt->draft = elt->recent = NIL; while (c != ')') { /* parse list of flags */ /* point at a flag */ while (*(flag = ++*txtptr) == ' '); /* scan for end of flag */ while (**txtptr != ' ' && **txtptr != ')') ++*txtptr; c = **txtptr; /* save delimiter */ **txtptr = '\0'; /* tie off flag */ if (!*flag) break; /* null flag */ /* if starts with \ must be sys flag */ else if (*flag == '\\') { if (!compare_cstring (flag,"\\Seen")) elt->seen = T; else if (!compare_cstring (flag,"\\Deleted")) elt->deleted = T; else if (!compare_cstring (flag,"\\Flagged")) elt->flagged = T; else if (!compare_cstring (flag,"\\Answered")) elt->answered = T; else if (!compare_cstring (flag,"\\Recent")) elt->recent = T; else if (!compare_cstring (flag,"\\Draft")) elt->draft = T; } /* otherwise user flag */ else elt->user_flags |= imap_parse_user_flag (stream,flag); } ++*txtptr; /* bump past delimiter */ if (!old.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); } /* IMAP parse user flag * Accepts: MAIL stream * flag name * Returns: flag bit position */ unsigned long imap_parse_user_flag (MAILSTREAM *stream,char *flag) { long i; /* sniff through all user flags */ for (i = 0; i < NUSERFLAGS; ++i) if (stream->user_flags[i]) if (!compare_cstring (flag,stream->user_flags[i])) return (1 << i); return (unsigned long) 0; /* not found */ } /* IMAP parse atom-string * Accepts: MAIL stream * current text pointer * parsed reply * returned string length * Returns: string * * Updates text pointer */ unsigned char *imap_parse_astring (MAILSTREAM *stream,unsigned char **txtptr, IMAPPARSEDREPLY *reply,unsigned long *len) { unsigned long i; unsigned char c,*s,*ret; /* ignore leading spaces */ for (c = **txtptr; c == ' '; c = *++*txtptr); switch (c) { case '"': /* quoted string? */ case '{': /* literal? */ ret = imap_parse_string (stream,txtptr,reply,NIL,len,NIL); break; default: /* must be atom */ for (c = *(s = *txtptr); /* find end of atom */ c && (c > ' ') && (c != '(') && (c != ')') && (c != '{') && (c != '%') && (c != '*') && (c != '"') && (c != '\\') && (c < 0x80); c = *++*txtptr); if (i = *txtptr - s) { /* atom ends at atom_special */ if (len) *len = i; /* return length of atom */ ret = strncpy ((char *) fs_get (i + 1),s,i); ret[i] = '\0'; /* tie off string */ } else { /* no atom found */ sprintf (LOCAL->tmp,"Not an atom: %.80s",(char *) *txtptr); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; if (len) *len = 0; ret = NIL; } break; } return ret; } /* IMAP parse string * Accepts: MAIL stream * current text pointer * parsed reply * mailgets data * returned string length * filter newline flag * Returns: string * * Updates text pointer */ unsigned char *imap_parse_string (MAILSTREAM *stream,unsigned char **txtptr, IMAPPARSEDREPLY *reply,GETS_DATA *md, unsigned long *len,long flags) { char *st; char *string = NIL; unsigned long i,j,k; int bogon = NIL; unsigned char c = **txtptr; /* sniff at first character */ mailgets_t mg = (mailgets_t) mail_parameters (NIL,GET_GETS,NIL); readprogress_t rp = (readprogress_t) mail_parameters (NIL,GET_READPROGRESS,NIL); /* ignore leading spaces */ while (c == ' ') c = *++*txtptr; st = ++*txtptr; /* remember start of string */ switch (c) { case '"': /* if quoted string */ i = 0; /* initial byte count */ /* search for end of string */ for (c = **txtptr; c != '"'; ++i,c = *++*txtptr) { /* backslash quotes next character */ if (c == '\\') c = *++*txtptr; /* CHAR8 not permitted in quoted string */ if (!bogon && (bogon = (c & 0x80))) { sprintf (LOCAL->tmp,"Invalid CHAR in quoted string: %x", (unsigned int) c); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; } else if (!c) { /* NUL not permitted either */ mm_notify (stream,"Unterminated quoted string",WARN); stream->unhealthy = T; if (len) *len = 0; /* punt, since may be at end of string */ return NIL; } } ++*txtptr; /* bump past delimiter */ string = (char *) fs_get ((size_t) i + 1); for (j = 0; j < i; j++) { /* copy the string */ if (*st == '\\') ++st; /* quoted character */ string[j] = *st++; } string[j] = '\0'; /* tie off string */ if (len) *len = i; /* set return value too */ if (md && mg) { /* have special routine to slurp string? */ STRING bs; if (md->first) { /* partial fetch? */ md->first--; /* restore origin octet */ md->last = i; /* number of octets that we got */ } INIT (&bs,mail_string,string,i); (*mg) (mail_read,&bs,i,md); } break; case 'N': /* if NIL */ case 'n': ++*txtptr; /* bump past "I" */ ++*txtptr; /* bump past "L" */ if (len) *len = 0; break; case '{': /* if literal string */ /* get size of string */ if ((i = strtoul (*txtptr,(char **) txtptr,10)) > MAXSERVERLIT) { sprintf (LOCAL->tmp,"Absurd server literal length %lu",i); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; /* read and discard */ do net_getbuffer (LOCAL->netstream,j = min (i,(long) IMAPTMPLEN - 1), LOCAL->tmp); while (i -= j); } if (len) *len = i; /* set return value */ if (md && mg) { /* have special routine to slurp string? */ if (md->first) { /* partial fetch? */ md->first--; /* restore origin octet */ md->last = i; /* number of octets that we got */ } else md->flags |= MG_COPY;/* otherwise flag need to copy */ string = (*mg) (net_getbuffer,LOCAL->netstream,i,md); } else { /* must slurp into free storage */ string = (char *) fs_get ((size_t) i + 1); *string = '\0'; /* init in case getbuffer fails */ /* get the literal */ if (rp) for (k = 0; j = min ((long) MAILTMPLEN,(long) i); i -= j) { net_getbuffer (LOCAL->netstream,j,string + k); (*rp) (md,k += j); } else net_getbuffer (LOCAL->netstream,i,string); } fs_give ((void **) &reply->line); if (flags && string) /* need to filter newlines? */ for (st = string; st = strpbrk (st,"\015\012\011"); *st++ = ' '); /* get new reply text line */ if (!(reply->line = net_getline (LOCAL->netstream))) reply->line = cpystr (""); if (stream->debug) mm_dlog (reply->line); *txtptr = reply->line; /* set text pointer to point at it */ break; default: sprintf (LOCAL->tmp,"Not a string: %c%.80s",c,(char *) *txtptr); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; if (len) *len = 0; break; } return (unsigned char *) string; } /* Register text in IMAP cache * Accepts: MAIL stream * message number * IMAP segment specifier * header string list (if a HEADER section specifier) * sized text to register * Returns: non-zero if cache non-empty */ long imap_cache (MAILSTREAM *stream,unsigned long msgno,char *seg, STRINGLIST *stl,SIZEDTEXT *text) { char *t,tmp[MAILTMPLEN]; unsigned long i; BODY *b; SIZEDTEXT *ret; STRINGLIST *stc; MESSAGECACHE *elt = mail_elt (stream,msgno); /* top-level header never does mailgets */ if (!strcmp (seg,"HEADER") || !strcmp (seg,"0") || !strcmp (seg,"HEADER.FIELDS") || !strcmp (seg,"HEADER.FIELDS.NOT")) { ret = &elt->private.msg.header.text; if (text) { /* don't do this if no text */ if (ret->data) fs_give ((void **) &ret->data); mail_free_stringlist (&elt->private.msg.lines); elt->private.msg.lines = stl; /* prevent cache reuse of .NOT */ if ((seg[0] == 'H') && (seg[6] == '.') && (seg[13] == '.')) for (stc = stl; stc; stc = stc->next) stc->text.size = 0; if (stream->scache) { /* short caching puts it in the stream */ if (stream->msgno != msgno) { /* flush old stuff */ mail_free_envelope (&stream->env); mail_free_body (&stream->body); stream->msgno = msgno; } imap_parse_header (stream,&stream->env,text,stl); } /* regular caching */ else imap_parse_header (stream,&elt->private.msg.env,text,stl); } } /* top level text */ else if (!strcmp (seg,"TEXT")) { ret = &elt->private.msg.text.text; if (text && ret->data) fs_give ((void **) &ret->data); } else if (!*seg) { /* full message */ ret = &elt->private.msg.full.text; if (text && ret->data) fs_give ((void **) &ret->data); } else { /* nested, find non-contents specifier */ for (t = seg; *t && !((*t == '.') && (isalpha(t[1]) || !atol (t+1))); t++); if (*t) *t++ = '\0'; /* tie off section from data specifier */ if (!(b = mail_body (stream,msgno,seg))) { sprintf (tmp,"Unknown section number: %.80s",seg); mm_notify (stream,tmp,WARN); stream->unhealthy = T; return NIL; } if (*t) { /* if a non-numberic subpart */ if ((i = (b->type == TYPEMESSAGE) && (!strcmp (b->subtype,"RFC822"))) && (!strcmp (t,"HEADER") || !strcmp (t,"0") || !strcmp (t,"HEADER.FIELDS") || !strcmp (t,"HEADER.FIELDS.NOT"))) { ret = &b->nested.msg->header.text; if (text) { if (ret->data) fs_give ((void **) &ret->data); mail_free_stringlist (&b->nested.msg->lines); b->nested.msg->lines = stl; /* prevent cache reuse of .NOT */ if ((t[0] == 'H') && (t[6] == '.') && (t[13] == '.')) for (stc = stl; stc; stc = stc->next) stc->text.size = 0; imap_parse_header (stream,&b->nested.msg->env,text,stl); } } else if (i && !strcmp (t,"TEXT")) { ret = &b->nested.msg->text.text; if (text && ret->data) fs_give ((void **) &ret->data); } /* otherwise it must be MIME */ else if (!strcmp (t,"MIME")) { ret = &b->mime.text; if (text && ret->data) fs_give ((void **) &ret->data); } else { sprintf (tmp,"Unknown section specifier: %.80s.%.80s",seg,t); mm_notify (stream,tmp,WARN); stream->unhealthy = T; return NIL; } } else { /* ordinary contents */ ret = &b->contents.text; if (text && ret->data) fs_give ((void **) &ret->data); } } if (text) { /* update cache if requested */ ret->data = text->data; ret->size = text->size; } return ret->data ? LONGT : NIL; } /* IMAP parse body structure * Accepts: MAIL stream * body structure to write into * current text pointer * parsed reply * * Updates text pointer */ void imap_parse_body_structure (MAILSTREAM *stream,BODY *body, unsigned char **txtptr,IMAPPARSEDREPLY *reply) { int i; char *s; PART *part = NIL; char c = *((*txtptr)++); /* grab first character */ /* ignore leading spaces */ while (c == ' ') c = *((*txtptr)++); switch (c) { /* dispatch on first character */ case '(': /* body structure list */ if (**txtptr == '(') { /* multipart body? */ body->type= TYPEMULTIPART;/* yes, set its type */ do { /* instantiate new body part */ if (part) part = part->next = mail_newbody_part (); else body->nested.part = part = mail_newbody_part (); /* parse it */ imap_parse_body_structure (stream,&part->body,txtptr,reply); } while (**txtptr == '(');/* for each body part */ if (body->subtype = imap_parse_string(stream,txtptr,reply,NIL,NIL,LONGT)) ucase (body->subtype); else { mm_notify (stream,"Missing multipart subtype",WARN); stream->unhealthy = T; body->subtype = cpystr (rfc822_default_subtype (body->type)); } if (**txtptr == ' ') /* multipart parameters */ body->parameter = imap_parse_body_parameter (stream,txtptr,reply); if (**txtptr == ' ') { /* disposition */ imap_parse_disposition (stream,body,txtptr,reply); if (LOCAL->cap.extlevel < BODYEXTDSP) LOCAL->cap.extlevel = BODYEXTDSP; } if (**txtptr == ' ') { /* language */ body->language = imap_parse_language (stream,txtptr,reply); if (LOCAL->cap.extlevel < BODYEXTLANG) LOCAL->cap.extlevel = BODYEXTLANG; } if (**txtptr == ' ') { /* location */ body->location = imap_parse_string (stream,txtptr,reply,NIL,NIL,LONGT); if (LOCAL->cap.extlevel < BODYEXTLOC) LOCAL->cap.extlevel = BODYEXTLOC; } while (**txtptr == ' ') imap_parse_extension (stream,txtptr,reply); if (**txtptr != ')') { /* validate ending */ sprintf (LOCAL->tmp,"Junk at end of multipart body: %.80s", (char *) *txtptr); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; } else ++*txtptr; /* skip past delimiter */ } else { /* not multipart, parse type name */ if (**txtptr == ')') { /* empty body? */ ++*txtptr; /* bump past it */ break; /* and punt */ } body->type = TYPEOTHER; /* assume unknown type */ body->encoding = ENCOTHER;/* and unknown encoding */ /* parse type */ if (s = imap_parse_string (stream,txtptr,reply,NIL,NIL,LONGT)) { ucase (s); /* application always gets uppercase form */ for (i = 0; /* look in existing table */ (i <= TYPEMAX) && body_types[i] && strcmp (s,body_types[i]); i++); if (i <= TYPEMAX) { /* only if found a slot */ body->type = i; /* set body type */ if (body_types[i]) fs_give ((void **) &s); else body_types[i]=s; /* assign empty slot */ } } if (body->subtype = imap_parse_string(stream,txtptr,reply,NIL,NIL,LONGT)) ucase (body->subtype); /* parse subtype */ else { mm_notify (stream,"Missing body subtype",WARN); stream->unhealthy = T; body->subtype = cpystr (rfc822_default_subtype (body->type)); } body->parameter = imap_parse_body_parameter (stream,txtptr,reply); body->id = imap_parse_string (stream,txtptr,reply,NIL,NIL,LONGT); body->description = imap_parse_string (stream,txtptr,reply,NIL,NIL, LONGT); if (s = imap_parse_string (stream,txtptr,reply,NIL,NIL,LONGT)) { ucase (s); /* application always gets uppercase form */ for (i = 0; /* search for body encoding */ (i <= ENCMAX) && body_encodings[i] && strcmp(s,body_encodings[i]); i++); if (i > ENCMAX) body->encoding = ENCOTHER; else { /* only if found a slot */ body->encoding = i; /* set body encoding */ if (body_encodings[i]) fs_give ((void **) &s); /* assign empty slot */ else body_encodings[i] = s; } } /* parse size of contents in bytes */ body->size.bytes = strtoul (*txtptr,(char **) txtptr,10); switch (body->type) { /* possible extra stuff */ case TYPEMESSAGE: /* message envelope and body */ /* non MESSAGE/RFC822 is basic type */ if (strcmp (body->subtype,"RFC822")) break; { /* make certain server sends an envelope */ ENVELOPE *env = NIL; imap_parse_envelope (stream,&env,txtptr,reply); if (!env) { mm_notify (stream,"Missing body message envelope",WARN); stream->unhealthy = T; body->subtype = cpystr ("RFC822_MISSING_ENVELOPE"); break; } (body->nested.msg = mail_newmsg ())->env = env; } body->nested.msg->body = mail_newbody (); imap_parse_body_structure (stream,body->nested.msg->body,txtptr,reply); /* drop into text case */ case TYPETEXT: /* size in lines */ body->size.lines = strtoul (*txtptr,(char **) txtptr,10); break; default: /* otherwise nothing special */ break; } if (**txtptr == ' ') { /* extension data - md5 */ body->md5 = imap_parse_string (stream,txtptr,reply,NIL,NIL,LONGT); if (LOCAL->cap.extlevel < BODYEXTMD5) LOCAL->cap.extlevel = BODYEXTMD5; } if (**txtptr == ' ') { /* disposition */ imap_parse_disposition (stream,body,txtptr,reply); if (LOCAL->cap.extlevel < BODYEXTDSP) LOCAL->cap.extlevel = BODYEXTDSP; } if (**txtptr == ' ') { /* language */ body->language = imap_parse_language (stream,txtptr,reply); if (LOCAL->cap.extlevel < BODYEXTLANG) LOCAL->cap.extlevel = BODYEXTLANG; } if (**txtptr == ' ') { /* location */ body->location = imap_parse_string (stream,txtptr,reply,NIL,NIL,LONGT); if (LOCAL->cap.extlevel < BODYEXTLOC) LOCAL->cap.extlevel = BODYEXTLOC; } while (**txtptr == ' ') imap_parse_extension (stream,txtptr,reply); if (**txtptr != ')') { /* validate ending */ sprintf (LOCAL->tmp,"Junk at end of body part: %.80s", (char *) *txtptr); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; } else ++*txtptr; /* skip past delimiter */ } break; case 'N': /* if NIL */ case 'n': ++*txtptr; /* bump past "I" */ ++*txtptr; /* bump past "L" */ break; default: /* otherwise quite bogus */ sprintf (LOCAL->tmp,"Bogus body structure: %.80s",(char *) *txtptr); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; break; } } /* IMAP parse body parameter * Accepts: MAIL stream * current text pointer * parsed reply * Returns: body parameter * Updates text pointer */ PARAMETER *imap_parse_body_parameter (MAILSTREAM *stream, unsigned char **txtptr, IMAPPARSEDREPLY *reply) { PARAMETER *ret = NIL; PARAMETER *par = NIL; char c,*s; /* ignore leading spaces */ while ((c = *(*txtptr)++) == ' '); /* parse parameter list */ if (c == '(') while (c != ')') { /* append new parameter to tail */ if (ret) par = par->next = mail_newbody_parameter (); else ret = par = mail_newbody_parameter (); if(!(par->attribute=imap_parse_string (stream,txtptr,reply,NIL,NIL, LONGT))) { mm_notify (stream,"Missing parameter attribute",WARN); stream->unhealthy = T; par->attribute = cpystr ("UNKNOWN"); } if (!(par->value = imap_parse_string (stream,txtptr,reply,NIL,NIL,LONGT))){ sprintf (LOCAL->tmp,"Missing value for parameter %.80s",par->attribute); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; par->value = cpystr ("UNKNOWN"); } switch (c = **txtptr) { /* see what comes after */ case ' ': /* flush whitespace */ while ((c = *++*txtptr) == ' '); break; case ')': /* end of attribute/value pairs */ ++*txtptr; /* skip past closing paren */ break; default: sprintf (LOCAL->tmp,"Junk at end of parameter: %.80s",(char *) *txtptr); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; break; } } /* empty parameter, must be NIL */ else if (((c == 'N') || (c == 'n')) && ((*(s = *txtptr) == 'I') || (*s == 'i')) && ((s[1] == 'L') || (s[1] == 'l'))) *txtptr += 2; else { sprintf (LOCAL->tmp,"Bogus body parameter: %c%.80s",c, (char *) (*txtptr) - 1); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; } return ret; } /* IMAP parse body disposition * Accepts: MAIL stream * body structure to write into * current text pointer * parsed reply */ void imap_parse_disposition (MAILSTREAM *stream,BODY *body, unsigned char **txtptr,IMAPPARSEDREPLY *reply) { switch (*++*txtptr) { case '(': ++*txtptr; /* skip open paren */ body->disposition.type = imap_parse_string (stream,txtptr,reply,NIL,NIL, LONGT); body->disposition.parameter = imap_parse_body_parameter (stream,txtptr,reply); if (**txtptr != ')') { /* validate ending */ sprintf (LOCAL->tmp,"Junk at end of disposition: %.80s", (char *) *txtptr); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; } else ++*txtptr; /* skip past delimiter */ break; case 'N': /* if NIL */ case 'n': ++*txtptr; /* bump past "N" */ ++*txtptr; /* bump past "I" */ ++*txtptr; /* bump past "L" */ break; default: sprintf (LOCAL->tmp,"Unknown body disposition: %.80s",(char *) *txtptr); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; /* try to skip to next space */ while ((*++*txtptr != ' ') && (**txtptr != ')') && **txtptr); break; } } /* IMAP parse body language * Accepts: MAIL stream * current text pointer * parsed reply * Returns: string list or NIL if empty or error */ STRINGLIST *imap_parse_language (MAILSTREAM *stream,unsigned char **txtptr, IMAPPARSEDREPLY *reply) { unsigned long i; char *s; STRINGLIST *ret = NIL; /* language is a list */ if (*++*txtptr == '(') ret = imap_parse_stringlist (stream,txtptr,reply); else if (s = imap_parse_string (stream,txtptr,reply,NIL,&i,LONGT)) { (ret = mail_newstringlist ())->text.data = (unsigned char *) s; ret->text.size = i; } return ret; } /* IMAP parse string list * Accepts: MAIL stream * current text pointer * parsed reply * Returns: string list or NIL if empty or error */ STRINGLIST *imap_parse_stringlist (MAILSTREAM *stream,unsigned char **txtptr, IMAPPARSEDREPLY *reply) { STRINGLIST *stl = NIL; STRINGLIST *stc = NIL; unsigned char *t = *txtptr; /* parse the list */ if (*t++ == '(') while (*t != ')') { if (stl) stc = stc->next = mail_newstringlist (); else stc = stl = mail_newstringlist (); /* parse astring */ if (!(stc->text.data = imap_parse_astring (stream,&t,reply,&stc->text.size))) { sprintf (LOCAL->tmp,"Bogus string list member: %.80s",(char *) t); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; mail_free_stringlist (&stl); break; } else if (*t == ' ') ++t; /* another token follows */ } if (stl) *txtptr = ++t; /* update return string */ return stl; } /* IMAP parse unknown body extension data * Accepts: MAIL stream * current text pointer * parsed reply * * Updates text pointer */ void imap_parse_extension (MAILSTREAM *stream,unsigned char **txtptr, IMAPPARSEDREPLY *reply) { unsigned long i,j; switch (*++*txtptr) { /* action depends upon first character */ case '(': while (**txtptr != ')') imap_parse_extension (stream,txtptr,reply); ++*txtptr; /* bump past closing parenthesis */ break; case '"': /* if quoted string */ while (*++*txtptr != '"') if (**txtptr == '\\') ++*txtptr; ++*txtptr; /* bump past closing quote */ break; case 'N': /* if NIL */ case 'n': ++*txtptr; /* bump past "N" */ ++*txtptr; /* bump past "I" */ ++*txtptr; /* bump past "L" */ break; case '{': /* get size of literal */ ++*txtptr; /* bump past open squiggle */ if (i = strtoul (*txtptr,(char **) txtptr,10)) do net_getbuffer (LOCAL->netstream,j = min (i,(long) IMAPTMPLEN - 1), LOCAL->tmp); while (i -= j); /* get new reply text line */ if (!(reply->line = net_getline (LOCAL->netstream))) reply->line = cpystr (""); if (stream->debug) mm_dlog (reply->line); *txtptr = reply->line; /* set text pointer to point at it */ break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': strtoul (*txtptr,(char **) txtptr,10); break; default: sprintf (LOCAL->tmp,"Unknown extension token: %.80s",(char *) *txtptr); mm_notify (stream,LOCAL->tmp,WARN); stream->unhealthy = T; /* try to skip to next space */ while ((*++*txtptr != ' ') && (**txtptr != ')') && **txtptr); break; } } /* IMAP parse capabilities * Accepts: MAIL stream * capability list */ void imap_parse_capabilities (MAILSTREAM *stream,char *t) { char *s,*r; unsigned long i; THREADER *thr,*th; if (!LOCAL->gotcapability) { /* need to save previous capabilities? */ /* no, flush threaders */ if (thr = LOCAL->cap.threader) while (th = thr) { fs_give ((void **) &th->name); thr = th->next; fs_give ((void **) &th); } /* zap capabilities */ memset (&LOCAL->cap,0,sizeof (LOCAL->cap)); LOCAL->gotcapability = T; /* flag that capabilities arrived */ } for (t = strtok_r (t," ",&r); t; t = strtok_r (NIL," ",&r)) { if (!compare_cstring (t,"IMAP4")) LOCAL->cap.imap4 = LOCAL->cap.imap2bis = LOCAL->cap.rfc1176 = T; else if (!compare_cstring (t,"IMAP4rev1")) LOCAL->cap.imap4rev1 = LOCAL->cap.imap2bis = LOCAL->cap.rfc1176 = T; else if (!compare_cstring (t,"IMAP2")) LOCAL->cap.rfc1176 = T; else if (!compare_cstring (t,"IMAP2bis")) LOCAL->cap.imap2bis = LOCAL->cap.rfc1176 = T; else if (!compare_cstring (t,"ACL")) LOCAL->cap.acl = T; else if (!compare_cstring (t,"QUOTA")) LOCAL->cap.quota = T; else if (!compare_cstring (t,"LITERAL+")) LOCAL->cap.litplus = T; else if (!compare_cstring (t,"IDLE")) LOCAL->cap.idle = T; else if (!compare_cstring (t,"MAILBOX-REFERRALS")) LOCAL->cap.mbx_ref = T; else if (!compare_cstring (t,"LOGIN-REFERRALS")) LOCAL->cap.log_ref = T; else if (!compare_cstring (t,"NAMESPACE")) LOCAL->cap.namespace = T; else if (!compare_cstring (t,"UIDPLUS")) LOCAL->cap.uidplus = T; else if (!compare_cstring (t,"STARTTLS")) LOCAL->cap.starttls = T; else if (!compare_cstring (t,"LOGINDISABLED"))LOCAL->cap.logindisabled = T; else if (!compare_cstring (t,"ID")) LOCAL->cap.id = T; else if (!compare_cstring (t,"CHILDREN")) LOCAL->cap.children = T; else if (!compare_cstring (t,"MULTIAPPEND")) LOCAL->cap.multiappend = T; else if (!compare_cstring (t,"BINARY")) LOCAL->cap.binary = T; else if (!compare_cstring (t,"UNSELECT")) LOCAL->cap.unselect = T; else if (!compare_cstring (t,"SASL-IR")) LOCAL->cap.sasl_ir = T; else if (!compare_cstring (t,"SCAN")) LOCAL->cap.scan = T; else if (!compare_cstring (t,"URLAUTH")) LOCAL->cap.urlauth = T; else if (!compare_cstring (t,"CATENATE")) LOCAL->cap.catenate = T; else if (!compare_cstring (t,"CONDSTORE")) LOCAL->cap.condstore = T; else if (!compare_cstring (t,"ESEARCH")) LOCAL->cap.esearch = T; else if (((t[0] == 'S') || (t[0] == 's')) && ((t[1] == 'O') || (t[1] == 'o')) && ((t[2] == 'R') || (t[2] == 'r')) && ((t[3] == 'T') || (t[3] == 't'))) LOCAL->cap.sort = T; /* capability with value? */ else if (s = strchr (t,'=')) { *s++ = '\0'; /* separate token from value */ if (!compare_cstring (t,"THREAD") && !LOCAL->loser) { THREADER *thread = (THREADER *) fs_get (sizeof (THREADER)); thread->name = cpystr (s); thread->dispatch = NIL; thread->next = LOCAL->cap.threader; LOCAL->cap.threader = thread; } else if (!compare_cstring (t,"AUTH")) { if ((i = mail_lookup_auth_name (s,LOCAL->authflags)) && (--i < MAXAUTHENTICATORS)) LOCAL->cap.auth |= (1 << i); else if (!compare_cstring (s,"ANONYMOUS")) LOCAL->cap.authanon = T; } } /* ignore other capabilities */ } /* disable LOGIN if PLAIN also advertised */ if ((i = mail_lookup_auth_name ("PLAIN",NIL)) && (--i < MAXAUTHENTICATORS) && (LOCAL->cap.auth & (1 << i)) && (i = mail_lookup_auth_name ("LOGIN",NIL)) && (--i < MAXAUTHENTICATORS)) LOCAL->cap.auth &= ~(1 << i); } /* IMAP load cache * Accepts: MAIL stream * sequence * flags * Returns: parsed reply from fetch */ IMAPPARSEDREPLY *imap_fetch (MAILSTREAM *stream,char *sequence,long flags) { int i = 2; char *cmd = (LEVELIMAP4 (stream) && (flags & FT_UID)) ? "UID FETCH" : "FETCH"; IMAPARG *args[9],aseq,aarg,aenv,ahhr,axtr,ahtr,abdy,atrl; if (LOCAL->loser) sequence = imap_reform_sequence (stream,sequence, flags & FT_UID); args[0] = &aseq; aseq.type = SEQUENCE; aseq.text = (void *) sequence; args[1] = &aarg; aarg.type = ATOM; aenv.type = ATOM; aenv.text = (void *) "ENVELOPE"; ahhr.type = ATOM; ahhr.text = (void *) hdrheader[LOCAL->cap.extlevel]; axtr.type = ATOM; axtr.text = (void *) imap_extrahdrs; ahtr.type = ATOM; ahtr.text = (void *) hdrtrailer; abdy.type = ATOM; abdy.text = (void *) "BODYSTRUCTURE"; atrl.type = ATOM; atrl.text = (void *) "INTERNALDATE RFC822.SIZE FLAGS)"; if (LEVELIMAP4 (stream)) { /* include UID if IMAP4 or IMAP4rev1 */ aarg.text = (void *) "(UID"; if (flags & FT_NEEDENV) { /* if need envelopes */ args[i++] = &aenv; /* include envelope */ /* extra header poop if IMAP4rev1 */ if (!(flags & FT_NOHDRS) && LEVELIMAP4rev1 (stream)) { args[i++] = &ahhr; /* header header */ if (axtr.text) args[i++] = &axtr; args[i++] = &ahtr; /* header trailer */ } /* fetch body if requested */ if (flags & FT_NEEDBODY) args[i++] = &abdy; } args[i++] = &atrl; /* fetch trailer */ } /* easy if IMAP2 */ else aarg.text = (void *) (flags & FT_NEEDENV) ? ((flags & FT_NEEDBODY) ? "(RFC822.HEADER BODY INTERNALDATE RFC822.SIZE FLAGS)" : "(RFC822.HEADER INTERNALDATE RFC822.SIZE FLAGS)") : "FAST"; args[i] = NIL; /* tie off command */ return imap_send (stream,cmd,args); } /* Reform sequence for losing server that doesn't handle ranges right * Accepts: MAIL stream * sequence * non-zero if UID * Returns: sequence */ char *imap_reform_sequence (MAILSTREAM *stream,char *sequence,long flags) { unsigned long i,j,star; char *s,*t,*tl,*rs; /* can't win if empty */ if (!stream->nmsgs) return sequence; /* get highest possible range value */ star = flags ? mail_uid (stream,stream->nmsgs) : stream->nmsgs; /* flush old reformed sequence */ if (LOCAL->reform) fs_give ((void **) &LOCAL->reform); rs = LOCAL->reform = (char *) fs_get (1+ strlen (sequence)); for (s = sequence; t = strpbrk (s,",:"); ) switch (*t++) { case ',': /* single message */ strncpy (rs,s,i = t - s); /* copy string up to that point */ rs += i; /* advance destination pointer */ s += i; /* and source */ break; case ':': /* message range */ i = (*s == '*') ? star : strtoul (s,NIL,10); if (*t == '*') { /* range ends with star */ j = star; tl = t+1; } else { /* numeric range end */ j = strtoul (t,(char **) &tl,10); if (!tl) tl = t + strlen (t); } if (i <= j) { /* if first less than second */ if (*tl) tl++; /* skip past end of range if present */ strncpy (rs,s,i = tl - s);/* copy string up to that point */ rs += i; /* advance destination and source pointers */ s += i; } else { /* here's the workaround for losing servers */ strncpy (rs,t,i = tl - t);/* swap the order */ rs[i] = ':'; /* delimit */ strncpy (rs+i+1,s,j = (t-1) - s); rs += i + 1 + j; /* advance destination pointer */ if (*tl) *rs++ = *tl++; /* write trailing delimiter if present */ s = tl; /* advance source pointer */ } } if (*s) strcpy (rs,s); /* write remainder of sequence */ else *rs = '\0'; /* tie off string */ return LOCAL->reform; } /* IMAP return host name * Accepts: MAIL stream * Returns: host name */ char *imap_host (MAILSTREAM *stream) { if (stream->dtb != &imapdriver) fatal ("imap_host called on non-IMAP stream!"); /* return host name on stream if open */ return (LOCAL && LOCAL->netstream) ? net_host (LOCAL->netstream) : ".NO-IMAP-CONNECTION."; } /* IMAP return IMAP capability structure * Accepts: MAIL stream * Returns: IMAP capability structure */ IMAPCAP *imap_cap (MAILSTREAM *stream) { if (stream->dtb != &imapdriver) fatal ("imap_cap called on non-IMAP stream!"); return &LOCAL->cap; /* return capability structure */ }