/* ========================================================================
 * 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 */
}
