install/uw-imap-2007f
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
22f316e36dc00e445408f7a47750b7fa9c3ce369
uw-imap-2007f/src/c-client/imap4r1.c
Chris 22f316e36d Source from upstream; imap-2007f.tar.gz 
MD5 2126fd125ea26b73b20f01fcd5940369
2019-01-03 04:12:17 -06:00

5671 lines
193 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* ========================================================================
* 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;
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 */
}
Reference in New Issue View Git Blame Copy Permalink