Initial Alpine Version

36 files changed, 27616 insertions, 0 deletions

diff --git a/imap/src/c-client/auth_ext.c b/imap/src/c-client/auth_ext.c
new file mode 100644
index 00000000..61dfc1b8
--- /dev/null
+++ b/imap/src/c-client/auth_ext.c
@@ -0,0 +1,96 @@
+/* ========================================================================
+ * Copyright 1988-2006 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:	EXTERNAL authenticator
+ *
+ * Author:	Mark Crispin
+ *		Networks and Distributed Computing
+ *		Computing & Communications
+ *		University of Washington
+ *		Administration Building, AG-44
+ *		Seattle, WA  98195
+ *		Internet: MRC@CAC.Washington.EDU
+ *
+ * Date:	6 April 2005
+ * Last Edited:	30 August 2006
+ */
+
+long auth_external_client (authchallenge_t challenger,authrespond_t responder,
+			  char *service,NETMBX *mb,void *stream,
+			  unsigned long *trial,char *user);
+char *auth_external_server (authresponse_t responder,int argc,char *argv[]);
+
+AUTHENTICATOR auth_ext = {	/* secure, has full auth, hidden */
+  AU_SECURE | AU_AUTHUSER | AU_HIDE,
+  "EXTERNAL",			/* authenticator name */
+  NIL,				/* always valid */
+  auth_external_client,		/* client method */
+  auth_external_server,		/* server method */
+  NIL				/* next authenticator */
+};
+
+/* Client authenticator
+ * Accepts: challenger function
+ *	   responder function
+ *	   SASL service name
+ *	   parsed network mailbox structure
+ *	   stream argument for functions
+ *	   pointer to current trial count
+ *	   returned user name
+ * Returns: T if success, NIL otherwise, number of trials incremented if retry
+ */
+
+long auth_external_client (authchallenge_t challenger,authrespond_t responder,
+			  char *service,NETMBX *mb,void *stream,
+			  unsigned long *trial,char *user)
+{
+  void *challenge;
+  unsigned long clen;
+  long ret = NIL;
+  *trial = 65535;		/* never retry */
+  if (challenge = (*challenger) (stream,&clen)) {
+    fs_give ((void **) &challenge);
+				/* send authorization id (empty string OK) */
+    if ((*responder) (stream,strcpy (user,mb->user),strlen (mb->user))) {
+      if (challenge = (*challenger) (stream,&clen))
+	fs_give ((void **) &challenge);
+      else ret = LONGT;		/* check the authentication */
+    }
+  }
+  return ret;
+}
+
+
+/* Server authenticator
+ * Accepts: responder function
+ *	    argument count
+ *	    argument vector
+ * Returns: authenticated user name or NIL
+ */
+
+char *auth_external_server (authresponse_t responder,int argc,char *argv[])
+{
+  unsigned long len;
+  char *authid;
+  char *authenid = (char *) mail_parameters (NIL,GET_EXTERNALAUTHID,NIL);
+  char *ret = NIL;
+				/* get authorization identity */
+  if (authenid && (authid = (*responder) ("",0,&len))) {
+				/* note: responders null-terminate */
+    if (*authid ? authserver_login (authid,authenid,argc,argv) :
+	authserver_login (authenid,NIL,argc,argv)) ret = myusername ();
+    fs_give ((void **) &authid);
+  }
+  return ret;
+}
diff --git a/imap/src/c-client/auth_gss.c b/imap/src/c-client/auth_gss.c
new file mode 100644
index 00000000..26bf9e50
--- /dev/null
+++ b/imap/src/c-client/auth_gss.c
@@ -0,0 +1,423 @@
+/* ========================================================================
+ * Copyright 1988-2006 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:	GSSAPI authenticator
+ *
+ * Author:	Mark Crispin
+ *		Networks and Distributed Computing
+ *		Computing & Communications
+ *		University of Washington
+ *		Administration Building, AG-44
+ *		Seattle, WA  98195
+ *		Internet: MRC@CAC.Washington.EDU
+ *
+ * Date:	12 January 1998
+ * Last Edited:	30 August 2006
+ */
+
+
+long auth_gssapi_valid (void);
+long auth_gssapi_client (authchallenge_t challenger,authrespond_t responder,
+			 char *service,NETMBX *mb,void *stream,
+			 unsigned long *trial,char *user);
+long auth_gssapi_client_work (authchallenge_t challenger,gss_buffer_desc chal,
+			      authrespond_t responder,char *service,NETMBX *mb,
+			      void *stream,char *user,kinit_t ki);
+char *auth_gssapi_server (authresponse_t responder,int argc,char *argv[]);
+
+
+AUTHENTICATOR auth_gss = {
+  AU_SECURE | AU_AUTHUSER,	/* secure authenticator */
+  "GSSAPI",			/* authenticator name */
+  auth_gssapi_valid,		/* check if valid */
+  auth_gssapi_client,		/* client method */
+  auth_gssapi_server,		/* server method */
+  NIL				/* next authenticator */
+};
+
+#define AUTH_GSSAPI_P_NONE 1
+#define AUTH_GSSAPI_P_INTEGRITY 2
+#define AUTH_GSSAPI_P_PRIVACY 4
+
+#define AUTH_GSSAPI_C_MAXSIZE 8192
+
+#define SERVER_LOG(x,y) syslog (LOG_ALERT,x,y)
+
+/* Check if GSSAPI valid on this system
+ * Returns: T if valid, NIL otherwise
+ */
+
+long auth_gssapi_valid (void)
+{
+  char tmp[MAILTMPLEN];
+  OM_uint32 smn;
+  gss_buffer_desc buf;
+  gss_name_t name;
+				/* make service name */
+  sprintf (tmp,"%s@%s",(char *) mail_parameters (NIL,GET_SERVICENAME,NIL),
+	   mylocalhost ());
+  buf.length = strlen (buf.value = tmp);
+				/* see if can build a name */
+  if (gss_import_name (&smn,&buf,GSS_C_NT_HOSTBASED_SERVICE,&name) !=
+      GSS_S_COMPLETE) return NIL;
+				/* remove server method if no keytab */
+  if (!kerberos_server_valid ()) auth_gss.server = NIL;
+  gss_release_name (&smn,&name);/* finished with name */
+  return LONGT;
+}
+
+/* Client authenticator
+ * Accepts: challenger function
+ *	    responder function
+ *	    SASL service name
+ *	    parsed network mailbox structure
+ *	    stream argument for functions
+ *	    pointer to current trial count
+ *	    returned user name
+ * Returns: T if success, NIL otherwise, number of trials incremented if retry
+ */
+
+long auth_gssapi_client (authchallenge_t challenger,authrespond_t responder,
+			 char *service,NETMBX *mb,void *stream,
+			 unsigned long *trial,char *user)
+{
+  gss_buffer_desc chal;
+  kinit_t ki = (kinit_t) mail_parameters (NIL,GET_KINIT,NIL);
+  long ret = NIL;
+  *trial = 65535;		/* never retry */
+				/* get initial (empty) challenge */
+  if (chal.value = (*challenger) (stream,(unsigned long *) &chal.length)) {
+    if (chal.length) {		/* abort if challenge non-empty */
+      mm_log ("Server bug: non-empty initial GSSAPI challenge",WARN);
+      (*responder) (stream,NIL,0);
+      ret = LONGT;		/* will get a BAD response back */
+    }
+    else if (mb->authuser[0] && strcmp (mb->authuser,myusername ())) {
+      mm_log ("Can't use Kerberos: invalid /authuser",WARN);
+      (*responder) (stream,NIL,0);
+      ret = LONGT;		/* will get a BAD response back */
+    }
+    else ret = auth_gssapi_client_work (challenger,chal,responder,service,mb,
+					stream,user,ki);
+  }
+  return ret;
+}
+
+/* Client authenticator worker function
+ * Accepts: challenger function
+ *	    responder function
+ *	    SASL service name
+ *	    parsed network mailbox structure
+ *	    stream argument for functions
+ *	    returned user name
+ *	    kinit function pointer if should retry with kinit
+ * Returns: T if success, NIL otherwise
+ */
+
+long auth_gssapi_client_work (authchallenge_t challenger,gss_buffer_desc chal,
+			      authrespond_t responder,char *service,NETMBX *mb,
+			      void *stream,char *user,kinit_t ki)
+{
+  char tmp[MAILTMPLEN];
+  OM_uint32 smj,smn,dsmj,dsmn;
+  OM_uint32 mctx = 0;
+  gss_ctx_id_t ctx = GSS_C_NO_CONTEXT;
+  gss_buffer_desc resp,buf;
+  long i;
+  int conf;
+  gss_qop_t qop;
+  gss_name_t crname = NIL;
+  blocknotify_t bn = (blocknotify_t) mail_parameters (NIL,GET_BLOCKNOTIFY,NIL);
+  void *data;
+  long ret = NIL;
+  sprintf (tmp,"%s@%s",service,mb->host);
+  buf.length = strlen (buf.value = tmp);
+				/* get service name */
+  if (gss_import_name (&smn,&buf,GSS_C_NT_HOSTBASED_SERVICE,&crname) !=
+       GSS_S_COMPLETE) {
+    mm_log ("Can't import Kerberos service name",WARN);
+    (*responder) (stream,NIL,0);
+  }
+  else {
+    data = (*bn) (BLOCK_SENSITIVE,NIL);
+				/* negotiate with KDC */
+    smj = gss_init_sec_context (&smn,GSS_C_NO_CREDENTIAL,&ctx,crname,NIL,
+				GSS_C_INTEG_FLAG | GSS_C_MUTUAL_FLAG |
+				GSS_C_REPLAY_FLAG,0,GSS_C_NO_CHANNEL_BINDINGS,
+				GSS_C_NO_BUFFER,NIL,&resp,NIL,NIL);
+    (*bn) (BLOCK_NONSENSITIVE,data);
+
+				/* while continuation needed */
+    while (smj == GSS_S_CONTINUE_NEEDED) {
+      if (chal.value) fs_give ((void **) &chal.value);
+				/* send response, get next challenge */
+      i = (*responder) (stream,resp.value,resp.length) &&
+	(chal.value = (*challenger) (stream,(unsigned long *) &chal.length));
+      gss_release_buffer (&smn,&resp);
+      if (i) {			/* negotiate continuation with KDC */
+	data = (*bn) (BLOCK_SENSITIVE,NIL);
+	switch (smj =		/* make sure continuation going OK */
+		gss_init_sec_context (&smn,GSS_C_NO_CREDENTIAL,&ctx,
+				      crname,GSS_C_NO_OID,GSS_C_INTEG_FLAG |
+				      GSS_C_MUTUAL_FLAG | GSS_C_REPLAY_FLAG,0,
+				      GSS_C_NO_CHANNEL_BINDINGS,&chal,NIL,
+				      &resp,NIL,NIL)) {
+	case GSS_S_CONTINUE_NEEDED:
+	case GSS_S_COMPLETE:
+	  break;
+	default:		/* error, don't need context any more */
+	  gss_delete_sec_context (&smn,&ctx,NIL);
+	}
+	(*bn) (BLOCK_NONSENSITIVE,data);
+      }
+      else {			/* error in continuation */
+	mm_log ("Error in negotiating Kerberos continuation",WARN);
+	(*responder) (stream,NIL,0);
+				/* don't need context any more */
+	gss_delete_sec_context (&smn,&ctx,NIL);
+	break;
+      }
+    }
+
+    switch (smj) {		/* done - deal with final condition */
+    case GSS_S_COMPLETE:
+      if (chal.value) fs_give ((void **) &chal.value);
+				/* get prot mechanisms and max size */
+      if ((*responder) (stream,resp.value ? resp.value : "",resp.length) &&
+	  (chal.value = (*challenger) (stream,(unsigned long *)&chal.length))&&
+	  (gss_unwrap (&smn,ctx,&chal,&resp,&conf,&qop) == GSS_S_COMPLETE) &&
+	  (resp.length >= 4) && (*((char *) resp.value) & AUTH_GSSAPI_P_NONE)){
+				/* make copy of flags and length */
+	memcpy (tmp,resp.value,4);
+	gss_release_buffer (&smn,&resp);
+				/* no session protection */
+	tmp[0] = AUTH_GSSAPI_P_NONE;
+				/* install user name */
+	strcpy (tmp+4,strcpy (user,mb->user[0] ? mb->user : myusername ()));
+	buf.value = tmp; buf.length = strlen (user) + 4;
+				/* successful negotiation */
+	switch (smj = gss_wrap (&smn,ctx,NIL,qop,&buf,&conf,&resp)) {
+	case GSS_S_COMPLETE:
+	  if ((*responder) (stream,resp.value,resp.length)) ret = T;
+	  gss_release_buffer (&smn,&resp);
+	  break;
+	default:
+	  do switch (dsmj = gss_display_status (&dsmn,smj,GSS_C_GSS_CODE,
+						GSS_C_NO_OID,&mctx,&resp)) {
+	  case GSS_S_COMPLETE:
+	    mctx = 0;
+	  case GSS_S_CONTINUE_NEEDED:
+	    sprintf (tmp,"Unknown gss_wrap failure: %s",(char *) resp.value);
+	    mm_log (tmp,WARN);
+	    gss_release_buffer (&dsmn,&resp);
+	  }
+	  while (dsmj == GSS_S_CONTINUE_NEEDED);
+	  do switch (dsmj = gss_display_status (&dsmn,smn,GSS_C_MECH_CODE,
+						GSS_C_NO_OID,&mctx,&resp)) {
+	  case GSS_S_COMPLETE:
+	  case GSS_S_CONTINUE_NEEDED:
+	    sprintf (tmp,"GSSAPI mechanism status: %s",(char *) resp.value);
+	    mm_log (tmp,WARN);
+	    gss_release_buffer (&dsmn,&resp);
+	  }
+	  while (dsmj == GSS_S_CONTINUE_NEEDED);
+	  (*responder) (stream,NIL,0);
+	}
+      }
+				/* flush final challenge */
+      if (chal.value) fs_give ((void **) &chal.value);
+				/* don't need context any more */
+      gss_delete_sec_context (&smn,&ctx,NIL);
+      break;
+
+    case GSS_S_CREDENTIALS_EXPIRED:
+      if (chal.value) fs_give ((void **) &chal.value);
+				/* retry if application kinits */
+      if (ki && (*ki) (mb->host,"Kerberos credentials expired"))
+	ret = auth_gssapi_client_work (challenger,chal,responder,service,mb,
+				       stream,user,NIL);
+      else {			/* application can't kinit */
+	sprintf (tmp,"Kerberos credentials expired (try running kinit) for %s",
+		 mb->host);
+	mm_log (tmp,WARN);
+	(*responder) (stream,NIL,0);
+      }
+      break;
+    case GSS_S_FAILURE:
+      if (chal.value) fs_give ((void **) &chal.value);
+      do switch (dsmj = gss_display_status (&dsmn,smn,GSS_C_MECH_CODE,
+					    GSS_C_NO_OID,&mctx,&resp)) {
+      case GSS_S_COMPLETE:	/* end of message, can kinit? */
+	if (ki && kerberos_try_kinit (smn) &&
+	    (*ki) (mb->host,(char *) resp.value)) {
+	  gss_release_buffer (&dsmn,&resp);
+	  ret = auth_gssapi_client_work (challenger,chal,responder,service,mb,
+					 stream,user,NIL);
+	  break;		/* done */
+	}
+	else (*responder) (stream,NIL,0);
+      case GSS_S_CONTINUE_NEEDED:
+	sprintf (tmp,kerberos_try_kinit (smn) ?
+		 "Kerberos error: %.80s (try running kinit) for %.80s" :
+		 "GSSAPI failure: %s for %.80s",(char *) resp.value,mb->host);
+	mm_log (tmp,WARN);
+	gss_release_buffer (&dsmn,&resp);
+      } while (dsmj == GSS_S_CONTINUE_NEEDED);
+      break;
+
+    default:			/* miscellaneous errors */
+      if (chal.value) fs_give ((void **) &chal.value);
+      do switch (dsmj = gss_display_status (&dsmn,smj,GSS_C_GSS_CODE,
+					    GSS_C_NO_OID,&mctx,&resp)) {
+      case GSS_S_COMPLETE:
+	mctx = 0;
+      case GSS_S_CONTINUE_NEEDED:
+	sprintf (tmp,"Unknown GSSAPI failure: %s",(char *) resp.value);
+	mm_log (tmp,WARN);
+	gss_release_buffer (&dsmn,&resp);
+      }
+      while (dsmj == GSS_S_CONTINUE_NEEDED);
+      do switch (dsmj = gss_display_status (&dsmn,smn,GSS_C_MECH_CODE,
+					    GSS_C_NO_OID,&mctx,&resp)) {
+      case GSS_S_COMPLETE:
+      case GSS_S_CONTINUE_NEEDED:
+	sprintf (tmp,"GSSAPI mechanism status: %s",(char *) resp.value);
+	mm_log (tmp,WARN);
+	gss_release_buffer (&dsmn,&resp);
+      }
+      while (dsmj == GSS_S_CONTINUE_NEEDED);
+      (*responder) (stream,NIL,0);
+      break;
+    }
+				/* finished with credentials name */
+    if (crname) gss_release_name (&smn,&crname);
+  }
+  return ret;			/* return status */
+}
+
+/* Server authenticator
+ * Accepts: responder function
+ *	    argument count
+ *	    argument vector
+ * Returns: authenticated user name or NIL
+ */
+
+char *auth_gssapi_server (authresponse_t responder,int argc,char *argv[])
+{
+  char *ret = NIL;
+  char tmp[MAILTMPLEN];
+  unsigned long maxsize = htonl (AUTH_GSSAPI_C_MAXSIZE);
+  int conf;
+  OM_uint32 smj,smn,dsmj,dsmn,flags;
+  OM_uint32 mctx = 0;
+  gss_name_t crname,name;
+  gss_OID mech;
+  gss_buffer_desc chal,resp,buf;
+  gss_cred_id_t crd;
+  gss_ctx_id_t ctx = GSS_C_NO_CONTEXT;
+  gss_qop_t qop = GSS_C_QOP_DEFAULT;
+				/* make service name */
+  sprintf (tmp,"%s@%s",(char *) mail_parameters (NIL,GET_SERVICENAME,NIL),
+	   tcp_serverhost ());
+  buf.length = strlen (buf.value = tmp);
+				/* acquire credentials */
+  if ((gss_import_name (&smn,&buf,GSS_C_NT_HOSTBASED_SERVICE,&crname)) ==
+      GSS_S_COMPLETE) {
+    if ((smj = gss_acquire_cred (&smn,crname,0,NIL,GSS_C_ACCEPT,&crd,NIL,NIL))
+	== GSS_S_COMPLETE) {
+      if (resp.value = (*responder) ("",0,(unsigned long *) &resp.length)) {
+	do {			/* negotiate authentication */
+	  smj = gss_accept_sec_context (&smn,&ctx,crd,&resp,
+					GSS_C_NO_CHANNEL_BINDINGS,&name,&mech,
+					&chal,&flags,NIL,NIL);
+				/* don't need response any more */
+	  fs_give ((void **) &resp.value);
+	  switch (smj) {	/* how did it go? */
+	  case GSS_S_COMPLETE:	/* successful */
+	  case GSS_S_CONTINUE_NEEDED:
+	    if (chal.value) {	/* send challenge, get next response */
+	      resp.value = (*responder) (chal.value,chal.length,
+					 (unsigned long *) &resp.length);
+	      gss_release_buffer (&smn,&chal);
+	    }
+	    break;
+	  }
+	}
+	while (resp.value && resp.length && (smj == GSS_S_CONTINUE_NEEDED));
+
+				/* successful exchange? */
+	if ((smj == GSS_S_COMPLETE) &&
+	    (gss_display_name (&smn,name,&buf,&mech) == GSS_S_COMPLETE)) {
+				/* send security and size */
+	  memcpy (resp.value = tmp,(void *) &maxsize,resp.length = 4);
+	  tmp[0] = AUTH_GSSAPI_P_NONE;
+	  if (gss_wrap (&smn,ctx,NIL,qop,&resp,&conf,&chal) == GSS_S_COMPLETE){
+	    resp.value = (*responder) (chal.value,chal.length,
+				       (unsigned long *) &resp.length);
+	    gss_release_buffer (&smn,&chal);
+	    if (gss_unwrap (&smn,ctx,&resp,&chal,&conf,&qop)==GSS_S_COMPLETE) {
+				/* client request valid */
+	      if (chal.value && (chal.length > 4) &&
+		  (chal.length < (MAILTMPLEN - 1)) &&
+		  memcpy (tmp,chal.value,chal.length) &&
+		  (tmp[0] & AUTH_GSSAPI_P_NONE)) {
+				/* tie off authorization ID */
+		tmp[chal.length] = '\0';
+		ret = kerberos_login (tmp+4,buf.value,argc,argv);
+	      }
+				/* done with user name */
+	      gss_release_buffer (&smn,&chal);
+	    }
+				/* finished with response */
+	    fs_give ((void **) &resp.value);
+	  }
+				/* don't need name buffer any more */
+	  gss_release_buffer (&smn,&buf);
+	}
+				/* don't need client name any more */
+	gss_release_name (&smn,&name);
+				/* don't need context any more */
+	if (ctx != GSS_C_NO_CONTEXT) gss_delete_sec_context (&smn,&ctx,NIL);
+      }
+				/* finished with credentials */
+      gss_release_cred (&smn,&crd);
+    }
+
+    else {			/* can't acquire credentials! */
+      if (gss_display_name (&dsmn,crname,&buf,&mech) == GSS_S_COMPLETE)
+	SERVER_LOG ("Failed to acquire credentials for %s",buf.value);
+      if (smj != GSS_S_FAILURE) do
+	switch (dsmj = gss_display_status (&dsmn,smj,GSS_C_GSS_CODE,
+					   GSS_C_NO_OID,&mctx,&resp)) {
+	case GSS_S_COMPLETE:
+	  mctx = 0;
+	case GSS_S_CONTINUE_NEEDED:
+	  SERVER_LOG ("Unknown GSSAPI failure: %s",resp.value);
+	  gss_release_buffer (&dsmn,&resp);
+	}
+      while (dsmj == GSS_S_CONTINUE_NEEDED);
+      do switch (dsmj = gss_display_status (&dsmn,smn,GSS_C_MECH_CODE,
+					    GSS_C_NO_OID,&mctx,&resp)) {
+      case GSS_S_COMPLETE:
+      case GSS_S_CONTINUE_NEEDED:
+	SERVER_LOG ("GSSAPI mechanism status: %s",resp.value);
+	gss_release_buffer (&dsmn,&resp);
+      }
+      while (dsmj == GSS_S_CONTINUE_NEEDED);
+    }
+				/* finished with credentials name */
+    gss_release_name (&smn,&crname);
+  }
+  return ret;			/* return status */
+}
diff --git a/imap/src/c-client/auth_log.c b/imap/src/c-client/auth_log.c
new file mode 100644
index 00000000..1e1b1b5c
--- /dev/null
+++ b/imap/src/c-client/auth_log.c
@@ -0,0 +1,117 @@
+/* ========================================================================
+ * Copyright 1988-2006 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:	Login authenticator
+ *
+ * Author:	Mark Crispin
+ *		Networks and Distributed Computing
+ *		Computing & Communications
+ *		University of Washington
+ *		Administration Building, AG-44
+ *		Seattle, WA  98195
+ *		Internet: MRC@CAC.Washington.EDU
+ *
+ * Date:	5 December 1995
+ * Last Edited:	30 August 2006
+ */
+
+long auth_login_client (authchallenge_t challenger,authrespond_t responder,
+			char *service,NETMBX *mb,void *stream,
+			unsigned long *trial,char *user);
+char *auth_login_server (authresponse_t responder,int argc,char *argv[]);
+
+AUTHENTICATOR auth_log = {
+  AU_HIDE,			/* hidden */
+  "LOGIN",			/* authenticator name */
+  NIL,				/* always valid */
+  auth_login_client,		/* client method */
+  auth_login_server,		/* server method */
+  NIL				/* next authenticator */
+};
+
+#define PWD_USER "User Name"
+#define PWD_PWD "Password"
+
+/* Client authenticator
+ * Accepts: challenger function
+ *	    responder function
+ *	    SASL service name
+ *	    parsed network mailbox structure
+ *	    stream argument for functions
+ *	    pointer to current trial count
+ *	    returned user name
+ * Returns: T if success, NIL otherwise, number of trials incremented if retry
+ */
+
+long auth_login_client (authchallenge_t challenger,authrespond_t responder,
+			char *service,NETMBX *mb,void *stream,
+			unsigned long *trial,char *user)
+{
+  char pwd[MAILTMPLEN];
+  void *challenge;
+  unsigned long clen;
+  long ret = NIL;
+				/* get user name prompt */
+  if (challenge = (*challenger) (stream,&clen)) {
+    fs_give ((void **) &challenge);
+    pwd[0] = NIL;		/* prompt user */
+    mm_login (mb,user,pwd,*trial);
+    if (!pwd[0]) {		/* user requested abort */
+      (*responder) (stream,NIL,0);
+      *trial = 0;		/* cancel subsequent attempts */
+      ret = LONGT;		/* will get a BAD response back */
+    }
+				/* send user name */
+    else if ((*responder) (stream,user,strlen (user)) &&
+	     (challenge = (*challenger) (stream,&clen))) {
+      fs_give ((void **) &challenge);
+				/* send password */
+      if ((*responder) (stream,pwd,strlen (pwd))) {
+	if (challenge = (*challenger) (stream,&clen))
+	  fs_give ((void **) &challenge);
+	else {
+	  ++*trial;		/* can try again if necessary */
+	  ret = LONGT;		/* check the authentication */
+	}
+      }
+    }
+  }
+  memset (pwd,0,MAILTMPLEN);	/* erase password */
+  if (!ret) *trial = 65535;	/* don't retry if bad protocol */
+  return ret;
+}
+
+
+/* Server authenticator
+ * Accepts: responder function
+ *	    argument count
+ *	    argument vector
+ * Returns: authenticated user name or NIL
+ */
+
+char *auth_login_server (authresponse_t responder,int argc,char *argv[])
+{
+  char *ret = NIL;
+  char *user,*pass,*authuser;
+  if (user = (*responder) (PWD_USER,sizeof (PWD_USER),NIL)) {
+    if (pass = (*responder) (PWD_PWD,sizeof (PWD_PWD),NIL)) {
+				/* delimit user from possible admin */
+      if (authuser = strchr (user,'*')) *authuser++ = '\0';
+      if (server_login (user,pass,authuser,argc,argv)) ret = myusername ();
+      fs_give ((void **) &pass);
+    }
+    fs_give ((void **) &user);
+  }
+  return ret;
+}
diff --git a/imap/src/c-client/auth_md5.c b/imap/src/c-client/auth_md5.c
new file mode 100644
index 00000000..29ab947d
--- /dev/null
+++ b/imap/src/c-client/auth_md5.c
@@ -0,0 +1,495 @@
+/* ========================================================================
+ * Copyright 1988-2007 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:	CRAM-MD5 authenticator
+ *
+ * Author:	Mark Crispin
+ *		Networks and Distributed Computing
+ *		Computing & Communications
+ *		University of Washington
+ *		Administration Building, AG-44
+ *		Seattle, WA  98195
+ *		Internet: MRC@CAC.Washington.EDU
+ *
+ * Date:	21 October 1998
+ * Last Edited:	30 January 2007
+ */
+
+/* MD5 context */
+
+#define MD5BLKLEN 64		/* MD5 block length */
+#define MD5DIGLEN 16		/* MD5 digest length */
+
+typedef struct {
+  unsigned long chigh;		/* high 32bits of byte count */
+  unsigned long clow;		/* low 32bits of byte count */
+  unsigned long state[4];	/* state (ABCD) */
+  unsigned char buf[MD5BLKLEN];	/* input buffer */
+  unsigned char *ptr;		/* buffer position */
+} MD5CONTEXT;
+
+
+/* Prototypes */
+
+long auth_md5_valid (void);
+long auth_md5_client (authchallenge_t challenger,authrespond_t responder,
+		      char *service,NETMBX *mb,void *stream,
+		      unsigned long *trial,char *user);
+char *auth_md5_server (authresponse_t responder,int argc,char *argv[]);
+char *auth_md5_pwd (char *user);
+char *apop_login (char *chal,char *user,char *md5,int argc,char *argv[]);
+char *hmac_md5 (char *text,unsigned long tl,char *key,unsigned long kl);
+void md5_init (MD5CONTEXT *ctx);
+void md5_update (MD5CONTEXT *ctx,unsigned char *data,unsigned long len);
+void md5_final (unsigned char *digest,MD5CONTEXT *ctx);
+static void md5_transform (unsigned long *state,unsigned char *block);
+static void md5_encode (unsigned char *dst,unsigned long *src,int len);
+static void md5_decode (unsigned long *dst,unsigned char *src,int len);
+
+
+/* Authenticator linkage */
+
+AUTHENTICATOR auth_md5 = {
+  AU_SECURE,			/* secure authenticator */
+  "CRAM-MD5",			/* authenticator name */
+  auth_md5_valid,		/* check if valid */
+  auth_md5_client,		/* client method */
+  auth_md5_server,		/* server method */
+  NIL				/* next authenticator */
+};
+
+/* Check if CRAM-MD5 valid on this system
+ * Returns: T, always
+ */
+
+long auth_md5_valid (void)
+{
+  struct stat sbuf;
+				/* server forbids MD5 if no MD5 enable file */
+  if (stat (MD5ENABLE,&sbuf)) auth_md5.server = NIL;
+  return T;			/* MD5 is otherwise valid */
+}
+
+
+/* Client authenticator
+ * Accepts: challenger function
+ *	    responder function
+ *	    SASL service name
+ *	    parsed network mailbox structure
+ *	    stream argument for functions
+ *	    pointer to current trial count
+ *	    returned user name
+ * Returns: T if success, NIL otherwise, number of trials incremented if retry
+ */
+
+long auth_md5_client (authchallenge_t challenger,authrespond_t responder,
+		      char *service,NETMBX *mb,void *stream,
+		      unsigned long *trial,char *user)
+{
+  char pwd[MAILTMPLEN];
+  void *challenge;
+  unsigned long clen;
+  long ret = NIL;
+				/* get challenge */
+  if (challenge = (*challenger) (stream,&clen)) {
+    pwd[0] = NIL;		/* prompt user */
+    mm_login (mb,user,pwd,*trial);
+    if (!pwd[0]) {		/* user requested abort */
+      fs_give ((void **) &challenge);
+      (*responder) (stream,NIL,0);
+      *trial = 0;		/* cancel subsequent attempts */
+      ret = LONGT;		/* will get a BAD response back */
+    }
+    else {			/* got password, build response */
+      sprintf (pwd,"%.65s %.33s",user,hmac_md5 (challenge,clen,
+						pwd,strlen (pwd)));
+      fs_give ((void **) &challenge);
+				/* send credentials, allow retry if OK */
+      if ((*responder) (stream,pwd,strlen (pwd))) {
+	if (challenge = (*challenger) (stream,&clen))
+	  fs_give ((void **) &challenge);
+	else {
+	  ++*trial;		/* can try again if necessary */
+	  ret = LONGT;		/* check the authentication */
+	}
+      }
+    }
+  }
+  memset (pwd,0,MAILTMPLEN);	/* erase password in case not overwritten */
+  if (!ret) *trial = 65535;	/* don't retry if bad protocol */
+  return ret;
+}
+
+/* Server authenticator
+ * Accepts: responder function
+ *	    argument count
+ *	    argument vector
+ * Returns: authenticated user name or NIL
+ *
+ * This is much hairier than it needs to be due to the necessary of zapping
+ * the password data.
+ */
+
+static int md5try = MAXLOGINTRIALS;
+
+char *auth_md5_server (authresponse_t responder,int argc,char *argv[])
+{
+  char *ret = NIL;
+  char *p,*u,*user,*authuser,*hash,chal[MAILTMPLEN];
+  unsigned long cl,pl;
+				/* generate challenge */
+  sprintf (chal,"<%lu.%lu@%s>",(unsigned long) getpid (),
+	   (unsigned long) time (0),mylocalhost ());
+				/* send challenge, get user and hash */
+  if (user = (*responder) (chal,cl = strlen (chal),NIL)) {
+				/* got user, locate hash */
+    if (hash = strrchr (user,' ')) {
+      *hash++ = '\0';		/* tie off user */
+				/* see if authentication user */
+      if (authuser = strchr (user,'*')) *authuser++ = '\0';
+				/* get password */
+      if (p = auth_md5_pwd ((authuser && *authuser) ? authuser : user)) {
+	pl = strlen (p);
+	u = (md5try && !strcmp (hash,hmac_md5 (chal,cl,p,pl))) ? user : NIL;
+	memset (p,0,pl);	/* erase sensitive information */
+	fs_give ((void **) &p);	/* flush erased password */
+				/* now log in for real */
+	if (u && authserver_login (u,authuser,argc,argv)) ret = myusername ();
+	else if (md5try) --md5try;
+      }
+    }
+    fs_give ((void **) &user);
+  }
+  if (!ret) sleep (3);		/* slow down possible cracker */
+  return ret;
+}
+
+/* Return MD5 password for user
+ * Accepts: user name
+ * Returns: plaintext password if success, else NIL
+ *
+ * This is much hairier than it needs to be due to the necessary of zapping
+ * the password data.  That's why we don't use stdio here.
+ */
+
+char *auth_md5_pwd (char *user)
+{
+  struct stat sbuf;
+  int fd = open (MD5ENABLE,O_RDONLY,NIL);
+  unsigned char *s,*t,*buf,*lusr,*lret;
+  char *r;
+  char *ret = NIL;
+  if (fd >= 0) {		/* found the file? */
+    fstat (fd,&sbuf);		/* yes, slurp it into memory */
+    read (fd,buf = (char *) fs_get (sbuf.st_size + 1),sbuf.st_size);
+				/* see if any uppercase characters in user */
+    for (s = user; *s && ((*s < 'A') || (*s > 'Z')); s++);
+				/* yes, make lowercase copy */
+    lusr = *s ? lcase (cpystr (user)) : NIL;
+    for (s = strtok_r ((char *) buf,"\015\012",&r),lret = NIL; s;
+	 s = ret ? NIL : strtok_r (NIL,"\015\012",&r))
+				/* must be valid entry line */
+      if (*s && (*s != '#') && (t = strchr (s,'\t')) && t[1]) {
+	*t++ = '\0';		/* found tab, tie off user, point to pwd */
+	if (!strcmp (s,user)) ret = cpystr (t);
+	else if (lusr && !lret) if (!strcmp (s,lusr)) lret = t;
+      }
+				/* accept case-independent name */
+    if (!ret && lret) ret = cpystr (lret);
+				/* don't need lowercase copy any more */
+    if (lusr) fs_give ((void **) &lusr);
+				/* erase sensitive information from buffer */
+    memset (buf,0,sbuf.st_size + 1);
+    fs_give ((void **) &buf);	/* flush the buffer */
+    close (fd);			/* don't need file any longer */
+  }
+  return ret;			/* return password */
+}
+
+/* APOP server login
+ * Accepts: challenge
+ *	    desired user name
+ *	    purported MD5
+ *	    argument count
+ *	    argument vector
+ * Returns: authenticated user name or NIL
+ */
+
+char *apop_login (char *chal,char *user,char *md5,int argc,char *argv[])
+{
+  int i,j;
+  char *ret = NIL;
+  char *s,*authuser,tmp[MAILTMPLEN];
+  unsigned char digest[MD5DIGLEN];
+  MD5CONTEXT ctx;
+  char *hex = "0123456789abcdef";
+				/* see if authentication user */
+  if (authuser = strchr (user,'*')) *authuser++ = '\0';
+				/* get password */
+  if (s = auth_md5_pwd ((authuser && *authuser) ? authuser : user)) {
+    md5_init (&ctx);		/* initialize MD5 context */
+				/* build string to get MD5 digest */
+    sprintf (tmp,"%.128s%.128s",chal,s);
+    memset (s,0,strlen (s));	/* erase sensitive information */
+    fs_give ((void **) &s);	/* flush erased password */
+    md5_update (&ctx,(unsigned char *) tmp,strlen (tmp));
+    memset (tmp,0,MAILTMPLEN);	/* erase sensitive information */
+    md5_final (digest,&ctx);
+				/* convert to printable hex */
+    for (i = 0, s = tmp; i < MD5DIGLEN; i++) {
+      *s++ = hex[(j = digest[i]) >> 4];
+      *s++ = hex[j & 0xf];
+    }
+    *s = '\0';			/* tie off hash text */
+    memset (digest,0,MD5DIGLEN);/* erase sensitive information */
+    if (md5try && !strcmp (md5,tmp) &&
+	authserver_login (user,authuser,argc,argv))
+      ret = cpystr (myusername ());
+    else if (md5try) --md5try;
+    memset (tmp,0,MAILTMPLEN);	/* erase sensitive information */
+  }
+  if (!ret) sleep (3);		/* slow down possible cracker */
+  return ret;
+}
+
+/*
+ * RFC 2104 HMAC hashing
+ * Accepts: text to hash
+ *	    text length
+ *	    key
+ *	    key length
+ * Returns: hash as text, always
+ */
+
+char *hmac_md5 (char *text,unsigned long tl,char *key,unsigned long kl)
+{
+  int i,j;
+  static char hshbuf[2*MD5DIGLEN + 1];
+  char *s;
+  MD5CONTEXT ctx;
+  char *hex = "0123456789abcdef";
+  unsigned char digest[MD5DIGLEN],k_ipad[MD5BLKLEN+1],k_opad[MD5BLKLEN+1];
+  if (kl > MD5BLKLEN) {		/* key longer than pad length? */
+    md5_init (&ctx);		/* yes, set key as MD5(key) */
+    md5_update (&ctx,(unsigned char *) key,kl);
+    md5_final (digest,&ctx);
+    key = (char *) digest;
+    kl = MD5DIGLEN;
+  }
+  memcpy (k_ipad,key,kl);	/* store key in pads */
+  memset (k_ipad+kl,0,(MD5BLKLEN+1)-kl);
+  memcpy (k_opad,k_ipad,MD5BLKLEN+1);
+				/* XOR key with ipad and opad values */
+  for (i = 0; i < MD5BLKLEN; i++) {
+    k_ipad[i] ^= 0x36;
+    k_opad[i] ^= 0x5c;
+  }
+  md5_init (&ctx);		/* inner MD5: hash ipad and text */
+  md5_update (&ctx,k_ipad,MD5BLKLEN);
+  md5_update (&ctx,(unsigned char *) text,tl);
+  md5_final (digest,&ctx);
+  md5_init (&ctx);		/* outer MD5: hash opad and inner results */
+  md5_update (&ctx,k_opad,MD5BLKLEN);
+  md5_update (&ctx,digest,MD5DIGLEN);
+  md5_final (digest,&ctx);
+				/* convert to printable hex */
+  for (i = 0, s = hshbuf; i < MD5DIGLEN; i++) {
+    *s++ = hex[(j = digest[i]) >> 4];
+    *s++ = hex[j & 0xf];
+  }
+  *s = '\0';			/* tie off hash text */
+  return hshbuf;
+}
+
+/* Everything after this point is derived from the RSA Data Security, Inc.
+ * MD5 Message-Digest Algorithm
+ */
+
+/* You may wonder why these strange "a &= 0xffffffff;" statements are here.
+ * This is to ensure correct results on machines with a unsigned long size of
+ * larger than 32 bits.
+ */
+
+#define RND1(a,b,c,d,x,s,ac) \
+ a += ((b & c) | (d & ~b)) + x + (unsigned long) ac; \
+ a &= 0xffffffff; \
+ a = b + ((a << s) | (a >> (32 - s)));
+
+#define RND2(a,b,c,d,x,s,ac) \
+ a += ((b & d) | (c & ~d)) + x + (unsigned long) ac; \
+ a &= 0xffffffff; \
+ a = b + ((a << s) | (a >> (32 - s)));
+
+#define RND3(a,b,c,d,x,s,ac) \
+ a += (b ^ c ^ d) + x + (unsigned long) ac; \
+ a &= 0xffffffff; \
+ a = b + ((a << s) | (a >> (32 - s)));
+
+#define RND4(a,b,c,d,x,s,ac) \
+ a += (c ^ (b | ~d)) + x + (unsigned long) ac; \
+ a &= 0xffffffff; \
+ a = b + ((a << s) | (a >> (32 - s)));
+
+/* Initialize MD5 context
+ * Accepts: context to initialize
+ */
+
+void md5_init (MD5CONTEXT *ctx)
+{
+  ctx->clow = ctx->chigh = 0;	/* initialize byte count to zero */
+				/* initialization constants */
+  ctx->state[0] = 0x67452301; ctx->state[1] = 0xefcdab89;
+  ctx->state[2] = 0x98badcfe; ctx->state[3] = 0x10325476;
+  ctx->ptr = ctx->buf;		/* reset buffer pointer */
+}
+
+
+/* MD5 add data to context
+ * Accepts: context
+ *	    input data
+ *	    length of data
+ */
+
+void md5_update (MD5CONTEXT *ctx,unsigned char *data,unsigned long len)
+{
+  unsigned long i = (ctx->buf + MD5BLKLEN) - ctx->ptr;
+				/* update double precision number of bytes */
+  if ((ctx->clow += len) < len) ctx->chigh++;
+  while (i <= len) {		/* copy/transform data, 64 bytes at a time */
+    memcpy (ctx->ptr,data,i);	/* fill up 64 byte chunk */
+    md5_transform (ctx->state,ctx->ptr = ctx->buf);
+    data += i,len -= i,i = MD5BLKLEN;
+  }
+  memcpy (ctx->ptr,data,len);	/* copy final bit of data in buffer */
+  ctx->ptr += len;		/* update buffer pointer */
+}
+
+/* MD5 Finalization
+ * Accepts: destination digest
+ *	    context
+ */
+
+void md5_final (unsigned char *digest,MD5CONTEXT *ctx)
+{
+  unsigned long i,bits[2];
+  bits[0] = ctx->clow << 3;	/* calculate length in bits (before padding) */
+  bits[1] = (ctx->chigh << 3) + (ctx->clow >> 29);
+  *ctx->ptr++ = 0x80;		/* padding byte */
+  if ((i = (ctx->buf + MD5BLKLEN) - ctx->ptr) < 8) {
+    memset (ctx->ptr,0,i);	/* pad out buffer with zeros */
+    md5_transform (ctx->state,ctx->buf);
+				/* pad out with zeros, leaving 8 bytes */
+    memset (ctx->buf,0,MD5BLKLEN - 8);
+    ctx->ptr = ctx->buf + MD5BLKLEN - 8;
+  }
+  else if (i -= 8) {		/* need to pad this buffer? */
+    memset (ctx->ptr,0,i);	/* yes, pad out with zeros, leaving 8 bytes */
+    ctx->ptr += i;
+  }
+  md5_encode (ctx->ptr,bits,2);	/* make LSB-first length */
+  md5_transform (ctx->state,ctx->buf);
+				/* store state in digest */
+  md5_encode (digest,ctx->state,4);
+				/* erase context */
+  memset (ctx,0,sizeof (MD5CONTEXT));
+}
+
+/* MD5 basic transformation
+ * Accepts: state vector
+ *	    current 64-byte block
+ */
+
+static void md5_transform (unsigned long *state,unsigned char *block)
+{
+  unsigned long a = state[0],b = state[1],c = state[2],d = state[3],x[16];
+  md5_decode (x,block,16);	/* decode into 16 longs */
+				/* round 1 */
+  RND1 (a,b,c,d,x[ 0], 7,0xd76aa478); RND1 (d,a,b,c,x[ 1],12,0xe8c7b756);
+  RND1 (c,d,a,b,x[ 2],17,0x242070db); RND1 (b,c,d,a,x[ 3],22,0xc1bdceee);
+  RND1 (a,b,c,d,x[ 4], 7,0xf57c0faf); RND1 (d,a,b,c,x[ 5],12,0x4787c62a);
+  RND1 (c,d,a,b,x[ 6],17,0xa8304613); RND1 (b,c,d,a,x[ 7],22,0xfd469501);
+  RND1 (a,b,c,d,x[ 8], 7,0x698098d8); RND1 (d,a,b,c,x[ 9],12,0x8b44f7af);
+  RND1 (c,d,a,b,x[10],17,0xffff5bb1); RND1 (b,c,d,a,x[11],22,0x895cd7be);
+  RND1 (a,b,c,d,x[12], 7,0x6b901122); RND1 (d,a,b,c,x[13],12,0xfd987193);
+  RND1 (c,d,a,b,x[14],17,0xa679438e); RND1 (b,c,d,a,x[15],22,0x49b40821);
+				/* round 2 */
+  RND2 (a,b,c,d,x[ 1], 5,0xf61e2562); RND2 (d,a,b,c,x[ 6], 9,0xc040b340);
+  RND2 (c,d,a,b,x[11],14,0x265e5a51); RND2 (b,c,d,a,x[ 0],20,0xe9b6c7aa);
+  RND2 (a,b,c,d,x[ 5], 5,0xd62f105d); RND2 (d,a,b,c,x[10], 9, 0x2441453);
+  RND2 (c,d,a,b,x[15],14,0xd8a1e681); RND2 (b,c,d,a,x[ 4],20,0xe7d3fbc8);
+  RND2 (a,b,c,d,x[ 9], 5,0x21e1cde6); RND2 (d,a,b,c,x[14], 9,0xc33707d6);
+  RND2 (c,d,a,b,x[ 3],14,0xf4d50d87); RND2 (b,c,d,a,x[ 8],20,0x455a14ed);
+  RND2 (a,b,c,d,x[13], 5,0xa9e3e905); RND2 (d,a,b,c,x[ 2], 9,0xfcefa3f8);
+  RND2 (c,d,a,b,x[ 7],14,0x676f02d9); RND2 (b,c,d,a,x[12],20,0x8d2a4c8a);
+				/* round 3 */
+  RND3 (a,b,c,d,x[ 5], 4,0xfffa3942); RND3 (d,a,b,c,x[ 8],11,0x8771f681);
+  RND3 (c,d,a,b,x[11],16,0x6d9d6122); RND3 (b,c,d,a,x[14],23,0xfde5380c);
+  RND3 (a,b,c,d,x[ 1], 4,0xa4beea44); RND3 (d,a,b,c,x[ 4],11,0x4bdecfa9);
+  RND3 (c,d,a,b,x[ 7],16,0xf6bb4b60); RND3 (b,c,d,a,x[10],23,0xbebfbc70);
+  RND3 (a,b,c,d,x[13], 4,0x289b7ec6); RND3 (d,a,b,c,x[ 0],11,0xeaa127fa);
+  RND3 (c,d,a,b,x[ 3],16,0xd4ef3085); RND3 (b,c,d,a,x[ 6],23, 0x4881d05);
+  RND3 (a,b,c,d,x[ 9], 4,0xd9d4d039); RND3 (d,a,b,c,x[12],11,0xe6db99e5);
+  RND3 (c,d,a,b,x[15],16,0x1fa27cf8); RND3 (b,c,d,a,x[ 2],23,0xc4ac5665);
+				/* round 4 */
+  RND4 (a,b,c,d,x[ 0], 6,0xf4292244); RND4 (d,a,b,c,x[ 7],10,0x432aff97);
+  RND4 (c,d,a,b,x[14],15,0xab9423a7); RND4 (b,c,d,a,x[ 5],21,0xfc93a039);
+  RND4 (a,b,c,d,x[12], 6,0x655b59c3); RND4 (d,a,b,c,x[ 3],10,0x8f0ccc92);
+  RND4 (c,d,a,b,x[10],15,0xffeff47d); RND4 (b,c,d,a,x[ 1],21,0x85845dd1);
+  RND4 (a,b,c,d,x[ 8], 6,0x6fa87e4f); RND4 (d,a,b,c,x[15],10,0xfe2ce6e0);
+  RND4 (c,d,a,b,x[ 6],15,0xa3014314); RND4 (b,c,d,a,x[13],21,0x4e0811a1);
+  RND4 (a,b,c,d,x[ 4], 6,0xf7537e82); RND4 (d,a,b,c,x[11],10,0xbd3af235);
+  RND4 (c,d,a,b,x[ 2],15,0x2ad7d2bb); RND4 (b,c,d,a,x[ 9],21,0xeb86d391);
+				/* update state */
+  state[0] += a; state[1] += b; state[2] += c; state[3] += d;
+  memset (x,0,sizeof (x));	/* erase sensitive data */
+}
+
+/* You may wonder why these strange "& 0xff" maskings are here.  This is to
+ * ensure correct results on machines with a char size of larger than 8 bits.
+ * For example, the KCC compiler on the PDP-10 uses 9-bit chars.
+ */
+
+/* MD5 encode unsigned long into LSB-first bytes
+ * Accepts: destination pointer
+ *	    source
+ *	    length of source
+ */ 
+
+static void md5_encode (unsigned char *dst,unsigned long *src,int len)
+{
+  int i;
+  for (i = 0; i < len; i++) {
+    *dst++ = (unsigned char) (src[i] & 0xff);
+    *dst++ = (unsigned char) ((src[i] >> 8) & 0xff);
+    *dst++ = (unsigned char) ((src[i] >> 16) & 0xff);
+    *dst++ = (unsigned char) ((src[i] >> 24) & 0xff);
+  }
+}
+
+
+/* MD5 decode LSB-first bytes into unsigned long
+ * Accepts: destination pointer
+ *	    source
+ *	    length of destination
+ */ 
+
+static void md5_decode (unsigned long *dst,unsigned char *src,int len)
+{
+  int i, j;
+  for (i = 0, j = 0; i < len; i++, j += 4)
+    dst[i] = ((unsigned long) (src[j] & 0xff)) |
+      (((unsigned long) (src[j+1] & 0xff)) << 8) |
+      (((unsigned long) (src[j+2] & 0xff)) << 16) |
+	(((unsigned long) (src[j+3] & 0xff)) << 24);
+}
diff --git a/imap/src/c-client/auth_pla.c b/imap/src/c-client/auth_pla.c
new file mode 100644
index 00000000..73ca2259
--- /dev/null
+++ b/imap/src/c-client/auth_pla.c
@@ -0,0 +1,133 @@
+/* ========================================================================
+ * Copyright 1988-2006 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:	Plain authenticator
+ *
+ * Author:	Mark Crispin
+ *		Networks and Distributed Computing
+ *		Computing & Communications
+ *		University of Washington
+ *		Administration Building, AG-44
+ *		Seattle, WA  98195
+ *		Internet: MRC@CAC.Washington.EDU
+ *
+ * Date:	22 September 1998
+ * Last Edited:	30 August 2006
+ */
+
+long auth_plain_client (authchallenge_t challenger,authrespond_t responder,
+			char *service,NETMBX *mb,void *stream,
+			unsigned long *trial,char *user);
+char *auth_plain_server (authresponse_t responder,int argc,char *argv[]);
+
+AUTHENTICATOR auth_pla = {
+  AU_AUTHUSER | AU_HIDE,	/* allow authuser, hidden */
+  "PLAIN",			/* authenticator name */
+  NIL,				/* always valid */
+  auth_plain_client,		/* client method */
+  auth_plain_server,		/* server method */
+  NIL				/* next authenticator */
+};
+
+/* Client authenticator
+ * Accepts: challenger function
+ *	    responder function
+ *	    SASL service name
+ *	    parsed network mailbox structure
+ *	    stream argument for functions
+ *	    pointer to current trial count
+ *	    returned user name
+ * Returns: T if success, NIL otherwise, number of trials incremented if retry
+ */
+
+long auth_plain_client (authchallenge_t challenger,authrespond_t responder,
+			char *service,NETMBX *mb,void *stream,
+			unsigned long *trial,char *user)
+{
+  char *u,pwd[MAILTMPLEN];
+  void *challenge;
+  unsigned long clen;
+  long ret = NIL;
+				/* snarl if not SSL/TLS session */
+  if (!mb->sslflag && !mb->tlsflag)
+    mm_log ("SECURITY PROBLEM: insecure server advertised AUTH=PLAIN",WARN);
+				/* get initial (empty) challenge */
+  if (challenge = (*challenger) (stream,&clen)) {
+    fs_give ((void **) &challenge);
+    if (clen) {			/* abort if challenge non-empty */
+      mm_log ("Server bug: non-empty initial PLAIN challenge",WARN);
+      (*responder) (stream,NIL,0);
+      ret = LONGT;		/* will get a BAD response back */
+    }
+    pwd[0] = NIL;		/* prompt user if empty challenge */
+    mm_login (mb,user,pwd,*trial);
+    if (!pwd[0]) {		/* empty challenge or user requested abort */
+      (*responder) (stream,NIL,0);
+      *trial = 0;		/* cancel subsequent attempts */
+      ret = LONGT;		/* will get a BAD response back */
+    }
+    else {
+      unsigned long rlen = 
+	strlen (mb->authuser) + strlen (user) + strlen (pwd) + 2;
+      char *response = (char *) fs_get (rlen);
+      char *t = response;	/* copy authorization id */
+      if (mb->authuser[0]) for (u = user; *u; *t++ = *u++);
+      *t++ = '\0';		/* delimiting NUL */
+				/* copy authentication id */
+      for (u = mb->authuser[0] ? mb->authuser : user; *u; *t++ = *u++);
+      *t++ = '\0';		/* delimiting NUL */
+				/* copy password */
+      for (u = pwd; *u; *t++ = *u++);
+				/* send credentials */
+      if ((*responder) (stream,response,rlen)) {
+	if (challenge = (*challenger) (stream,&clen))
+	  fs_give ((void **) &challenge);
+	else {
+	  ++*trial;		/* can try again if necessary */
+	  ret = LONGT;		/* check the authentication */
+	}
+      }
+      memset (response,0,rlen);	/* erase credentials */
+      fs_give ((void **) &response);
+    }
+  }
+  memset (pwd,0,MAILTMPLEN);	/* erase password */
+  if (!ret) *trial = 65535;	/* don't retry if bad protocol */
+  return ret;
+}
+
+/* Server authenticator
+ * Accepts: responder function
+ *	    argument count
+ *	    argument vector
+ * Returns: authenticated user name or NIL
+ */
+
+char *auth_plain_server (authresponse_t responder,int argc,char *argv[])
+{
+  char *ret = NIL;
+  char *user,*aid,*pass;
+  unsigned long len;
+				/* get user name */
+  if (aid = (*responder) ("",0,&len)) {
+				/* note: responders null-terminate */
+    if ((((unsigned long) ((user = aid + strlen (aid) + 1) - aid)) < len) &&
+	(((unsigned long) ((pass = user + strlen (user) + 1) - aid)) < len) &&
+	(((unsigned long) ((pass + strlen (pass)) - aid)) == len) &&
+	(*aid ? server_login (aid,pass,user,argc,argv) :
+	 server_login (user,pass,NIL,argc,argv))) ret = myusername ();
+    fs_give ((void **) &aid);
+  }
+  return ret;
+}
diff --git a/imap/src/c-client/c-client.h b/imap/src/c-client/c-client.h
new file mode 100644
index 00000000..7bf3710a
--- /dev/null
+++ b/imap/src/c-client/c-client.h
@@ -0,0 +1,55 @@
+/* ========================================================================
+ * Copyright 1988-2006 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:	c-client master include for application programs
+ *
+ * Author:	Mark Crispin
+ *		Networks and Distributed Computing
+ *		Computing & Communications
+ *		University of Washington
+ *		Administration Building, AG-44
+ *		Seattle, WA  98195
+ *		Internet: MRC@CAC.Washington.EDU
+ *
+ * Date:	19 May 2000
+ * Last Edited:	6 December 2006
+ */
+
+#ifndef __CCLIENT_H		/* nobody should include this twice... */
+#define __CCLIENT_H
+
+#ifdef __cplusplus		/* help out people who use C++ compilers */
+extern "C" {
+  /* If you use gcc, you may also have to use -fno-operator-names */
+#define private cclientPrivate	/* private to c-client */
+#define and cclientAnd		/* C99 doesn't realize that ISO 646 is dead */
+#define or cclientOr
+#define not cclientNot
+#endif
+
+#include "mail.h"		/* primary interfaces */
+#include "osdep.h"		/* OS-dependent routines */
+#include "rfc822.h"		/* RFC822 and MIME routines */
+#include "smtp.h"		/* SMTP sending routines */
+#include "nntp.h"		/* NNTP sending routines */
+#include "utf8.h"		/* Unicode and charset routines */
+#include "utf8aux.h"		/* Unicode auxillary routines */
+#include "misc.h"		/* miscellaneous utility routines */
+
+#ifdef __cplusplus		/* undo the C++ mischief */
+#undef private
+}
+#endif
+
+#endif
diff --git a/imap/src/c-client/env.h b/imap/src/c-client/env.h
new file mode 100644
index 00000000..d03e7e63
--- /dev/null
+++ b/imap/src/c-client/env.h
@@ -0,0 +1,45 @@
+/* ========================================================================
+ * 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:	Environment routines
+ *
+ * Author:	Mark Crispin
+ *		UW Technology
+ *		University of Washington
+ *		Seattle, WA  98195
+ *		Internet: MRC@Washington.EDU
+ *
+ * Date:	1 August 1988
+ * Last Edited:	13 February 2008
+ */
+
+/* Function prototypes */
+
+long pmatch_full (unsigned char *s,unsigned char *pat,unsigned char delim);
+long dmatch (unsigned char *s,unsigned char *pat,unsigned char delim);
+void *env_parameters (long function,void *value);
+void rfc822_date (char *date);
+void rfc822_timezone (char *s,void *t);
+void internal_date (char *date);
+long server_input_wait (long seconds);
+void server_init (char *server,char *service,char *sasl,
+		  void *clkint,void *kodint,void *hupint,void *trmint,
+		  void *staint);
+long server_login (char *user,char *pass,char *authuser,int argc,char *argv[]);
+long authserver_login (char *user,char *authuser,int argc,char *argv[]);
+long anonymous_login (int argc,char *argv[]);
+char *mylocalhost (void);
+char *myhomedir (void);
+char *mailboxfile (char *dst,char *name);
+MAILSTREAM *default_proto (long type);
diff --git a/imap/src/c-client/flstring.c b/imap/src/c-client/flstring.c
new file mode 100644
index 00000000..bbdbe3c8
--- /dev/null
+++ b/imap/src/c-client/flstring.c
@@ -0,0 +1,91 @@
+/* ========================================================================
+ * Copyright 1988-2006 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:	File string routines
+ *
+ * Author:	Mark Crispin
+ *		Networks and Distributed Computing
+ *		Computing & Communications
+ *		University of Washington
+ *		Administration Building, AG-44
+ *		Seattle, WA  98195
+ *		Internet: MRC@CAC.Washington.EDU
+ *
+ * Date:	15 April 1997
+ * Last Edited:	6 December 2006
+ */
+
+
+#include <stdio.h>
+#include "mail.h"
+#include "flstring.h"
+
+/* String driver for stdio file strings */
+
+static void file_string_init (STRING *s,void *data,unsigned long size);
+static char file_string_next (STRING *s);
+static void file_string_setpos (STRING *s,unsigned long i);
+
+STRINGDRIVER file_string = {
+  file_string_init,		/* initialize string structure */
+  file_string_next,		/* get next byte in string structure */
+  file_string_setpos		/* set position in string structure */
+};
+
+
+/* Initialize mail string structure for file
+ * Accepts: string structure
+ *	    pointer to string
+ *	    size of string
+ */
+
+static void file_string_init (STRING *s,void *data,unsigned long size)
+{
+  s->data = data;		/* note file descriptor */
+				/* big enough for one byte */
+  s->chunk = s->curpos = (char *) &s->data1;
+  s->size = size;		/* data size */
+  s->cursize = s->chunksize = 1;/* always call stdio */
+  file_string_setpos (s,0);	/* initial offset is 0 */
+}
+
+
+/* Get next character from string
+ * Accepts: string structure
+ * Returns: character, string structure chunk refreshed
+ */
+
+static char file_string_next (STRING *s)
+{
+  char ret = *s->curpos;
+  s->offset++;			/* advance position */
+  s->cursize = 1;		/* reset size */
+  *s->curpos = (char) getc ((FILE *) s->data);
+  return ret;
+}
+
+
+/* Set string pointer position
+ * Accepts: string structure
+ *	    new position
+ */
+
+static void file_string_setpos (STRING *s,unsigned long i)
+{
+  s->offset = i;		/* note new offset */
+  fseek ((FILE *) s->data,i,SEEK_SET);
+				/* in case using returnstringstruct hack */
+  s->chunk = s->curpos = (char *) &s->data1;
+  *s->curpos = (char) getc ((FILE *) s->data);
+}
diff --git a/imap/src/c-client/flstring.h b/imap/src/c-client/flstring.h
new file mode 100644
index 00000000..be6a831c
--- /dev/null
+++ b/imap/src/c-client/flstring.h
@@ -0,0 +1,30 @@
+/* ========================================================================
+ * Copyright 1988-2006 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:	File string routines
+ *
+ * Author:	Mark Crispin
+ *		Networks and Distributed Computing
+ *		Computing & Communications
+ *		University of Washington
+ *		Administration Building, AG-44
+ *		Seattle, WA  98195
+ *		Internet: MRC@CAC.Washington.EDU
+ *
+ * Date:	15 April 1997
+ * Last Edited:	30 August 2006
+ */
+
+
+extern STRINGDRIVER file_string;
diff --git a/imap/src/c-client/fs.h b/imap/src/c-client/fs.h
new file mode 100644
index 00000000..7bf32136
--- /dev/null
+++ b/imap/src/c-client/fs.h
@@ -0,0 +1,34 @@
+/* ========================================================================
+ * Copyright 1988-2006 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:	Free storage management routines
+ *
+ * Author:	Mark Crispin
+ *		Networks and Distributed Computing
+ *		Computing & Communications
+ *		University of Washington
+ *		Administration Building, AG-44
+ *		Seattle, WA  98195
+ *		Internet: MRC@CAC.Washington.EDU
+ *
+ * Date:	1 August 1988
+ * Last Edited:	30 August 2006
+ */
+
+
+/* Function prototypes */
+
+void *fs_get (size_t size);
+void fs_resize (void **block,size_t size);
+void fs_give (void **block);
diff --git a/imap/src/c-client/ftl.h b/imap/src/c-client/ftl.h
new file mode 100644
index 00000000..59348ad5
--- /dev/null
+++ b/imap/src/c-client/ftl.h
@@ -0,0 +1,32 @@
+/* ========================================================================
+ * Copyright 1988-2006 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:	Crash management routines
+ *
+ * Author:	Mark Crispin
+ *		Networks and Distributed Computing
+ *		Computing & Communications
+ *		University of Washington
+ *		Administration Building, AG-44
+ *		Seattle, WA  98195
+ *		Internet: MRC@CAC.Washington.EDU
+ *
+ * Date:	1 August 1988
+ * Last Edited:	30 August 2006
+ */
+
+
+/* Function prototypes */
+
+void fatal (char *string);
diff --git a/imap/src/c-client/imap4r1.c b/imap/src/c-client/imap4r1.c
new file mode 100644
index 00000000..1409b37d
--- /dev/null
+++ b/imap/src/c-client/imap4r1.c
@@ -0,0 +1,5672 @@
+/* ========================================================================
+ * 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;
+      (*env)->ngpathexists = nenv->ngpathexists;
+      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)->ngpathexists = oenv->ngpathexists;
+      (*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 */
+}
diff --git a/imap/src/c-client/imap4r1.h b/imap/src/c-client/imap4r1.h
new file mode 100644
index 00000000..8ee8a186
--- /dev/null
+++ b/imap/src/c-client/imap4r1.h
@@ -0,0 +1,281 @@
+/* ========================================================================
+ * Copyright 1988-2007 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 Mail Access Protocol 4rev1 (IMAP4R1) routines
+ *
+ * Author:	Mark Crispin
+ *		Networks and Distributed Computing
+ *		Computing & Communications
+ *		University of Washington
+ *		Administration Building, AG-44
+ *		Seattle, WA  98195
+ *		Internet: MRC@CAC.Washington.EDU
+ *
+ * Date:	14 October 1988
+ * Last Edited:	5 September 2007
+ */
+
+
+/* This include file is provided for applications which need to look under
+ * the covers at the IMAP driver and in particular want to do different
+ * operations depending upon the IMAP server's protocol level and
+ * capabilities.  It is NOT included in the normal c-client.h application
+ * export, and most applications do NOT need the definitions in this file.
+ *
+ * As of October 15, 2003, it is believed that:
+ *
+ * Version	RFC		Status		Known Implementations
+ * -------	---		------		---------------------
+ * IMAP1	none		extinct		experimental TOPS-20 server
+ * IMAP2	1064		extinct		old TOPS-20, SUMEX servers
+ * IMAP2	1176		rare		TOPS-20, old UW servers
+ * IMAP2bis	expired I-D	uncommon	old UW, Cyrus servers
+ * IMAP3	1203		extinct		none (never implemented)
+ * IMAP4	1730		rare		old UW, Cyrus, Netscape servers
+ * IMAP4rev1	2060, 3501	ubiquitous	UW, Cyrus, and many others
+ *
+ * Most client implementations will only interoperate with an IMAP4rev1
+ * server.  c-client based client implementations can interoperate with IMAP2,
+ * IMAP2bis, IMAP4, and IMAP4rev1 servers, but only if they are very careful.
+ *
+ * The LEVELxxx() macros in this file enable the client to determine the
+ * server protocol level and capabilities.  This file also contains a few
+ * backdoor calls into the IMAP driver.
+ */
+
+/* Server protocol level and capabilities */
+
+typedef struct imap_cap {
+  unsigned int rfc1176 : 1;	/* server is RFC-1176 IMAP2 */
+  unsigned int imap2bis : 1;	/* server is IMAP2bis */
+  unsigned int imap4 : 1;	/* server is IMAP4 (RFC 1730) */
+  unsigned int imap4rev1 : 1;	/* server is IMAP4rev1 */
+  unsigned int acl : 1;		/* server has ACL (RFC 2086) */
+  unsigned int quota : 1;	/* server has QUOTA (RFC 2087) */
+  unsigned int litplus : 1;	/* server has LITERAL+ (RFC 2088) */
+  unsigned int idle : 1;	/* server has IDLE (RFC 2177) */
+  unsigned int mbx_ref : 1;	/* server has mailbox referrals (RFC 2193) */
+  unsigned int log_ref : 1;	/* server has login referrals (RFC 2221) */
+  unsigned int authanon : 1;	/* server has anonymous SASL (RFC 2245) */
+  unsigned int namespace :1;	/* server has NAMESPACE (RFC 2342) */
+  unsigned int uidplus : 1;	/* server has UIDPLUS (RFC 2359) */
+  unsigned int starttls : 1;	/* server has STARTTLS (RFC 2595) */
+				/* server disallows LOGIN command (RFC 2595) */
+  unsigned int logindisabled : 1;
+  unsigned int id : 1;		/* server has ID (RFC 2971) */
+  unsigned int children : 1;	/* server has CHILDREN (RFC 3348) */
+  unsigned int multiappend : 1;	/* server has multi-APPEND (RFC 3502) ;*/
+  unsigned int binary : 1;	/* server has BINARY (RFC 3516) */
+  unsigned int unselect : 1;	/* server has UNSELECT */
+  unsigned int sasl_ir : 1;	/* server has SASL-IR initial response */
+  unsigned int sort : 1;	/* server has SORT */
+  unsigned int scan : 1;	/* server has SCAN */
+  unsigned int urlauth : 1;	/* server has URLAUTH (RFC 4467) */
+  unsigned int catenate : 1;	/* server has CATENATE (RFC 4469) */
+  unsigned int condstore : 1;	/* server has CONDSTORE (RFC 4551) */
+  unsigned int esearch : 1;	/* server has ESEARCH (RFC 4731) */
+  unsigned int within : 1;	/* server has WITHIN (RFC 5032) */
+  unsigned int extlevel;	/* extension data level supported by server */
+				/* supported authenticators */
+  unsigned int auth : MAXAUTHENTICATORS;
+  THREADER *threader;		/* list of threaders */
+} IMAPCAP;
+
+/* IMAP4rev1 level or better */
+
+#define LEVELIMAP4rev1(stream) imap_cap (stream)->imap4rev1
+
+#define LEVELSTATUS LEVELIMAP4rev1
+
+
+/* IMAP4 level or better (not including RFC 1730 design mistakes) */
+
+#define LEVELIMAP4(stream) (imap_cap (stream)->imap4rev1 || \
+			    imap_cap (stream)->imap4)
+
+
+/* IMAP4 RFC-1730 level */
+
+#define LEVEL1730(stream) imap_cap (stream)->imap4
+
+
+/* IMAP2bis level or better */
+
+#define LEVELIMAP2bis(stream) imap_cap (stream)->imap2bis
+
+
+/* IMAP2 RFC-1176 level or better */
+
+#define LEVEL1176(stream) imap_cap (stream)->rfc1176
+
+
+/* IMAP2 RFC-1064 or better */
+
+#define LEVEL1064(stream) 1
+
+/* Has ACL extension */
+
+#define LEVELACL(stream) imap_cap (stream)->acl
+
+
+/* Has QUOTA extension */
+
+#define LEVELQUOTA(stream) imap_cap (stream)->quota
+
+
+/* Has LITERALPLUS extension */
+
+#define LEVELLITERALPLUS(stream) imap_cap (stream)->litplus
+
+
+/* Has IDLE extension */
+
+#define LEVELIDLE(stream) imap_cap (stream)->idle
+
+
+/* Has mailbox referrals */
+
+#define LEVELMBX_REF(stream) imap_cap (stream)->mbx_ref
+
+
+/* Has login referrals */
+
+#define LEVELLOG_REF(stream) imap_cap (stream)->log_ref
+
+
+/* Has AUTH=ANONYMOUS extension */
+
+#define LEVELANONYMOUS(stream) imap_cap (stream)->authanon
+
+
+/* Has NAMESPACE extension */
+
+#define LEVELNAMESPACE(stream) imap_cap (stream)->namespace
+
+
+/* Has UIDPLUS extension */
+
+#define LEVELUIDPLUS(stream) imap_cap (stream)->uidplus
+
+
+/* Has STARTTLS extension */
+
+#define LEVELSTARTTLS(stream) imap_cap (stream)->starttls
+
+
+/* Has LOGINDISABLED extension */
+
+#define LEVELLOGINDISABLED(stream) imap_cap (stream)->logindisabled
+
+/* Has ID extension */
+
+#define LEVELID(stream) imap_cap (stream)->id
+
+
+/* Has CHILDREN extension */
+
+#define LEVELCHILDREN(stream) imap_cap (stream)->children
+
+
+/* Has MULTIAPPEND extension */
+
+#define LEVELMULTIAPPEND(stream) imap_cap (stream)->multiappend
+
+
+/* Has BINARY extension */
+
+#define LEVELBINARY(stream) imap_cap (stream)->binary
+
+
+/* Has UNSELECT extension */
+
+#define LEVELUNSELECT(stream) imap_cap (stream)->unselect
+
+
+/* Has SASL initial response extension */
+
+#define LEVELSASLIR(stream) imap_cap (stream)->sasl_ir
+
+
+/* Has SORT extension */
+
+#define LEVELSORT(stream) imap_cap (stream)->sort
+
+
+/* Has at least one THREAD extension */
+
+#define LEVELTHREAD(stream) ((imap_cap (stream)->threader) ? T : NIL)
+
+
+/* Has SCAN extension */
+
+#define LEVELSCAN(stream) imap_cap (stream)->scan
+
+
+/* Has URLAUTH extension */
+
+#define LEVELURLAUTH(stream) imap_cap (stream)->urlauth
+
+
+/* Has CATENATE extension */
+
+#define LEVELCATENATE(stream) imap_cap (stream)->catenate
+
+
+/* Has CONDSTORE extension */
+
+#define LEVELCONDSTORE(stream) imap_cap (stream)->condstore
+
+
+/* Has ESEARCH extension */
+
+#define LEVELESEARCH(stream) imap_cap (stream)->esearch
+
+
+/* Has WITHIN extension */
+
+#define LEVELWITHIN(stream) imap_cap (stream)->within
+
+/* Body structure extension levels */
+
+/* These are in BODYSTRUCTURE order.  Note that multipart bodies do not have
+ * body-fld-md5.  This is alright, since all subsequent body structure
+ * extensions are in both singlepart and multipart bodies.  If that ever
+ * changes, this will have to be split.
+ */
+
+#define BODYEXTMD5 1		/* body-fld-md5 */
+#define BODYEXTDSP 2		/* body-fld-dsp */
+#define BODYEXTLANG 3		/* body-fld-lang */
+#define BODYEXTLOC 4		/* body-fld-loc */
+
+
+/* Function prototypes */
+
+IMAPCAP *imap_cap (MAILSTREAM *stream);
+char *imap_host (MAILSTREAM *stream);
+long imap_cache (MAILSTREAM *stream,unsigned long msgno,char *seg,
+		 STRINGLIST *stl,SIZEDTEXT *text);
+
+
+/* Temporary */
+
+long imap_setacl (MAILSTREAM *stream,char *mailbox,char *id,char *rights);
+long imap_deleteacl (MAILSTREAM *stream,char *mailbox,char *id);
+long imap_getacl (MAILSTREAM *stream,char *mailbox);
+long imap_listrights (MAILSTREAM *stream,char *mailbox,char *id);
+long imap_myrights (MAILSTREAM *stream,char *mailbox);
+long imap_setquota (MAILSTREAM *stream,char *qroot,STRINGLIST *limits);
+long imap_getquota (MAILSTREAM *stream,char *qroot);
+long imap_getquotaroot (MAILSTREAM *stream,char *mailbox);
diff --git a/imap/src/c-client/mail.c b/imap/src/c-client/mail.c
new file mode 100644
index 00000000..d80a01f6
--- /dev/null
+++ b/imap/src/c-client/mail.c
@@ -0,0 +1,6337 @@
+/* ========================================================================
+ * Copyright 1988-2008 University of Washington
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 
+ * ========================================================================
+ */
+
+/*
+ * Program:	Mailbox Access routines
+ *
+ * Author:	Mark Crispin
+ *		UW Technology
+ *		University of Washington
+ *		Seattle, WA  98195
+ *		Internet: MRC@Washington.EDU
+ *
+ * Date:	22 November 1989
+ * Last Edited:	15 April 2008
+ */
+
+
+#include <ctype.h>
+#include <stdio.h>
+#include <time.h>
+#include "c-client.h"
+
+char *UW_copyright = "Copyright 1988-2007 University of Washington\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n     http://www.apache.org/licenses/LICENSE-2.0\n";
+
+/* c-client global data */
+
+				/* version of this library */
+static char *mailcclientversion = CCLIENTVERSION;
+				/* list of mail drivers */
+static DRIVER *maildrivers = NIL;
+				/* list of authenticators */
+static AUTHENTICATOR *mailauthenticators = NIL;
+				/* SSL driver pointer */
+static NETDRIVER *mailssldriver = NIL;
+				/* pointer to alternate gets function */
+static mailgets_t mailgets = NIL;
+				/* pointer to read progress function */
+static readprogress_t mailreadprogress = NIL;
+				/* mail cache manipulation function */
+static mailcache_t mailcache = mm_cache;
+				/* RFC-822 output generator */
+static rfc822out_t mail822out = NIL;
+				/* RFC-822 output generator (new style) */
+static rfc822outfull_t mail822outfull = NIL;
+				/* SMTP verbose callback */
+static smtpverbose_t mailsmtpverbose = mm_dlog;
+				/* proxy copy routine */
+static mailproxycopy_t mailproxycopy = NIL;
+				/* RFC-822 external line parse */
+static parseline_t mailparseline = NIL;
+				/* RFC-822 external phrase parser */
+static parsephrase_t mailparsephrase = NIL;
+static kinit_t mailkinit = NIL;	/* application kinit callback */
+				/* note network sent command */
+static sendcommand_t mailsendcommand = NIL;
+				/* newsrc file name decision function */
+static newsrcquery_t mailnewsrcquery = NIL;
+				/* ACL results callback */
+static getacl_t mailaclresults = NIL;
+				/* list rights results callback */
+static listrights_t maillistrightsresults = NIL;
+				/* my rights results callback */
+static myrights_t mailmyrightsresults = NIL;
+				/* quota results callback */
+static quota_t mailquotaresults = NIL;
+				/* quota root results callback */
+static quotaroot_t mailquotarootresults = NIL;
+				/* sorted results callback */
+static sortresults_t mailsortresults = NIL;
+				/* threaded results callback */
+static threadresults_t mailthreadresults = NIL;
+				/* COPY UID results */
+static copyuid_t mailcopyuid = NIL;
+				/* APPEND UID results */
+static appenduid_t mailappenduid = NIL;
+				/* free elt extra stuff callback */
+static freeeltsparep_t mailfreeeltsparep = NIL;
+				/* free envelope extra stuff callback */
+static freeenvelopesparep_t mailfreeenvelopesparep = NIL;
+				/* free body extra stuff callback */
+static freebodysparep_t mailfreebodysparep = NIL;
+				/* free stream extra stuff callback */
+static freestreamsparep_t mailfreestreamsparep = NIL;
+				/* SSL start routine */
+static sslstart_t mailsslstart = NIL;
+				/* SSL certificate query */
+static sslcertificatequery_t mailsslcertificatequery = NIL;
+				/* SSL client certificate */
+static sslclientcert_t mailsslclientcert = NIL;
+				/* SSL client private key */
+static sslclientkey_t mailsslclientkey = NIL;
+				/* SSL failure notify */
+static sslfailure_t mailsslfailure = NIL;
+				/* snarf interval */
+static long mailsnarfinterval = 60;
+				/* snarf preservation */
+static long mailsnarfpreserve = NIL;
+				/* newsrc name uses canonical host */
+static long mailnewsrccanon = LONGT;
+
+				/* supported threaders */
+static THREADER mailthreadordsub = {
+  "ORDEREDSUBJECT",mail_thread_orderedsubject,NIL
+};
+static THREADER mailthreadlist = {
+  "REFERENCES",mail_thread_references,&mailthreadordsub
+};
+
+				/* server name */
+static char *servicename = "unknown";
+				/* server externally-set authentication ID */
+static char *externalauthid = NIL;
+static int expungeatping = T;	/* mail_ping() may call mm_expunged() */
+static int trysslfirst = NIL;	/* always try SSL first */
+static int notimezones = NIL;	/* write timezones in "From " header */
+static int trustdns = T;	/* do DNS canonicalization */
+static int saslusesptrname = T;	/* SASL uses name from DNS PTR lookup */
+				/* trustdns also must be set */
+static int debugsensitive = NIL;/* debug telemetry includes sensitive data */
+
+/* Default mail cache handler
+ * Accepts: pointer to cache handle
+ *	    message number
+ *	    caching function
+ * Returns: cache data
+ */
+
+void *mm_cache (MAILSTREAM *stream,unsigned long msgno,long op)
+{
+  size_t n;
+  void *ret = NIL;
+  unsigned long i;
+  switch ((int) op) {		/* what function? */
+  case CH_INIT:			/* initialize cache */
+    if (stream->cache) {	/* flush old cache contents */
+      while (stream->cachesize) {
+	mm_cache (stream,stream->cachesize,CH_FREE);
+	mm_cache (stream,stream->cachesize--,CH_FREESORTCACHE);
+      }
+      fs_give ((void **) &stream->cache);
+      fs_give ((void **) &stream->sc);
+      stream->nmsgs = 0;	/* can't have any messages now */
+    }
+    break;
+  case CH_SIZE:			/* (re-)size the cache */
+    if (!stream->cache)	{	/* have a cache already? */
+				/* no, create new cache */
+      n = (stream->cachesize = msgno + CACHEINCREMENT) * sizeof (void *);
+      stream->cache = (MESSAGECACHE **) memset (fs_get (n),0,n);
+      stream->sc = (SORTCACHE **) memset (fs_get (n),0,n);
+    }
+				/* is existing cache size large neough */
+    else if (msgno > stream->cachesize) {
+      i = stream->cachesize;	/* remember old size */
+      n = (stream->cachesize = msgno + CACHEINCREMENT) * sizeof (void *);
+      fs_resize ((void **) &stream->cache,n);
+      fs_resize ((void **) &stream->sc,n);
+      while (i < stream->cachesize) {
+	stream->cache[i] = NIL;
+	stream->sc[i++] = NIL;
+      }
+    }
+    break;
+
+  case CH_MAKEELT:		/* return elt, make if necessary */
+    if (!stream->cache[msgno - 1])
+      stream->cache[msgno - 1] = mail_new_cache_elt (msgno);
+				/* falls through */
+  case CH_ELT:			/* return elt */
+    ret = (void *) stream->cache[msgno - 1];
+    break;
+  case CH_SORTCACHE:		/* return sortcache entry, make if needed */
+    if (!stream->sc[msgno - 1]) stream->sc[msgno - 1] =
+      (SORTCACHE *) memset (fs_get (sizeof (SORTCACHE)),0,sizeof (SORTCACHE));
+    ret = (void *) stream->sc[msgno - 1];
+    break;
+  case CH_FREE:			/* free elt */
+    mail_free_elt (&stream->cache[msgno - 1]);
+    break;
+  case CH_FREESORTCACHE:
+    if (stream->sc[msgno - 1]) {
+      if (stream->sc[msgno - 1]->from)
+	fs_give ((void **) &stream->sc[msgno - 1]->from);
+      if (stream->sc[msgno - 1]->to)
+	fs_give ((void **) &stream->sc[msgno - 1]->to);
+      if (stream->sc[msgno - 1]->cc)
+	fs_give ((void **) &stream->sc[msgno - 1]->cc);
+      if (stream->sc[msgno - 1]->subject)
+	fs_give ((void **) &stream->sc[msgno - 1]->subject);
+      if (stream->sc[msgno - 1]->unique &&
+	  (stream->sc[msgno - 1]->unique != stream->sc[msgno - 1]->message_id))
+	fs_give ((void **) &stream->sc[msgno - 1]->unique);
+      if (stream->sc[msgno - 1]->message_id)
+	fs_give ((void **) &stream->sc[msgno - 1]->message_id);
+      if (stream->sc[msgno - 1]->references)
+	mail_free_stringlist (&stream->sc[msgno - 1]->references);
+      fs_give ((void **) &stream->sc[msgno - 1]);
+    }
+    break;
+  case CH_EXPUNGE:		/* expunge cache slot */
+    for (i = msgno - 1; msgno < stream->nmsgs; i++,msgno++) {
+      if (stream->cache[i] = stream->cache[msgno])
+	stream->cache[i]->msgno = msgno;
+      stream->sc[i] = stream->sc[msgno];
+    }
+    stream->cache[i] = NIL;	/* top of cache goes away */
+    stream->sc[i] = NIL;
+    break;
+  default:
+    fatal ("Bad mm_cache op");
+    break;
+  }
+  return ret;
+}
+
+/* Dummy string driver for complete in-memory strings */
+
+static void mail_string_init (STRING *s,void *data,unsigned long size);
+static char mail_string_next (STRING *s);
+static void mail_string_setpos (STRING *s,unsigned long i);
+
+STRINGDRIVER mail_string = {
+  mail_string_init,		/* initialize string structure */
+  mail_string_next,		/* get next byte in string structure */
+  mail_string_setpos		/* set position in string structure */
+};
+
+
+/* Initialize mail string structure for in-memory string
+ * Accepts: string structure
+ *	    pointer to string
+ *	    size of string
+ */
+
+static void mail_string_init (STRING *s,void *data,unsigned long size)
+{
+				/* set initial string pointers */
+  s->chunk = s->curpos = (char *) (s->data = data);
+				/* and sizes */
+  s->size = s->chunksize = s->cursize = size;
+  s->data1 = s->offset = 0;	/* never any offset */
+}
+
+
+/* Get next character from string
+ * Accepts: string structure
+ * Returns: character, string structure chunk refreshed
+ */
+
+static char mail_string_next (STRING *s)
+{
+  return *s->curpos++;		/* return the last byte */
+}
+
+
+/* Set string pointer position
+ * Accepts: string structure
+ *	    new position
+ */
+
+static void mail_string_setpos (STRING *s,unsigned long i)
+{
+  s->curpos = s->chunk + i;	/* set new position */
+  s->cursize = s->chunksize - i;/* and new size */
+}
+
+/* Mail routines
+ *
+ *  mail_xxx routines are the interface between this module and the outside
+ * world.  Only these routines should be referenced by external callers.
+ *
+ *  Note that there is an important difference between a "sequence" and a
+ * "message #" (msgno).  A sequence is a string representing a sequence in
+ * {"n", "n:m", or combination separated by commas} format, whereas a msgno
+ * is a single integer.
+ *
+ */
+
+/* Mail version check
+ * Accepts: version
+ */
+
+void mail_versioncheck (char *version)
+{
+				/* attempt to protect again wrong .h */
+  if (strcmp (version,mailcclientversion)) {
+    char tmp[MAILTMPLEN];
+    sprintf (tmp,"c-client library version skew, app=%.100s library=%.100s",
+	     version,mailcclientversion);
+    fatal (tmp);
+  }
+}
+
+
+/* Mail link driver
+ * Accepts: driver to add to list
+ */
+
+void mail_link (DRIVER *driver)
+{
+  DRIVER **d = &maildrivers;
+  while (*d) d = &(*d)->next;	/* find end of list of drivers */
+  *d = driver;			/* put driver at the end */
+  driver->next = NIL;		/* this driver is the end of the list */
+}
+
+/* Mail manipulate driver parameters
+ * Accepts: mail stream
+ *	    function code
+ *	    function-dependent value
+ * Returns: function-dependent return value
+ */
+
+void *mail_parameters (MAILSTREAM *stream,long function,void *value)
+{
+  void *r,*ret = NIL;
+  DRIVER *d;
+  AUTHENTICATOR *a;
+  switch ((int) function) {
+  case SET_INBOXPATH:
+    fatal ("SET_INBOXPATH not permitted");
+  case GET_INBOXPATH:
+    if ((stream || (stream = mail_open (NIL,"INBOX",OP_PROTOTYPE))) &&
+	stream->dtb) ret = (*stream->dtb->parameters) (function,value);
+    break;
+  case SET_THREADERS:
+    fatal ("SET_THREADERS not permitted");
+  case GET_THREADERS:		/* use stream dtb instead of global */
+    ret = (stream && stream->dtb) ?
+				/* KLUDGE ALERT: note stream passed as value */
+      (*stream->dtb->parameters) (function,stream) : (void *) &mailthreadlist;
+    break;
+  case SET_NAMESPACE:
+    fatal ("SET_NAMESPACE not permitted");
+    break;
+  case SET_NEWSRC:		/* too late on open stream */
+    if (stream && stream->dtb && (stream != ((*stream->dtb->open) (NIL))))
+      fatal ("SET_NEWSRC not permitted");
+    else ret = env_parameters (function,value);
+    break;
+  case GET_NAMESPACE:
+  case GET_NEWSRC:		/* use stream dtb instead of environment */
+    ret = (stream && stream->dtb) ?
+				/* KLUDGE ALERT: note stream passed as value */
+      (*stream->dtb->parameters) (function,stream) :
+	env_parameters (function,value);
+    break;
+  case ENABLE_DEBUG:
+    fatal ("ENABLE_DEBUG not permitted");
+  case DISABLE_DEBUG:
+    fatal ("DISABLE_DEBUG not permitted");
+  case SET_DIRFMTTEST:
+    fatal ("SET_DIRFMTTEST not permitted");
+  case GET_DIRFMTTEST:
+    if (!(stream && stream->dtb &&
+	  (ret = (*stream->dtb->parameters) (function,NIL))))
+      fatal ("GET_DIRFMTTEST not permitted");
+    break;
+
+  case SET_DRIVERS:
+    fatal ("SET_DRIVERS not permitted");
+  case GET_DRIVERS:		/* always return global */
+    ret = (void *) maildrivers;
+    break;
+  case SET_DRIVER:
+    fatal ("SET_DRIVER not permitted");
+  case GET_DRIVER:
+    for (d = maildrivers; d && compare_cstring (d->name,(char *) value);
+	 d = d->next);
+    ret = (void *) d;
+    break;
+  case ENABLE_DRIVER:
+    for (d = maildrivers; d && compare_cstring (d->name,(char *) value);
+	 d = d->next);
+    if (ret = (void *) d) d->flags &= ~DR_DISABLE;
+    break;
+  case DISABLE_DRIVER:
+    for (d = maildrivers; d && compare_cstring (d->name,(char *) value);
+	 d = d->next);
+    if (ret = (void *) d) d->flags |= DR_DISABLE;
+    break;
+  case ENABLE_AUTHENTICATOR:
+    for (a = mailauthenticators;/* scan authenticators */
+	 a && compare_cstring (a->name,(char *) value); a = a->next);
+    if (ret = (void *) a) a->flags &= ~AU_DISABLE;
+    break;
+  case DISABLE_AUTHENTICATOR:
+    for (a = mailauthenticators;/* scan authenticators */
+	 a && compare_cstring (a->name,(char *) value); a = a->next);
+    if (ret = (void *) a) a->flags |= AU_DISABLE;
+    break;
+  case UNHIDE_AUTHENTICATOR:
+    for (a = mailauthenticators;/* scan authenticators */
+	 a && compare_cstring (a->name,(char *) value); a = a->next);
+    if (ret = (void *) a) a->flags &= ~AU_HIDE;
+    break;
+  case HIDE_AUTHENTICATOR:
+    for (a = mailauthenticators;/* scan authenticators */
+	 a && compare_cstring (a->name,(char *) value); a = a->next);
+    if (ret = (void *) a) a->flags |= AU_HIDE;
+    break;
+  case SET_EXTERNALAUTHID:
+    if (value) {		/* setting external authentication ID */
+      externalauthid = cpystr ((char *) value);
+      mail_parameters (NIL,UNHIDE_AUTHENTICATOR,"EXTERNAL");
+    }
+    else {			/* clearing external authentication ID */
+      if (externalauthid) fs_give ((void **) &externalauthid);
+      mail_parameters (NIL,HIDE_AUTHENTICATOR,"EXTERNAL");
+    }
+  case GET_EXTERNALAUTHID:
+    ret = (void *) externalauthid;
+    break;
+
+  case SET_GETS:
+    mailgets = (mailgets_t) value;
+  case GET_GETS:
+    ret = (void *) mailgets;
+    break;
+  case SET_READPROGRESS:
+    mailreadprogress = (readprogress_t) value;
+  case GET_READPROGRESS:
+    ret = (void *) mailreadprogress;
+    break;
+  case SET_CACHE:
+    mailcache = (mailcache_t) value;
+  case GET_CACHE:
+    ret = (void *) mailcache;
+    break;
+  case SET_RFC822OUTPUT:
+    mail822out = (rfc822out_t) value;
+  case GET_RFC822OUTPUT:
+    ret = (void *) mail822out;
+    break;
+  case SET_RFC822OUTPUTFULL:
+    mail822outfull = (rfc822outfull_t) value;
+  case GET_RFC822OUTPUTFULL:
+    ret = (void *) mail822outfull;
+    break;
+  case SET_SMTPVERBOSE:
+    mailsmtpverbose = (smtpverbose_t) value;
+  case GET_SMTPVERBOSE:
+    ret = (void *) mailsmtpverbose;
+    break;
+  case SET_MAILPROXYCOPY:
+    mailproxycopy = (mailproxycopy_t) value;
+  case GET_MAILPROXYCOPY:
+    ret = (void *) mailproxycopy;
+    break;
+  case SET_PARSELINE:
+    mailparseline = (parseline_t) value;
+  case GET_PARSELINE:
+    ret = (void *) mailparseline;
+    break;
+  case SET_PARSEPHRASE:
+    mailparsephrase = (parsephrase_t) value;
+  case GET_PARSEPHRASE:
+    ret = (void *) mailparsephrase;
+    break;
+  case SET_NEWSRCQUERY:
+    mailnewsrcquery = (newsrcquery_t) value;
+  case GET_NEWSRCQUERY:
+    ret = (void *) mailnewsrcquery;
+    break;
+  case SET_NEWSRCCANONHOST:
+    mailnewsrccanon = (long) value;
+  case GET_NEWSRCCANONHOST:
+    ret = (void *) mailnewsrccanon;
+    break;
+
+  case SET_COPYUID:
+    mailcopyuid = (copyuid_t) value;
+  case GET_COPYUID:
+    ret = (void *) mailcopyuid;
+    break;
+  case SET_APPENDUID:
+    mailappenduid = (appenduid_t) value;
+  case GET_APPENDUID:
+    ret = (void *) mailappenduid;
+    break;
+  case SET_FREEENVELOPESPAREP:
+    mailfreeenvelopesparep = (freeenvelopesparep_t) value;
+  case GET_FREEENVELOPESPAREP:
+    ret = (void *) mailfreeenvelopesparep;
+    break;
+  case SET_FREEELTSPAREP:
+    mailfreeeltsparep = (freeeltsparep_t) value;
+  case GET_FREEELTSPAREP:
+    ret = (void *) mailfreeeltsparep;
+    break;
+  case SET_FREESTREAMSPAREP:
+    mailfreestreamsparep = (freestreamsparep_t) value;
+  case GET_FREESTREAMSPAREP:
+    ret = (void *) mailfreestreamsparep;
+    break;
+  case SET_FREEBODYSPAREP:
+    mailfreebodysparep = (freebodysparep_t) value;
+  case GET_FREEBODYSPAREP:
+    ret = (void *) mailfreebodysparep;
+    break;
+
+  case SET_SSLSTART:
+    mailsslstart = (sslstart_t) value;
+  case GET_SSLSTART:
+    ret = (void *) mailsslstart;
+    break;
+  case SET_SSLCERTIFICATEQUERY:
+    mailsslcertificatequery = (sslcertificatequery_t) value;
+  case GET_SSLCERTIFICATEQUERY:
+    ret = (void *) mailsslcertificatequery;
+    break;
+  case SET_SSLCLIENTCERT:
+    mailsslclientcert = (sslclientcert_t) value;
+  case GET_SSLCLIENTCERT:
+    ret = (void *) mailsslclientcert;
+    break;
+  case SET_SSLCLIENTKEY:
+    mailsslclientkey = (sslclientkey_t) value;
+  case GET_SSLCLIENTKEY:
+    ret = (void *) mailsslclientkey;
+    break;
+  case SET_SSLFAILURE:
+    mailsslfailure = (sslfailure_t) value;
+  case GET_SSLFAILURE:
+    ret = (void *) mailsslfailure;
+    break;
+  case SET_KINIT:
+    mailkinit = (kinit_t) value;
+  case GET_KINIT:
+    ret = (void *) mailkinit;
+    break;
+  case SET_SENDCOMMAND:
+    mailsendcommand = (sendcommand_t) value;
+  case GET_SENDCOMMAND:
+    ret = (void *) mailsendcommand;
+    break;
+
+  case SET_SERVICENAME:
+    servicename = (char *) value;
+  case GET_SERVICENAME:
+    ret = (void *) servicename;
+    break;
+  case SET_EXPUNGEATPING:
+    expungeatping = (value ? T : NIL);
+  case GET_EXPUNGEATPING:
+    ret = (void *) (expungeatping ? VOIDT : NIL);
+    break;
+  case SET_SORTRESULTS:
+    mailsortresults = (sortresults_t) value;
+  case GET_SORTRESULTS:
+    ret = (void *) mailsortresults;
+    break;
+  case SET_THREADRESULTS:
+    mailthreadresults = (threadresults_t) value;
+  case GET_THREADRESULTS:
+    ret = (void *) mailthreadresults;
+    break;
+  case SET_SSLDRIVER:
+    mailssldriver = (NETDRIVER *) value;
+  case GET_SSLDRIVER:
+    ret = (void *) mailssldriver;
+    break;
+  case SET_TRYSSLFIRST:
+    trysslfirst = (value ? T : NIL);
+  case GET_TRYSSLFIRST:
+    ret = (void *) (trysslfirst ? VOIDT : NIL);
+    break;
+  case SET_NOTIMEZONES:
+    notimezones = (value ? T : NIL);
+  case GET_NOTIMEZONES:
+    ret = (void *) (notimezones ? VOIDT : NIL);
+    break;
+  case SET_TRUSTDNS:
+    trustdns = (value ? T : NIL);
+  case GET_TRUSTDNS:
+    ret = (void *) (trustdns ? VOIDT : NIL);
+    break;
+  case SET_SASLUSESPTRNAME:
+    saslusesptrname = (value ? T : NIL);
+  case GET_SASLUSESPTRNAME:
+    ret = (void *) (saslusesptrname ? VOIDT : NIL);
+    break;
+  case SET_DEBUGSENSITIVE:
+    debugsensitive = (value ? T : NIL);
+  case GET_DEBUGSENSITIVE:
+    ret = (void *) (debugsensitive ? VOIDT : NIL);
+    break;
+
+  case SET_ACL:
+    mailaclresults = (getacl_t) value;
+  case GET_ACL:
+    ret = (void *) mailaclresults;
+    break;
+  case SET_LISTRIGHTS:
+    maillistrightsresults = (listrights_t) value;
+  case GET_LISTRIGHTS:
+    ret = (void *) maillistrightsresults;
+    break;
+  case SET_MYRIGHTS:
+    mailmyrightsresults = (myrights_t) value;
+  case GET_MYRIGHTS:
+    ret = (void *) mailmyrightsresults;
+    break;
+  case SET_QUOTA:
+    mailquotaresults = (quota_t) value;
+  case GET_QUOTA:
+    ret = (void *) mailquotaresults;
+    break;
+  case SET_QUOTAROOT:
+    mailquotarootresults = (quotaroot_t) value;
+  case GET_QUOTAROOT:
+    ret = (void *) mailquotarootresults;
+    break;
+  case SET_SNARFINTERVAL:
+    mailsnarfinterval = (long) value;
+  case GET_SNARFINTERVAL:
+    ret = (void *) mailsnarfinterval;
+    break;
+  case SET_SNARFPRESERVE:
+    mailsnarfpreserve = (long) value;
+  case GET_SNARFPRESERVE:
+    ret = (void *) mailsnarfpreserve;
+    break;
+  case SET_SNARFMAILBOXNAME:
+    if (stream) {		/* have a stream? */
+      if (stream->snarf.name) fs_give ((void **) &stream->snarf.name);
+      stream->snarf.name = cpystr ((char *) value);
+    }
+    else fatal ("SET_SNARFMAILBOXNAME with no stream");
+  case GET_SNARFMAILBOXNAME:
+    if (stream) ret = (void *) stream->snarf.name;
+    break;
+  default:
+    if (r = smtp_parameters (function,value)) ret = r;
+    if (r = env_parameters (function,value)) ret = r;
+    if (r = tcp_parameters (function,value)) ret = r;
+    if (stream && stream->dtb) {/* if have stream, do for its driver only */
+      if (r = (*stream->dtb->parameters) (function,value)) ret = r;
+    }
+				/* else do all drivers */
+    else for (d = maildrivers; d; d = d->next)
+      if (r = (d->parameters) (function,value)) ret = r;
+    break;
+  }
+  return ret;
+}
+
+/* Mail validate mailbox name
+ * Accepts: MAIL stream
+ *	    mailbox name
+ *	    purpose string for error message
+ * Return: driver factory on success, NIL on failure
+ */
+
+DRIVER *mail_valid (MAILSTREAM *stream,char *mailbox,char *purpose)
+{
+  char tmp[MAILTMPLEN];
+  DRIVER *factory = NIL;
+				/* never allow names with newlines */
+  if (strpbrk (mailbox,"\015\012")) {
+    if (purpose) {		/* if want an error message */
+      sprintf (tmp,"Can't %s with such a name",purpose);
+      MM_LOG (tmp,ERROR);
+    }
+    return NIL;
+  }
+				/* validate name, find driver factory */
+  if (strlen (mailbox) < (NETMAXHOST+(NETMAXUSER*2)+NETMAXMBX+NETMAXSRV+50))
+    for (factory = maildrivers; factory && 
+	 ((factory->flags & DR_DISABLE) ||
+	  ((factory->flags & DR_LOCAL) && (*mailbox == '{')) ||
+	  !(*factory->valid) (mailbox));
+	 factory = factory->next);
+				/* validate factory against non-dummy stream */
+  if (factory && stream && stream->dtb && (stream->dtb != factory) &&
+      strcmp (stream->dtb->name,"dummy"))
+				/* factory invalid; if dummy, use stream */
+    factory = strcmp (factory->name,"dummy") ? NIL : stream->dtb;
+  if (!factory && purpose) {	/* if want an error message */
+    sprintf (tmp,"Can't %s %.80s: %s",purpose,mailbox,(*mailbox == '{') ?
+	     "invalid remote specification" : "no such mailbox");
+    MM_LOG (tmp,ERROR);
+  }
+  return factory;		/* return driver factory */
+}
+
+/* Mail validate network mailbox name
+ * Accepts: mailbox name
+ *	    mailbox driver to validate against
+ *	    pointer to where to return host name if non-NIL
+ *	    pointer to where to return mailbox name if non-NIL
+ * Returns: driver on success, NIL on failure
+ */
+
+DRIVER *mail_valid_net (char *name,DRIVER *drv,char *host,char *mailbox)
+{
+  NETMBX mb;
+  if (!mail_valid_net_parse (name,&mb) || strcmp (mb.service,drv->name))
+    return NIL;
+  if (host) strcpy (host,mb.host);
+  if (mailbox) strcpy (mailbox,mb.mailbox);
+  return drv;
+}
+
+
+/* Mail validate network mailbox name
+ * Accepts: mailbox name
+ *	    NETMBX structure to return values
+ * Returns: T on success, NIL on failure
+ */
+
+long mail_valid_net_parse (char *name,NETMBX *mb)
+{
+  return mail_valid_net_parse_work (name,mb,"imap");
+}
+
+/* Mail validate network mailbox name worker routine
+ * Accepts: mailbox name
+ *	    NETMBX structure to return values
+ *	    default service
+ * Returns: T on success, NIL on failure
+ */
+
+long mail_valid_net_parse_work (char *name,NETMBX *mb,char *service)
+{
+  int i,j;
+  char c,*s,*t,*v,tmp[MAILTMPLEN],arg[MAILTMPLEN];
+				/* initialize structure */
+  memset (mb,'\0',sizeof (NETMBX));
+				/* must have host specification */
+  if (*name++ != '{') return NIL;
+  if (*name == '[') {		/* if domain literal, find its ending */
+    if (!((v = strpbrk (name,"]}")) && (*v++ == ']'))) return NIL;
+  }
+				/* find end of host name */
+  else if (!(v = strpbrk (name,"/:}"))) return NIL;
+				/* validate length, find mailbox part */
+  if (!((i = v - name) && (i < NETMAXHOST) && (t = strchr (v,'}')) &&
+	((j = t - v) < MAILTMPLEN) && (strlen (t+1) < (size_t) NETMAXMBX)))
+    return NIL;			/* invalid mailbox */
+  strncpy (mb->host,name,i);	/* set host name */
+  strncpy (mb->orighost,name,i);
+  mb->host[i] = mb->orighost[i] = '\0';
+  strcpy (mb->mailbox,t+1);	/* set mailbox name */
+  if (t - v) {			/* any switches or port specification? */
+    strncpy (t = tmp,v,j);	/* copy it */
+    tmp[j] = '\0';		/* tie it off */
+    c = *t++;			/* get first delimiter */
+    do switch (c) {		/* act based upon the character */
+    case ':':			/* port specification */
+      if (mb->port || !(mb->port = strtoul (t,&t,10))) return NIL;
+      c = t ? *t++ : '\0';	/* get delimiter, advance pointer */
+      break;
+    case '/':			/* switch */
+				/* find delimiter */
+      if (t = strpbrk (s = t,"/:=")) {
+	c = *t;			/* remember delimiter for later */
+	*t++ = '\0';		/* tie off switch name */
+      }
+      else c = '\0';		/* no delimiter */
+      if (c == '=') {		/* parse switches which take arguments */
+	if (*t == '"') {	/* quoted string? */
+	  for (v = arg,i = 0,++t; (c = *t++) != '"';) {
+	    if (!c) return NIL;	/* unterminated string */
+				/* quote next character */
+	    if (c == '\\') c = *t++;
+	    if (!c) return NIL;	/* can't quote NUL either */
+	    arg[i++] = c;
+	  }
+	  c = *t++;		/* remember delimiter for later */
+	  arg[i] = '\0';	/* tie off argument */
+	}
+	else {			/* non-quoted argument */
+	  if (t = strpbrk (v = t,"/:")) {
+	    c = *t;		/* remember delimiter for later */
+	    *t++ = '\0';	/* tie off switch name */
+	  }
+	  else c = '\0';	/* no delimiter */
+	  i = strlen (v);	/* length of argument */
+	}
+	if (!compare_cstring (s,"service") && (i < NETMAXSRV) && !*mb->service)
+	  lcase (strcpy (mb->service,v));
+	else if (!compare_cstring (s,"user") && (i < NETMAXUSER) && !*mb->user)
+	  strcpy (mb->user,v);
+	else if (!compare_cstring (s,"authuser") && (i < NETMAXUSER) &&
+		 !*mb->authuser) strcpy (mb->authuser,v);
+	else return NIL;
+      }
+
+      else {			/* non-argument switch */
+	if (!compare_cstring (s,"anonymous")) mb->anoflag = T;
+	else if (!compare_cstring (s,"debug")) mb->dbgflag = T;
+	else if (!compare_cstring (s,"readonly")) mb->readonlyflag = T;
+	else if (!compare_cstring (s,"secure")) mb->secflag = T;
+	else if (!compare_cstring (s,"norsh")) mb->norsh = T;
+	else if (!compare_cstring (s,"loser")) mb->loser = T;
+	else if (!compare_cstring (s,"tls") && !mb->notlsflag)
+	  mb->tlsflag = T;
+	else if (!compare_cstring (s,"tls-sslv23") && !mb->notlsflag)
+	  mb->tlssslv23 = mb->tlsflag = T;
+	else if (!compare_cstring (s,"notls") && !mb->tlsflag)
+	  mb->notlsflag = T;
+	else if (!compare_cstring (s,"tryssl"))
+	  mb->trysslflag = mailssldriver? T : NIL;
+	else if (mailssldriver && !compare_cstring (s,"ssl") && !mb->tlsflag)
+	  mb->sslflag = mb->notlsflag = T;
+	else if (mailssldriver && !compare_cstring (s,"novalidate-cert"))
+	  mb->novalidate = T;
+				/* hack for compatibility with the past */
+	else if (mailssldriver && !compare_cstring (s,"validate-cert"));
+				/* service switches below here */
+	else if (*mb->service) return NIL;
+	else if (!compare_cstring (s,"imap") ||
+		 !compare_cstring (s,"nntp") ||
+		 !compare_cstring (s,"pop3") ||
+		 !compare_cstring (s,"smtp") ||
+		 !compare_cstring (s,"submit"))
+	  lcase (strcpy (mb->service,s));
+	else if (!compare_cstring (s,"imap2") ||
+		 !compare_cstring (s,"imap2bis") ||
+		 !compare_cstring (s,"imap4") ||
+		 !compare_cstring (s,"imap4rev1"))
+	  strcpy (mb->service,"imap");
+	else if (!compare_cstring (s,"pop"))
+	  strcpy (mb->service,"pop3");
+	else return NIL;	/* invalid non-argument switch */
+      }
+      break;
+    default:			/* anything else is bogus */
+      return NIL;
+    } while (c);		/* see if anything more to parse */
+  }
+				/* default mailbox name */
+  if (!*mb->mailbox) strcpy (mb->mailbox,"INBOX");
+				/* default service name */
+  if (!*mb->service) strcpy (mb->service,service);
+				/* /norsh only valid if imap */
+  if (mb->norsh && strcmp (mb->service,"imap")) return NIL;
+  return T;
+}
+
+/* Mail scan mailboxes for string
+ * Accepts: mail stream
+ *	    reference
+ *	    pattern to search
+ *	    contents to search
+ */
+
+void mail_scan (MAILSTREAM *stream,char *ref,char *pat,char *contents)
+{
+  int remote = ((*pat == '{') || (ref && *ref == '{'));
+  DRIVER *d;
+  if (ref && (strlen (ref) > NETMAXMBX)) {
+    char tmp[MAILTMPLEN];
+    sprintf (tmp,"Invalid LIST reference specification: %.80s",ref);
+    MM_LOG (tmp,ERROR);
+    return;
+  }
+  if (strlen (pat) > NETMAXMBX) {
+    char tmp[MAILTMPLEN];
+    sprintf (tmp,"Invalid LIST pattern specification: %.80s",pat);
+    MM_LOG (tmp,ERROR);
+    return;
+  }
+  if (*pat == '{') ref = NIL;	/* ignore reference if pattern is remote */
+  if (stream) {			/* if have a stream, do it for that stream */
+    if ((d = stream->dtb) && d->scan &&
+	!(((d->flags & DR_LOCAL) && remote)))
+      (*d->scan) (stream,ref,pat,contents);
+  }
+				/* otherwise do for all DTB's */
+  else for (d = maildrivers; d; d = d->next)
+    if (d->scan && !((d->flags & DR_DISABLE) ||
+		     ((d->flags & DR_LOCAL) && remote)))
+      (d->scan) (NIL,ref,pat,contents);
+}
+
+/* Mail list mailboxes
+ * Accepts: mail stream
+ *	    reference
+ *	    pattern to search
+ */
+
+void mail_list (MAILSTREAM *stream,char *ref,char *pat)
+{
+  int remote = ((*pat == '{') || (ref && *ref == '{'));
+  DRIVER *d = maildrivers;
+  if (ref && (strlen (ref) > NETMAXMBX)) {
+    char tmp[MAILTMPLEN];
+    sprintf (tmp,"Invalid LIST reference specification: %.80s",ref);
+    MM_LOG (tmp,ERROR);
+    return;
+  }
+  if (strlen (pat) > NETMAXMBX) {
+    char tmp[MAILTMPLEN];
+    sprintf (tmp,"Invalid LIST pattern specification: %.80s",pat);
+    MM_LOG (tmp,ERROR);
+    return;
+  }
+  if (*pat == '{') ref = NIL;	/* ignore reference if pattern is remote */
+  if (stream && stream->dtb) {	/* if have a stream, do it for that stream */
+    if (!(((d = stream->dtb)->flags & DR_LOCAL) && remote))
+      (*d->list) (stream,ref,pat);
+  }
+				/* otherwise do for all DTB's */
+  else do if (!((d->flags & DR_DISABLE) ||
+		((d->flags & DR_LOCAL) && remote)))
+    (d->list) (NIL,ref,pat);
+  while (d = d->next);		/* until at the end */
+}
+
+/* Mail list subscribed mailboxes
+ * Accepts: mail stream
+ *	    pattern to search
+ */
+
+void mail_lsub (MAILSTREAM *stream,char *ref,char *pat)
+{
+  int remote = ((*pat == '{') || (ref && *ref == '{'));
+  DRIVER *d = maildrivers;
+  if (ref && (strlen (ref) > NETMAXMBX)) {
+    char tmp[MAILTMPLEN];
+    sprintf (tmp,"Invalid LSUB reference specification: %.80s",ref);
+    MM_LOG (tmp,ERROR);
+    return;
+  }
+  if (strlen (pat) > NETMAXMBX) {
+    char tmp[MAILTMPLEN];
+    sprintf (tmp,"Invalid LSUB pattern specification: %.80s",pat);
+    MM_LOG (tmp,ERROR);
+    return;
+  }
+  if (*pat == '{') ref = NIL;	/* ignore reference if pattern is remote */
+  if (stream && stream->dtb) {	/* if have a stream, do it for that stream */
+    if (!(((d = stream->dtb)->flags & DR_LOCAL) && remote))
+      (*d->lsub) (stream,ref,pat);
+  }
+				/* otherwise do for all DTB's */
+  else do if (!((d->flags & DR_DISABLE) ||
+		((d->flags & DR_LOCAL) && remote)))
+    (d->lsub) (NIL,ref,pat);
+  while (d = d->next);		/* until at the end */
+}
+
+/* Mail subscribe to mailbox
+ * Accepts: mail stream
+ *	    mailbox to add to subscription list
+ * Returns: T on success, NIL on failure
+ */
+
+long mail_subscribe (MAILSTREAM *stream,char *mailbox)
+{
+  DRIVER *factory = mail_valid (stream,mailbox,"subscribe to mailbox");
+  return factory ?
+    (factory->subscribe ?
+     (*factory->subscribe) (stream,mailbox) : sm_subscribe (mailbox)) : NIL;
+}
+
+
+/* Mail unsubscribe to mailbox
+ * Accepts: mail stream
+ *	    mailbox to delete from subscription list
+ * Returns: T on success, NIL on failure
+ */
+
+long mail_unsubscribe (MAILSTREAM *stream,char *mailbox)
+{
+  DRIVER *factory = mail_valid (stream,mailbox,NIL);
+  return (factory && factory->unsubscribe) ?
+    (*factory->unsubscribe) (stream,mailbox) : sm_unsubscribe (mailbox);
+}
+
+/* Mail create mailbox
+ * Accepts: mail stream
+ *	    mailbox name to create
+ * Returns: T on success, NIL on failure
+ */
+
+long mail_create (MAILSTREAM *stream,char *mailbox)
+{
+  MAILSTREAM *ts;
+  char *s,*t,tmp[MAILTMPLEN];
+  size_t i;
+  DRIVER *d;
+				/* never allow names with newlines */
+  if (s = strpbrk (mailbox,"\015\012")) {
+    MM_LOG ("Can't create mailbox with such a name",ERROR);
+    return NIL;
+  }
+  if (strlen (mailbox) >= (NETMAXHOST+(NETMAXUSER*2)+NETMAXMBX+NETMAXSRV+50)) {
+    sprintf (tmp,"Can't create %.80s: %s",mailbox,(*mailbox == '{') ?
+	     "invalid remote specification" : "no such mailbox");
+    MM_LOG (tmp,ERROR);
+    return NIL;
+  }
+				/* create of INBOX invalid */
+  if (!compare_cstring (mailbox,"INBOX")) {
+    MM_LOG ("Can't create INBOX",ERROR);
+    return NIL;
+  }
+				/* validate name */
+  if (s = mail_utf7_valid (mailbox)) {
+    sprintf (tmp,"Can't create %s: %.80s",s,mailbox);
+    MM_LOG (tmp,ERROR);
+    return NIL;
+  }
+
+				/* see if special driver hack */
+  if ((mailbox[0] == '#') && ((mailbox[1] == 'd') || (mailbox[1] == 'D')) &&
+      ((mailbox[2] == 'r') || (mailbox[2] == 'R')) &&
+      ((mailbox[3] == 'i') || (mailbox[3] == 'I')) &&
+      ((mailbox[4] == 'v') || (mailbox[4] == 'V')) &&
+      ((mailbox[5] == 'e') || (mailbox[5] == 'E')) &&
+      ((mailbox[6] == 'r') || (mailbox[6] == 'R')) && (mailbox[7] == '.')) {
+				/* copy driver until likely delimiter */
+    if ((s = strpbrk (t = mailbox+8,"/\\:")) && (i = s - t)) {
+      strncpy (tmp,t,i);
+      tmp[i] = '\0';
+    } 
+    else {
+      sprintf (tmp,"Can't create mailbox %.80s: bad driver syntax",mailbox);
+      MM_LOG (tmp,ERROR);
+      return NIL;
+    }
+    for (d = maildrivers; d && strcmp (d->name,tmp); d = d->next);
+    if (d) mailbox = ++s;	/* skip past driver specification */
+    else {
+      sprintf (tmp,"Can't create mailbox %.80s: unknown driver",mailbox);
+      MM_LOG (tmp,ERROR);
+      return NIL;
+    }
+  }
+				/* use stream if one given or deterministic */
+  else if ((stream && stream->dtb) ||
+	   (((*mailbox == '{') || (*mailbox == '#')) &&
+	    (stream = mail_open (NIL,mailbox,OP_PROTOTYPE | OP_SILENT))))
+    d = stream->dtb;
+  else if ((*mailbox != '{') && (ts = default_proto (NIL))) d = ts->dtb;
+  else {			/* failed utterly */
+    sprintf (tmp,"Can't create mailbox %.80s: indeterminate format",mailbox);
+    MM_LOG (tmp,ERROR);
+    return NIL;
+  }
+  return (*d->create) (stream,mailbox);
+}
+
+/* Mail delete mailbox
+ * Accepts: mail stream
+ *	    mailbox name to delete
+ * Returns: T on success, NIL on failure
+ */
+
+long mail_delete (MAILSTREAM *stream,char *mailbox)
+{
+  DRIVER *dtb = mail_valid (stream,mailbox,"delete mailbox");
+  if (!dtb) return NIL;
+  if (((mailbox[0] == 'I') || (mailbox[0] == 'i')) &&
+      ((mailbox[1] == 'N') || (mailbox[1] == 'n')) &&
+      ((mailbox[2] == 'B') || (mailbox[2] == 'b')) &&
+      ((mailbox[3] == 'O') || (mailbox[3] == 'o')) &&
+      ((mailbox[4] == 'X') || (mailbox[4] == 'x')) && !mailbox[5]) {
+    MM_LOG ("Can't delete INBOX",ERROR);
+    return NIL;
+  }
+  return SAFE_DELETE (dtb,stream,mailbox);
+}
+
+
+/* Mail rename mailbox
+ * Accepts: mail stream
+ *	    old mailbox name
+ *	    new mailbox name
+ * Returns: T on success, NIL on failure
+ */
+
+long mail_rename (MAILSTREAM *stream,char *old,char *newname)
+{
+  char *s,tmp[MAILTMPLEN];
+  DRIVER *dtb = mail_valid (stream,old,"rename mailbox");
+  if (!dtb) return NIL;
+				/* validate name */
+  if (s = mail_utf7_valid (newname)) {
+    sprintf (tmp,"Can't rename to %s: %.80s",s,newname);
+    MM_LOG (tmp,ERROR);
+    return NIL;
+  }
+  if ((*old != '{') && (*old != '#') && mail_valid (NIL,newname,NIL)) {
+    sprintf (tmp,"Can't rename %.80s: mailbox %.80s already exists",
+	     old,newname);
+    MM_LOG (tmp,ERROR);
+    return NIL;
+  }
+  return SAFE_RENAME (dtb,stream,old,newname);
+}
+
+/* Validate mailbox as Modified UTF-7
+ * Accepts: candidate mailbox name
+ * Returns: error string if error, NIL if valid
+ */
+
+char *mail_utf7_valid (char *mailbox)
+{
+  char *s;
+  for (s = mailbox; *s; s++) {	/* make sure valid name */
+				/* reserved for future use with UTF-8 */
+    if (*s & 0x80) return "mailbox name with 8-bit octet";
+				/* validate modified UTF-7 */
+    else if (*s == '&') while (*++s != '-') switch (*s) {
+    case '\0':
+      return "unterminated modified UTF-7 name";
+    case '+':			/* valid modified BASE64 */
+    case ',':
+      break;			/* all OK so far */
+    default:			/* must be alphanumeric */
+      if (!isalnum (*s)) return "invalid modified UTF-7 name";
+      break;
+    }
+  }
+  return NIL;			/* all OK */
+}
+
+/* Mail status of mailbox
+ * Accepts: mail stream if open on this mailbox
+ *	    mailbox name
+ *	    status flags
+ * Returns: T on success, NIL on failure
+ */
+
+long mail_status (MAILSTREAM *stream,char *mbx,long flags)
+{
+  DRIVER *dtb = mail_valid (stream,mbx,"get status of mailbox");
+  if (!dtb) return NIL;		/* only if valid */
+  if (stream && ((dtb != stream->dtb) ||
+		 ((dtb->flags & DR_LOCAL) && strcmp (mbx,stream->mailbox) &&
+		  strcmp (mbx,stream->original_mailbox))))
+    stream = NIL;		/* stream not suitable */
+  return SAFE_STATUS (dtb,stream,mbx,flags);
+}
+
+
+/* Mail status of mailbox default handler
+ * Accepts: mail stream
+ *	    mailbox name
+ *	    status flags
+ * Returns: T on success, NIL on failure
+ */
+
+long mail_status_default (MAILSTREAM *stream,char *mbx,long flags)
+{
+  MAILSTATUS status;
+  unsigned long i;
+  MAILSTREAM *tstream = NIL;
+				/* make temporary stream (unless this mbx) */
+  if (!stream && !(stream = tstream =
+		   mail_open (NIL,mbx,OP_READONLY|OP_SILENT))) return NIL;
+  status.flags = flags;		/* return status values */
+  status.messages = stream->nmsgs;
+  status.recent = stream->recent;
+  if (flags & SA_UNSEEN)	/* must search to get unseen messages */
+    for (i = 1,status.unseen = 0; i <= stream->nmsgs; i++)
+      if (!mail_elt (stream,i)->seen) status.unseen++;
+  status.uidnext = stream->uid_last + 1;
+  status.uidvalidity = stream->uid_validity;
+  MM_STATUS(stream,mbx,&status);/* pass status to main program */
+  if (tstream) mail_close (tstream);
+  return T;			/* success */
+}
+
+/* Mail open
+ * Accepts: candidate stream for recycling
+ *	    mailbox name
+ *	    open options
+ * Returns: stream to use on success, NIL on failure
+ */
+
+MAILSTREAM *mail_open (MAILSTREAM *stream,char *name,long options)
+{
+  int i;
+  char c,*s,tmp[MAILTMPLEN];
+  NETMBX mb;
+  DRIVER *d;
+  switch (name[0]) {		/* see if special handling */
+  case '#':			/* possible special hacks */
+    if (((name[1] == 'M') || (name[1] == 'm')) &&
+	((name[2] == 'O') || (name[2] == 'o')) &&
+	((name[3] == 'V') || (name[3] == 'v')) &&
+	((name[4] == 'E') || (name[4] == 'e')) && (c = name[5]) &&
+	(s = strchr (name+6,c)) && (i = s - (name + 6)) && (i < MAILTMPLEN)) {
+      if (stream = mail_open (stream,s+1,options)) {
+	strncpy (tmp,name+6,i);	/* copy snarf mailbox name */
+	tmp[i] = '\0';		/* tie off name */
+	mail_parameters (stream,SET_SNARFMAILBOXNAME,(void *) tmp);
+	stream->snarf.options = options;
+	mail_ping (stream);	/* do initial snarf */
+				/* punt if can't do initial snarf */
+	if (!stream->snarf.time) stream = mail_close (stream);
+      }
+      return stream;
+    }
+				/* special POP hack */
+    else if (((name[1] == 'P') || (name[1] == 'p')) &&
+	     ((name[2] == 'O') || (name[2] == 'o')) &&
+	     ((name[3] == 'P') || (name[3] == 'p')) &&
+	     mail_valid_net_parse_work (name+4,&mb,"pop3") &&
+	!strcmp (mb.service,"pop3") && !mb.anoflag && !mb.readonlyflag) {
+      if (stream = mail_open (stream,mb.mailbox,options)) {
+	sprintf (tmp,"{%.255s",mb.host);
+	if (mb.port) sprintf (tmp + strlen (tmp),":%lu",mb.port);
+	if (mb.user[0]) sprintf (tmp + strlen (tmp),"/user=%.64s",mb.user);
+	if (mb.dbgflag) strcat (tmp,"/debug");
+	if (mb.secflag) strcat (tmp,"/secure");
+	if (mb.tlsflag) strcat (tmp,"/tls");
+	if (mb.notlsflag) strcat (tmp,"/notls");
+	if (mb.sslflag) strcat (tmp,"/ssl");
+	if (mb.trysslflag) strcat (tmp,"/tryssl");
+	if (mb.novalidate) strcat (tmp,"/novalidate-cert");
+	strcat (tmp,"/pop3/loser}");
+	mail_parameters (stream,SET_SNARFMAILBOXNAME,(void *) tmp);
+	mail_ping (stream);	/* do initial snarf */
+      }
+      return stream;		/* return local mailbox stream */
+    }
+
+    else if ((options & OP_PROTOTYPE) &&
+	     ((name[1] == 'D') || (name[1] == 'd')) &&
+	     ((name[2] == 'R') || (name[2] == 'r')) &&
+	     ((name[3] == 'I') || (name[3] == 'i')) &&
+	     ((name[4] == 'V') || (name[4] == 'v')) &&
+	     ((name[5] == 'E') || (name[5] == 'e')) &&
+	     ((name[6] == 'R') || (name[6] == 'r')) && (name[7] == '.')) {
+      sprintf (tmp,"%.80s",name+8);
+				/* tie off name at likely delimiter */
+      if (s = strpbrk (tmp,"/\\:")) *s++ = '\0';
+      else {
+	sprintf (tmp,"Can't resolve mailbox %.80s: bad driver syntax",name);
+	MM_LOG (tmp,ERROR);
+	return mail_close (stream);
+      }
+      for (d = maildrivers; d && compare_cstring (d->name,tmp); d = d->next);
+      if (d) return (*d->open) (NIL);
+      sprintf (tmp,"Can't resolve mailbox %.80s: unknown driver",name);
+      MM_LOG (tmp,ERROR);
+      return mail_close (stream);
+    }
+				/* fall through to default case */
+  default:			/* not special hack (but could be # name */
+    d = mail_valid (NIL,name,(options & OP_SILENT) ?
+		    (char *) NIL : "open mailbox");
+  }
+  return d ? mail_open_work (d,stream,name,options) : stream;
+}
+
+/* Mail open worker routine
+ * Accepts: factory
+ *	    candidate stream for recycling
+ *	    mailbox name
+ *	    open options
+ * Returns: stream to use on success, NIL on failure
+ */
+
+MAILSTREAM *mail_open_work (DRIVER *d,MAILSTREAM *stream,char *name,
+			    long options)
+{
+  int i;
+  char tmp[MAILTMPLEN];
+  NETMBX mb;
+  if (options & OP_PROTOTYPE) return (*d->open) (NIL);
+  /* name is copied here in case the caller does a re-open using
+   * stream->mailbox or stream->original_mailbox as the argument.
+   */
+  name = cpystr (name);		/* make copy of name */
+  if (stream) {			/* recycling requested? */
+    if ((stream->dtb == d) && (d->flags & DR_RECYCLE) &&
+	((d->flags & DR_HALFOPEN) || !(options & OP_HALFOPEN)) &&
+	mail_usable_network_stream (stream,name)) {
+				/* yes, checkpoint if needed */
+      if (d->flags & DR_XPOINT) mail_check (stream);
+      mail_free_cache (stream);	/* clean up stream */
+      if (stream->mailbox) fs_give ((void **) &stream->mailbox);
+      if (stream->original_mailbox)
+	fs_give ((void **) &stream->original_mailbox);
+				/* flush user flags */
+      for (i = 0; i < NUSERFLAGS; i++)
+	if (stream->user_flags[i]) fs_give ((void **) &stream->user_flags[i]);
+    }
+    else {			/* stream not recycleable, babble if net */
+      if (!stream->silent && stream->dtb && !(stream->dtb->flags&DR_LOCAL) &&
+	  mail_valid_net_parse (stream->mailbox,&mb)) {
+	sprintf (tmp,"Closing connection to %.80s",mb.host);
+	MM_LOG (tmp,(long) NIL);
+      }
+				/* flush the old stream */
+      stream = mail_close (stream);
+    }
+  }
+				/* check if driver does not support halfopen */
+  else if ((options & OP_HALFOPEN) && !(d->flags & DR_HALFOPEN)) {
+    fs_give ((void **) &name);
+    return NIL;
+  }
+
+				/* instantiate new stream if not recycling */
+  if (!stream) (*mailcache) (stream = (MAILSTREAM *)
+			     memset (fs_get (sizeof (MAILSTREAM)),0,
+				     sizeof (MAILSTREAM)),(long) 0,CH_INIT);
+  stream->dtb = d;		/* set dispatch */
+				/* set mailbox name */
+  stream->mailbox = cpystr (stream->original_mailbox = name);
+				/* initialize stream flags */
+  stream->inbox = stream->lock = NIL;
+  stream->debug = (options & OP_DEBUG) ? T : NIL;
+  stream->rdonly = (options & OP_READONLY) ? T : NIL;
+  stream->anonymous = (options & OP_ANONYMOUS) ? T : NIL;
+  stream->scache = (options & OP_SHORTCACHE) ? T : NIL;
+  stream->silent = (options & OP_SILENT) ? T : NIL;
+  stream->halfopen = (options & OP_HALFOPEN) ? T : NIL;
+  stream->secure = (options & OP_SECURE) ? T : NIL;
+  stream->tryssl = (options & OP_TRYSSL) ? T : NIL;
+  stream->mulnewsrc = (options & OP_MULNEWSRC) ? T : NIL;
+  stream->nokod = (options & OP_NOKOD) ? T : NIL;
+  stream->sniff = (options & OP_SNIFF) ? T : NIL;
+  stream->perm_seen = stream->perm_deleted = stream->perm_flagged =
+    stream->perm_answered = stream->perm_draft = stream->kwd_create = NIL;
+  stream->uid_nosticky = (d->flags & DR_NOSTICKY) ? T : NIL;
+  stream->uid_last = 0;		/* default UID validity */
+  stream->uid_validity = (unsigned long) time (0);
+				/* have driver open, flush if failed */
+  return ((*d->open) (stream)) ? stream : mail_close (stream);
+}
+
+/* Mail close
+ * Accepts: mail stream
+ *	    close options
+ * Returns: NIL, always
+ */
+
+MAILSTREAM *mail_close_full (MAILSTREAM *stream,long options)
+{
+  int i;
+  if (stream) {			/* make sure argument given */
+				/* do the driver's close action */
+    if (stream->dtb) (*stream->dtb->close) (stream,options);
+    stream->dtb = NIL;		/* resign driver */
+    if (stream->mailbox) fs_give ((void **) &stream->mailbox);
+    if (stream->original_mailbox)
+      fs_give ((void **) &stream->original_mailbox);
+    if (stream->snarf.name) fs_give ((void **) &stream->snarf.name);
+    stream->sequence++;		/* invalidate sequence */
+				/* flush user flags */
+    for (i = 0; i < NUSERFLAGS; i++)
+      if (stream->user_flags[i]) fs_give ((void **) &stream->user_flags[i]);
+    mail_free_cache (stream);	/* finally free the stream's storage */
+    if (mailfreestreamsparep && stream->sparep)
+      (*mailfreestreamsparep) (&stream->sparep);
+    if (!stream->use) fs_give ((void **) &stream);
+  }
+  return NIL;
+}
+
+/* Mail make handle
+ * Accepts: mail stream
+ * Returns: handle
+ *
+ *  Handles provide a way to have multiple pointers to a stream yet allow the
+ * stream's owner to nuke it or recycle it.
+ */
+
+MAILHANDLE *mail_makehandle (MAILSTREAM *stream)
+{
+  MAILHANDLE *handle = (MAILHANDLE *) fs_get (sizeof (MAILHANDLE));
+  handle->stream = stream;	/* copy stream */
+				/* and its sequence */
+  handle->sequence = stream->sequence;
+  stream->use++;		/* let stream know another handle exists */
+  return handle;
+}
+
+
+/* Mail release handle
+ * Accepts: Mail handle
+ */
+
+void mail_free_handle (MAILHANDLE **handle)
+{
+  MAILSTREAM *s;
+  if (*handle) {		/* only free if exists */
+				/* resign stream, flush unreferenced zombies */
+    if ((!--(s = (*handle)->stream)->use) && !s->dtb) fs_give ((void **) &s);
+    fs_give ((void **) handle);	/* now flush the handle */
+  }
+}
+
+
+/* Mail get stream handle
+ * Accepts: Mail handle
+ * Returns: mail stream or NIL if stream gone
+ */
+
+MAILSTREAM *mail_stream (MAILHANDLE *handle)
+{
+  MAILSTREAM *s = handle->stream;
+  return (s->dtb && (handle->sequence == s->sequence)) ? s : NIL;
+}
+
+/* Mail fetch cache element
+ * Accepts: mail stream
+ *	    message # to fetch
+ * Returns: cache element of this message
+ * Can also be used to create cache elements for new messages.
+ */
+
+MESSAGECACHE *mail_elt (MAILSTREAM *stream,unsigned long msgno)
+{
+  if (msgno < 1 || msgno > stream->nmsgs) {
+    char tmp[MAILTMPLEN];
+    sprintf (tmp,"Bad msgno %lu in mail_elt, nmsgs = %lu, mbx=%.80s",
+	     msgno,stream->nmsgs,stream->mailbox ? stream->mailbox : "???");
+    fatal (tmp);
+  }
+  return (MESSAGECACHE *) (*mailcache) (stream,msgno,CH_MAKEELT);
+}
+
+
+/* Mail fetch fast information
+ * Accepts: mail stream
+ *	    sequence
+ *	    option flags
+ *
+ * Generally, mail_fetch_structure is preferred
+ */
+
+void mail_fetch_fast (MAILSTREAM *stream,char *sequence,long flags)
+{
+  				/* do the driver's action */
+  if (stream->dtb && stream->dtb->fast)
+    (*stream->dtb->fast) (stream,sequence,flags);
+}
+
+
+/* Mail fetch flags
+ * Accepts: mail stream
+ *	    sequence
+ *	    option flags
+ */
+
+void mail_fetch_flags (MAILSTREAM *stream,char *sequence,long flags)
+{
+  				/* do the driver's action */
+  if (stream->dtb && stream->dtb->msgflags)
+    (*stream->dtb->msgflags) (stream,sequence,flags);
+}
+
+/* Mail fetch message overview
+ * Accepts: mail stream
+ *	    UID sequence to fetch
+ *	    pointer to overview return function
+ */
+
+void mail_fetch_overview (MAILSTREAM *stream,char *sequence,overview_t ofn)
+{
+  if (stream->dtb && mail_uid_sequence (stream,sequence) &&
+      !(stream->dtb->overview && (*stream->dtb->overview) (stream,ofn)) &&
+      mail_ping (stream))
+    mail_fetch_overview_default (stream,ofn);
+}
+
+
+/* Mail fetch message overview using sequence numbers instead of UIDs
+ * Accepts: mail stream
+ *	    sequence to fetch
+ *	    pointer to overview return function
+ */
+
+void mail_fetch_overview_sequence (MAILSTREAM *stream,char *sequence,
+				   overview_t ofn)
+{
+  if (stream->dtb && mail_sequence (stream,sequence) &&
+      !(stream->dtb->overview && (*stream->dtb->overview) (stream,ofn)) &&
+      mail_ping (stream))
+    mail_fetch_overview_default (stream,ofn);
+}
+
+
+/* Mail fetch message overview default handler
+ * Accepts: mail stream with sequence bits lit
+ *	    pointer to overview return function
+ */
+
+void mail_fetch_overview_default (MAILSTREAM *stream,overview_t ofn)
+{
+  MESSAGECACHE *elt;
+  ENVELOPE *env;
+  OVERVIEW ov;
+  unsigned long i;
+  ov.optional.lines = 0;
+  ov.optional.xref = NIL;
+  for (i = 1; i <= stream->nmsgs; i++)
+    if (((elt = mail_elt (stream,i))->sequence) &&
+	(env = mail_fetch_structure (stream,i,NIL,NIL)) && ofn) {
+      ov.subject = env->subject;
+      ov.from = env->from;
+      ov.date = env->date;
+      ov.message_id = env->message_id;
+      ov.references = env->references;
+      ov.optional.octets = elt->rfc822_size;
+      (*ofn) (stream,mail_uid (stream,i),&ov,i);
+    }
+}
+
+/* Mail fetch message structure
+ * Accepts: mail stream
+ *	    message # to fetch
+ *	    pointer to return body
+ *	    option flags
+ * Returns: envelope of this message, body returned in body value
+ *
+ * Fetches the "fast" information as well
+ */
+
+ENVELOPE *mail_fetch_structure (MAILSTREAM *stream,unsigned long msgno,
+				BODY **body,long flags)
+{
+  ENVELOPE **env;
+  BODY **b;
+  MESSAGECACHE *elt;
+  char c,*s,*hdr;
+  unsigned long hdrsize;
+  STRING bs;
+				/* do the driver's action if specified */
+  if (stream->dtb && stream->dtb->structure)
+    return (*stream->dtb->structure) (stream,msgno,body,flags);
+  if (flags & FT_UID) {		/* UID form of call */
+    if (msgno = mail_msgno (stream,msgno)) flags &= ~FT_UID;
+    else return NIL;		/* must get UID/msgno map first */
+  }
+  elt = mail_elt (stream,msgno);/* get elt for real message number */
+  if (stream->scache) {		/* short caching */
+    if (msgno != stream->msgno){/* garbage collect if not same message */
+      mail_gc (stream,GC_ENV | GC_TEXTS);
+      stream->msgno = msgno;	/* this is the current message now */
+    }
+    env = &stream->env;		/* get pointers to envelope and body */
+    b = &stream->body;
+  }
+  else {			/* get pointers to elt envelope and body */
+    env = &elt->private.msg.env;
+    b = &elt->private.msg.body;
+  }
+
+  if (stream->dtb && ((body && !*b) || !*env || (*env)->incomplete)) {
+    mail_free_envelope (env);	/* flush old envelope and body */
+    mail_free_body (b);
+				/* see if need to fetch the whole thing */
+    if (body || !elt->rfc822_size) {
+      s = (*stream->dtb->header) (stream,msgno,&hdrsize,flags & ~FT_INTERNAL);
+				/* make copy in case body fetch smashes it */
+      hdr = (char *) memcpy (fs_get ((size_t) hdrsize+1),s,(size_t) hdrsize);
+      hdr[hdrsize] = '\0';	/* tie off header */
+      (*stream->dtb->text) (stream,msgno,&bs,(flags & ~FT_INTERNAL) | FT_PEEK);
+      if (!elt->rfc822_size) elt->rfc822_size = hdrsize + SIZE (&bs);
+      if (body)			/* only parse body if requested */
+	rfc822_parse_msg (env,b,hdr,hdrsize,&bs,BADHOST,stream->dtb->flags);
+      else
+	rfc822_parse_msg (env,NIL,hdr,hdrsize,NIL,BADHOST,stream->dtb->flags);
+      fs_give ((void **) &hdr);	/* flush header */
+    }
+    else {			/* can save memory doing it this way */
+      hdr = (*stream->dtb->header) (stream,msgno,&hdrsize,flags | FT_INTERNAL);
+      if (hdrsize) {		/* in case null header */
+	c = hdr[hdrsize];	/* preserve what's there */
+	hdr[hdrsize] = '\0';	/* tie off header */
+	rfc822_parse_msg (env,NIL,hdr,hdrsize,NIL,BADHOST,stream->dtb->flags);
+	hdr[hdrsize] = c;	/* restore in case cached data */
+      }
+      else *env = mail_newenvelope ();
+    }
+  }
+				/* if need date, have date in envelope? */
+  if (!elt->day && *env && (*env)->date) mail_parse_date (elt,(*env)->date);
+				/* sigh, fill in bogus default */
+  if (!elt->day) elt->day = elt->month = 1;
+  if (body) *body = *b;		/* return the body */
+  return *env;			/* return the envelope */
+}
+
+/* Mail mark single message (internal use only)
+ * Accepts: mail stream
+ *	    elt to mark
+ *	    fetch flags
+ */
+
+static void markseen (MAILSTREAM *stream,MESSAGECACHE *elt,long flags)
+{
+  unsigned long i;
+  char sequence[20];
+  MESSAGECACHE *e;
+				/* non-peeking and needs to set \Seen? */
+  if (!(flags & FT_PEEK) && !elt->seen) {
+    if (stream->dtb->flagmsg){	/* driver wants per-message call? */
+      elt->valid = NIL;		/* do pre-alteration driver call */
+      (*stream->dtb->flagmsg) (stream,elt);
+				/* set seen, do post-alteration driver call */
+      elt->seen = elt->valid = T;
+      (*stream->dtb->flagmsg) (stream,elt);
+    }
+    if (stream->dtb->flag) {	/* driver wants one-time call?  */
+				/* better safe than sorry, save seq bits */
+      for (i = 1; i <= stream->nmsgs; i++) {
+	e = mail_elt (stream,i);
+	e->private.sequence = e->sequence;
+      }
+				/* call driver to set the message */
+      sprintf (sequence,"%lu",elt->msgno);
+      (*stream->dtb->flag) (stream,sequence,"\\Seen",ST_SET);
+				/* restore sequence bits */
+      for (i = 1; i <= stream->nmsgs; i++) {
+	e = mail_elt (stream,i);
+	e->sequence = e->private.sequence;
+      }
+    }
+				/* notify mail program of flag change */
+    MM_FLAGS (stream,elt->msgno);
+  }
+}
+
+/* Mail fetch message
+ * Accepts: mail stream
+ *	    message # to fetch
+ *	    pointer to returned length
+ *	    flags
+ * Returns: message text
+ */
+
+char *mail_fetch_message (MAILSTREAM *stream,unsigned long msgno,
+			  unsigned long *len,long flags)
+{
+  GETS_DATA md;
+  SIZEDTEXT *t;
+  STRING bs;
+  MESSAGECACHE *elt;
+  char *s,*u;
+  unsigned long i,j;
+  if (len) *len = 0;		/* default return size */
+  if (flags & FT_UID) {		/* UID form of call */
+    if (msgno = mail_msgno (stream,msgno)) flags &= ~FT_UID;
+    else return "";		/* must get UID/msgno map first */
+  }
+				/* initialize message data identifier */
+  INIT_GETS (md,stream,msgno,"",0,0);
+				/* is data already cached? */
+  if ((t = &(elt = mail_elt (stream,msgno))->private.msg.full.text)->data) {
+    markseen (stream,elt,flags);/* mark message seen */
+    return mail_fetch_text_return (&md,t,len);
+  }
+  if (!stream->dtb) return "";	/* not in cache, must have live driver */
+  if (stream->dtb->msgdata) return
+    ((*stream->dtb->msgdata) (stream,msgno,"",0,0,NIL,flags) && t->data) ?
+      mail_fetch_text_return (&md,t,len) : "";
+				/* ugh, have to do this the crufty way */
+  u = mail_fetch_header (stream,msgno,NIL,NIL,&i,flags);
+				/* copy in case text method stomps on it */
+  s = (char *) memcpy (fs_get ((size_t) i),u,(size_t) i);
+  if ((*stream->dtb->text) (stream,msgno,&bs,flags)) {
+    t = &stream->text;		/* build combined copy */
+    if (t->data) fs_give ((void **) &t->data);
+    t->data = (unsigned char *) fs_get ((t->size = i + SIZE (&bs)) + 1);
+    if (!elt->rfc822_size) elt->rfc822_size = t->size;
+    else if (elt->rfc822_size != t->size) {
+      char tmp[MAILTMPLEN];
+      sprintf (tmp,"Calculated RFC822.SIZE (%lu) != reported size (%lu)",
+	       t->size,elt->rfc822_size);
+      mm_log (tmp,WARN);	/* bug trap */
+    }
+    memcpy (t->data,s,(size_t) i);
+    for (u = (char *) t->data + i, j = SIZE (&bs); j;) {
+      memcpy (u,bs.curpos,bs.cursize);
+      u += bs.cursize;		/* update text */
+      j -= bs.cursize;
+      bs.curpos += (bs.cursize -1);
+      bs.cursize = 0;
+      (*bs.dtb->next) (&bs);	/* advance to next buffer's worth */
+    } 
+    *u = '\0';			/* tie off data */
+    u = mail_fetch_text_return (&md,t,len);
+  }
+  else u = "";
+  fs_give ((void **) &s);	/* finished with copy of header */
+  return u;
+}
+
+/* Mail fetch message header
+ * Accepts: mail stream
+ *	    message # to fetch
+ *	    MIME section specifier (#.#.#...#)
+ *	    list of lines to fetch
+ *	    pointer to returned length
+ *	    flags
+ * Returns: message header in RFC822 format
+ *
+ * Note: never calls a mailgets routine
+ */
+
+char *mail_fetch_header (MAILSTREAM *stream,unsigned long msgno,char *section,
+			 STRINGLIST *lines,unsigned long *len,long flags)
+{
+  STRING bs;
+  BODY *b = NIL;
+  SIZEDTEXT *t = NIL,rt;
+  MESSAGE *m = NIL;
+  MESSAGECACHE *elt;
+  char tmp[MAILTMPLEN];
+  if (len) *len = 0;		/* default return size */
+  if (section && (strlen (section) > (MAILTMPLEN - 20))) return "";
+  if (flags & FT_UID) {		/* UID form of call */
+    if (msgno = mail_msgno (stream,msgno)) flags &= ~FT_UID;
+    else return "";		/* must get UID/msgno map first */
+  }
+  elt = mail_elt (stream,msgno);/* get cache data */
+  if (section && *section) {	/* nested body header wanted? */
+    if (!((b = mail_body (stream,msgno,section)) &&
+	  (b->type == TYPEMESSAGE) && !strcmp (b->subtype,"RFC822")))
+      return "";		/* lose if no body or not MESSAGE/RFC822 */
+    m = b->nested.msg;		/* point to nested message */
+  }
+				/* else top-level message header wanted */
+  else m = &elt->private.msg;
+  if (m->header.text.data && mail_match_lines (lines,m->lines,flags)) {
+    if (lines) textcpy (t = &stream->text,&m->header.text);
+    else t = &m->header.text;	/* in cache, and cache is valid */
+    markseen (stream,elt,flags);/* mark message seen */
+  }
+
+  else if (stream->dtb) {	/* not in cache, has live driver? */
+    if (stream->dtb->msgdata) {	/* has driver section fetch? */
+				/* build driver section specifier */
+      if (section && *section) sprintf (tmp,"%s.HEADER",section);
+      else strcpy (tmp,"HEADER");
+      if ((*stream->dtb->msgdata) (stream,msgno,tmp,0,0,lines,flags)) {
+	t = &m->header.text;	/* fetch data */
+				/* don't need to postprocess lines */
+	if (m->lines) lines = NIL;
+	else if (lines) textcpy (t = &stream->text,&m->header.text);
+      }
+    }
+    else if (b) {		/* nested body wanted? */
+      if (stream->private.search.text) {
+	rt.data = (unsigned char *) stream->private.search.text +
+	  b->nested.msg->header.offset;
+	rt.size = b->nested.msg->header.text.size;
+	t = &rt;
+      }
+      else if ((*stream->dtb->text) (stream,msgno,&bs,flags & ~FT_INTERNAL)) {
+	if ((bs.dtb->next == mail_string_next) && !lines) {
+	  rt.data = (unsigned char *) bs.curpos + b->nested.msg->header.offset;
+	  rt.size = b->nested.msg->header.text.size;
+	  if (stream->private.search.string)
+	    stream->private.search.text = bs.curpos;
+	  t = &rt;		/* special hack to avoid extra copy */
+	}
+	else textcpyoffstring (t = &stream->text,&bs,
+			       b->nested.msg->header.offset,
+			       b->nested.msg->header.text.size);
+      }
+    }
+    else {			/* top-level header fetch */
+				/* mark message seen */
+      markseen (stream,elt,flags);
+      if (rt.data = (unsigned char *)
+	  (*stream->dtb->header) (stream,msgno,&rt.size,flags)) {
+				/* make a safe copy if need to filter */
+	if (lines) textcpy (t = &stream->text,&rt);
+	else t = &rt;		/* top level header */
+      }
+    }
+  }
+  if (!t || !t->data) return "";/* error if no string */
+				/* filter headers if requested */
+  if (lines) t->size = mail_filter ((char *) t->data,t->size,lines,flags);
+  if (len) *len = t->size;	/* return size if requested */
+  return (char *) t->data;	/* and text */
+}
+
+/* Mail fetch message text
+ * Accepts: mail stream
+ *	    message # to fetch
+ *	    MIME section specifier (#.#.#...#)
+ *	    pointer to returned length
+ *	    flags
+ * Returns: message text
+ */
+
+char *mail_fetch_text (MAILSTREAM *stream,unsigned long msgno,char *section,
+		       unsigned long *len,long flags)
+{
+  GETS_DATA md;
+  PARTTEXT *p;
+  STRING bs;
+  MESSAGECACHE *elt;
+  BODY *b = NIL;
+  char tmp[MAILTMPLEN];
+  unsigned long i;
+  if (len) *len = 0;		/* default return size */
+  memset (&stream->private.string,NIL,sizeof (STRING));
+  if (section && (strlen (section) > (MAILTMPLEN - 20))) return "";
+  if (flags & FT_UID) {		/* UID form of call */
+    if (msgno = mail_msgno (stream,msgno)) flags &= ~FT_UID;
+    else return "";		/* must get UID/msgno map first */
+  }
+  elt = mail_elt (stream,msgno);/* get cache data */
+  if (section && *section) {	/* nested body text wanted? */
+    if (!((b = mail_body (stream,msgno,section)) &&
+	  (b->type == TYPEMESSAGE) && !strcmp (b->subtype,"RFC822")))
+      return "";		/* lose if no body or not MESSAGE/RFC822 */
+    p = &b->nested.msg->text;	/* point at nested message */
+				/* build IMAP-format section specifier */
+    sprintf (tmp,"%s.TEXT",section);
+    flags &= ~FT_INTERNAL;	/* can't win with this set */
+  }
+  else {			/* top-level message text wanted */
+    p = &elt->private.msg.text;
+    strcpy (tmp,"TEXT");
+  }
+				/* initialize message data identifier */
+  INIT_GETS (md,stream,msgno,section,0,0);
+  if (p->text.data) {		/* is data already cached? */
+    markseen (stream,elt,flags);/* mark message seen */
+    return mail_fetch_text_return (&md,&p->text,len);
+  }
+  if (!stream->dtb) return "";	/* not in cache, must have live driver */
+  if (stream->dtb->msgdata) return
+    ((*stream->dtb->msgdata) (stream,msgno,tmp,0,0,NIL,flags) && p->text.data)?
+      mail_fetch_text_return (&md,&p->text,len) : "";
+  if (!(*stream->dtb->text) (stream,msgno,&bs,flags)) return "";
+  if (section && *section) {	/* nested is more complex */
+    SETPOS (&bs,p->offset);
+    i = p->text.size;		/* just want this much */
+  }
+  else i = SIZE (&bs);		/* want entire text */
+  return mail_fetch_string_return (&md,&bs,i,len,flags);
+}
+
+/* Mail fetch message body part MIME headers
+ * Accepts: mail stream
+ *	    message # to fetch
+ *	    MIME section specifier (#.#.#...#)
+ *	    pointer to returned length
+ *	    flags
+ * Returns: message text
+ */
+
+char *mail_fetch_mime (MAILSTREAM *stream,unsigned long msgno,char *section,
+		       unsigned long *len,long flags)
+{
+  PARTTEXT *p;
+  STRING bs;
+  BODY *b;
+  char tmp[MAILTMPLEN];
+  if (len) *len = 0;		/* default return size */
+  if (section && (strlen (section) > (MAILTMPLEN - 20))) return "";
+  if (flags & FT_UID) {		/* UID form of call */
+    if (msgno = mail_msgno (stream,msgno)) flags &= ~FT_UID;
+    else return "";		/* must get UID/msgno map first */
+  }
+  flags &= ~FT_INTERNAL;	/* can't win with this set */
+  if (!(section && *section && (b = mail_body (stream,msgno,section))))
+    return "";			/* not valid section */
+				/* in cache? */
+  if ((p = &b->mime)->text.data) {
+				/* mark message seen */
+    markseen (stream,mail_elt (stream,msgno),flags);
+    if (len) *len = p->text.size;
+    return (char *) p->text.data;
+  }
+  if (!stream->dtb) return "";	/* not in cache, must have live driver */
+  if (stream->dtb->msgdata) {	/* has driver fetch? */
+				/* build driver section specifier */
+    sprintf (tmp,"%s.MIME",section);
+    if ((*stream->dtb->msgdata) (stream,msgno,tmp,0,0,NIL,flags) &&
+	p->text.data) {
+      if (len) *len = p->text.size;
+      return (char *) p->text.data;
+    }
+    else return "";
+  }
+  if (len) *len = b->mime.text.size;
+  if (!b->mime.text.size) {	/* empty MIME header -- mark seen anyway */
+    markseen (stream,mail_elt (stream,msgno),flags);
+    return "";
+  }
+				/* have to get it from offset */
+  if (stream->private.search.text)
+    return stream->private.search.text + b->mime.offset;
+  if (!(*stream->dtb->text) (stream,msgno,&bs,flags)) {
+    if (len) *len = 0;
+    return "";
+  }
+  if (bs.dtb->next == mail_string_next) {
+    if (stream->private.search.string) stream->private.search.text = bs.curpos;
+    return bs.curpos + b->mime.offset;
+  }
+  return textcpyoffstring (&stream->text,&bs,b->mime.offset,b->mime.text.size);
+}
+
+/* Mail fetch message body part
+ * Accepts: mail stream
+ *	    message # to fetch
+ *	    MIME section specifier (#.#.#...#)
+ *	    pointer to returned length
+ *	    flags
+ * Returns: message body
+ */
+
+char *mail_fetch_body (MAILSTREAM *stream,unsigned long msgno,char *section,
+		       unsigned long *len,long flags)
+{
+  GETS_DATA md;
+  PARTTEXT *p;
+  STRING bs;
+  BODY *b;
+  SIZEDTEXT *t;
+  char *s,tmp[MAILTMPLEN];
+  memset (&stream->private.string,NIL,sizeof (STRING));
+  if (!(section && *section))	/* top-level text wanted? */
+    return mail_fetch_message (stream,msgno,len,flags);
+  else if (strlen (section) > (MAILTMPLEN - 20)) return "";
+  flags &= ~FT_INTERNAL;	/* can't win with this set */
+				/* initialize message data identifier */
+  INIT_GETS (md,stream,msgno,section,0,0);
+				/* kludge for old section 0 header */
+  if (!strcmp (s = strcpy (tmp,section),"0") ||
+      ((s = strstr (tmp,".0")) && !s[2])) {
+    SIZEDTEXT ht;
+    *s = '\0';			/* tie off section */
+				/* this silly way so it does mailgets */
+    ht.data = (unsigned char *) mail_fetch_header (stream,msgno,
+						   tmp[0] ? tmp : NIL,NIL,
+						   &ht.size,flags);
+				/* may have UIDs here */
+    md.flags = (flags & FT_UID) ? MG_UID : NIL;
+    return mail_fetch_text_return (&md,&ht,len);
+  }
+  if (len) *len = 0;		/* default return size */
+  if (flags & FT_UID) {		/* UID form of call */
+    if (msgno = mail_msgno (stream,msgno)) flags &= ~FT_UID;
+    else return "";		/* must get UID/msgno map first */
+  }
+				/* must have body */
+  if (!(b = mail_body (stream,msgno,section))) return "";
+				/* have cached text? */
+  if ((t = &(p = &b->contents)->text)->data) {
+				/* mark message seen */
+    markseen (stream,mail_elt (stream,msgno),flags);
+    return mail_fetch_text_return (&md,t,len);
+  }
+  if (!stream->dtb) return "";	/* not in cache, must have live driver */
+  if (stream->dtb->msgdata) return
+    ((*stream->dtb->msgdata)(stream,msgno,section,0,0,NIL,flags) && t->data) ?
+      mail_fetch_text_return (&md,t,len) : "";
+  if (len) *len = t->size;
+  if (!t->size) {		/* empty body part -- mark seen anyway */
+    markseen (stream,mail_elt (stream,msgno),flags);
+    return "";
+  }
+				/* copy body from stringstruct offset */
+  if (stream->private.search.text)
+    return stream->private.search.text + p->offset;
+  if (!(*stream->dtb->text) (stream,msgno,&bs,flags)) {
+    if (len) *len = 0;
+    return "";
+  }
+  if (bs.dtb->next == mail_string_next) {
+    if (stream->private.search.string) stream->private.search.text = bs.curpos;
+    return bs.curpos + p->offset;
+  }
+  SETPOS (&bs,p->offset);
+  return mail_fetch_string_return (&md,&bs,t->size,len,flags);
+}
+
+/* Mail fetch partial message text
+ * Accepts: mail stream
+ *	    message # to fetch
+ *	    MIME section specifier (#.#.#...#)
+ *	    offset of first designed byte or 0 to start at beginning
+ *	    maximum number of bytes or 0 for all bytes
+ *	    flags
+ * Returns: T if successful, else NIL
+ */
+
+long mail_partial_text (MAILSTREAM *stream,unsigned long msgno,char *section,
+			unsigned long first,unsigned long last,long flags)
+{
+  GETS_DATA md;
+  PARTTEXT *p = NIL;
+  MESSAGECACHE *elt;
+  STRING bs;
+  BODY *b;
+  char tmp[MAILTMPLEN];
+  unsigned long i;
+  if (!mailgets) fatal ("mail_partial_text() called without a mailgets!");
+  if (section && (strlen (section) > (MAILTMPLEN - 20))) return NIL;
+  if (flags & FT_UID) {		/* UID form of call */
+    if (msgno = mail_msgno (stream,msgno)) flags &= ~FT_UID;
+    else return NIL;		/* must get UID/msgno map first */
+  }
+  elt = mail_elt (stream,msgno);/* get cache data */
+  flags &= ~FT_INTERNAL;	/* bogus if this is set */
+  if (section && *section) {	/* nested body text wanted? */
+    if (!((b = mail_body (stream,msgno,section)) &&
+	  (b->type == TYPEMESSAGE) && !strcmp (b->subtype,"RFC822")))
+      return NIL;		/* lose if no body or not MESSAGE/RFC822 */
+    p = &b->nested.msg->text;	/* point at nested message */
+				/* build IMAP-format section specifier */
+    sprintf (tmp,"%s.TEXT",section);
+  }
+  else {			/* else top-level message text wanted */
+    p = &elt->private.msg.text;
+    strcpy (tmp,"TEXT");
+  }
+
+				/* initialize message data identifier */
+  INIT_GETS (md,stream,msgno,tmp,first,last);
+  if (p->text.data) {		/* is data already cached? */
+    INIT (&bs,mail_string,p->text.data,i = p->text.size);
+    markseen (stream,elt,flags);/* mark message seen */
+  }
+  else {			/* else get data from driver */
+    if (!stream->dtb) return NIL;
+    if (stream->dtb->msgdata)	/* driver will handle this */
+      return (*stream->dtb->msgdata) (stream,msgno,tmp,first,last,NIL,flags);
+    if (!(*stream->dtb->text) (stream,msgno,&bs,flags)) return NIL;
+    if (section && *section) {	/* nexted if more complex */
+      SETPOS (&bs,p->offset);	/* offset stringstruct to data */
+      i = p->text.size;		/* maximum size of data */
+    }
+    else i = SIZE (&bs);	/* just want this much */
+  }
+  if (i <= first) i = first = 0;/* first byte is beyond end of text */
+				/* truncate as needed */
+  else {			/* offset and truncate */
+    SETPOS (&bs,first + GETPOS (&bs));
+    i -= first;			/* reduced size */
+    if (last && (i > last)) i = last;
+  }
+				/* do the mailgets thing */
+  (*mailgets) (mail_read,&bs,i,&md);
+  return T;			/* success */
+}
+
+/* Mail fetch partial message body part
+ * Accepts: mail stream
+ *	    message # to fetch
+ *	    MIME section specifier (#.#.#...#)
+ *	    offset of first designed byte or 0 to start at beginning
+ *	    maximum number of bytes or 0 for all bytes
+ *	    flags
+ * Returns: T if successful, else NIL
+ */
+
+long mail_partial_body (MAILSTREAM *stream,unsigned long msgno,char *section,
+			unsigned long first,unsigned long last,long flags)
+{
+  GETS_DATA md;
+  PARTTEXT *p;
+  STRING bs;
+  BODY *b;
+  SIZEDTEXT *t;
+  unsigned long i;
+  if (!(section && *section))	/* top-level text wanted? */
+    return mail_partial_text (stream,msgno,NIL,first,last,flags);
+  if (!mailgets) fatal ("mail_partial_body() called without a mailgets!");
+  if (flags & FT_UID) {		/* UID form of call */
+    if (msgno = mail_msgno (stream,msgno)) flags &= ~FT_UID;
+    else return NIL;		/* must get UID/msgno map first */
+  }
+				/* must have body */
+  if (!(b = mail_body (stream,msgno,section))) return NIL;
+  flags &= ~FT_INTERNAL;	/* bogus if this is set */
+
+				/* initialize message data identifier */
+  INIT_GETS (md,stream,msgno,section,first,last);
+				/* have cached text? */
+  if ((t = &(p = &b->contents)->text)->data) {
+				/* mark message seen */
+    markseen (stream,mail_elt (stream,msgno),flags);
+    INIT (&bs,mail_string,t->data,i = t->size);
+  }
+  else {			/* else get data from driver */
+    if (!stream->dtb) return NIL;
+    if (stream->dtb->msgdata)	/* driver will handle this */
+      return (*stream->dtb->msgdata) (stream,msgno,section,first,last,NIL,
+				      flags);
+    if (!(*stream->dtb->text) (stream,msgno,&bs,flags)) return NIL;
+    if (section && *section) {	/* nexted if more complex */
+      SETPOS (&bs,p->offset);	/* offset stringstruct to data */
+      i = t->size;		/* maximum size of data */
+    }
+    else i = SIZE (&bs);	/* just want this much */
+  }
+  if (i <= first) i = first = 0;/* first byte is beyond end of text */
+  else {			/* offset and truncate */
+    SETPOS (&bs,first + GETPOS (&bs));
+    i -= first;			/* reduced size */
+    if (last && (i > last)) i = last;
+  }
+				/* do the mailgets thing */
+  (*mailgets) (mail_read,&bs,i,&md);
+  return T;			/* success */
+}
+
+/* Mail return message text
+ * Accepts: identifier data
+ *	    sized text
+ *	    pointer to returned length
+ * Returns: text
+ */
+
+char *mail_fetch_text_return (GETS_DATA *md,SIZEDTEXT *t,unsigned long *len)
+{
+  STRING bs;
+  if (len) *len = t->size;	/* return size */
+  if (t->size && mailgets) {	/* have to do the mailgets thing? */
+				/* silly but do it anyway for consistency */
+    INIT (&bs,mail_string,t->data,t->size);
+    return (*mailgets) (mail_read,&bs,t->size,md);
+  }
+  return t->size ? (char *) t->data : "";
+}
+
+
+/* Mail return message string
+ * Accepts: identifier data
+ *	    stringstruct
+ *	    text length
+ *	    pointer to returned length
+ *	    flags
+ * Returns: text, or NIL if stringstruct returned
+ */
+
+char *mail_fetch_string_return (GETS_DATA *md,STRING *bs,unsigned long i,
+				unsigned long *len,long flags)
+{
+  char *ret = NIL;
+  if (len) *len = i;		/* return size */
+				/* return stringstruct hack */
+  if (flags & FT_RETURNSTRINGSTRUCT) {
+    memcpy (&md->stream->private.string,bs,sizeof (STRING));
+    SETPOS (&md->stream->private.string,GETPOS (&md->stream->private.string));
+  }
+				/* have to do the mailgets thing? */
+  else if (mailgets) ret = (*mailgets) (mail_read,bs,i,md);
+				/* special hack to avoid extra copy */
+  else if (bs->dtb->next == mail_string_next) ret = bs->curpos;
+				/* make string copy in memory */
+  else ret = textcpyoffstring (&md->stream->text,bs,GETPOS (bs),i);
+  return ret;
+}
+
+/* Read data from stringstruct
+ * Accepts: stringstruct
+ *	    size of data to read
+ *	    buffer to read into
+ * Returns: T, always, stringstruct updated
+ */
+
+long mail_read (void *stream,unsigned long size,char *buffer)
+{
+  unsigned long i;
+  STRING *s = (STRING *) stream;
+  while (size) {		/* until satisfied */
+    memcpy (buffer,s->curpos,i = min (s->cursize,size));
+    buffer += i;		/* update buffer */
+    size -= i;			/* note that we read this much */
+    s->curpos += --i;		/* advance that many spaces minus 1 */
+    s->cursize -= i;
+    SNX (s);			/* now use SNX to advance the last byte */
+  }
+  return T;
+}
+
+/* Mail fetch UID
+ * Accepts: mail stream
+ *	    message number
+ * Returns: UID or zero if dead stream
+ */
+
+unsigned long mail_uid (MAILSTREAM *stream,unsigned long msgno)
+{
+  unsigned long uid = mail_elt (stream,msgno)->private.uid;
+  return uid ? uid :
+    (stream->dtb && stream->dtb->uid) ? (*stream->dtb->uid) (stream,msgno) : 0;
+}
+
+
+/* Mail fetch msgno from UID
+ * Accepts: mail stream
+ *	    UID
+ * Returns: msgno or zero if failed
+ */
+
+unsigned long mail_msgno (MAILSTREAM *stream,unsigned long uid)
+{
+  unsigned long msgno,delta,first,firstuid,last,lastuid,middle,miduid;
+  if (stream->dtb) {		/* active stream? */
+    if (stream->dtb->msgno)	/* direct way */
+      return (*stream->dtb->msgno) (stream,uid);
+    else if (stream->dtb->uid) {/* indirect way */
+      /* Placeholder for now, since currently there are no drivers which
+       * have a uid method but not a msgno method
+       */
+      for (msgno = 1; msgno <= stream->nmsgs; msgno++)
+	if ((*stream->dtb->uid) (stream,msgno) == uid) return msgno;
+    }
+				/* binary search since have full map */
+    else for (first = 1,last = stream->nmsgs, delta = (first <= last) ? 1 : 0;
+	      delta &&
+	      (uid >= (firstuid = mail_elt (stream,first)->private.uid)) &&
+		(uid <= (lastuid = mail_elt (stream,last)->private.uid));) {
+				/* done if match at an endpoint */
+	if (uid == firstuid) return first;
+	if (uid == lastuid) return last;
+				/* have anything between endpoints? */
+	if (delta = ((last - first) / 2)) {
+	  if ((miduid = mail_elt (stream,middle = first + delta)->private.uid)
+	      == uid)
+	    return middle;	/* found match in middle */
+	  else if (uid < miduid) last = middle - 1;
+	  else first = middle + 1;
+	}
+    }
+  }
+  else {			/* dead stream, do linear search for UID */
+    for (msgno = 1; msgno <= stream->nmsgs; msgno++)
+      if (mail_elt (stream,msgno)->private.uid == uid) return msgno;
+  }
+  return 0;			/* didn't find the UID anywhere */
+}
+
+/* Mail fetch From string for menu
+ * Accepts: destination string
+ *	    mail stream
+ *	    message # to fetch
+ *	    desired string length
+ * Returns: string of requested length
+ */
+
+void mail_fetchfrom (char *s,MAILSTREAM *stream,unsigned long msgno,
+		     long length)
+{
+  char *t;
+  char tmp[MAILTMPLEN];
+  ENVELOPE *env = mail_fetchenvelope (stream,msgno);
+  ADDRESS *adr = env ? env->from : NIL;
+  memset (s,' ',(size_t)length);/* fill it with spaces */
+  s[length] = '\0';		/* tie off with null */
+				/* get first from address from envelope */
+  while (adr && !adr->host) adr = adr->next;
+  if (adr) {			/* if a personal name exists use it */
+    if (!(t = adr->personal))
+      sprintf (t = tmp,"%.256s@%.256s",adr->mailbox,adr->host);
+    memcpy (s,t,(size_t) min (length,(long) strlen (t)));
+  }
+}
+
+
+/* Mail fetch Subject string for menu
+ * Accepts: destination string
+ *	    mail stream
+ *	    message # to fetch
+ *	    desired string length
+ * Returns: string of no more than requested length
+ */
+
+void mail_fetchsubject (char *s,MAILSTREAM *stream,unsigned long msgno,
+			long length)
+{
+  ENVELOPE *env = mail_fetchenvelope (stream,msgno);
+  memset (s,'\0',(size_t) length+1);
+				/* copy subject from envelope */
+  if (env && env->subject) strncpy (s,env->subject,(size_t) length);
+  else *s = ' ';		/* if no subject then just a space */
+}
+
+/* Mail modify flags
+ * Accepts: mail stream
+ *	    sequence
+ *	    flag(s)
+ *	    option flags
+ */
+
+void mail_flag (MAILSTREAM *stream,char *sequence,char *flag,long flags)
+{
+  MESSAGECACHE *elt;
+  unsigned long i,uf;
+  long f;
+  short nf;
+  if (!stream->dtb) return;	/* no-op if no stream */
+  if ((stream->dtb->flagmsg || !stream->dtb->flag) &&
+      ((flags & ST_UID) ? mail_uid_sequence (stream,sequence) :
+       mail_sequence (stream,sequence)) &&
+      ((f = mail_parse_flags (stream,flag,&uf)) || uf))
+    for (i = 1,nf = (flags & ST_SET) ? T : NIL; i <= stream->nmsgs; i++)
+      if ((elt = mail_elt (stream,i))->sequence) {
+	struct {		/* old flags */
+	  unsigned int valid : 1;
+	  unsigned int seen : 1;
+	  unsigned int deleted : 1;
+	  unsigned int flagged : 1;
+	  unsigned int answered : 1;
+	  unsigned int draft : 1;
+	  unsigned long user_flags;
+	} old;
+	old.valid = elt->valid; old.seen = elt->seen;
+	old.deleted = elt->deleted; old.flagged = elt->flagged;
+	old.answered = elt->answered; old.draft = elt->draft;
+	old.user_flags = elt->user_flags;
+	elt->valid = NIL;	/* prepare for flag alteration */
+	if (stream->dtb->flagmsg) (*stream->dtb->flagmsg) (stream,elt);
+	if (f&fSEEN) elt->seen = nf;
+	if (f&fDELETED) elt->deleted = nf;
+	if (f&fFLAGGED) elt->flagged = nf;
+	if (f&fANSWERED) elt->answered = nf;
+	if (f&fDRAFT) elt->draft = nf;
+				/* user flags */
+	if (flags & ST_SET) elt->user_flags |= uf;
+	else elt->user_flags &= ~uf;
+	elt->valid = T;		/* flags now altered */
+	if ((old.valid != elt->valid) || (old.seen != elt->seen) ||
+	    (old.deleted != elt->deleted) || (old.flagged != elt->flagged) ||
+	    (old.answered != elt->answered) || (old.draft != elt->draft) ||
+	    (old.user_flags != elt->user_flags))
+	  MM_FLAGS (stream,elt->msgno);
+	if (stream->dtb->flagmsg) (*stream->dtb->flagmsg) (stream,elt);
+      }
+				/* call driver once */
+  if (stream->dtb->flag) (*stream->dtb->flag) (stream,sequence,flag,flags);
+}
+
+/* Mail search for messages
+ * Accepts: mail stream
+ *	    character set
+ *	    search program
+ *	    option flags
+ * Returns: T if successful, NIL if dead stream, NIL searchpgm or bad charset
+ */
+
+long mail_search_full (MAILSTREAM *stream,char *charset,SEARCHPGM *pgm,
+		       long flags)
+{
+  unsigned long i;
+  long ret = NIL;
+  if (!(flags & SE_RETAIN))	/* clear search vector unless retaining */
+    for (i = 1; i <= stream->nmsgs; ++i) mail_elt (stream,i)->searched = NIL;
+  if (pgm && stream->dtb)	/* must have a search program and driver */
+    ret = (*(stream->dtb->search ? stream->dtb->search : mail_search_default))
+      (stream,charset,pgm,flags);
+				/* flush search program if requested */
+  if (flags & SE_FREE) mail_free_searchpgm (&pgm);
+  return ret;
+}
+
+
+/* Mail search for messages default handler
+ * Accepts: mail stream
+ *	    character set
+ *	    search program
+ *	    option flags
+ * Returns: T if successful, NIL if bad charset
+ */
+
+long mail_search_default (MAILSTREAM *stream,char *charset,SEARCHPGM *pgm,
+			  long flags)
+{
+  unsigned long i;
+  char *msg;
+				/* make sure that charset is good */
+  if (msg = utf8_badcharset (charset)) {
+    MM_LOG (msg,ERROR);		/* output error */
+    fs_give ((void **) &msg);
+    return NIL;
+  }
+  utf8_searchpgm (pgm,charset);
+  for (i = 1; i <= stream->nmsgs; ++i)
+    if (mail_search_msg (stream,i,NIL,pgm)) {
+      if (flags & SE_UID) mm_searched (stream,mail_uid (stream,i));
+      else {			/* mark as searched, notify mail program */
+	mail_elt (stream,i)->searched = T;
+	if (!stream->silent) mm_searched (stream,i);
+      }
+    }
+  return LONGT;		/* search completed */
+}
+
+/* Mail ping mailbox
+ * Accepts: mail stream
+ * Returns: stream if still open else NIL
+ */
+
+long mail_ping (MAILSTREAM *stream)
+{
+  unsigned long i,n,uf,len;
+  char *s,*f,tmp[MAILTMPLEN],flags[MAILTMPLEN];
+  MAILSTREAM *snarf;
+  MESSAGECACHE *elt;
+  STRING bs;
+  long ret;
+				/* do driver action */
+  if ((ret = ((stream && stream->dtb) ? (stream->dtb->ping) (stream) : NIL)) &&
+      stream->snarf.name &&	/* time to snarf? */
+				/* prohibit faster than once/min */
+      (time (0) > (time_t) (stream->snarf.time + min(60,mailsnarfinterval))) &&
+      (snarf = mail_open (NIL,stream->snarf.name,
+			  stream->snarf.options | OP_SILENT))) {
+    if ((n = snarf->nmsgs) &&	/* yes, have messages to snarf? */
+	mail_search_full (snarf,NIL,mail_criteria ("UNDELETED"),SE_FREE)) {
+      for (i = 1; ret && (i <= n); i++)	/* for each message */
+	if ((elt = mail_elt (snarf,i))->searched &&
+	    (s = mail_fetch_message (snarf,i,&len,FT_PEEK)) && len) {
+	  INIT (&bs,mail_string,s,len);
+	  if (mailsnarfpreserve) {
+				/* yes, make sure have fast data */
+	    if (!elt->valid || !elt->day) {
+	      sprintf (tmp,"%lu",n);
+	      mail_fetch_fast (snarf,tmp,NIL);
+	    }
+				/* initialize flag string */
+	    memset (flags,0,MAILTMPLEN);
+				/* output system flags except \Deleted */
+	    if (elt->seen) strcat (flags," \\Seen");
+	    if (elt->flagged) strcat (flags," \\Flagged");
+	    if (elt->answered) strcat (flags," \\Answered");
+	    if (elt->draft) strcat (flags," \\Draft");
+				/* any user flags? */
+	    for (uf = elt->user_flags,s = flags + strlen (flags);
+		 uf && (f = stream->user_flags[find_rightmost_bit (&uf)]) &&
+		   ((MAILTMPLEN - (s - tmp)) > (long) (2 + strlen (f)));
+		 s += strlen (s)) sprintf (s," %s",f);
+	    ret = mail_append_full (stream,stream->mailbox,flags + 1,
+				    mail_date (tmp,elt),&bs);
+	  }
+	  else ret = mail_append (stream,stream->mailbox,&bs);
+
+	  if (ret) {		/* did snarf succeed? */
+				/* driver has per-message (or no) flag call */
+	    if (snarf->dtb->flagmsg || !snarf->dtb->flag) {
+	      elt->valid = NIL;	/* prepare for flag alteration */
+	      if (snarf->dtb->flagmsg) (*snarf->dtb->flagmsg) (snarf,elt);
+				/* flags now altered */
+	      elt->deleted = elt->seen = elt->valid = T;
+	      if (snarf->dtb->flagmsg) (*snarf->dtb->flagmsg) (snarf,elt);
+	    }
+				/* driver has one-time flag call */
+	    if (snarf->dtb->flag) {
+	      sprintf (tmp,"%lu",i);
+	      (*snarf->dtb->flag) (snarf,tmp,"\\Deleted \\Seen",ST_SET);
+	    }
+	  }
+	  else {		/* copy failed */
+	    sprintf (tmp,"Unable to move message %lu from %s mailbox",
+		     i,snarf->dtb->name);
+	    mm_log (tmp,WARN);
+	  }
+	}
+    }
+				/* expunge the messages */
+    mail_close_full (snarf,n ? CL_EXPUNGE : NIL);
+    stream->snarf.time = (unsigned long) time (0);
+    /* Even if the snarf failed, we don't want to return NIL if the stream
+     * is still alive.  Or at least that's what we currently think.
+     */
+  				/* redo the driver's action */
+    ret = stream->dtb ? (*stream->dtb->ping) (stream) : NIL;
+  }
+  return ret;
+}
+
+/* Mail check mailbox
+ * Accepts: mail stream
+ */
+
+void mail_check (MAILSTREAM *stream)
+{
+  				/* do the driver's action */
+  if (stream->dtb) (*stream->dtb->check) (stream);
+}
+
+
+/* Mail expunge mailbox
+ * Accepts: mail stream
+ *	    sequence to expunge if non-NIL
+ *	    expunge options
+ * Returns: T on success, NIL on failure
+ */
+
+long mail_expunge_full (MAILSTREAM *stream,char *sequence,long options)
+{
+  				/* do the driver's action */
+  return stream->dtb ? (*stream->dtb->expunge) (stream,sequence,options) : NIL;
+}
+
+
+/* Mail copy message(s)
+ * Accepts: mail stream
+ *	    sequence
+ *	    destination mailbox
+ *	    flags
+ */
+
+long mail_copy_full (MAILSTREAM *stream,char *sequence,char *mailbox,
+		     long options)
+{
+  return stream->dtb ?
+    SAFE_COPY (stream->dtb,stream,sequence,mailbox,options) : NIL;
+}
+
+/* Append data package to use for old single-message mail_append() interface */
+
+typedef struct mail_append_package {
+  char *flags;			/* initial flags */
+  char *date;			/* message internal date */
+  STRING *message;		/* stringstruct of message */
+} APPENDPACKAGE;
+
+
+/* Single append message string
+ * Accepts: mail stream
+ *	    package pointer (cast as a void *)
+ *	    pointer to return initial flags
+ *	    pointer to return message internal date
+ *	    pointer to return stringstruct of message to append
+ * Returns: T, always
+ */
+
+static long mail_append_single (MAILSTREAM *stream,void *data,char **flags,
+				char **date,STRING **message)
+{
+  APPENDPACKAGE *ap = (APPENDPACKAGE *) data;
+  *flags = ap->flags;		/* get desired data from the package */
+  *date = ap->date;
+  *message = ap->message;
+  ap->message = NIL;		/* so next callback puts a stop to it */
+  return LONGT;			/* always return success */
+}
+
+
+/* Mail append message string
+ * Accepts: mail stream
+ *	    destination mailbox
+ *	    initial flags
+ *	    message internal date
+ *	    stringstruct of message to append
+ * Returns: T on success, NIL on failure
+ */
+
+long mail_append_full (MAILSTREAM *stream,char *mailbox,char *flags,char *date,
+		       STRING *message)
+{
+  APPENDPACKAGE ap;
+  ap.flags = flags;		/* load append package */
+  ap.date = date;
+  ap.message = message;
+  return mail_append_multiple (stream,mailbox,mail_append_single,(void *) &ap);
+}
+
+/* Mail append message(s)
+ * Accepts: mail stream
+ *	    destination mailbox
+ *	    append data callback
+ *	    arbitrary data for callback use
+ * Returns: T on success, NIL on failure
+ */
+
+long mail_append_multiple (MAILSTREAM *stream,char *mailbox,append_t af,
+			   void *data)
+{
+  char *s,tmp[MAILTMPLEN];
+  DRIVER *d = NIL;
+  long ret = NIL;
+				/* never allow names with newlines */
+  if (strpbrk (mailbox,"\015\012"))
+    MM_LOG ("Can't append to mailbox with such a name",ERROR);
+  else if (strlen (mailbox) >=
+	   (NETMAXHOST+(NETMAXUSER*2)+NETMAXMBX+NETMAXSRV+50)) {
+    sprintf (tmp,"Can't append %.80s: %s",mailbox,(*mailbox == '{') ?
+	     "invalid remote specification" : "no such mailbox");
+    MM_LOG (tmp,ERROR);
+  }
+				/* special driver hack? */
+  else if (!strncmp (lcase (strcpy (tmp,mailbox)),"#driver.",8)) {
+				/* yes, tie off name at likely delimiter */
+    if (!(s = strpbrk (tmp+8,"/\\:"))) {
+      sprintf (tmp,"Can't append to mailbox %.80s: bad driver syntax",mailbox);
+      MM_LOG (tmp,ERROR);
+      return NIL;
+    }
+    *s++ = '\0';		/* tie off at delimiter */
+    if (!(d = (DRIVER *) mail_parameters (NIL,GET_DRIVER,tmp+8))) {
+      sprintf (tmp,"Can't append to mailbox %.80s: unknown driver",mailbox);
+      MM_LOG (tmp,ERROR);
+    }
+    else ret = SAFE_APPEND (d,stream,mailbox + (s - tmp),af,data);
+  }
+  else if (d = mail_valid (stream,mailbox,NIL))
+    ret = SAFE_APPEND (d,stream,mailbox,af,data);
+  /* No driver, try for TRYCREATE if no stream.  Note that we use the
+   * createProto here, not the appendProto, since the dummy driver already
+   * took care of the appendProto case.  Otherwise, if appendProto is set to
+   * NIL, we won't get a TRYCREATE.
+   */
+  else if (!stream && (stream = default_proto (NIL)) && stream->dtb &&
+	   SAFE_APPEND (stream->dtb,stream,mailbox,af,data))
+				/* timing race? */
+    MM_NOTIFY (stream,"Append validity confusion",WARN);
+				/* generate error message */
+  else mail_valid (stream,mailbox,"append to mailbox");
+  return ret;
+}
+
+/* Mail garbage collect stream
+ * Accepts: mail stream
+ *	    garbage collection flags
+ */
+
+void mail_gc (MAILSTREAM *stream,long gcflags)
+{
+  MESSAGECACHE *elt;
+  unsigned long i;
+  				/* do the driver's action first */
+  if (stream->dtb && stream->dtb->gc) (*stream->dtb->gc) (stream,gcflags);
+  stream->msgno = 0;		/* nothing cached now */
+  if (gcflags & GC_ENV) {	/* garbage collect envelopes? */
+    if (stream->env) mail_free_envelope (&stream->env);
+    if (stream->body) mail_free_body (&stream->body);
+  }
+  if (gcflags & GC_TEXTS) {	/* free texts */
+    if (stream->text.data) fs_give ((void **) &stream->text.data);
+    stream->text.size = 0;
+  }
+				/* garbage collect per-message stuff */
+  for (i = 1; i <= stream->nmsgs; i++) 
+    if (elt = (MESSAGECACHE *) (*mailcache) (stream,i,CH_ELT))
+      mail_gc_msg (&elt->private.msg,gcflags);
+}
+
+
+/* Mail garbage collect message
+ * Accepts: message structure
+ *	    garbage collection flags
+ */
+
+void mail_gc_msg (MESSAGE *msg,long gcflags)
+{
+  if (gcflags & GC_ENV) {	/* garbage collect envelopes? */
+    mail_free_envelope (&msg->env);
+    mail_free_body (&msg->body);
+  }
+  if (gcflags & GC_TEXTS) {	/* garbage collect texts */
+    if (msg->full.text.data) fs_give ((void **) &msg->full.text.data);
+    if (msg->header.text.data) {
+      mail_free_stringlist (&msg->lines);
+      fs_give ((void **) &msg->header.text.data);
+    }
+    if (msg->text.text.data) fs_give ((void **) &msg->text.text.data);
+				/* now GC all body components */
+    if (msg->body) mail_gc_body (msg->body);
+  }
+}
+
+/* Mail garbage collect texts in BODY structure
+ * Accepts: BODY structure
+ */
+
+void mail_gc_body (BODY *body)
+{
+  PART *part;
+  switch (body->type) {		/* free contents */
+  case TYPEMULTIPART:		/* multiple part */
+    for (part = body->nested.part; part; part = part->next)
+      mail_gc_body (&part->body);
+    break;
+  case TYPEMESSAGE:		/* encapsulated message */
+    if (body->subtype && !strcmp (body->subtype,"RFC822")) {
+      mail_free_stringlist (&body->nested.msg->lines);
+      mail_gc_msg (body->nested.msg,GC_TEXTS);
+    }
+    break;
+  default:
+    break;
+  }
+  if (body->mime.text.data) fs_give ((void **) &body->mime.text.data);
+  if (body->contents.text.data) fs_give ((void **) &body->contents.text.data);
+}
+
+/* Mail get body part
+ * Accepts: mail stream
+ *	    message number
+ *	    section specifier
+ * Returns: pointer to body
+ */
+
+BODY *mail_body (MAILSTREAM *stream,unsigned long msgno,unsigned char *section)
+{
+  BODY *b = NIL;
+  PART *pt;
+  unsigned long i;
+				/* make sure have a body */
+  if (section && *section && mail_fetchstructure (stream,msgno,&b) && b)
+    while (*section) {		/* find desired section */
+      if (isdigit (*section)) {	/* get section specifier */
+				/* make sure what follows is valid */
+	if (!(i = strtoul (section,(char **) &section,10)) ||
+	    (*section && ((*section++ != '.') || !*section))) return NIL;
+				/* multipart content? */
+	if (b->type == TYPEMULTIPART) {
+				/* yes, find desired part */
+	  if (pt = b->nested.part) while (--i && (pt = pt->next));
+	  if (!pt) return NIL;	/* bad specifier */
+	  b = &pt->body;	/* note new body */
+	}
+				/* otherwise must be section 1 */
+	else if (i != 1) return NIL;
+				/* need to go down further? */
+	if (*section) switch (b->type) {
+	case TYPEMULTIPART:	/* multipart */
+	  break;
+	case TYPEMESSAGE:	/* embedded message */
+	  if (!strcmp (b->subtype,"RFC822")) {
+	    b = b->nested.msg->body;
+	    break;
+	  }
+	default:		/* bogus subpart specification */
+	  return NIL;
+	}
+      }
+      else return NIL;		/* unknown section specifier */
+    }
+  return b;
+}  
+
+/* Mail output date from elt fields
+ * Accepts: character string to write into
+ *	    elt to get data data from
+ * Returns: the character string
+ */
+
+const char *days[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
+
+const char *months[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
+			"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
+
+char *mail_date (char *string,MESSAGECACHE *elt)
+{
+  sprintf (string,"%2d-%s-%d %02d:%02d:%02d %c%02d%02d",
+	   elt->day ? elt->day : 1,
+	   months[elt->month ? (elt->month - 1) : 0],
+	   elt->year + BASEYEAR,elt->hours,elt->minutes,elt->seconds,
+	   elt->zoccident ? '-' : '+',elt->zhours,elt->zminutes);
+  return string;
+}
+
+
+/* Mail output extended-ctime format date from elt fields
+ * Accepts: character string to write into
+ *	    elt to get data data from
+ * Returns: the character string
+ */
+
+char *mail_cdate (char *string,MESSAGECACHE *elt)
+{
+  char *fmt = "%s %s %2d %02d:%02d:%02d %4d %s%02d%02d\n";
+  int d = elt->day ? elt->day : 1;
+  int m = elt->month ? (elt->month - 1) : 0;
+  int y = elt->year + BASEYEAR;
+  const char *s = months[m];
+  if (m < 2) {			/* if before March, */
+    m += 10;			/* January = month 10 of previous year */
+    y--;
+  }
+  else m -= 2;			/* March is month 0 */
+  sprintf (string,fmt,days[(int) (d + 2 + ((7 + 31 * m) / 12)
+#ifndef USEJULIANCALENDAR
+#ifndef USEORTHODOXCALENDAR	/* Gregorian calendar */
+				  + (y / 400)
+#ifdef Y4KBUGFIX
+				  - (y / 4000)
+#endif
+#else				/* Orthodox calendar */
+				  + (2 * (y / 900)) + ((y % 900) >= 200)
+				  + ((y % 900) >= 600)
+#endif
+				  - (y / 100)
+#endif
+				  + y + (y / 4)) % 7],
+	   s,d,elt->hours,elt->minutes,elt->seconds,elt->year + BASEYEAR,
+	   elt->zoccident ? "-" : "+",elt->zhours,elt->zminutes);
+  return string;
+}
+
+/* Mail parse date into elt fields
+ * Accepts: elt to write into
+ *	    date string to parse
+ * Returns: T if parse successful, else NIL 
+ * This routine parses dates as follows:
+ * . leading three alphas followed by comma and space are ignored
+ * . date accepted in format: mm/dd/yy, mm/dd/yyyy, dd-mmm-yy, dd-mmm-yyyy,
+ *    dd mmm yy, dd mmm yyyy, yyyy-mm-dd, yyyymmdd
+ * . two and three digit years interpreted according to RFC 2822 rules
+ * . mandatory end of string if yyyy-mm-dd or yyyymmdd; otherwise optional
+ *    space followed by time:
+ * . time accepted in format hh:mm:ss or hh:mm
+ * . end of string accepted
+ * . timezone accepted: hyphen followed by symbolic timezone, or space
+ *    followed by signed numeric timezone or symbolic timezone
+ * Examples of normal input:
+ * . IMAP date-only (SEARCH):
+ *    dd-mmm-yyyy
+ * . IMAP date-time (INTERNALDATE):
+ *    dd-mmm-yyyy hh:mm:ss +zzzz
+ * . RFC-822:
+ *    www, dd mmm yy hh:mm:ss zzz
+ * . RFC-2822:
+ *    www, dd mmm yyyy hh:mm:ss +zzzz
+ */
+
+long mail_parse_date (MESSAGECACHE *elt,unsigned char *s)
+{
+  unsigned long d,m,y;
+  int mi,ms;
+  struct tm *t;
+  time_t tn;
+  char tmp[MAILTMPLEN];
+  static unsigned long maxyear = 0;
+  if (!maxyear) {		/* know the end of time yet? */
+    MESSAGECACHE tmpelt;
+    memset (&tmpelt,0xff,sizeof (MESSAGECACHE));
+    maxyear = BASEYEAR + tmpelt.year;
+  }
+				/* clear elt */
+  elt->zoccident = elt->zhours = elt->zminutes =
+    elt->hours = elt->minutes = elt->seconds =
+      elt->day = elt->month = elt->year = 0;
+				/* make a writeable uppercase copy */
+  if (s && *s && (strlen (s) < (size_t)MAILTMPLEN)) s = ucase (strcpy (tmp,s));
+  else return NIL;
+				/* skip over possible day of week */
+  if (isalpha (*s) && isalpha (s[1]) && isalpha (s[2]) && (s[3] == ',') &&
+      (s[4] == ' ')) s += 5;
+  while (*s == ' ') s++;	/* parse first number (probable month) */
+  if (!(m = strtoul (s,(char **) &s,10))) return NIL;
+
+  switch (*s) {			/* different parse based on delimiter */
+  case '/':			/* mm/dd/yy format */
+    if (isdigit (*++s) && (d = strtoul (s,(char **) &s,10)) &&
+	(*s == '/') && isdigit (*++s)) {
+      y = strtoul (s,(char **) &s,10);
+      if (*s == '\0') break;	/* must end here */
+    }
+    return NIL;			/* bogon */
+  case ' ':			/* dd mmm yy format */
+    while (s[1] == ' ') s++;	/* slurp extra whitespace */
+  case '-':
+    if (isdigit (s[1])) {	/* possible ISO 8601 date format? */
+      y = m;			/* yes, first number is year */
+				/* get month and day */
+      if ((m = strtoul (s+1,(char **) &s,10)) && (*s++ == '-') && 
+	  (d = strtoul (s,(char **) &s,10)) && !*s) break;
+      return NIL;		/* syntax error or time present */
+    }
+    d = m;			/* dd-mmm-yy[yy], so first number is a day */
+				/* make sure string long enough! */
+    if (strlen (s) < (size_t) 5) return NIL;
+    /* Some compilers don't allow `<<' and/or longs in case statements. */
+				/* slurp up the month string */
+    ms = ((s[1] - 'A') * 1024) + ((s[2] - 'A') * 32) + (s[3] - 'A');
+    switch (ms) {		/* determine the month */
+    case (('J'-'A') * 1024) + (('A'-'A') * 32) + ('N'-'A'): m = 1; break;
+    case (('F'-'A') * 1024) + (('E'-'A') * 32) + ('B'-'A'): m = 2; break;
+    case (('M'-'A') * 1024) + (('A'-'A') * 32) + ('R'-'A'): m = 3; break;
+    case (('A'-'A') * 1024) + (('P'-'A') * 32) + ('R'-'A'): m = 4; break;
+    case (('M'-'A') * 1024) + (('A'-'A') * 32) + ('Y'-'A'): m = 5; break;
+    case (('J'-'A') * 1024) + (('U'-'A') * 32) + ('N'-'A'): m = 6; break;
+    case (('J'-'A') * 1024) + (('U'-'A') * 32) + ('L'-'A'): m = 7; break;
+    case (('A'-'A') * 1024) + (('U'-'A') * 32) + ('G'-'A'): m = 8; break;
+    case (('S'-'A') * 1024) + (('E'-'A') * 32) + ('P'-'A'): m = 9; break;
+    case (('O'-'A') * 1024) + (('C'-'A') * 32) + ('T'-'A'): m = 10; break;
+    case (('N'-'A') * 1024) + (('O'-'A') * 32) + ('V'-'A'): m = 11; break;
+    case (('D'-'A') * 1024) + (('E'-'A') * 32) + ('C'-'A'): m = 12; break;
+    default: return NIL;	/* unknown month */
+    }
+    if (s[4] == *s) s += 5;	/* advance to year */
+    else {			/* first three were OK, possibly full name */
+      mi = *s;			/* note delimiter, skip alphas */
+      for (s += 4; isalpha (*s); s++);
+				/* error if delimiter not here */
+      if (mi != *s++) return NIL;
+    }
+    while (*s == ' ') s++;	/* parse year */
+    if (isdigit (*s)) {		/* must be a digit here */
+      y = strtoul (s,(char **) &s,10);
+      if (*s == '\0' || *s == ' ') break;
+    }
+  case '\0':			/* ISO 8601 compact date */
+    if (m < (BASEYEAR * 10000)) return NIL;
+    y = m / 10000;		/* get year */
+    d = (m %= 10000) % 100;	/* get day */
+    m /= 100;			/* and month */
+    break;
+  default:
+    return NIL;			/* unknown date format */
+  }
+
+				/* minimal validity check of date */
+  if ((d > 31) || (m > 12)) return NIL; 
+  if (y < 49) y += 2000;	/* RFC 2282 rules for two digit years 00-49 */
+  else if (y < 999) y += 1900;	/* 2-digit years 50-99 and 3-digit years */
+				/* reject prehistoric and far future years */
+  if ((y < BASEYEAR) || (y > maxyear)) return NIL;
+				/* set values in elt */
+  elt->day = d; elt->month = m; elt->year = y - BASEYEAR;
+  ms = '\0';			/* initially no time zone string */
+  if (*s) {			/* time specification present? */
+				/* parse time */
+    d = strtoul (s+1,(char **) &s,10);
+    if (*s != ':') return NIL;
+    m = strtoul (++s,(char **) &s,10);
+    y = (*s == ':') ? strtoul (++s,(char **) &s,10) : 0;
+				/* validity check time */
+    if ((d > 23) || (m > 59) || (y > 60)) return NIL; 
+				/* set values in elt */
+    elt->hours = d; elt->minutes = m; elt->seconds = y;
+    switch (*s) {		/* time zone specifier? */
+    case ' ':			/* numeric time zone */
+      while (s[1] == ' ') s++;	/* slurp extra whitespace */
+      if (!isalpha (s[1])) {	/* treat as '-' case if alphabetic */
+				/* test for sign character */
+	if ((elt->zoccident = (*++s == '-')) || (*s == '+')) s++;
+				/* validate proper timezone */
+	if (isdigit(*s) && isdigit(s[1]) && isdigit(s[2]) && (s[2] < '6') &&
+	    isdigit(s[3])) {
+	  elt->zhours = (*s - '0') * 10 + (s[1] - '0');
+	  elt->zminutes = (s[2] - '0') * 10 + (s[3] - '0');
+	}
+	return T;		/* all done! */
+      }
+				/* falls through */
+    case '-':			/* symbolic time zone */
+      if (!(ms = *++s)) ms = 'Z';
+      else if (*++s) {		/* multi-character? */
+	ms -= 'A'; ms *= 1024;	/* yes, make compressed three-byte form */
+	ms += ((*s++ - 'A') * 32);
+	if (*s) ms += *s++ - 'A';
+	if (*s) ms = '\0';	/* more than three characters */
+      }
+    default:			/* ignore anything else */
+      break;
+    }
+  }
+
+  /*  This is not intended to be a comprehensive list of all possible
+   * timezone strings.  Such a list would be impractical.  Rather, this
+   * listing is intended to incorporate all military, North American, and
+   * a few special cases such as Japan and the major European zone names,
+   * such as what might be expected to be found in a Tenex format mailbox
+   * and spewed from an IMAP server.  The trend is to migrate to numeric
+   * timezones which lack the flavor but also the ambiguity of the names.
+   *
+   *  RFC-822 only recognizes UT, GMT, 1-letter military timezones, and the
+   * 4 CONUS timezones and their summer time variants.  [Sorry, Canadian
+   * Atlantic Provinces, Alaska, and Hawaii.]
+   */
+  switch (ms) {			/* determine the timezone */
+				/* Universal */
+  case (('U'-'A')*1024)+(('T'-'A')*32):
+#ifndef STRICT_RFC822_TIMEZONES
+  case (('U'-'A')*1024)+(('T'-'A')*32)+'C'-'A':
+#endif
+				/* Greenwich */
+  case (('G'-'A')*1024)+(('M'-'A')*32)+'T'-'A':
+  case 'Z': elt->zhours = 0; break;
+
+    /* oriental (from Greenwich) timezones */
+#ifndef STRICT_RFC822_TIMEZONES
+				/* Middle Europe */
+  case (('M'-'A')*1024)+(('E'-'A')*32)+'T'-'A':
+#endif
+#ifdef BRITISH_SUMMER_TIME
+				/* British Summer */
+  case (('B'-'A')*1024)+(('S'-'A')*32)+'T'-'A':
+#endif
+  case 'A': elt->zhours = 1; break;
+#ifndef STRICT_RFC822_TIMEZONES
+				/* Eastern Europe */
+  case (('E'-'A')*1024)+(('E'-'A')*32)+'T'-'A':
+#endif
+  case 'B': elt->zhours = 2; break;
+  case 'C': elt->zhours = 3; break;
+  case 'D': elt->zhours = 4; break;
+  case 'E': elt->zhours = 5; break;
+  case 'F': elt->zhours = 6; break;
+  case 'G': elt->zhours = 7; break;
+  case 'H': elt->zhours = 8; break;
+#ifndef STRICT_RFC822_TIMEZONES
+				/* Japan */
+  case (('J'-'A')*1024)+(('S'-'A')*32)+'T'-'A':
+#endif
+  case 'I': elt->zhours = 9; break;
+  case 'K': elt->zhours = 10; break;
+  case 'L': elt->zhours = 11; break;
+  case 'M': elt->zhours = 12; break;
+
+	/* occidental (from Greenwich) timezones */
+  case 'N': elt->zoccident = 1; elt->zhours = 1; break;
+  case 'O': elt->zoccident = 1; elt->zhours = 2; break;
+#ifndef STRICT_RFC822_TIMEZONES
+  case (('A'-'A')*1024)+(('D'-'A')*32)+'T'-'A':
+#endif
+  case 'P': elt->zoccident = 1; elt->zhours = 3; break;
+#ifdef NEWFOUNDLAND_STANDARD_TIME
+				/* Newfoundland */
+  case (('N'-'A')*1024)+(('S'-'A')*32)+'T'-'A':
+    elt->zoccident = 1; elt->zhours = 3; elt->zminutes = 30; break;
+#endif
+#ifndef STRICT_RFC822_TIMEZONES
+				/* Atlantic */
+  case (('A'-'A')*1024)+(('S'-'A')*32)+'T'-'A':
+#endif
+	/* CONUS */
+  case (('E'-'A')*1024)+(('D'-'A')*32)+'T'-'A':
+  case 'Q': elt->zoccident = 1; elt->zhours = 4; break;
+				/* Eastern */
+  case (('E'-'A')*1024)+(('S'-'A')*32)+'T'-'A':
+  case (('C'-'A')*1024)+(('D'-'A')*32)+'T'-'A':
+  case 'R': elt->zoccident = 1; elt->zhours = 5; break;
+				/* Central */
+  case (('C'-'A')*1024)+(('S'-'A')*32)+'T'-'A':
+  case (('M'-'A')*1024)+(('D'-'A')*32)+'T'-'A':
+  case 'S': elt->zoccident = 1; elt->zhours = 6; break;
+				/* Mountain */
+  case (('M'-'A')*1024)+(('S'-'A')*32)+'T'-'A':
+  case (('P'-'A')*1024)+(('D'-'A')*32)+'T'-'A':
+  case 'T': elt->zoccident = 1; elt->zhours = 7; break;
+				/* Pacific */
+  case (('P'-'A')*1024)+(('S'-'A')*32)+'T'-'A':
+#ifndef STRICT_RFC822_TIMEZONES
+  case (('Y'-'A')*1024)+(('D'-'A')*32)+'T'-'A':
+#endif
+  case 'U': elt->zoccident = 1; elt->zhours = 8; break;
+#ifndef STRICT_RFC822_TIMEZONES
+				/* Yukon */
+  case (('Y'-'A')*1024)+(('S'-'A')*32)+'T'-'A':
+#endif
+  case 'V': elt->zoccident = 1; elt->zhours = 9; break;
+#ifndef STRICT_RFC822_TIMEZONES
+				/* Hawaii */
+  case (('H'-'A')*1024)+(('S'-'A')*32)+'T'-'A':
+#endif
+  case 'W': elt->zoccident = 1; elt->zhours = 10; break;
+				/* Nome/Bering/Samoa */
+#ifdef NOME_STANDARD_TIME
+  case (('N'-'A')*1024)+(('S'-'A')*32)+'T'-'A':
+#endif
+#ifdef BERING_STANDARD_TIME
+  case (('B'-'A')*1024)+(('S'-'A')*32)+'T'-'A':
+#endif
+#ifdef SAMOA_STANDARD_TIME
+  case (('S'-'A')*1024)+(('S'-'A')*32)+'T'-'A':
+#endif
+  case 'X': elt->zoccident = 1; elt->zhours = 11; break;
+  case 'Y': elt->zoccident = 1; elt->zhours = 12; break;
+
+  default:			/* unknown time zones treated as local */
+    tn = time (0);		/* time now... */
+    t = localtime (&tn);	/* get local minutes since midnight */
+    mi = t->tm_hour * 60 + t->tm_min;
+    ms = t->tm_yday;		/* note Julian day */
+    if (t = gmtime (&tn)) {	/* minus UTC minutes since midnight */
+      mi -= t->tm_hour * 60 + t->tm_min;
+	/* ms can be one of:
+	 *  36x  local time is December 31, UTC is January 1, offset -24 hours
+	 *    1  local time is 1 day ahead of UTC, offset +24 hours
+	 *    0  local time is same day as UTC, no offset
+	 *   -1  local time is 1 day behind UTC, offset -24 hours
+	 * -36x  local time is January 1, UTC is December 31, offset +24 hours
+	 */
+      if (ms -= t->tm_yday)	/* correct offset if different Julian day */
+	mi += ((ms < 0) == (abs (ms) == 1)) ? -24*60 : 24*60;
+      if (mi < 0) {		/* occidental? */
+	mi = abs (mi);		/* yup, make positive number */
+	elt->zoccident = 1;	/* and note west of UTC */
+      }
+      elt->zhours = mi / 60;	/* now break into hours and minutes */
+      elt->zminutes = mi % 60;
+    }
+    break;
+  }
+  return T;
+}
+
+/* Mail n messages exist
+ * Accepts: mail stream
+ *	    number of messages
+ */
+
+void mail_exists (MAILSTREAM *stream,unsigned long nmsgs)
+{
+  char tmp[MAILTMPLEN];
+  if (nmsgs > MAXMESSAGES) {
+    sprintf (tmp,"Mailbox has more messages (%lu) exist than maximum (%lu)",
+	     nmsgs,MAXMESSAGES);
+    mm_log (tmp,ERROR);
+    nmsgs = MAXMESSAGES;	/* cap to maximum */
+    /* probably will crash in mail_elt() soon enough... */
+  }
+				/* make sure cache is large enough */
+  (*mailcache) (stream,nmsgs,CH_SIZE);
+  stream->nmsgs = nmsgs;	/* update stream status */
+				/* notify main program of change */
+  if (!stream->silent) MM_EXISTS (stream,nmsgs);
+}
+
+
+/* Mail n messages are recent
+ * Accepts: mail stream
+ *	    number of recent messages
+ */
+
+void mail_recent (MAILSTREAM *stream,unsigned long recent)
+{
+  char tmp[MAILTMPLEN];
+  if (recent <= stream->nmsgs) stream->recent = recent;
+  else {
+    sprintf (tmp,"Non-existent recent message(s) %lu, nmsgs=%lu",
+	     recent,stream->nmsgs);
+    mm_log (tmp,ERROR);
+  }
+}
+
+
+/* Mail message n is expunged
+ * Accepts: mail stream
+ *	    message #
+ */
+
+void mail_expunged (MAILSTREAM *stream,unsigned long msgno)
+{
+  char tmp[MAILTMPLEN];
+  MESSAGECACHE *elt;
+  if (msgno > stream->nmsgs) {
+    sprintf (tmp,"Expunge of non-existent message %lu, nmsgs=%lu",
+	     msgno,stream->nmsgs);
+    mm_log (tmp,ERROR);
+  }
+  else {
+    elt = (MESSAGECACHE *) (*mailcache) (stream,msgno,CH_ELT);
+				/* notify main program of change */
+    if (!stream->silent) MM_EXPUNGED (stream,msgno);
+    if (elt) {			/* if an element is there */
+      elt->msgno = 0;		/* invalidate its message number and free */
+      (*mailcache) (stream,msgno,CH_FREE);
+      (*mailcache) (stream,msgno,CH_FREESORTCACHE);
+    }
+				/* expunge the slot */
+    (*mailcache) (stream,msgno,CH_EXPUNGE);
+    --stream->nmsgs;		/* update stream status */
+    if (stream->msgno) {	/* have stream pointers? */
+				/* make sure the short cache is nuked */
+      if (stream->scache) mail_gc (stream,GC_ENV | GC_TEXTS);
+      else stream->msgno = 0;	/* make sure invalidated in any case */
+    }
+  }
+}
+
+/* Mail stream status routines */
+
+
+/* Mail lock stream
+ * Accepts: mail stream
+ */
+
+void mail_lock (MAILSTREAM *stream)
+{
+  if (stream->lock) {
+    char tmp[MAILTMPLEN];
+    sprintf (tmp,"Lock when already locked, mbx=%.80s",
+	     stream->mailbox ? stream->mailbox : "???");
+    fatal (tmp);
+  }
+  else stream->lock = T;	/* lock stream */
+}
+
+
+/* Mail unlock stream
+ * Accepts: mail stream
+ */
+ 
+void mail_unlock (MAILSTREAM *stream)
+{
+  if (!stream->lock) fatal ("Unlock when not locked");
+  else stream->lock = NIL;	/* unlock stream */
+}
+
+
+/* Mail turn on debugging telemetry
+ * Accepts: mail stream
+ */
+
+void mail_debug (MAILSTREAM *stream)
+{
+  stream->debug = T;		/* turn on debugging telemetry */
+  if (stream->dtb) (*stream->dtb->parameters) (ENABLE_DEBUG,stream);
+}
+
+
+/* Mail turn off debugging telemetry
+ * Accepts: mail stream
+ */
+
+void mail_nodebug (MAILSTREAM *stream)
+{
+  stream->debug = NIL;		/* turn off debugging telemetry */
+  if (stream->dtb) (*stream->dtb->parameters) (DISABLE_DEBUG,stream);
+}
+
+
+/* Mail log to debugging telemetry
+ * Accepts: message
+ *	    flag that data is "sensitive"
+ */
+
+void mail_dlog (char *string,long flag)
+{
+  mm_dlog ((debugsensitive || !flag) ? string : "<suppressed>");
+}
+
+/* Mail parse UID sequence
+ * Accepts: mail stream
+ *	    sequence to parse
+ * Returns: T if parse successful, else NIL
+ */
+
+long mail_uid_sequence (MAILSTREAM *stream,unsigned char *sequence)
+{
+  unsigned long i,j,k,x,y;
+  for (i = 1; i <= stream->nmsgs; i++) mail_elt (stream,i)->sequence = NIL;
+  while (sequence && *sequence){/* while there is something to parse */
+    if (*sequence == '*') {	/* maximum message */
+      i = stream->nmsgs ? mail_uid (stream,stream->nmsgs) : stream->uid_last;
+      sequence++;		/* skip past * */
+    }
+				/* parse and validate message number */
+				/* parse and validate message number */
+    else if (!isdigit (*sequence)) {
+      MM_LOG ("Syntax error in sequence",ERROR);
+      return NIL;
+    }
+    else if (!(i = strtoul (sequence,(char **) &sequence,10))) {
+      MM_LOG ("UID may not be zero",ERROR);
+      return NIL;
+    }
+    switch (*sequence) {	/* see what the delimiter is */
+    case ':':			/* sequence range */
+      if (*++sequence == '*') {	/* maximum message */
+	j = stream->nmsgs ? mail_uid (stream,stream->nmsgs) : stream->uid_last;
+	sequence++;		/* skip past * */
+      }
+				/* parse end of range */
+      else if (!(j = strtoul (sequence,(char **) &sequence,10))) {
+	MM_LOG ("UID sequence range invalid",ERROR);
+	return NIL;
+      }
+      if (*sequence && *sequence++ != ',') {
+	MM_LOG ("UID sequence range syntax error",ERROR);
+	return NIL;
+      }
+      if (i > j) {		/* swap the range if backwards */
+	x = i; i = j; j = x;
+      }
+      x = mail_msgno (stream,i);/* get msgnos */
+      y = mail_msgno (stream,j);/* for both UIDS (don't && it) */
+				/* easy if both UIDs valid */
+      if (x && y) while (x <= y) mail_elt (stream,x++)->sequence = T;
+				/* start UID valid, end is not */
+      else if (x) while ((x <= stream->nmsgs) && (mail_uid (stream,x) <= j))
+	mail_elt (stream,x++)->sequence = T;
+				/* end UID valid, start is not */
+      else if (y) for (x = 1; x <= y; x++) {
+	if (mail_uid (stream,x) >= i) mail_elt (stream,x)->sequence = T;
+      }
+				/* neither is valid, ugh */
+      else for (x = 1; x <= stream->nmsgs; x++)
+	if (((k = mail_uid (stream,x)) >= i) && (k <= j))
+	  mail_elt (stream,x)->sequence = T;
+      break;
+    case ',':			/* single message */
+      ++sequence;		/* skip the delimiter, fall into end case */
+    case '\0':			/* end of sequence, mark this message */
+      if (x = mail_msgno (stream,i)) mail_elt (stream,x)->sequence = T;
+      break;
+    default:			/* anything else is a syntax error! */
+      MM_LOG ("UID sequence syntax error",ERROR);
+      return NIL;
+    }
+  }
+  return T;			/* successfully parsed sequence */
+}
+
+/* Mail see if line list matches that in cache
+ * Accepts: candidate line list
+ *	    cached line list
+ *	    matching flags
+ * Returns: T if match, NIL if no match
+ */
+
+long mail_match_lines (STRINGLIST *lines,STRINGLIST *msglines,long flags)
+{
+  unsigned long i;
+  unsigned char *s,*t;
+  STRINGLIST *m;
+  if (!msglines) return T;	/* full header is in cache */
+				/* need full header but filtered in cache */
+  if ((flags & FT_NOT) || !lines) return NIL;
+  do {				/* make sure all present & accounted for */
+    for (m = msglines; m; m = m->next) if (lines->text.size == m->text.size) {
+      for (s = lines->text.data,t = m->text.data,i = lines->text.size;
+	   i && !compare_uchar (*s,*t); s++,t++,i--);
+      if (!i) break;		/* this line matches */
+    }
+    if (!m) return NIL;		/* didn't find in the list */
+  }
+  while (lines = lines->next);
+  return T;			/* all lines found */
+}
+
+/* Mail filter text by header lines
+ * Accepts: text to filter, with trailing null
+ *	    length of text
+ *	    list of lines
+ *	    fetch flags
+ * Returns: new text size, text overwritten
+ */
+
+unsigned long mail_filter (char *text,unsigned long len,STRINGLIST *lines,
+			   long flags)
+{
+  STRINGLIST *hdrs;
+  int notfound;
+  unsigned long i;
+  char c,*s,*e,*t,tmp[MAILTMPLEN];
+  char *src = text;
+  char *dst = src;
+  char *end = text + len;
+  text[len] = '\012';		/* guard against running off buffer */
+  while (src < end) {		/* process header */
+				/* slurp header line name */
+    for (s = src,e = s + MAILTMPLEN - 1,e = (e < end ? e : end),t = tmp;
+	 (s < e) && ((c = (*s ? *s : (*s = ' '))) != ':') &&
+	 ((c > ' ') ||
+	  ((c != ' ') && (c != '\t') && (c != '\015') && (c != '\012')));
+	 *t++ = *s++);
+    *t = '\0';			/* tie off */
+    notfound = T;		/* not found yet */
+    if (i = t - tmp)		/* see if found in header */
+      for (hdrs = lines; hdrs && notfound; hdrs = hdrs->next)
+	if ((hdrs->text.size == i) && !compare_csizedtext (tmp,&hdrs->text))
+	  notfound = NIL;
+				/* skip header line if not wanted */
+    if (i && ((flags & FT_NOT) ? !notfound : notfound))
+      while (((*src++ != '\012') && (*src++ != '\012') && (*src++ != '\012') &&
+	      (*src++ != '\012') && (*src++ != '\012') && (*src++ != '\012') &&
+	      (*src++ != '\012') && (*src++ != '\012') && (*src++ != '\012') &&
+	      (*src++ != '\012')) || ((*src == ' ') || (*src == '\t')));
+    else if (src == dst) {	/* copy to self */
+      while (((*src++ != '\012') && (*src++ != '\012') && (*src++ != '\012') &&
+	      (*src++ != '\012') && (*src++ != '\012') && (*src++ != '\012') &&
+	      (*src++ != '\012') && (*src++ != '\012') && (*src++ != '\012') &&
+	      (*src++ != '\012')) || ((*src == ' ') || (*src == '\t')));
+      dst = src;		/* update destination */
+    }
+    else {			/* copy line and any continuation line */
+      while ((((*dst++ = *src++) != '\012') && ((*dst++ = *src++) != '\012') &&
+	      ((*dst++ = *src++) != '\012') && ((*dst++ = *src++) != '\012') &&
+	      ((*dst++ = *src++) != '\012') && ((*dst++ = *src++) != '\012') &&
+	      ((*dst++ = *src++) != '\012') && ((*dst++ = *src++) != '\012') &&
+	      ((*dst++ = *src++) != '\012') && ((*dst++ = *src++) != '\012'))||
+	     ((*src == ' ') || (*src == '\t')));
+				/* in case hit the guard LF */
+      if (src > end) dst -= (src - end);
+    }
+  }
+  *dst = '\0';			/* tie off destination */
+  return dst - text;
+}
+
+/* Local mail search message
+ * Accepts: MAIL stream
+ *	    message number
+ *	    optional section specification
+ *	    search program
+ * Returns: T if found, NIL otherwise
+ */
+
+long mail_search_msg (MAILSTREAM *stream,unsigned long msgno,char *section,
+		      SEARCHPGM *pgm)
+{
+  unsigned short d;
+  char tmp[MAILTMPLEN];
+  MESSAGECACHE *elt = mail_elt (stream,msgno);
+  SEARCHHEADER *hdr;
+  SEARCHOR *or;
+  SEARCHPGMLIST *not;
+  unsigned long now = (unsigned long) time (0);
+  if (pgm->msgno || pgm->uid) {	/* message set searches */
+    SEARCHSET *set;
+				/* message sequences */
+    if (pgm->msgno) {		/* inside this message sequence set */
+      for (set = pgm->msgno; set; set = set->next)
+	if (set->last ? ((set->first <= set->last) ?
+			 ((msgno >= set->first) && (msgno <= set->last)) :
+			 ((msgno >= set->last) && (msgno <= set->first))) :
+	    msgno == set->first) break;
+      if (!set) return NIL;	/* not found within sequence */
+    }
+    if (pgm->uid) {		/* inside this unique identifier set */
+      unsigned long uid = mail_uid (stream,msgno);
+      for (set = pgm->uid; set; set = set->next)
+	if (set->last ? ((set->first <= set->last) ?
+			 ((uid >= set->first) && (uid <= set->last)) :
+			 ((uid >= set->last) && (uid <= set->first))) :
+	    uid == set->first) break;
+      if (!set) return NIL;	/* not found within sequence */
+    }
+  }
+
+  /* Fast data searches */
+				/* need to fetch fast data? */
+  if ((!elt->rfc822_size && (pgm->larger || pgm->smaller)) ||
+      (!elt->year && (pgm->before || pgm->on || pgm->since ||
+		      pgm->older || pgm->younger)) ||
+      (!elt->valid && (pgm->answered || pgm->unanswered ||
+		       pgm->deleted || pgm->undeleted ||
+		       pgm->draft || pgm->undraft ||
+		       pgm->flagged || pgm->unflagged ||
+		       pgm->recent || pgm->old ||
+		       pgm->seen || pgm->unseen ||
+		       pgm->keyword || pgm->unkeyword))) {
+    unsigned long i;
+    MESSAGECACHE *ielt;
+    for (i = elt->msgno;	/* find last unloaded message in range */
+	 (i < stream->nmsgs) && (ielt = mail_elt (stream,i+1)) &&
+	   ((!ielt->rfc822_size && (pgm->larger || pgm->smaller)) ||
+	    (!ielt->year && (pgm->before || pgm->on || pgm->since ||
+			     pgm->older || pgm->younger)) ||
+	    (!ielt->valid && (pgm->answered || pgm->unanswered ||
+			      pgm->deleted || pgm->undeleted ||
+			      pgm->draft || pgm->undraft ||
+			      pgm->flagged || pgm->unflagged ||
+			      pgm->recent || pgm->old ||
+			      pgm->seen || pgm->unseen ||
+			      pgm->keyword || pgm->unkeyword))); ++i);
+    if (i == elt->msgno) sprintf (tmp,"%lu",elt->msgno);
+    else sprintf (tmp,"%lu:%lu",elt->msgno,i);
+    mail_fetch_fast (stream,tmp,NIL);
+  }
+				/* size ranges */
+  if ((pgm->larger && (elt->rfc822_size <= pgm->larger)) ||
+      (pgm->smaller && (elt->rfc822_size >= pgm->smaller))) return NIL;
+				/* message flags */
+  if ((pgm->answered && !elt->answered) ||
+      (pgm->unanswered && elt->answered) ||
+      (pgm->deleted && !elt->deleted) ||
+      (pgm->undeleted && elt->deleted) ||
+      (pgm->draft && !elt->draft) ||
+      (pgm->undraft && elt->draft) ||
+      (pgm->flagged && !elt->flagged) ||
+      (pgm->unflagged && elt->flagged) ||
+      (pgm->recent && !elt->recent) ||
+      (pgm->old && elt->recent) ||
+      (pgm->seen && !elt->seen) ||
+      (pgm->unseen && elt->seen)) return NIL;
+				/* keywords */
+  if ((pgm->keyword && !mail_search_keyword (stream,elt,pgm->keyword,LONGT)) ||
+      (pgm->unkeyword && !mail_search_keyword (stream,elt,pgm->unkeyword,NIL)))
+    return NIL;
+				/* internal date ranges */
+  if (pgm->before || pgm->on || pgm->since) {
+    d = mail_shortdate (elt->year,elt->month,elt->day);
+    if (pgm->before && (d >= pgm->before)) return NIL;
+    if (pgm->on && (d != pgm->on)) return NIL;
+    if (pgm->since && (d < pgm->since)) return NIL;
+  }
+  if (pgm->older || pgm->younger) {
+    unsigned long msgd = mail_longdate (elt);
+    if (pgm->older && msgd > (now - pgm->older)) return NIL;
+    if (pgm->younger && msgd < (now - pgm->younger)) return NIL;
+  }
+
+				/* envelope searches */
+  if (pgm->sentbefore || pgm->senton || pgm->sentsince ||
+      pgm->bcc || pgm->cc || pgm->from || pgm->to || pgm->subject ||
+      pgm->return_path || pgm->sender || pgm->reply_to || pgm->in_reply_to ||
+      pgm->message_id || pgm->newsgroups || pgm->followup_to ||
+      pgm->references) {
+    ENVELOPE *env;
+    MESSAGECACHE delt;
+    if (section) {		/* use body part envelope */
+      BODY *body = mail_body (stream,msgno,section);
+      env = (body && (body->type == TYPEMESSAGE) && body->subtype &&
+	     !strcmp (body->subtype,"RFC822")) ? body->nested.msg->env : NIL;
+    }
+    else {			/* use top level envelope if no section */
+      if (pgm->header && !stream->scache && !(stream->dtb->flags & DR_LOCAL))
+	mail_fetch_header(stream,msgno,NIL,NIL,NIL,FT_PEEK|FT_SEARCHLOOKAHEAD);
+      env = mail_fetchenvelope (stream,msgno);
+    }
+    if (!env) return NIL;	/* no envelope obtained */
+				/* sent date ranges */
+    if ((pgm->sentbefore || pgm->senton || pgm->sentsince) &&
+	(!mail_parse_date (&delt,env->date) ||
+	 !(d = mail_shortdate (delt.year,delt.month,delt.day)) ||
+	 (pgm->sentbefore && (d >= pgm->sentbefore)) ||
+	 (pgm->senton && (d != pgm->senton)) ||
+	 (pgm->sentsince && (d < pgm->sentsince)))) return NIL;
+				/* search headers */
+    if ((pgm->bcc && !mail_search_addr (env->bcc,pgm->bcc)) ||
+	(pgm->cc && !mail_search_addr (env->cc,pgm->cc)) ||
+	(pgm->from && !mail_search_addr (env->from,pgm->from)) ||
+	(pgm->to && !mail_search_addr (env->to,pgm->to)) ||
+	(pgm->subject && !mail_search_header_text (env->subject,pgm->subject)))
+      return NIL;
+    /* These criteria are not supported by IMAP and have to be emulated */
+    if ((pgm->return_path &&
+	 !mail_search_addr (env->return_path,pgm->return_path)) ||
+	(pgm->sender && !mail_search_addr (env->sender,pgm->sender)) ||
+	(pgm->reply_to && !mail_search_addr (env->reply_to,pgm->reply_to)) ||
+	(pgm->in_reply_to &&
+	 !mail_search_header_text (env->in_reply_to,pgm->in_reply_to)) ||
+	(pgm->message_id &&
+	!mail_search_header_text (env->message_id,pgm->message_id)) ||
+	(pgm->newsgroups &&
+	 !mail_search_header_text (env->newsgroups,pgm->newsgroups)) ||
+	(pgm->followup_to &&
+	 !mail_search_header_text (env->followup_to,pgm->followup_to)) ||
+	(pgm->references &&
+	 !mail_search_header_text (env->references,pgm->references)))
+      return NIL;
+  }
+
+				/* search header lines */
+  for (hdr = pgm->header; hdr; hdr = hdr->next) {
+    char *t,*e,*v;
+    SIZEDTEXT s;
+    STRINGLIST sth,stc;
+    sth.next = stc.next = NIL;	/* only one at a time */
+    sth.text.data = hdr->line.data;
+    sth.text.size = hdr->line.size;
+				/* get the header text */
+    if ((t = mail_fetch_header (stream,msgno,NIL,&sth,&s.size,
+				FT_INTERNAL | FT_PEEK |
+				(section ? NIL : FT_SEARCHLOOKAHEAD))) &&
+	strchr (t,':')) {
+      if (hdr->text.size) {	/* anything matches empty search string */
+				/* non-empty, copy field data */
+	s.data = (unsigned char *) fs_get (s.size + 1);
+				/* for each line */
+	for (v = (char *) s.data, e = t + s.size; t < e;) switch (*t) {
+	default:		/* non-continuation, skip leading field name */
+	  while ((t < e) && (*t++ != ':'));
+	  if ((t < e) && (*t == ':')) t++;
+	case '\t': case ' ':	/* copy field data  */
+	  while ((t < e) && (*t != '\015') && (*t != '\012')) *v++ = *t++;
+	  *v++ = '\n';		/* tie off line */
+	  while (((*t == '\015') || (*t == '\012')) && (t < e)) t++;
+	}
+				/* calculate true size */
+	s.size = v - (char *) s.data;
+	*v = '\0';		/* tie off results */
+	stc.text.data = hdr->text.data;
+	stc.text.size = hdr->text.size;
+				/* search header */
+	if (mail_search_header (&s,&stc)) fs_give ((void **) &s.data);
+	else {			/* search failed */
+	  fs_give ((void **) &s.data);
+	  return NIL;
+	}
+      }
+    }
+    else return NIL;		/* no matching header text */
+  }
+				/* search strings */
+  if ((pgm->text && !mail_search_text (stream,msgno,section,pgm->text,LONGT))||
+      (pgm->body && !mail_search_text (stream,msgno,section,pgm->body,NIL)))
+    return NIL;
+				/* logical conditions */
+  for (or = pgm->or; or; or = or->next)
+    if (!(mail_search_msg (stream,msgno,section,or->first) ||
+	  mail_search_msg (stream,msgno,section,or->second))) return NIL;
+  for (not = pgm->not; not; not = not->next)
+    if (mail_search_msg (stream,msgno,section,not->pgm)) return NIL;
+  return T;
+}
+
+/* Mail search message header null-terminated text
+ * Accepts: header text
+ *	    strings to search
+ * Returns: T if search found a match
+ */
+
+long mail_search_header_text (char *s,STRINGLIST *st)
+{
+  SIZEDTEXT h;
+				/* have any text? */
+  if (h.data = (unsigned char *) s) {
+    h.size = strlen (s);	/* yes, get its size */
+    return mail_search_header (&h,st);
+  }
+  return NIL;
+}
+
+
+/* Mail search message header
+ * Accepts: header as sized text
+ *	    strings to search
+ * Returns: T if search found a match
+ */
+
+long mail_search_header (SIZEDTEXT *hdr,STRINGLIST *st)
+{
+  SIZEDTEXT h;
+  long ret = LONGT;
+				/* make UTF-8 version of header */
+  utf8_mime2text (hdr,&h,U8T_CANONICAL);
+  while (h.size && ((h.data[h.size-1]=='\015') || (h.data[h.size-1]=='\012')))
+    --h.size;			/* slice off trailing newlines */
+  do if (h.size ?		/* search non-empty string */
+	 !ssearch (h.data,h.size,st->text.data,st->text.size) : st->text.size)
+    ret = NIL;
+  while (ret && (st = st->next));
+  if (h.data != hdr->data) fs_give ((void **) &h.data);
+  return ret;
+}
+
+/* Mail search message body
+ * Accepts: MAIL stream
+ *	    message number
+ *	    optional section specification
+ *	    string list
+ *	    flags
+ * Returns: T if search found a match
+ */
+
+long mail_search_text (MAILSTREAM *stream,unsigned long msgno,char *section,
+		       STRINGLIST *st,long flags)
+{
+  BODY *body;
+  long ret = NIL;
+  STRINGLIST *s = mail_newstringlist ();
+  mailgets_t omg = mailgets;
+  if (stream->dtb->flags & DR_LOWMEM) mailgets = mail_search_gets;
+				/* strings to search */
+  for (stream->private.search.string = s; st;) {
+    s->text.data = st->text.data;
+    s->text.size = st->text.size;
+    if (st = st->next) s = s->next = mail_newstringlist ();
+  }
+  stream->private.search.text = NIL;
+  if (flags) {			/* want header? */
+    SIZEDTEXT s,t;
+    s.data = (unsigned char *)
+      mail_fetch_header (stream,msgno,section,NIL,&s.size,FT_INTERNAL|FT_PEEK);
+    utf8_mime2text (&s,&t,U8T_CANONICAL);
+    ret = mail_search_string_work (&t,&stream->private.search.string);
+    if (t.data != s.data) fs_give ((void **) &t.data);
+  }
+  if (!ret) {			/* still looking for match? */
+				/* no section, get top-level body */
+    if (!section) mail_fetchstructure (stream,msgno,&body);
+				/* get body of nested message */
+    else if ((body = mail_body (stream,msgno,section)) &&
+	     (body->type == TYPEMULTIPART) && body->subtype &&
+	     !strcmp (body->subtype,"RFC822")) body = body->nested.msg->body;
+    if (body) ret = mail_search_body (stream,msgno,body,NIL,1,flags);
+  }
+  mailgets = omg;		/* restore former gets routine */
+				/* clear searching */
+  for (s = stream->private.search.string; s; s = s->next) s->text.data = NIL;
+  mail_free_stringlist (&stream->private.search.string);
+  stream->private.search.text = NIL;
+  return ret;
+}
+
+/* Mail search message body text parts
+ * Accepts: MAIL stream
+ *	    message number
+ *	    current body pointer
+ *	    hierarchical level prefix
+ *	    position at current hierarchical level
+ *	    string list
+ *	    flags
+ * Returns: T if search found a match
+ */
+
+long mail_search_body (MAILSTREAM *stream,unsigned long msgno,BODY *body,
+		       char *prefix,unsigned long section,long flags)
+{
+  long ret = NIL;
+  unsigned long i;
+  char *s,*t,sect[MAILTMPLEN];
+  SIZEDTEXT st,h;
+  PART *part;
+  PARAMETER *param;
+  if (prefix && (strlen (prefix) > (MAILTMPLEN - 20))) return NIL;
+  sprintf (sect,"%s%lu",prefix ? prefix : "",section++);
+  if (flags && prefix) {	/* want to search MIME header too? */
+    st.data = (unsigned char *) mail_fetch_mime (stream,msgno,sect,&st.size,
+						 FT_INTERNAL | FT_PEEK);
+    if (stream->dtb->flags & DR_LOWMEM) ret = stream->private.search.result;
+    else {
+				/* make UTF-8 version of header */
+      utf8_mime2text (&st,&h,U8T_CANONICAL);
+      ret = mail_search_string_work (&h,&stream->private.search.string);
+      if (h.data != st.data) fs_give ((void **) &h.data);
+    }
+  }
+  if (!ret) switch (body->type) {
+  case TYPEMULTIPART:
+				/* extend prefix if not first time */
+    s = prefix ? strcat (sect,".") : "";
+    for (i = 1,part = body->nested.part; part && !ret; i++,part = part->next)
+      ret = mail_search_body (stream,msgno,&part->body,s,i,flags);
+    break;
+  case TYPEMESSAGE:
+    if (!strcmp (body->subtype,"RFC822")) {
+      if (flags) {		/* want to search nested message header? */
+	st.data = (unsigned char *)
+	  mail_fetch_header (stream,msgno,sect,NIL,&st.size,
+			     FT_INTERNAL | FT_PEEK);
+	if (stream->dtb->flags & DR_LOWMEM) ret =stream->private.search.result;
+	else {
+				/* make UTF-8 version of header */
+	  utf8_mime2text (&st,&h,U8T_CANONICAL);
+	  ret = mail_search_string_work (&h,&stream->private.search.string);
+	  if (h.data != st.data) fs_give ((void **) &h.data);
+	}
+      }
+      if (body = body->nested.msg->body)
+	ret = (body->type == TYPEMULTIPART) ?
+	  mail_search_body (stream,msgno,body,(prefix ? prefix : ""),
+			    section - 1,flags) :
+	mail_search_body (stream,msgno,body,strcat (sect,"."),1,flags);
+      break;
+    }
+				/* non-MESSAGE/RFC822 falls into text case */
+
+  case TYPETEXT:
+    s = mail_fetch_body (stream,msgno,sect,&i,FT_INTERNAL | FT_PEEK);
+    if (stream->dtb->flags & DR_LOWMEM) ret = stream->private.search.result;
+    else {
+      for (t = NIL,param = body->parameter; param && !t; param = param->next)
+	if (!strcmp (param->attribute,"CHARSET")) t = param->value;
+      switch (body->encoding) {	/* what encoding? */
+      case ENCBASE64:
+	if (st.data = (unsigned char *)
+	    rfc822_base64 ((unsigned char *) s,i,&st.size)) {
+	  ret = mail_search_string (&st,t,&stream->private.search.string);
+	  fs_give ((void **) &st.data);
+	}
+	break;
+      case ENCQUOTEDPRINTABLE:
+	if (st.data = rfc822_qprint ((unsigned char *) s,i,&st.size)) {
+	  ret = mail_search_string (&st,t,&stream->private.search.string);
+	  fs_give ((void **) &st.data);
+	}
+	break;
+      default:
+	st.data = (unsigned char *) s;
+	st.size = i;
+	ret = mail_search_string (&st,t,&stream->private.search.string);
+	break;
+      }
+    }
+    break;
+  }
+  return ret;
+}
+
+/* Mail search text
+ * Accepts: sized text to search
+ *	    character set of sized text
+ *	    string list of search keys
+ * Returns: T if search found a match
+ */
+
+long mail_search_string (SIZEDTEXT *s,char *charset,STRINGLIST **st)
+{
+  SIZEDTEXT u;
+  long ret;
+  STRINGLIST **sc = st;
+				/* convert to UTF-8 as best we can */
+  if (!utf8_text (s,charset,&u,U8T_CANONICAL))
+    utf8_text (s,NIL,&u,U8T_CANONICAL);
+  ret = mail_search_string_work (&u,st);
+  if (u.data != s->data) fs_give ((void **) &u.data);
+  return ret;
+}
+
+
+/* Mail search text worker routine
+ * Accepts: sized text to search
+ *	    string list of search keys
+ * Returns: T if search found a match
+ */
+
+long mail_search_string_work (SIZEDTEXT *s,STRINGLIST **st)
+{
+  void *t;
+  STRINGLIST **sc = st;
+  while (*sc) {			/* run down criteria list */
+    if (ssearch (s->data,s->size,(*sc)->text.data,(*sc)->text.size)) {
+      t = (void *) (*sc);	/* found one, need to flush this */
+      *sc = (*sc)->next;	/* remove it from the list */
+      fs_give (&t);		/* flush the buffer */
+    }
+    else sc = &(*sc)->next;	/* move to next in list */
+  }
+  return *st ? NIL : LONGT;
+}
+
+
+/* Mail search keyword
+ * Accepts: MAIL stream
+ *	    elt to get flags from
+ *	    keyword list
+ *	    T for keyword search, NIL for unkeyword search
+ * Returns: T if search found a match
+ */
+
+long mail_search_keyword (MAILSTREAM *stream,MESSAGECACHE *elt,STRINGLIST *st,
+			  long flag)
+{
+  int i,j;
+  unsigned long f = 0;
+  unsigned long tf;
+  do {
+    for (i = 0; (j = (i < NUSERFLAGS) && stream->user_flags[i]); ++i)
+      if (!compare_csizedtext (stream->user_flags[i],&st->text)) {
+	f |= (1 << i);
+	break;
+      }
+    if (flag && !j) return NIL;
+  } while (st = st->next);
+  tf = elt->user_flags & f;	/* get set flags which match */
+  return flag ? (f == tf) : !tf;
+}
+
+/* Mail search an address list
+ * Accepts: address list
+ *	    string list
+ * Returns: T if search found a match
+ */
+
+#define SEARCHBUFLEN (size_t) 2000
+#define SEARCHBUFSLOP (size_t) 5
+
+long mail_search_addr (ADDRESS *adr,STRINGLIST *st)
+{
+  ADDRESS *a,tadr;
+  SIZEDTEXT txt;
+  char tmp[SENDBUFLEN + 1];
+  size_t i = SEARCHBUFLEN;
+  size_t k;
+  long ret = NIL;
+  if (adr) {
+    txt.data = (unsigned char *) fs_get (i + SEARCHBUFSLOP);
+				/* never an error or next */
+    tadr.error = NIL,tadr.next = NIL;
+				/* write address list */
+    for (txt.size = 0,a = adr; a; a = a->next) {
+      k = (tadr.mailbox = a->mailbox) ? 4 + 2*strlen (a->mailbox) : 3;
+      if (tadr.personal = a->personal) k += 3 + 2*strlen (a->personal);
+      if (tadr.adl = a->adl) k += 3 + 2*strlen (a->adl);
+      if (tadr.host = a->host) k += 3 + 2*strlen (a->host);
+      if (tadr.personal || tadr.adl) k += 2;
+      if (k < (SENDBUFLEN-10)) {/* ignore ridiculous addresses */
+	tmp[0] = '\0';
+	rfc822_write_address (tmp,&tadr);
+				/* resize buffer if necessary */
+	if (((k = strlen (tmp)) + txt.size) > i)
+	  fs_resize ((void **) &txt.data,SEARCHBUFSLOP + (i += SEARCHBUFLEN));
+				/* add new address */
+	memcpy (txt.data + txt.size,tmp,k);
+	txt.size += k;
+				/* another address follows */
+	if (a->next) txt.data[txt.size++] = ',';
+      }
+    }
+    txt.data[txt.size] = '\0';	/* tie off string */
+    ret = mail_search_header (&txt,st);
+    fs_give ((void **) &txt.data);
+  }
+  return ret;
+}
+
+/* Get string for low-memory searching
+ * Accepts: readin function pointer
+ *	    stream to use
+ *	    number of bytes
+ *	    gets data packet
+
+ *	    mail stream
+ *	    message number
+ *	    descriptor string
+ *	    option flags
+ * Returns: NIL, always
+ */
+
+#define SEARCHSLOP 128
+
+char *mail_search_gets (readfn_t f,void *stream,unsigned long size,
+			GETS_DATA *md)
+{
+  unsigned long i;
+  char tmp[MAILTMPLEN+SEARCHSLOP+1];
+  SIZEDTEXT st;
+				/* better not be called unless searching */
+  if (!md->stream->private.search.string) {
+    sprintf (tmp,"Search botch, mbx = %.80s, %s = %lu[%.80s]",
+	     md->stream->mailbox,
+	     (md->flags & FT_UID) ? "UID" : "msg",md->msgno,md->what);
+    fatal (tmp);
+  }
+				/* initially no match for search */
+  md->stream->private.search.result = NIL;
+				/* make sure buffer clear */
+  memset (st.data = (unsigned char *) tmp,'\0',
+	  (size_t) MAILTMPLEN+SEARCHSLOP+1);
+				/* read first buffer */
+  (*f) (stream,st.size = i = min (size,(long) MAILTMPLEN),tmp);
+				/* search for text */
+  if (mail_search_string (&st,NIL,&md->stream->private.search.string))
+    md->stream->private.search.result = T;
+  else if (size -= i) {		/* more to do, blat slop down */
+    memmove (tmp,tmp+MAILTMPLEN-SEARCHSLOP,(size_t) SEARCHSLOP);
+    do {			/* read subsequent buffers one at a time */
+      (*f) (stream,i = min (size,(long) MAILTMPLEN),tmp+SEARCHSLOP);
+      st.size = i + SEARCHSLOP;
+      if (mail_search_string (&st,NIL,&md->stream->private.search.string))
+	md->stream->private.search.result = T;
+      else memmove (tmp,tmp+MAILTMPLEN,(size_t) SEARCHSLOP);
+    }
+    while ((size -= i) && !md->stream->private.search.result);
+  }
+  if (size) {			/* toss out everything after that */
+    do (*f) (stream,i = min (size,(long) MAILTMPLEN),tmp);
+    while (size -= i);
+  }
+  return NIL;
+}
+
+/* Mail parse search criteria
+ * Accepts: criteria
+ * Returns: search program if parse successful, else NIL
+ */
+
+SEARCHPGM *mail_criteria (char *criteria)
+{
+  SEARCHPGM *pgm = NIL;
+  char *criterion,*r,tmp[MAILTMPLEN];
+  int f;
+  if (criteria) {		/* only if criteria defined */
+				/* make writeable copy of criteria */
+    criteria = cpystr (criteria);
+				/* for each criterion */
+    for (pgm = mail_newsearchpgm (), criterion = strtok_r (criteria," ",&r);
+	 criterion; (criterion = strtok_r (NIL," ",&r))) {
+      f = NIL;			/* init then scan the criterion */
+      switch (*ucase (criterion)) {
+      case 'A':			/* possible ALL, ANSWERED */
+	if (!strcmp (criterion+1,"LL")) f = T;
+	else if (!strcmp (criterion+1,"NSWERED")) f = pgm->answered = T;
+	break;
+      case 'B':			/* possible BCC, BEFORE, BODY */
+	if (!strcmp (criterion+1,"CC"))
+	  f = mail_criteria_string (&pgm->bcc,&r);
+	else if (!strcmp (criterion+1,"EFORE"))
+	  f = mail_criteria_date (&pgm->before,&r);
+	else if (!strcmp (criterion+1,"ODY"))
+	  f = mail_criteria_string (&pgm->body,&r);
+	break;
+      case 'C':			/* possible CC */
+	if (!strcmp (criterion+1,"C")) f = mail_criteria_string (&pgm->cc,&r);
+	break;
+      case 'D':			/* possible DELETED */
+	if (!strcmp (criterion+1,"ELETED")) f = pgm->deleted = T;
+	break;
+      case 'F':			/* possible FLAGGED, FROM */
+	if (!strcmp (criterion+1,"LAGGED")) f = pgm->flagged = T;
+	else if (!strcmp (criterion+1,"ROM"))
+	  f = mail_criteria_string (&pgm->from,&r);
+	break;
+      case 'K':			/* possible KEYWORD */
+	if (!strcmp (criterion+1,"EYWORD"))
+	  f = mail_criteria_string (&pgm->keyword,&r);
+	break;
+
+      case 'N':			/* possible NEW */
+	if (!strcmp (criterion+1,"EW")) f = pgm->recent = pgm->unseen = T;
+	break;
+      case 'O':			/* possible OLD, ON */
+	if (!strcmp (criterion+1,"LD")) f = pgm->old = T;
+	else if (!strcmp (criterion+1,"N"))
+	  f = mail_criteria_date (&pgm->on,&r);
+	break;
+      case 'R':			/* possible RECENT */
+	if (!strcmp (criterion+1,"ECENT")) f = pgm->recent = T;
+	break;
+      case 'S':			/* possible SEEN, SINCE, SUBJECT */
+	if (!strcmp (criterion+1,"EEN")) f = pgm->seen = T;
+	else if (!strcmp (criterion+1,"INCE"))
+	  f = mail_criteria_date (&pgm->since,&r);
+	else if (!strcmp (criterion+1,"UBJECT"))
+	  f = mail_criteria_string (&pgm->subject,&r);
+	break;
+      case 'T':			/* possible TEXT, TO */
+	if (!strcmp (criterion+1,"EXT"))
+	  f = mail_criteria_string (&pgm->text,&r);
+	else if (!strcmp (criterion+1,"O"))
+	  f = mail_criteria_string (&pgm->to,&r);
+	break;
+      case 'U':			/* possible UN* */
+	if (criterion[1] == 'N') {
+	  if (!strcmp (criterion+2,"ANSWERED")) f = pgm->unanswered = T;
+	  else if (!strcmp (criterion+2,"DELETED")) f = pgm->undeleted = T;
+	  else if (!strcmp (criterion+2,"FLAGGED")) f = pgm->unflagged = T;
+	  else if (!strcmp (criterion+2,"KEYWORD"))
+	    f = mail_criteria_string (&pgm->unkeyword,&r);
+	  else if (!strcmp (criterion+2,"SEEN")) f = pgm->unseen = T;
+	}
+	break;
+      default:			/* we will barf below */
+	break;
+      }
+      if (!f) {			/* if can't identify criterion */
+	sprintf (tmp,"Unknown search criterion: %.30s",criterion);
+	MM_LOG (tmp,ERROR);
+	mail_free_searchpgm (&pgm);
+	break;
+      }
+    }
+				/* no longer need copy of criteria */
+    fs_give ((void **) &criteria);
+  }
+  return pgm;
+}
+
+/* Parse a date
+ * Accepts: pointer to date integer to return
+ *	    pointer to strtok state
+ * Returns: T if successful, else NIL
+ */
+
+int mail_criteria_date (unsigned short *date,char **r)
+{
+  STRINGLIST *s = NIL;
+  MESSAGECACHE elt;
+				/* parse the date and return fn if OK */
+  int ret = (mail_criteria_string (&s,r) &&
+	     mail_parse_date (&elt,(char *) s->text.data) &&
+	     (*date = mail_shortdate (elt.year,elt.month,elt.day))) ?
+	       T : NIL;
+  if (s) mail_free_stringlist (&s);
+  return ret;
+}
+
+/* Calculate shortdate from elt values
+ * Accepts: year (0 = BASEYEAR)
+ *	    month (1 = January)
+ *	    day
+ * Returns: shortdate
+ */
+
+unsigned short mail_shortdate (unsigned int year,unsigned int month,
+			       unsigned int day)
+{
+  return (year << 9) + (month << 5) + day;
+}
+
+/* Parse a string
+ * Accepts: pointer to stringlist
+ *	    pointer to strtok state
+ * Returns: T if successful, else NIL
+ */
+
+int mail_criteria_string (STRINGLIST **s,char **r)
+{
+  unsigned long n;
+  char e,*d,*end = " ",*c = strtok_r (NIL,"",r);
+  if (!c) return NIL;		/* missing argument */
+  switch (*c) {			/* see what the argument is */
+  case '{':			/* literal string */
+    n = strtoul (c+1,&d,10);	/* get its length */
+    if ((*d++ == '}') && (*d++ == '\015') && (*d++ == '\012') &&
+	(!(*(c = d + n)) || (*c == ' '))) {
+      e = *--c;			/* store old delimiter */
+      *c = '\377';		/* make sure not a space */
+      strtok_r (c," ",r);	/* reset the strtok mechanism */
+      *c = e;			/* put character back */
+      break;
+    }
+  case '\0':			/* catch bogons */
+  case ' ':
+    return NIL;
+  case '"':			/* quoted string */
+    if (strchr (c+1,'"')) end = "\"";
+    else return NIL;		/* falls through */
+  default:			/* atomic string */
+    if (d = strtok_r (c,end,r)) n = strlen (d);
+    else return NIL;
+    break;
+  }
+  while (*s) s = &(*s)->next;	/* find tail of list */
+  *s = mail_newstringlist ();	/* make new entry */
+				/* return the data */
+  (*s)->text.data = (unsigned char *) cpystr (d);
+  (*s)->text.size = n;
+  return T;
+}
+
+/* Mail parse set from string
+ * Accepts: string to parse
+ *	    pointer to updated string pointer for return
+ * Returns: set with pointer updated, or NIL if error
+ */
+
+SEARCHSET *mail_parse_set (char *s,char **ret)
+{
+  SEARCHSET *cur;
+  SEARCHSET *set = NIL;
+  while (isdigit (*s)) {
+    if (!set) cur = set = mail_newsearchset ();
+    else cur = cur->next = mail_newsearchset ();
+				/* parse value */
+    if (!(cur->first = strtoul (s,&s,10)) ||
+	((*s == ':') && !(isdigit (*++s) && (cur->last = strtoul (s,&s,10)))))
+      break;			/* bad value or range */
+    if (*s == ',') ++s;		/* point to next value if more */
+    else {			/* end of set */
+      *ret = s;			/* set return pointer */
+      return set;		/* return set */
+    }
+  }
+  mail_free_searchset (&set);	/* failure, punt partial set */
+  return NIL;
+}
+
+
+/* Mail append to set
+ * Accepts: head of search set or NIL to do nothing
+ *	    message to add
+ * Returns: tail of search set or NIL if did nothing
+ */
+
+SEARCHSET *mail_append_set (SEARCHSET *set,unsigned long msgno)
+{
+  if (set) {			/* find tail */
+    while (set->next) set = set->next;
+				/* start of set if no first member */
+    if (!set->first) set->first = msgno;
+    else if (msgno == (set->last ? set->last : set->first) + 1)
+      set->last = msgno;	/* extend range if 1 past current */
+    else (set = set->next = mail_newsearchset ())->first = msgno;
+  }
+  return set;
+}
+
+/* Mail sort messages
+ * Accepts: mail stream
+ *	    character set
+ *	    search program
+ *	    sort program
+ *	    option flags
+ * Returns: vector of sorted message sequences or NIL if error
+ */
+
+unsigned long *mail_sort (MAILSTREAM *stream,char *charset,SEARCHPGM *spg,
+			  SORTPGM *pgm,long flags)
+{
+  unsigned long *ret = NIL;
+  if (stream->dtb)		/* do the driver's action */
+    ret = (*(stream->dtb->sort ? stream->dtb->sort : mail_sort_msgs))
+      (stream,charset,spg,pgm,flags);
+				/* flush search/sort programs if requested */
+  if (spg && (flags & SE_FREE)) mail_free_searchpgm (&spg);
+  if (flags & SO_FREE) mail_free_sortpgm (&pgm);
+  return ret;
+}
+
+/* Mail sort messages work routine
+ * Accepts: mail stream
+ *	    character set
+ *	    search program
+ *	    sort program
+ *	    option flags
+ * Returns: vector of sorted message sequences or NIL if error
+ */
+
+unsigned long *mail_sort_msgs (MAILSTREAM *stream,char *charset,SEARCHPGM *spg,
+			       SORTPGM *pgm,long flags)
+{
+  unsigned long i;
+  SORTCACHE **sc;
+  unsigned long *ret = NIL;
+  if (spg) {			/* only if a search needs to be done */
+    int silent = stream->silent;
+    stream->silent = T;		/* don't pass up mm_searched() events */
+				/* search for messages */
+    mail_search_full (stream,charset,spg,NIL);
+    stream->silent = silent;	/* restore silence state */
+  }
+				/* initialize progress counters */
+  pgm->nmsgs = pgm->progress.cached = 0;
+				/* pass 1: count messages to sort */
+  for (i = 1; i <= stream->nmsgs; ++i)
+    if (mail_elt (stream,i)->searched) pgm->nmsgs++;
+  if (pgm->nmsgs) {		/* pass 2: sort cache */
+    sc = mail_sort_loadcache (stream,pgm);
+				/* pass 3: sort messages */
+    if (!pgm->abort) ret = mail_sort_cache (stream,pgm,sc,flags);
+    fs_give ((void **) &sc);	/* don't need sort vector any more */
+  }
+				/* empty sort results */
+  else ret = (unsigned long *) memset (fs_get (sizeof (unsigned long)),0,
+				       sizeof (unsigned long));
+				/* also return via callback if requested */
+  if (mailsortresults) (*mailsortresults) (stream,ret,pgm->nmsgs);
+  return ret;			/* return sort results */
+}
+
+/* Mail sort sortcache vector
+ * Accepts: mail stream
+ *	    sort program
+ *	    sortcache vector
+ *	    option flags
+ * Returns: vector of sorted message sequences or NIL if error
+ */
+
+unsigned long *mail_sort_cache (MAILSTREAM *stream,SORTPGM *pgm,SORTCACHE **sc,
+				long flags)
+{
+  unsigned long i,*ret;
+				/* pass 3: sort messages */
+  qsort ((void *) sc,pgm->nmsgs,sizeof (SORTCACHE *),mail_sort_compare);
+				/* optional post sorting */
+  if (pgm->postsort) (*pgm->postsort) ((void *) sc);
+				/* pass 4: return results */
+  ret = (unsigned long *) fs_get ((pgm->nmsgs+1) * sizeof (unsigned long));
+  if (flags & SE_UID)		/* UID or msgno? */
+    for (i = 0; i < pgm->nmsgs; i++) ret[i] = mail_uid (stream,sc[i]->num);
+  else for (i = 0; i < pgm->nmsgs; i++) ret[i] = sc[i]->num;
+  ret[pgm->nmsgs] = 0;		/* tie off message list */
+  return ret;
+}
+
+/* Mail load sortcache
+ * Accepts: mail stream, already searched
+ *	    sort program
+ * Returns: vector of sortcache pointers matching search
+ */
+
+static STRINGLIST maildateline = {{(unsigned char *) "date",4},NIL};
+static STRINGLIST mailrnfromline = {{(unsigned char *) ">from",5},NIL};
+static STRINGLIST mailfromline = {{(unsigned char *) "from",4},
+				    &mailrnfromline};
+static STRINGLIST mailtonline = {{(unsigned char *) "to",2},NIL};
+static STRINGLIST mailccline = {{(unsigned char *) "cc",2},NIL};
+static STRINGLIST mailsubline = {{(unsigned char *) "subject",7},NIL};
+
+SORTCACHE **mail_sort_loadcache (MAILSTREAM *stream,SORTPGM *pgm)
+{
+  char *t,*v,*x,tmp[MAILTMPLEN];
+  SORTPGM *pg;
+  SORTCACHE *s,**sc;
+  MESSAGECACHE *elt,telt;
+  ENVELOPE *env;
+  ADDRESS *adr = NIL;
+  unsigned long i = (pgm->nmsgs) * sizeof (SORTCACHE *);
+  sc = (SORTCACHE **) memset (fs_get ((size_t) i),0,(size_t) i);
+				/* see what needs to be loaded */
+  for (i = 1; !pgm->abort && (i <= stream->nmsgs); i++)
+    if ((elt = mail_elt (stream,i))->searched) {
+      sc[pgm->progress.cached++] =
+	s = (SORTCACHE *) (*mailcache) (stream,i,CH_SORTCACHE);
+      s->pgm = pgm;		/* note sort program */
+      s->num = i;
+				/* get envelope if cached */
+      if (stream->scache) env = (i == stream->msgno) ? stream->env : NIL;
+      else env = elt->private.msg.env;
+      for (pg = pgm; pg; pg = pg->next) switch (pg->function) {
+      case SORTARRIVAL:		/* sort by arrival date */
+	if (!s->arrival) {
+				/* internal date unknown but can get? */
+	  if (!elt->day && !(stream->dtb->flags & DR_NOINTDATE)) {
+	    sprintf (tmp,"%lu",i);
+	    mail_fetch_fast (stream,tmp,NIL);
+	  }
+				/* wrong thing before 3-Jan-1970 */
+	  s->arrival = elt->day ? mail_longdate (elt) : 1;
+	  s->dirty = T;
+	}
+	break;
+      case SORTSIZE:		/* sort by message size */
+	if (!s->size) {
+	  if (!elt->rfc822_size) {
+	    sprintf (tmp,"%lu",i);
+	    mail_fetch_fast (stream,tmp,NIL);
+	  }
+	  s->size = elt->rfc822_size ? elt->rfc822_size : 1;
+	  s->dirty = T;
+	}
+	break;
+
+      case SORTDATE:		/* sort by date */
+	if (!s->date) {
+	  if (env) t = env->date;
+	  else if ((t = mail_fetch_header (stream,i,NIL,&maildateline,NIL,
+					   FT_INTERNAL | FT_PEEK)) &&
+		   (t = strchr (t,':')))
+	    for (x = ++t; x = strpbrk (x,"\012\015"); x++)
+	      switch (*(v = ((*x == '\015') && (x[1] == '\012')) ? x+2 : x+1)){
+	      case ' ':		/* erase continuation newlines */
+	      case '\t':
+		memmove (x,v,strlen (v));
+		break;
+	      default:		/* tie off extraneous text */
+		*x = x[1] = '\0';
+	      }
+				/* skip leading whitespace */
+	  if (t) while ((*t == ' ') || (*t == '\t')) t++;
+				/* parse date from Date: header */
+	  if (!(t && mail_parse_date (&telt,t) && 
+		(s->date = mail_longdate (&telt)))) {
+				/* failed, use internal date */
+	    if (!(s->date = s->arrival)) {
+				/* internal date unknown but can get? */
+	      if (!elt->day && !(stream->dtb->flags & DR_NOINTDATE)) {
+		sprintf (tmp,"%lu",i);
+		mail_fetch_fast (stream,tmp,NIL);
+	      }
+				/* wrong thing before 3-Jan-1970 */
+	      s->date = (s->arrival = elt->day ? mail_longdate (elt) : 1);
+	    }
+	  }
+	  s->dirty = T;
+	}
+	break;
+
+      case SORTFROM:		/* sort by first from */
+	if (!s->from) {
+	  if (env) s->from = env->from && env->from->mailbox ?
+	    cpystr (env->from->mailbox) : NIL;
+	  else if ((t = mail_fetch_header (stream,i,NIL,&mailfromline,NIL,
+					   FT_INTERNAL | FT_PEEK)) &&
+		   (t = strchr (t,':'))) {
+	    for (x = ++t; x = strpbrk (x,"\012\015"); x++)
+	      switch (*(v = ((*x == '\015') && (x[1] == '\012')) ? x+2 : x+1)){
+	      case ' ':		/* erase continuation newlines */
+	      case '\t':
+		memmove (x,v,strlen (v));
+		break;
+	      case 'f':		/* continuation but with extra "From:" */
+	      case 'F':
+		if (v = strchr (v,':')) {
+		  memmove (x,v+1,strlen (v+1));
+		  break;
+		}
+	      default:		/* tie off extraneous text */
+		*x = x[1] = '\0';
+	      }
+	    if (adr = rfc822_parse_address (&adr,adr,&t,BADHOST,0)) {
+	      s->from = adr->mailbox;
+	      adr->mailbox = NIL;
+	      mail_free_address (&adr);
+	    }
+	  }
+	  if (!s->from) s->from = cpystr ("");
+	  s->dirty = T;
+	}
+	break;
+
+      case SORTTO:		/* sort by first to */
+	if (!s->to) {
+	  if (env) s->to = env->to && env->to->mailbox ?
+	    cpystr (env->to->mailbox) : NIL;
+	  else if ((t = mail_fetch_header (stream,i,NIL,&mailtonline,NIL,
+					   FT_INTERNAL | FT_PEEK)) &&
+		   (t = strchr (t,':'))) {
+	    for (x = ++t; x = strpbrk (x,"\012\015"); x++)
+	      switch (*(v = ((*x == '\015') && (x[1] == '\012')) ? x+2 : x+1)){
+	      case ' ':		/* erase continuation newlines */
+	      case '\t':
+		memmove (x,v,strlen (v));
+		break;
+	      case 't':		/* continuation but with extra "To:" */
+	      case 'T':
+		if (v = strchr (v,':')) {
+		  memmove (x,v+1,strlen (v+1));
+		  break;
+		}
+	      default:		/* tie off extraneous text */
+		*x = x[1] = '\0';
+	      }
+	    if (adr = rfc822_parse_address (&adr,adr,&t,BADHOST,0)) {
+	      s->to = adr->mailbox;
+	      adr->mailbox = NIL;
+	      mail_free_address (&adr);
+	    }
+	  }
+	  if (!s->to) s->to = cpystr ("");
+	  s->dirty = T;
+	}
+	break;
+
+      case SORTCC:		/* sort by first cc */
+	if (!s->cc) {
+	  if (env) s->cc = env->cc && env->cc->mailbox ?
+	    cpystr (env->cc->mailbox) : NIL;
+	  else if ((t = mail_fetch_header (stream,i,NIL,&mailccline,NIL,
+					   FT_INTERNAL | FT_PEEK)) &&
+		   (t = strchr (t,':'))) {
+	    for (x = ++t; x = strpbrk (x,"\012\015"); x++)
+	      switch (*(v = ((*x == '\015') && (x[1] == '\012')) ? x+2 : x+1)){
+	      case ' ':		/* erase continuation newlines */
+	      case '\t':
+		memmove (x,v,strlen (v));
+		break;
+	      case 't':		/* continuation but with extra "To:" */
+	      case 'T':
+		if (v = strchr (v,':')) {
+		  memmove (x,v+1,strlen (v+1));
+		  break;
+		}
+	      default:		/* tie off extraneous text */
+		*x = x[1] = '\0';
+	      }
+	    if (adr = rfc822_parse_address (&adr,adr,&t,BADHOST,0)) {
+	      s->cc = adr->mailbox;
+	      adr->mailbox = NIL;
+	      mail_free_address (&adr);
+	    }
+	  }
+	  if (!s->cc) s->cc = cpystr ("");
+	  s->dirty = T;
+	}
+	break;
+
+      case SORTSUBJECT:		/* sort by subject */
+	if (!s->subject) {
+				/* get subject from envelope if have one */
+	  if (env) t = env->subject ? env->subject : "";
+				/* otherwise snarf from header text */
+	  else if ((t = mail_fetch_header (stream,i,NIL,&mailsubline,
+					   NIL,FT_INTERNAL | FT_PEEK)) &&
+		   (t = strchr (t,':')))
+	    for (x = ++t; x = strpbrk (x,"\012\015"); x++)
+	      switch (*(v = ((*x == '\015') && (x[1] == '\012')) ? x+2 : x+1)){
+	      case ' ':		/* erase continuation newlines */
+	      case '\t':
+		memmove (x,v,strlen (v));
+		break;
+	      default:		/* tie off extraneous text */
+		*x = x[1] = '\0';
+	      }
+	  else t = "";		/* empty subject */
+				/* strip and cache subject */
+	  s->refwd = mail_strip_subject (t,&s->subject);
+	  s->dirty = T;
+	}
+	break;
+      default:
+	fatal ("Unknown sort function");
+      }
+    }
+  return sc;
+}
+
+/* Strip subjects of extra spaces and leading and trailing cruft for sorting
+ * Accepts: unstripped subject
+ *	    pointer to return stripped subject, in cpystr form
+ * Returns: T if subject had a re/fwd, NIL otherwise
+ */
+
+unsigned int mail_strip_subject (char *t,char **ret)
+{
+  SIZEDTEXT src,dst;
+  unsigned long i,slen;
+  char c,*s,*x;
+  unsigned int refwd = NIL;
+  if (src.size = strlen (t)) {	/* have non-empty subject? */
+    src.data = (unsigned char *) t;
+			/* Step 1 */
+				/* make copy, convert MIME2 if needed */
+    *ret = s = (utf8_mime2text (&src,&dst,U8T_CANONICAL) &&
+		(src.data != dst.data)) ? (char *) dst.data : cpystr (t);
+				/* convert spaces to tab, strip extra spaces */
+    for (x = t = s, c = 'x'; *t; t++) {
+      if (c != ' ') c = *x++ = ((*t == '\t') ? ' ' : *t);
+      else if ((*t != '\t') && (*t != ' ')) c = *x++ = *t;
+    }
+    *x = '\0';			/* tie off string */
+			/* Step 2 */
+    for (slen = dst.size; s; slen = strlen (s))  {
+      for (t = s + slen; t > s; ) switch (t[-1]) {
+      case ' ': case '\t':	/* WSP */
+	*--t = '\0';		/* just remove it */
+	break;
+      case ')':			/* possible "(fwd)" */
+	if ((t >= (s + 5)) && (t[-5] == '(') &&
+	    ((t[-4] == 'F') || (t[-4] == 'f')) &&
+	    ((t[-3] == 'W') || (t[-3] == 'w')) &&
+	    ((t[-2] == 'D') || (t[-2] == 'd'))) {
+	  *(t -= 5) = '\0';	/* remove "(fwd)" */
+	  refwd = T;		/* note a re/fwd */
+	  break;
+	}
+      default:			/* not a subj-trailer */
+	t = s;
+	break;
+      }
+			/* Steps 3-5 */
+      for (t = s; t; ) switch (*s) {
+      case ' ': case '\t':	/* WSP */
+	s = t = mail_strip_subject_wsp (s + 1);
+	break;
+      case 'r': case 'R':	/* possible "re" */
+	if (((s[1] == 'E') || (s[1] == 'e')) &&
+	    (t = mail_strip_subject_wsp (s + 2)) &&
+	    (t = mail_strip_subject_blob (t)) && (*t == ':')) {
+	  s = ++t;		/* found "re" */
+	  refwd = T;		/* definitely a re/fwd at this point */
+	}
+	else t = NIL;		/* found subj-middle */
+	break;
+      case 'f': case 'F':	/* possible "fw" or "fwd" */
+	if (((s[1] == 'w') || (s[1] == 'W')) &&
+	    (((s[2] == 'd') || (s[2] == 'D')) ?
+	     (t = mail_strip_subject_wsp (s + 3)) :
+	     (t = mail_strip_subject_wsp (s + 2))) &&
+	    (t = mail_strip_subject_blob (t)) && (*t == ':')) {
+	  s = ++t;		/* found "fwd" */
+	  refwd = T;		/* definitely a re/fwd at this point */
+	}
+	else t = NIL;		/* found subj-middle */
+	break;
+      case '[':			/* possible subj-blob */
+	if ((t = mail_strip_subject_blob (s)) && *t) s = t;
+	else t = NIL;		/* found subj-middle */
+	break;
+      default:
+	t = NIL;		/* found subj-middle */
+	break;
+      }
+			/* Step 6 */
+				/* Netscape-style "[Fwd: ...]"? */
+      if ((*s == '[') && ((s[1] == 'F') || (s[1] == 'f')) &&
+	  ((s[2] == 'W') || (s[2] == 'w')) &&
+	  ((s[3] == 'D') || (s[3] == 'd')) && (s[4] == ':') &&
+	  (s[i = strlen (s) - 1] == ']')) {
+	s[i] = '\0';		/* flush closing "]" */
+	s += 5;			/* and leading "[Fwd:" */
+	refwd = T;		/* definitely a re/fwd at this point */
+      }
+      else break;		/* don't need to loop back to step 2 */
+    }
+    if (s != (t = *ret)) {	/* removed leading text? */
+      s = *ret = cpystr (s);	/* yes, make a fresh return copy */
+      fs_give ((void **) &t);	/* flush old copy */
+    }
+  }
+  else *ret = cpystr ("");	/* empty subject */
+  return refwd;			/* return re/fwd state */
+}
+
+/* Strip subject wsp helper routine
+ * Accepts: text
+ * Returns: pointer to text after blob
+ */
+
+char *mail_strip_subject_wsp (char *s)
+{
+  while ((*s == ' ') || (*s == '\t')) s++;
+  return s;
+}
+
+
+/* Strip subject blob helper routine
+ * Accepts: text
+ * Returns: pointer to text after any blob, NIL if blob-like but not blob
+ */
+
+char *mail_strip_subject_blob (char *s)
+{
+  if (*s != '[') return s;	/* not a blob, ignore */
+				/* search for end of blob */
+  while (*++s != ']') if ((*s == '[') || !*s) return NIL;
+  return mail_strip_subject_wsp (s + 1);
+}
+
+/* Sort compare messages
+ * Accept: first message sort cache element
+ *	   second message sort cache element
+ * Returns: -1 if a1 < a2, 0 if a1 == a2, 1 if a1 > a2
+ */
+
+int mail_sort_compare (const void *a1,const void *a2)
+{
+  int i = 0;
+  SORTCACHE *s1 = *(SORTCACHE **) a1;
+  SORTCACHE *s2 = *(SORTCACHE **) a2;
+  SORTPGM *pgm = s1->pgm;
+  if (!s1->sorted) {		/* this one sorted yet? */
+    s1->sorted = T;
+    pgm->progress.sorted++;	/* another sorted message */
+  }
+  if (!s2->sorted) {		/* this one sorted yet? */
+    s2->sorted = T;
+    pgm->progress.sorted++;	/* another sorted message */
+  }
+  do {
+    switch (pgm->function) {	/* execute search program */
+    case SORTDATE:		/* sort by date */
+      i = compare_ulong (s1->date,s2->date);
+      break;
+    case SORTARRIVAL:		/* sort by arrival date */
+      i = compare_ulong (s1->arrival,s2->arrival);
+      break;
+    case SORTSIZE:		/* sort by message size */
+      i = compare_ulong (s1->size,s2->size);
+      break;
+    case SORTFROM:		/* sort by first from */
+      i = compare_cstring (s1->from,s2->from);
+      break;
+    case SORTTO:		/* sort by first to */
+      i = compare_cstring (s1->to,s2->to);
+      break;
+    case SORTCC:		/* sort by first cc */
+      i = compare_cstring (s1->cc,s2->cc);
+      break;
+    case SORTSUBJECT:		/* sort by subject */
+      i = compare_cstring (s1->subject,s2->subject);
+      break;
+    }
+    if (pgm->reverse) i = -i;	/* flip results if necessary */
+  }
+  while (pgm = i ? NIL : pgm->next);
+				/* return result, avoid 0 if at all possible */
+  return i ? i : compare_ulong (s1->num,s2->num);
+}
+
+/* Return message date as an unsigned long seconds since time began
+ * Accepts: message cache pointer
+ * Returns: unsigned long of date
+ *
+ * This routine, like most UNIX systems, is clueless about leap seconds.
+ * Thus, it treats 23:59:60 as equivalent to 00:00:00 the next day.
+ *
+ * This routine forces any early hours on 1-Jan-1970 in oriental timezones
+ * to be 1-Jan-1970 00:00:00 UTC, so as to avoid negative longdates.
+ */
+
+unsigned long mail_longdate (MESSAGECACHE *elt)
+{
+  unsigned long m = elt->month ? elt->month : 1;
+  unsigned long yr = elt->year + BASEYEAR;
+				/* number of days since time began */
+  unsigned long ret = (elt->day ? (elt->day - 1) : 0)
+    + 30 * (m - 1) + ((m + (m > 8)) / 2)
+#ifndef USEJULIANCALENDAR
+#ifndef USEORTHODOXCALENDAR	/* Gregorian calendar */
+    + ((yr / 400) - (BASEYEAR / 400)) - ((yr / 100) - (BASEYEAR / 100))
+#ifdef Y4KBUGFIX
+    - ((yr / 4000) - (BASEYEAR / 4000))
+#endif
+    - ((m < 3) ?
+       !(yr % 4) && ((yr % 100) || (!(yr % 400)
+#ifdef Y4KBUGFIX
+				    && (yr % 4000)
+#endif
+				    )) : 2)
+#else				/* Orthodox calendar */
+    + ((2*(yr / 900)) - (2*(BASEYEAR / 900)))
+    + (((yr % 900) >= 200) - ((BASEYEAR % 900) >= 200))
+    + (((yr % 900) >= 600) - ((BASEYEAR % 900) >= 600))
+    - ((yr / 100) - (BASEYEAR / 100))
+    - ((m < 3) ?
+       !(yr % 4) && ((yr % 100) || ((yr % 900) == 200) || ((yr % 900) == 600))
+       : 2)
+#endif
+#endif
+    + elt->year * 365 + (((unsigned long) (elt->year + (BASEYEAR % 4))) / 4);
+  ret *= 24; ret += elt->hours;	/* date value in hours */
+  ret *= 60; ret +=elt->minutes;/* date value in minutes */
+  yr = (elt->zhours * 60) + elt->zminutes;
+  if (elt->zoccident) ret += yr;/* occidental timezone, make UTC */
+  else if (ret < yr) return 0;	/* still 31-Dec-1969 in UTC */
+  else ret -= yr;		/* oriental timezone, make UTC */
+  ret *= 60; ret += elt->seconds;
+  return ret;
+}
+
+/* Mail thread messages
+ * Accepts: mail stream
+ *	    thread type
+ *	    character set
+ *	    search program
+ *	    option flags
+ * Returns: thread node tree or NIL if error
+ */
+
+THREADNODE *mail_thread (MAILSTREAM *stream,char *type,char *charset,
+			 SEARCHPGM *spg,long flags)
+{
+  THREADNODE *ret = NIL;
+  if (stream->dtb)		/* must have a live driver */
+    ret = stream->dtb->thread ?	/* do driver's action if available */
+      (*stream->dtb->thread) (stream,type,charset,spg,flags) :
+	mail_thread_msgs (stream,type,charset,spg,flags,mail_sort_msgs);
+				/* flush search/sort programs if requested */
+  if (spg && (flags & SE_FREE)) mail_free_searchpgm (&spg);
+  return ret;
+}
+
+
+/* Mail thread messages
+ * Accepts: mail stream
+ *	    thread type
+ *	    character set
+ *	    search program
+ *	    option flags
+ *	    sorter routine
+ * Returns: thread node tree or NIL if error
+ */
+
+THREADNODE *mail_thread_msgs (MAILSTREAM *stream,char *type,char *charset,
+			      SEARCHPGM *spg,long flags,sorter_t sorter)
+{
+  THREADER *t;
+  for (t = &mailthreadlist; t; t = t->next)
+    if (!compare_cstring (type,t->name)) {
+      THREADNODE *ret = (*t->dispatch) (stream,charset,spg,flags,sorter);
+      if (mailthreadresults) (*mailthreadresults) (stream,ret);
+      return ret;
+    }
+  MM_LOG ("No such thread type",ERROR);
+  return NIL;
+}
+
+/* Mail thread ordered subject
+ * Accepts: mail stream
+ *	    character set
+ *	    search program
+ *	    option flags
+ *	    sorter routine
+ * Returns: thread node tree
+ */
+
+THREADNODE *mail_thread_orderedsubject (MAILSTREAM *stream,char *charset,
+					SEARCHPGM *spg,long flags,
+					sorter_t sorter)
+{
+  THREADNODE *thr = NIL;
+  THREADNODE *cur,*top,**tc;
+  SORTPGM pgm,pgm2;
+  SORTCACHE *s;
+  unsigned long i,j,*lst,*ls;
+				/* sort by subject+date */
+  memset (&pgm,0,sizeof (SORTPGM));
+  memset (&pgm2,0,sizeof (SORTPGM));
+  pgm.function = SORTSUBJECT;
+  pgm.next = &pgm2;
+  pgm2.function = SORTDATE;
+  if (lst = (*sorter) (stream,charset,spg,&pgm,flags & ~(SE_FREE | SE_UID))){
+    if (*(ls = lst)) {		/* create thread */
+				/* note first subject */
+      cur = top = thr = mail_newthreadnode
+	((SORTCACHE *) (*mailcache) (stream,*ls++,CH_SORTCACHE));
+				/* note its number */
+      cur->num = (flags & SE_UID) ? mail_uid (stream,*lst) : *lst;
+      i = 1;			/* number of threads */
+      while (*ls) {		/* build tree */
+				/* subjects match? */
+	s = (SORTCACHE *) (*mailcache) (stream,*ls++,CH_SORTCACHE);
+	if (compare_cstring (top->sc->subject,s->subject)) {
+	  i++;			/* have a new thread */
+	  top = top->branch = cur = mail_newthreadnode (s);
+	}
+				/* start a child of the top */
+	else if (cur == top) cur = cur->next = mail_newthreadnode (s);
+				/* sibling of child */
+	else cur = cur->branch = mail_newthreadnode (s);
+				/* set to msgno or UID as needed */
+	cur->num = (flags & SE_UID) ? mail_uid (stream,s->num) : s->num;
+      }
+				/* make threadnode cache */
+      tc = (THREADNODE **) fs_get (i * sizeof (THREADNODE *));
+				/* load threadnode cache */
+      for (j = 0, cur = thr; cur; cur = cur->branch) tc[j++] = cur;
+      if (i != j) fatal ("Threadnode cache confusion");
+      qsort ((void *) tc,i,sizeof (THREADNODE *),mail_thread_compare_date);
+      for (j = 0, --i; j < i; j++) tc[j]->branch = tc[j+1];
+      tc[j]->branch = NIL;	/* end of root */
+      thr = tc[0];		/* head of data */
+      fs_give ((void **) &tc);
+    }
+    fs_give ((void **) &lst);
+  }
+  return thr;
+}
+
+/* Mail thread references
+ * Accepts: mail stream
+ *	    character set
+ *	    search program
+ *	    option flags
+ *	    sorter routine
+ * Returns: thread node tree
+ */
+
+#define REFHASHSIZE 1009	/* arbitrary prime for hash table size */
+
+/*  Reference threading container, as described in Jamie Zawinski's web page
+ * (http://www.jwz.org/doc/threading.html) for this algorithm.  These are
+ * stored as extended data in the hash table (called "id_table" in JWZ's
+ * document) and are maintained by the hash table routines.  The hash table
+ * routines implement extended data as additional void* words at the end of
+ * each bucket, hence these strange macros instead of a struct which would
+ * have been more straightforward.
+ */
+
+#define THREADLINKS 3		/* number of thread links */
+
+#define CACHE(data) ((SORTCACHE *) (data)[0])
+#define PARENT(data) ((container_t) (data)[1])
+#define SETPARENT(data,value) ((container_t) (data[1] = value))
+#define SIBLING(data) ((container_t) (data)[2])
+#define SETSIBLING(data,value) ((container_t) (data[2] = value))
+#define CHILD(data) ((container_t) (data)[3])
+#define SETCHILD(data,value) ((container_t) (data[3] = value))
+
+THREADNODE *mail_thread_references (MAILSTREAM *stream,char *charset,
+				    SEARCHPGM *spg,long flags,sorter_t sorter)
+{
+  MESSAGECACHE *elt,telt;
+  ENVELOPE *env;
+  SORTCACHE *s;
+  STRINGLIST *st;
+  HASHENT *he;
+  THREADNODE **tc,*cur,*lst,*nxt,*sis,*msg;
+  container_t con,nxc,prc,sib;
+  void **sub;
+  char *t,tmp[MAILTMPLEN];
+  unsigned long j,nmsgs;
+  unsigned long i = stream->nmsgs * sizeof (SORTCACHE *);
+  SORTCACHE **sc = (SORTCACHE **) memset (fs_get ((size_t) i),0,(size_t) i);
+  HASHTAB *ht = hash_create (REFHASHSIZE);
+  THREADNODE *root = NIL;
+  if (spg) {			/* only if a search needs to be done */
+    int silent = stream->silent;
+    stream->silent = T;		/* don't pass up mm_searched() events */
+				/* search for messages */
+    mail_search_full (stream,charset,spg,NIL);
+    stream->silent = silent;	/* restore silence state */
+  }
+
+				/* create SORTCACHE vector of requested msgs */
+  for (i = 1, nmsgs = 0; i <= stream->nmsgs; ++i)
+    if (mail_elt (stream,i)->searched)
+      (sc[nmsgs++] = (SORTCACHE *)(*mailcache)(stream,i,CH_SORTCACHE))->num =i;
+	/* separate pass so can do overview fetch lookahead */
+  for (i = 0; i < nmsgs; ++i) {	/* for each requested message */
+				/* is anything missing in its SORTCACHE? */
+    if (!((s = sc[i])->date && s->subject && s->message_id && s->references)) {
+				/* driver has an overview mechanism? */
+      if (stream->dtb && stream->dtb->overview) {
+				/* yes, find following unloaded entries */
+	for (j = i + 1; (j < nmsgs) && !sc[j]->references; ++j);
+	sprintf (tmp,"%lu",mail_uid (stream,s->num));
+	if (i != --j)		/* end of range different? */
+	  sprintf (tmp + strlen (tmp),":%lu",mail_uid (stream,sc[j]->num));
+				/* load via overview mechanism */
+	mail_fetch_overview (stream,tmp,mail_thread_loadcache);
+      }
+				/* still missing data? */
+      if (!s->date || !s->subject || !s->message_id || !s->references) {
+				/* try to load data from envelope */
+	if (env = mail_fetch_structure (stream,s->num,NIL,NIL)) {
+	  if (!s->date && env->date && mail_parse_date (&telt,env->date))
+	    s->date = mail_longdate (&telt);
+	  if (!s->subject && env->subject)
+	    s->refwd =
+	      mail_strip_subject (env->subject,&s->subject);
+	  if (!s->message_id && env->message_id && *env->message_id)
+	    s->message_id = mail_thread_parse_msgid (env->message_id,NIL);
+	  if (!s->references &&	/* use References: or In-Reply-To: */
+	      !(s->references = 
+		mail_thread_parse_references (env->references,T)))
+	    s->references = mail_thread_parse_references(env->in_reply_to,NIL);
+	}
+				/* last resort */
+	if (!s->date && !(s->date = s->arrival)) {
+				/* internal date unknown but can get? */
+	  if (!(elt = mail_elt (stream,s->num))->day &&
+	      !(stream->dtb->flags & DR_NOINTDATE)) {
+	    sprintf (tmp,"%lu",s->num);
+	    mail_fetch_fast (stream,tmp,NIL);
+	  }
+				/* wrong thing before 3-Jan-1970 */
+	  s->date = (s->arrival = elt->day ? mail_longdate (elt) : 1);
+	}
+	if (!s->subject) s->subject = cpystr ("");
+	if (!s->references) s->references = mail_newstringlist ();
+	s->dirty = T;
+      }
+    }
+
+			/* Step 1 (preliminary) */
+				/* generate unique string */
+    sprintf (tmp,"%s.%lx.%lx@%s",stream->mailbox,stream->uid_validity,
+	     mail_uid (stream,s->num),mylocalhost ());
+				/* flush old unique string if not message-id */
+    if (s->unique && (s->unique != s->message_id))
+      fs_give ((void **) &s->unique);
+    s->unique = s->message_id ?	/* don't permit Message ID duplicates */
+      (hash_lookup (ht,s->message_id) ? cpystr (tmp) : s->message_id) :
+	(s->message_id = cpystr (tmp));
+				/* add unique string to hash table */
+    hash_add (ht,s->unique,s,THREADLINKS);
+  }
+			/* Step 1 */
+  for (i = 0; i < nmsgs; ++i) {	/* for each message in sortcache */
+			/* Step 1A */
+    if ((st = (s = sc[i])->references) && st->text.data)
+      for (con = hash_lookup_and_add (ht,(char *) st->text.data,NIL,
+				      THREADLINKS); st = st->next; con = nxc) {
+	nxc = hash_lookup_and_add (ht,(char *) st->text.data,NIL,THREADLINKS);
+				/* only if no parent & won't introduce loop */
+	if (!PARENT (nxc) && !mail_thread_check_child (con,nxc)) {
+	  SETPARENT (nxc,con);	/* establish parent/child link */
+				/* other children become sibling of this one */
+	  SETSIBLING (nxc,CHILD (con));
+	  SETCHILD (con,nxc);	/* set as child of parent */
+	}
+      }
+    else con = NIL;		/* else message has no ancestors */
+			/* Step 1B */
+    if ((prc = PARENT ((nxc = hash_lookup (ht,s->unique)))) &&
+	(prc != con)) {		/* break links if have a different parent */
+      SETPARENT (nxc,NIL);	/* easy if direct child */
+      if (nxc == CHILD (prc)) SETCHILD (prc,SIBLING (nxc));
+      else {			/* otherwise hunt through sisters */
+	for (sib = CHILD (prc); nxc != SIBLING (sib); sib = SIBLING (sib));
+	SETSIBLING (sib,SIBLING (nxc));
+      }
+      SETSIBLING (nxc,NIL);	/* no more little sisters either */
+      prc = NIL;		/* no more parent set */
+    }
+				/* need to set parent, and parent is good? */
+    if (!prc && !mail_thread_check_child (con,nxc)) {
+      SETPARENT (nxc,con);	/* establish parent/child link */
+      if (con) {		/* if non-root parent, set parent's child */
+	if (CHILD (con)) {	/* have a child already */
+				/* find youngest daughter */
+	  for (con = CHILD (con); SIBLING (con); con = SIBLING (con));
+	  SETSIBLING (con,nxc);	/* add new baby sister */
+	}
+	else SETCHILD (con,nxc);/* set as only child */
+      }
+    }
+  }
+  fs_give ((void **) &sc);	/* finished with sortcache vector */
+
+			/* Step 2 */
+				/* search hash table for parentless messages */
+  for (i = 0, prc = con = NIL; i < ht->size; i++)
+    for (he = ht->table[i]; he; he = he->next)
+      if (!PARENT ((nxc = he->data))) {
+				/* sibling of previous parentless message */
+	if (con) con = SETSIBLING (con,nxc);
+	else prc = con = nxc;	/* first parentless message */
+      }
+  /*  Once the dummy containers are pruned, we no longer need the parent
+   * information, so we can convert the containers to THREADNODEs.  Since
+   * we don't need the id_table any more either, we can reset the hash table
+   * and reuse it as a subject_table.  Resetting the hash table will also
+   * destroy the containers.
+   */
+			/* Step 3 */
+				/* prune dummies, convert to threadnode */
+  root = mail_thread_c2node (stream,mail_thread_prune_dummy (prc,NIL),flags);
+			/* Step 4 */
+				/* make buffer for sorting */
+  tc = (THREADNODE **) fs_get (nmsgs * sizeof (THREADNODE *));
+				/* load threadcache and count nodes to sort */
+  for (i = 0, cur = root; cur ; cur = cur->branch) tc[i++] = cur;
+  if (i > 1) {			/* only if need to sort */
+    qsort ((void *) tc,i,sizeof (THREADNODE *),mail_thread_compare_date);
+				/* relink siblings */
+    for (j = 0, --i; j < i; j++) tc[j]->branch = tc[j+1];
+    tc[j]->branch = NIL;	/* end of root */
+    root = tc[0];		/* establish new root */
+  }
+			/* Step 5A */
+  hash_reset (ht);		/* discard containers, reset ht */
+			/* Step 5B */
+  for (cur = root; cur; cur = cur->branch)
+    if ((t = (nxt = (cur->sc ? cur : cur->next))->sc->subject) && *t) {
+				/* add new subject to hash table */
+      if (!(sub = hash_lookup (ht,t))) hash_add (ht,t,cur,0);
+				/* if one in table not dummy and */
+      else if ((s = (lst = (THREADNODE *) sub[0])->sc) &&
+				/* current dummy, or not re/fwd and table is */
+	       (!cur->sc || (!nxt->sc->refwd && s->refwd)))
+	sub[0] = (void *) cur;	/* replace with this message */
+    }
+
+			/* Step 5C */
+  for (cur = root, sis = NIL; cur; cur = msg) {
+				/* do nothing if current message or no sub */
+    if (!(t = (cur->sc ? cur : cur->next)->sc->subject) || !*t ||
+	((lst = (THREADNODE *) (sub = hash_lookup (ht,t))[0]) == cur))
+      msg = (sis = cur)->branch;
+    else if (!lst->sc) {	/* is message in the table a dummy? */
+				/* find youngest daughter of msg in table */
+      for (msg = lst->next; msg->branch; msg = msg->branch);
+      if (!cur->sc) {		/* current message a dummy? */
+	msg->branch = cur->next;/* current's daughter now dummy's youngest */
+	msg = cur->branch;	/* continue scan at younger sister */
+				/* now delete this node */
+	cur->branch = cur->next = NIL;
+	mail_free_threadnode (&cur);
+      }
+      else {			/* current message not a dummy */
+	msg->branch = cur;	/* append as youngest daughter */
+	msg = cur->branch;	/* continue scan at younger sister */
+	cur->branch = NIL;	/* lose our younger sisters */
+      }
+    }
+    else {			/* no dummies, is current re/fwd, table not? */
+      if (cur->sc->refwd && !lst->sc->refwd) {
+	if (lst->next) {	/* find youngest daughter of msg in table */
+	  for (msg = lst->next; msg->branch; msg = msg->branch);
+	  msg->branch = cur;	/* append as youngest daughter */
+	}
+	else lst->next = cur;	/* no children, so make the eldest daughter */
+      }
+
+      else {			/* no re/fwd, create a new dummy */
+	msg = mail_newthreadnode (NIL);
+	if (lst == root) {	/* msg in table is root? */
+	  root = lst->branch;	/* younger sister becomes new root */
+				/* no longer older sister either */
+	  if (lst == sis) sis = NIL;
+	}
+	else {			/* find older sister of msg in table */
+	  for (nxt = root; lst != nxt->branch; nxt = nxt->branch);
+				/* remove from older sister */
+	  nxt->branch = lst->branch;
+	}
+	msg->next = lst;	/* msg in table becomes child */
+	lst->branch = cur;	/* current now little sister of msg in table */
+	if (sis) {		/* have an elder sister? */
+	  if (sis == lst)	/* rescan if lost her */
+	    for (sis = root; cur != sis->branch; sis = sis->branch);
+	  sis->branch = msg;	/* make dummy younger sister of big sister */
+	}
+	else root = msg;	/* otherwise this is the new root */
+	sub[0] = sis = msg;	/* set new msg in table and new big sister */
+      }
+      msg = cur->branch;	/* continue scan at younger sister */
+      cur->branch = NIL;	/* lose our younger sisters */
+    }
+    if (sis) sis->branch = msg;	/* older sister gets this as younger sister */
+    else root = msg;		/* otherwise this is the new root */
+  }
+  hash_destroy (&ht);		/* finished with hash table */
+			/* Step 6 */
+				/* sort threads */
+  root = mail_thread_sort (root,tc);
+  fs_give ((void **) &tc);	/* finished with sort buffer */
+  return root;			/* return sorted list */
+}
+
+/* Fetch overview callback to load sortcache for threading
+ * Accepts: MAIL stream
+ *	    UID of this message
+ *	    overview of this message
+ *	    msgno of this message
+ */
+
+void mail_thread_loadcache (MAILSTREAM *stream,unsigned long uid,OVERVIEW *ov,
+			    unsigned long msgno)
+{
+  if (msgno && ov) {		/* just in case */
+    MESSAGECACHE telt, *elt;
+    ENVELOPE *env;
+    SORTCACHE *s = (SORTCACHE *) (*mailcache) (stream,msgno,CH_SORTCACHE);
+    if (!s->subject && ov->subject) {
+      s->refwd = mail_strip_subject (ov->subject,&s->subject);
+      s->dirty = T;
+    }
+    if (!s->from && ov->from && ov->from->mailbox) {
+      s->from = cpystr (ov->from->mailbox);
+      s->dirty = T;
+    }
+    if (!s->date && ov->date && mail_parse_date (&telt,ov->date)) {
+      s->date = mail_longdate (&telt);
+      s->dirty = T;
+    }
+    if (!s->message_id && ov->message_id) {
+      s->message_id = mail_thread_parse_msgid (ov->message_id,NIL);
+      s->dirty = T;
+    }
+    if (!s->references &&
+	!(s->references = mail_thread_parse_references (ov->references,T))
+	&& stream->dtb && !strcmp(stream->dtb->name, "imap")
+	&& (elt = mail_elt (stream, msgno)) != NULL
+	&& (env = elt->private.msg.env) != NULL 
+	&& env->in_reply_to
+	&& !(s->references = mail_thread_parse_references(env->in_reply_to, NIL))) {
+				/* don't do In-Reply-To with NNTP mailboxes */
+      s->references = mail_newstringlist ();
+      s->dirty = T;
+    }
+    if (!s->size && ov->optional.octets) {
+      s->size = ov->optional.octets;
+      s->dirty = T;
+    }
+  }
+}
+
+/* Thread parse Message ID
+ * Accepts: pointer to purported Message ID
+ *	    pointer to return pointer
+ * Returns: Message ID or NIL, return pointer updated
+ */
+
+char *mail_thread_parse_msgid (char *s,char **ss)
+{
+  char *ret = NIL;
+  char *t = NIL;
+  ADDRESS *adr;
+  if (s) {			/* only for non-NIL strings */
+    rfc822_skipws (&s);		/* skip whitespace */
+				/* ignore phrases */
+    if (((*s == '<') || (s = rfc822_parse_phrase (s))) &&
+	(adr = rfc822_parse_routeaddr (s,&t,BADHOST))) {
+				/* make return msgid */
+      if (adr->mailbox && adr->host)
+	sprintf (ret = (char *) fs_get (strlen (adr->mailbox) +
+					strlen (adr->host) + 2),"%s@%s",
+		 adr->mailbox,adr->host);
+      mail_free_address (&adr);	/* don't need temporary address */
+    }
+  }
+  if (ss) *ss = t;		/* update return pointer */
+  return ret;
+}
+
+
+/* Thread parse references
+ * Accepts: pointer to purported references
+ *	    parse multiple references flag
+ * Returns: references or NIL
+ */
+
+STRINGLIST *mail_thread_parse_references (char *s,long flag)
+{
+  char *t;
+  STRINGLIST *ret = NIL;
+  STRINGLIST *cur;
+				/* found first reference? */
+  if (t = mail_thread_parse_msgid (s,&s)) {
+    (ret = mail_newstringlist ())->text.data = (unsigned char *) t;
+    ret->text.size = strlen (t);
+    if (flag)			/* parse subsequent references */
+      for (cur = ret; t = mail_thread_parse_msgid (s,&s); cur = cur->next) {
+	(cur->next = mail_newstringlist ())->text.data = (unsigned char *) t;
+	cur->next->text.size = strlen (t);
+      }
+  }
+  return ret;
+}
+
+/* Prune dummy messages
+ * Accepts: candidate container to prune
+ *	    older sibling of container, if any
+ * Returns: container in this position, possibly pruned
+ * All children and younger siblings are also pruned
+ */
+
+container_t mail_thread_prune_dummy (container_t msg,container_t ane)
+{
+				/* prune container and children */
+  container_t ret = msg ? mail_thread_prune_dummy_work (msg,ane) : NIL;
+				/* prune all younger sisters */
+  if (ret) for (ane = ret; ane && (msg = SIBLING (ane)); ane = msg)
+    msg = mail_thread_prune_dummy_work (msg,ane);
+  return ret;
+}
+
+
+/* Prune dummy messages worker routine
+ * Accepts: candidate container to prune
+ *	    older sibling of container, if any
+ * Returns: container in this position, possibly pruned
+ * All children are also pruned
+ */
+
+container_t mail_thread_prune_dummy_work (container_t msg,container_t ane)
+{
+  container_t cur;
+				/* get children, if any */
+  container_t nxt = mail_thread_prune_dummy (CHILD (msg),NIL);
+				/* just update children if container has msg */
+  if (CACHE (msg)) SETCHILD (msg,nxt);
+  else if (!nxt) {		/* delete dummy with no children */
+    nxt = SIBLING (msg);	/* get younger sister */
+    if (ane) SETSIBLING (ane,nxt);
+				/* prune younger sister if exists */
+    msg = nxt ? mail_thread_prune_dummy_work (nxt,ane) : NIL;
+  }
+				/* not if parent root & multiple children */
+  else if ((cur = PARENT (msg)) || !SIBLING (nxt)) {
+				/* OK to promote, try younger sister of aunt */
+    if (ane) SETSIBLING (ane,nxt);
+				/* otherwise promote to child of grandmother */
+    else if (cur) SETCHILD (cur,nxt);
+    SETPARENT (nxt,cur);	/* set parent as well */
+				/* look for end of siblings in new container */
+    for (cur = nxt; SIBLING (cur); cur = SIBLING (cur));
+				/* reattach deleted container's siblings */
+    SETSIBLING (cur,SIBLING (msg));
+				/* prune and return new container */
+    msg = mail_thread_prune_dummy_work (nxt,ane);
+  }
+  else SETCHILD (msg,nxt);	/* in case child pruned */
+  return msg;			/* return this message */
+}
+
+/* Test that purported mother is not a child of purported daughter
+ * Accepts: mother
+ *	    purported daugher
+ * Returns: T if circular parentage exists, else NIL
+ */
+
+long mail_thread_check_child (container_t mother,container_t daughter)
+{
+  if (mother) {			/* only if mother non-NIL */
+    if (mother == daughter) return T;
+    for (daughter = CHILD (daughter); daughter; daughter = SIBLING (daughter))
+      if (mail_thread_check_child (mother,daughter)) return T;
+  }
+  return NIL;
+}
+
+
+/* Generate threadnodes from containers
+ * Accepts: Mail stream
+ *	    container
+ *	    flags
+ * Return: threadnode list
+ */
+
+THREADNODE *mail_thread_c2node (MAILSTREAM *stream,container_t con,long flags)
+{
+  THREADNODE *ret,*cur;
+  SORTCACHE *s;
+  container_t nxt;
+				/* for each container */
+  for (ret = cur = NIL; con; con = SIBLING (con)) {
+    s = CACHE (con);		/* yes, get its sortcache */
+				/* create node for it */
+    if (ret) cur = cur->branch = mail_newthreadnode (s);
+    else ret = cur = mail_newthreadnode (s);
+				/* attach sequence or UID for non-dummy */
+    if (s) cur->num = (flags & SE_UID) ? mail_uid (stream,s->num) : s->num;
+				/* attach the children */
+    if (nxt = CHILD (con)) cur->next = mail_thread_c2node (stream,nxt,flags);
+  }
+  return ret;
+}
+
+/* Sort thread tree by date
+ * Accepts: thread tree to sort
+ *	    qsort vector to sort
+ * Returns: sorted thread tree
+ */
+
+THREADNODE *mail_thread_sort (THREADNODE *thr,THREADNODE **tc)
+{
+  unsigned long i,j;
+  THREADNODE *cur;
+				/* sort children of each thread */
+  for (cur = thr; cur; cur = cur->branch)
+    if (cur->next) cur->next = mail_thread_sort (cur->next,tc);
+  /* Must do this in a separate pass since recursive call will clobber tc */
+				/* load threadcache and count nodes to sort */
+  for (i = 0, cur = thr; cur; cur = cur->branch) tc[i++] = cur;
+  if (i > 1) {			/* only if need to sort */
+    qsort ((void *) tc,i,sizeof (THREADNODE *),mail_thread_compare_date);
+				/* relink root siblings */
+    for (j = 0, --i; j < i; j++) tc[j]->branch = tc[j+1];
+    tc[j]->branch = NIL;	/* end of root */
+  }
+  return i ? tc[0] : NIL;	/* return new head of list */
+}
+
+
+/* Thread compare date
+ * Accept: first message sort cache element
+ *	   second message sort cache element
+ * Returns: -1 if a1 < a2, 1 if a1 > a2
+ *
+ * This assumes that a sort cache element is either a message (with a
+ * sortcache entry) or a dummy with a message (with sortcache entry) child.
+ * This is true of both the ORDEREDSUBJECT (no dummies) and REFERENCES
+ * (dummies only at top-level, and with non-dummy children).
+ *
+ * If a new algorithm allows a dummy parent to have a dummy child, this
+ * routine must be changed if it is to be used by that algorithm.
+ *
+ * Messages with bogus dates are always sorted at the top.
+ */
+
+int mail_thread_compare_date (const void *a1,const void *a2)
+{
+  THREADNODE *t1 = *(THREADNODE **) a1;
+  THREADNODE *t2 = *(THREADNODE **) a2;
+  SORTCACHE *s1 = t1->sc ? t1->sc : t1->next->sc;
+  SORTCACHE *s2 = t2->sc ? t2->sc : t2->next->sc;
+  int ret = compare_ulong (s1->date,s2->date);
+				/* use number as final tie-breaker */
+  return ret ? ret : compare_ulong (s1->num,s2->num);
+}
+
+/* Mail parse sequence
+ * Accepts: mail stream
+ *	    sequence to parse
+ * Returns: T if parse successful, else NIL
+ */
+
+long mail_sequence (MAILSTREAM *stream,unsigned char *sequence)
+{
+  unsigned long i,j,x;
+  for (i = 1; i <= stream->nmsgs; i++) mail_elt (stream,i)->sequence = NIL;
+  while (sequence && *sequence){/* while there is something to parse */
+    if (*sequence == '*') {	/* maximum message */
+      if (stream->nmsgs) i = stream->nmsgs;
+      else {
+	MM_LOG ("No messages, so no maximum message number",ERROR);
+	return NIL;
+      }
+      sequence++;		/* skip past * */
+    }
+				/* parse and validate message number */
+    else if (!isdigit (*sequence)) {
+      MM_LOG ("Syntax error in sequence",ERROR);
+      return NIL;
+    }
+    else if (!(i = strtoul (sequence,(char **) &sequence,10)) ||
+	     (i > stream->nmsgs)) {
+      MM_LOG ("Sequence out of range",ERROR);
+      return NIL;
+    }
+    switch (*sequence) {	/* see what the delimiter is */
+    case ':':			/* sequence range */
+      if (*++sequence == '*') {	/* maximum message */
+	if (stream->nmsgs) j = stream->nmsgs;
+	else {
+	  MM_LOG ("No messages, so no maximum message number",ERROR);
+	  return NIL;
+	}
+	sequence++;		/* skip past * */
+      }
+				/* parse end of range */
+      else if (!(j = strtoul (sequence,(char **) &sequence,10)) ||
+	       (j > stream->nmsgs)) {
+	MM_LOG ("Sequence range invalid",ERROR);
+	return NIL;
+      }
+      if (*sequence && *sequence++ != ',') {
+	MM_LOG ("Sequence range syntax error",ERROR);
+	return NIL;
+      }
+      if (i > j) {		/* swap the range if backwards */
+	x = i; i = j; j = x;
+      }
+				/* mark each item in the sequence */
+      while (i <= j) mail_elt (stream,j--)->sequence = T;
+      break;
+    case ',':			/* single message */
+      ++sequence;		/* skip the delimiter, fall into end case */
+    case '\0':			/* end of sequence, mark this message */
+      mail_elt (stream,i)->sequence = T;
+      break;
+    default:			/* anything else is a syntax error! */
+      MM_LOG ("Sequence syntax error",ERROR);
+      return NIL;
+    }
+  }
+  return T;			/* successfully parsed sequence */
+}
+
+/* Parse flag list
+ * Accepts: MAIL stream
+ *	    flag list as a character string
+ *	    pointer to user flags to return
+ * Returns: system flags
+ */
+
+long mail_parse_flags (MAILSTREAM *stream,char *flag,unsigned long *uf)
+{
+  char *t,*n,*s,tmp[MAILTMPLEN],msg[MAILTMPLEN];
+  short f = 0;
+  long i,j;
+  *uf = 0;			/* initially no user flags */
+  if (flag && *flag) {		/* no-op if no flag string */
+				/* check if a list and make sure valid */
+    if (((i = (*flag == '(')) ^ (flag[strlen (flag)-1] == ')')) ||
+	(strlen (flag) >= MAILTMPLEN)) {
+      MM_LOG ("Bad flag list",ERROR);
+      return NIL;
+    }
+				/* copy the flag string w/o list construct */
+    strncpy (n = tmp,flag+i,(j = strlen (flag) - (2*i)));
+    tmp[j] = '\0';
+    while ((t = n) && *t) {	/* parse the flags */
+				/* find end of flag */
+      if (n = strchr (t,' ')) *n++ = '\0';
+      if (*t == '\\') {		/* system flag? */
+	if (!compare_cstring (t+1,"SEEN")) f |= fSEEN;
+	else if (!compare_cstring (t+1,"DELETED")) f |= fDELETED;
+	else if (!compare_cstring (t+1,"FLAGGED")) f |= fFLAGGED;
+	else if (!compare_cstring (t+1,"ANSWERED")) f |= fANSWERED;
+	else if (!compare_cstring (t+1,"DRAFT")) f |= fDRAFT;
+	else {
+	  sprintf (msg,"Unsupported system flag: %.80s",t);
+	  MM_LOG (msg,WARN);
+	}
+      }
+
+      else {			/* keyword flag */
+	for (i = j = 0;		/* user flag, search through table */
+	     !i && (j < NUSERFLAGS) && (s = stream->user_flags[j]); ++j)
+	  if (!compare_cstring (t,s)) *uf |= i = 1 << j;
+	if (!i) {		/* flag not found, can it be created? */
+	  if (stream->kwd_create && (j < NUSERFLAGS) && *t &&
+	      (strlen (t) <= MAXUSERFLAG)) {
+	    for (s = t; t && *s; s++) switch (*s) {
+	    default:		/* all other characters */
+				/* SPACE, CTL, or not CHAR */
+	      if ((*s > ' ') && (*s < 0x7f)) break;
+	    case '*': case '%':	/* list_wildcards */
+	    case '"': case '\\':/* quoted-specials */
+				/* atom_specials */
+	    case '(': case ')': case '{':
+	    case ']':		/* resp-specials */
+	      sprintf (msg,"Invalid flag: %.80s",t);
+	      MM_LOG (msg,WARN);
+	      t = NIL;
+	    }
+	    if (t) {		/* only if valid */
+	      *uf |= 1 << j;	/* set the bit */
+	      stream->user_flags[j] = cpystr (t);
+				/* if out of user flags */
+	      if (j == NUSERFLAGS - 1) stream->kwd_create = NIL;
+	    }
+	  }
+	  else {
+	    if (*t) sprintf (msg,"Unknown flag: %.80s",t);
+	    else strcpy (msg,"Empty flag invalid");
+	    MM_LOG (msg,WARN);
+	  }
+	}
+      }
+    }
+  }
+  return f;
+}
+
+/* Mail check network stream for usability with new name
+ * Accepts: MAIL stream
+ *	    candidate new name
+ * Returns: T if stream can be used, NIL otherwise
+ */
+
+long mail_usable_network_stream (MAILSTREAM *stream,char *name)
+{
+  NETMBX smb,nmb,omb;
+  return (stream && stream->dtb && !(stream->dtb->flags & DR_LOCAL) &&
+	  mail_valid_net_parse (name,&nmb) &&
+	  mail_valid_net_parse (stream->mailbox,&smb) &&
+	  mail_valid_net_parse (stream->original_mailbox,&omb) &&
+	  ((!compare_cstring (smb.host,
+			      trustdns ? tcp_canonical (nmb.host) : nmb.host)&&
+	    !strcmp (smb.service,nmb.service) &&
+	    (!nmb.port || (smb.port == nmb.port)) &&
+	    (nmb.anoflag == stream->anonymous) &&
+	    (!nmb.user[0] || !strcmp (smb.user,nmb.user))) ||
+	   (!compare_cstring (omb.host,nmb.host) &&
+	    !strcmp (omb.service,nmb.service) &&
+	    (!nmb.port || (omb.port == nmb.port)) &&
+	    (nmb.anoflag == stream->anonymous) &&
+	    (!nmb.user[0] || !strcmp (omb.user,nmb.user))))) ? LONGT : NIL;
+}
+
+/* Mail data structure instantiation routines */
+
+
+/* Mail instantiate cache elt
+ * Accepts: initial message number
+ * Returns: new cache elt
+ */
+
+MESSAGECACHE *mail_new_cache_elt (unsigned long msgno)
+{
+  MESSAGECACHE *elt = (MESSAGECACHE *) memset (fs_get (sizeof (MESSAGECACHE)),
+					       0,sizeof (MESSAGECACHE));
+  elt->lockcount = 1;		/* initially only cache references it */
+  elt->msgno = msgno;		/* message number */
+  return elt;
+}
+
+
+/* Mail instantiate envelope
+ * Returns: new envelope
+ */
+
+ENVELOPE *mail_newenvelope (void)
+{
+  return (ENVELOPE *) memset (fs_get (sizeof (ENVELOPE)),0,sizeof (ENVELOPE));
+}
+
+
+/* Mail instantiate address
+ * Returns: new address
+ */
+
+ADDRESS *mail_newaddr (void)
+{
+  return (ADDRESS *) memset (fs_get (sizeof (ADDRESS)),0,sizeof (ADDRESS));
+}
+
+/* Mail instantiate body
+ * Returns: new body
+ */
+
+BODY *mail_newbody (void)
+{
+  return mail_initbody ((BODY *) fs_get (sizeof (BODY)));
+}
+
+
+/* Mail initialize body
+ * Accepts: body
+ * Returns: body
+ */
+
+BODY *mail_initbody (BODY *body)
+{
+  memset ((void *) body,0,sizeof (BODY));
+  body->type = TYPETEXT;	/* content type */
+  body->encoding = ENC7BIT;	/* content encoding */
+  return body;
+}
+
+
+/* Mail instantiate body parameter
+ * Returns: new body part
+ */
+
+PARAMETER *mail_newbody_parameter (void)
+{
+  return (PARAMETER *) memset (fs_get (sizeof(PARAMETER)),0,sizeof(PARAMETER));
+}
+
+
+/* Mail instantiate body part
+ * Returns: new body part
+ */
+
+PART *mail_newbody_part (void)
+{
+  PART *part = (PART *) memset (fs_get (sizeof (PART)),0,sizeof (PART));
+  mail_initbody (&part->body);	/* initialize the body */
+  return part;
+}
+
+
+/* Mail instantiate body message part
+ * Returns: new body message part
+ */
+
+MESSAGE *mail_newmsg (void)
+{
+  return (MESSAGE *) memset (fs_get (sizeof (MESSAGE)),0,sizeof (MESSAGE));
+}
+
+/* Mail instantiate string list
+ * Returns: new string list
+ */
+
+STRINGLIST *mail_newstringlist (void)
+{
+  return (STRINGLIST *) memset (fs_get (sizeof (STRINGLIST)),0,
+				sizeof (STRINGLIST));
+}
+
+
+/* Mail instantiate new search program
+ * Returns: new search program
+ */
+
+SEARCHPGM *mail_newsearchpgm (void)
+{
+  return (SEARCHPGM *) memset (fs_get (sizeof(SEARCHPGM)),0,sizeof(SEARCHPGM));
+}
+
+
+/* Mail instantiate new search program
+ * Accepts: header line name   
+ * Returns: new search program
+ */
+
+SEARCHHEADER *mail_newsearchheader (char *line,char *text)
+{
+  SEARCHHEADER *hdr = (SEARCHHEADER *) memset (fs_get (sizeof (SEARCHHEADER)),
+					       0,sizeof (SEARCHHEADER));
+  hdr->line.size = strlen ((char *) (hdr->line.data =
+				     (unsigned char *) cpystr (line)));
+  hdr->text.size = strlen ((char *) (hdr->text.data =
+				     (unsigned char *) cpystr (text)));
+  return hdr;
+}
+
+
+/* Mail instantiate new search set
+ * Returns: new search set
+ */
+
+SEARCHSET *mail_newsearchset (void)
+{
+  return (SEARCHSET *) memset (fs_get (sizeof(SEARCHSET)),0,sizeof(SEARCHSET));
+}
+
+
+/* Mail instantiate new search or
+ * Returns: new search or
+ */
+
+SEARCHOR *mail_newsearchor (void)
+{
+  SEARCHOR *or = (SEARCHOR *) memset (fs_get (sizeof (SEARCHOR)),0,
+				      sizeof (SEARCHOR));
+  or->first = mail_newsearchpgm ();
+  or->second = mail_newsearchpgm ();
+  return or;
+}
+
+/* Mail instantiate new searchpgmlist
+ * Returns: new searchpgmlist
+ */
+
+SEARCHPGMLIST *mail_newsearchpgmlist (void)
+{
+  SEARCHPGMLIST *pgl = (SEARCHPGMLIST *)
+    memset (fs_get (sizeof (SEARCHPGMLIST)),0,sizeof (SEARCHPGMLIST));
+  pgl->pgm = mail_newsearchpgm ();
+  return pgl;
+}
+
+
+/* Mail instantiate new sortpgm
+ * Returns: new sortpgm
+ */
+
+SORTPGM *mail_newsortpgm (void)
+{
+  return (SORTPGM *) memset (fs_get (sizeof (SORTPGM)),0,sizeof (SORTPGM));
+}
+
+
+/* Mail instantiate new threadnode
+ * Accepts: sort cache for thread node
+ * Returns: new threadnode
+ */
+
+THREADNODE *mail_newthreadnode (SORTCACHE *sc)
+{
+  THREADNODE *thr = (THREADNODE *) memset (fs_get (sizeof (THREADNODE)),0,
+					   sizeof (THREADNODE));
+  if (sc) thr->sc = sc;		/* initialize sortcache */
+  return thr;
+}
+
+
+/* Mail instantiate new acllist
+ * Returns: new acllist
+ */
+
+ACLLIST *mail_newacllist (void)
+{
+  return (ACLLIST *) memset (fs_get (sizeof (ACLLIST)),0,sizeof (ACLLIST));
+}
+
+
+/* Mail instantiate new quotalist
+ * Returns: new quotalist
+ */
+
+QUOTALIST *mail_newquotalist (void)
+{
+  return (QUOTALIST *) memset (fs_get (sizeof (QUOTALIST)),0,
+			       sizeof (QUOTALIST));
+}
+
+/* Mail garbage collection routines */
+
+
+/* Mail garbage collect body
+ * Accepts: pointer to body pointer
+ */
+
+void mail_free_body (BODY **body)
+{
+  if (*body) {			/* only free if exists */
+    mail_free_body_data (*body);/* free its data */
+    fs_give ((void **) body);	/* return body to free storage */
+  }
+}
+
+
+/* Mail garbage collect body data
+ * Accepts: body pointer
+ */
+
+void mail_free_body_data (BODY *body)
+{
+  switch (body->type) {		/* free contents */
+  case TYPEMULTIPART:		/* multiple part */
+    mail_free_body_part (&body->nested.part);
+    break;
+  case TYPEMESSAGE:		/* encapsulated message */
+    if (body->subtype && !strcmp (body->subtype,"RFC822")) {
+      mail_free_stringlist (&body->nested.msg->lines);
+      mail_gc_msg (body->nested.msg,GC_ENV | GC_TEXTS);
+    }
+    if (body->nested.msg) fs_give ((void **) &body->nested.msg);
+    break;
+  default:
+    break;
+  }
+  if (body->subtype) fs_give ((void **) &body->subtype);
+  mail_free_body_parameter (&body->parameter);
+  if (body->id) fs_give ((void **) &body->id);
+  if (body->description) fs_give ((void **) &body->description);
+  if (body->disposition.type) fs_give ((void **) &body->disposition.type);
+  if (body->disposition.parameter)
+    mail_free_body_parameter (&body->disposition.parameter);
+  if (body->language) mail_free_stringlist (&body->language);
+  if (body->location) fs_give ((void **) &body->location);
+  if (body->mime.text.data) fs_give ((void **) &body->mime.text.data);
+  if (body->contents.text.data) fs_give ((void **) &body->contents.text.data);
+  if (body->md5) fs_give ((void **) &body->md5);
+  if (mailfreebodysparep && body->sparep)
+      (*mailfreebodysparep) (&body->sparep);
+}
+
+/* Mail garbage collect body parameter
+ * Accepts: pointer to body parameter pointer
+ */
+
+void mail_free_body_parameter (PARAMETER **parameter)
+{
+  if (*parameter) {		/* only free if exists */
+    if ((*parameter)->attribute) fs_give ((void **) &(*parameter)->attribute);
+    if ((*parameter)->value) fs_give ((void **) &(*parameter)->value);
+				/* run down the list as necessary */
+    mail_free_body_parameter (&(*parameter)->next);
+				/* return body part to free storage */
+    fs_give ((void **) parameter);
+  }
+}
+
+
+/* Mail garbage collect body part
+ * Accepts: pointer to body part pointer
+ */
+
+void mail_free_body_part (PART **part)
+{
+  if (*part) {			/* only free if exists */
+    mail_free_body_data (&(*part)->body);
+				/* run down the list as necessary */
+    mail_free_body_part (&(*part)->next);
+    fs_give ((void **) part);	/* return body part to free storage */
+  }
+}
+
+/* Mail garbage collect message cache
+ * Accepts: mail stream
+ *
+ * The message cache is set to NIL when this function finishes.
+ */
+
+void mail_free_cache (MAILSTREAM *stream)
+{
+				/* do driver specific stuff first */
+  mail_gc (stream,GC_ELT | GC_ENV | GC_TEXTS);
+				/* flush the cache */
+  (*mailcache) (stream,(long) 0,CH_INIT);
+}
+
+
+/* Mail garbage collect cache element
+ * Accepts: pointer to cache element pointer
+ */
+
+void mail_free_elt (MESSAGECACHE **elt)
+{
+				/* only free if exists and no sharers */
+  if (*elt && !--(*elt)->lockcount) {
+    mail_gc_msg (&(*elt)->private.msg,GC_ENV | GC_TEXTS);
+    if (mailfreeeltsparep && (*elt)->sparep)
+      (*mailfreeeltsparep) (&(*elt)->sparep);
+    fs_give ((void **) elt);
+  }
+  else *elt = NIL;		/* else simply drop pointer */
+}
+
+/* Mail garbage collect envelope
+ * Accepts: pointer to envelope pointer
+ */
+
+void mail_free_envelope (ENVELOPE **env)
+{
+  if (*env) {			/* only free if exists */
+    if ((*env)->remail) fs_give ((void **) &(*env)->remail);
+    mail_free_address (&(*env)->return_path);
+    if ((*env)->date) fs_give ((void **) &(*env)->date);
+    mail_free_address (&(*env)->from);
+    mail_free_address (&(*env)->sender);
+    mail_free_address (&(*env)->reply_to);
+    if ((*env)->subject) fs_give ((void **) &(*env)->subject);
+    mail_free_address (&(*env)->to);
+    mail_free_address (&(*env)->cc);
+    mail_free_address (&(*env)->bcc);
+    if ((*env)->in_reply_to) fs_give ((void **) &(*env)->in_reply_to);
+    if ((*env)->message_id) fs_give ((void **) &(*env)->message_id);
+    if ((*env)->newsgroups) fs_give ((void **) &(*env)->newsgroups);
+    if ((*env)->followup_to) fs_give ((void **) &(*env)->followup_to);
+    if ((*env)->references) fs_give ((void **) &(*env)->references);
+    if (mailfreeenvelopesparep && (*env)->sparep)
+      (*mailfreeenvelopesparep) (&(*env)->sparep);
+    fs_give ((void **) env);	/* return envelope to free storage */
+  }
+}
+
+
+/* Mail garbage collect address
+ * Accepts: pointer to address pointer
+ */
+
+void mail_free_address (ADDRESS **address)
+{
+  if (*address) {		/* only free if exists */
+    if ((*address)->personal) fs_give ((void **) &(*address)->personal);
+    if ((*address)->adl) fs_give ((void **) &(*address)->adl);
+    if ((*address)->mailbox) fs_give ((void **) &(*address)->mailbox);
+    if ((*address)->host) fs_give ((void **) &(*address)->host);
+    if ((*address)->error) fs_give ((void **) &(*address)->error);
+    if ((*address)->orcpt.type) fs_give ((void **) &(*address)->orcpt.type);
+    if ((*address)->orcpt.addr) fs_give ((void **) &(*address)->orcpt.addr);
+    mail_free_address (&(*address)->next);
+    fs_give ((void **) address);/* return address to free storage */
+  }
+}
+
+
+/* Mail garbage collect stringlist
+ * Accepts: pointer to stringlist pointer
+ */
+
+void mail_free_stringlist (STRINGLIST **string)
+{
+  if (*string) {		/* only free if exists */
+    if ((*string)->text.data) fs_give ((void **) &(*string)->text.data);
+    mail_free_stringlist (&(*string)->next);
+    fs_give ((void **) string);	/* return string to free storage */
+  }
+}
+
+/* Mail garbage collect searchpgm
+ * Accepts: pointer to searchpgm pointer
+ */
+
+void mail_free_searchpgm (SEARCHPGM **pgm)
+{
+  if (*pgm) {			/* only free if exists */
+    mail_free_searchset (&(*pgm)->msgno);
+    mail_free_searchset (&(*pgm)->uid);
+    mail_free_searchor (&(*pgm)->or);
+    mail_free_searchpgmlist (&(*pgm)->not);
+    mail_free_searchheader (&(*pgm)->header);
+    mail_free_stringlist (&(*pgm)->bcc);
+    mail_free_stringlist (&(*pgm)->body);
+    mail_free_stringlist (&(*pgm)->cc);
+    mail_free_stringlist (&(*pgm)->from);
+    mail_free_stringlist (&(*pgm)->keyword);
+    mail_free_stringlist (&(*pgm)->subject);
+    mail_free_stringlist (&(*pgm)->text);
+    mail_free_stringlist (&(*pgm)->to);
+    fs_give ((void **) pgm);	/* return program to free storage */
+  }
+}
+
+
+/* Mail garbage collect searchheader
+ * Accepts: pointer to searchheader pointer
+ */
+
+void mail_free_searchheader (SEARCHHEADER **hdr)
+{
+  if (*hdr) {			/* only free if exists */
+    if ((*hdr)->line.data) fs_give ((void **) &(*hdr)->line.data);
+    if ((*hdr)->text.data) fs_give ((void **) &(*hdr)->text.data);
+    mail_free_searchheader (&(*hdr)->next);
+    fs_give ((void **) hdr);	/* return header to free storage */
+  }
+}
+
+
+/* Mail garbage collect searchset
+ * Accepts: pointer to searchset pointer
+ */
+
+void mail_free_searchset (SEARCHSET **set)
+{
+  if (*set) {			/* only free if exists */
+    mail_free_searchset (&(*set)->next);
+    fs_give ((void **) set);	/* return set to free storage */
+  }
+}
+
+/* Mail garbage collect searchor
+ * Accepts: pointer to searchor pointer
+ */
+
+void mail_free_searchor (SEARCHOR **orl)
+{
+  if (*orl) {			/* only free if exists */
+    mail_free_searchpgm (&(*orl)->first);
+    mail_free_searchpgm (&(*orl)->second);
+    mail_free_searchor (&(*orl)->next);
+    fs_give ((void **) orl);	/* return searchor to free storage */
+  }
+}
+
+
+/* Mail garbage collect search program list
+ * Accepts: pointer to searchpgmlist pointer
+ */
+
+void mail_free_searchpgmlist (SEARCHPGMLIST **pgl)
+{
+  if (*pgl) {			/* only free if exists */
+    mail_free_searchpgm (&(*pgl)->pgm);
+    mail_free_searchpgmlist (&(*pgl)->next);
+    fs_give ((void **) pgl);	/* return searchpgmlist to free storage */
+  }
+}
+
+
+/* Mail garbage collect namespace
+ * Accepts: poiner to namespace
+ */
+
+void mail_free_namespace (NAMESPACE **n)
+{
+  if (*n) {
+    fs_give ((void **) &(*n)->name);
+    mail_free_namespace (&(*n)->next);
+    mail_free_body_parameter (&(*n)->param);
+    fs_give ((void **) n);	/* return namespace to free storage */
+  }
+}
+
+/* Mail garbage collect sort program
+ * Accepts: pointer to sortpgm pointer
+ */
+
+void mail_free_sortpgm (SORTPGM **pgm)
+{
+  if (*pgm) {			/* only free if exists */
+    mail_free_sortpgm (&(*pgm)->next);
+    fs_give ((void **) pgm);	/* return sortpgm to free storage */
+  }
+}
+
+
+/* Mail garbage collect thread node
+ * Accepts: pointer to threadnode pointer
+ */
+
+void mail_free_threadnode (THREADNODE **thr)
+{
+  if (*thr) {			/* only free if exists */
+    mail_free_threadnode (&(*thr)->branch);
+    mail_free_threadnode (&(*thr)->next);
+    fs_give ((void **) thr);	/* return threadnode to free storage */
+  }
+}
+
+
+/* Mail garbage collect acllist
+ * Accepts: pointer to acllist pointer
+ */
+
+void mail_free_acllist (ACLLIST **al)
+{
+  if (*al) {			/* only free if exists */
+    if ((*al)->identifier) fs_give ((void **) &(*al)->identifier);
+    if ((*al)->rights) fs_give ((void **) &(*al)->rights);
+    mail_free_acllist (&(*al)->next);
+    fs_give ((void **) al);	/* return acllist to free storage */
+  }
+}
+
+
+/* Mail garbage collect quotalist
+ * Accepts: pointer to quotalist pointer
+ */
+
+void mail_free_quotalist (QUOTALIST **ql)
+{
+  if (*ql) {			/* only free if exists */
+    if ((*ql)->name) fs_give ((void **) &(*ql)->name);
+    mail_free_quotalist (&(*ql)->next);
+    fs_give ((void **) ql);	/* return quotalist to free storage */
+  }
+}
+
+/* Link authenicator
+ * Accepts: authenticator to add to list
+ */
+
+void auth_link (AUTHENTICATOR *auth)
+{
+  if (!auth->valid || (*auth->valid) ()) {
+    AUTHENTICATOR **a = &mailauthenticators;
+    while (*a) a = &(*a)->next;	/* find end of list of authenticators */
+    *a = auth;			/* put authenticator at the end */
+    auth->next = NIL;		/* this authenticator is the end of the list */
+  }
+}
+
+
+/* Authenticate access
+ * Accepts: mechanism name
+ *	    responder function
+ *	    argument count
+ *	    argument vector
+ * Returns: authenticated user name or NIL
+ */
+
+char *mail_auth (char *mechanism,authresponse_t resp,int argc,char *argv[])
+{
+  AUTHENTICATOR *auth;
+  for (auth = mailauthenticators; auth; auth = auth->next)
+    if (auth->server && !compare_cstring (auth->name,mechanism))
+      return (!(auth->flags & AU_DISABLE) &&
+	      ((auth->flags & AU_SECURE) ||
+	       !mail_parameters (NIL,GET_DISABLEPLAINTEXT,NIL))) ?
+	(*auth->server) (resp,argc,argv) : NIL;
+  return NIL;			/* no authenticator found */
+}
+
+/* Lookup authenticator index
+ * Accepts: authenticator index
+ * Returns: authenticator, or 0 if not found
+ */
+
+AUTHENTICATOR *mail_lookup_auth (unsigned long i)
+{
+  AUTHENTICATOR *auth = mailauthenticators;
+  while (auth && --i) auth = auth->next;
+  return auth;
+}
+
+
+/* Lookup authenticator name
+ * Accepts: authenticator name
+ *	    required authenticator flags
+ * Returns: index in authenticator chain, or 0 if not found
+ */
+
+unsigned int mail_lookup_auth_name (char *mechanism,long flags)
+{
+  int i;
+  AUTHENTICATOR *auth;
+  for (i = 1, auth = mailauthenticators; auth; i++, auth = auth->next)
+    if (auth->client && !(flags & ~auth->flags) &&
+	!(auth->flags & AU_DISABLE) && !compare_cstring (auth->name,mechanism))
+      return i;
+  return 0;
+}
+
+/* Standard TCP/IP network driver */
+
+static NETDRIVER tcpdriver = {
+  tcp_open,			/* open connection */
+  tcp_aopen,			/* open preauthenticated connection */
+  tcp_getline,			/* get a line */
+  tcp_getbuffer,		/* get a buffer */
+  tcp_soutr,			/* output pushed data */
+  tcp_sout,			/* output string */
+  tcp_close,			/* close connection */
+  tcp_host,			/* return host name */
+  tcp_remotehost,		/* return remote host name */
+  tcp_port,			/* return port number */
+  tcp_localhost			/* return local host name */
+};
+
+
+/* Network open
+ * Accepts: NETMBX specifier to open
+ *	    default network driver
+ *	    default port
+ *	    SSL driver
+ *	    SSL service name
+ *	    SSL driver port
+ * Returns: Network stream if success, else NIL
+ */
+
+NETSTREAM *net_open (NETMBX *mb,NETDRIVER *dv,unsigned long port,
+		     NETDRIVER *ssld,char *ssls,unsigned long sslp)
+{
+  NETSTREAM *stream = NIL;
+  char tmp[MAILTMPLEN];
+  unsigned long flags = mb->novalidate ? NET_NOVALIDATECERT : 0;
+  if (strlen (mb->host) >= NETMAXHOST) {
+    sprintf (tmp,"Invalid host name: %.80s",mb->host);
+    MM_LOG (tmp,ERROR);
+  }
+				/* use designated driver if given */
+  else if (dv) stream = net_open_work (dv,mb->host,mb->service,port,mb->port,
+				       flags);
+  else if (mb->sslflag && ssld)	/* use ssl if sslflag lit */
+    stream = net_open_work (ssld,mb->host,ssls,sslp,mb->port,flags);
+				/* if trysslfirst and can open ssl... */
+  else if ((mb->trysslflag || trysslfirst) && ssld &&
+	   (stream = net_open_work (ssld,mb->host,ssls,sslp,mb->port,
+				    flags | NET_SILENT | NET_TRYSSL))) {
+    if (net_sout (stream,"",0)) mb->sslflag = T;
+    else {
+      net_close (stream);	/* flush fake SSL stream */
+      stream = NIL;
+    }
+  }
+				/* default to TCP driver */
+  else stream = net_open_work (&tcpdriver,mb->host,mb->service,port,mb->port,
+			       flags);
+  return stream;
+}
+
+/* Network open worker routine
+ * Accepts: network driver
+ *	    host name
+ *	    service name to look up port
+ *	    port number if service name not found
+ *	    port number to override service name
+ *	    flags (passed on top of port)
+ * Returns: Network stream if success, else NIL
+ */
+
+NETSTREAM *net_open_work (NETDRIVER *dv,char *host,char *service,
+			  unsigned long port,unsigned long portoverride,
+			  unsigned long flags)
+{
+  NETSTREAM *stream = NIL;
+  void *tstream;
+  if (service && (*service == '*')) {
+    flags |= NET_NOOPENTIMEOUT;	/* mark that no timeout is desired */
+    ++service;			/* no longer need the no timeout indicator */
+  }
+  if (portoverride) {		/* explicit port number? */
+    service = NIL;		/* yes, override service name */
+    port = portoverride;	/* use that instead of default port */
+  }
+  if (tstream = (*dv->open) (host,service,port | flags)) {
+    stream = (NETSTREAM *) fs_get (sizeof (NETSTREAM));
+    stream->stream = tstream;
+    stream->dtb = dv;
+  }
+  return stream;
+}
+
+
+/* Network authenticated open
+ * Accepts: network driver
+ *	    NETMBX specifier
+ *	    service specifier
+ *	    return user name buffer
+ * Returns: Network stream if success else NIL
+ */
+
+NETSTREAM *net_aopen (NETDRIVER *dv,NETMBX *mb,char *service,char *user)
+{
+  NETSTREAM *stream = NIL;
+  void *tstream;
+  if (!dv) dv = &tcpdriver;	/* default to TCP driver */
+  if (tstream = (*dv->aopen) (mb,service,user)) {
+    stream = (NETSTREAM *) fs_get (sizeof (NETSTREAM));
+    stream->stream = tstream;
+    stream->dtb = dv;
+  }
+  return stream;
+}
+
+/* Network receive line
+ * Accepts: Network stream
+ * Returns: text line string or NIL if failure
+ */
+
+char *net_getline (NETSTREAM *stream)
+{
+  return (*stream->dtb->getline) (stream->stream);
+}
+
+
+/* Network receive buffer
+ * Accepts: Network stream (must be void * for use as readfn_t)
+ *	    size in bytes
+ *	    buffer to read into
+ * Returns: T if success, NIL otherwise
+ */
+
+long net_getbuffer (void *st,unsigned long size,char *buffer)
+{
+  NETSTREAM *stream = (NETSTREAM *) st;
+  return (*stream->dtb->getbuffer) (stream->stream,size,buffer);
+}
+
+
+/* Network send null-terminated string
+ * Accepts: Network stream
+ *	    string pointer
+ * Returns: T if success else NIL
+ */
+
+long net_soutr (NETSTREAM *stream,char *string)
+{
+  return (*stream->dtb->soutr) (stream->stream,string);
+}
+
+
+/* Network send string
+ * Accepts: Network stream
+ *	    string pointer
+ *	    byte count
+ * Returns: T if success else NIL
+ */
+
+long net_sout (NETSTREAM *stream,char *string,unsigned long size)
+{
+  return (*stream->dtb->sout) (stream->stream,string,size);
+}
+
+/* Network close
+ * Accepts: Network stream
+ */
+
+void net_close (NETSTREAM *stream)
+{
+  if (stream->stream) (*stream->dtb->close) (stream->stream);
+  fs_give ((void **) &stream);
+}
+
+
+/* Network get host name
+ * Accepts: Network stream
+ * Returns: host name for this stream
+ */
+
+char *net_host (NETSTREAM *stream)
+{
+  return (*stream->dtb->host) (stream->stream);
+}
+
+
+/* Network get remote host name
+ * Accepts: Network stream
+ * Returns: host name for this stream
+ */
+
+char *net_remotehost (NETSTREAM *stream)
+{
+  return (*stream->dtb->remotehost) (stream->stream);
+}
+
+/* Network return port for this stream
+ * Accepts: Network stream
+ * Returns: port number for this stream
+ */
+
+unsigned long net_port (NETSTREAM *stream)
+{
+  return (*stream->dtb->port) (stream->stream);
+}
+
+
+/* Network get local host name
+ * Accepts: Network stream
+ * Returns: local host name
+ */
+
+char *net_localhost (NETSTREAM *stream)
+{
+  return (*stream->dtb->localhost) (stream->stream);
+}
diff --git a/imap/src/c-client/mail.h b/imap/src/c-client/mail.h
new file mode 100644
index 00000000..174993e1
--- /dev/null
+++ b/imap/src/c-client/mail.h
@@ -0,0 +1,1838 @@
+/* ========================================================================
+ * Copyright 1988-2008 University of Washington
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 
+ * ========================================================================
+ */
+
+/*
+ * Program:	Mailbox Access routines
+ *
+ * Author:	Mark Crispin
+ *		UW Technology
+ *		University of Washington
+ *		Seattle, WA  98195
+ *		Internet: MRC@Washington.EDU
+ *
+ * Date:	22 November 1989
+ * Last Edited:	16 December 2008
+ */
+
+/* The Version */
+
+#define CCLIENTVERSION "2007e"
+
+/* Build parameters */
+
+#define CACHEINCREMENT 250	/* cache growth increments */
+#define MAILTMPLEN 1024		/* size of a temporary buffer */
+#define SENDBUFLEN 16385	/* size of temporary sending buffer, also
+				 * used for SMTP commands and NETMBX generation
+				 * buffer so shouldn't be made smaller than
+				 * MAILTMPLEN.  Note that there's a guard byte,
+				 * so this is actually len+1. */
+#define MAXAUTHENTICATORS 8	/* maximum number of SASL authenticators */
+				/* maximum number of messages */
+#define MAXMESSAGES (unsigned long) 1000000
+#define MAXLOGINTRIALS 3	/* maximum number of client login attempts */
+#define MAXWILDCARDS 10		/* maximum wildcards allowed in LIST/LSUB */
+
+
+/* These can't be changed without changing code */
+
+#define NUSERFLAGS 30		/* maximum number of user flags */
+#define MAXUSERFLAG 50		/* maximum length of a user flag */
+#define BASEYEAR 1970		/* the year time began on Unix DON'T CHANGE */
+				/* default for unqualified addresses */
+#define BADHOST ".MISSING-HOST-NAME."
+				/* default for syntax errors in addresses */
+#define ERRHOST ".SYNTAX-ERROR."
+
+
+/* Coddle certain compilers' 6-character symbol limitation */
+
+#ifdef __COMPILER_KCC__
+#include "shortsym.h"
+#endif
+
+
+/* Function status code */
+
+#define NIL 0			/* convenient name */
+#define T 1			/* opposite of NIL */
+#define LONGT (long) 1		/* long T to pacify some compilers */
+#define VOIDT (void *) ""	/* void T ditto */
+
+/* Global and Driver Parameters */
+
+	/* 0xx: driver and authenticator flags */
+#define ENABLE_DRIVER (long) 1
+#define DISABLE_DRIVER (long) 2
+#define ENABLE_AUTHENTICATOR (long) 3
+#define DISABLE_AUTHENTICATOR (long) 4
+#define ENABLE_DEBUG (long) 5
+#define DISABLE_DEBUG (long) 6
+#define HIDE_AUTHENTICATOR (long) 7
+#define UNHIDE_AUTHENTICATOR (long) 8
+	/* 1xx: c-client globals */
+#define GET_DRIVERS (long) 101
+#define SET_DRIVERS (long) 102
+#define GET_GETS (long) 103
+#define SET_GETS (long) 104
+#define GET_CACHE (long) 105
+#define SET_CACHE (long) 106
+#define GET_SMTPVERBOSE (long) 107
+#define SET_SMTPVERBOSE (long) 108
+#define GET_RFC822OUTPUT (long) 109
+#define SET_RFC822OUTPUT (long) 110
+#define GET_READPROGRESS (long) 111
+#define SET_READPROGRESS (long) 112
+#define GET_THREADERS (long) 113
+#define SET_THREADERS (long) 114
+#define GET_NAMESPACE (long) 115
+#define SET_NAMESPACE (long) 116
+#define GET_MAILPROXYCOPY (long) 117
+#define SET_MAILPROXYCOPY (long) 118
+#define GET_SERVICENAME (long) 119
+#define SET_SERVICENAME (long) 120
+#define GET_DRIVER (long) 121
+#define SET_DRIVER (long) 122
+#define GET_EXPUNGEATPING (long) 123
+#define SET_EXPUNGEATPING (long) 124
+#define GET_PARSEPHRASE (long) 125
+#define SET_PARSEPHRASE (long) 126
+#define GET_SSLDRIVER (long) 127
+#define SET_SSLDRIVER (long) 128
+#define GET_TRYSSLFIRST (long) 129
+#define SET_TRYSSLFIRST (long) 130
+#define GET_BLOCKNOTIFY (long) 131
+#define SET_BLOCKNOTIFY (long) 132
+#define GET_SORTRESULTS (long) 133
+#define SET_SORTRESULTS (long) 134
+#define GET_THREADRESULTS (long) 135
+#define SET_THREADRESULTS (long) 136
+#define GET_PARSELINE (long) 137
+#define SET_PARSELINE (long) 138
+#define GET_NEWSRCQUERY (long) 139
+#define SET_NEWSRCQUERY (long) 140
+#define GET_FREEENVELOPESPAREP (long) 141
+#define SET_FREEENVELOPESPAREP (long) 142
+#define GET_FREEELTSPAREP (long) 143
+#define SET_FREEELTSPAREP (long) 144
+#define GET_SSLSTART (long) 145
+#define SET_SSLSTART (long) 146
+#define GET_DEBUGSENSITIVE (long) 147
+#define SET_DEBUGSENSITIVE (long) 148
+#define GET_TCPDEBUG (long) 149
+#define SET_TCPDEBUG (long) 150
+#define GET_FREESTREAMSPAREP (long) 151
+#define SET_FREESTREAMSPAREP (long) 152
+#define GET_FREEBODYSPAREP (long) 153
+#define SET_FREEBODYSPAREP (long) 154
+#define GET_COPYUID (long) 155
+#define SET_COPYUID (long) 156
+#define GET_APPENDUID (long) 157
+#define SET_APPENDUID (long) 158
+#define GET_RFC822OUTPUTFULL (long) 159
+#define SET_RFC822OUTPUTFULL (long) 160
+#define GET_BLOCKENVINIT (long) 161
+#define SET_BLOCKENVINIT (long) 162
+
+	/* 2xx: environment */
+#define GET_USERNAME (long) 201
+#define SET_USERNAME (long) 202
+#define GET_HOMEDIR (long) 203
+#define SET_HOMEDIR (long) 204
+#define GET_LOCALHOST (long) 205
+#define SET_LOCALHOST (long) 206
+#define GET_SYSINBOX (long) 207
+#define SET_SYSINBOX (long) 208
+#define GET_USERPROMPT (long) 209
+#define SET_USERPROMPT (long) 210
+#define GET_DISABLEPLAINTEXT (long) 211
+#define SET_DISABLEPLAINTEXT (long) 212
+#define GET_CHROOTSERVER (long) 213
+#define SET_CHROOTSERVER (long) 214
+#define GET_ADVERTISETHEWORLD (long) 215
+#define SET_ADVERTISETHEWORLD (long) 216
+#define GET_DISABLEAUTOSHAREDNS (long) 217
+#define SET_DISABLEAUTOSHAREDNS (long) 218
+#define GET_MAILSUBDIR 219
+#define SET_MAILSUBDIR 220
+#define GET_DISABLE822TZTEXT 221
+#define SET_DISABLE822TZTEXT 222
+#define GET_LIMITEDADVERTISE (long) 223
+#define SET_LIMITEDADVERTISE (long) 224
+#define GET_LOGOUTHOOK (long) 225
+#define SET_LOGOUTHOOK (long) 226
+#define GET_LOGOUTDATA (long) 227
+#define SET_LOGOUTDATA (long) 228
+#define GET_EXTERNALAUTHID (long) 229
+#define SET_EXTERNALAUTHID (long) 230
+#define GET_SSLCAPATH (long) 231
+#define SET_SSLCAPATH (long) 232
+
+	/* 3xx: TCP/IP */
+#define GET_OPENTIMEOUT (long) 300
+#define SET_OPENTIMEOUT (long) 301
+#define GET_READTIMEOUT (long) 302
+#define SET_READTIMEOUT (long) 303
+#define GET_WRITETIMEOUT (long) 304
+#define SET_WRITETIMEOUT (long) 305
+#define GET_CLOSETIMEOUT (long) 306
+#define SET_CLOSETIMEOUT (long) 307
+#define GET_TIMEOUT (long) 308
+#define SET_TIMEOUT (long) 309
+#define GET_RSHTIMEOUT (long) 310
+#define SET_RSHTIMEOUT (long) 311
+#define GET_ALLOWREVERSEDNS (long) 312
+#define SET_ALLOWREVERSEDNS (long) 313
+#define GET_RSHCOMMAND (long) 314
+#define SET_RSHCOMMAND (long) 315
+#define GET_RSHPATH (long) 316
+#define SET_RSHPATH (long) 317
+#define GET_SSHTIMEOUT (long) 318
+#define SET_SSHTIMEOUT (long) 319
+#define GET_SSHCOMMAND (long) 320
+#define SET_SSHCOMMAND (long) 321
+#define GET_SSHPATH (long) 322
+#define SET_SSHPATH (long) 323
+#define GET_SSLCERTIFICATEQUERY (long) 324
+#define SET_SSLCERTIFICATEQUERY (long) 325
+#define GET_SSLFAILURE (long) 326
+#define SET_SSLFAILURE (long) 327
+#define GET_NEWSRCCANONHOST (long) 328
+#define SET_NEWSRCCANONHOST (long) 329
+#define GET_KINIT (long) 330
+#define SET_KINIT (long) 331
+#define GET_SSLCLIENTCERT (long) 332
+#define SET_SSLCLIENTCERT (long) 333
+#define GET_SSLCLIENTKEY (long) 334
+#define SET_SSLCLIENTKEY (long) 335
+#define GET_KERBEROS_CP_SVR_NAME (long) 336
+#define SET_KERBEROS_CP_SVR_NAME (long) 337
+
+	/* 4xx: network drivers */
+#define GET_MAXLOGINTRIALS (long) 400
+#define SET_MAXLOGINTRIALS (long) 401
+#define GET_LOOKAHEAD (long) 402
+#define SET_LOOKAHEAD (long) 403
+#define GET_IMAPPORT (long) 404
+#define SET_IMAPPORT (long) 405
+#define GET_PREFETCH (long) 406
+#define SET_PREFETCH (long) 407
+#define GET_CLOSEONERROR (long) 408
+#define SET_CLOSEONERROR (long) 409
+#define GET_POP3PORT (long) 410
+#define SET_POP3PORT (long) 411
+#define GET_UIDLOOKAHEAD (long) 412
+#define SET_UIDLOOKAHEAD (long) 413
+#define GET_NNTPPORT (long) 414
+#define SET_NNTPPORT (long) 415
+#define GET_IMAPENVELOPE (long) 416
+#define SET_IMAPENVELOPE (long) 417
+#define GET_IMAPREFERRAL (long) 418
+#define SET_IMAPREFERRAL (long) 419
+#define GET_SSLIMAPPORT (long) 420
+#define SET_SSLIMAPPORT (long) 421
+#define GET_SSLPOPPORT (long) 422
+#define SET_SSLPOPPORT (long) 423
+#define GET_SSLNNTPPORT (long) 424
+#define SET_SSLNNTPPORT (long) 425
+#define GET_SSLSMTPPORT (long) 426
+#define SET_SSLSMTPPORT (long) 427
+#define GET_SMTPPORT (long) 428
+#define SET_SMTPPORT (long) 429
+#define GET_IMAPEXTRAHEADERS (long) 430
+#define SET_IMAPEXTRAHEADERS (long) 431
+#define GET_ACL (long) 432
+#define SET_ACL (long) 433
+#define GET_LISTRIGHTS (long) 434
+#define SET_LISTRIGHTS (long) 435
+#define GET_MYRIGHTS (long) 436
+#define SET_MYRIGHTS (long) 437
+#define GET_QUOTA (long) 438
+#define SET_QUOTA (long) 439
+#define GET_QUOTAROOT (long) 440
+#define SET_QUOTAROOT (long) 441
+#define GET_IMAPTRYSSL (long) 442
+#define SET_IMAPTRYSSL (long) 443
+#define GET_FETCHLOOKAHEAD (long) 444
+#define SET_FETCHLOOKAHEAD (long) 445
+#define GET_NNTPRANGE (long) 446
+#define SET_NNTPRANGE (long) 447
+#define GET_NNTPHIDEPATH (long) 448
+#define SET_NNTPHIDEPATH (long) 449
+#define GET_SENDCOMMAND (long) 450
+#define SET_SENDCOMMAND (long) 451
+#define GET_IDLETIMEOUT (long) 452
+#define SET_IDLETIMEOUT (long) 453
+#define GET_FETCHLOOKAHEADLIMIT (long) 454
+#define SET_FETCHLOOKAHEADLIMIT (long) 455
+
+	/* 5xx: local file drivers */
+#define GET_MBXPROTECTION (long) 500
+#define SET_MBXPROTECTION (long) 501
+#define GET_DIRPROTECTION (long) 502
+#define SET_DIRPROTECTION (long) 503
+#define GET_LOCKPROTECTION (long) 504
+#define SET_LOCKPROTECTION (long) 505
+#define GET_FROMWIDGET (long) 506
+#define SET_FROMWIDGET (long) 507
+#define GET_NEWSACTIVE (long) 508
+#define SET_NEWSACTIVE (long) 509
+#define GET_NEWSSPOOL (long) 510
+#define SET_NEWSSPOOL (long) 511
+#define GET_NEWSRC (long) 512
+#define SET_NEWSRC (long) 513
+#define GET_EXTENSION (long) 514
+#define SET_EXTENSION (long) 515
+#define GET_DISABLEFCNTLLOCK (long) 516
+#define SET_DISABLEFCNTLLOCK (long) 517
+#define GET_LOCKEACCESERROR (long) 518
+#define SET_LOCKEACCESERROR (long) 519
+#define GET_LISTMAXLEVEL (long) 520
+#define SET_LISTMAXLEVEL (long) 521
+#define GET_ANONYMOUSHOME (long) 522
+#define SET_ANONYMOUSHOME (long) 523
+#define GET_FTPHOME (long) 524
+#define SET_FTPHOME (long) 525
+#define GET_PUBLICHOME (long) 526
+#define SET_PUBLICHOME (long) 527
+#define GET_SHAREDHOME (long) 528
+#define SET_SHAREDHOME (long) 529
+#define GET_MHPROFILE (long) 530
+#define SET_MHPROFILE (long) 531
+#define GET_MHPATH (long) 532
+#define SET_MHPATH (long) 533
+#define GET_ONETIMEEXPUNGEATPING (long) 534
+#define SET_ONETIMEEXPUNGEATPING (long) 535
+#define GET_USERHASNOLIFE (long) 536
+#define SET_USERHASNOLIFE (long) 537
+#define GET_FTPPROTECTION (long) 538
+#define SET_FTPPROTECTION (long) 539
+#define GET_PUBLICPROTECTION (long) 540
+#define SET_PUBLICPROTECTION (long) 541
+#define GET_SHAREDPROTECTION (long) 542
+#define SET_SHAREDPROTECTION (long) 543
+#define GET_LOCKTIMEOUT (long) 544
+#define SET_LOCKTIMEOUT (long) 545
+#define GET_NOTIMEZONES (long) 546
+#define SET_NOTIMEZONES (long) 547
+#define GET_HIDEDOTFILES (long) 548
+#define SET_HIDEDOTFILES (long) 549
+#define GET_FTPDIRPROTECTION (long) 550
+#define SET_FTPDIRPROTECTION (long) 551
+#define GET_PUBLICDIRPROTECTION (long) 552
+#define SET_PUBLICDIRPROTECTION (long) 553
+#define GET_SHAREDDIRPROTECTION (long) 554
+#define SET_SHAREDDIRPROTECTION (long) 555
+#define GET_TRUSTDNS (long) 556
+#define SET_TRUSTDNS (long) 557
+#define GET_SASLUSESPTRNAME (long) 558
+#define SET_SASLUSESPTRNAME (long) 559
+#define GET_NETFSSTATBUG (long) 560
+#define SET_NETFSSTATBUG (long) 561
+#define GET_SNARFMAILBOXNAME (long) 562
+#define SET_SNARFMAILBOXNAME (long) 563
+#define GET_SNARFINTERVAL (long) 564
+#define SET_SNARFINTERVAL (long) 565
+#define GET_SNARFPRESERVE (long) 566
+#define SET_SNARFPRESERVE (long) 567
+#define GET_INBOXPATH (long) 568
+#define SET_INBOXPATH (long) 569
+#define GET_DIRFMTTEST (long) 570
+#define SET_DIRFMTTEST (long) 571
+#define GET_SCANCONTENTS (long) 572
+#define SET_SCANCONTENTS (long) 573
+#define GET_MHALLOWINBOX (long) 574
+#define SET_MHALLOWINBOX (long) 575
+
+/* Driver flags */
+
+#define DR_DISABLE (long) 0x1	/* driver is disabled */
+#define DR_LOCAL (long) 0x2	/* local file driver */
+#define DR_MAIL (long) 0x4	/* supports mail */
+#define DR_NEWS (long) 0x8	/* supports news */
+#define DR_READONLY (long) 0x10	/* driver only allows readonly access */
+#define DR_NOFAST (long) 0x20	/* "fast" data is slow (whole msg fetch) */
+#define DR_NAMESPACE (long) 0x40/* driver has a special namespace */
+#define DR_LOWMEM (long) 0x80	/* low amounts of memory available */
+#define DR_LOCKING (long) 0x100	/* driver does locking */
+#define DR_CRLF (long) 0x200	/* driver internal form uses CRLF newlines */
+#define DR_NOSTICKY (long) 0x400/* driver does not support sticky UIDs */
+#define DR_RECYCLE (long) 0x800	/* driver does stream recycling */
+#define DR_XPOINT (long) 0x1000	/* needs to be checkpointed */
+				/* driver has no real internal date */
+#define DR_NOINTDATE (long) 0x2000
+				/* driver does not announce new mail */
+#define DR_NONEWMAIL (long) 0x4000
+				/* driver does not announce new mail when RO */
+#define DR_NONEWMAILRONLY (long) 0x8000
+				/* driver can be halfopen */
+#define DR_HALFOPEN (long) 0x10000
+#define DR_DIRFMT (long) 0x20000/* driver is a directory-format */
+#define DR_MODSEQ (long) 0x40000/* driver supports modseqs */
+
+
+/* Cache management function codes */
+
+#define CH_INIT (long) 10	/* initialize cache */
+#define CH_SIZE (long) 11	/* (re-)size the cache */
+#define CH_MAKEELT (long) 30	/* return elt, make if needed */
+#define CH_ELT (long) 31	/* return elt if exists */
+#define CH_SORTCACHE (long) 35	/* return sortcache entry, make if needed */
+#define CH_FREE (long) 40	/* free space used by elt */
+				/* free space used by sortcache */
+#define CH_FREESORTCACHE (long) 43
+#define CH_EXPUNGE (long) 45	/* delete elt pointer from list */
+
+
+/* Mailbox open options
+ * For compatibility with the past, OP_DEBUG must always be 1.
+ */
+
+#define OP_DEBUG (long) 0x1	/* debug protocol negotiations */
+#define OP_READONLY (long) 0x2	/* read-only open */
+#define OP_ANONYMOUS (long) 0x4	/* anonymous open of newsgroup */
+#define OP_SHORTCACHE (long) 0x8/* short (elt-only) caching */
+#define OP_SILENT (long) 0x10	/* don't pass up events (internal use) */
+#define OP_PROTOTYPE (long) 0x20/* return driver prototype */
+#define OP_HALFOPEN (long) 0x40	/* half-open (IMAP connect but no select) */
+#define OP_EXPUNGE (long) 0x80	/* silently expunge recycle stream */
+#define OP_SECURE (long) 0x100	/* don't do non-secure authentication */
+#define OP_TRYSSL (long) 0x200	/* try SSL first */
+				/* use multiple newsrc files */
+#define OP_MULNEWSRC (long) 0x400
+#define OP_NOKOD (long) 0x800	/* suppress kiss-of-death */
+#define OP_SNIFF (long) 0x1000	/* metadata only open */
+				/* reserved for application use */
+#define OP_RESERVED (unsigned long) 0xff000000
+
+
+/* Net open options */
+
+				/* no error messages */
+#define NET_SILENT ((unsigned long) 0x80000000)
+				/* no validation of SSL certificates */
+#define NET_NOVALIDATECERT ((unsigned long) 0x40000000)
+				/* no open timeout */
+#define NET_NOOPENTIMEOUT ((unsigned long) 0x20000000)
+				/* TLS not SSL */
+#define NET_TLSCLIENT ((unsigned long) 0x10000000)
+				/* try SSL mode */
+#define NET_TRYSSL ((unsigned long) 0x8000000)
+
+/* Close options */
+
+#define CL_EXPUNGE (long) 1	/* expunge silently */
+
+
+/* Fetch options */
+
+#define FT_UID (long) 0x1	/* argument is a UID */
+#define FT_PEEK (long) 0x2	/* peek at data */
+#define FT_NOT (long) 0x4	/* NOT flag for header lines fetch */
+#define FT_INTERNAL (long) 0x8	/* text can be internal strings */
+				/* IMAP prefetch text when fetching header */
+#define FT_PREFETCHTEXT (long) 0x20
+#define FT_NOHDRS (long) 0x40	/* suppress fetching extra headers (note that
+				   this breaks news handling) */
+#define FT_NEEDENV (long) 0x80	/* (internal use) include envelope */
+#define FT_NEEDBODY (long) 0x100/* (internal use) include body structure */
+				/* no fetch lookahead */
+#define FT_NOLOOKAHEAD (long) 0x200
+				/* (internal use) lookahead in hdr searching */
+#define FT_SEARCHLOOKAHEAD (long) 0x400
+				/* stringstruct return hack */
+#define FT_RETURNSTRINGSTRUCT (long) 0x800
+
+
+/* Flagging options */
+
+#define ST_UID (long) 0x1	/* argument is a UID sequence */
+#define ST_SILENT (long) 0x2	/* don't return results */
+#define ST_SET (long) 0x4	/* set vs. clear */
+
+
+/* Expunge options */
+
+#define EX_UID (long) 0x1	/* argument is a UID sequence */
+
+
+/* Copy options */
+
+#define CP_UID (long) 0x1	/* argument is a UID sequence */
+#define CP_MOVE (long) 0x2	/* delete from source after copying */
+				/* set debug in any created stream */
+#define CP_DEBUG (long) 0x20000000
+
+/* Search/sort/thread options */
+
+#define SE_UID (long) 0x1	/* return UID */
+#define SE_FREE (long) 0x2	/* free search program after finished */
+#define SE_NOPREFETCH (long) 0x4/* no search prefetching */
+#define SO_FREE (long) 0x8	/* free sort program after finished */
+#define SE_NOSERVER (long) 0x10	/* don't do server-based search/sort/thread */
+#define SE_RETAIN (long) 0x20	/* retain previous search results */
+#define SO_OVERVIEW (long) 0x40	/* use overviews in searching (NNTP only) */
+#define SE_NEEDBODY (long) 0x80	/* include body structure in prefetch */
+#define SE_NOHDRS (long) 0x100	/* suppress prefetching extra headers (note
+				   that this breaks news handling) */
+#define SE_NOLOCAL (long) 0x200	/* no local retry (IMAP only) */
+
+#define SO_NOSERVER SE_NOSERVER	/* compatibility name */
+#define SE_SILLYOK (long) 0x400	/* allow silly searches */
+
+
+/* Status options */
+
+#define SA_MESSAGES (long) 0x1	/* number of messages */
+#define SA_RECENT (long) 0x2	/* number of recent messages */
+#define SA_UNSEEN (long) 0x4	/* number of unseen messages */
+#define SA_UIDNEXT (long) 0x8	/* next UID to be assigned */
+				/* UID validity value */
+#define SA_UIDVALIDITY (long) 0x10
+				/* set OP_DEBUG on any created stream */
+#define SA_DEBUG (long) 0x10000000
+				/* use multiple newsrcs */
+#define SA_MULNEWSRC (long) 0x20000000
+
+/* Mailgets flags */
+
+#define MG_UID (long) 0x1	/* message number is a UID */
+#define MG_COPY (long) 0x2	/* must return copy of argument */
+
+/* SASL authenticator categories */
+
+#define AU_SECURE (long) 0x1	/* /secure allowed */
+#define AU_AUTHUSER (long) 0x2	/* /authuser=xxx allowed */
+				/* authenticator hidden */
+#define AU_HIDE (long) 0x10000000
+				/* authenticator disabled */
+#define AU_DISABLE (long) 0x20000000
+
+
+/* Garbage collection flags */
+
+#define GC_ELT (long) 0x1	/* message cache elements */
+#define GC_ENV (long) 0x2	/* envelopes and bodies */
+#define GC_TEXTS (long) 0x4	/* cached texts */
+
+
+/* mm_log()/mm_notify() condition codes */
+
+#define WARN (long) 1		/* mm_log warning type */
+#define ERROR (long) 2		/* mm_log error type */
+#define PARSE (long) 3		/* mm_log parse error type */
+#define BYE (long) 4		/* mm_notify stream dying */
+#define TCPDEBUG (long) 5	/* mm_log TCP debug babble */
+
+
+/* Bits from mail_parse_flags().  Don't change these, since the header format
+ * used by tenex, mtx, and mbx corresponds to these bits.
+ */
+
+#define fSEEN 0x1
+#define fDELETED 0x2
+#define fFLAGGED 0x4
+#define fANSWERED 0x8
+#define fOLD 0x10
+#define fDRAFT 0x20
+
+#define fEXPUNGED 0x8000	/* internal flag */
+
+/* Bits for mm_list() and mm_lsub() */
+
+/* Note that (LATT_NOINFERIORS LATT_HASCHILDREN LATT_HASNOCHILDREN) and
+ * (LATT_NOSELECT LATT_MARKED LATT_UNMARKED) each have eight possible states,
+ * but only four of these are valid.  The other four are silly states which
+ * while invalid can unfortunately be expressed in the IMAP protocol.
+ */
+
+				/* terminal node in hierarchy */
+#define LATT_NOINFERIORS (long) 0x1
+				/* name can not be selected */
+#define LATT_NOSELECT (long) 0x2
+				/* changed since last accessed */
+#define LATT_MARKED (long) 0x4
+				/* accessed since last changed */
+#define LATT_UNMARKED (long) 0x8
+				/* name has referral to remote mailbox */
+#define LATT_REFERRAL (long) 0x10
+				/* has selectable inferiors */
+#define LATT_HASCHILDREN (long) 0x20
+				/* has no selectable inferiors */
+#define LATT_HASNOCHILDREN (long) 0x40
+
+
+/* Sort functions */
+
+#define SORTDATE 0		/* date */
+#define SORTARRIVAL 1		/* arrival date */
+#define SORTFROM 2		/* from */
+#define SORTSUBJECT 3		/* subject */
+#define SORTTO 4		/* to */
+#define SORTCC 5		/* cc */
+#define SORTSIZE 6		/* size */
+
+
+/* imapreferral_t codes */
+
+#define REFAUTHFAILED (long) 0	/* authentication referral -- not logged in */
+#define REFAUTH (long) 1	/* authentication referral -- logged in */
+#define REFSELECT (long) 2	/* select referral */
+#define REFCREATE (long) 3
+#define REFDELETE (long) 4
+#define REFRENAME (long) 5
+#define REFSUBSCRIBE (long) 6
+#define REFUNSUBSCRIBE (long) 7
+#define REFSTATUS (long) 8
+#define REFCOPY (long) 9
+#define REFAPPEND (long) 10
+
+
+/* sendcommand_t codes */
+
+				/* expunge response deferred */
+#define SC_EXPUNGEDEFERRED (long) 1
+
+/* Block notification codes */
+
+#define BLOCK_NONE 0		/* not blocked */
+#define BLOCK_SENSITIVE 1	/* sensitive code, disallow alarms */
+#define BLOCK_NONSENSITIVE 2	/* non-sensitive code, allow alarms */
+#define BLOCK_DNSLOOKUP 10	/* blocked on DNS lookup */
+#define BLOCK_TCPOPEN 11	/* blocked on TCP open */
+#define BLOCK_TCPREAD 12	/* blocked on TCP read */
+#define BLOCK_TCPWRITE 13	/* blocked on TCP write */
+#define BLOCK_TCPCLOSE 14	/* blocked on TCP close */
+#define BLOCK_FILELOCK 20	/* blocked on file locking */
+
+
+/* In-memory sized-text */
+
+#define SIZEDTEXT struct mail_sizedtext
+
+SIZEDTEXT {
+  unsigned char *data;		/* text */
+  unsigned long size;		/* size of text in octets */
+};
+
+
+/* String list */
+
+#define STRINGLIST struct string_list
+
+STRINGLIST {
+  SIZEDTEXT text;		/* string text */
+  STRINGLIST *next;
+};
+
+
+/* Parse results from mail_valid_net_parse */
+
+#define NETMAXHOST 256
+#define NETMAXUSER 65
+#define NETMAXMBX (MAILTMPLEN/4)
+#define NETMAXSRV 21
+typedef struct net_mailbox {
+  char host[NETMAXHOST];	/* host name (may be canonicalized) */
+  char orighost[NETMAXHOST];	/* host name before canonicalization */
+  char user[NETMAXUSER];	/* user name */
+  char authuser[NETMAXUSER];	/* authentication user name */
+  char mailbox[NETMAXMBX];	/* mailbox name */
+  char service[NETMAXSRV];	/* service name */
+  unsigned long port;		/* TCP port number */
+  unsigned int anoflag : 1;	/* anonymous */
+  unsigned int dbgflag : 1;	/* debug flag */
+  unsigned int secflag : 1;	/* secure flag */
+  unsigned int sslflag : 1;	/* SSL driver flag */
+  unsigned int trysslflag : 1;	/* try SSL driver first flag */
+  unsigned int novalidate : 1;	/* don't validate certificates */
+  unsigned int tlsflag : 1;	/* TLS flag */
+  unsigned int notlsflag : 1;	/* do not do TLS flag */
+  unsigned int readonlyflag : 1;/* want readonly */
+  unsigned int norsh : 1;	/* don't use rsh/ssh */
+  unsigned int loser : 1;	/* server is a loser */
+  unsigned int tlssslv23 : 1;	/* force SSLv23 client method over TLS */
+} NETMBX;
+
+/* Item in an address list */
+
+#define ADDRESS struct mail_address
+
+ADDRESS {
+  char *personal;		/* personal name phrase */
+  char *adl;			/* at-domain-list source route */
+  char *mailbox;		/* mailbox name */
+  char *host;			/* domain name of mailbox's host */
+  char *error;			/* error in address from SMTP module */
+  struct {
+    char *type;			/* address type (default "rfc822") */
+    char *addr;			/* address as xtext */
+  } orcpt;
+  ADDRESS *next;		/* pointer to next address in list */
+};
+
+
+/* Message envelope */
+
+typedef struct mail_envelope {
+  unsigned int ngpathexists : 1;	/* newsgroups may be bogus */
+  unsigned int incomplete : 1;	/* envelope may be incomplete */
+  unsigned int imapenvonly : 1;	/* envelope only has IMAP envelope */
+  char *remail;			/* remail header if any */
+  ADDRESS *return_path;		/* error return address */
+  unsigned char *date;		/* message composition date string */
+  ADDRESS *from;		/* originator address list */
+  ADDRESS *sender;		/* sender address list */
+  ADDRESS *reply_to;		/* reply address list */
+  char *subject;		/* message subject string */
+  ADDRESS *to;			/* primary recipient list */
+  ADDRESS *cc;			/* secondary recipient list */
+  ADDRESS *bcc;			/* blind secondary recipient list */
+  char *in_reply_to;		/* replied message ID */
+  char *message_id;		/* message ID */
+  char *newsgroups;		/* USENET newsgroups */
+  char *followup_to;		/* USENET reply newsgroups */
+  char *references;		/* USENET references */
+  void *sparep;			/* spare pointer reserved for main program */
+} ENVELOPE;
+
+/* Primary body types */
+/* If you change any of these you must also change body_types in rfc822.c */
+
+#define TYPETEXT 0		/* unformatted text */
+#define TYPEMULTIPART 1		/* multiple part */
+#define TYPEMESSAGE 2		/* encapsulated message */
+#define TYPEAPPLICATION 3	/* application data */
+#define TYPEAUDIO 4		/* audio */
+#define TYPEIMAGE 5		/* static image */
+#define TYPEVIDEO 6		/* video */
+#define TYPEMODEL 7		/* model */
+#define TYPEOTHER 8		/* unknown */
+#define TYPEMAX 15		/* maximum type code */
+
+
+/* Body encodings */
+/* If you change any of these you must also change body_encodings in rfc822.c
+ */
+
+#define ENC7BIT 0		/* 7 bit SMTP semantic data */
+#define ENC8BIT 1		/* 8 bit SMTP semantic data */
+#define ENCBINARY 2		/* 8 bit binary data */
+#define ENCBASE64 3		/* base-64 encoded data */
+#define ENCQUOTEDPRINTABLE 4	/* human-readable 8-as-7 bit data */
+#define ENCOTHER 5		/* unknown */
+#define ENCMAX 10		/* maximum encoding code */
+
+
+/* Body contents */
+
+#define BODY struct mail_bodystruct
+#define MESSAGE struct mail_body_message
+#define PARAMETER struct mail_body_parameter
+#define PART struct mail_body_part
+#define PARTTEXT struct mail_body_text
+
+/* Message body text */
+
+PARTTEXT {
+  unsigned long offset;		/* offset from body origin */
+  SIZEDTEXT text;		/* text */
+};
+
+
+/* Message body structure */
+
+BODY {
+  unsigned short type;		/* body primary type */
+  unsigned short encoding;	/* body transfer encoding */
+  char *subtype;		/* subtype string */
+  PARAMETER *parameter;		/* parameter list */
+  char *id;			/* body identifier */
+  char *description;		/* body description */
+  struct {			/* body disposition */
+    char *type;			/* disposition type */
+    PARAMETER *parameter;	/* disposition parameters */
+  } disposition;
+  STRINGLIST *language;		/* body language */
+  char *location;		/* body content URI */
+  PARTTEXT mime;		/* MIME header */
+  PARTTEXT contents;		/* body part contents */
+  union {			/* different ways of accessing contents */
+    PART *part;			/* body part list */
+    MESSAGE *msg;		/* body encapsulated message */
+  } nested;
+  struct {
+    unsigned long lines;	/* size of text in lines */
+    unsigned long bytes;	/* size of text in octets */
+  } size;
+  char *md5;			/* MD5 checksum */
+  void *sparep;			/* spare pointer reserved for main program */
+};
+
+
+/* Parameter list */
+
+PARAMETER {
+  char *attribute;		/* parameter attribute name */
+  char *value;			/* parameter value */
+  PARAMETER *next;		/* next parameter in list */
+};
+
+
+/* Multipart content list */
+
+PART {
+  BODY body;			/* body information for this part */
+  PART *next;			/* next body part */
+};
+
+
+/* RFC-822 Message */
+
+MESSAGE {
+  ENVELOPE *env;		/* message envelope */
+  BODY *body;			/* message body */
+  PARTTEXT full;		/* full message */
+  STRINGLIST *lines;		/* lines used to filter header */
+  PARTTEXT header;		/* header text */
+  PARTTEXT text;		/* body text */
+};
+
+/* Entry in the message cache array */
+
+typedef struct message_cache {
+  unsigned long msgno;		/* message number */
+  unsigned int lockcount : 8;	/* non-zero if multiple references */
+  unsigned long rfc822_size;	/* # of bytes of message as raw RFC822 */
+  struct {			/* c-client internal use only */
+    unsigned long uid;		/* message unique ID */
+    unsigned long mod;		/* modseq */
+    PARTTEXT special;		/* special text pointers */
+    MESSAGE msg;		/* internal message pointers */
+    union {			/* driver internal use */
+      unsigned long data;
+      void *ptr;
+    } spare;
+    unsigned int sequence : 1;	/* saved sequence bit */
+    unsigned int dirty : 1;	/* driver internal use */
+    unsigned int filter : 1;	/* driver internal use */
+    unsigned int ghost : 1;	/* driver internal use */
+  } private;
+			/* internal date */
+  unsigned int day : 5;		/* day of month (1-31) */
+  unsigned int month : 4;	/* month of year (1-12) */
+  unsigned int year : 7;	/* year since BASEYEAR (expires in 127 yrs) */
+  unsigned int hours: 5;	/* hours (0-23) */
+  unsigned int minutes: 6;	/* minutes (0-59) */
+  unsigned int seconds: 6;	/* seconds (0-59) */
+  unsigned int zoccident : 1;	/* non-zero if west of UTC */
+  unsigned int zhours : 4;	/* hours from UTC (0-12) */
+  unsigned int zminutes: 6;	/* minutes (0-59) */
+			/* system flags */
+  unsigned int seen : 1;	/* system Seen flag */
+  unsigned int deleted : 1;	/* system Deleted flag */
+  unsigned int flagged : 1; 	/* system Flagged flag */
+  unsigned int answered : 1;	/* system Answered flag */
+  unsigned int draft : 1;	/* system Draft flag */
+  unsigned int recent : 1;	/* system Recent flag */
+			/* message status */
+  unsigned int valid : 1;	/* elt has valid flags */
+  unsigned int searched : 1;	/* message was searched */
+  unsigned int sequence : 1;	/* message is in sequence */
+			/* reserved for use by main program */
+  unsigned int spare : 1;	/* first spare bit */
+  unsigned int spare2 : 1;	/* second spare bit */
+  unsigned int spare3 : 1;	/* third spare bit */
+  unsigned int spare4 : 1;	/* fourth spare bit */
+  unsigned int spare5 : 1;	/* fifth spare bit */
+  unsigned int spare6 : 1;	/* sixth spare bit */
+  unsigned int spare7 : 1;	/* seventh spare bit */
+  unsigned int spare8 : 1;	/* eighth spare bit */
+  void *sparep;			/* spare pointer */
+  unsigned long user_flags;	/* user-assignable flags */
+} MESSAGECACHE;
+
+/* String structure */
+
+#define STRINGDRIVER struct string_driver
+
+typedef struct mailstring {
+  void *data;			/* driver-dependent data */
+  unsigned long data1;		/* driver-dependent data */
+  unsigned long size;		/* total length of string */
+  char *chunk;			/* base address of chunk */
+  unsigned long chunksize;	/* size of chunk */
+  unsigned long offset;		/* offset of this chunk in base */
+  char *curpos;			/* current position in chunk */
+  unsigned long cursize;	/* number of bytes remaining in chunk */
+  STRINGDRIVER *dtb;		/* driver that handles this type of string */
+} STRING;
+
+
+/* Dispatch table for string driver */
+
+STRINGDRIVER {
+				/* initialize string driver */
+  void (*init) (STRING *s,void *data,unsigned long size);
+				/* get next character in string */
+  char (*next) (STRING *s);
+				/* set position in string */
+  void (*setpos) (STRING *s,unsigned long i);
+};
+
+
+/* Stringstruct access routines */
+
+#define INIT(s,d,data,size) ((*((s)->dtb = &d)->init) (s,data,size))
+#define SIZE(s) ((s)->size - GETPOS (s))
+#define CHR(s) (*(s)->curpos)
+#define SNX(s) (--(s)->cursize ? *(s)->curpos++ : (*(s)->dtb->next) (s))
+#define GETPOS(s) ((s)->offset + ((s)->curpos - (s)->chunk))
+#define SETPOS(s,i) (*(s)->dtb->setpos) (s,i)
+
+/* Search program */
+
+#define SEARCHPGM struct search_program
+#define SEARCHHEADER struct search_header
+#define SEARCHSET struct search_set
+#define SEARCHOR struct search_or
+#define SEARCHPGMLIST struct search_pgm_list
+
+
+SEARCHHEADER {			/* header search */
+  SIZEDTEXT line;		/* header line */
+  SIZEDTEXT text;		/* text in header */
+  SEARCHHEADER *next;		/* next in list */
+};
+
+
+SEARCHSET {			/* message set */
+  unsigned long first;		/* sequence number */
+  unsigned long last;		/* last value, if a range */
+  SEARCHSET *next;		/* next in list */
+};
+
+
+SEARCHOR {
+  SEARCHPGM *first;		/* first program */
+  SEARCHPGM *second;		/* second program */
+  SEARCHOR *next;		/* next in list */
+};
+
+
+SEARCHPGMLIST {
+  SEARCHPGM *pgm;		/* search program */
+  SEARCHPGMLIST *next;		/* next in list */
+};
+
+SEARCHPGM {			/* search program */
+  SEARCHSET *msgno;		/* message numbers */
+  SEARCHSET *uid;		/* unique identifiers */
+  SEARCHOR *or;			/* or'ed in programs */
+  SEARCHPGMLIST *not;		/* and'ed not program */
+  SEARCHHEADER *header;		/* list of headers */
+  STRINGLIST *bcc;		/* bcc recipients */
+  STRINGLIST *body;		/* text in message body */
+  STRINGLIST *cc;		/* cc recipients */
+  STRINGLIST *from;		/* originator */
+  STRINGLIST *keyword;		/* keywords */
+  STRINGLIST *unkeyword;	/* unkeywords */
+  STRINGLIST *subject;		/* text in subject */
+  STRINGLIST *text;		/* text in headers and body */
+  STRINGLIST *to;		/* to recipients */
+  unsigned long larger;		/* larger than this size */
+  unsigned long smaller;	/* smaller than this size */
+  unsigned long older;		/* older than this interval */
+  unsigned long younger;	/* younger than this interval */
+  unsigned short sentbefore;	/* sent before this date */
+  unsigned short senton;	/* sent on this date */
+  unsigned short sentsince;	/* sent since this date */
+  unsigned short before;	/* before this date */
+  unsigned short on;		/* on this date */
+  unsigned short since;		/* since this date */
+  unsigned int answered : 1;	/* answered messages */
+  unsigned int unanswered : 1;	/* unanswered messages */
+  unsigned int deleted : 1;	/* deleted messages */
+  unsigned int undeleted : 1;	/* undeleted messages */
+  unsigned int draft : 1;	/* message draft */
+  unsigned int undraft : 1;	/* message undraft */
+  unsigned int flagged : 1;	/* flagged messages */
+  unsigned int unflagged : 1;	/* unflagged messages */
+  unsigned int recent : 1;	/* recent messages */
+  unsigned int old : 1;		/* old messages */
+  unsigned int seen : 1;	/* seen messages */
+  unsigned int unseen : 1;	/* unseen messages */
+  /* These must be simulated in IMAP */
+  STRINGLIST *return_path;	/* error return address */
+  STRINGLIST *sender;		/* sender address list */
+  STRINGLIST *reply_to;		/* reply address list */
+  STRINGLIST *in_reply_to;	/* replied message ID */
+  STRINGLIST *message_id;	/* message ID */
+  STRINGLIST *newsgroups;	/* USENET newsgroups */
+  STRINGLIST *followup_to;	/* USENET reply newsgroups */
+  STRINGLIST *references;	/* USENET references */
+};
+
+
+/* Mailbox status */
+
+typedef struct mbx_status {
+  long flags;			/* validity flags */
+  unsigned long messages;	/* number of messages */
+  unsigned long recent;		/* number of recent messages */
+  unsigned long unseen;		/* number of unseen messages */
+  unsigned long uidnext;	/* next UID to be assigned */
+  unsigned long uidvalidity;	/* UID validity value */
+} MAILSTATUS;
+
+/* Sort program */
+
+typedef void (*postsort_t) (void *sc);
+
+#define SORTPGM struct sort_program
+
+SORTPGM {
+  unsigned int reverse : 1;	/* sort function is to be reversed */
+  unsigned int abort : 1;	/* abort sorting */
+  short function;		/* sort function */
+  unsigned long nmsgs;		/* number of messages being sorted */
+  struct {
+    unsigned long cached;	/* number of messages cached so far */
+    unsigned long sorted;	/* number of messages sorted so far */
+    unsigned long postsorted;	/* number of postsorted messages so far */
+  } progress;
+  postsort_t postsort;		/* post sorter */
+  SORTPGM *next;		/* next function */
+};
+
+
+/* Sort cache */
+
+#define SORTCACHE struct sort_cache
+
+SORTCACHE {
+  unsigned int sorted : 1;	/* message has been sorted */
+  unsigned int postsorted : 1;	/* message has been postsorted */
+  unsigned int refwd : 1;	/* subject is a re or fwd */
+  unsigned int dirty : 1;	/* has data not written to backup */
+  SORTPGM *pgm;			/* sort program */
+  unsigned long num;		/* message number (sequence or UID) */
+  unsigned long date;		/* sent date */
+  unsigned long arrival;	/* arrival date */
+  unsigned long size;		/* message size */
+  char *from;			/* from string */
+  char *to;			/* to string */
+  char *cc;			/* cc string */
+  char *subject;		/* extracted subject string */
+  char *message_id;		/* message-id string */
+  char *unique;			/* unique string, normally message-id */
+  STRINGLIST *references;	/* references string */
+};
+
+/* ACL list */
+
+#define ACLLIST struct acl_list
+
+ACLLIST {
+  char *identifier;		/* authentication identifier */
+  char *rights;			/* access rights */
+  ACLLIST *next;
+};
+
+/* Quota resource list */
+
+#define QUOTALIST struct quota_list
+
+QUOTALIST {
+  char *name;			/* resource name */
+  unsigned long usage;		/* resource usage */
+  unsigned long limit;		/* resource limit */
+  QUOTALIST *next;		/* next resource */
+};
+
+/* Mail Access I/O stream */
+
+
+/* Structure for mail driver dispatch */
+
+#define DRIVER struct driver	
+
+
+/* Mail I/O stream */
+	
+typedef struct mail_stream {
+  DRIVER *dtb;			/* dispatch table for this driver */
+  void *local;			/* pointer to driver local data */
+  char *mailbox;		/* mailbox name (canonicalized) */
+  char *original_mailbox;	/* mailbox name (non-canonicalized) */
+  unsigned short use;		/* stream use count */
+  unsigned short sequence;	/* stream sequence */
+  unsigned int inbox : 1;	/* stream open on an INBOX */
+  unsigned int lock : 1;	/* stream lock flag */
+  unsigned int debug : 1;	/* stream debug flag */
+  unsigned int silent : 1;	/* don't pass events to main program */
+  unsigned int rdonly : 1;	/* stream read-only flag */
+  unsigned int anonymous : 1;	/* stream anonymous access flag */
+  unsigned int scache : 1;	/* stream short cache flag */
+  unsigned int halfopen : 1;	/* stream half-open flag */
+  unsigned int secure : 1;	/* stream secure flag */
+  unsigned int tryssl : 1;	/* stream tryssl flag */
+  unsigned int mulnewsrc : 1;	/* stream use multiple newsrc files */
+  unsigned int perm_seen : 1;	/* permanent Seen flag */
+  unsigned int perm_deleted : 1;/* permanent Deleted flag */
+  unsigned int perm_flagged : 1;/* permanent Flagged flag */
+  unsigned int perm_answered :1;/* permanent Answered flag */
+  unsigned int perm_draft : 1;	/* permanent Draft flag */
+  unsigned int kwd_create : 1;	/* can create new keywords */
+  unsigned int uid_nosticky : 1;/* UIDs are not preserved */
+  unsigned int unhealthy : 1;	/* unhealthy protocol negotiations */
+  unsigned int nokod : 1;	/* suppress kiss-of-death */
+  unsigned int sniff : 1;	/* metadata only */
+  unsigned long perm_user_flags;/* mask of permanent user flags */
+  unsigned long gensym;		/* generated tag */
+  unsigned long nmsgs;		/* # of associated msgs */
+  unsigned long recent;		/* # of recent msgs */
+  unsigned long uid_validity;	/* UID validity sequence */
+  unsigned long uid_last;	/* last assigned UID */
+  char *user_flags[NUSERFLAGS];	/* pointers to user flags in bit order */
+  unsigned long cachesize;	/* size of message cache */
+  MESSAGECACHE **cache;		/* message cache array */
+  SORTCACHE **sc;		/* sort cache array */
+  unsigned long msgno;		/* message number of `current' message */
+  ENVELOPE *env;		/* scratch buffer for envelope */
+  BODY *body;			/* scratch buffer for body */
+  SIZEDTEXT text;		/* scratch buffer for text */
+  struct {
+    char *name;			/* mailbox name to snarf from */
+    unsigned long time;		/* last snarf time */
+    long options;		/* snarf open options */
+  } snarf;
+  struct {			/* internal use only */
+    struct {			/* search temporaries */
+      STRINGLIST *string;	/* string(s) to search */
+      long result;		/* search result */
+      char *text;		/* cache of fetched text */
+    } search;
+    STRING string;		/* stringstruct return hack */
+  } private;
+			/* reserved for use by main program */
+  void *sparep;			/* spare pointer */
+  unsigned int spare : 1;	/* first spare bit */
+  unsigned int spare2 : 1;	/* second spare bit */
+  unsigned int spare3 : 1;	/* third spare bit */
+  unsigned int spare4 : 1;	/* fourth spare bit */
+  unsigned int spare5 : 1;	/* fifth spare bit */
+  unsigned int spare6 : 1;	/* sixth spare bit */
+  unsigned int spare7 : 1;	/* seventh spare bit */
+  unsigned int spare8 : 1;	/* eighth spare bit */
+} MAILSTREAM;
+
+/* Mail I/O stream handle */
+
+typedef struct mail_stream_handle {
+  MAILSTREAM *stream;		/* pointer to mail stream */
+  unsigned short sequence;	/* sequence of what we expect stream to be */
+} MAILHANDLE;
+
+
+/* Message overview */
+
+typedef struct mail_overview {
+  char *subject;		/* message subject string */
+  ADDRESS *from;		/* originator address list */
+  char *date;			/* message composition date string */
+  char *message_id;		/* message ID */
+  char *references;		/* USENET references */
+  struct {			/* may be 0 or NUL if unknown/undefined */
+    unsigned long octets;	/* message octets (probably LF-newline form) */
+    unsigned long lines;	/* message lines */
+    char *xref;			/* cross references */
+  } optional;
+} OVERVIEW;
+
+/* Network access I/O stream */
+
+
+/* Structure for network driver dispatch */
+
+#define NETDRIVER struct net_driver
+
+
+/* Network transport I/O stream */
+
+typedef struct net_stream {
+  void *stream;			/* driver's I/O stream */
+  NETDRIVER *dtb;		/* network driver */
+} NETSTREAM;
+
+
+/* Network transport driver dispatch */
+
+NETDRIVER {
+  void *(*open) (char *host,char *service,unsigned long port);
+  void *(*aopen) (NETMBX *mb,char *service,char *usrbuf);
+  char *(*getline) (void *stream);
+  long (*getbuffer) (void *stream,unsigned long size,char *buffer);
+  long (*soutr) (void *stream,char *string);
+  long (*sout) (void *stream,char *string,unsigned long size);
+  void (*close) (void *stream);
+  char *(*host) (void *stream);
+  char *(*remotehost) (void *stream);
+  unsigned long (*port) (void *stream);
+  char *(*localhost) (void *stream);
+};
+
+
+/* Mailgets data identifier */
+
+typedef struct getsdata {
+  MAILSTREAM *stream;
+  unsigned long msgno;
+  char *what;
+  STRINGLIST *stl;
+  unsigned long first;
+  unsigned long last;
+  long flags;
+} GETS_DATA;
+
+
+#define INIT_GETS(md,s,m,w,f,l) \
+  md.stream = s, md.msgno = m, md.what = w, md.first = f, md.last = l, \
+  md.stl = NIL, md.flags = NIL;
+
+/* Mail delivery I/O stream */
+
+typedef struct send_stream {
+  NETSTREAM *netstream;		/* network I/O stream */
+  char *host;			/* SMTP service host */
+  char *reply;			/* last reply string */
+  long replycode;		/* last reply code */
+  unsigned int debug : 1;	/* stream debug flag */
+  unsigned int sensitive : 1;	/* sensitive data in progress */
+  unsigned int loser : 1;	/* server is a loser */
+  unsigned int saslcancel : 1;	/* SASL cancelled by protocol */
+  union {			/* protocol specific */
+    struct {			/* SMTP specific */
+      unsigned int ok : 1;	/* supports ESMTP */
+      struct {			/* service extensions */
+	unsigned int send : 1;	/* supports SEND */
+	unsigned int soml : 1;	/* supports SOML */
+	unsigned int saml : 1;	/* supports SAML */
+	unsigned int expn : 1;	/* supports EXPN */
+	unsigned int help : 1;	/* supports HELP */
+	unsigned int turn : 1;	/* supports TURN */
+	unsigned int etrn : 1;	/* supports ETRN */
+	unsigned int starttls:1;/* supports STARTTLS */
+	unsigned int relay : 1;	/* supports relaying */
+	unsigned int pipe : 1;	/* supports pipelining */
+	unsigned int ensc : 1;	/* supports enhanced status codes */
+	unsigned int bmime : 1;	/* supports BINARYMIME */
+	unsigned int chunk : 1;	/* supports CHUNKING */
+      } service;
+      struct {			/* 8-bit MIME transport */
+	unsigned int ok : 1;	/* supports 8-bit MIME */
+	unsigned int want : 1;	/* want 8-bit MIME */
+      } eightbit;
+      struct {			/* delivery status notification */
+	unsigned int ok : 1;	/* supports DSN */
+	unsigned int want : 1;	/* want DSN */
+	struct {		/* notification options */
+				/* notify on failure */
+	  unsigned int failure : 1;
+				/* notify on delay */
+	  unsigned int delay : 1;
+				/* notify on success */
+	  unsigned int success : 1;
+	} notify;
+	unsigned int full : 1;	/* return full headers */
+	char *envid;		/* envelope identifier as xtext */
+      } dsn;
+      struct {			/* size declaration */
+	unsigned int ok : 1;	/* supports SIZE */
+	unsigned long limit;	/* maximum size supported */
+      } size;
+      struct {			/* deliverby declaration */
+	unsigned int ok : 1;	/* supports DELIVERBY */
+	unsigned long minby;	/* minimum by-time */
+      } deliverby;
+      struct {			/* authenticated turn */
+	unsigned int ok : 1;	/* supports ATRN */
+	char *domains;		/* domains */
+      } atrn;
+				/* supported SASL authenticators */
+      unsigned int auth : MAXAUTHENTICATORS;
+    } esmtp;
+    struct {			/* NNTP specific */
+      unsigned int post : 1;	/* supports POST */
+      struct {			/* NNTP extensions */
+	unsigned int ok : 1;	/* supports extensions */
+				/* supports LISTGROUP */
+	unsigned int listgroup : 1;
+	unsigned int over : 1;	/* supports OVER */
+	unsigned int hdr : 1;	/* supports HDR */
+	unsigned int pat : 1;	/* supports PAT */
+				/* supports STARTTLS */
+	unsigned int starttls : 1;
+				/* server has MULTIDOMAIN */
+	unsigned int multidomain : 1;
+				/* supports AUTHINFO USER */
+	unsigned int authuser : 1;
+				/* supported authenticators */
+	unsigned int sasl : MAXAUTHENTICATORS;
+      } ext;
+    } nntp;
+  } protocol;
+} SENDSTREAM;
+
+/* Jacket into external interfaces */
+
+typedef long (*readfn_t) (void *stream,unsigned long size,char *buffer);
+typedef char *(*mailgets_t) (readfn_t f,void *stream,unsigned long size,
+			     GETS_DATA *md);
+typedef char *(*readprogress_t) (GETS_DATA *md,unsigned long octets);
+typedef void *(*mailcache_t) (MAILSTREAM *stream,unsigned long msgno,long op);
+typedef long (*mailproxycopy_t) (MAILSTREAM *stream,char *sequence,
+				 char *mailbox,long options);
+typedef long (*tcptimeout_t) (long overall,long last, char *host);
+typedef void *(*authchallenge_t) (void *stream,unsigned long *len);
+typedef long (*authrespond_t) (void *stream,char *s,unsigned long size);
+typedef long (*authcheck_t) (void);
+typedef long (*authclient_t) (authchallenge_t challenger,
+			      authrespond_t responder,char *service,NETMBX *mb,
+			      void *s,unsigned long *trial,char *user);
+typedef char *(*authresponse_t) (void *challenge,unsigned long clen,
+				 unsigned long *rlen);
+typedef char *(*authserver_t) (authresponse_t responder,int argc,char *argv[]);
+typedef void (*smtpverbose_t) (char *buffer);
+typedef void (*imapenvelope_t) (MAILSTREAM *stream,unsigned long msgno,
+				ENVELOPE *env);
+typedef char *(*imapreferral_t) (MAILSTREAM *stream,char *url,long code);
+typedef void (*overview_t) (MAILSTREAM *stream,unsigned long uid,OVERVIEW *ov,
+			    unsigned long msgno);
+typedef unsigned long *(*sorter_t) (MAILSTREAM *stream,char *charset,
+				    SEARCHPGM *spg,SORTPGM *pgm,long flags);
+typedef void (*parseline_t) (ENVELOPE *env,char *hdr,char *data,char *host);
+typedef ADDRESS *(*parsephrase_t) (char *phrase,char *end,char *host);
+typedef void *(*blocknotify_t) (int reason,void *data);
+typedef long (*kinit_t) (char *host,char *reason);
+typedef void (*sendcommand_t) (MAILSTREAM *stream,char *cmd,long flags);
+typedef char *(*newsrcquery_t) (MAILSTREAM *stream,char *mulname,char *name);
+typedef void (*getacl_t) (MAILSTREAM *stream,char *mailbox,ACLLIST *acl);
+typedef void (*listrights_t) (MAILSTREAM *stream,char *mailbox,char *id,
+			      char *alwaysrights,STRINGLIST *possiblerights);
+typedef void (*myrights_t) (MAILSTREAM *stream,char *mailbox,char *rights);
+typedef void (*quota_t) (MAILSTREAM *stream,char *qroot,QUOTALIST *qlist);
+typedef void (*quotaroot_t) (MAILSTREAM *stream,char *mbx,STRINGLIST *qroot);
+typedef void (*sortresults_t) (MAILSTREAM *stream,unsigned long *list,
+			       unsigned long size);
+typedef char *(*userprompt_t) (void);
+typedef long (*append_t) (MAILSTREAM *stream,void *data,char **flags,
+			  char **date,STRING **message);
+typedef void (*copyuid_t) (MAILSTREAM *stream,char *mailbox,
+			   unsigned long uidvalidity,SEARCHSET *sourceset,
+			   SEARCHSET *destset);
+typedef void (*appenduid_t) (char *mailbox,unsigned long uidvalidity,
+			     SEARCHSET *set);
+typedef long (*dirfmttest_t) (char *name);
+typedef long (*scancontents_t) (char *name,char *contents,unsigned long csiz,
+				unsigned long fsiz);
+
+typedef void (*freeeltsparep_t) (void **sparep);
+typedef void (*freeenvelopesparep_t) (void **sparep);
+typedef void (*freebodysparep_t) (void **sparep);
+typedef void (*freestreamsparep_t) (void **sparep);
+typedef void *(*sslstart_t) (void *stream,char *host,unsigned long flags);
+typedef long (*sslcertificatequery_t) (char *reason,char *host,char *cert);
+typedef void (*sslfailure_t) (char *host,char *reason,unsigned long flags);
+typedef void (*logouthook_t) (void *data);
+typedef char *(*sslclientcert_t) (void);
+typedef char *(*sslclientkey_t) (void);
+
+/* Globals */
+
+extern char *body_types[];	/* defined body type strings */
+extern char *body_encodings[];	/* defined body encoding strings */
+extern const char *days[];	/* day name strings */
+extern const char *months[];	/* month name strings */
+
+/* Threading */
+
+/* Thread node */
+
+#define THREADNODE struct thread_node
+
+THREADNODE {
+  unsigned long num;		/* message number */
+  SORTCACHE *sc;		/* (internal use) sortcache entry */
+  THREADNODE *branch;		/* branch at this point in tree */
+  THREADNODE *next;		/* next node */
+};
+
+typedef void (*threadresults_t) (MAILSTREAM *stream,THREADNODE *tree);
+
+
+/* Thread dispatch */
+
+#define THREADER struct threader_list
+
+THREADER {
+  char *name;			/* name of threader */
+  THREADNODE *(*dispatch) (MAILSTREAM *stream,char *charset,SEARCHPGM *spg,
+			   long flags,sorter_t sorter);
+  THREADER *next;
+};
+
+
+/* Container for references threading */
+
+typedef void ** container_t;
+
+/* Namespaces */
+
+#define NAMESPACE struct mail_namespace
+
+NAMESPACE {
+  char *name;			/* name of this namespace */
+  int delimiter;		/* hierarchy delimiter */
+  PARAMETER *param;		/* namespace parameters */
+  NAMESPACE *next;		/* next namespace */
+};
+
+
+/* Authentication */
+
+#define AUTHENTICATOR struct mail_authenticator
+
+AUTHENTICATOR {
+  long flags;			/* authenticator flags */
+  char *name;			/* name of this authenticator */
+  authcheck_t valid;		/* authenticator valid on this system */
+  authclient_t client;		/* client function that supports it */
+  authserver_t server;		/* server function that supports it */
+  AUTHENTICATOR *next;		/* next authenticator */
+};
+
+/* Mail driver dispatch */
+
+DRIVER {
+  char *name;			/* driver name */
+  unsigned long flags;		/* driver flags */
+  DRIVER *next;			/* next driver */
+				/* mailbox is valid for us */
+  DRIVER *(*valid) (char *mailbox);
+				/* manipulate driver parameters */
+  void *(*parameters) (long function,void *value);
+				/* scan mailboxes */
+  void (*scan) (MAILSTREAM *stream,char *ref,char *pat,char *contents);
+				/* list mailboxes */
+  void (*list) (MAILSTREAM *stream,char *ref,char *pat);
+				/* list subscribed mailboxes */
+  void (*lsub) (MAILSTREAM *stream,char *ref,char *pat);
+				/* subscribe to mailbox */
+  long (*subscribe) (MAILSTREAM *stream,char *mailbox);
+				/* unsubscribe from mailbox */
+  long (*unsubscribe) (MAILSTREAM *stream,char *mailbox);
+				/* create mailbox */
+  long (*create) (MAILSTREAM *stream,char *mailbox);
+				/* delete mailbox */
+  long (*mbxdel) (MAILSTREAM *stream,char *mailbox);
+				/* rename mailbox */
+  long (*mbxren) (MAILSTREAM *stream,char *old,char *newname);
+				/* status of mailbox */
+  long (*status) (MAILSTREAM *stream,char *mbx,long flags);
+
+				/* open mailbox */
+  MAILSTREAM *(*open) (MAILSTREAM *stream);
+				/* close mailbox */
+  void (*close) (MAILSTREAM *stream,long options);
+				/* fetch message "fast" attributes */
+  void (*fast) (MAILSTREAM *stream,char *sequence,long flags);
+				/* fetch message flags */
+  void (*msgflags) (MAILSTREAM *stream,char *sequence,long flags);
+				/* fetch message overview */
+  long (*overview) (MAILSTREAM *stream,overview_t ofn);
+				/* fetch message envelopes */
+  ENVELOPE *(*structure) (MAILSTREAM *stream,unsigned long msgno,BODY **body,
+			  long flags);
+				/* return RFC-822 header */
+  char *(*header) (MAILSTREAM *stream,unsigned long msgno,
+		   unsigned long *length,long flags);
+				/* return RFC-822 text */
+  long (*text) (MAILSTREAM *stream,unsigned long msgno,STRING *bs,long flags);
+				/* load cache */
+  long (*msgdata) (MAILSTREAM *stream,unsigned long msgno,char *section,
+		   unsigned long first,unsigned long last,STRINGLIST *lines,
+		   long flags);
+				/* return UID for message */
+  unsigned long (*uid) (MAILSTREAM *stream,unsigned long msgno);
+				/* return message number from UID */
+  unsigned long (*msgno) (MAILSTREAM *stream,unsigned long uid);
+				/* modify flags */
+  void (*flag) (MAILSTREAM *stream,char *sequence,char *flag,long flags);
+				/* per-message modify flags */
+  void (*flagmsg) (MAILSTREAM *stream,MESSAGECACHE *elt);
+				/* search for message based on criteria */
+  long (*search) (MAILSTREAM *stream,char *charset,SEARCHPGM *pgm,long flags);
+				/* sort messages */
+  unsigned long *(*sort) (MAILSTREAM *stream,char *charset,SEARCHPGM *spg,
+			  SORTPGM *pgm,long flags);
+				/* thread messages */
+  THREADNODE *(*thread) (MAILSTREAM *stream,char *type,char *charset,
+			 SEARCHPGM *spg,long flag);
+				/* ping mailbox to see if still alive */
+  long (*ping) (MAILSTREAM *stream);
+				/* check for new messages */
+  void (*check) (MAILSTREAM *stream);
+				/* expunge deleted messages */
+  long (*expunge) (MAILSTREAM *stream,char *sequence,long options);
+				/* copy messages to another mailbox */
+  long (*copy) (MAILSTREAM *stream,char *sequence,char *mailbox,long options);
+				/* append string message to mailbox */
+  long (*append) (MAILSTREAM *stream,char *mailbox,append_t af,void *data);
+				/* garbage collect stream */
+  void (*gc) (MAILSTREAM *stream,long gcflags);
+};
+
+
+#include "linkage.h"
+
+/* Compatibility support names for old interfaces */
+
+#define GET_TRYALTFIRST GET_TRYSSLFIRST
+#define SET_TRYALTFIRST SET_TRYSSLFIRST
+#define GET_IMAPTRYALT GET_IMAPTRYSSL
+#define SET_IMAPTRYALT SET_IMAPTRYSSL
+#define OP_TRYALT OP_TRYSSL
+#define altflag sslflag
+
+#define mail_close(stream) \
+  mail_close_full (stream,NIL)
+#define mail_fetchfast(stream,sequence) \
+  mail_fetch_fast (stream,sequence,NIL)
+#define mail_fetchfast_full mail_fetch_fast
+#define mail_fetchflags(stream,sequence) \
+  mail_fetch_flags (stream,sequence,NIL)
+#define mail_fetchflags_full mail_fetch_flags
+#define mail_fetchenvelope(stream,msgno) \
+  mail_fetch_structure (stream,msgno,NIL,NIL)
+#define mail_fetchstructure(stream,msgno,body) \
+  mail_fetch_structure (stream,msgno,body,NIL)
+#define mail_fetchstructure_full mail_fetch_structure
+#define mail_fetchheader(stream,msgno) \
+  mail_fetch_header (stream,msgno,NIL,NIL,NIL,FT_PEEK)
+#define mail_fetchheader_full(stream,msgno,lines,len,flags) \
+  mail_fetch_header (stream,msgno,NIL,lines,len,FT_PEEK | (flags))
+#define mail_fetchtext(stream,msgno) \
+  mail_fetch_text (stream,msgno,NIL,NIL,NIL)
+#define mail_fetchtext_full(stream,msgno,length,flags) \
+  mail_fetch_text (stream,msgno,NIL,length,flags)
+#define mail_fetchbody(stream,msgno,section,length) \
+  mail_fetch_body (stream,msgno,section,length,NIL)
+#define mail_fetchbody_full mail_fetch_body
+#define mail_setflag(stream,sequence,flag) \
+  mail_flag (stream,sequence,flag,ST_SET)
+#define mail_setflag_full(stream,sequence,flag,flags) \
+  mail_flag (stream,sequence,flag,ST_SET | (flags))
+#define mail_clearflag(stream,sequence,flag) \
+  mail_flag (stream,sequence,flag,NIL)
+#define mail_clearflag_full mail_flag
+#define mail_search(stream,criteria) \
+  mail_search_full (stream,NIL,mail_criteria (criteria),SE_FREE);
+#define mail_expunge(stream) \
+  mail_expunge_full (stream,NIL,NIL)
+#define mail_copy(stream,sequence,mailbox) \
+  mail_copy_full (stream,sequence,mailbox,NIL)
+#define mail_move(stream,sequence,mailbox) \
+  mail_copy_full (stream,sequence,mailbox,CP_MOVE)
+#define mail_append(stream,mailbox,message) \
+  mail_append_full (stream,mailbox,NIL,NIL,message)
+
+/* Interfaces for SVR4 locking brain-damage workaround */
+
+/* Driver dispatching */
+
+#define SAFE_DELETE(dtb,stream,mailbox) (*dtb->mbxdel) (stream,mailbox)
+#define SAFE_RENAME(dtb,stream,old,newname) (*dtb->mbxren) (stream,old,newname)
+#define SAFE_STATUS(dtb,stream,mbx,flags) (*dtb->status) (stream,mbx,flags)
+#define SAFE_COPY(dtb,stream,sequence,mailbox,options) \
+  (*dtb->copy) (stream,sequence,mailbox,options)
+#define SAFE_APPEND(dtb,stream,mailbox,af,data) \
+  (*dtb->append) (stream,mailbox,af,data)
+#define SAFE_SCAN_CONTENTS(dtb,name,contents,csiz,fsiz) \
+  scan_contents (dtb,name,contents,csiz,fsiz)
+
+
+/* Driver callbacks */
+
+#define MM_EXISTS mm_exists
+#define MM_EXPUNGED mm_expunged
+#define MM_FLAGS mm_flags
+#define MM_NOTIFY mm_notify
+#define MM_STATUS mm_status
+#define MM_LOG mm_log
+#define MM_CRITICAL mm_critical
+#define MM_NOCRITICAL mm_nocritical
+#define MM_DISKERROR mm_diskerror
+#define MM_FATAL mm_fatal
+#define MM_APPEND(af) (*af)
+
+/* Function prototypes */
+
+void mm_searched (MAILSTREAM *stream,unsigned long number);
+void mm_exists (MAILSTREAM *stream,unsigned long number);
+void mm_expunged (MAILSTREAM *stream,unsigned long number);
+void mm_flags (MAILSTREAM *stream,unsigned long number);
+void mm_notify (MAILSTREAM *stream,char *string,long errflg);
+void mm_list (MAILSTREAM *stream,int delimiter,char *name,long attributes);
+void mm_lsub (MAILSTREAM *stream,int delimiter,char *name,long attributes);
+void mm_status (MAILSTREAM *stream,char *mailbox,MAILSTATUS *status);
+void mm_log (char *string,long errflg);
+void mm_dlog (char *string);
+void mm_login (NETMBX *mb,char *user,char *pwd,long trial);
+void mm_critical (MAILSTREAM *stream);
+void mm_nocritical (MAILSTREAM *stream);
+long mm_diskerror (MAILSTREAM *stream,long errcode,long serious);
+void mm_fatal (char *string);
+void *mm_cache (MAILSTREAM *stream,unsigned long msgno,long op);
+
+extern STRINGDRIVER mail_string;
+void mail_versioncheck (char *version);
+void mail_link (DRIVER *driver);
+void *mail_parameters (MAILSTREAM *stream,long function,void *value);
+DRIVER *mail_valid (MAILSTREAM *stream,char *mailbox,char *purpose);
+DRIVER *mail_valid_net (char *name,DRIVER *drv,char *host,char *mailbox);
+long mail_valid_net_parse (char *name,NETMBX *mb);
+long mail_valid_net_parse_work (char *name,NETMBX *mb,char *service);
+void mail_scan (MAILSTREAM *stream,char *ref,char *pat,char *contents);
+void mail_list (MAILSTREAM *stream,char *ref,char *pat);
+void mail_lsub (MAILSTREAM *stream,char *ref,char *pat);
+long mail_subscribe (MAILSTREAM *stream,char *mailbox);
+long mail_unsubscribe (MAILSTREAM *stream,char *mailbox);
+long mail_create (MAILSTREAM *stream,char *mailbox);
+long mail_delete (MAILSTREAM *stream,char *mailbox);
+long mail_rename (MAILSTREAM *stream,char *old,char *newname);
+char *mail_utf7_valid (char *mailbox);
+long mail_status (MAILSTREAM *stream,char *mbx,long flags);
+long mail_status_default (MAILSTREAM *stream,char *mbx,long flags);
+MAILSTREAM *mail_open (MAILSTREAM *stream,char *name,long options);
+MAILSTREAM *mail_open_work (DRIVER *d,MAILSTREAM *stream,char *name,
+			    long options);
+MAILSTREAM *mail_close_full (MAILSTREAM *stream,long options);
+MAILHANDLE *mail_makehandle (MAILSTREAM *stream);
+void mail_free_handle (MAILHANDLE **handle);
+MAILSTREAM *mail_stream (MAILHANDLE *handle);
+
+void mail_fetch_fast (MAILSTREAM *stream,char *sequence,long flags);
+void mail_fetch_flags (MAILSTREAM *stream,char *sequence,long flags);
+void mail_fetch_overview (MAILSTREAM *stream,char *sequence,overview_t ofn);
+void mail_fetch_overview_sequence (MAILSTREAM *stream,char *sequence,
+				   overview_t ofn);
+void mail_fetch_overview_default (MAILSTREAM *stream,overview_t ofn);
+ENVELOPE *mail_fetch_structure (MAILSTREAM *stream,unsigned long msgno,
+				BODY **body,long flags);
+char *mail_fetch_message (MAILSTREAM *stream,unsigned long msgno,
+			  unsigned long *len,long flags);
+char *mail_fetch_header (MAILSTREAM *stream,unsigned long msgno,char *section,
+			 STRINGLIST *lines,unsigned long *len,long flags);
+char *mail_fetch_text (MAILSTREAM *stream,unsigned long msgno,char *section,
+		       unsigned long *len,long flags);
+char *mail_fetch_mime (MAILSTREAM *stream,unsigned long msgno,char *section,
+		       unsigned long *len,long flags);
+char *mail_fetch_body (MAILSTREAM *stream,unsigned long msgno,char *section,
+		       unsigned long *len,long flags);
+long mail_partial_text (MAILSTREAM *stream,unsigned long msgno,char *section,
+			unsigned long first,unsigned long last,long flags);
+long mail_partial_body (MAILSTREAM *stream,unsigned long msgno,char *section,
+			unsigned long first,unsigned long last,long flags);
+char *mail_fetch_text_return (GETS_DATA *md,SIZEDTEXT *t,unsigned long *len);
+char *mail_fetch_string_return (GETS_DATA *md,STRING *bs,unsigned long i,
+				unsigned long *len,long flags);
+long mail_read (void *stream,unsigned long size,char *buffer);
+unsigned long mail_uid (MAILSTREAM *stream,unsigned long msgno);
+unsigned long mail_msgno (MAILSTREAM *stream,unsigned long uid);
+void mail_fetchfrom (char *s,MAILSTREAM *stream,unsigned long msgno,
+		     long length);
+void mail_fetchsubject (char *s,MAILSTREAM *stream,unsigned long msgno,
+			long length);
+MESSAGECACHE *mail_elt (MAILSTREAM *stream,unsigned long msgno);
+void mail_flag (MAILSTREAM *stream,char *sequence,char *flag,long flags);
+long mail_search_full (MAILSTREAM *stream,char *charset,SEARCHPGM *pgm,
+		       long flags);
+long mail_search_default (MAILSTREAM *stream,char *charset,SEARCHPGM *pgm,
+			  long flags);
+long mail_ping (MAILSTREAM *stream);
+void mail_check (MAILSTREAM *stream);
+long mail_expunge_full (MAILSTREAM *stream,char *sequence,long options);
+long mail_copy_full (MAILSTREAM *stream,char *sequence,char *mailbox,
+		     long options);
+long mail_append_full (MAILSTREAM *stream,char *mailbox,char *flags,char *date,
+		       STRING *message);
+long mail_append_multiple (MAILSTREAM *stream,char *mailbox,append_t af,
+			   void *data);
+void mail_gc (MAILSTREAM *stream,long gcflags);
+void mail_gc_msg (MESSAGE *msg,long gcflags);
+void mail_gc_body (BODY *body);
+
+BODY *mail_body (MAILSTREAM *stream,unsigned long msgno,
+		 unsigned char *section);
+char *mail_date (char *string,MESSAGECACHE *elt);
+char *mail_cdate (char *string,MESSAGECACHE *elt);
+long mail_parse_date (MESSAGECACHE *elt,unsigned char *string);
+void mail_exists (MAILSTREAM *stream,unsigned long nmsgs);
+void mail_recent (MAILSTREAM *stream,unsigned long recent);
+void mail_expunged (MAILSTREAM *stream,unsigned long msgno);
+void mail_lock (MAILSTREAM *stream);
+void mail_unlock (MAILSTREAM *stream);
+void mail_debug (MAILSTREAM *stream);
+void mail_nodebug (MAILSTREAM *stream);
+void mail_dlog (char *string,long flag);
+long mail_match_lines (STRINGLIST *lines,STRINGLIST *msglines,long flags);
+unsigned long mail_filter (char *text,unsigned long len,STRINGLIST *lines,
+			   long flags);
+long mail_search_msg (MAILSTREAM *stream,unsigned long msgno,char *section,
+		      SEARCHPGM *pgm);
+long mail_search_header_text (char *s,STRINGLIST *st);
+long mail_search_header (SIZEDTEXT *hdr,STRINGLIST *st);
+long mail_search_text (MAILSTREAM *stream,unsigned long msgno,char *section,
+		       STRINGLIST *st,long flags);
+long mail_search_body (MAILSTREAM *stream,unsigned long msgno,BODY *body,
+		       char *prefix,unsigned long section,long flags);
+long mail_search_string (SIZEDTEXT *s,char *charset,STRINGLIST **st);
+long mail_search_string_work (SIZEDTEXT *s,STRINGLIST **st);
+long mail_search_keyword (MAILSTREAM *stream,MESSAGECACHE *elt,STRINGLIST *st,
+			  long flag);
+long mail_search_addr (ADDRESS *adr,STRINGLIST *st);
+char *mail_search_gets (readfn_t f,void *stream,unsigned long size,
+			GETS_DATA *md);
+SEARCHPGM *mail_criteria (char *criteria);
+int mail_criteria_date (unsigned short *date,char **r);
+int mail_criteria_string (STRINGLIST **s,char **r);
+unsigned short mail_shortdate (unsigned int year,unsigned int month,
+			       unsigned int day);
+SEARCHSET *mail_parse_set (char *s,char **ret);
+SEARCHSET *mail_append_set (SEARCHSET *set,unsigned long msgno);
+unsigned long *mail_sort (MAILSTREAM *stream,char *charset,SEARCHPGM *spg,
+			  SORTPGM *pgm,long flags);
+unsigned long *mail_sort_cache (MAILSTREAM *stream,SORTPGM *pgm,SORTCACHE **sc,
+				long flags);
+unsigned long *mail_sort_msgs (MAILSTREAM *stream,char *charset,SEARCHPGM *spg,
+			       SORTPGM *pgm,long flags);
+SORTCACHE **mail_sort_loadcache (MAILSTREAM *stream,SORTPGM *pgm);
+unsigned int mail_strip_subject (char *t,char **ret);
+char *mail_strip_subject_wsp (char *s);
+char *mail_strip_subject_blob (char *s);
+int mail_sort_compare (const void *a1,const void *a2);
+unsigned long mail_longdate (MESSAGECACHE *elt);
+THREADNODE *mail_thread (MAILSTREAM *stream,char *type,char *charset,
+			 SEARCHPGM *spg,long flags);
+THREADNODE *mail_thread_msgs (MAILSTREAM *stream,char *type,char *charset,
+			      SEARCHPGM *spg,long flags,sorter_t sorter);
+THREADNODE *mail_thread_orderedsubject (MAILSTREAM *stream,char *charset,
+					SEARCHPGM *spg,long flags,
+					sorter_t sorter);
+THREADNODE *mail_thread_references (MAILSTREAM *stream,char *charset,
+				    SEARCHPGM *spg,long flags,
+				    sorter_t sorter);
+void mail_thread_loadcache (MAILSTREAM *stream,unsigned long uid,OVERVIEW *ov,
+			    unsigned long msgno);
+char *mail_thread_parse_msgid (char *s,char **ss);
+STRINGLIST *mail_thread_parse_references (char *s,long flag);
+long mail_thread_check_child (container_t mother,container_t daughter);
+container_t mail_thread_prune_dummy (container_t msg,container_t ane);
+container_t mail_thread_prune_dummy_work (container_t msg,container_t ane);
+THREADNODE *mail_thread_c2node (MAILSTREAM *stream,container_t con,long flags);
+THREADNODE *mail_thread_sort (THREADNODE *thr,THREADNODE **tc);
+int mail_thread_compare_date (const void *a1,const void *a2);
+long mail_sequence (MAILSTREAM *stream,unsigned char *sequence);
+long mail_uid_sequence (MAILSTREAM *stream,unsigned char *sequence);
+long mail_parse_flags (MAILSTREAM *stream,char *flag,unsigned long *uf);
+long mail_usable_network_stream (MAILSTREAM *stream,char *name);
+
+MESSAGECACHE *mail_new_cache_elt (unsigned long msgno);
+ENVELOPE *mail_newenvelope (void);
+ADDRESS *mail_newaddr (void);
+BODY *mail_newbody (void);
+BODY *mail_initbody (BODY *body);
+PARAMETER *mail_newbody_parameter (void);
+PART *mail_newbody_part (void);
+MESSAGE *mail_newmsg (void);
+STRINGLIST *mail_newstringlist (void);
+SEARCHPGM *mail_newsearchpgm (void);
+SEARCHHEADER *mail_newsearchheader (char *line,char *text);
+SEARCHSET *mail_newsearchset (void);
+SEARCHOR *mail_newsearchor (void);
+SEARCHPGMLIST *mail_newsearchpgmlist (void);
+SORTPGM *mail_newsortpgm (void);
+THREADNODE *mail_newthreadnode (SORTCACHE *sc);
+ACLLIST *mail_newacllist (void);
+QUOTALIST *mail_newquotalist (void);
+void mail_free_body (BODY **body);
+void mail_free_body_data (BODY *body);
+void mail_free_body_parameter (PARAMETER **parameter);
+void mail_free_body_part (PART **part);
+void mail_free_cache (MAILSTREAM *stream);
+void mail_free_elt (MESSAGECACHE **elt);
+void mail_free_envelope (ENVELOPE **env);
+void mail_free_address (ADDRESS **address);
+void mail_free_stringlist (STRINGLIST **string);
+void mail_free_searchpgm (SEARCHPGM **pgm);
+void mail_free_searchheader (SEARCHHEADER **hdr);
+void mail_free_searchset (SEARCHSET **set);
+void mail_free_searchor (SEARCHOR **orl);
+void mail_free_searchpgmlist (SEARCHPGMLIST **pgl);
+void mail_free_namespace (NAMESPACE **n);
+void mail_free_sortpgm (SORTPGM **pgm);
+void mail_free_threadnode (THREADNODE **thr);
+void mail_free_acllist (ACLLIST **al);
+void mail_free_quotalist (QUOTALIST **ql);
+void auth_link (AUTHENTICATOR *auth);
+char *mail_auth (char *mechanism,authresponse_t resp,int argc,char *argv[]);
+AUTHENTICATOR *mail_lookup_auth (unsigned long i);
+unsigned int mail_lookup_auth_name (char *mechanism,long flags);
+
+NETSTREAM *net_open (NETMBX *mb,NETDRIVER *dv,unsigned long port,
+		     NETDRIVER *ssld,char *ssls,unsigned long sslp);
+NETSTREAM *net_open_work (NETDRIVER *dv,char *host,char *service,
+			  unsigned long port,unsigned long portoverride,
+			  unsigned long flags);
+NETSTREAM *net_aopen (NETDRIVER *dv,NETMBX *mb,char *service,char *usrbuf);
+char *net_getline (NETSTREAM *stream);
+				/* stream must be void* for use as readfn_t */
+long net_getbuffer (void *stream,unsigned long size,char *buffer);
+long net_soutr (NETSTREAM *stream,char *string);
+long net_sout (NETSTREAM *stream,char *string,unsigned long size);
+void net_close (NETSTREAM *stream);
+char *net_host (NETSTREAM *stream);
+char *net_remotehost (NETSTREAM *stream);
+unsigned long net_port (NETSTREAM *stream);
+char *net_localhost (NETSTREAM *stream);
+
+long sm_subscribe (char *mailbox);
+long sm_unsubscribe (char *mailbox);
+char *sm_read (void **sdb);
+
+void ssl_onceonlyinit (void);
+char *ssl_start_tls (char *s);
+void ssl_server_init (char *server);
+
+
+/* Server I/O functions */
+
+int PBIN (void);
+char *PSIN (char *s,int n);
+long PSINR (char *s,unsigned long n);
+int PBOUT (int c);
+long INWAIT (long seconds);
+int PSOUT (char *s);
+int PSOUTR (SIZEDTEXT *s);
+int PFLUSH (void);
diff --git a/imap/src/c-client/misc.c b/imap/src/c-client/misc.c
new file mode 100644
index 00000000..4b789af8
--- /dev/null
+++ b/imap/src/c-client/misc.c
@@ -0,0 +1,475 @@
+/* ========================================================================
+ * Copyright 1988-2006 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:	Miscellaneous utility routines
+ *
+ * Author:	Mark Crispin
+ *		Networks and Distributed Computing
+ *		Computing & Communications
+ *		University of Washington
+ *		Administration Building, AG-44
+ *		Seattle, WA  98195
+ *		Internet: MRC@CAC.Washington.EDU
+ *
+ * Date:	5 July 1988
+ * Last Edited:	6 December 2006
+ *
+ * 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 NationalInstitutes of Health
+ * under grant number RR-00785.
+ */
+
+
+#include <ctype.h>
+#include "c-client.h"
+
+/* Convert ASCII string to all uppercase
+ * Accepts: string pointer
+ * Returns: string pointer
+ *
+ * Don't use islower/toupper since this function must be ASCII only.
+ */
+
+unsigned char *ucase (unsigned char *s)
+{
+  unsigned char *t;
+				/* if lowercase covert to upper */
+  for (t = s; *t; t++) if ((*t >= 'a') && (*t <= 'z')) *t -= ('a' - 'A');
+  return s;			/* return string */
+}
+
+
+/* Convert string to all lowercase
+ * Accepts: string pointer
+ * Returns: string pointer
+ *
+ * Don't use isupper/tolower since this function must be ASCII only.
+ */
+
+unsigned char *lcase (unsigned char *s)
+{
+  unsigned char *t;
+				/* if uppercase covert to lower */
+  for (t = s; *t; t++) if ((*t >= 'A') && (*t <= 'Z')) *t += ('a' - 'A');
+  return s;			/* return string */
+}
+
+/* Copy string to free storage
+ * Accepts: source string
+ * Returns: free storage copy of string
+ */
+
+char *cpystr (const char *string)
+{
+  return string ? strcpy ((char *) fs_get (1 + strlen (string)),string) : NIL;
+}
+
+
+/* Copy text/size to free storage as sized text
+ * Accepts: destination sized text
+ *	    pointer to source text
+ *	    size of source text
+ * Returns: text as a char *
+ */
+
+char *cpytxt (SIZEDTEXT *dst,char *text,unsigned long size)
+{
+				/* flush old space */
+  if (dst->data) fs_give ((void **) &dst->data);
+				/* copy data in sized text */
+  memcpy (dst->data = (unsigned char *)
+	  fs_get ((size_t) (dst->size = size) + 1),text,(size_t) size);
+  dst->data[size] = '\0';	/* tie off text */
+  return (char *) dst->data;	/* convenience return */
+}
+
+/* Copy sized text to free storage as sized text
+ * Accepts: destination sized text
+ *	    source sized text
+ * Returns: text as a char *
+ */
+
+char *textcpy (SIZEDTEXT *dst,SIZEDTEXT *src)
+{
+				/* flush old space */
+  if (dst->data) fs_give ((void **) &dst->data);
+				/* copy data in sized text */
+  memcpy (dst->data = (unsigned char *)
+	  fs_get ((size_t) (dst->size = src->size) + 1),
+	  src->data,(size_t) src->size);
+  dst->data[dst->size] = '\0';	/* tie off text */
+  return (char *) dst->data;	/* convenience return */
+}
+
+
+/* Copy stringstruct to free storage as sized text
+ * Accepts: destination sized text
+ *	    source stringstruct
+ * Returns: text as a char *
+ */
+
+char *textcpystring (SIZEDTEXT *text,STRING *bs)
+{
+  unsigned long i = 0;
+				/* clear old space */
+  if (text->data) fs_give ((void **) &text->data);
+				/* make free storage space in sized text */
+  text->data = (unsigned char *) fs_get ((size_t) (text->size = SIZE (bs)) +1);
+  while (i < text->size) text->data[i++] = SNX (bs);
+  text->data[i] = '\0';		/* tie off text */
+  return (char *) text->data;	/* convenience return */
+}
+
+
+/* Copy stringstruct from offset to free storage as sized text
+ * Accepts: destination sized text
+ *	    source stringstruct
+ *	    offset into stringstruct
+ *	    size of source text
+ * Returns: text as a char *
+ */
+
+char *textcpyoffstring (SIZEDTEXT *text,STRING *bs,unsigned long offset,
+			unsigned long size)
+{
+  unsigned long i = 0;
+				/* clear old space */
+  if (text->data) fs_give ((void **) &text->data);
+  SETPOS (bs,offset);		/* offset the string */
+				/* make free storage space in sized text */
+  text->data = (unsigned char *) fs_get ((size_t) (text->size = size) + 1);
+  while (i < size) text->data[i++] = SNX (bs);
+  text->data[i] = '\0';		/* tie off text */
+  return (char *) text->data;	/* convenience return */
+}
+
+/* Returns index of rightmost bit in word
+ * Accepts: pointer to a 32 bit value
+ * Returns: -1 if word is 0, else index of rightmost bit
+ *
+ * Bit is cleared in the word
+ */
+
+unsigned long find_rightmost_bit (unsigned long *valptr)
+{
+  unsigned long value = *valptr;
+  unsigned long bit = 0;
+  if (!(value & 0xffffffff)) return 0xffffffff;
+				/* binary search for rightmost bit */
+  if (!(value & 0xffff)) value >>= 16, bit += 16;
+  if (!(value & 0xff)) value >>= 8, bit += 8;
+  if (!(value & 0xf)) value >>= 4, bit += 4;
+  if (!(value & 0x3)) value >>= 2, bit += 2;
+  if (!(value & 0x1)) value >>= 1, bit += 1;
+  *valptr ^= (1 << bit);	/* clear specified bit */
+  return bit;
+}
+
+
+/* Return minimum of two integers
+ * Accepts: integer 1
+ *	    integer 2
+ * Returns: minimum
+ */
+
+long min (long i,long j)
+{
+  return ((i < j) ? i : j);
+}
+
+
+/* Return maximum of two integers
+ * Accepts: integer 1
+ *	    integer 2
+ * Returns: maximum
+ */
+
+long max (long i,long j)
+{
+  return ((i > j) ? i : j);
+}
+
+/* Search, case-insensitive for ASCII characters
+ * Accepts: base string
+ *	    length of base string
+ *	    pattern string
+ *	    length of pattern string
+ * Returns: T if pattern exists inside base, else NIL
+ */
+
+long search (unsigned char *base,long basec,unsigned char *pat,long patc)
+{
+  long i,j,k;
+  int c;
+  unsigned char mask[256];
+  static unsigned char alphatab[256] = {
+    255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+    255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+    255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+    255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+    255,223,223,223,223,223,223,223,223,223,223,223,223,223,223,223,
+    223,223,223,223,223,223,223,223,223,223,223,255,255,255,255,255,
+    255,223,223,223,223,223,223,223,223,223,223,223,223,223,223,223,
+    223,223,223,223,223,223,223,223,223,223,223,255,255,255,255,255,
+    255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+    255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+    255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+    255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+    255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+    255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+    255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+    255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255
+    };
+				/* validate arguments */
+  if (base && (basec > 0) && pat && (basec >= patc)) {
+    if (patc <= 0) return T;	/* empty pattern always succeeds */
+    memset (mask,0,256);	/* initialize search validity mask */
+    for (i = 0; i < patc; i++) if (!mask[c = pat[i]]) {
+				/* mark single character if non-alphabetic */
+      if (alphatab[c] & 0x20) mask[c] = T;
+				/* else mark both cases */
+      else mask[c & 0xdf] = mask[c | 0x20] = T;
+    }
+				/* Boyer-Moore type search */
+    for (i = --patc; i < basec; i += (mask[c] ? 1 : (j + 1)))
+      for (j = patc,c = base[k = i]; !((c ^ pat[j]) & alphatab[c]);
+	   j--,c = base[--k])
+	if (!j) return T;	/* found a match! */
+  }
+  return NIL;			/* pattern not found */
+}
+
+/* Boyer-Moore string search
+ * Accepts: base string
+ *	    length of base string
+ *	    pattern string
+ *	    length of pattern string
+ * Returns: T if pattern exists inside base, else NIL
+ */
+
+long ssearch (unsigned char *base,long basec,unsigned char *pat,long patc)
+{
+  long i,j,k;
+  int c;
+  unsigned char mask[256];
+				/* validate arguments */
+  if (base && (basec > 0) && pat && (basec >= patc)) {
+    if (patc <= 0) return T;	/* empty pattern always succeeds */
+    memset (mask,0,256);	/* initialize search validity mask */
+    for (i = 0; i < patc; i++) mask[pat[i]] = T;
+				/* Boyer-Moore type search */
+    for (i = --patc, c = pat[i]; i < basec; i += (mask[c] ? 1 : (j + 1)))
+      for (j = patc,c = base[k = i]; (c == pat[j]); j--,c = base[--k])
+	if (!j) return T;	/* found a match! */
+  }
+  return NIL;			/* pattern not found */
+}
+
+/* Create a hash table
+ * Accepts: size of new table (note: should be a prime)
+ * Returns: hash table
+ */
+
+HASHTAB *hash_create (size_t size)
+{
+  size_t i = sizeof (size_t) + size * sizeof (HASHENT *);
+  HASHTAB *ret = (HASHTAB *) memset (fs_get (i),0,i);
+  ret->size = size;
+  return ret;
+}
+
+
+/* Destroy hash table
+ * Accepts: hash table
+ */
+
+void hash_destroy (HASHTAB **hashtab)
+{
+  if (*hashtab) {
+    hash_reset (*hashtab);	/* reset hash table */
+    fs_give ((void **) hashtab);
+  }
+}
+
+
+/* Reset hash table
+ * Accepts: hash table
+ */
+
+void hash_reset (HASHTAB *hashtab)
+{
+  size_t i;
+  HASHENT *ent,*nxt;
+				/* free each hash entry */
+  for (i = 0; i < hashtab->size; i++) if (ent = hashtab->table[i])
+    for (hashtab->table[i] = NIL; ent; ent = nxt) {
+      nxt = ent->next;		/* get successor */
+      fs_give ((void **) &ent);	/* flush this entry */
+    }
+}
+
+/* Calculate index into hash table
+ * Accepts: hash table
+ *	    entry name
+ * Returns: index
+ */
+
+unsigned long hash_index (HASHTAB *hashtab,char *key)
+{
+  unsigned long i,ret;
+				/* polynomial of letters of the word */
+  for (ret = 0; i = (unsigned int) *key++; ret += i) ret *= HASHMULT;
+  return ret % (unsigned long) hashtab->size;
+}
+
+
+/* Look up name in hash table
+ * Accepts: hash table
+ *	    key
+ * Returns: associated data
+ */
+
+void **hash_lookup (HASHTAB *hashtab,char *key)
+{
+  HASHENT *ret;
+  for (ret = hashtab->table[hash_index (hashtab,key)]; ret; ret = ret->next)
+    if (!strcmp (key,ret->name)) return ret->data;
+  return NIL;
+}
+
+/* Add entry to hash table
+ * Accepts: hash table
+ *	    key
+ *	    associated data
+ *	    number of extra data slots
+ * Returns: hash entry
+ * Caller is responsible for ensuring that entry isn't already in table
+ */
+
+HASHENT *hash_add (HASHTAB *hashtab,char *key,void *data,long extra)
+{
+  unsigned long i = hash_index (hashtab,key);
+  size_t j = sizeof (HASHENT) + (extra * sizeof (void *));
+  HASHENT *ret = (HASHENT *) memset (fs_get (j),0,j);
+  ret->next = hashtab->table[i];/* insert as new head in this index */
+  ret->name = key;		/* set up hash key */
+  ret->data[0] = data;		/* and first data */
+  return hashtab->table[i] = ret;
+}
+
+
+/* Look up name in hash table
+ * Accepts: hash table
+ *	    key
+ *	    associated data
+ *	    number of extra data slots
+ * Returns: associated data
+ */
+
+void **hash_lookup_and_add (HASHTAB *hashtab,char *key,void *data,long extra)
+{
+  HASHENT *ret;
+  unsigned long i = hash_index (hashtab,key);
+  size_t j = sizeof (HASHENT) + (extra * sizeof (void *));
+  for (ret = hashtab->table[i]; ret; ret = ret->next)
+    if (!strcmp (key,ret->name)) return ret->data;
+  ret = (HASHENT *) memset (fs_get (j),0,j);
+  ret->next = hashtab->table[i];/* insert as new head in this index */
+  ret->name = key;		/* set up hash key */
+  ret->data[0] = data;		/* and first data */
+  return (hashtab->table[i] = ret)->data;
+}
+
+/* Convert two hex characters into byte
+ * Accepts: char for high nybble
+ *	    char for low nybble
+ * Returns: byte
+ *
+ * Arguments must be isxdigit validated
+ */
+
+unsigned char hex2byte (unsigned char c1,unsigned char c2)
+{
+				/* merge the two nybbles */
+  return ((c1 -= (isdigit (c1) ? '0' : ((c1 <= 'Z') ? 'A' : 'a') - 10)) << 4) +
+    (c2 - (isdigit (c2) ? '0' : ((c2 <= 'Z') ? 'A' : 'a') - 10));
+}
+
+
+/* Compare two unsigned longs
+ * Accepts: first value
+ *	    second value
+ * Returns: -1 if l1 < l2, 0 if l1 == l2, 1 if l1 > l2
+ */
+
+int compare_ulong (unsigned long l1,unsigned long l2)
+{
+  if (l1 < l2) return -1;
+  if (l1 > l2) return 1;
+  return 0;
+}
+
+
+/* Compare two unsigned chars, case-independent
+ * Accepts: first value
+ *	    second value
+ * Returns: -1 if c1 < c2, 0 if c1 == c2, 1 if c1 > c2
+ *
+ * Don't use isupper/tolower since this function must be ASCII only.
+ */
+
+int compare_uchar (unsigned char c1,unsigned char c2)
+{
+  return compare_ulong (((c1 >= 'A') && (c1 <= 'Z')) ? c1 + ('a' - 'A') : c1,
+			((c2 >= 'A') && (c2 <= 'Z')) ? c2 + ('a' - 'A') : c2);
+}
+
+/* Compare two case-independent ASCII strings
+ * Accepts: first string
+ *	    second string
+ * Returns: -1 if s1 < s2, 0 if s1 == s2, 1 if s1 > s2
+ */
+
+int compare_cstring (unsigned char *s1,unsigned char *s2)
+{
+  int i;
+  if (!s1) return s2 ? -1 : 0;	/* empty string cases */
+  else if (!s2) return 1;
+  for (; *s1 && *s2; s1++,s2++) if (i = (compare_uchar (*s1,*s2))) return i;
+  if (*s1) return 1;		/* first string is longer */
+  return *s2 ? -1 : 0;		/* second string longer : strings identical */
+}
+
+
+/* Compare case-independent string with sized text
+ * Accepts: first string
+ *	    sized text
+ * Returns: -1 if s1 < s2, 0 if s1 == s2, 1 if s1 > s2
+ */
+
+int compare_csizedtext (unsigned char *s1,SIZEDTEXT *s2)
+{
+  int i;
+  unsigned char *s;
+  unsigned long j;
+  if (!s1) return s2 ? -1 : 0;	/* null string cases */
+  else if (!s2) return 1;
+  for (s = (char *) s2->data,j = s2->size; *s1 && j; ++s1,++s,--j)
+    if (i = (compare_uchar (*s1,*s))) return i;
+  if (*s1) return 1;		/* first string is longer */
+  return j ? -1 : 0;		/* second string longer : strings identical */
+}
diff --git a/imap/src/c-client/misc.h b/imap/src/c-client/misc.h
new file mode 100644
index 00000000..1ac79485
--- /dev/null
+++ b/imap/src/c-client/misc.h
@@ -0,0 +1,110 @@
+/* ========================================================================
+ * Copyright 1988-2006 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:	Miscellaneous utility routines
+ *
+ * Author:	Mark Crispin
+ *		Networks and Distributed Computing
+ *		Computing & Communications
+ *		University of Washington
+ *		Administration Building, AG-44
+ *		Seattle, WA  98195
+ *		Internet: MRC@CAC.Washington.EDU
+ *
+ * Date:	5 July 1988
+ * Last Edited:	30 August 2006
+ *
+ * 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 NationalInstitutes of Health
+ * under grant number RR-00785.
+ */
+
+/* Hash table operations */
+
+#define HASHMULT 29		/* hash polynomial multiplier */
+
+#define HASHENT struct hash_entry
+
+HASHENT {
+  HASHENT *next;		/* next entry with same hash code */
+  char *name;			/* name of this hash entry */
+  void *data[1];		/* data of this hash entry */
+};
+
+
+#define HASHTAB struct hash_table
+
+HASHTAB {
+  size_t size;			/* size of this table */
+  HASHENT *table[1];		/* table */
+};
+
+
+/* KLUDGE ALERT!!!
+ *
+ * Yes, write() is overridden here instead of in osdep.  This
+ * is because misc.h is one of the last files that most things #include, so
+ * this should avoid problems with some system #include file.
+ */
+
+#define write safe_write
+
+
+/* Some C compilers have these as macros */
+
+#undef min
+#undef max
+
+
+/* And some C libraries have these as int functions */
+
+#define min Min
+#define max Max
+
+
+/* Compatibility definitions */
+
+#define pmatch(s,pat) \
+  pmatch_full (s,pat,NIL)
+
+/* Function prototypes */
+
+unsigned char *ucase (unsigned char *string);
+unsigned char *lcase (unsigned char *string);
+char *cpystr (const char *string);
+char *cpytxt (SIZEDTEXT *dst,char *text,unsigned long size);
+char *textcpy (SIZEDTEXT *dst,SIZEDTEXT *src);
+char *textcpystring (SIZEDTEXT *text,STRING *bs);
+char *textcpyoffstring (SIZEDTEXT *text,STRING *bs,unsigned long offset,
+			unsigned long size);
+unsigned long find_rightmost_bit (unsigned long *valptr);
+long min (long i,long j);
+long max (long i,long j);
+long search (unsigned char *base,long basec,unsigned char *pat,long patc);
+long ssearch (unsigned char *base,long basec,unsigned char *pat,long patc);
+HASHTAB *hash_create (size_t size);
+void hash_destroy (HASHTAB **hashtab);
+void hash_reset (HASHTAB *hashtab);
+unsigned long hash_index (HASHTAB *hashtab,char *key);
+void **hash_lookup (HASHTAB *hashtab,char *key);
+HASHENT *hash_add (HASHTAB *hashtab,char *key,void *data,long extra);
+void **hash_lookup_and_add (HASHTAB *hashtab,char *key,void *data,long extra);
+unsigned char hex2byte (unsigned char c1,unsigned char c2);
+int compare_ulong (unsigned long l1,unsigned long l2);
+int compare_uchar (unsigned char c1,unsigned char c2);
+int compare_cstring (unsigned char *s1,unsigned char *s2);
+int compare_csizedtext (unsigned char *s1,SIZEDTEXT *s2);
diff --git a/imap/src/c-client/netmsg.c b/imap/src/c-client/netmsg.c
new file mode 100644
index 00000000..187e4ebb
--- /dev/null
+++ b/imap/src/c-client/netmsg.c
@@ -0,0 +1,104 @@
+/* ========================================================================
+ * Copyright 1988-2006 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:	Network message (SMTP/NNTP/POP2/POP3) routines
+ *
+ * Author:	Mark Crispin
+ *		Networks and Distributed Computing
+ *		Computing & Communications
+ *		University of Washington
+ *		Administration Building, AG-44
+ *		Seattle, WA  98195
+ *		Internet: MRC@CAC.Washington.EDU
+ *
+ * Date:	8 June 1995
+ * Last Edited:	6 December 2006
+ */
+
+
+#include <stdio.h>
+#include <errno.h>
+extern int errno;		/* just in case */
+#include "c-client.h"
+#include "netmsg.h"
+#include "flstring.h"
+
+/* Network message read
+ * Accepts: file
+ *	    number of bytes to read
+ *	    buffer address
+ * Returns: T if success, NIL otherwise
+ */
+
+long netmsg_read (void *stream,unsigned long count,char *buffer)
+{
+  return (fread (buffer,(size_t) 1,(size_t) count,(FILE *) stream) == count) ?
+    T : NIL;
+}
+
+/* Slurp dot-terminated text from NET
+ * Accepts: NET stream
+ *	    place to return size
+ *	    place to return header size
+ * Returns: file descriptor
+ */
+
+FILE *netmsg_slurp (NETSTREAM *stream,unsigned long *size,unsigned long *hsiz)
+{
+  unsigned long i;
+  char *s,*t,tmp[MAILTMPLEN];
+  FILE *f = tmpfile ();
+  if (!f) {
+    sprintf (tmp,".%lx.%lx",(unsigned long) time (0),(unsigned long)getpid ());
+    if (f = fopen (tmp,"wb+")) unlink (tmp);
+    else {
+      sprintf (tmp,"Unable to create scratch file: %.80s",strerror (errno));
+      MM_LOG (tmp,ERROR);
+      return NIL;
+    }
+  }
+  *size = 0;			/* initially emtpy */
+  if (hsiz) *hsiz = 0;
+  while (s = net_getline (stream)) {
+    if (*s == '.') {		/* possible end of text? */
+      if (s[1]) t = s + 1;	/* pointer to true start of line */
+      else {
+	fs_give ((void **) &s);	/* free the line */
+	break;			/* end of data */
+      }
+    }
+    else t = s;			/* want the entire line */
+    if (f) {			/* copy it to the file */
+      i = strlen (t);		/* size of line */
+      if ((fwrite (t,(size_t) 1,(size_t) i,f) == i) &&
+	  (fwrite ("\015\012",(size_t) 1,(size_t) 2,f) == 2)) {
+	*size += i + 2;		/* tally up size of data */
+				/* note header position */
+	if (!i && hsiz && !*hsiz) *hsiz = *size;
+      }
+      else {
+	sprintf (tmp,"Error writing scratch file at byte %lu",*size);
+	MM_LOG (tmp,ERROR);
+	fclose (f);		/* forget it */
+	f = NIL;		/* failure now */
+      }
+    }
+    fs_give ((void **) &s);	/* free the line */
+  }
+				/* if making a file, rewind to start of file */
+  if (f) fseek (f,(unsigned long) 0,SEEK_SET);
+				/* header consumes entire message */
+  if (hsiz && !*hsiz) *hsiz = *size;
+  return f;			/* return the file descriptor */
+}
diff --git a/imap/src/c-client/netmsg.h b/imap/src/c-client/netmsg.h
new file mode 100644
index 00000000..bacff576
--- /dev/null
+++ b/imap/src/c-client/netmsg.h
@@ -0,0 +1,32 @@
+/* ========================================================================
+ * Copyright 1988-2006 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:	Network message (SMTP/NNTP/POP2/POP3) routines
+ *
+ * Author:	Mark Crispin
+ *		Networks and Distributed Computing
+ *		Computing & Communications
+ *		University of Washington
+ *		Administration Building, AG-44
+ *		Seattle, WA  98195
+ *		Internet: MRC@CAC.Washington.EDU
+ *
+ * Date:	8 June 1995
+ * Last Edited:	30 August 2006
+ */
+
+
+				/* stream must be void* for use as readfn_t */
+long netmsg_read (void *stream,unsigned long count,char *buffer);
+FILE *netmsg_slurp (NETSTREAM *stream,unsigned long *size,unsigned long *hsiz);
diff --git a/imap/src/c-client/newsrc.c b/imap/src/c-client/newsrc.c
new file mode 100644
index 00000000..41f1fd24
--- /dev/null
+++ b/imap/src/c-client/newsrc.c
@@ -0,0 +1,510 @@
+/* ========================================================================
+ * Copyright 1988-2006 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:	Newsrc manipulation routines
+ *
+ * Author:	Mark Crispin
+ *		Networks and Distributed Computing
+ *		Computing & Communications
+ *		University of Washington
+ *		Administration Building, AG-44
+ *		Seattle, WA  98195
+ *		Internet: MRC@CAC.Washington.EDU
+ *
+ * Date:	12 September 1994
+ * Last Edited:	30 August 2006
+ */
+
+
+#include <ctype.h>
+#include <stdio.h>
+#include "c-client.h"
+#include "newsrc.h"
+
+#ifndef OLDFILESUFFIX
+#define OLDFILESUFFIX ".old"
+#endif
+
+/* Error message
+ * Accepts: message format
+ *	    additional message string
+ *	    message level
+ * Returns: NIL, always
+ */
+
+long newsrc_error (char *fmt,char *text,long errflg)
+{
+  char tmp[MAILTMPLEN];
+  sprintf (tmp,fmt,text);
+  MM_LOG (tmp,errflg);
+  return NIL;
+}
+
+
+/* Write error message
+ * Accepts: newsrc name
+ *	    file designator
+ *	    file designator
+ * Returns: NIL, always
+ */
+
+long newsrc_write_error (char *name,FILE *f1,FILE *f2)
+{
+  if (f1) fclose (f1);		/* close file designators */
+  if (f2) fclose (f2);
+  return newsrc_error ("Error writing to %.80s",name,ERROR);
+}
+
+
+/* Create newsrc file in local form
+ * Accepts: MAIL stream
+ *	    notification flag
+ * Returns: file designator of newsrc
+ */
+
+FILE *newsrc_create (MAILSTREAM *stream,int notify)
+{
+  char *newsrc = (char *) mail_parameters (stream,GET_NEWSRC,stream);
+  FILE *f = fopen (newsrc,"wb");
+  if (!f) newsrc_error ("Unable to create news state %.80s",newsrc,ERROR);
+  else if (notify) newsrc_error ("Creating news state %.80s",newsrc,WARN);
+  return f;
+}
+
+/* Write new state in newsrc
+ * Accepts: file designator of newsrc
+ *	    group
+ *	    new subscription status character
+ *	    newline convention
+ * Returns: T if successful, NIL otherwise
+ */
+
+long newsrc_newstate (FILE *f,char *group,char state,char *nl)
+{
+  long ret = (f && (fputs (group,f) != EOF) && ((putc (state,f)) != EOF) &&
+	      ((putc (' ',f)) != EOF) && (fputs (nl,f) != EOF)) ? LONGT : NIL;
+  if (fclose (f) == EOF) ret = NIL;
+  return ret;
+}
+
+
+/* Write messages in newsrc
+ * Accepts: file designator of newsrc
+ *	    MAIL stream
+ *	    message number/newsgroup message map
+ *	    newline convention
+ * Returns: T if successful, NIL otherwise
+ */
+
+long newsrc_newmessages (FILE *f,MAILSTREAM *stream,char *nl)
+{
+  unsigned long i,j,k;
+  char tmp[MAILTMPLEN];
+  MESSAGECACHE *elt;
+  int c = ' ';
+  if (stream->nmsgs) {		/* have any messages? */
+    for (i = 1,j = k = (mail_elt (stream,i)->private.uid > 1) ? 1 : 0;
+	 i <= stream->nmsgs; ++i) {
+				/* deleted message? */
+      if ((elt = mail_elt (stream,i))->deleted) {
+	k = elt->private.uid;	/* this is the top of the current range */
+	if (!j) j = k;		/* if no range in progress, start one */
+      }
+      else if (j) {		/* unread message, ending a range */
+				/* calculate end of range */
+	if (k = elt->private.uid - 1) {
+				/* dump range */
+	  sprintf (tmp,(j == k) ? "%c%ld" : "%c%ld-%ld",c,j,k);
+	  if (fputs (tmp,f) == EOF) return NIL;
+	  c = ',';		/* need a comma after the first time */
+	}
+	j = 0;			/* no more range in progress */
+      }
+    }
+    if (j) {			/* dump trailing range */
+      sprintf (tmp,(j == k) ? "%c%ld" : "%c%ld-%ld",c,j,k);
+      if (fputs (tmp,f) == EOF) return NIL;
+    }
+  }
+				/* write trailing newline, return */
+  return (fputs (nl,f) == EOF) ? NIL : LONGT;
+}
+
+/* List subscribed newsgroups
+ * Accepts: MAIL stream
+ *	    prefix to append name
+ * 	    pattern to search
+ */
+
+void newsrc_lsub (MAILSTREAM *stream,char *pattern)
+{
+  char *s,*t,*lcl,name[MAILTMPLEN];
+  int c = ' ';
+  int showuppers = pattern[strlen (pattern) - 1] == '%';
+  FILE *f = fopen ((char *) mail_parameters (stream,GET_NEWSRC,stream),"rb");
+  if (f) {			/* got file? */
+				/* remote name? */
+    if (*(lcl = strcpy (name,pattern)) == '{') lcl = strchr (lcl,'}') + 1;
+    if (*lcl == '#') lcl += 6;	/* namespace format name? */
+    while (c != EOF) {		/* yes, read newsrc */
+      for (s = lcl; (s < (name + MAILTMPLEN - 1)) && ((c = getc (f)) != EOF) &&
+	   (c != ':') && (c != '!') && (c != '\015') && (c != '\012');
+	   *s++ = c);
+      if (c == ':') {		/* found a subscribed newsgroup? */
+	*s = '\0';		/* yes, tie off name */
+				/* report if match */
+	if (pmatch_full (name,pattern,'.')) mm_lsub (stream,'.',name,NIL);
+	else while (showuppers && (t = strrchr (lcl,'.'))) {
+	  *t = '\0';		/* tie off the name */
+	  if (pmatch_full (name,pattern,'.'))
+	    mm_lsub (stream,'.',name,LATT_NOSELECT);
+	}
+      }
+      while ((c != '\015') && (c != '\012') && (c != EOF)) c = getc (f);
+    }
+    fclose (f);
+  }
+}
+
+/* Update subscription status of newsrc
+ * Accepts: MAIL stream
+ * 	    group
+ *	    new subscription status character
+ * Returns: T if successful, NIL otherwise
+ */
+
+long newsrc_update (MAILSTREAM *stream,char *group,char state)
+{
+  char tmp[MAILTMPLEN];
+  char *newsrc = (char *) mail_parameters (stream,GET_NEWSRC,stream);
+  long ret = NIL;
+  FILE *f = fopen (newsrc,"r+b");
+  if (f) {			/* update existing file */
+    int c = 0;
+    char *s,nl[3];
+    long pos = 0;
+    nl[0] = nl[1] = nl[2]='\0';	/* no newline known yet */
+    do {			/* read newsrc */
+      for (s = tmp; (s < (tmp + MAILTMPLEN - 1)) && ((c = getc (f)) != EOF) &&
+	   (c != ':') && (c != '!') && (c != '\015') && (c != '\012');
+	   *s++ = c) pos = ftell (f);
+      *s = '\0';		/* tie off name */
+				/* found the newsgroup? */
+      if (((c == ':') || (c == '!')) && !strcmp (tmp,group)) {
+	if (c == state) {	/* already at that state? */
+	  if (c == ':') newsrc_error("Already subscribed to %.80s",group,WARN);
+	  ret = LONGT;		/* noop the update */
+	}
+				/* write the character */
+	else if (!fseek (f,pos,0)) ret = ((putc (state,f)) == EOF) ? NIL:LONGT;
+	if (fclose (f) == EOF) ret = NIL;
+	f = NIL;		/* done with file */
+	break;
+      }
+				/* gobble remainder of this line */
+      while ((c != '\015') && (c != '\012') && (c != EOF)) c = getc (f);
+				/* need to know about newlines and found it? */
+      if (!nl[0] && ((c == '\015') || (c == '\012')) && ((nl[0]=c) == '\015')){
+				/* sniff and see if an LF */
+	if ((c = getc (f)) == '\012') nl[1] = c;
+	else ungetc (c,f);	/* nope, push it back */
+      }
+    } while (c != EOF);
+
+    if (f) {			/* still haven't written it yet? */
+      if (nl[0]) {		/* know its newline convention? */
+	fseek (f,0L,2);		/* yes, seek to end of file */
+	ret = newsrc_newstate (f,group,state,nl);
+      }
+      else {			/* can't find a newline convention */
+	fclose (f);		/* punt the file */
+				/* can't win if read something */
+	if (pos) newsrc_error ("Unknown newline convention in %.80s",
+			       newsrc,ERROR);
+				/* file must have been empty, rewrite it */
+	else ret = newsrc_newstate(newsrc_create(stream,NIL),group,state,"\n");
+      }
+    }
+  }
+				/* create new file */
+  else ret = newsrc_newstate (newsrc_create (stream,T),group,state,"\n");
+  return ret;			/* return with update status */
+}
+
+/* Update newsgroup status in stream
+ * Accepts: newsgroup name
+ *	    MAIL stream
+ * Returns: number of recent messages
+ */
+
+long newsrc_read (char *group,MAILSTREAM *stream)
+{
+  int c = 0;
+  char *s,tmp[MAILTMPLEN];
+  unsigned long i,j;
+  MESSAGECACHE *elt;
+  unsigned long m = 1,recent = 0,unseen = 0;
+  FILE *f = fopen ((char *) mail_parameters (stream,GET_NEWSRC,stream),"rb");
+  if (f) do {			/* read newsrc */
+    for (s = tmp; (s < (tmp + MAILTMPLEN - 1)) && ((c = getc (f)) != EOF) &&
+	 (c != ':') && (c != '!') && (c != '\015') && (c != '\012'); *s++ = c);
+    *s = '\0';			/* tie off name */
+    if ((c==':') || (c=='!')) {	/* found newsgroup? */
+      if (strcmp (tmp,group))	/* group name match? */
+	while ((c != '\015') && (c != '\012') && (c != EOF)) c = getc (f);
+      else {			/* yes, skip leading whitespace */
+	while ((c = getc (f)) == ' ');
+				/* only if unprocessed messages */
+	if (stream->nmsgs) while (f && (m <= stream->nmsgs)) {
+				/* collect a number */
+	  if (isdigit (c)) {	/* better have a number */
+	    for (i = 0,j = 0; isdigit (c); c = getc (f)) i = i*10 + (c-'0');
+	    if (c == '-') for (c = getc (f); isdigit (c); c = getc (f))
+	      j = j*10 +(c-'0');/* collect second value if range */
+	    if (!unseen && (mail_elt (stream,m)->private.uid < i)) unseen = m;
+				/* skip messages before first value */
+	    while ((m <= stream->nmsgs) &&
+		   ((elt = mail_elt (stream,m))->private.uid < i) && m++)
+	      elt->valid = T;
+				/* do all messages in range */
+	    while ((m <= stream->nmsgs) && (elt = mail_elt (stream,m)) &&
+		   (j ? ((elt->private.uid >= i) && (elt->private.uid <= j)) :
+		    (elt->private.uid == i)) && m++)
+	      elt->valid = elt->deleted = T;
+	  }
+
+	  switch (c) {		/* what is the delimiter? */
+	  case ',':		/* more to come */
+	    c = getc (f);	/* get first character of number */
+	    break;
+	  default:		/* bogus character */
+	    sprintf (tmp,"Bogus character 0x%x in news state",(unsigned int)c);
+	    MM_LOG (tmp,ERROR);
+	  case EOF: case '\015': case '\012':
+	    fclose (f);		/* all done - close the file */
+	    f = NIL;
+	    break;
+	  }
+	}
+	else {			/* empty newsgroup */
+	  while ((c != '\015') && (c != '\012') && (c != EOF)) c = getc (f);
+	  fclose (f);		/* all done - close the file */
+	  f = NIL;
+	}
+      }
+    }
+  } while (f && (c != EOF));	/* until file closed or EOF */
+  if (f) {			/* still have file open? */
+    sprintf (tmp,"No state for newsgroup %.80s found, reading as new",group);
+    MM_LOG (tmp,WARN);
+    fclose (f);			/* close the file */
+  }
+  if (m <= stream->nmsgs) {	/* any messages beyond newsrc range? */
+    if (!unseen) unseen = m;	/* then this must be the first unseen one */
+    do {
+      elt = mail_elt (stream,m++);
+      elt->valid = elt->recent = T;
+      ++recent;			/* count another recent message */
+    }
+    while (m <= stream->nmsgs);
+  }
+  if (unseen) {			/* report first unseen message */
+    sprintf (tmp,"[UNSEEN] %lu is first unseen message in %.80s",unseen,group);
+    MM_NOTIFY (stream,tmp,(long) NIL);
+  }
+  return recent;
+}
+
+/* Update newsgroup entry in newsrc
+ * Accepts: newsgroup name
+ *	    MAIL stream
+ * Returns: T if successful, NIL otherwise
+ */
+
+long newsrc_write (char *group,MAILSTREAM *stream)
+{
+  long ret = NIL;
+  int c = 0,d = EOF;
+  char *newsrc = (char *) mail_parameters (stream,GET_NEWSRC,stream);
+  char *s,tmp[MAILTMPLEN],backup[MAILTMPLEN],nl[3];
+  FILE *f,*bf;
+  nl[0] = nl[1] = nl[2] = '\0';	/* no newline known yet */
+  if (f = fopen (newsrc,"rb")) {/* have existing newsrc file? */
+    if (!(bf = fopen ((strcat (strcpy (backup,newsrc),OLDFILESUFFIX)),"wb"))) {
+      fclose (f);		/* punt input file */
+      return newsrc_error("Can't create backup news state %.80s",backup,ERROR);
+    }
+				/* copy to backup file */
+    while ((c = getc (f)) != EOF) {
+				/* need to know about newlines and found it? */
+      if (!nl[0] && ((c == '\015') || (c == '\012')) && ((nl[0]=c) == '\015')){
+				/* sniff and see if an LF */
+	if ((c = getc (f)) == '\012') nl[1] = c;
+	ungetc (c,f);		/* push it back */
+      }
+				/* write to backup file */
+      if ((d = putc (c,bf)) == EOF) {
+	fclose (f);		/* punt input file */
+	return newsrc_error ("Error writing backup news state %.80s",
+			     newsrc,ERROR);
+      }
+    }
+    fclose (f);			/* close existing file */
+    if (fclose (bf) == EOF)	/* and backup file */
+      return newsrc_error ("Error closing backup news state %.80s",
+			   newsrc,ERROR);
+    if (d == EOF) {		/* open for write if empty file */
+      if (f = newsrc_create (stream,NIL)) bf = NIL;
+      else return NIL;
+    }
+    else if (!nl[0])		/* make sure newlines valid */
+      return newsrc_error ("Unknown newline convention in %.80s",newsrc,ERROR);
+				/* now read backup file */
+    else if (!(bf = fopen (backup,"rb")))
+      return newsrc_error ("Error reading backup news state %.80s",
+			   backup,ERROR);
+				/* open newsrc for writing */
+    else if (!(f = fopen (newsrc,"wb"))) {
+      fclose (bf);		/* punt backup */
+      return newsrc_error ("Can't rewrite news state %.80s",newsrc,ERROR);
+    }
+  }
+  else {			/* create new newsrc file */
+    if (f = newsrc_create (stream,T)) bf = NIL;
+    else return NIL;		/* can't create newsrc */
+  }
+  
+  while (bf) {			/* read newsrc */
+    for (s = tmp; (s < (tmp + MAILTMPLEN - 1)) && ((c = getc (bf)) != EOF) &&
+	 (c != ':') && (c != '!') && (c != '\015') && (c != '\012'); *s++ = c);
+    *s = '\0';			/* tie off name */
+				/* saw correct end of group delimiter? */
+    if (tmp[0] && ((c == ':') || (c == '!'))) {
+				/* yes, write newsgroup name and delimiter */
+      if ((tmp[0] && (fputs (tmp,f) == EOF)) || ((putc (c,f)) == EOF))
+	return newsrc_write_error (newsrc,bf,f);
+      if (!strcmp (tmp,group)) {/* found correct group? */
+				/* yes, write new status */
+	if (!newsrc_newmessages (f,stream,nl[0] ? nl : "\n"))
+	  return newsrc_write_error (newsrc,bf,f);
+				/* skip past old data */
+	while (((c = getc (bf)) != EOF) && (c != '\015') && (c != '\012'));
+				/* skip past newline */
+	while ((c == '\015') || (c == '\012')) c = getc (bf);
+	while (c != EOF) {	/* copy remainder of file */
+	  if (putc (c,f) == EOF) return newsrc_write_error (newsrc,bf,f);
+	  c = getc (bf);	/* get next character */
+	}
+				/* done with file */
+	if (fclose (f) == EOF) return newsrc_write_error (newsrc,bf,NIL);
+	f = NIL;
+      }
+				/* copy remainder of line */
+      else while (((c = getc (bf)) != EOF) && (c != '\015') && (c != '\012'))
+	if (putc (c,f) == EOF) return newsrc_write_error (newsrc,bf,f);
+      if (c == '\015') {	/* write CR if seen */
+	if (putc (c,f) == EOF) return newsrc_write_error (newsrc,bf,f);
+				/* sniff to see if LF */
+	if (((c = getc (bf)) != EOF) && (c != '\012')) ungetc (c,bf);
+      }
+				/* write LF if seen */
+      if ((c == '\012') && (putc (c,f) == EOF))
+	return newsrc_write_error (newsrc,bf,f);
+    }
+    if (c == EOF) {		/* hit end of file? */
+      fclose (bf);		/* yup, close the file */
+      bf = NIL;
+    }
+  }
+  if (f) {			/* still have newsrc file open? */
+    ret = ((fputs (group,f) != EOF) && ((putc (':',f)) != EOF) &&
+	   newsrc_newmessages (f,stream,nl[0] ? nl : "\n")) ? LONGT : NIL;
+    if (fclose (f) == EOF) ret = newsrc_write_error (newsrc,NIL,NIL);
+  }
+  else ret = LONGT;
+  return ret;
+}
+
+/* Get newsgroup state as text stream
+ * Accepts: MAIL stream
+ *	    newsgroup name
+ * Returns: string containing newsgroup state, or NIL if not found
+ */
+
+char *newsrc_state (MAILSTREAM *stream,char *group)
+{
+  int c = 0;
+  char *s,tmp[MAILTMPLEN];
+  long pos;
+  size_t size;
+  FILE *f = fopen ((char *) mail_parameters (stream,GET_NEWSRC,stream),"rb");
+  if (f) do {			/* read newsrc */
+    for (s = tmp; (s < (tmp + MAILTMPLEN - 1)) && ((c = getc (f)) != EOF) &&
+	 (c != ':') && (c != '!') && (c != '\015') && (c != '\012'); *s++ = c);
+    *s = '\0';			/* tie off name */
+    if ((c==':') || (c=='!')) {	/* found newsgroup? */
+      if (strcmp (tmp,group))	/* group name match? */
+	while ((c != '\015') && (c != '\012') && (c != EOF)) c = getc (f);
+      else {			/* yes, skip leading whitespace */
+	do pos = ftell (f);
+	while ((c = getc (f)) == ' ');
+				/* count characters in state */
+	for (size = 0; (c != '\015') && (c != '\012') && (c != EOF); size++)
+	  c = getc (f);
+				/* now copy it */
+	s = (char *) fs_get (size + 1);
+	fseek (f,pos,SEEK_SET);
+	fread (s,(size_t) 1,size,f);
+	s[size] = '\0';		/* tie off string */
+	fclose (f);		/* all done - close the file */
+	return s;
+      }
+    }
+  } while (f && (c != EOF));	/* until file closed or EOF */
+  sprintf (tmp,"No state for newsgroup %.80s found",group);
+  MM_LOG (tmp,WARN);
+  if (f) fclose (f);		/* close the file */
+  return NIL;			/* not found return */
+}
+
+/* Check UID in newsgroup state
+ * Accepts: newsgroup state string
+ *	    uid
+ *	    returned recent count
+ *	    returned unseen count
+ */
+
+void newsrc_check_uid (unsigned char *state,unsigned long uid,
+		       unsigned long *recent,unsigned long *unseen)
+{
+  unsigned long i,j;
+  while (*state) {		/* until run out of state string */
+				/* collect a number */
+    for (i = 0; isdigit (*state); i = i*10 + (*state++ - '0'));
+    if (*state != '-') j = i;	/* coerce single mesage into range */
+    else {			/* have a range */
+      for (j = 0; isdigit (*++state); j = j*10 + (*state - '0'));
+      if (!j) j = i;		/* guard against -0 */
+      if (j < i) return;	/* bogon if end less than start */
+    }
+    if (*state == ',') state++;	/* skip past comma */
+    else if (*state) return;	/* otherwise it's a bogon */
+    if (uid <= j) {		/* covered by upper bound? */
+      if (uid < i) ++*unseen;	/* unseen if not covered by lower bound */
+      return;			/* don't need to look further */
+    }
+  }
+  ++*unseen;			/* not found in any range, message is unseen */
+  ++*recent;			/* and recent */
+}
diff --git a/imap/src/c-client/newsrc.h b/imap/src/c-client/newsrc.h
new file mode 100644
index 00000000..578f656d
--- /dev/null
+++ b/imap/src/c-client/newsrc.h
@@ -0,0 +1,43 @@
+/* ========================================================================
+ * Copyright 1988-2006 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:	Newsrc manipulation routines
+ *
+ * Author:	Mark Crispin
+ *		Networks and Distributed Computing
+ *		Computing & Communications
+ *		University of Washington
+ *		Administration Building, AG-44
+ *		Seattle, WA  98195
+ *		Internet: MRC@CAC.Washington.EDU
+ *
+ * Date:	12 September 1994
+ * Last Edited:	30 August 2006
+ */
+
+
+/* Function prototypes */
+
+long newsrc_error (char *fmt,char *text,long errflg);
+long newsrc_write_error (char *name,FILE *f1,FILE *f2);
+FILE *newsrc_create (MAILSTREAM *stream,int notify);
+long newsrc_newstate (FILE *f,char *group,char state,char *nl);
+long newsrc_newmessages (FILE *f,MAILSTREAM *stream,char *nl);
+void newsrc_lsub (MAILSTREAM *stream,char *pattern);
+long newsrc_update (MAILSTREAM *stream,char *group,char state);
+long newsrc_read (char *group,MAILSTREAM *stream);
+long newsrc_write (char *group,MAILSTREAM *stream);
+char *newsrc_state (MAILSTREAM *stream,char *group);
+void newsrc_check_uid (unsigned char *state,unsigned long uid,
+		       unsigned long *recent,unsigned long *unseen);
diff --git a/imap/src/c-client/nl.h b/imap/src/c-client/nl.h
new file mode 100644
index 00000000..520e9f7e
--- /dev/null
+++ b/imap/src/c-client/nl.h
@@ -0,0 +1,34 @@
+/* ========================================================================
+ * Copyright 1988-2006 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:	Newline routines
+ *
+ * Author:	Mark Crispin
+ *		Networks and Distributed Computing
+ *		Computing & Communications
+ *		University of Washington
+ *		Administration Building, AG-44
+ *		Seattle, WA  98195
+ *		Internet: MRC@CAC.Washington.EDU
+ *
+ * Date:	1 August 1988
+ * Last Edited:	30 August 2006
+ */
+
+
+/* Function prototypes */
+
+unsigned long strcrlfcpy (unsigned char **dst,unsigned long *dstl,
+			  unsigned char *src,unsigned long srcl);
+unsigned long strcrlflen (STRING *s);
diff --git a/imap/src/c-client/nntp.c b/imap/src/c-client/nntp.c
new file mode 100644
index 00000000..fe90edba
--- /dev/null
+++ b/imap/src/c-client/nntp.c
@@ -0,0 +1,2224 @@
+/* ========================================================================
+ * Copyright 1988-2007 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:	Network News Transfer Protocol (NNTP) routines
+ *
+ * Author:	Mark Crispin
+ *		Networks and Distributed Computing
+ *		Computing & Communications
+ *		University of Washington
+ *		Administration Building, AG-44
+ *		Seattle, WA  98195
+ *		Internet: MRC@CAC.Washington.EDU
+ *
+ * Date:	10 February 1992
+ * Last Edited:	6 September 2007
+ */
+
+
+#include <ctype.h>
+#include <stdio.h>
+#include "c-client.h"
+#include "newsrc.h"
+#include "netmsg.h"
+#include "flstring.h"
+
+/* Constants */
+
+#define NNTPSSLPORT (long) 563	/* assigned SSL TCP contact port */
+#define NNTPGREET (long) 200	/* NNTP successful greeting */
+				/* NNTP successful greeting w/o posting priv */
+#define NNTPGREETNOPOST (long) 201
+#define NNTPEXTOK (long) 202	/* NNTP extensions OK */
+#define NNTPGOK (long) 211	/* NNTP group selection OK */
+#define NNTPGLIST (long) 215	/* NNTP group list being returned */
+#define NNTPARTICLE (long) 220	/* NNTP article file */
+#define NNTPHEAD (long) 221	/* NNTP header text */
+#define NNTPBODY (long) 222	/* NNTP body text */
+#define NNTPOVER (long) 224	/* NNTP overview text */
+#define NNTPOK (long) 240	/* NNTP OK code */
+#define NNTPAUTHED (long) 281	/* NNTP successful authentication */
+				/* NNTP successful authentication with data */
+#define NNTPAUTHEDDATA (long) 282
+#define NNTPREADY (long) 340	/* NNTP ready for data */
+#define NNTPWANTAUTH2 (long) 380/* NNTP authentication needed (old) */
+#define NNTPWANTPASS (long) 381	/* NNTP password needed */
+#define NNTPTLSSTART (long) 382	/* NNTP continue with TLS negotiation */
+#define NNTPCHALLENGE (long) 383/* NNTP challenge, want response */
+#define NNTPSOFTFATAL (long) 400/* NNTP soft fatal code */
+#define NNTPWANTAUTH (long) 480	/* NNTP authentication needed */
+#define NNTPBADCMD (long) 500	/* NNTP unrecognized command */
+#define IDLETIMEOUT (long) 3	/* defined in NNTPEXT WG base draft */
+
+
+/* NNTP I/O stream local data */
+	
+typedef struct nntp_local {
+  SENDSTREAM *nntpstream;	/* NNTP stream for I/O */
+  unsigned int dirty : 1;	/* disk copy of .newsrc needs updating */
+  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 xover : 1;	/* supports XOVER */
+  unsigned int xhdr : 1;	/* supports XHDR */
+  char *name;			/* remote newsgroup name */
+  char *user;			/* mailbox user */
+  char *newsrc;			/* newsrc file */
+  char *over_fmt;		/* overview format */
+  unsigned long msgno;		/* current text message number */
+  FILE *txt;			/* current text */
+  unsigned long txtsize;	/* current text size */
+} NNTPLOCAL;
+
+
+/* Convenient access to local data */
+
+#define LOCAL ((NNTPLOCAL *) stream->local)
+
+
+/* Convenient access to protocol-specific data */
+
+#define NNTP stream->protocol.nntp
+
+
+/* Convenient access to extensions */
+
+#define EXTENSION LOCAL->nntpstream->protocol.nntp.ext
+
+/* Function prototypes */
+
+DRIVER *nntp_valid (char *name);
+DRIVER *nntp_isvalid (char *name,char *mbx);
+void *nntp_parameters (long function,void *value);
+void nntp_scan (MAILSTREAM *stream,char *ref,char *pat,char *contents);
+void nntp_list (MAILSTREAM *stream,char *ref,char *pat);
+void nntp_lsub (MAILSTREAM *stream,char *ref,char *pat);
+long nntp_canonicalize (char *ref,char *pat,char *pattern,char *wildmat);
+long nntp_subscribe (MAILSTREAM *stream,char *mailbox);
+long nntp_unsubscribe (MAILSTREAM *stream,char *mailbox);
+long nntp_create (MAILSTREAM *stream,char *mailbox);
+long nntp_delete (MAILSTREAM *stream,char *mailbox);
+long nntp_rename (MAILSTREAM *stream,char *old,char *newname);
+long nntp_status (MAILSTREAM *stream,char *mbx,long flags);
+long nntp_getmap (MAILSTREAM *stream,char *name,
+		  unsigned long first,unsigned long last,
+		  unsigned long rnmsgs,unsigned long nmsgs,char *tmp);
+MAILSTREAM *nntp_mopen (MAILSTREAM *stream);
+void nntp_mclose (MAILSTREAM *stream,long options);
+void nntp_fetchfast (MAILSTREAM *stream,char *sequence,long flags);
+void nntp_flags (MAILSTREAM *stream,char *sequence,long flags);
+long nntp_overview (MAILSTREAM *stream,overview_t ofn);
+long nntp_parse_overview (OVERVIEW *ov,char *text,MESSAGECACHE *elt);
+long nntp_over (MAILSTREAM *stream,char *sequence);
+char *nntp_header (MAILSTREAM *stream,unsigned long msgno,unsigned long *size,
+		   long flags);
+long nntp_text (MAILSTREAM *stream,unsigned long msgno,STRING *bs,long flags);
+FILE *nntp_article (MAILSTREAM *stream,char *msgid,unsigned long *size,
+		    unsigned long *hsiz);
+void nntp_flagmsg (MAILSTREAM *stream,MESSAGECACHE *elt);
+long nntp_search (MAILSTREAM *stream,char *charset,SEARCHPGM *pgm,long flags);
+long nntp_search_msg (MAILSTREAM *stream,unsigned long msgno,SEARCHPGM *pgm,
+		      OVERVIEW *ov);
+unsigned long *nntp_sort (MAILSTREAM *stream,char *charset,SEARCHPGM *spg,
+			  SORTPGM *pgm,long flags);
+SORTCACHE **nntp_sort_loadcache (MAILSTREAM *stream,SORTPGM *pgm,
+				 unsigned long start,unsigned long last,
+				 long flags);
+THREADNODE *nntp_thread (MAILSTREAM *stream,char *type,char *charset,
+			 SEARCHPGM *spg,long flags);
+long nntp_ping (MAILSTREAM *stream);
+void nntp_check (MAILSTREAM *stream);
+long nntp_expunge (MAILSTREAM *stream,char *sequence,long options);
+long nntp_copy (MAILSTREAM *stream,char *sequence,char *mailbox,long options);
+long nntp_append (MAILSTREAM *stream,char *mailbox,append_t af,void *data);
+
+long nntp_extensions (SENDSTREAM *stream,long flags);
+long nntp_send (SENDSTREAM *stream,char *command,char *args);
+long nntp_send_work (SENDSTREAM *stream,char *command,char *args);
+long nntp_send_auth (SENDSTREAM *stream,long flags);
+long nntp_send_auth_work (SENDSTREAM *stream,NETMBX *mb,char *pwd,long flags);
+void *nntp_challenge (void *s,unsigned long *len);
+long nntp_response (void *s,char *response,unsigned long size);
+long nntp_reply (SENDSTREAM *stream);
+long nntp_fake (SENDSTREAM *stream,char *text);
+long nntp_soutr (void *stream,char *s);
+
+/* Driver dispatch used by MAIL */
+
+DRIVER nntpdriver = {
+  "nntp",			/* driver name */
+				/* driver flags */
+#ifdef INADEQUATE_MEMORY
+  DR_LOWMEM |
+#endif
+  DR_NEWS|DR_READONLY|DR_NOFAST|DR_NAMESPACE|DR_CRLF|DR_RECYCLE|DR_XPOINT |
+    DR_NOINTDATE|DR_NONEWMAIL|DR_HALFOPEN,
+  (DRIVER *) NIL,		/* next driver */
+  nntp_valid,			/* mailbox is valid for us */
+  nntp_parameters,		/* manipulate parameters */
+  nntp_scan,			/* scan mailboxes */
+  nntp_list,			/* find mailboxes */
+  nntp_lsub,			/* find subscribed mailboxes */
+  nntp_subscribe,		/* subscribe to mailbox */
+  nntp_unsubscribe,		/* unsubscribe from mailbox */
+  nntp_create,			/* create mailbox */
+  nntp_delete,			/* delete mailbox */
+  nntp_rename,			/* rename mailbox */
+  nntp_status,			/* status of mailbox */
+  nntp_mopen,			/* open mailbox */
+  nntp_mclose,			/* close mailbox */
+  nntp_fetchfast,		/* fetch message "fast" attributes */
+  nntp_flags,			/* fetch message flags */
+  nntp_overview,		/* fetch overview */
+  NIL,				/* fetch message structure */
+  nntp_header,			/* fetch message header */
+  nntp_text,			/* fetch message text */
+  NIL,				/* fetch message */
+  NIL,				/* unique identifier */
+  NIL,				/* message number from UID */
+  NIL,				/* modify flags */
+  nntp_flagmsg,			/* per-message modify flags */
+  nntp_search,			/* search for message based on criteria */
+  nntp_sort,			/* sort messages */
+  nntp_thread,			/* thread messages */
+  nntp_ping,			/* ping mailbox to see if still alive */
+  nntp_check,			/* check for new messages */
+  nntp_expunge,			/* expunge deleted messages */
+  nntp_copy,			/* copy messages to another mailbox */
+  nntp_append,			/* append string message to mailbox */
+  NIL				/* garbage collect stream */
+};
+
+				/* prototype stream */
+MAILSTREAM nntpproto = {&nntpdriver};
+
+
+				/* driver parameters */
+static unsigned long nntp_maxlogintrials = MAXLOGINTRIALS;
+static long nntp_port = 0;
+static long nntp_sslport = 0;
+static unsigned long nntp_range = 0;
+static long nntp_hidepath = 0;
+
+/* NNTP validate mailbox
+ * Accepts: mailbox name
+ * Returns: our driver if name is valid, NIL otherwise
+ */
+
+DRIVER *nntp_valid (char *name)
+{
+  char tmp[MAILTMPLEN];
+  return nntp_isvalid (name,tmp);
+}
+
+
+/* NNTP validate mailbox work routine
+ * Accepts: mailbox name
+ *	    buffer for returned mailbox name
+ * Returns: our driver if name is valid, NIL otherwise
+ */
+
+DRIVER *nntp_isvalid (char *name,char *mbx)
+{
+  NETMBX mb;
+  if (!mail_valid_net_parse (name,&mb) || strcmp (mb.service,nntpdriver.name)||
+      mb.anoflag) return NIL;
+  if (mb.mailbox[0] != '#') strcpy (mbx,mb.mailbox);
+			/* namespace format name */
+  else if ((mb.mailbox[1] == 'n') && (mb.mailbox[2] == 'e') &&
+	   (mb.mailbox[3] == 'w') && (mb.mailbox[4] == 's') &&
+	   (mb.mailbox[5] == '.')) strcpy (mbx,mb.mailbox+6);
+  else return NIL;		/* bogus name */
+  return &nntpdriver;
+}
+
+/* News manipulate driver parameters
+ * Accepts: function code
+ *	    function-dependent value
+ * Returns: function-dependent return value
+ */
+
+void *nntp_parameters (long function,void *value)
+{
+  switch ((int) function) {
+  case SET_MAXLOGINTRIALS:
+    nntp_maxlogintrials = (unsigned long) value;
+    break;
+  case GET_MAXLOGINTRIALS:
+    value = (void *) nntp_maxlogintrials;
+    break;
+  case SET_NNTPPORT:
+    nntp_port = (long) value;
+    break;
+  case GET_NNTPPORT:
+    value = (void *) nntp_port;
+    break;
+  case SET_SSLNNTPPORT:
+    nntp_sslport = (long) value;
+    break;
+  case GET_SSLNNTPPORT:
+    value = (void *) nntp_sslport;
+    break;
+  case SET_NNTPRANGE:
+    nntp_range = (unsigned long) value;
+    break;
+  case GET_NNTPRANGE:
+    value = (void *) nntp_range;
+    break;
+  case SET_NNTPHIDEPATH:
+    nntp_hidepath = (long) value;
+    break;
+  case GET_NNTPHIDEPATH:
+    value = (void *) nntp_hidepath;
+    break;
+  case GET_NEWSRC:
+    if (value)
+      value = (void *) ((NNTPLOCAL *) ((MAILSTREAM *) value)->local)->newsrc;
+    break;
+  case GET_IDLETIMEOUT:
+    value = (void *) IDLETIMEOUT;
+    break;
+  case ENABLE_DEBUG:
+    if (value)
+      ((NNTPLOCAL *) ((MAILSTREAM *) value)->local)->nntpstream->debug = T;
+    break;
+  case DISABLE_DEBUG:
+    if (value)
+      ((NNTPLOCAL *) ((MAILSTREAM *) value)->local)->nntpstream->debug = NIL;
+    break;
+  default:
+    value = NIL;		/* error case */
+    break;
+  }
+  return value;
+}
+
+/* NNTP mail scan mailboxes for string
+ * Accepts: mail stream
+ *	    reference
+ *	    pattern to search
+ *	    string to scan
+ */
+
+void nntp_scan (MAILSTREAM *stream,char *ref,char *pat,char *contents)
+{
+  char tmp[MAILTMPLEN];
+  if (nntp_canonicalize (ref,pat,tmp,NIL))
+    mm_log ("Scan not valid for NNTP mailboxes",ERROR);
+}
+
+
+/* NNTP list newsgroups
+ * Accepts: mail stream
+ *	    reference
+ *	    pattern to search
+ */
+
+void nntp_list (MAILSTREAM *stream,char *ref,char *pat)
+{
+  MAILSTREAM *st = stream;
+  char *s,*t,*lcl,pattern[MAILTMPLEN],name[MAILTMPLEN],wildmat[MAILTMPLEN];
+  int showuppers = pat[strlen (pat) - 1] == '%';
+  if (!*pat) {
+    if (nntp_canonicalize (ref,"*",pattern,NIL)) {
+				/* tie off name at root */
+      if ((s = strchr (pattern,'}')) && (s = strchr (s+1,'.'))) *++s = '\0';
+      else pattern[0] = '\0';
+      mm_list (stream,'.',pattern,NIL);
+    }
+  }
+				/* ask server for open newsgroups */
+  else if (nntp_canonicalize (ref,pat,pattern,wildmat) &&
+	   ((stream && LOCAL && LOCAL->nntpstream) ||
+	    (stream = mail_open (NIL,pattern,OP_HALFOPEN|OP_SILENT))) &&
+	   ((nntp_send (LOCAL->nntpstream,"LIST ACTIVE",
+			wildmat[0] ? wildmat : NIL) == NNTPGLIST) ||
+	    (nntp_send (LOCAL->nntpstream,"LIST",NIL) == NNTPGLIST))) {
+				/* namespace format name? */
+    if (*(lcl = strchr (strcpy (name,pattern),'}') + 1) == '#') lcl += 6;
+				/* process data until we see final dot */
+    while (s = net_getline (LOCAL->nntpstream->netstream)) {
+      if ((*s == '.') && !s[1]){/* end of text */
+	fs_give ((void **) &s);
+	break;
+      }
+      if (t = strchr (s,' ')) {	/* tie off after newsgroup name */
+	*t = '\0';
+	strcpy (lcl,s);		/* make full form of name */
+				/* report if match */
+	if (pmatch_full (name,pattern,'.')) mm_list (stream,'.',name,NIL);
+	else while (showuppers && (t = strrchr (lcl,'.'))) {
+	  *t = '\0';		/* tie off the name */
+	  if (pmatch_full (name,pattern,'.'))
+	    mm_list (stream,'.',name,LATT_NOSELECT);
+	}
+      }
+      fs_give ((void **) &s);	/* clean up */
+    }
+    if (stream != st) mail_close (stream);
+  }
+}
+
+/* NNTP list subscribed newsgroups
+ * Accepts: mail stream
+ *	    reference
+ *	    pattern to search
+ */
+
+void nntp_lsub (MAILSTREAM *stream,char *ref,char *pat)
+{
+  void *sdb = NIL;
+  char *s,mbx[MAILTMPLEN];
+				/* return data from newsrc */
+  if (nntp_canonicalize (ref,pat,mbx,NIL)) newsrc_lsub (stream,mbx);
+  if (*pat == '{') {		/* if remote pattern, must be NNTP */
+    if (!nntp_valid (pat)) return;
+    ref = NIL;			/* good NNTP pattern, punt reference */
+  }
+				/* if remote reference, must be valid NNTP */
+  if (ref && (*ref == '{') && !nntp_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 (nntp_valid (s) && pmatch (s,mbx))
+    mm_lsub (stream,NIL,s,NIL);
+  while (s = sm_read (&sdb));	/* until no more subscriptions */
+}
+
+/* NNTP canonicalize newsgroup name
+ * Accepts: reference
+ *	    pattern
+ *	    returned single pattern
+ *	    returned wildmat pattern
+ * Returns: T on success, NIL on failure
+ */
+
+long nntp_canonicalize (char *ref,char *pat,char *pattern,char *wildmat)
+{
+  char *s;
+  DRIVER *ret;
+  if (ref && *ref) {		/* have a reference */
+    if (!nntp_valid (ref)) return NIL;
+    strcpy (pattern,ref);	/* copy reference to pattern */
+				/* # overrides mailbox field in reference */
+    if (*pat == '#') strcpy (strchr (pattern,'}') + 1,pat);
+				/* pattern starts, reference ends, with . */
+    else if ((*pat == '.') && (pattern[strlen (pattern) - 1] == '.'))
+      strcat (pattern,pat + 1);	/* append, omitting one of the period */
+    else strcat (pattern,pat);	/* anything else is just appended */
+  }
+  else strcpy (pattern,pat);	/* just have basic name */
+  if ((ret = wildmat ?		/* if valid and wildmat */
+       nntp_isvalid (pattern,wildmat) : nntp_valid (pattern)) && wildmat) {
+				/* don't return wildmat if specials present */
+    if (strpbrk (wildmat,",?![\\]")) wildmat[0] = '\0';
+				/* replace all % with * */
+    for (s = wildmat; s = strchr (s,'%'); *s = '*');
+  }
+  return ret ? LONGT : NIL;
+}
+
+/* NNTP subscribe to mailbox
+ * Accepts: mail stream
+ *	    mailbox to add to subscription list
+ * Returns: T on success, NIL on failure
+ */
+
+long nntp_subscribe (MAILSTREAM *stream,char *mailbox)
+{
+  char mbx[MAILTMPLEN];
+  return nntp_isvalid (mailbox,mbx) ? newsrc_update (stream,mbx,':') : NIL;
+}
+
+
+/* NNTP unsubscribe to mailbox
+ * Accepts: mail stream
+ *	    mailbox to delete from subscription list
+ * Returns: T on success, NIL on failure
+ */
+
+long nntp_unsubscribe (MAILSTREAM *stream,char *mailbox)
+{
+  char mbx[MAILTMPLEN];
+  return nntp_isvalid (mailbox,mbx) ? newsrc_update (stream,mbx,'!') : NIL;
+}
+
+/* NNTP create mailbox
+ * Accepts: mail stream
+ *	    mailbox name to create
+ * Returns: T on success, NIL on failure
+ */
+
+long nntp_create (MAILSTREAM *stream,char *mailbox)
+{
+  return NIL;			/* never valid for NNTP */
+}
+
+
+/* NNTP delete mailbox
+ *	    mailbox name to delete
+ * Returns: T on success, NIL on failure
+ */
+
+long nntp_delete (MAILSTREAM *stream,char *mailbox)
+{
+  return NIL;			/* never valid for NNTP */
+}
+
+
+/* NNTP rename mailbox
+ * Accepts: mail stream
+ *	    old mailbox name
+ *	    new mailbox name
+ * Returns: T on success, NIL on failure
+ */
+
+long nntp_rename (MAILSTREAM *stream,char *old,char *newname)
+{
+  return NIL;			/* never valid for NNTP */
+}
+
+/* NNTP status
+ * Accepts: mail stream
+ *	    mailbox name
+ *	    status flags
+ * Returns: T on success, NIL on failure
+ */
+
+long nntp_status (MAILSTREAM *stream,char *mbx,long flags)
+{
+  MAILSTATUS status;
+  NETMBX mb;
+  unsigned long i,j,k,rnmsgs;
+  long ret = NIL;
+  char *s,*name,*state,tmp[MAILTMPLEN];
+  char *old = (stream && !stream->halfopen) ? LOCAL->name : NIL;
+  MAILSTREAM *tstream = NIL;
+  if (!(mail_valid_net_parse (mbx,&mb) && !strcmp (mb.service,"nntp") &&
+	*mb.mailbox &&
+	((mb.mailbox[0] != '#') ||
+	 ((mb.mailbox[1] == 'n') && (mb.mailbox[2] == 'e') &&
+	  (mb.mailbox[3] == 'w') && (mb.mailbox[4] == 's') &&
+	  (mb.mailbox[5] == '.'))))) {
+    sprintf (tmp,"Invalid NNTP name %s",mbx);
+    mm_log (tmp,ERROR);
+    return NIL;
+  }
+				/* note mailbox name */
+  name = (*mb.mailbox == '#') ? mb.mailbox+6 : mb.mailbox;
+				/* stream to reuse? */
+  if (!(stream && LOCAL->nntpstream &&
+	mail_usable_network_stream (stream,mbx)) &&
+      !(tstream = stream =
+	mail_open (NIL,mbx,OP_HALFOPEN|OP_SILENT|
+		   ((flags & SA_MULNEWSRC) ? OP_MULNEWSRC : NIL))))
+    return NIL;			/* can't reuse or make a new one */
+
+  if (nntp_send (LOCAL->nntpstream,"GROUP",name) == NNTPGOK) {
+    status.flags = flags;	/* status validity flags */
+    k = strtoul (LOCAL->nntpstream->reply + 4,&s,10);
+    i = strtoul (s,&s,10);	/* first assigned UID */
+				/* next UID to be assigned */
+    status.uidnext = (j = strtoul (s,NIL,10)) + 1;
+				/* maximum number of messages */
+    rnmsgs = status.messages = (i | j) ? status.uidnext - i : 0;
+    if (k > status.messages) {	/* check for absurdity */
+      sprintf (tmp,"NNTP SERVER BUG (impossible message count): %lu > %lu",
+	       k,status.messages);
+      mm_log (tmp,WARN);
+    }
+				/* restrict article range if needed */
+    if (nntp_range && (status.messages > nntp_range)) {
+      i = status.uidnext - (status.messages = nntp_range);
+      if (k > nntp_range) k = nntp_range;
+    }
+				/* initially zero */
+    status.recent = status.unseen = 0;
+    if (!status.messages);	/* empty case */
+				/* use server guesstimate in simple case */
+    else if (!(flags & (SA_RECENT | SA_UNSEEN))) status.messages = k;
+
+				/* have newsrc state? */
+    else if (state = newsrc_state (stream,name)) {
+				/* yes, get the UID/sequence map */
+      if (nntp_getmap (stream,name,i,status.uidnext - 1,rnmsgs,
+		       status.messages,tmp)) {
+				/* calculate true count */
+	for (status.messages = 0;
+	     (s = net_getline (LOCAL->nntpstream->netstream)) &&
+	       strcmp (s,"."); ) {
+				/* only count if in range */
+	  if (((k = atol (s)) >= i) && (k < status.uidnext)) {
+	    newsrc_check_uid (state,k,&status.recent,&status.unseen);
+	    status.messages++;
+	  }
+	  fs_give ((void **) &s);
+	}
+	if (s) fs_give ((void **) &s);
+      }
+				/* assume c-client/NNTP map is entire range */
+      else while (i < status.uidnext)
+	newsrc_check_uid (state,i++,&status.recent,&status.unseen);
+      fs_give ((void **) &state);
+    }
+				/* no .newsrc state, all messages new */
+    else status.recent = status.unseen = status.messages;
+				/* UID validity is a constant */
+    status.uidvalidity = stream->uid_validity;
+				/* pass status to main program */
+    mm_status (stream,mbx,&status);
+    ret = T;			/* succes */
+  }
+				/* flush temporary stream */
+  if (tstream) mail_close (tstream);
+				/* else reopen old newsgroup */
+  else if (old && nntp_send (LOCAL->nntpstream,"GROUP",old) != NNTPGOK) {
+    mm_log (LOCAL->nntpstream->reply,ERROR);
+    stream->halfopen = T;	/* go halfopen */
+  }
+  return ret;			/* success */
+}
+
+/* NNTP get map
+ * Accepts: stream
+ *	    newsgroup name
+ *	    first UID in map range
+ *	    last UID in map range
+ *	    reported total number of messages in newsgroup
+ *	    calculated number of messages in range
+ *	    temporary buffer
+ * Returns: T on success, NIL on failure
+ */
+
+long nntp_getmap (MAILSTREAM *stream,char *name,
+		  unsigned long first,unsigned long last,
+		  unsigned long rnmsgs,unsigned long nmsgs,char *tmp)
+{
+  short trylistgroup = NIL;
+  if (rnmsgs > (nmsgs * 8))	/* small subrange? */
+    trylistgroup = T;		/* yes, can try LISTGROUP if [X]HDR fails */
+  else switch ((int) nntp_send (LOCAL->nntpstream,"LISTGROUP",name)) {
+  case NNTPGOK:			/* got data */
+    return LONGT;
+  default:			/* else give up if server claims LISTGROUP */
+    if (EXTENSION.listgroup) return NIL;
+  }
+				/* build range */
+  sprintf (tmp,"%lu-%lu",first,last);
+  if (EXTENSION.hdr)		/* have HDR extension? */
+    return (nntp_send (LOCAL->nntpstream,"HDR Date",tmp) == NNTPHEAD) ?
+      LONGT : NIL;
+  if (LOCAL->xhdr)		/* try the experimental extension then */
+    switch ((int) nntp_send (LOCAL->nntpstream,"XHDR Date",tmp)) {
+    case NNTPHEAD:		/* got an overview? */
+      return LONGT;
+    case NNTPBADCMD:		/* unknown command? */
+      LOCAL->xhdr = NIL;	/* disable future XHDR attempts */
+    }
+  if (trylistgroup &&		/* no [X]HDR, maybe do LISTGROUP after all */
+      (nntp_send (LOCAL->nntpstream,"LISTGROUP",name) == NNTPGOK))
+    return LONGT;
+  return NIL;
+}
+
+/* NNTP open
+ * Accepts: stream to open
+ * Returns: stream on success, NIL on failure
+ */
+
+MAILSTREAM *nntp_mopen (MAILSTREAM *stream)
+{
+  unsigned long i,j,k,nmsgs,rnmsgs;
+  char *s,*mbx,tmp[MAILTMPLEN];
+  FILE *f;
+  NETMBX mb;
+  char *newsrc = (char *) mail_parameters (NIL,GET_NEWSRC,NIL);
+  newsrcquery_t nq = (newsrcquery_t) mail_parameters (NIL,GET_NEWSRCQUERY,NIL);
+  SENDSTREAM *nstream = NIL;
+				/* return prototype for OP_PROTOTYPE call */
+  if (!stream) return &nntpproto;
+  mail_valid_net_parse (stream->mailbox,&mb);
+				/* note mailbox anme */
+  mbx = (*mb.mailbox == '#') ? mb.mailbox+6 : mb.mailbox;
+  if (LOCAL) {			/* recycle stream */
+    nstream = LOCAL->nntpstream;/* remember NNTP protocol stream */
+    sprintf (tmp,"Reusing connection to %s",net_host (nstream->netstream));
+    if (!stream->silent) mm_log (tmp,(long) NIL);
+    if (stream->rdonly) mb.readonlyflag = T;
+    if (LOCAL->tlsflag) mb.tlsflag = T;
+    if (LOCAL->tlssslv23) mb.tlssslv23 = T;
+    if (LOCAL->notlsflag) mb.notlsflag = T;
+    if (LOCAL->sslflag) mb.sslflag = T;
+    if (LOCAL->novalidate) mb.novalidate = T;
+    if (LOCAL->nntpstream->loser) mb.loser = T;
+    if (stream->secure) mb.secflag = T;
+    LOCAL->nntpstream = NIL;	/* keep nntp_mclose() from punting it */
+    nntp_mclose (stream,NIL);	/* do close action */
+    stream->dtb = &nntpdriver;	/* reattach this driver */
+  }
+				/* copy flags */
+  if (mb.dbgflag) stream->debug = T;
+  if (mb.readonlyflag) stream->rdonly = T;
+  if (mb.secflag) stream->secure = T;
+  mb.trysslflag = stream->tryssl = (mb.trysslflag || stream->tryssl) ? T : NIL;
+  if (!nstream) {		/* open NNTP now if not already open */
+    char *hostlist[2];
+    hostlist[0] = strcpy (tmp,mb.host);
+    if (mb.port || nntp_port)
+      sprintf (tmp + strlen (tmp),":%lu",mb.port ? mb.port : nntp_port);
+    if (mb.tlsflag) strcat (tmp,"/tls");
+    if (mb.tlssslv23) strcat (tmp,"/tls-sslv23");
+    if (mb.notlsflag) strcat (tmp,"/notls");
+    if (mb.sslflag) strcat (tmp,"/ssl");
+    if (mb.novalidate) strcat (tmp,"/novalidate-cert");
+    if (mb.loser) strcat (tmp,"/loser");
+    if (mb.secflag) strcat (tmp,"/secure");
+    if (mb.user[0]) sprintf (tmp + strlen (tmp),"/user=\"%s\"",mb.user);
+    hostlist[1] = NIL;
+    if (!(nstream = nntp_open (hostlist,NOP_READONLY |
+			       (stream->debug ? NOP_DEBUG : NIL)))) return NIL;
+  }
+
+				/* always zero messages if halfopen */
+  if (stream->halfopen) i = j = k = rnmsgs = nmsgs = 0;
+				/* otherwise open the newsgroup */
+  else if (nntp_send (nstream,"GROUP",mbx) == NNTPGOK) {
+    k = strtoul (nstream->reply + 4,&s,10);
+    i = strtoul (s,&s,10);
+    stream->uid_last = j = strtoul (s,&s,10);
+    rnmsgs = nmsgs = (i | j) ? 1 + j - i : 0;
+    if (k > nmsgs) {		/* check for absurdity */
+      sprintf (tmp,"NNTP SERVER BUG (impossible message count): %lu > %lu",
+	       k,nmsgs);
+      mm_log (tmp,WARN);
+    }
+				/* restrict article range if needed */
+    if (nntp_range && (nmsgs > nntp_range)) i = 1 + j - (nmsgs = nntp_range);
+  }
+  else {			/* no such newsgroup */
+    mm_log (nstream->reply,ERROR);
+    nntp_close (nstream);	/* punt stream */
+    return NIL;
+  }
+				/* instantiate local data */
+  stream->local = memset (fs_get (sizeof (NNTPLOCAL)),0,sizeof (NNTPLOCAL));
+  LOCAL->nntpstream = nstream;
+				/* 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->nntpstream->loser = T;
+				/* assume present until proven otherwise */
+  LOCAL->xhdr = LOCAL->xover = T;
+  LOCAL->name = cpystr (mbx);	/* copy newsgroup name */
+  if (stream->mulnewsrc) {	/* want to use multiple .newsrc files? */
+    strcpy (tmp,newsrc);
+    s = tmp + strlen (tmp);	/* end of string */
+    *s++ = '-';			/* hyphen delimiter and host */
+    lcase (strcpy (s,(long) mail_parameters (NIL,GET_NEWSRCCANONHOST,NIL) ?
+		   net_host (nstream->netstream) : mb.host));
+    LOCAL->newsrc = cpystr (nq ? (*nq) (stream,tmp,newsrc) : tmp);
+  }
+  else LOCAL->newsrc = cpystr (newsrc);
+  if (mb.user[0]) LOCAL->user = cpystr (mb.user);
+  stream->sequence++;		/* bump sequence number */
+  stream->rdonly = stream->perm_deleted = T;
+				/* UIDs are always valid */
+  stream->uid_validity = 0xbeefface;
+  sprintf (tmp,"{%s:%lu/nntp",(long) mail_parameters (NIL,GET_TRUSTDNS,NIL) ?
+	   net_host (nstream->netstream) : mb.host,
+	   net_port (nstream->netstream));
+  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->nntpstream->loser) strcat (tmp,"/loser");
+  if (stream->secure) strcat (tmp,"/secure");
+  if (stream->rdonly) strcat (tmp,"/readonly");
+  if (LOCAL->user) sprintf (tmp + strlen (tmp),"/user=\"%s\"",LOCAL->user);
+  if (stream->halfopen) strcat (tmp,"}<no_mailbox>");
+  else sprintf (tmp + strlen (tmp),"}#news.%s",mbx);
+  fs_give ((void **) &stream->mailbox);
+  stream->mailbox = cpystr (tmp);
+
+  if (EXTENSION.over &&		/* get overview format if have OVER */
+      (nntp_send (LOCAL->nntpstream,"LIST","OVERVIEW.FMT") == NNTPGLIST) &&
+      (f = netmsg_slurp (LOCAL->nntpstream->netstream,&k,NIL))) {
+    fread (LOCAL->over_fmt = (char *) fs_get ((size_t) k + 3),
+	   (size_t) 1,(size_t) k,f);
+    LOCAL->over_fmt[k] = '\0';
+    fclose (f);			/* flush temp file */
+  }
+  if (nmsgs) {			/* if any messages exist */
+    short silent = stream->silent;
+    stream->silent = T;		/* don't notify main program yet */
+    mail_exists (stream,nmsgs);	/* silently set the cache to the guesstimate */
+				/* get UID/sequence map, nuke holes */
+    if (nntp_getmap (stream,mbx,i,j,rnmsgs,nmsgs,tmp)) {
+      for (nmsgs = 0;		/* calculate true count */
+	   (s = net_getline (nstream->netstream)) && strcmp (s,"."); ) {
+	if ((k = atol (s)) > j){/* discard too high article numbers */
+	  sprintf (tmp,"NNTP SERVER BUG (out of range article ID): %lu > %lu",
+		   k,j);
+	  mm_notify (stream,tmp,NIL);
+	  stream->unhealthy = T;
+	}
+	else if (k >= i) {	/* silently ignore too-low article numbers */
+				/* guard against server returning extra msgs */
+	  if (nmsgs == stream->nmsgs) mail_exists (stream,nmsgs+1);
+				/* create elt for this message, set UID */
+	  mail_elt (stream,++nmsgs)->private.uid = k;
+	}
+	fs_give ((void **) &s);
+      }
+      if (s) fs_give ((void **) &s);
+    }
+				/* assume c-client/NNTP map is entire range */
+    else for (k = 1; k <= nmsgs; k++) mail_elt (stream,k)->private.uid = i++;
+    stream->unhealthy = NIL;	/* set healthy */
+    stream->nmsgs = 0;		/* whack it back down */
+    stream->silent = silent;	/* restore old silent setting */
+    mail_exists (stream,nmsgs);	/* notify upper level that messages exist */
+				/* read .newsrc entries */
+    mail_recent (stream,newsrc_read (mbx,stream));
+  }
+  else {			/* empty newsgroup or halfopen */
+    if (!(stream->silent || stream->halfopen)) {
+      sprintf (tmp,"Newsgroup %s is empty",mbx);
+      mm_log (tmp,WARN);
+    }
+    mail_exists (stream,(long) 0);
+    mail_recent (stream,(long) 0);
+  }
+  return stream;		/* return stream to caller */
+}
+
+/* NNTP close
+ * Accepts: MAIL stream
+ *	    option flags
+ */
+
+void nntp_mclose (MAILSTREAM *stream,long options)
+{
+  unsigned long i;
+  MESSAGECACHE *elt;
+  if (LOCAL) {			/* only if a file is open */
+    nntp_check (stream);	/* dump final checkpoint */
+    if (LOCAL->over_fmt) fs_give ((void **) &LOCAL->over_fmt);
+    if (LOCAL->name) fs_give ((void **) &LOCAL->name);
+    if (LOCAL->user) fs_give ((void **) &LOCAL->user);
+    if (LOCAL->newsrc) fs_give ((void **) &LOCAL->newsrc);
+    if (LOCAL->txt) fclose (LOCAL->txt);
+				/* close NNTP connection */
+    if (LOCAL->nntpstream) nntp_close (LOCAL->nntpstream);
+    for (i = 1; i <= stream->nmsgs; i++)
+      if ((elt = mail_elt (stream,i))->private.spare.ptr)
+	fs_give ((void **) &elt->private.spare.ptr);
+				/* nuke the local data */
+    fs_give ((void **) &stream->local);
+    stream->dtb = NIL;		/* log out the DTB */
+  }
+}
+
+/* NNTP fetch fast information
+ * Accepts: MAIL stream
+ *	    sequence
+ *	    option flags
+ * This is ugly and slow
+ */
+
+void nntp_fetchfast (MAILSTREAM *stream,char *sequence,long flags)
+{
+  unsigned long i;
+  MESSAGECACHE *elt;
+				/* get sequence */
+  if (stream && LOCAL && ((flags & FT_UID) ?
+			  mail_uid_sequence (stream,sequence) :
+			  mail_sequence (stream,sequence)))
+    for (i = 1; i <= stream->nmsgs; i++) {
+      if ((elt = mail_elt (stream,i))->sequence && (elt->valid = T) &&
+	  !(elt->day && elt->rfc822_size)) {
+	ENVELOPE **env = NIL;
+	ENVELOPE *e = NIL;
+	if (!stream->scache) env = &elt->private.msg.env;
+	else if (stream->msgno == i) env = &stream->env;
+	else env = &e;
+	if (!*env || !elt->rfc822_size) {
+	  STRING bs;
+	  unsigned long hs;
+	  char *ht = (*stream->dtb->header) (stream,i,&hs,NIL);
+				/* need to make an envelope? */
+	  if (!*env) rfc822_parse_msg (env,NIL,ht,hs,NIL,BADHOST,
+				       stream->dtb->flags);
+				/* need message size too, ugh */
+	  if (!elt->rfc822_size) {
+	    (*stream->dtb->text) (stream,i,&bs,FT_PEEK);
+	    elt->rfc822_size = hs + SIZE (&bs) - GETPOS (&bs);
+	  }
+	}
+				/* if need date, have date in envelope? */
+	if (!elt->day && *env && (*env)->date)
+	  mail_parse_date (elt,(*env)->date);
+				/* sigh, fill in bogus default */
+	if (!elt->day) elt->day = elt->month = 1;
+	mail_free_envelope (&e);
+      }
+    }
+}
+
+/* NNTP fetch flags
+ * Accepts: MAIL stream
+ *	    sequence
+ *	    option flags
+ */
+
+void nntp_flags (MAILSTREAM *stream,char *sequence,long flags)
+{
+  unsigned long i;
+  if ((flags & FT_UID) ?	/* validate all elts */
+      mail_uid_sequence (stream,sequence) : mail_sequence (stream,sequence))
+    for (i = 1; i <= stream->nmsgs; i++) mail_elt (stream,i)->valid = T;
+}
+
+/* NNTP fetch overview
+ * Accepts: MAIL stream, sequence bits set
+ *	    overview return function
+ * Returns: T if successful, NIL otherwise
+ */
+
+long nntp_overview (MAILSTREAM *stream,overview_t ofn)
+{
+  unsigned long i,j,k,uid;
+  char c,*s,*t,*v,tmp[MAILTMPLEN];
+  MESSAGECACHE *elt;
+  OVERVIEW ov;
+  if (!LOCAL->nntpstream->netstream) return NIL;
+				/* scan sequence to load cache */
+  for (i = 1; i <= stream->nmsgs; i++)
+				/* have cached overview yet? */
+    if ((elt = mail_elt (stream,i))->sequence && !elt->private.spare.ptr) {
+      for (j = i + 1;		/* no, find end of cache gap range */
+	   (j <= stream->nmsgs) && (elt = mail_elt (stream,j))->sequence &&
+	   !elt->private.spare.ptr; j++);
+				/* make NNTP range */
+      sprintf (tmp,(i == (j - 1)) ? "%lu" : "%lu-%lu",mail_uid (stream,i),
+	       mail_uid (stream,j - 1));
+      i = j;			/* advance beyond gap */
+				/* ask server for overview data to cache */
+      if (nntp_over (stream,tmp)) {
+	while ((s = net_getline (LOCAL->nntpstream->netstream)) &&
+	       strcmp (s,".")) {
+				/* death to embedded newlines */
+	  for (t = v = s; c = *v++;)
+	    if ((c != '\012') && (c != '\015')) *t++ = c;
+	  *t++ = '\0';		/* tie off string in case it was shortened */
+				/* cache the overview if found its sequence */
+	  if ((uid = atol (s)) && (k = mail_msgno (stream,uid)) &&
+	      (t = strchr (s,'\t'))) {
+	    if ((elt = mail_elt (stream,k))->private.spare.ptr)
+	      fs_give ((void **) &elt->private.spare.ptr);
+	    elt->private.spare.ptr = cpystr (t + 1);
+	  }
+	  else {		/* shouldn't happen, snarl if it does */
+	    sprintf (tmp,"Server returned data for unknown UID %lu",uid);
+	    mm_notify (stream,tmp,WARN);
+	    stream->unhealthy = T;
+	  }
+				/* flush the overview */
+	  fs_give ((void **) &s);
+	}
+	stream->unhealthy = NIL;/* set healthy */
+				/* flush the terminating dot */
+	if (s) fs_give ((void **) &s);
+      }
+      else i = stream->nmsgs;	/* OVER failed, punt cache load */
+    }
+
+				/* now scan sequence to return overviews */
+  if (ofn) for (i = 1; i <= stream->nmsgs; i++)
+    if ((elt = mail_elt (stream,i))->sequence) {
+      uid = mail_uid (stream,i);/* UID for this message */
+				/* parse cached overview */
+      if (nntp_parse_overview (&ov,s = (char *) elt->private.spare.ptr,elt))
+	(*ofn) (stream,uid,&ov,i);
+      else {			/* parse failed */
+	(*ofn) (stream,uid,NIL,i);
+	if (s && *s) {		/* unusable cached entry? */
+	  sprintf (tmp,"Unable to parse overview for UID %lu: %.500s",uid,s);
+	  mm_notify (stream,tmp,WARN);
+	  stream->unhealthy = T;
+				/* erase it from the cache */
+	  fs_give ((void **) &s);
+	}
+	stream->unhealthy = NIL;/* set healthy */
+				/* insert empty cached text as necessary */
+	if (!s) elt->private.spare.ptr = cpystr ("");
+      }
+				/* clean up overview data */
+      if (ov.from) mail_free_address (&ov.from);
+      if (ov.subject) fs_give ((void **) &ov.subject);
+    }
+  return T;
+}
+
+/* Send OVER to NNTP server
+ * Accepts: mail stream
+ *	    sequence to send
+ * Returns: T if success and overviews will follow, else NIL
+ */
+
+long nntp_over (MAILSTREAM *stream,char *sequence)
+{
+  unsigned char *s;
+				/* test for Netscape Collabra server */
+  if (EXTENSION.over && LOCAL->xover &&
+      nntp_send (LOCAL->nntpstream,"OVER","0") == NNTPOVER) {
+    /* "Netscape-Collabra/3.52 03615 NNTP" responds to the OVER command with
+     * a bogus "Subject:From:Date:Bytes:Lines" response followed by overviews
+     * which lack the Message-ID and References:.  This violates the draft
+     * NNTP specification (draft-ietf-nntpext-base-18.txt as of this writing).
+     * XOVER works fine.
+     */
+    while ((s = net_getline (LOCAL->nntpstream->netstream)) && strcmp (s,".")){
+      if (!isdigit (*s)) {	/* is it that fetid piece of reptile dung? */
+	EXTENSION.over = NIL;	/* sure smells like it */
+	mm_log ("Working around Netscape Collabra bug",WARN);
+      }
+      fs_give ((void **) &s);	/* flush the overview */
+    }
+    if (s) fs_give ((void **) &s);
+				/* don't do this test again */
+    if (EXTENSION.over) LOCAL->xover = NIL;
+  }
+  if (EXTENSION.over)		/* have OVER extension? */
+    return (nntp_send (LOCAL->nntpstream,"OVER",sequence) == NNTPOVER) ?
+      LONGT : NIL;
+  if (LOCAL->xover)		/* try the experiment extension then */
+    switch ((int) nntp_send (LOCAL->nntpstream,"XOVER",sequence)) {
+    case NNTPOVER:		/* got an overview? */
+      return LONGT;
+    case NNTPBADCMD:		/* unknown command? */
+      LOCAL->xover = NIL;	/* disable future XOVER attempts */
+    }
+  return NIL;
+}
+
+/* Parse OVERVIEW struct from cached NNTP OVER response
+ * Accepts: struct to load
+ *	    cached OVER response
+ *	    internaldate
+ * Returns: T if success, NIL if fail
+ */
+
+long nntp_parse_overview (OVERVIEW *ov,char *text,MESSAGECACHE *elt)
+{
+  char *t;
+				/* nothing in overview yet */
+  memset ((void *) ov,0,sizeof (OVERVIEW));
+				/* no cached data */
+  if (!(text && *text)) return NIL;
+  ov->subject = cpystr (text);	/* make hackable copy of overview */
+				/* find end of Subject */
+  if (t = strchr (ov->subject,'\t')) {
+    *t++ = '\0';		/* tie off Subject, point to From */
+				/* find end of From */
+    if (ov->date = strchr (t,'\t')) {
+      *ov->date++ = '\0';	/* tie off From, point to Date */
+				/* load internaldate too */
+      if (!elt->day) mail_parse_date (elt,ov->date);
+				/* parse From */
+      rfc822_parse_adrlist (&ov->from,t,BADHOST);
+				/* find end of Date */
+      if (ov->message_id = strchr (ov->date,'\t')) {
+				/* tie off Date, point to Message-ID */
+	*ov->message_id++ = '\0';
+				/* find end of Message-ID */
+	if (ov->references = strchr (ov->message_id,'\t')) {
+				/* tie off Message-ID, point to References */
+	  *ov->references++ = '\0';
+				/* fine end of References */
+	  if (t = strchr (ov->references,'\t')) {
+	    *t++ = '\0';	/* tie off References, point to octet size */
+				/* parse size of message in octets */
+	    ov->optional.octets = atol (t);
+				/* find end of size */
+	    if (t = strchr (t,'\t')) {
+				/* parse size of message in lines */
+	      ov->optional.lines = atol (++t);
+				/* find Xref */
+	      if (ov->optional.xref = strchr (t,'\t'))
+		*ov->optional.xref++ = '\0';
+	    }
+	  }
+	}
+      }
+    }
+  }
+  return ov->references ? T : NIL;
+}
+
+/* NNTP fetch header as text
+ * Accepts: mail stream
+ *	    message number
+ *	    pointer to return size
+ *	    flags
+ * Returns: header text
+ */
+
+char *nntp_header (MAILSTREAM *stream,unsigned long msgno,unsigned long *size,
+		   long flags)
+{
+  char tmp[MAILTMPLEN];
+  MESSAGECACHE *elt;
+  FILE *f;
+  *size = 0;
+  if ((flags & FT_UID) && !(msgno = mail_msgno (stream,msgno))) return "";
+				/* have header text? */
+  if (!(elt = mail_elt (stream,msgno))->private.msg.header.text.data) {
+    sprintf (tmp,"%lu",mail_uid (stream,msgno));
+				/* get header text */
+    switch (nntp_send (LOCAL->nntpstream,"HEAD",tmp)) {
+    case NNTPHEAD:
+      if (f = netmsg_slurp (LOCAL->nntpstream->netstream,size,NIL)) {
+	fread (elt->private.msg.header.text.data =
+	       (unsigned char *) fs_get ((size_t) *size + 3),
+	       (size_t) 1,(size_t) *size,f);
+	fclose (f);		/* flush temp file */
+				/* tie off header with extra CRLF and NUL */
+	elt->private.msg.header.text.data[*size] = '\015';
+	elt->private.msg.header.text.data[++*size] = '\012';
+	elt->private.msg.header.text.data[++*size] = '\0';
+	elt->private.msg.header.text.size = *size;
+	elt->valid = T;		/* make elt valid now */
+	break;
+      }
+				/* fall into default case */
+    default:			/* failed, mark as deleted and empty */
+      elt->valid = elt->deleted = T;
+    case NNTPSOFTFATAL:		/* don't mark deleted if stream dead */
+      *size = elt->private.msg.header.text.size = 0;
+      break;
+    }
+  }
+				/* just return size of text */
+  else *size = elt->private.msg.header.text.size;
+  return elt->private.msg.header.text.data ?
+    (char *) elt->private.msg.header.text.data : "";
+}
+
+/* NNTP fetch body
+ * Accepts: mail stream
+ *	    message number
+ *	    pointer to stringstruct to initialize
+ *	    flags
+ * Returns: T if successful, else NIL
+ */
+
+long nntp_text (MAILSTREAM *stream,unsigned long msgno,STRING *bs,long flags)
+{
+  char tmp[MAILTMPLEN];
+  MESSAGECACHE *elt;
+  INIT (bs,mail_string,(void *) "",0);
+  if ((flags & FT_UID) && !(msgno = mail_msgno (stream,msgno))) return NIL;
+  elt = mail_elt (stream,msgno);
+				/* different message, flush cache */
+  if (LOCAL->txt && (LOCAL->msgno != msgno)) {
+    fclose (LOCAL->txt);
+    LOCAL->txt = NIL;
+  }
+  LOCAL->msgno = msgno;		/* note cached message */
+  if (!LOCAL->txt) {		/* have file for this message? */
+    sprintf (tmp,"%lu",elt->private.uid);
+    switch (nntp_send (LOCAL->nntpstream,"BODY",tmp)) {
+    case NNTPBODY:
+      if (LOCAL->txt = netmsg_slurp (LOCAL->nntpstream->netstream,
+				     &LOCAL->txtsize,NIL)) break;
+				/* fall into default case */
+    default:			/* failed, mark as deleted */
+      elt->deleted = T;
+    case NNTPSOFTFATAL:		/* don't mark deleted if stream dead */
+      return NIL;
+    }
+  }
+  if (!(flags & FT_PEEK)) {	/* mark seen if needed */
+    elt->seen = T;
+    mm_flags (stream,elt->msgno);
+  }
+  INIT (bs,file_string,(void *) LOCAL->txt,LOCAL->txtsize);
+  return T;
+}
+
+/* NNTP fetch article from message ID (for news: URL support)
+ * Accepts: mail stream
+ *	    message ID
+ *	    pointer to return total message size
+ *	    pointer to return file size
+ * Returns: FILE * to message if successful, else NIL
+ */
+
+FILE *nntp_article (MAILSTREAM *stream,char *msgid,unsigned long *size,
+		    unsigned long *hsiz)
+{
+  return (nntp_send (LOCAL->nntpstream,"ARTICLE",msgid) == NNTPARTICLE) ?
+    netmsg_slurp (LOCAL->nntpstream->netstream,size,hsiz) : NIL;
+}
+
+
+/* NNTP per-message modify flag
+ * Accepts: MAIL stream
+ *	    message cache element
+ */
+
+void nntp_flagmsg (MAILSTREAM *stream,MESSAGECACHE *elt)
+{
+  if (!LOCAL->dirty) {		/* only bother checking if not dirty yet */
+    if (elt->valid) {		/* if done, see if deleted changed */
+      if (elt->sequence != elt->deleted) LOCAL->dirty = T;
+      elt->sequence = T;	/* leave the sequence set */
+    }
+				/* note current setting of deleted flag */
+    else elt->sequence = elt->deleted;
+  }
+}
+
+/* NNTP search messages
+ * Accepts: mail stream
+ *	    character set
+ *	    search program
+ *	    option flags
+ * Returns: T on success, NIL on failure
+ */
+
+long nntp_search (MAILSTREAM *stream,char *charset,SEARCHPGM *pgm,long flags)
+{
+  unsigned long i;
+  MESSAGECACHE *elt;
+  OVERVIEW ov;
+  char *msg;
+				/* make sure that charset is good */
+  if (msg = utf8_badcharset (charset)) {
+    MM_LOG (msg,ERROR);		/* output error */
+    fs_give ((void **) &msg);
+    return NIL;
+  }
+  utf8_searchpgm (pgm,charset);
+  if (flags & SO_OVERVIEW) {	/* only if specified to use overview */
+				/* identify messages that will be searched */
+    for (i = 1; i <= stream->nmsgs; ++i)
+      mail_elt (stream,i)->sequence = nntp_search_msg (stream,i,pgm,NIL);
+    nntp_overview (stream,NIL);	/* load the overview cache */
+  }
+				/* init in case no overview at cleanup */
+  memset ((void *) &ov,0,sizeof (OVERVIEW));
+				/* otherwise do default search */
+  for (i = 1; i <= stream->nmsgs; ++i) {
+    if (((flags & SO_OVERVIEW) && ((elt = mail_elt (stream,i))->sequence) &&
+	 nntp_parse_overview (&ov,(char *) elt->private.spare.ptr,elt)) ?
+	nntp_search_msg (stream,i,pgm,&ov) :
+	mail_search_msg (stream,i,NIL,pgm)) {
+      if (flags & SE_UID) mm_searched (stream,mail_uid (stream,i));
+      else {			/* mark as searched, notify mail program */
+	mail_elt (stream,i)->searched = T;
+	if (!stream->silent) mm_searched (stream,i);
+      }
+    }
+				/* clean up overview data */
+    if (ov.from) mail_free_address (&ov.from);
+    if (ov.subject) fs_give ((void **) &ov.subject);
+  }
+  return LONGT;
+}
+
+/* NNTP search message
+ * Accepts: MAIL stream
+ *	    message number
+ *	    search program
+ *	    overview to search (NIL means preliminary pass)
+ * Returns: T if found, NIL otherwise
+ */
+
+long nntp_search_msg (MAILSTREAM *stream,unsigned long msgno,SEARCHPGM *pgm,
+		      OVERVIEW *ov)
+{
+  unsigned short d;
+  unsigned long now = (unsigned long) time (0);
+  MESSAGECACHE *elt = mail_elt (stream,msgno);
+  SEARCHHEADER *hdr;
+  SEARCHOR *or;
+  SEARCHPGMLIST *not;
+  if (pgm->msgno || pgm->uid) {	/* message set searches */
+    SEARCHSET *set;
+				/* message sequences */
+    if (set = pgm->msgno) {	/* must be inside this sequence */
+      while (set) {		/* run down until find matching range */
+	if (set->last ? ((msgno < set->first) || (msgno > set->last)) :
+	    msgno != set->first) set = set->next;
+	else break;
+      }
+      if (!set) return NIL;	/* not found within sequence */
+    }
+    if (set = pgm->uid) {	/* must be inside this sequence */
+      unsigned long uid = mail_uid (stream,msgno);
+      while (set) {		/* run down until find matching range */
+	if (set->last ? ((uid < set->first) || (uid > set->last)) :
+	    uid != set->first) set = set->next;
+	else break;
+      }
+      if (!set) return NIL;	/* not found within sequence */
+    }
+  }
+
+  /* Fast data searches */
+				/* message flags */
+  if ((pgm->answered && !elt->answered) ||
+      (pgm->unanswered && elt->answered) ||
+      (pgm->deleted && !elt->deleted) ||
+      (pgm->undeleted && elt->deleted) ||
+      (pgm->draft && !elt->draft) ||
+      (pgm->undraft && elt->draft) ||
+      (pgm->flagged && !elt->flagged) ||
+      (pgm->unflagged && elt->flagged) ||
+      (pgm->recent && !elt->recent) ||
+      (pgm->old && elt->recent) ||
+      (pgm->seen && !elt->seen) ||
+      (pgm->unseen && elt->seen)) return NIL;
+				/* keywords */
+  if ((pgm->keyword && !mail_search_keyword (stream,elt,pgm->keyword,LONGT)) ||
+      (pgm->unkeyword && mail_search_keyword (stream,elt,pgm->unkeyword,NIL)))
+    return NIL;
+  if (ov) {			/* only do this if real searching */
+    MESSAGECACHE delt;
+				/* size ranges */
+    if ((pgm->larger && (ov->optional.octets <= pgm->larger)) ||
+	(pgm->smaller && (ov->optional.octets >= pgm->smaller))) return NIL;
+				/* date ranges */
+    if ((pgm->sentbefore || pgm->senton || pgm->sentsince ||
+	 pgm->before || pgm->on || pgm->since) &&
+	(!mail_parse_date (&delt,ov->date) ||
+	 !(d = mail_shortdate (delt.year,delt.month,delt.day)) ||
+	 (pgm->sentbefore && (d >= pgm->sentbefore)) ||
+	 (pgm->senton && (d != pgm->senton)) ||
+	 (pgm->sentsince && (d < pgm->sentsince)) ||
+	 (pgm->before && (d >= pgm->before)) ||
+	 (pgm->on && (d != pgm->on)) ||
+	 (pgm->since && (d < pgm->since)))) return NIL;
+    if (pgm->older || pgm->younger) {
+      unsigned long msgd = mail_longdate (elt);
+      if (pgm->older && msgd > (now - pgm->older)) return NIL;
+      if (pgm->younger && msgd < (now - pgm->younger)) return NIL;
+    }
+    if ((pgm->from && !mail_search_addr (ov->from,pgm->from)) ||
+	(pgm->subject && !mail_search_header_text (ov->subject,pgm->subject))||
+	(pgm->message_id &&
+	 !mail_search_header_text (ov->message_id,pgm->message_id)) ||
+	(pgm->references &&
+	 !mail_search_header_text (ov->references,pgm->references)))
+      return NIL;
+
+
+				/* envelope searches */
+    if (pgm->bcc || pgm->cc || pgm->to || pgm->return_path || pgm->sender ||
+	pgm->reply_to || pgm->in_reply_to || pgm->newsgroups ||
+	pgm->followup_to) {
+      ENVELOPE *env = mail_fetchenvelope (stream,msgno);
+      if (!env) return NIL;	/* no envelope obtained */
+				/* search headers */
+      if ((pgm->bcc && !mail_search_addr (env->bcc,pgm->bcc)) ||
+	  (pgm->cc && !mail_search_addr (env->cc,pgm->cc)) ||
+	  (pgm->to && !mail_search_addr (env->to,pgm->to)))
+	return NIL;
+      /* These criteria are not supported by IMAP and have to be emulated */
+      if ((pgm->return_path &&
+	   !mail_search_addr (env->return_path,pgm->return_path)) ||
+	  (pgm->sender && !mail_search_addr (env->sender,pgm->sender)) ||
+	  (pgm->reply_to && !mail_search_addr (env->reply_to,pgm->reply_to)) ||
+	  (pgm->in_reply_to &&
+	   !mail_search_header_text (env->in_reply_to,pgm->in_reply_to)) ||
+	  (pgm->newsgroups &&
+	   !mail_search_header_text (env->newsgroups,pgm->newsgroups)) ||
+	  (pgm->followup_to &&
+	   !mail_search_header_text (env->followup_to,pgm->followup_to)))
+	return NIL;
+    }
+
+				/* search header lines */
+    for (hdr = pgm->header; hdr; hdr = hdr->next) {
+      char *t,*e,*v;
+      SIZEDTEXT s;
+      STRINGLIST sth,stc;
+      sth.next = stc.next = NIL;/* only one at a time */
+      sth.text.data = hdr->line.data;
+      sth.text.size = hdr->line.size;
+				/* get the header text */
+      if ((t = mail_fetch_header (stream,msgno,NIL,&sth,&s.size,
+				  FT_INTERNAL | FT_PEEK)) && strchr (t,':')) {
+	if (hdr->text.size) {	/* anything matches empty search string */
+				/* non-empty, copy field data */
+	  s.data = (unsigned char *) fs_get (s.size + 1);
+				/* for each line */
+	  for (v = (char *) s.data, e = t + s.size; t < e;) switch (*t) {
+	  default:		/* non-continuation, skip leading field name */
+	    while ((t < e) && (*t++ != ':'));
+	    if ((t < e) && (*t == ':')) t++;
+	  case '\t': case ' ':	/* copy field data  */
+	    while ((t < e) && (*t != '\015') && (*t != '\012')) *v++ = *t++;
+	    *v++ = '\n';	/* tie off line */
+	    while (((*t == '\015') || (*t == '\012')) && (t < e)) t++;
+	  }
+				/* calculate true size */
+	  s.size = v - (char *) s.data;
+	  *v = '\0';		/* tie off results */
+	  stc.text.data = hdr->text.data;
+	  stc.text.size = hdr->text.size;
+				/* search header */
+	  if (mail_search_header (&s,&stc)) fs_give ((void **) &s.data);
+	  else {		/* search failed */
+	    fs_give ((void **) &s.data);
+	    return NIL;
+	  }
+	}
+      }
+      else return NIL;		/* no matching header text */
+    }
+				/* search strings */
+    if ((pgm->text &&
+	 !mail_search_text (stream,msgno,NIL,pgm->text,LONGT))||
+	(pgm->body && !mail_search_text (stream,msgno,NIL,pgm->body,NIL)))
+      return NIL;
+  }
+				/* logical conditions */
+  for (or = pgm->or; or; or = or->next)
+    if (!(nntp_search_msg (stream,msgno,or->first,ov) ||
+	  nntp_search_msg (stream,msgno,or->second,ov))) return NIL;
+  for (not = pgm->not; not; not = not->next)
+    if (nntp_search_msg (stream,msgno,not->pgm,ov)) return NIL;
+  return T;
+}
+
+/* NNTP 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 *nntp_sort (MAILSTREAM *stream,char *charset,SEARCHPGM *spg,
+			  SORTPGM *pgm,long flags)
+{
+  unsigned long i,start,last;
+  SORTCACHE **sc;
+  mailcache_t mailcache = (mailcache_t) mail_parameters (NIL,GET_CACHE,NIL);
+  unsigned long *ret = NIL;
+  sortresults_t sr = (sortresults_t) mail_parameters (NIL,GET_SORTRESULTS,NIL);
+  if (spg) {			/* only if a search needs to be done */
+    int silent = stream->silent;
+    stream->silent = T;		/* don't pass up mm_searched() events */
+				/* search for messages */
+    mail_search_full (stream,charset,spg,NIL);
+    stream->silent = silent;	/* restore silence state */
+  }
+				/* initialize progress counters */
+  pgm->nmsgs = pgm->progress.cached = 0;
+				/* pass 1: count messages to sort */
+  for (i = 1,start = last = 0; i <= stream->nmsgs; ++i)
+    if (mail_elt (stream,i)->searched) {
+      pgm->nmsgs++;
+				/* have this in the sortcache already? */
+      if (!((SORTCACHE *) (*mailcache) (stream,i,CH_SORTCACHE))->date) {
+				/* no, record as last message */
+	last = mail_uid (stream,i);
+				/* and as first too if needed */
+	if (!start) start = last;
+      }
+    }
+  if (pgm->nmsgs) {		/* pass 2: load sort cache */
+    sc = nntp_sort_loadcache (stream,pgm,start,last,flags);
+				/* pass 3: sort messages */
+    if (!pgm->abort) ret = mail_sort_cache (stream,pgm,sc,flags);
+    fs_give ((void **) &sc);	/* don't need sort vector any more */
+  }
+				/* empty sort results */
+  else ret = (unsigned long *) memset (fs_get (sizeof (unsigned long)),0,
+				       sizeof (unsigned long));
+				/* also return via callback if requested */
+  if (sr) (*sr) (stream,ret,pgm->nmsgs);
+  return ret;
+}
+
+/* Mail load sortcache
+ * Accepts: mail stream, already searched
+ *	    sort program
+ *	    first UID to OVER
+ *	    last UID to OVER
+ *	    option flags
+ * Returns: vector of sortcache pointers matching search
+ */
+
+SORTCACHE **nntp_sort_loadcache (MAILSTREAM *stream,SORTPGM *pgm,
+				 unsigned long start,unsigned long last,
+				 long flags)
+{
+  unsigned long i;
+  char c,*s,*t,*v,tmp[MAILTMPLEN];
+  SORTPGM *pg;
+  SORTCACHE **sc,*r;
+  MESSAGECACHE telt;
+  ADDRESS *adr = NIL;
+  mailcache_t mailcache = (mailcache_t) mail_parameters (NIL,GET_CACHE,NIL);
+				/* verify that the sortpgm is OK */
+  for (pg = pgm; pg; pg = pg->next) switch (pg->function) {
+  case SORTARRIVAL:		/* sort by arrival date */
+  case SORTSIZE:		/* sort by message size */
+  case SORTDATE:		/* sort by date */
+  case SORTFROM:		/* sort by first from */
+  case SORTSUBJECT:		/* sort by subject */
+    break;
+  case SORTTO:			/* sort by first to */
+    mm_notify (stream,"[NNTPSORT] Can't do To-field sorting in NNTP",WARN);
+    break;
+  case SORTCC:			/* sort by first cc */
+    mm_notify (stream,"[NNTPSORT] Can't do cc-field sorting in NNTP",WARN);
+    break;
+  default:
+    fatal ("Unknown sort function");
+  }
+
+  if (start) {			/* messages need to be loaded in sortcache? */
+				/* yes, build range */
+    if (start != last) sprintf (tmp,"%lu-%lu",start,last);
+    else sprintf (tmp,"%lu",start);
+				/* get it from the NNTP server */
+    if (!nntp_over (stream,tmp)) return mail_sort_loadcache (stream,pgm);
+    while ((s = net_getline (LOCAL->nntpstream->netstream)) && strcmp (s,".")){
+				/* death to embedded newlines */
+      for (t = v = s; c = *v++;) if ((c != '\012') && (c != '\015')) *t++ = c;
+      *t++ = '\0';		/* tie off resulting string */
+				/* parse OVER response */
+      if ((i = mail_msgno (stream,atol (s))) &&
+	  (t = strchr (s,'\t')) && (v = strchr (++t,'\t'))) {
+	*v++ = '\0';		/* tie off subject */
+				/* put stripped subject in sortcache */
+	r = (SORTCACHE *) (*mailcache) (stream,i,CH_SORTCACHE);
+	  r->refwd = mail_strip_subject (t,&r->subject);
+	if (t = strchr (v,'\t')) {
+	  *t++ = '\0';		/* tie off from */
+	  if (adr = rfc822_parse_address (&adr,adr,&v,BADHOST,0)) {
+	    r->from = adr->mailbox;
+	    adr->mailbox = NIL;
+	    mail_free_address (&adr);
+	  }
+	  if (v = strchr (t,'\t')) {
+	    *v++ = '\0';	/* tie off date */
+	    if (mail_parse_date (&telt,t)) r->date = mail_longdate (&telt);
+	    if ((v = strchr (v,'\t')) && (v = strchr (++v,'\t')))
+	      r->size = atol (++v);
+	  }
+	}
+      }
+      fs_give ((void **) &s);
+    }
+    if (s) fs_give ((void **) &s);
+  }
+
+				/* calculate size of sortcache index */
+  i = pgm->nmsgs * sizeof (SORTCACHE *);
+				/* instantiate the index */
+  sc = (SORTCACHE **) memset (fs_get ((size_t) i),0,(size_t) i);
+				/* see what needs to be loaded */
+  for (i = 1; !pgm->abort && (i <= stream->nmsgs); i++)
+    if ((mail_elt (stream,i))->searched) {
+      sc[pgm->progress.cached++] =
+	r = (SORTCACHE *) (*mailcache) (stream,i,CH_SORTCACHE);
+      r->pgm = pgm;	/* note sort program */
+      r->num = (flags & SE_UID) ? mail_uid (stream,i) : i;
+      if (!r->date) r->date = r->num;
+      if (!r->arrival) r->arrival = mail_uid (stream,i);
+      if (!r->size) r->size = 1;
+      if (!r->from) r->from = cpystr ("");
+      if (!r->to) r->to = cpystr ("");
+      if (!r->cc) r->cc = cpystr ("");
+      if (!r->subject) r->subject = cpystr ("");
+    }
+  return sc;
+}
+
+
+/* NNTP thread messages
+ * Accepts: mail stream
+ *	    thread type
+ *	    character set
+ *	    search program
+ *	    option flags
+ * Returns: thread node tree
+ */
+
+THREADNODE *nntp_thread (MAILSTREAM *stream,char *type,char *charset,
+			 SEARCHPGM *spg,long flags)
+{
+  return mail_thread_msgs (stream,type,charset,spg,flags,nntp_sort);
+}
+
+/* NNTP ping mailbox
+ * Accepts: MAIL stream
+ * Returns: T if stream alive, else NIL
+ */
+
+long nntp_ping (MAILSTREAM *stream)
+{
+  return (nntp_send (LOCAL->nntpstream,"STAT",NIL) != NNTPSOFTFATAL);
+}
+
+
+/* NNTP check mailbox
+ * Accepts: MAIL stream
+ */
+
+void nntp_check (MAILSTREAM *stream)
+{
+				/* never do if no updates */
+  if (LOCAL->dirty) newsrc_write (LOCAL->name,stream);
+  LOCAL->dirty = NIL;
+}
+
+
+/* NNTP expunge mailbox
+ * Accepts: MAIL stream
+ *	    sequence to expunge if non-NIL
+ *	    expunge options
+ * Returns: T if success, NIL if failure
+ */
+
+long nntp_expunge (MAILSTREAM *stream,char *sequence,long options)
+{
+  if (!stream->silent) mm_log ("Expunge ignored on readonly mailbox",NIL);
+  return LONGT;
+}
+
+/* NNTP copy message(s)
+ * Accepts: MAIL stream
+ *	    sequence
+ *	    destination mailbox
+ *	    option flags
+ * Returns: T if copy successful, else NIL
+ */
+
+long nntp_copy (MAILSTREAM *stream,char *sequence,char *mailbox,long options)
+{
+  mailproxycopy_t pc =
+    (mailproxycopy_t) mail_parameters (stream,GET_MAILPROXYCOPY,NIL);
+  if (pc) return (*pc) (stream,sequence,mailbox,options);
+  mm_log ("Copy not valid for NNTP",ERROR);
+  return NIL;
+}
+
+
+/* NNTP append message from stringstruct
+ * Accepts: MAIL stream
+ *	    destination mailbox
+ *	    append callback
+ *	    data for callback
+ * Returns: T if append successful, else NIL
+ */
+
+long nntp_append (MAILSTREAM *stream,char *mailbox,append_t af,void *data)
+{
+  mm_log ("Append not valid for NNTP",ERROR);
+  return NIL;
+}
+
+/* NNTP open connection
+ * Accepts: network driver
+ *	    service host list
+ *	    port number
+ *	    service name
+ *	    NNTP open options
+ * Returns: SEND stream on success, NIL on failure
+ */
+
+SENDSTREAM *nntp_open_full (NETDRIVER *dv,char **hostlist,char *service,
+			    unsigned long port,long options)
+{
+  SENDSTREAM *stream = NIL;
+  NETSTREAM *netstream = NIL;
+  NETMBX mb;
+  char tmp[MAILTMPLEN];
+  long extok = LONGT;
+  NETDRIVER *ssld = (NETDRIVER *) mail_parameters (NIL,GET_SSLDRIVER,NIL);
+  sslstart_t stls = (sslstart_t) mail_parameters (NIL,GET_SSLSTART,NIL);
+  if (!(hostlist && *hostlist)) mm_log ("Missing NNTP service host",ERROR);
+  else do {			/* try to open connection */
+    sprintf (tmp,"{%.200s/%.20s}",*hostlist,service ? service : "nntp");
+    if (!mail_valid_net_parse (tmp,&mb) || mb.anoflag) {
+      sprintf (tmp,"Invalid host specifier: %.80s",*hostlist);
+      mm_log (tmp,ERROR);
+    }
+    else {			/* light tryssl flag if requested */
+      mb.trysslflag = (options & NOP_TRYSSL) ? T : NIL;
+				/* default port */
+      if (mb.port) port = mb.port;
+      else if (!port) port = nntp_port ? nntp_port : NNTPTCPPORT;
+      if (netstream =		/* try to open ordinary connection */
+	  net_open (&mb,dv,port,
+		    (NETDRIVER *) mail_parameters (NIL,GET_SSLDRIVER,NIL),
+		    "*nntps",nntp_sslport ? nntp_sslport : NNTPSSLPORT)) {
+	stream = (SENDSTREAM *) fs_get (sizeof (SENDSTREAM));
+				/* initialize stream */
+	memset ((void *) stream,0,sizeof (SENDSTREAM));
+	stream->netstream = netstream;
+	stream->host = cpystr ((long) mail_parameters (NIL,GET_TRUSTDNS,NIL) ?
+			       net_host (netstream) : mb.host);
+	stream->debug = (mb.dbgflag || (options & NOP_DEBUG)) ? T : NIL;
+	if (mb.loser) stream->loser = T;
+				/* process greeting */
+	switch ((int) nntp_reply (stream)) {
+	case NNTPGREET:		/* allow posting */
+	  NNTP.post = T;
+	  mm_notify (NIL,stream->reply + 4,(long) NIL);
+	  break;
+	case NNTPGREETNOPOST:	/* posting not allowed, must be readonly */
+	  NNTP.post = NIL;
+	  break;
+	default:
+	  mm_log (stream->reply,ERROR);
+	  stream = nntp_close (stream);
+	  break;
+	}
+      }
+    }
+  } while (!stream && *++hostlist);
+
+				/* get extensions */
+  if (stream && extok)
+    extok = nntp_extensions (stream,(mb.secflag ? AU_SECURE : NIL) |
+			     (mb.authuser[0] ? AU_AUTHUSER : NIL));
+  if (stream && !dv && stls && NNTP.ext.starttls &&
+      !mb.sslflag && !mb.notlsflag &&
+      (nntp_send_work (stream,"STARTTLS",NNTP.ext.multidomain ? mb.host : NIL)
+       == NNTPTLSSTART)) {
+    mb.tlsflag = T;		/* TLS OK, get into TLS at this end */
+    stream->netstream->dtb = ssld;
+				/* negotiate TLS */
+    if (stream->netstream->stream =
+	(*stls) (stream->netstream->stream,mb.host,
+		 (mb.tlssslv23 ? NIL : NET_TLSCLIENT) |
+		 (mb.novalidate ? NET_NOVALIDATECERT:NIL)))
+      extok = nntp_extensions (stream,(mb.secflag ? AU_SECURE : NIL) |
+			       (mb.authuser[0] ? AU_AUTHUSER : NIL));
+    else {
+      sprintf (tmp,"Unable to negotiate TLS with this server: %.80s",mb.host);
+      mm_log (tmp,ERROR);
+				/* close without doing QUIT */
+      if (stream->netstream) net_close (stream->netstream);
+      stream->netstream = NIL;
+      stream = nntp_close (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 (stream) {			/* have a session? */
+    if (mb.user[0]) {		/* yes, have user name? */
+      if ((long) mail_parameters (NIL,GET_TRUSTDNS,NIL)) {
+				/* remote name for authentication */
+	strncpy (mb.host,(long) mail_parameters (NIL,GET_SASLUSESPTRNAME,NIL) ?
+		 net_remotehost (netstream) : net_host (netstream),
+		 NETMAXHOST-1);
+	mb.host[NETMAXHOST-1] = '\0';
+      }
+      if (!nntp_send_auth_work (stream,&mb,tmp,NIL))
+	stream = nntp_close (stream);
+    }
+				/* authenticate if no-post and not readonly */
+    else if (!(NNTP.post || (options & NOP_READONLY) ||
+	       nntp_send_auth (stream,NIL))) stream = nntp_close (stream);
+  }
+
+				/* in case server demands MODE READER */
+  if (stream) switch ((int) nntp_send_work (stream,"MODE","READER")) {
+  case NNTPGREET:
+    NNTP.post = T;
+    break;
+  case NNTPGREETNOPOST:
+    NNTP.post = NIL;
+    break;
+  case NNTPWANTAUTH:		/* server wants auth first, do so and retry */
+  case NNTPWANTAUTH2:		/* remote name for authentication */
+    if ((long) mail_parameters (NIL,GET_TRUSTDNS,NIL)) {
+      strncpy (mb.host,(long) mail_parameters (NIL,GET_SASLUSESPTRNAME,NIL) ?
+	       net_remotehost (netstream) : net_host (netstream),NETMAXHOST-1);
+      mb.host[NETMAXHOST-1] = '\0';
+    }
+    if (nntp_send_auth_work (stream,&mb,tmp,NIL))
+      switch ((int) nntp_send (stream,"MODE","READER")) {
+      case NNTPGREET:
+	NNTP.post = T;
+	break;
+      case NNTPGREETNOPOST:
+	NNTP.post = NIL;
+	break;
+      }
+    else stream = nntp_close (stream);
+    break;
+  }
+  if (stream) {			/* looks like we have a stream? */
+				/* yes, make sure can post if not readonly */
+    if (!(NNTP.post || (options & NOP_READONLY))) stream = nntp_close (stream);
+    else if (extok) nntp_extensions (stream,(mb.secflag ? AU_SECURE : NIL) |
+				     (mb.authuser[0] ? AU_AUTHUSER : NIL));
+  }
+  return stream;
+}
+
+/* NNTP extensions
+ * Accepts: stream
+ *	    authenticator flags
+ * Returns: T on success, NIL on failure
+ */
+
+long nntp_extensions (SENDSTREAM *stream,long flags)
+{
+  unsigned long i;
+  char *t,*r,*args;
+				/* zap all old extensions */
+  memset (&NNTP.ext,0,sizeof (NNTP.ext));
+  if (stream->loser) return NIL;/* nothing at all for losers */
+				/* get server extensions */
+  switch ((int) nntp_send_work (stream,"LIST","EXTENSIONS")) {
+  case NNTPEXTOK:		/* what NNTP base spec says */
+  case NNTPGLIST:		/* some servers do this instead */
+    break;
+  default:			/* no LIST EXTENSIONS on this server */
+    return NIL;
+  }
+  NNTP.ext.ok = T;		/* server offers extensions */
+  while ((t = net_getline (stream->netstream)) && (t[1] || (*t != '.'))) {
+    if (stream->debug) mm_dlog (t);
+				/* get optional capability arguments */
+    if (args = strchr (t,' ')) *args++ = '\0';
+    if (!compare_cstring (t,"LISTGROUP")) NNTP.ext.listgroup = T;
+    else if (!compare_cstring (t,"OVER")) NNTP.ext.over = T;
+    else if (!compare_cstring (t,"HDR")) NNTP.ext.hdr = T;
+    else if (!compare_cstring (t,"PAT")) NNTP.ext.pat = T;
+    else if (!compare_cstring (t,"STARTTLS")) NNTP.ext.starttls = T;
+    else if (!compare_cstring (t,"MULTIDOMAIN")) NNTP.ext.multidomain = T;
+
+    else if (!compare_cstring (t,"AUTHINFO") && args) {
+      char *sasl = NIL;
+      for (args = strtok_r (args," ",&r); args; args = strtok_r (NIL," ",&r)) {
+	if (!compare_cstring (args,"USER")) NNTP.ext.authuser = T;
+	else if (((args[0] == 'S') || (args[0] == 's')) &&
+		 ((args[1] == 'A') || (args[1] == 'a')) &&
+		 ((args[2] == 'S') || (args[2] == 's')) &&
+		 ((args[3] == 'L') || (args[3] == 'l')) && (args[4] == ':'))
+	  sasl = args + 5;
+      }
+      if (sasl) {		/* if SASL, look up authenticators */
+	for (sasl = strtok_r (sasl,",",&r); sasl; sasl = strtok_r (NIL,",",&r))
+	  if ((i = mail_lookup_auth_name (sasl,flags)) &&
+	      (--i < MAXAUTHENTICATORS))
+	    NNTP.ext.sasl |= (1 << i);
+				/* disable LOGIN if PLAIN also advertised */
+	if ((i = mail_lookup_auth_name ("PLAIN",NIL)) &&
+	    (--i < MAXAUTHENTICATORS) && (NNTP.ext.sasl & (1 << i)) &&
+	    (i = mail_lookup_auth_name ("LOGIN",NIL)) &&
+	    (--i < MAXAUTHENTICATORS)) NNTP.ext.sasl &= ~(1 << i);
+      }
+    }
+    fs_give ((void **) &t);
+  }
+  if (t) {			/* flush end of text indicator */
+    if (stream->debug) mm_dlog (t);
+    fs_give ((void **) &t);
+  }
+  return LONGT;
+}
+
+/* NNTP close connection
+ * Accepts: SEND stream
+ * Returns: NIL always
+ */
+
+SENDSTREAM *nntp_close (SENDSTREAM *stream)
+{
+  if (stream) {			/* send "QUIT" */
+    if (stream->netstream) nntp_send (stream,"QUIT",NIL);
+				/* do close actions */
+    if (stream->netstream) net_close (stream->netstream);
+    if (stream->host) fs_give ((void **) &stream->host);
+    if (stream->reply) fs_give ((void **) &stream->reply);
+    fs_give ((void **) &stream);/* flush the stream */
+  }
+  return NIL;
+}
+
+/* NNTP deliver news
+ * Accepts: SEND stream
+ *	    message envelope
+ *	    message body
+ * Returns: T on success, NIL on failure
+ */
+
+long nntp_mail (SENDSTREAM *stream,ENVELOPE *env,BODY *body)
+{
+  long ret;
+  RFC822BUFFER buf;
+  char *s,path[MAILTMPLEN],tmp[SENDBUFLEN+1];
+  long error = NIL;
+  long retry = NIL;
+  buf.f = nntp_soutr;		/* initialize buffer */
+  buf.s = stream->netstream;
+  buf.end = (buf.beg = buf.cur = tmp) + SENDBUFLEN;
+  tmp[SENDBUFLEN] = '\0';	/* must have additional null guard byte */
+  /* Gabba gabba hey, we need some brain damage to send netnews!!!
+   *
+   * First, we give ourselves a frontal lobotomy, and put in some UUCP
+   *  syntax.  It doesn't matter that it's completely bogus UUCP, and
+   *  that UUCP has nothing to do with anything we're doing.  It's been
+   *  alleged that "Path: not-for-mail" is also acceptable, but we won't
+   *  make assumptions unless the user says so.
+   *
+   * Second, we bop ourselves on the head with a ball-peen hammer.  How
+   *  dare we be so presumptious as to insert a *comment* in a Date:
+   *  header line.  Why, we were actually trying to be nice to a human
+   *  by giving a symbolic timezone (such as PST) in addition to a
+   *  numeric timezone (such as -0800).  But the gods of news transport
+   *  will have none of this.  Unix weenies, tried and true, rule!!!
+   *
+   * Third, Netscape Collabra server doesn't give the NNTPWANTAUTH error
+   *  until after requesting and receiving the entire message.  So we can't
+   *  call rely upon nntp_send() to do the auth retry.
+   */
+				/* RFC-1036 requires this cretinism */
+  sprintf (path,"Path: %s!%s\015\012",net_localhost (stream->netstream),
+	   env->sender ? env->sender->mailbox :
+	   (env->from ? env->from->mailbox : "not-for-mail"));
+				/* here's another cretinism */
+  if (s = strstr (env->date," (")) *s = NIL;
+  do if ((ret = nntp_send_work (stream,"POST",NIL)) == NNTPREADY)
+				/* output data, return success status */
+    ret = (net_soutr (stream->netstream,
+		      nntp_hidepath ? "Path: not-for-mail\015\012" : path) &&
+	   rfc822_output_full (&buf,env,body,T)) ?
+      nntp_send_work (stream,".",NIL) :
+      nntp_fake (stream,"NNTP connection broken (message text)");
+  while (((ret == NNTPWANTAUTH) || (ret == NNTPWANTAUTH2)) &&
+	 nntp_send_auth (stream,LONGT));
+  if (s) *s = ' ';		/* put the comment in the date back */
+  if (ret == NNTPOK) return LONGT;
+  else if (ret < 400) {		/* if not an error reply */
+    sprintf (tmp,"Unexpected NNTP posting reply code %ld",ret);
+    mm_log (tmp,WARN);		/* so someone looks at this eventually */
+    if ((ret >= 200) && (ret < 300)) return LONGT;
+  }
+  return NIL;
+}
+
+/* NNTP send command
+ * Accepts: SEND stream
+ *	    text
+ * Returns: reply code
+ */
+
+long nntp_send (SENDSTREAM *stream,char *command,char *args)
+{
+  long ret;
+  switch ((int) (ret = nntp_send_work (stream,command,args))) {
+  case NNTPWANTAUTH:		/* authenticate and retry */
+  case NNTPWANTAUTH2:
+    if (nntp_send_auth (stream,LONGT))
+      ret = nntp_send_work (stream,command,args);
+    else {			/* we're probably hosed, nuke the session */
+      nntp_send (stream,"QUIT",NIL);
+				/* close net connection */
+      if (stream->netstream) net_close (stream->netstream);
+      stream->netstream = NIL;
+    }
+  default:			/* all others just return */
+    break;
+  }
+  return ret;
+}
+
+
+/* NNTP send command worker routine
+ * Accepts: SEND stream
+ *	    text
+ * Returns: reply code
+ */
+
+long nntp_send_work (SENDSTREAM *stream,char *command,char *args)
+{
+  long ret;
+  char *s = (char *) fs_get (strlen (command) + (args ? strlen (args) + 1 : 0)
+			     + 3);
+  if (!stream->netstream) ret = nntp_fake (stream,"NNTP connection lost");
+  else {			/* build the complete command */
+    if (args) sprintf (s,"%s %s",command,args);
+    else strcpy (s,command);
+    if (stream->debug) mail_dlog (s,stream->sensitive);
+    strcat (s,"\015\012");
+				/* send the command */
+    ret = net_soutr (stream->netstream,s) ? nntp_reply (stream) :
+      nntp_fake (stream,"NNTP connection broken (command)");
+  }
+  fs_give ((void **) &s);
+  return ret;
+}
+
+/* NNTP send authentication if needed
+ * Accepts: SEND stream
+ *	    flags (non-NIL to get new extensions)
+ * Returns: T if need to redo command, NIL otherwise
+ */
+
+long nntp_send_auth (SENDSTREAM *stream,long flags)
+{
+  NETMBX mb;
+  char tmp[MAILTMPLEN];
+				/* remote name for authentication */
+  sprintf (tmp,"{%.200s/nntp",(long) mail_parameters (NIL,GET_TRUSTDNS,NIL) ?
+	   ((long) mail_parameters (NIL,GET_SASLUSESPTRNAME,NIL) ?
+	    net_remotehost (stream->netstream) : net_host (stream->netstream)):
+	   stream->host);
+  if (stream->netstream->dtb ==
+      (NETDRIVER *) mail_parameters (NIL,GET_SSLDRIVER,NIL))
+    strcat (tmp,"/ssl");
+  strcat (tmp,"}<none>");
+  mail_valid_net_parse (tmp,&mb);
+  return nntp_send_auth_work (stream,&mb,tmp,flags);
+}
+
+/* NNTP send authentication worker routine
+ * Accepts: SEND stream
+ *	    NETMBX structure
+ *	    scratch buffer of length MAILTMPLEN
+ *	    flags (non-NIL to get new extensions)
+ * Returns: T if authenticated, NIL otherwise
+ */
+
+long nntp_send_auth_work (SENDSTREAM *stream,NETMBX *mb,char *pwd,long flags)
+{
+  unsigned long trial,auths;
+  char tmp[MAILTMPLEN],usr[MAILTMPLEN];
+  AUTHENTICATOR *at;
+  char *lsterr = NIL;
+  long ret = NIL;
+				/* try SASL first */
+  for (auths = NNTP.ext.sasl, stream->saslcancel = NIL;
+       !ret && stream->netstream && auths &&
+       (at = mail_lookup_auth (find_rightmost_bit (&auths) + 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';		/* empty buffer */
+    if (stream->netstream) do {
+      if (lsterr) {
+	sprintf (tmp,"Retrying %s authentication after %.80s",at->name,lsterr);
+	mm_log (tmp,WARN);
+	fs_give ((void **) &lsterr);
+      }
+      stream->saslcancel = NIL;
+      if (nntp_send (stream,"AUTHINFO SASL",at->name) == NNTPCHALLENGE) {
+				/* hide client authentication responses */
+	if (!(at->flags & AU_SECURE)) stream->sensitive = T;
+	if ((*at->client) (nntp_challenge,nntp_response,"nntp",mb,stream,
+			   &trial,usr)) {
+	  if (stream->replycode == NNTPAUTHED) ret = LONGT;
+				/* if main program requested cancellation */
+	  else if (!trial) mm_log ("NNTP Authentication cancelled",ERROR);
+	}
+	stream->sensitive = NIL;/* unhide */
+      }
+				/* remember response if error and no cancel */
+      if (!ret && trial) lsterr = cpystr (stream->reply);
+    } while (!ret && stream->netstream && trial &&
+	     (trial < nntp_maxlogintrials));
+  }
+
+  if (lsterr) {			/* SAIL failed? */
+    if (!stream->saslcancel) {	/* don't do this if a cancel */
+      sprintf (tmp,"Can not authenticate to NNTP server: %.80s",lsterr);
+      mm_log (tmp,ERROR);
+    }
+    fs_give ((void **) &lsterr);
+  }
+  else if (mb->secflag)		/* no SASL, can't do /secure */
+    mm_log ("Can't do secure authentication with this server",ERROR);
+  else if (mb->authuser[0])	/* or /authuser */
+    mm_log ("Can't do /authuser with this server",ERROR);
+  /* Always try AUTHINFO USER, even if NNTP.ext.authuser isn't set.  There
+   * are servers that require it but don't return it as an extension.
+   */
+  else for (trial = 0, pwd[0] = 'x';
+	    !ret && pwd[0] && (trial < nntp_maxlogintrials) &&
+	      stream->netstream; ) {
+    pwd[0] = NIL;		/* get user name and password */
+    mm_login (mb,usr,pwd,trial++);
+				/* do the authentication */
+    if (pwd[0]) switch ((int) nntp_send_work (stream,"AUTHINFO USER",usr)) {
+    case NNTPBADCMD:		/* give up if unrecognized command */
+      mm_log (NNTP.ext.authuser ? stream->reply :
+	      "Can't do AUTHINFO USER to this server",ERROR);
+      trial = nntp_maxlogintrials;
+      break;
+    case NNTPAUTHED:		/* successful authentication */
+      ret = LONGT;		/* guess no password was needed */
+      break;
+    case NNTPWANTPASS:		/* wants password */
+      stream->sensitive = T;	/* hide this command */
+      if (nntp_send_work (stream,"AUTHINFO PASS",pwd) == NNTPAUTHED)
+	ret = LONGT;		/* password OK */
+      stream->sensitive = NIL;	/* unhide */
+      if (ret) break;		/* OK if successful */
+    default:			/* authentication failed */
+      mm_log (stream->reply,WARN);
+      if (trial == nntp_maxlogintrials)
+	mm_log ("Too many NNTP authentication failures",ERROR);
+    }
+				/* user refused to give a password */
+    else mm_log ("Login aborted",ERROR);
+  }
+  memset (pwd,0,MAILTMPLEN);	/* erase password */
+				/* get new extensions if needed */
+  if (ret && flags) nntp_extensions (stream,(mb->secflag ? AU_SECURE : NIL) |
+				     (mb->authuser[0] ? AU_AUTHUSER : NIL));
+  return ret;
+}
+
+/* Get challenge to authenticator in binary
+ * Accepts: stream
+ *	    pointer to returned size
+ * Returns: challenge or NIL if not challenge
+ */
+
+void *nntp_challenge (void *s,unsigned long *len)
+{
+  char tmp[MAILTMPLEN];
+  void *ret = NIL;
+  SENDSTREAM *stream = (SENDSTREAM *) s;
+  if ((stream->replycode == NNTPCHALLENGE) &&
+      !(ret = rfc822_base64 ((unsigned char *) stream->reply + 4,
+			     strlen (stream->reply + 4),len))) {
+    sprintf (tmp,"NNTP SERVER BUG (invalid challenge): %.80s",stream->reply+4);
+    mm_log (tmp,ERROR);
+  }
+  return ret;
+}
+
+
+/* Send authenticator response in BASE64
+ * Accepts: MAIL stream
+ *	    string to send
+ *	    length of string
+ * Returns: T, always
+ */
+
+long nntp_response (void *s,char *response,unsigned long size)
+{
+  SENDSTREAM *stream = (SENDSTREAM *) s;
+  unsigned long i,j;
+  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 */
+      i = nntp_send_work (stream,t,NIL);
+      fs_give ((void **) &t);
+    }
+    else i = nntp_send_work (stream,"",NIL);
+  }
+  else {			/* abort requested */
+    i = nntp_send_work (stream,"*",NIL);
+    stream->saslcancel = T;	/* mark protocol-requested SASL cancel */
+  }
+  return LONGT;
+}
+
+/* NNTP get reply
+ * Accepts: SEND stream
+ * Returns: reply code
+ */
+
+long nntp_reply (SENDSTREAM *stream)
+{
+				/* flush old reply */
+  if (stream->reply) fs_give ((void **) &stream->reply);
+  				/* get reply */
+  if (!(stream->reply = net_getline (stream->netstream)))
+    return nntp_fake (stream,"NNTP connection broken (response)");
+  if (stream->debug) mm_dlog (stream->reply);
+				/* handle continuation by recursion */
+  if (stream->reply[3] == '-') return nntp_reply (stream);
+				/* return response code */
+  return stream->replycode = atol (stream->reply);
+}
+
+
+/* NNTP set fake error
+ * Accepts: SEND stream
+ *	    error text
+ * Returns: error code
+ */
+
+long nntp_fake (SENDSTREAM *stream,char *text)
+{
+  if (stream->netstream) {	/* close net connection if still open */
+    net_close (stream->netstream);
+    stream->netstream = NIL;
+  }
+				/* flush any old reply */
+  if (stream->reply) fs_give ((void **) &stream->reply);
+  				/* set up pseudo-reply string */
+  stream->reply = (char *) fs_get (20+strlen (text));
+  sprintf (stream->reply,"%ld %s",NNTPSOFTFATAL,text);
+  return NNTPSOFTFATAL;		/* return error code */
+}
+
+/* NNTP filter mail
+ * Accepts: stream
+ *	    string
+ * Returns: T on success, NIL on failure
+ */
+
+long nntp_soutr (void *stream,char *s)
+{
+  char c,*t;
+				/* "." on first line */
+  if (s[0] == '.') net_soutr (stream,".");
+				/* find lines beginning with a "." */
+  while (t = strstr (s,"\015\012.")) {
+    c = *(t += 3);		/* remember next character after "." */
+    *t = '\0';			/* tie off string */
+				/* output prefix */
+    if (!net_soutr (stream,s)) return NIL;
+    *t = c;			/* restore delimiter */
+    s = t - 1;			/* push pointer up to the "." */
+  }
+				/* output remainder of text */
+  return *s ? net_soutr (stream,s) : T;
+}
diff --git a/imap/src/c-client/nntp.h b/imap/src/c-client/nntp.h
new file mode 100644
index 00000000..445ae4d7
--- /dev/null
+++ b/imap/src/c-client/nntp.h
@@ -0,0 +1,56 @@
+/* ========================================================================
+ * Copyright 1988-2006 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:	Network News Transfer Protocol (NNTP) routines
+ *
+ * Author:	Mark Crispin
+ *		Networks and Distributed Computing
+ *		Computing & Communications
+ *		University of Washington
+ *		Administration Building, AG-44
+ *		Seattle, WA  98195
+ *		Internet: MRC@CAC.Washington.EDU
+ *
+ * Date:	10 February 1992
+ * Last Edited:	30 August 2006
+ */
+
+/* Constants (should be in nntp.c) */
+
+#define NNTPTCPPORT (long) 119	/* assigned TCP contact port */
+
+
+/* NNTP open options
+ * For compatibility with the past, NOP_DEBUG must always be 1.
+ */
+
+#define NOP_DEBUG (long) 0x1	/* debug protocol negotiations */
+#define NOP_READONLY (long) 0x2	/* read-only open */
+#define NOP_TRYSSL (long) 0x4	/* try SSL first */
+				/* reserved for application use */
+#define NOP_RESERVED (unsigned long) 0xff000000
+
+
+/* Compatibility support names */
+
+#define nntp_open(hostlist,options) \
+  nntp_open_full (NIL,hostlist,"nntp",NIL,options)
+
+
+/* Function prototypes */
+
+SENDSTREAM *nntp_open_full (NETDRIVER *dv,char **hostlist,char *service,
+			    unsigned long port,long options);
+SENDSTREAM *nntp_close (SENDSTREAM *stream);
+long nntp_mail (SENDSTREAM *stream,ENVELOPE *msg,BODY *body);
diff --git a/imap/src/c-client/pop3.c b/imap/src/c-client/pop3.c
new file mode 100644
index 00000000..58a9ceb6
--- /dev/null
+++ b/imap/src/c-client/pop3.c
@@ -0,0 +1,1091 @@
+/* ========================================================================
+ * Copyright 1988-2007 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:	Post Office Protocol 3 (POP3) client routines
+ *
+ * Author:	Mark Crispin
+ *		Networks and Distributed Computing
+ *		Computing & Communications
+ *		University of Washington
+ *		Administration Building, AG-44
+ *		Seattle, WA  98195
+ *		Internet: MRC@CAC.Washington.EDU
+ *
+ * Date:	6 June 1994
+ * Last Edited:	4 April 2007
+ */
+
+
+#include <ctype.h>
+#include <stdio.h>
+#include <time.h>
+#include "c-client.h"
+#include "flstring.h"
+#include "netmsg.h"
+
+/* Parameters */
+
+#define POP3TCPPORT (long) 110	/* assigned TCP contact port */
+#define POP3SSLPORT (long) 995	/* assigned SSL TCP contact port */
+#define IDLETIMEOUT (long) 10	/* defined in RFC 1939 */
+
+
+/* POP3 I/O stream local data */
+	
+typedef struct pop3_local {
+  NETSTREAM *netstream;		/* TCP I/O stream */
+  char *response;		/* last server reply */
+  char *reply;			/* text of last server reply */
+  unsigned long cached;		/* current cached message uid */
+  unsigned long hdrsize;	/* current cached header size */
+  FILE *txt;			/* current cached file descriptor */
+  struct {
+    unsigned int capa : 1;	/* server has CAPA, definitely new */
+    unsigned int expire : 1;	/* server has EXPIRE */
+    unsigned int logindelay : 1;/* server has LOGIN-DELAY */
+    unsigned int stls : 1;	/* server has STLS */
+    unsigned int pipelining : 1;/* server has PIPELINING */
+    unsigned int respcodes : 1;	/* server has RESP-CODES */
+    unsigned int top : 1;	/* server has TOP */
+    unsigned int uidl : 1;	/* server has UIDL */
+    unsigned int user : 1;	/* server has USER */
+    char *implementation;	/* server implementation string */
+    long delaysecs;		/* minimum time between login (neg variable) */
+    long expiredays;		/* server-guaranteed minimum retention days */
+				/* supported authenticators */
+    unsigned int sasl : MAXAUTHENTICATORS;
+  } cap;
+  unsigned int sensitive : 1;	/* sensitive data in progress */
+  unsigned int loser : 1;	/* server is a loser */
+  unsigned int saslcancel : 1;	/* SASL cancelled by protocol */
+} POP3LOCAL;
+
+
+/* Convenient access to local data */
+
+#define LOCAL ((POP3LOCAL *) stream->local)
+
+/* Function prototypes */
+
+DRIVER *pop3_valid (char *name);
+void *pop3_parameters (long function,void *value);
+void pop3_scan (MAILSTREAM *stream,char *ref,char *pat,char *contents);
+void pop3_list (MAILSTREAM *stream,char *ref,char *pat);
+void pop3_lsub (MAILSTREAM *stream,char *ref,char *pat);
+long pop3_subscribe (MAILSTREAM *stream,char *mailbox);
+long pop3_unsubscribe (MAILSTREAM *stream,char *mailbox);
+long pop3_create (MAILSTREAM *stream,char *mailbox);
+long pop3_delete (MAILSTREAM *stream,char *mailbox);
+long pop3_rename (MAILSTREAM *stream,char *old,char *newname);
+long pop3_status (MAILSTREAM *stream,char *mbx,long flags);
+MAILSTREAM *pop3_open (MAILSTREAM *stream);
+long pop3_capa (MAILSTREAM *stream,long flags);
+long pop3_auth (MAILSTREAM *stream,NETMBX *mb,char *pwd,char *usr);
+void *pop3_challenge (void *stream,unsigned long *len);
+long pop3_response (void *stream,char *s,unsigned long size);
+void pop3_close (MAILSTREAM *stream,long options);
+void pop3_fetchfast (MAILSTREAM *stream,char *sequence,long flags);
+char *pop3_header (MAILSTREAM *stream,unsigned long msgno,unsigned long *size,
+		   long flags);
+long pop3_text (MAILSTREAM *stream,unsigned long msgno,STRING *bs,long flags);
+unsigned long pop3_cache (MAILSTREAM *stream,MESSAGECACHE *elt);
+long pop3_ping (MAILSTREAM *stream);
+void pop3_check (MAILSTREAM *stream);
+long pop3_expunge (MAILSTREAM *stream,char *sequence,long options);
+long pop3_copy (MAILSTREAM *stream,char *sequence,char *mailbox,long options);
+long pop3_append (MAILSTREAM *stream,char *mailbox,append_t af,void *data);
+
+long pop3_send_num (MAILSTREAM *stream,char *command,unsigned long n);
+long pop3_send (MAILSTREAM *stream,char *command,char *args);
+long pop3_reply (MAILSTREAM *stream);
+long pop3_fake (MAILSTREAM *stream,char *text);
+
+/* POP3 mail routines */
+
+
+/* Driver dispatch used by MAIL */
+
+DRIVER pop3driver = {
+  "pop3",			/* driver name */
+				/* driver flags */
+#ifdef INADEQUATE_MEMORY
+  DR_LOWMEM |
+#endif
+  DR_MAIL|DR_NOFAST|DR_CRLF|DR_NOSTICKY|DR_NOINTDATE|DR_NONEWMAIL,
+  (DRIVER *) NIL,		/* next driver */
+  pop3_valid,			/* mailbox is valid for us */
+  pop3_parameters,		/* manipulate parameters */
+  pop3_scan,			/* scan mailboxes */
+  pop3_list,			/* find mailboxes */
+  pop3_lsub,			/* find subscribed mailboxes */
+  pop3_subscribe,		/* subscribe to mailbox */
+  pop3_unsubscribe,		/* unsubscribe from mailbox */
+  pop3_create,			/* create mailbox */
+  pop3_delete,			/* delete mailbox */
+  pop3_rename,			/* rename mailbox */
+  pop3_status,			/* status of mailbox */
+  pop3_open,			/* open mailbox */
+  pop3_close,			/* close mailbox */
+  pop3_fetchfast,		/* fetch message "fast" attributes */
+  NIL,				/* fetch message flags */
+  NIL,				/* fetch overview */
+  NIL,				/* fetch message structure */
+  pop3_header,			/* fetch message header */
+  pop3_text,			/* fetch message text */
+  NIL,				/* fetch message */
+  NIL,				/* unique identifier */
+  NIL,				/* message number from UID */
+  NIL,				/* modify flags */
+  NIL,				/* per-message modify flags */
+  NIL,				/* search for message based on criteria */
+  NIL,				/* sort messages */
+  NIL,				/* thread messages */
+  pop3_ping,			/* ping mailbox to see if still alive */
+  pop3_check,			/* check for new messages */
+  pop3_expunge,			/* expunge deleted messages */
+  pop3_copy,			/* copy messages to another mailbox */
+  pop3_append,			/* append string message to mailbox */
+  NIL				/* garbage collect stream */
+};
+
+				/* prototype stream */
+MAILSTREAM pop3proto = {&pop3driver};
+
+				/* driver parameters */
+static unsigned long pop3_maxlogintrials = MAXLOGINTRIALS;
+static long pop3_port = 0;
+static long pop3_sslport = 0;
+
+/* POP3 mail validate mailbox
+ * Accepts: mailbox name
+ * Returns: our driver if name is valid, NIL otherwise
+ */
+
+DRIVER *pop3_valid (char *name)
+{
+  NETMBX mb;
+  return (mail_valid_net_parse (name,&mb) &&
+	  !strcmp (mb.service,pop3driver.name) && !mb.authuser[0] &&
+	  !compare_cstring (mb.mailbox,"INBOX")) ? &pop3driver : NIL;
+}
+
+
+/* News manipulate driver parameters
+ * Accepts: function code
+ *	    function-dependent value
+ * Returns: function-dependent return value
+ */
+
+void *pop3_parameters (long function,void *value)
+{
+  switch ((int) function) {
+  case SET_MAXLOGINTRIALS:
+    pop3_maxlogintrials = (unsigned long) value;
+    break;
+  case GET_MAXLOGINTRIALS:
+    value = (void *) pop3_maxlogintrials;
+    break;
+  case SET_POP3PORT:
+    pop3_port = (long) value;
+    break;
+  case GET_POP3PORT:
+    value = (void *) pop3_port;
+    break;
+  case SET_SSLPOPPORT:
+    pop3_sslport = (long) value;
+    break;
+  case GET_SSLPOPPORT:
+    value = (void *) pop3_sslport;
+    break;
+  case GET_IDLETIMEOUT:
+    value = (void *) IDLETIMEOUT;
+    break;
+  default:
+    value = NIL;		/* error case */
+    break;
+  }
+  return value;
+}
+
+/* POP3 mail scan mailboxes for string
+ * Accepts: mail stream
+ *	    reference
+ *	    pattern to search
+ *	    string to scan
+ */
+
+void pop3_scan (MAILSTREAM *stream,char *ref,char *pat,char *contents)
+{
+  char tmp[MAILTMPLEN];
+  if ((ref && *ref) ?		/* have a reference */
+      (pop3_valid (ref) && pmatch ("INBOX",pat)) :
+      (mail_valid_net (pat,&pop3driver,NIL,tmp) && pmatch ("INBOX",tmp)))
+    mm_log ("Scan not valid for POP3 mailboxes",ERROR);
+}
+
+
+/* POP3 mail find list of all mailboxes
+ * Accepts: mail stream
+ *	    reference
+ *	    pattern to search
+ */
+
+void pop3_list (MAILSTREAM *stream,char *ref,char *pat)
+{
+  char tmp[MAILTMPLEN];
+  if (ref && *ref) {		/* have a reference */
+    if (pop3_valid (ref) && pmatch ("INBOX",pat)) {
+      strcpy (strchr (strcpy (tmp,ref),'}')+1,"INBOX");
+      mm_list (stream,NIL,tmp,LATT_NOINFERIORS);
+    }
+  }
+  else if (mail_valid_net (pat,&pop3driver,NIL,tmp) && pmatch ("INBOX",tmp)) {
+    strcpy (strchr (strcpy (tmp,pat),'}')+1,"INBOX");
+    mm_list (stream,NIL,tmp,LATT_NOINFERIORS);
+  }
+}
+
+/* POP3 mail find list of subscribed mailboxes
+ * Accepts: mail stream
+ *	    reference
+ *	    pattern to search
+ */
+
+void pop3_lsub (MAILSTREAM *stream,char *ref,char *pat)
+{
+  void *sdb = NIL;
+  char *s,mbx[MAILTMPLEN];
+  if (*pat == '{') {		/* if remote pattern, must be POP3 */
+    if (!pop3_valid (pat)) return;
+    ref = NIL;			/* good POP3 pattern, punt reference */
+  }
+				/* if remote reference, must be valid POP3 */
+  if (ref && (*ref == '{') && !pop3_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 (pop3_valid (s) && pmatch (s,mbx))
+    mm_lsub (stream,NIL,s,NIL);
+  while (s = sm_read (&sdb));	/* until no more subscriptions */
+}
+
+
+/* POP3 mail subscribe to mailbox
+ * Accepts: mail stream
+ *	    mailbox to add to subscription list
+ * Returns: T on success, NIL on failure
+ */
+
+long pop3_subscribe (MAILSTREAM *stream,char *mailbox)
+{
+  return sm_subscribe (mailbox);
+}
+
+
+/* POP3 mail unsubscribe to mailbox
+ * Accepts: mail stream
+ *	    mailbox to delete from subscription list
+ * Returns: T on success, NIL on failure
+ */
+
+long pop3_unsubscribe (MAILSTREAM *stream,char *mailbox)
+{
+  return sm_unsubscribe (mailbox);
+}
+
+/* POP3 mail create mailbox
+ * Accepts: mail stream
+ *	    mailbox name to create
+ * Returns: T on success, NIL on failure
+ */
+
+long pop3_create (MAILSTREAM *stream,char *mailbox)
+{
+  return NIL;			/* never valid for POP3 */
+}
+
+
+/* POP3 mail delete mailbox
+ *	    mailbox name to delete
+ * Returns: T on success, NIL on failure
+ */
+
+long pop3_delete (MAILSTREAM *stream,char *mailbox)
+{
+  return NIL;			/* never valid for POP3 */
+}
+
+
+/* POP3 mail rename mailbox
+ * Accepts: mail stream
+ *	    old mailbox name
+ *	    new mailbox name
+ * Returns: T on success, NIL on failure
+ */
+
+long pop3_rename (MAILSTREAM *stream,char *old,char *newname)
+{
+  return NIL;			/* never valid for POP3 */
+}
+
+/* POP3 status
+ * Accepts: mail stream
+ *	    mailbox name
+ *	    status flags
+ * Returns: T on success, NIL on failure
+ */
+
+long pop3_status (MAILSTREAM *stream,char *mbx,long flags)
+{
+  MAILSTATUS status;
+  unsigned long i;
+  long ret = NIL;
+  MAILSTREAM *tstream =
+    (stream && LOCAL->netstream && mail_usable_network_stream (stream,mbx)) ?
+      stream : mail_open (NIL,mbx,OP_SILENT);
+  if (tstream) {		/* have a usable stream? */
+    status.flags = flags;	/* return status values */
+    status.messages = tstream->nmsgs;
+    status.recent = tstream->recent;
+    if (flags & SA_UNSEEN)	/* must search to get unseen messages */
+      for (i = 1,status.unseen = 0; i <= tstream->nmsgs; i++)
+	if (!mail_elt (tstream,i)->seen) status.unseen++;
+    status.uidnext = tstream->uid_last + 1;
+    status.uidvalidity = tstream->uid_validity;
+				/* pass status to main program */
+    mm_status (tstream,mbx,&status);
+    if (stream != tstream) mail_close (tstream);
+    ret = LONGT;
+  }
+  return ret;			/* success */
+}
+
+/* POP3 mail open
+ * Accepts: stream to open
+ * Returns: stream on success, NIL on failure
+ */
+
+MAILSTREAM *pop3_open (MAILSTREAM *stream)
+{
+  unsigned long i,j;
+  char *s,*t,tmp[MAILTMPLEN],usr[MAILTMPLEN];
+  NETMBX mb;
+  MESSAGECACHE *elt;
+				/* return prototype for OP_PROTOTYPE call */
+  if (!stream) return &pop3proto;
+  mail_valid_net_parse (stream->mailbox,&mb);
+  usr[0] = '\0';		/* initially no user name */
+  if (stream->local) fatal ("pop3 recycle stream");
+				/* /anonymous not supported */
+  if (mb.anoflag || stream->anonymous) {
+    mm_log ("Anonymous POP3 login not available",ERROR);
+    return NIL;
+  }
+				/* /readonly not supported either */
+  if (mb.readonlyflag || stream->rdonly) {
+    mm_log ("Read-only POP3 access not available",ERROR);
+    return NIL;
+  }
+				/* copy other switches */
+  if (mb.dbgflag) stream->debug = T;
+  if (mb.secflag) stream->secure = T;
+  mb.trysslflag = stream->tryssl = (mb.trysslflag || stream->tryssl) ? T : NIL;
+  stream->local =		/* instantiate localdata */
+    (void *) memset (fs_get (sizeof (POP3LOCAL)),0,sizeof (POP3LOCAL));
+  stream->sequence++;		/* bump sequence number */
+  stream->perm_deleted = T;	/* deleted is only valid flag */
+
+  if ((LOCAL->netstream =	/* try to open connection */
+       net_open (&mb,NIL,pop3_port ? pop3_port : POP3TCPPORT,
+		 (NETDRIVER *) mail_parameters (NIL,GET_SSLDRIVER,NIL),
+		 "*pop3s",pop3_sslport ? pop3_sslport : POP3SSLPORT)) &&
+      pop3_reply (stream)) {
+    mm_log (LOCAL->reply,NIL);	/* give greeting */
+    if (!pop3_auth (stream,&mb,tmp,usr)) pop3_close (stream,NIL);
+    else if (pop3_send (stream,"STAT",NIL)) {
+      int silent = stream->silent;
+      stream->silent = T;
+      sprintf (tmp,"{%.200s:%lu/pop3",
+	       (long) mail_parameters (NIL,GET_TRUSTDNS,NIL) ?
+	       net_host (LOCAL->netstream) : mb.host,
+	       net_port (LOCAL->netstream));
+      if (mb.tlsflag) strcat (tmp,"/tls");
+      if (mb.tlssslv23) strcat (tmp,"/tls-sslv23");
+      if (mb.notlsflag) strcat (tmp,"/notls");
+      if (mb.sslflag) strcat (tmp,"/ssl");
+      if (mb.novalidate) strcat (tmp,"/novalidate-cert");
+      if (LOCAL->loser = mb.loser) strcat (tmp,"/loser");
+      if (stream->secure) strcat (tmp,"/secure");
+      sprintf (tmp + strlen (tmp),"/user=\"%s\"}%s",usr,mb.mailbox);
+      stream->inbox = T;	/* always INBOX */
+      fs_give ((void **) &stream->mailbox);
+      stream->mailbox = cpystr (tmp);
+				/* notify upper level */
+      mail_exists (stream,stream->uid_last = strtoul (LOCAL->reply,NIL,10));
+      mail_recent (stream,stream->nmsgs);
+				/* instantiate elt */
+      for (i = 0; i < stream->nmsgs;) {
+	elt = mail_elt (stream,++i);
+	elt->valid = elt->recent = T;
+	elt->private.uid = i;
+      }
+
+				/* trust LIST output if new server */
+      if (!LOCAL->loser && LOCAL->cap.capa && pop3_send (stream,"LIST",NIL)) {
+	while ((s = net_getline (LOCAL->netstream)) && (*s != '.')) {
+	  if ((i = strtoul (s,&t,10)) && (i <= stream->nmsgs) &&
+	      (j = strtoul (t,NIL,10))) mail_elt (stream,i)->rfc822_size = j;
+	  fs_give ((void **) &s);
+	}
+				/* flush final dot */
+	if (s) fs_give ((void **) &s);
+	else {			/* lost connection */
+	  mm_log ("POP3 connection broken while itemizing messages",ERROR);
+	  pop3_close (stream,NIL);
+	  return NIL;
+	}
+      }
+      stream->silent = silent;	/* notify main program */
+      mail_exists (stream,stream->nmsgs);
+				/* notify if empty */
+      if (!(stream->nmsgs || stream->silent)) mm_log ("Mailbox is empty",WARN);
+    }
+    else {			/* error in STAT */
+      mm_log (LOCAL->reply,ERROR);
+      pop3_close (stream,NIL);	/* too bad */
+    }
+  }
+  else {			/* connection failed */
+    if (LOCAL->reply) mm_log (LOCAL->reply,ERROR);
+    pop3_close (stream,NIL);	/* failed, clean up */
+  }
+  return LOCAL ? stream : NIL;	/* if stream is alive, return to caller */
+}
+
+/* POP3 capabilities
+ * Accepts: stream
+ *	    authenticator flags
+ * Returns: T on success, NIL on failure
+ */
+
+long pop3_capa (MAILSTREAM *stream,long flags)
+{
+  unsigned long i;
+  char *s,*t,*r,*args;
+  if (LOCAL->cap.implementation)/* zap all old capabilities */
+    fs_give ((void **) &LOCAL->cap.implementation);
+  memset (&LOCAL->cap,0,sizeof (LOCAL->cap));
+				/* get server capabilities */
+  if (pop3_send (stream,"CAPA",NIL)) LOCAL->cap.capa = T;
+  else {
+    LOCAL->cap.user = T;	/* guess worst-case old server */
+    return NIL;			/* no CAPA on this server */
+  }
+  while ((t = net_getline (LOCAL->netstream)) && (t[1] || (*t != '.'))) {
+    if (stream->debug) mm_dlog (t);
+				/* get optional capability arguments */
+    if (args = strchr (t,' ')) *args++ = '\0';
+    if (!compare_cstring (t,"STLS")) LOCAL->cap.stls = T;
+    else if (!compare_cstring (t,"PIPELINING")) LOCAL->cap.pipelining = T;
+    else if (!compare_cstring (t,"RESP-CODES")) LOCAL->cap.respcodes = T;
+    else if (!compare_cstring (t,"TOP")) LOCAL->cap.top = T;
+    else if (!compare_cstring (t,"UIDL")) LOCAL->cap.uidl = T;
+    else if (!compare_cstring (t,"USER")) LOCAL->cap.user = T;
+    else if (!compare_cstring (t,"IMPLEMENTATION") && args)
+      LOCAL->cap.implementation = cpystr (args);
+    else if (!compare_cstring (t,"EXPIRE") && args) {
+      LOCAL->cap.expire = T;	/* note that it is present */
+      if (s = strchr(args,' ')){/* separate time from possible USER */
+	*s++ = '\0';
+				/* in case they add something after USER */
+	if ((strlen (s) > 4) && (s[4] == ' ')) s[4] = '\0';
+      }
+      LOCAL->cap.expire =	/* get expiration time */
+	(!compare_cstring (args,"NEVER")) ? 65535 :
+	  ((s && !compare_cstring (s,"USER")) ? -atoi (args) : atoi (args));
+    }
+    else if (!compare_cstring (t,"LOGIN-DELAY") && args) {
+      LOCAL->cap.logindelay = T;/* note that it is present */
+      if (s = strchr(args,' ')){/* separate time from possible USER */
+	*s++ = '\0';
+				/* in case they add something after USER */
+	if ((strlen (s) > 4) && (s[4] == ' ')) s[4] = '\0';
+      }
+				/* get delay time */
+      LOCAL->cap.delaysecs = (s && !compare_cstring (s,"USER")) ?
+	-atoi (args) : atoi (args);
+    }
+    else if (!compare_cstring (t,"SASL") && args)
+      for (args = strtok_r (args," ",&r); args; args = strtok_r (NIL," ",&r))
+	if ((i = mail_lookup_auth_name (args,flags)) &&
+	    (--i < MAXAUTHENTICATORS))
+	  LOCAL->cap.sasl |= (1 << i);
+    fs_give ((void **) &t);
+  }
+  if (t) {			/* flush end of text indicator */
+    if (stream->debug) mm_dlog (t);
+    fs_give ((void **) &t);
+  }
+  return LONGT;
+}
+
+/* POP3 authenticate
+ * 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 pop3_auth (MAILSTREAM *stream,NETMBX *mb,char *pwd,char *usr)
+{
+  unsigned long i,trial,auths = 0;
+  char *t;
+  AUTHENTICATOR *at;
+  long ret = NIL;
+  long flags = (stream->secure ? AU_SECURE : NIL) |
+    (mb->authuser[0] ? AU_AUTHUSER : NIL);
+  long capaok = pop3_capa (stream,flags);
+  NETDRIVER *ssld = (NETDRIVER *) mail_parameters (NIL,GET_SSLDRIVER,NIL);
+  sslstart_t stls = (sslstart_t) mail_parameters (NIL,GET_SSLSTART,NIL);
+				/* server has TLS? */
+  if (stls && LOCAL->cap.stls && !mb->sslflag && !mb->notlsflag &&
+      pop3_send (stream,"STLS",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;
+      return NIL;		/* TLS negotiation failed */
+    }
+    pop3_capa (stream,flags);	/* get capabilities now that TLS in effect */
+  }
+  else if (mb->tlsflag) {	/* user specified /tls but can't do it */
+    mm_log ("Unable to negotiate TLS with this server",ERROR);
+    return NIL;
+  }
+  				/* get authenticators from capabilities */
+  if (capaok) auths = LOCAL->cap.sasl;
+				/* get list of authenticators */
+  else if (pop3_send (stream,"AUTH",NIL)) {
+    while ((t = net_getline (LOCAL->netstream)) && (t[1] || (*t != '.'))) {
+      if (stream->debug) mm_dlog (t);
+      if ((i = mail_lookup_auth_name (t,flags)) && (--i < MAXAUTHENTICATORS))
+	auths |= (1 << i);
+      fs_give ((void **) &t);
+    }
+    if (t) {			/* flush end of text indicator */
+      if (stream->debug) mm_dlog (t);
+      fs_give ((void **) &t);
+    }
+  }
+				/* disable LOGIN if PLAIN also advertised */
+  if ((i = mail_lookup_auth_name ("PLAIN",NIL)) && (--i < MAXAUTHENTICATORS) &&
+      (auths & (1 << i)) &&
+      (i = mail_lookup_auth_name ("LOGIN",NIL)) && (--i < MAXAUTHENTICATORS))
+    auths &= ~(1 << i);
+
+  if (auths) {			/* got any authenticators? */
+    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';
+    }
+    for (t = NIL, LOCAL->saslcancel = NIL; !ret && LOCAL->netstream && auths &&
+	 (at = mail_lookup_auth (find_rightmost_bit (&auths)+1)); ) {
+      if (t) {			/* previous authenticator failed? */
+	sprintf (pwd,"Retrying using %.80s authentication after %.80s",
+		 at->name,t);
+	mm_log (pwd,NIL);
+	fs_give ((void **) &t);
+      }
+      trial = 0;		/* initial trial count */
+      do {
+	if (t) {
+	  sprintf (pwd,"Retrying %s authentication after %.80s",at->name,t);
+	  mm_log (pwd,WARN);
+	  fs_give ((void **) &t);
+	}
+	LOCAL->saslcancel = NIL;
+	if (pop3_send (stream,"AUTH",at->name)) {
+				/* hide client authentication responses */
+	  if (!(at->flags & AU_SECURE)) LOCAL->sensitive = T;
+	  if ((*at->client) (pop3_challenge,pop3_response,"pop",mb,stream,
+			     &trial,usr) && LOCAL->response) {
+	    if (*LOCAL->response == '+') ret = LONGT;
+				/* if main program requested cancellation */
+	    else if (!trial) mm_log ("POP3 Authentication cancelled",ERROR);
+	  }
+	  LOCAL->sensitive=NIL;	/* unhide */
+	}
+				/* remember response if error and no cancel */
+	if (!ret && trial) t = cpystr (LOCAL->reply);
+      } while (!ret && trial && (trial < pop3_maxlogintrials) &&
+	       LOCAL->netstream);
+    }
+    if (t) {			/* previous authenticator failed? */
+      if (!LOCAL->saslcancel) {	/* don't do this if a cancel */
+	sprintf (pwd,"Can not authenticate to POP3 server: %.80s",t);
+	mm_log (pwd,ERROR);
+      }
+      fs_give ((void **) &t);
+    }
+  }
+
+  else if (stream->secure)
+    mm_log ("Can't do secure authentication with this server",ERROR);
+  else if (mb->authuser[0])
+    mm_log ("Can't do /authuser with this server",ERROR);
+  else if (!LOCAL->cap.user) mm_log ("Can't login to this server",ERROR);
+  else {			/* traditional login */
+    trial = 0;			/* initial trial count */
+    do {
+      pwd[0] = 0;		/* prompt user for password */
+      mm_login (mb,usr,pwd,trial++);
+      if (pwd[0]) {		/* send login sequence if have password */
+	if (pop3_send (stream,"USER",usr)) {
+	  LOCAL->sensitive = T;	/* hide this command */
+	  if (pop3_send (stream,"PASS",pwd)) ret = LONGT;
+	  LOCAL->sensitive=NIL;	/* unhide */
+	}
+	if (!ret) {		/* failure */
+	  mm_log (LOCAL->reply,WARN);
+	  if (trial == pop3_maxlogintrials)
+	    mm_log ("Too many login failures",ERROR);
+	}
+      }
+				/* user refused to give password */
+      else mm_log ("Login aborted",ERROR);
+    } while (!ret && pwd[0] && (trial < pop3_maxlogintrials) &&
+	     LOCAL->netstream);
+  }
+  memset (pwd,0,MAILTMPLEN);	/* erase password */
+				/* get capabilities if logged in */
+  if (ret && capaok) pop3_capa (stream,flags);
+  return ret;
+}
+
+/* Get challenge to authenticator in binary
+ * Accepts: stream
+ *	    pointer to returned size
+ * Returns: challenge or NIL if not challenge
+ */
+
+void *pop3_challenge (void *s,unsigned long *len)
+{
+  char tmp[MAILTMPLEN];
+  void *ret = NIL;
+  MAILSTREAM *stream = (MAILSTREAM *) s;
+  if (stream && LOCAL->response &&
+      (*LOCAL->response == '+') && (LOCAL->response[1] == ' ') &&
+      !(ret = rfc822_base64 ((unsigned char *) LOCAL->reply,
+			     strlen (LOCAL->reply),len))) {
+    sprintf (tmp,"POP3 SERVER BUG (invalid challenge): %.80s",LOCAL->reply);
+    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 pop3_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'; *u = '\0';
+      ret = net_sout (LOCAL->netstream,t,u - t);
+      fs_give ((void **) &t);
+    }
+    else ret = net_sout (LOCAL->netstream,"\015\012",2);
+  }
+  else {			/* abort requested */
+    ret = net_sout (LOCAL->netstream,"*\015\012",3);
+    LOCAL->saslcancel = T;	/* mark protocol-requested SASL cancel */
+  }
+  pop3_reply (stream);		/* get response */
+  return ret;
+}
+
+/* POP3 mail close
+ * Accepts: MAIL stream
+ *	    option flags
+ */
+
+void pop3_close (MAILSTREAM *stream,long options)
+{
+  int silent = stream->silent;
+  if (LOCAL) {			/* only if a file is open */
+    if (LOCAL->netstream) {	/* close POP3 connection */
+      stream->silent = T;
+      if (options & CL_EXPUNGE) pop3_expunge (stream,NIL,NIL);
+      stream->silent = silent;
+      pop3_send (stream,"QUIT",NIL);
+      mm_notify (stream,LOCAL->reply,BYE);
+    }
+				/* close POP3 connection */
+    if (LOCAL->netstream) net_close (LOCAL->netstream);
+				/* clean up */
+    if (LOCAL->cap.implementation)
+      fs_give ((void **) &LOCAL->cap.implementation);
+    if (LOCAL->txt) fclose (LOCAL->txt);
+    LOCAL->txt = NIL;
+    if (LOCAL->response) fs_give ((void **) &LOCAL->response);
+				/* nuke the local data */
+    fs_give ((void **) &stream->local);
+    stream->dtb = NIL;		/* log out the DTB */
+  }
+}
+
+/* POP3 mail fetch fast information
+ * Accepts: MAIL stream
+ *	    sequence
+ *	    option flags
+ * This is ugly and slow
+ */
+
+void pop3_fetchfast (MAILSTREAM *stream,char *sequence,long flags)
+{
+  unsigned long i;
+  MESSAGECACHE *elt;
+				/* get sequence */
+  if (stream && LOCAL && ((flags & FT_UID) ?
+			  mail_uid_sequence (stream,sequence) :
+			  mail_sequence (stream,sequence)))
+    for (i = 1; i <= stream->nmsgs; i++)
+      if ((elt = mail_elt (stream,i))->sequence &&
+	  !(elt->day && elt->rfc822_size)) {
+	ENVELOPE **env = NIL;
+	ENVELOPE *e = NIL;
+	if (!stream->scache) env = &elt->private.msg.env;
+	else if (stream->msgno == i) env = &stream->env;
+	else env = &e;
+	if (!*env || !elt->rfc822_size) {
+	  STRING bs;
+	  unsigned long hs;
+	  char *ht = (*stream->dtb->header) (stream,i,&hs,NIL);
+				/* need to make an envelope? */
+	  if (!*env) rfc822_parse_msg (env,NIL,ht,hs,NIL,BADHOST,
+				       stream->dtb->flags);
+				/* need message size too, ugh */
+	  if (!elt->rfc822_size) {
+	    (*stream->dtb->text) (stream,i,&bs,FT_PEEK);
+	    elt->rfc822_size = hs + SIZE (&bs) - GETPOS (&bs);
+	  }
+	}
+				/* if need date, have date in envelope? */
+	if (!elt->day && *env && (*env)->date)
+	  mail_parse_date (elt,(*env)->date);
+				/* sigh, fill in bogus default */
+	if (!elt->day) elt->day = elt->month = 1;
+	mail_free_envelope (&e);
+      }
+}
+
+/* POP3 fetch header as text
+ * Accepts: mail stream
+ *	    message number
+ *	    pointer to return size
+ *	    flags
+ * Returns: header text
+ */
+
+char *pop3_header (MAILSTREAM *stream,unsigned long msgno,unsigned long *size,
+		   long flags)
+{
+  unsigned long i;
+  char tmp[MAILTMPLEN];
+  MESSAGECACHE *elt;
+  FILE *f = NIL;
+  *size = 0;			/* initially no header size */
+  if ((flags & FT_UID) && !(msgno = mail_msgno (stream,msgno))) return "";
+				/* have header text already? */
+  if (!(elt = mail_elt (stream,msgno))->private.msg.header.text.data) {
+				/* if have CAPA and TOP, assume good TOP */
+    if (!LOCAL->loser && LOCAL->cap.top) {
+      sprintf (tmp,"TOP %lu 0",mail_uid (stream,msgno));
+      if (pop3_send (stream,tmp,NIL))
+	f = netmsg_slurp (LOCAL->netstream,&i,
+			  &elt->private.msg.header.text.size);
+    }
+				/* otherwise load the cache with the message */
+    else if (elt->private.msg.header.text.size = pop3_cache (stream,elt))
+      f = LOCAL->txt;
+    if (f) {			/* got it, make sure at start of file */
+      fseek (f,(unsigned long) 0,SEEK_SET);
+				/* read header from the cache */
+      fread (elt->private.msg.header.text.data = (unsigned char *)
+	     fs_get ((size_t) elt->private.msg.header.text.size + 1),
+	     (size_t) 1,(size_t) elt->private.msg.header.text.size,f);
+				/* tie off header text */
+      elt->private.msg.header.text.data[elt->private.msg.header.text.size] =
+	'\0';
+				/* close if not the cache */
+      if (f != LOCAL->txt) fclose (f);
+    }
+  }
+				/* return size of text */
+  if (size) *size = elt->private.msg.header.text.size;
+  return elt->private.msg.header.text.data ?
+    (char *) elt->private.msg.header.text.data : "";
+}
+
+/* POP3 fetch body
+ * Accepts: mail stream
+ *	    message number
+ *	    pointer to stringstruct to initialize
+ *	    flags
+ * Returns: T if successful, else NIL
+ */
+
+long pop3_text (MAILSTREAM *stream,unsigned long msgno,STRING *bs,long flags)
+{
+  MESSAGECACHE *elt;
+  INIT (bs,mail_string,(void *) "",0);
+  if ((flags & FT_UID) && !(msgno = mail_msgno (stream,msgno))) return NIL;
+  elt = mail_elt (stream,msgno);
+  pop3_cache (stream,elt);	/* make sure cache loaded */
+  if (!LOCAL->txt) return NIL;	/* error if don't have a file */
+  if (!(flags & FT_PEEK)) {	/* mark seen if needed */
+    elt->seen = T;
+    mm_flags (stream,elt->msgno);
+  }
+  INIT (bs,file_string,(void *) LOCAL->txt,elt->rfc822_size);
+  SETPOS (bs,LOCAL->hdrsize);	/* skip past header */
+  return T;
+}
+
+/* POP3 cache message
+ * Accepts: mail stream
+ *	    message number
+ * Returns: header size
+ */
+
+unsigned long pop3_cache (MAILSTREAM *stream,MESSAGECACHE *elt)
+{
+				/* already cached? */
+  if (LOCAL->cached != mail_uid (stream,elt->msgno)) {
+				/* no, close current file */
+    if (LOCAL->txt) fclose (LOCAL->txt);
+    LOCAL->txt = NIL;
+    LOCAL->cached = LOCAL->hdrsize = 0;
+    if (pop3_send_num (stream,"RETR",elt->msgno) &&
+	(LOCAL->txt = netmsg_slurp (LOCAL->netstream,&elt->rfc822_size,
+				    &LOCAL->hdrsize)))
+				/* set as current message number */
+      LOCAL->cached = mail_uid (stream,elt->msgno);
+    else elt->deleted = T;
+  }
+  return LOCAL->hdrsize;
+}
+
+/* POP3 mail ping mailbox
+ * Accepts: MAIL stream
+ * Returns: T if stream alive, else NIL
+ */
+
+long pop3_ping (MAILSTREAM *stream)
+{
+  return pop3_send (stream,"NOOP",NIL);
+}
+
+
+/* POP3 mail check mailbox
+ * Accepts: MAIL stream
+ */
+
+void pop3_check (MAILSTREAM *stream)
+{
+  if (pop3_ping (stream)) mm_log ("Check completed",NIL);
+}
+
+
+/* POP3 mail expunge mailbox
+ * Accepts: MAIL stream
+ *	    sequence to expunge if non-NIL
+ *	    expunge options
+ * Returns: T if success, NIL if failure
+ */
+
+long pop3_expunge (MAILSTREAM *stream,char *sequence,long options)
+{
+  char tmp[MAILTMPLEN];
+  MESSAGECACHE *elt;
+  unsigned long i = 1,n = 0;
+  long ret;
+  if (ret = sequence ? ((options & EX_UID) ?
+			mail_uid_sequence (stream,sequence) :
+			mail_sequence (stream,sequence)) :
+      LONGT) {			/* build selected sequence if needed */
+    while (i <= stream->nmsgs) {
+      elt = mail_elt (stream,i);
+      if (elt->deleted && (sequence ? elt->sequence : T) &&
+	  pop3_send_num (stream,"DELE",i)) {
+				/* expunging currently cached message? */
+	if (LOCAL->cached == mail_uid (stream,i)) {
+				/* yes, close current file */
+	  if (LOCAL->txt) fclose (LOCAL->txt);
+	  LOCAL->txt = NIL;
+	  LOCAL->cached = LOCAL->hdrsize = 0;
+	}
+	mail_expunged (stream,i);
+	n++;
+      }
+      else i++;			/* try next message */
+    }
+    if (!stream->silent) {	/* only if not silent */
+      if (n) {			/* did we expunge anything? */
+	sprintf (tmp,"Expunged %lu messages",n);
+	mm_log (tmp,(long) NIL);
+      }
+      else mm_log ("No messages deleted, so no update needed",(long) NIL);
+    }
+  }
+  return ret;
+}
+
+/* POP3 mail copy message(s)
+ * Accepts: MAIL stream
+ *	    sequence
+ *	    destination mailbox
+ *	    option flags
+ * Returns: T if copy successful, else NIL
+ */
+
+long pop3_copy (MAILSTREAM *stream,char *sequence,char *mailbox,long options)
+{
+  mailproxycopy_t pc =
+    (mailproxycopy_t) mail_parameters (stream,GET_MAILPROXYCOPY,NIL);
+  if (pc) return (*pc) (stream,sequence,mailbox,options);
+  mm_log ("Copy not valid for POP3",ERROR);
+  return NIL;
+}
+
+
+/* POP3 mail append message from stringstruct
+ * Accepts: MAIL stream
+ *	    destination mailbox
+ *	    append callback
+ *	    data for callback
+ * Returns: T if append successful, else NIL
+ */
+
+long pop3_append (MAILSTREAM *stream,char *mailbox,append_t af,void *data)
+{
+  mm_log ("Append not valid for POP3",ERROR);
+  return NIL;
+}
+
+/* Internal routines */
+
+
+/* Post Office Protocol 3 send command with number argument
+ * Accepts: MAIL stream
+ *	    command
+ *	    number
+ * Returns: T if successful, NIL if failure
+ */
+
+long pop3_send_num (MAILSTREAM *stream,char *command,unsigned long n)
+{
+  char tmp[MAILTMPLEN];
+  sprintf (tmp,"%lu",mail_uid (stream,n));
+  return pop3_send (stream,command,tmp);
+}
+
+
+/* Post Office Protocol 3 send command
+ * Accepts: MAIL stream
+ *	    command
+ *	    command argument
+ * Returns: T if successful, NIL if failure
+ */
+
+long pop3_send (MAILSTREAM *stream,char *command,char *args)
+{
+  long ret;
+  char *s = (char *) fs_get (strlen (command) + (args ? strlen (args) + 1: 0)
+			     + 3);
+  mail_lock (stream);		/* lock up the stream */
+  if (!LOCAL->netstream) ret = pop3_fake (stream,"POP3 connection lost");
+  else {			/* build the complete command */
+    if (args) sprintf (s,"%s %s",command,args);
+    else strcpy (s,command);
+    if (stream->debug) mail_dlog (s,LOCAL->sensitive);
+    strcat (s,"\015\012");
+				/* send the command */
+    ret = net_soutr (LOCAL->netstream,s) ? pop3_reply (stream) :
+      pop3_fake (stream,"POP3 connection broken in command");
+  }
+  fs_give ((void **) &s);
+  mail_unlock (stream);		/* unlock stream */
+  return ret;
+}
+
+/* Post Office Protocol 3 get reply
+ * Accepts: MAIL stream
+ * Returns: T if success reply, NIL if error reply
+ */
+
+long pop3_reply (MAILSTREAM *stream)
+{
+  char *s;
+				/* flush old reply */
+  if (LOCAL->response) fs_give ((void **) &LOCAL->response);
+  				/* get reply */
+  if (!(LOCAL->response = net_getline (LOCAL->netstream)))
+    return pop3_fake (stream,"POP3 connection broken in response");
+  if (stream->debug) mm_dlog (LOCAL->response);
+  LOCAL->reply = (s = strchr (LOCAL->response,' ')) ? s + 1 : LOCAL->response;
+				/* return success or failure */
+  return (*LOCAL->response =='+') ? T : NIL;
+}
+
+
+/* Post Office Protocol 3 set fake error
+ * Accepts: MAIL stream
+ *	    error text
+ * Returns: NIL, always
+ */
+
+long pop3_fake (MAILSTREAM *stream,char *text)
+{
+  mm_notify (stream,text,BYE);	/* send bye alert */
+  if (LOCAL->netstream) net_close (LOCAL->netstream);
+  LOCAL->netstream = NIL;	/* farewell, dear TCP stream */
+				/* flush any old reply */
+  if (LOCAL->response) fs_give ((void **) &LOCAL->response);
+  LOCAL->reply = text;		/* set up pseudo-reply string */
+  return NIL;			/* return error code */
+}
diff --git a/imap/src/c-client/rfc822.c b/imap/src/c-client/rfc822.c
new file mode 100644
index 00000000..d9239646
--- /dev/null
+++ b/imap/src/c-client/rfc822.c
@@ -0,0 +1,2373 @@
+/* ========================================================================
+ * 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:	RFC 2822 and MIME routines
+ *
+ * Author:	Mark Crispin
+ *		UW Technology
+ *		University of Washington
+ *		Seattle, WA  98195
+ *		Internet: MRC@Washington.EDU
+ *
+ * Date:	27 July 1988
+ * Last Edited:	14 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 NationalInstitutes of Health
+ * under grant number RR-00785.
+ */
+
+
+#include <ctype.h>
+#include <stdio.h>
+#include <time.h>
+#include "c-client.h"
+
+
+/* Support for deprecated features in earlier specifications.  Note that this
+ * module follows RFC 2822, and all use of "rfc822" in function names is
+ * for compatibility.  Only the code identified by the conditionals below
+ * follows the earlier documents.
+ */
+
+#define RFC733 1		/* parse "at" */
+#define RFC822 0		/* generate A-D-L (MUST be 0 for 2822) */
+
+/* RFC-822 static data */
+
+#define RFC822CONT "    "	/* RFC 2822 continuation */
+
+				/* should have been "Remailed-" */
+#define RESENTPREFIX "ReSent-"
+static char *resentprefix = RESENTPREFIX;
+				/* syntax error host string */
+static const char *errhst = ERRHOST;
+
+
+/* Body formats constant strings, must match definitions in mail.h */
+
+char *body_types[TYPEMAX+1] = {
+  "TEXT", "MULTIPART", "MESSAGE", "APPLICATION", "AUDIO", "IMAGE", "VIDEO",
+  "MODEL", "X-UNKNOWN"
+};
+
+
+char *body_encodings[ENCMAX+1] = {
+  "7BIT", "8BIT", "BINARY", "BASE64", "QUOTED-PRINTABLE", "X-UNKNOWN"
+};
+
+
+/* Token delimiting special characters */
+
+				/* RFC 2822 specials */
+const char *specials = " ()<>@,;:\\\"[].\1\2\3\4\5\6\7\10\11\12\13\14\15\16\17\20\21\22\23\24\25\26\27\30\31\32\33\34\35\36\37\177";
+				/* RFC 2822 phrase specials (no space) */
+const char *rspecials = "()<>@,;:\\\"[].\1\2\3\4\5\6\7\10\11\12\13\14\15\16\17\20\21\22\23\24\25\26\27\30\31\32\33\34\35\36\37\177";
+				/* RFC 2822 dot-atom specials (no dot) */
+const char *wspecials = " ()<>@,;:\\\"[]\1\2\3\4\5\6\7\10\11\12\13\14\15\16\17\20\21\22\23\24\25\26\27\30\31\32\33\34\35\36\37\177";
+				/* RFC 2045 MIME body token specials */
+const char *tspecials = " ()<>@,;:\\\"[]/?=\1\2\3\4\5\6\7\10\11\12\13\14\15\16\17\20\21\22\23\24\25\26\27\30\31\32\33\34\35\36\37\177";
+
+/* Subtype defaulting (a no-no, but regretably necessary...)
+ * Accepts: type code
+ * Returns: default subtype name
+ */
+
+char *rfc822_default_subtype (unsigned short type)
+{
+  switch (type) {
+  case TYPETEXT:		/* default is TEXT/PLAIN */
+    return "PLAIN";
+  case TYPEMULTIPART:		/* default is MULTIPART/MIXED */
+    return "MIXED";
+  case TYPEMESSAGE:		/* default is MESSAGE/RFC822 */
+    return "RFC822";
+  case TYPEAPPLICATION:		/* default is APPLICATION/OCTET-STREAM */
+    return "OCTET-STREAM";
+  case TYPEAUDIO:		/* default is AUDIO/BASIC */
+    return "BASIC";
+  default:			/* others have no default subtype */
+    return "UNKNOWN";
+  }
+}
+
+/* RFC 2822 parsing routines */
+
+
+/* Parse an RFC 2822 message
+ * Accepts: pointer to return envelope
+ *	    pointer to return body
+ *	    pointer to header
+ *	    header byte count
+ *	    pointer to body stringstruct
+ *	    pointer to local host name
+ *	    recursion depth
+ *	    source driver flags
+ */
+
+void rfc822_parse_msg_full (ENVELOPE **en,BODY **bdy,char *s,unsigned long i,
+			    STRING *bs,char *host,unsigned long depth,
+			    unsigned long flags)
+{
+  char c,*t,*d;
+  char *tmp = (char *) fs_get ((size_t) i + 100);
+  ENVELOPE *env = (*en = mail_newenvelope ());
+  BODY *body = bdy ? (*bdy = mail_newbody ()) : NIL;
+  long MIMEp = -1;		/* flag that MIME semantics are in effect */
+  long PathP = NIL;             /* flag that a Path: was seen */
+  parseline_t pl = (parseline_t) mail_parameters (NIL,GET_PARSELINE,NIL);
+  if (!host) host = BADHOST;	/* make sure that host is non-null */
+  while (i && *s != '\n') {	/* until end of header */
+    t = tmp;			/* initialize buffer pointer */
+    c = ' ';			/* and previous character */
+    while (i && c) {		/* collect text until logical end of line */
+      switch (c = *s++) {	/* slurp a character */
+      case '\015':		/* return, possible end of logical line */
+	if (*s == '\n') break;	/* ignore if LF follows */
+      case '\012':		/* LF, possible end of logical line */
+				/* tie off unless next line starts with WS */
+	if (*s != ' ' && *s != '\t') *t++ = c = '\0';
+	break;
+      case '\t':		/* tab */
+	*t++ = ' ';		/* coerce to space */
+	break;
+      default:			/* all other characters */
+	*t++ = c;		/* insert the character into the line */
+	break;
+      }
+      if (!--i) *t++ = '\0';	/* see if end of header */
+    }
+
+				/* find header item type */
+    if (t = d = strchr (tmp,':')) {
+      *d++ = '\0';		/* tie off header item, point at its data */
+      while (*d == ' ') d++;	/* flush whitespace */
+      while ((tmp < t--) && (*t == ' ')) *t = '\0';
+      ucase (tmp);		/* coerce to uppercase */
+				/* external callback */
+      if (pl) (*pl) (env,tmp,d,host);
+      switch (*tmp) {		/* dispatch based on first character */
+      case '>':			/* possible >From: */
+	if (!strcmp (tmp+1,"FROM")) rfc822_parse_adrlist (&env->from,d,host);
+	break;
+      case 'B':			/* possible bcc: */
+	if (!strcmp (tmp+1,"CC")) rfc822_parse_adrlist (&env->bcc,d,host);
+	break;
+      case 'C':			/* possible cc: or Content-<mumble>*/
+	if (!strcmp (tmp+1,"C")) rfc822_parse_adrlist (&env->cc,d,host);
+	else if ((tmp[1] == 'O') && (tmp[2] == 'N') && (tmp[3] == 'T') &&
+		 (tmp[4] == 'E') && (tmp[5] == 'N') && (tmp[6] == 'T') &&
+		 (tmp[7] == '-') && body)
+	  switch (MIMEp) {
+	  case -1:		/* unknown if MIME or not */
+	    if (!(MIMEp =	/* see if MIME-Version header exists */
+		  search ((unsigned char *) s-1,i,
+			  (unsigned char *)"\012MIME-Version",(long) 13))) {
+#if 1
+	      /* This is a disgusting kludge, and most of the messages which
+	       * benefit from it are spam.
+	       */
+	      if (!strcmp (tmp+8,"TRANSFER-ENCODING") ||
+		  (!strcmp (tmp+8,"TYPE") && strchr (d,'/'))) {
+		MM_LOG ("Warning: MIME header encountered in non-MIME message",
+			PARSE);
+		MIMEp = 1;	/* declare MIME now */
+	      }
+	      else
+#endif
+		break;		/* non-MIME message */
+	    }
+	  case T:		/* definitely MIME */
+	    rfc822_parse_content_header (body,tmp+8,d);
+	  }
+	break;
+      case 'D':			/* possible Date: */
+	if (!env->date && !strcmp (tmp+1,"ATE")) env->date = cpystr (d);
+	break;
+      case 'F':			/* possible From: */
+	if (!strcmp (tmp+1,"ROM")) rfc822_parse_adrlist (&env->from,d,host);
+	else if (!strcmp (tmp+1,"OLLOWUP-TO")) {
+	  t = env->followup_to = (char *) fs_get (1 + strlen (d));
+	  while (c = *d++) if (c != ' ') *t++ = c;
+	  *t++ = '\0';
+	}
+	break;
+      case 'I':			/* possible In-Reply-To: */
+	if (!env->in_reply_to && !strcmp (tmp+1,"N-REPLY-TO"))
+	  env->in_reply_to = cpystr (d);
+	break;
+
+      case 'M':			/* possible Message-ID: or MIME-Version: */
+	if (!env->message_id && !strcmp (tmp+1,"ESSAGE-ID"))
+	  env->message_id = cpystr (d);
+	else if (!strcmp (tmp+1,"IME-VERSION")) {
+				/* tie off at end of phrase */
+	  if (t = rfc822_parse_phrase (d)) *t = '\0';
+	  rfc822_skipws (&d);	/* skip whitespace */
+				/* known version? */
+	  if (strcmp (d,"1.0") && strcmp (d,"RFC-XXXX"))
+	    MM_LOG ("Warning: message has unknown MIME version",PARSE);
+	  MIMEp = T;		/* note that we are MIME */
+	}
+	break;
+      case 'N':			/* possible Newsgroups: */
+	if (!env->newsgroups && !strcmp (tmp+1,"EWSGROUPS")) {
+	  t = env->newsgroups = (char *) fs_get (1 + strlen (d));
+	  while (c = *d++) if (c != ' ') *t++ = c;
+	  *t++ = '\0';
+	}
+	break;
+      case 'P':                 /* possible Path: */
+	if (!strcmp (tmp+1,"ATH")) env->ngpathexists = T;
+	break;
+      case 'R':			/* possible Reply-To: */
+	if (!strcmp (tmp+1,"EPLY-TO"))
+	  rfc822_parse_adrlist (&env->reply_to,d,host);
+	else if (!env->references && !strcmp (tmp+1,"EFERENCES"))
+	  env->references = cpystr (d);
+	break;
+      case 'S':			/* possible Subject: or Sender: */
+	if (!env->subject && !strcmp (tmp+1,"UBJECT"))
+	  env->subject = cpystr (d);
+	else if (!strcmp (tmp+1,"ENDER"))
+	  rfc822_parse_adrlist (&env->sender,d,host);
+	break;
+      case 'T':			/* possible To: */
+	if (!strcmp (tmp+1,"O")) rfc822_parse_adrlist (&env->to,d,host);
+	break;
+      default:
+	break;
+      }
+    }
+  }
+  fs_give ((void **) &tmp);	/* done with scratch buffer */
+				/* default Sender: and Reply-To: to From: */
+  if (!env->sender) env->sender = rfc822_cpy_adr (env->from);
+  if (!env->reply_to) env->reply_to = rfc822_cpy_adr (env->from);
+				/* now parse the body */
+  if (body) rfc822_parse_content (body,bs,host,depth,flags);
+}
+
+/* Parse a message body content
+ * Accepts: pointer to body structure
+ *	    body string
+ *	    pointer to local host name
+ *	    recursion depth
+ *	    source driver flags
+ */
+
+void rfc822_parse_content (BODY *body,STRING *bs,char *h,unsigned long depth,
+			   unsigned long flags)
+{
+  char c,c1,*s,*s1;
+  int f;
+  unsigned long i,j,k,m;
+  PARAMETER *param;
+  PART *part = NIL;
+  if (depth > MAXMIMEDEPTH) {	/* excessively deep recursion? */
+    body->type = TYPETEXT;	/* yes, probably a malicious MIMEgram */
+    MM_LOG ("Ignoring excessively deep MIME recursion",PARSE);
+  }
+  if (!body->subtype)		/* default subtype if still unknown */
+    body->subtype = cpystr (rfc822_default_subtype (body->type));
+				/* note offset and sizes */
+  body->contents.offset = GETPOS (bs);
+				/* note internal body size in all cases */
+  body->size.bytes = body->contents.text.size = i = SIZE (bs);
+  if (!(flags & DR_CRLF)) body->size.bytes = strcrlflen (bs);
+  switch (body->type) {		/* see if anything else special to do */
+  case TYPETEXT:		/* text content */
+    if (!body->parameter) {	/* no parameters set */
+      body->parameter = mail_newbody_parameter ();
+      body->parameter->attribute = cpystr ("CHARSET");
+      while (i--) {		/* count lines and guess charset */
+	c = SNX (bs);		/* get current character */
+				/* charset still unknown? */
+	if (!body->parameter->value) {
+	  if ((c == I2C_ESC) && (i && i--) && ((c = SNX (bs)) == I2C_MULTI) &&
+	      (i && i--) && (((c = SNX (bs)) == I2CS_94x94_JIS_NEW) ||
+			     (c == I2CS_94x94_JIS_OLD)))
+	    body->parameter->value = cpystr ("ISO-2022-JP");
+	  else if (c & 0x80) body->parameter->value = cpystr ("X-UNKNOWN");
+	}
+	if (c == '\n') body->size.lines++;
+      }
+				/* 7-bit content */
+      if (!body->parameter->value) switch (body->encoding) {
+      case ENC7BIT:		/* unadorned 7-bit */
+      case ENC8BIT:		/* unadorned 8-bit (but 7-bit content) */
+      case ENCBINARY:		/* binary (but 7-bit content( */
+	body->parameter->value = cpystr ("US-ASCII");
+	break;
+      default:			/* QUOTED-PRINTABLE, BASE64, etc. */
+	body->parameter->value = cpystr ("X-UNKNOWN");
+	break;
+      }
+    }
+				/* just count lines */
+    else while (i--) if ((SNX (bs)) == '\n') body->size.lines++;
+    break;
+
+  case TYPEMESSAGE:		/* encapsulated message */
+				/* encapsulated RFC-822 message? */
+    if (!strcmp (body->subtype,"RFC822")) {
+      body->nested.msg = mail_newmsg ();
+      switch (body->encoding) {	/* make sure valid encoding */
+      case ENC7BIT:		/* these are valid nested encodings */
+      case ENC8BIT:
+      case ENCBINARY:
+	break;
+      default:
+	MM_LOG ("Ignoring nested encoding of message contents",PARSE);
+      }
+				/* hunt for blank line */
+      for (c = '\012',j = 0; (i > j) && ((c != '\012') || (CHR(bs) != '\012'));
+	   j++) if ((c1 = SNX (bs)) != '\015') c = c1;
+      if (i > j) {		/* unless no more text */
+	c1 = SNX (bs);		/* body starts here */
+	j++;			/* advance count */
+      }
+				/* note body text offset and header size */
+      body->nested.msg->header.text.size = j;
+      body->nested.msg->text.text.size = body->contents.text.size - j;
+      body->nested.msg->text.offset = GETPOS (bs);
+      body->nested.msg->full.offset = body->nested.msg->header.offset =
+	body->contents.offset;
+      body->nested.msg->full.text.size = body->contents.text.size;
+				/* copy header string */
+      SETPOS (bs,body->contents.offset);
+      s = (char *) fs_get ((size_t) j + 1);
+      for (s1 = s,k = j; k--; *s1++ = SNX (bs));
+      s[j] = '\0';		/* tie off string (not really necessary) */
+				/* now parse the body */
+      rfc822_parse_msg_full (&body->nested.msg->env,&body->nested.msg->body,s,
+			     j,bs,h,depth+1,flags);
+      fs_give ((void **) &s);	/* free header string */
+				/* restore position */
+      SETPOS (bs,body->contents.offset);
+    }
+				/* count number of lines */
+    while (i--) if (SNX (bs) == '\n') body->size.lines++;
+    break;
+  case TYPEMULTIPART:		/* multiple parts */
+    switch (body->encoding) {	/* make sure valid encoding */
+    case ENC7BIT:		/* these are valid nested encodings */
+    case ENC8BIT:
+    case ENCBINARY:
+      break;
+    default:
+      MM_LOG ("Ignoring nested encoding of multipart contents",PARSE);
+    }
+				/* remember if digest */
+    f = !strcmp (body->subtype,"DIGEST");
+				/* find cookie */
+    for (s1 = NIL,param = body->parameter; param && !s1; param = param->next)
+      if (!strcmp (param->attribute,"BOUNDARY")) s1 = param->value;
+    if (!s1) s1 = "-";		/* yucky default */
+    j = strlen (s1) + 2;	/* length of cookie and header */
+    c = '\012';			/* initially at beginning of line */
+
+    while (i > j) {		/* examine data */
+      if (m = GETPOS (bs)) m--;	/* get position in front of character */
+      switch (c) {		/* examine each line */
+      case '\015':		/* handle CRLF form */
+	if (CHR (bs) == '\012'){/* following LF? */
+	  c = SNX (bs); i--;	/* yes, slurp it */
+	}
+      case '\012':		/* at start of a line, start with -- ? */
+	if (!(i && i-- && ((c = SNX (bs)) == '-') && i-- &&
+	      ((c = SNX (bs)) == '-'))) break;
+				/* see if cookie matches */
+	if (k = j - 2) for (s = s1; i-- && *s++ == (c = SNX (bs)) && --k;);
+	if (k) break;		/* strings didn't match if non-zero */
+				/* terminating delimiter? */
+	if ((c = ((i && i--) ? (SNX (bs)) : '\012')) == '-') {
+	  if ((i && i--) && ((c = SNX (bs)) == '-') &&
+	      ((i && i--) ? (((c = SNX (bs)) == '\015') || (c=='\012')):T)) {
+				/* if have a final part calculate its size */
+	    if (part) part->body.mime.text.size =
+	      (m > part->body.mime.offset) ? (m - part->body.mime.offset) :0;
+	    part = NIL; i = 1;	/* terminate scan */
+	  }
+	  break;
+	}
+				/* swallow trailing whitespace */
+	while ((c == ' ') || (c == '\t'))
+	  c = ((i && i--) ? (SNX (bs)) : '\012');
+	switch (c) {		/* need newline after all of it */
+	case '\015':		/* handle CRLF form */
+	  if (i && CHR (bs) == '\012') {
+	    c = SNX (bs); i--;/* yes, slurp it */
+	  }
+	case '\012':		/* new line */
+	  if (part) {		/* calculate size of previous */
+	    part->body.mime.text.size =
+	      (m > part->body.mime.offset) ? (m-part->body.mime.offset) : 0;
+	    /* instantiate next */
+	    part = part->next = mail_newbody_part ();
+	  }			/* otherwise start new list */
+	  else part = body->nested.part = mail_newbody_part ();
+				/* digest has a different default */
+	  if (f) part->body.type = TYPEMESSAGE;
+				/* note offset from main body */
+	  part->body.mime.offset = GETPOS (bs);
+	  break;
+	default:		/* whatever it was it wasn't valid */
+	  break;
+	}
+	break;
+      default:			/* not at a line */
+	c = SNX (bs); i--;	/* get next character */
+	break;
+      }
+    }
+
+				/* calculate size of any final part */
+    if (part) part->body.mime.text.size = i +
+      ((GETPOS(bs) > part->body.mime.offset) ?
+       (GETPOS(bs) - part->body.mime.offset) : 0);
+				/* make a scratch buffer */
+    s1 = (char *) fs_get ((size_t) (k = MAILTMPLEN));
+				/* in case empty multipart */
+    if (!body->nested.part) body->nested.part = mail_newbody_part ();
+				/* parse non-empty body parts */
+    for (part = body->nested.part; part; part = part->next) {
+				/* part non-empty (header and/or content)? */
+      if (i = part->body.mime.text.size) {
+				/* move to that part of the body */
+	SETPOS (bs,part->body.mime.offset);
+				/* until end of header */
+	while (i && ((c = CHR (bs)) != '\015') && (c != '\012')) {
+				/* collect text until logical end of line */
+	  for (j = 0,c = ' '; c; ) {
+				/* make sure buffer big enough */
+	    if (j > (k - 10)) fs_resize ((void **) &s1,k += MAILTMPLEN);
+	    switch (c1 = SNX (bs)) {
+	    case '\015':	/* return */
+	      if (i && (CHR (bs) == '\012')) {
+		c1 = SNX (bs);	/* eat any LF following */
+		i--;
+	      }
+	    case '\012':	/* newline, possible end of logical line */
+				/* tie off unless continuation */
+	      if (!i || ((CHR (bs) != ' ') && (CHR (bs) != '\t')))
+		s1[j] = c = '\0';
+	      break;
+	    case '\t':		/* tab */
+	    case ' ':		/* insert whitespace if not already there */
+	      if (c != ' ') s1[j++] = c = ' ';
+	      break;
+	    default:		/* all other characters */
+	      s1[j++] = c = c1;	/* insert the character into the line */
+	      break;
+	    }
+				/* end of data ties off the header */
+	    if (!i || !--i) s1[j++] = c = '\0';
+	  }
+
+				/* find header item type */
+	  if (((s1[0] == 'C') || (s1[0] == 'c')) &&
+	      ((s1[1] == 'O') || (s1[1] == 'o')) &&
+	      ((s1[2] == 'N') || (s1[2] == 'n')) &&
+	      ((s1[3] == 'T') || (s1[3] == 't')) &&
+	      ((s1[4] == 'E') || (s1[4] == 'e')) &&
+	      ((s1[5] == 'N') || (s1[5] == 'n')) &&
+	      ((s1[6] == 'T') || (s1[6] == 't')) &&
+	      (s1[7] == '-') && (s = strchr (s1+8,':'))) {
+				/* tie off and flush whitespace */
+	    for (*s++ = '\0'; *s == ' '; s++);
+				/* parse the header */
+	    rfc822_parse_content_header (&part->body,ucase (s1+8),s);
+	  }
+	}
+				/* skip header trailing (CR)LF */
+	if (i && (CHR (bs) =='\015')) {i--; c1 = SNX (bs);}
+	if (i && (CHR (bs) =='\012')) {i--; c1 = SNX (bs);}
+	j = bs->size;		/* save upper level size */
+				/* set offset for next level, fake size to i */
+	bs->size = GETPOS (bs) + i;
+	part->body.mime.text.size -= i;
+				/* now parse it */
+	rfc822_parse_content (&part->body,bs,h,depth+1,flags);
+	bs->size = j;		/* restore current level size */
+      }
+      else {			/* zero-length part, use default subtype */
+	part->body.subtype = cpystr (rfc822_default_subtype (part->body.type));
+				/* see if anything else special to do */
+	switch (part->body.type) {
+	case TYPETEXT:		/* text content */
+				/* default parameters */
+	  if (!part->body.parameter) {
+	    part->body.parameter = mail_newbody_parameter ();
+	    part->body.parameter->attribute = cpystr ("CHARSET");
+				/* only assume US-ASCII if 7BIT */
+	    part->body.parameter->value =
+	      cpystr ((part->body.encoding == ENC7BIT) ?
+		      "US-ASCII" : "X-UNKNOWN");
+	  }
+	  break;
+	case TYPEMESSAGE:	/* encapsulated message in digest */
+	  part->body.nested.msg = mail_newmsg ();
+	  break;
+	default:
+	  break;
+	}
+      }
+    }
+    fs_give ((void **) &s1);	/* finished with scratch buffer */
+    break;
+  default:			/* nothing special to do in any other case */
+    break;
+  }
+}
+
+/* Parse RFC 2822 body content header
+ * Accepts: body to write to
+ *	    possible content name
+ *	    remainder of header
+ */
+
+void rfc822_parse_content_header (BODY *body,char *name,char *s)
+{
+  char c,*t,tmp[MAILTMPLEN];
+  long i;
+  STRINGLIST *stl;
+  rfc822_skipws (&s);		/* skip leading comments */
+				/* flush whitespace */
+  if (t = strchr (name,' ')) *t = '\0';
+  switch (*name) {		/* see what kind of content */
+  case 'I':			/* possible Content-ID */
+    if (!(strcmp (name+1,"D") || body->id)) body->id = cpystr (s);
+    break;
+  case 'D':			/* possible Content-Description */
+    if (!(strcmp (name+1,"ESCRIPTION") || body->description))
+      body->description = cpystr (s);
+    if (!(strcmp (name+1,"ISPOSITION") || body->disposition.type)) {
+				/* get type word */
+      if (!(name = rfc822_parse_word (s,tspecials))) break;
+      c = *name;		/* remember delimiter */
+      *name = '\0';		/* tie off type */
+      body->disposition.type = ucase (cpystr (s));
+      *name = c;		/* restore delimiter */
+      rfc822_skipws (&name);	/* skip whitespace */
+      rfc822_parse_parameter (&body->disposition.parameter,name);
+    }
+    break;
+  case 'L':			/* possible Content-Language */
+    if (!(strcmp (name+1,"ANGUAGE") || body->language)) {
+      stl = NIL;		/* process languages */
+      while (s && (name = rfc822_parse_word (s,tspecials))) {
+	c = *name;		/* save delimiter */
+	*name = '\0';		/* tie off subtype */
+	if (stl) stl = stl->next = mail_newstringlist ();
+	else stl = body->language = mail_newstringlist ();
+	stl->text.data = (unsigned char *) ucase (cpystr (s));
+	stl->text.size = strlen ((char *) stl->text.data);
+	*name = c;		/* restore delimiter */
+	rfc822_skipws (&name);	/* skip whitespace */
+	if (*name == ',') {	/* any more languages? */
+	  s = ++name;		/* advance to it them */
+	  rfc822_skipws (&s);
+	}
+	else s = NIL;		/* bogus or end of list */
+      }
+    }
+    else if (!(strcmp (name+1,"OCATION") || body->location))
+      body->location = cpystr (s);
+    break;
+  case 'M':			/* possible Content-MD5 */
+    if (!(strcmp (name+1,"D5") || body->md5)) body->md5 = cpystr (s);
+    break;
+
+  case 'T':			/* possible Content-Type/Transfer-Encoding */
+    if (!(strcmp (name+1,"YPE") || body->subtype || body->parameter)) {
+				/* get type word */
+      if (!(name = rfc822_parse_word (s,tspecials))) break;
+      c = *name;		/* remember delimiter */
+      *name = '\0';		/* tie off type */
+				/* search for body type */
+      for (i = 0,s = rfc822_cpy (s);
+	   (i <= TYPEMAX) && body_types[i] &&
+	     compare_cstring (s,body_types[i]); i++);
+      if (i > TYPEMAX) {	/* fell off end of loop? */
+	body->type = TYPEOTHER;	/* coerce to X-UNKNOWN */
+	sprintf (tmp,"MIME type table overflow: %.100s",s);
+	MM_LOG (tmp,PARSE);
+      }
+      else {			/* record body type index */
+	body->type = (unsigned short) i;
+				/* and name if new type */
+	if (body_types[body->type]) fs_give ((void **) &s);
+	else {			/* major MIME body type unknown to us */
+	  body_types[body->type] = ucase (s);
+	  sprintf (tmp,"Unknown MIME type: %.100s",s);
+	  MM_LOG (tmp,PARSE);
+	}
+      }
+      *name = c;		/* restore delimiter */
+      rfc822_skipws (&name);	/* skip whitespace */
+      if ((*name == '/') &&	/* subtype? */
+	  (name = rfc822_parse_word ((s = ++name),tspecials))) {
+	c = *name;		/* save delimiter */
+	*name = '\0';		/* tie off subtype */
+	rfc822_skipws (&s);	/* copy subtype */
+	if (s) body->subtype = ucase (rfc822_cpy (s));
+	*name = c;		/* restore delimiter */
+	rfc822_skipws (&name);	/* skip whitespace */
+      }
+      else if (!name) {		/* no subtype, was a subtype delimiter? */
+	name = s;		/* barf, restore pointer */
+	rfc822_skipws (&name);	/* skip leading whitespace */
+      }
+      rfc822_parse_parameter (&body->parameter,name);
+    }
+
+    else if (!strcmp (name+1,"RANSFER-ENCODING")) {
+      if (!(name = rfc822_parse_word (s,tspecials))) break;
+      c = *name;		/* remember delimiter */
+      *name = '\0';		/* tie off encoding */
+				/* search for body encoding */      
+      for (i = 0,s = rfc822_cpy (s);
+	   (i <= ENCMAX) && body_encodings[i] &&
+	     compare_cstring (s,body_encodings[i]); i++);
+      if (i > ENCMAX) {		/* fell off end of loop? */
+	body->encoding = ENCOTHER;
+	sprintf (tmp,"MIME encoding table overflow: %.100s",s);
+	MM_LOG (tmp,PARSE);
+      }
+      else {			/* record body encoding index */
+	body->encoding = (unsigned short) i;
+				/* and name if new encoding */
+	if (body_encodings[body->encoding]) fs_give ((void **) &s);
+	else {
+	  body_encodings[body->encoding] = ucase (s);
+	  sprintf (tmp,"Unknown MIME transfer encoding: %.100s",s);
+	  MM_LOG (tmp,PARSE);
+	}
+      }
+      *name = c;		/* restore delimiter */
+      /* ??check for cruft here?? */
+    }
+    break;
+  default:			/* otherwise unknown */
+    break;
+  }
+}
+
+/* Parse RFC 2822 body parameter list
+ * Accepts: parameter list to write to
+ *	    text of list
+ */
+
+void rfc822_parse_parameter (PARAMETER **par,char *text)
+{
+  char c,*s,tmp[MAILTMPLEN];
+  PARAMETER *param = NIL;
+				/* parameter list? */
+  while (text && (*text == ';') &&
+	 (text = rfc822_parse_word ((s = ++text),tspecials))) {
+    c = *text;			/* remember delimiter */
+    *text = '\0';		/* tie off attribute name */
+    rfc822_skipws (&s);		/* skip leading attribute whitespace */
+    if (!*s) *text = c;		/* must have an attribute name */
+    else {			/* instantiate a new parameter */
+      if (*par) param = param->next = mail_newbody_parameter ();
+      else param = *par = mail_newbody_parameter ();
+      param->attribute = ucase (cpystr (s));
+      *text = c;		/* restore delimiter */
+      rfc822_skipws (&text);	/* skip whitespace before equal sign */
+      if ((*text == '=') &&	/* make sure have value */
+	  (text = rfc822_parse_word ((s = ++text),tspecials))) {
+	c = *text;		/* remember delimiter */
+	*text = '\0';		/* tie off value */
+	rfc822_skipws (&s);	/* skip leading value whitespace */
+	if (*s) param->value = rfc822_cpy (s);
+	*text = c;		/* restore delimiter */
+	rfc822_skipws (&text);
+      }
+      if (!param->value) {	/* value not found? */
+	param->value = cpystr ("MISSING_PARAMETER_VALUE");
+	sprintf (tmp,"Missing parameter value: %.80s",param->attribute);
+	MM_LOG (tmp,PARSE);
+      }
+    }
+  }
+				/* string not present */
+  if (!text) MM_LOG ("Missing parameter",PARSE);
+  else if (*text) {		/* must be end of poop */
+    sprintf (tmp,"Unexpected characters at end of parameters: %.80s",text);
+    MM_LOG (tmp,PARSE);
+  }
+}
+
+/* Parse RFC 2822 address list
+ * Accepts: address list to write to
+ *	    input string
+ *	    default host name
+ */
+
+void rfc822_parse_adrlist (ADDRESS **lst,char *string,char *host)
+{
+  int c;
+  char *s,tmp[MAILTMPLEN];
+  ADDRESS *last = *lst;
+  ADDRESS *adr;
+  if (!string) return;		/* no string */
+  rfc822_skipws (&string);	/* skip leading WS */
+  if (!*string) return;		/* empty string */
+				/* run to tail of list */
+  if (last) while (last->next) last = last->next;
+  while (string) {		/* loop until string exhausted */
+    while (*string == ',') {	/* RFC 822 allowed null addresses!! */
+      ++string;			/* skip the comma */
+      rfc822_skipws (&string);	/* and any leading WS */
+    }
+    if (!*string) string = NIL;	/* punt if ran out of string */
+				/* got an address? */
+    else if (adr = rfc822_parse_address (lst,last,&string,host,0)) {
+      last = adr;		/* new tail address */
+      if (string) {		/* analyze what follows */
+	rfc822_skipws (&string);
+	switch (c = *(unsigned char *) string) {
+	case ',':		/* comma? */
+	  ++string;		/* then another address follows */
+	  break;
+	default:
+	  s = isalnum (c) ? "Must use comma to separate addresses: %.80s" :
+	    "Unexpected characters at end of address: %.80s";
+	  sprintf (tmp,s,string);
+	  MM_LOG (tmp,PARSE);
+	  last = last->next = mail_newaddr ();
+	  last->mailbox = cpystr ("UNEXPECTED_DATA_AFTER_ADDRESS");
+	  last->host = cpystr (errhst);
+				/* falls through */
+	case '\0':		/* null-specified address? */
+	  string = NIL;		/* punt remainder of parse */
+	  break;
+	}
+      }
+    }
+    else if (string) {		/* bad mailbox */
+      rfc822_skipws (&string);	/* skip WS */
+      if (!*string) strcpy (tmp,"Missing address after comma");
+      else sprintf (tmp,"Invalid mailbox list: %.80s",string);
+      MM_LOG (tmp,PARSE);
+      string = NIL;
+      (adr = mail_newaddr ())->mailbox = cpystr ("INVALID_ADDRESS");
+      adr->host = cpystr (errhst);
+      if (last) last = last->next = adr;
+      else *lst = last = adr;
+      break;
+    }
+  }
+}
+
+/* Parse RFC 2822 address
+ * Accepts: address list to write to
+ *	    tail of address list
+ *	    pointer to input string
+ *	    default host name
+ *	    group nesting depth
+ * Returns: new list tail
+ */
+
+ADDRESS *rfc822_parse_address (ADDRESS **lst,ADDRESS *last,char **string,
+			       char *defaulthost,unsigned long depth)
+{
+  ADDRESS *adr;
+  if (!*string) return NIL;	/* no string */
+  rfc822_skipws (string);	/* skip leading WS */
+  if (!**string) return NIL;	/* empty string */
+  if (adr = rfc822_parse_group (lst,last,string,defaulthost,depth)) last = adr;
+				/* got an address? */
+  else if (adr = rfc822_parse_mailbox (string,defaulthost)) {
+    if (!*lst) *lst = adr;	/* yes, first time through? */
+    else last->next = adr;	/* no, append to the list */
+				/* set for subsequent linking */
+    for (last = adr; last->next; last = last->next);
+  }
+  else if (*string) return NIL;
+  return last;
+}
+
+/* Parse RFC 2822 group
+ * Accepts: address list to write to
+ *	    pointer to tail of address list
+ *	    pointer to input string
+ *	    default host name
+ *	    group nesting depth
+ */
+
+ADDRESS *rfc822_parse_group (ADDRESS **lst,ADDRESS *last,char **string,
+			     char *defaulthost,unsigned long depth)
+{
+  char tmp[MAILTMPLEN];
+  char *p,*s;
+  ADDRESS *adr;
+  if (depth > MAXGROUPDEPTH) {	/* excessively deep recursion? */
+    MM_LOG ("Ignoring excessively deep group recursion",PARSE);
+    return NIL;			/* probably abusive */
+  }
+  if (!*string) return NIL;	/* no string */
+  rfc822_skipws (string);	/* skip leading WS */
+  if (!**string ||		/* trailing whitespace or not group */
+      ((*(p = *string) != ':') && !(p = rfc822_parse_phrase (*string))))
+    return NIL;
+  s = p;			/* end of candidate phrase */
+  rfc822_skipws (&s);		/* find delimiter */
+  if (*s != ':') return NIL;	/* not really a group */
+  *p = '\0';			/* tie off group name */
+  p = ++s;			/* continue after the delimiter */
+  rfc822_skipws (&p);		/* skip subsequent whitespace */
+				/* write as address */
+  (adr = mail_newaddr ())->mailbox = rfc822_cpy (*string);
+  if (!*lst) *lst = adr;	/* first time through? */
+  else last->next = adr;	/* no, append to the list */
+  last = adr;			/* set for subsequent linking */
+  *string = p;			/* continue after this point */
+  while (*string && **string && (**string != ';')) {
+    if (adr = rfc822_parse_address (lst,last,string,defaulthost,depth+1)) {
+      last = adr;		/* new tail address */
+      if (*string) {		/* anything more? */
+	rfc822_skipws (string);	/* skip whitespace */
+	switch (**string) {	/* see what follows */
+	case ',':		/* another address? */
+	  ++*string;		/* yes, skip past the comma */
+	case ';':		/* end of group? */
+	case '\0':		/* end of string */
+	  break;
+	default:
+	  sprintf (tmp,"Unexpected characters after address in group: %.80s",
+		   *string);
+	  MM_LOG (tmp,PARSE);
+	  *string = NIL;	/* cancel remainder of parse */
+	  last = last->next = mail_newaddr ();
+	  last->mailbox = cpystr ("UNEXPECTED_DATA_AFTER_ADDRESS_IN_GROUP");
+	  last->host = cpystr (errhst);
+	}
+      }
+    }
+    else {			/* bogon */
+      sprintf (tmp,"Invalid group mailbox list: %.80s",*string);
+      MM_LOG (tmp,PARSE);
+      *string = NIL;		/* cancel remainder of parse */
+      (adr = mail_newaddr ())->mailbox = cpystr ("INVALID_ADDRESS_IN_GROUP");
+      adr->host = cpystr (errhst);
+      last = last->next = adr;
+    }
+  }
+  if (*string) {		/* skip close delimiter */
+    if (**string == ';') ++*string;
+    rfc822_skipws (string);
+  }
+				/* append end of address mark to the list */
+  last->next = (adr = mail_newaddr ());
+  last = adr;			/* set for subsequent linking */
+  return last;			/* return the tail */
+}
+
+/* Parse RFC 2822 mailbox
+ * Accepts: pointer to string pointer
+ *	    default host
+ * Returns: address list
+ *
+ * Updates string pointer
+ */
+
+ADDRESS *rfc822_parse_mailbox (char **string,char *defaulthost)
+{
+  ADDRESS *adr = NIL;
+  char *s,*end;
+  parsephrase_t pp = (parsephrase_t) mail_parameters (NIL,GET_PARSEPHRASE,NIL);
+  if (!*string) return NIL;	/* no string */
+  rfc822_skipws (string);	/* flush leading whitespace */
+  if (!**string) return NIL;	/* empty string */
+  if (*(s = *string) == '<') 	/* note start, handle case of phraseless RA */
+    adr = rfc822_parse_routeaddr (s,string,defaulthost);
+				/* otherwise, expect at least one word */
+  else if (end = rfc822_parse_phrase (s)) {
+    if ((adr = rfc822_parse_routeaddr (end,string,defaulthost))) {
+				/* phrase is a personal name */
+      if (adr->personal) fs_give ((void **) &adr->personal);
+      *end = '\0';		/* tie off phrase */
+      adr->personal = rfc822_cpy (s);
+    }
+				/* call external phraseparser if phrase only */
+    else if (pp && rfc822_phraseonly (end) &&
+	     (adr = (*pp) (s,end,defaulthost))) {
+      *string = end;		/* update parse pointer */
+      rfc822_skipws (string);	/* skip WS in the normal way */
+    }
+    else adr = rfc822_parse_addrspec (s,string,defaulthost);
+  }
+  return adr;			/* return the address */
+}
+
+
+/* Check if address is a phrase only
+ * Accepts: pointer to end of phrase
+ * Returns: T if phrase only, else NIL;
+ */
+
+long rfc822_phraseonly (char *end)
+{
+  while (*end == ' ') ++end;	/* call rfc822_skipws() instead?? */
+  switch (*end) {
+  case '\0': case ',': case ';':
+    return LONGT;		/* is a phrase only */
+  }
+  return NIL;			/* something other than phase is here */
+}
+
+/* Parse RFC 2822 route-address
+ * Accepts: string pointer
+ *	    pointer to string pointer to update
+ * Returns: address
+ *
+ * Updates string pointer
+ */
+
+ADDRESS *rfc822_parse_routeaddr (char *string,char **ret,char *defaulthost)
+{
+  char tmp[MAILTMPLEN];
+  ADDRESS *adr;
+  char *s,*t,*adl;
+  size_t adllen,i;
+  if (!string) return NIL;
+  rfc822_skipws (&string);	/* flush leading whitespace */
+				/* must start with open broket */
+  if (*string != '<') return NIL;
+  t = ++string;			/* see if A-D-L there */
+  rfc822_skipws (&t);		/* flush leading whitespace */
+  for (adl = NIL,adllen = 0;	/* parse possible A-D-L */
+       (*t == '@') && (s = rfc822_parse_domain (t+1,&t));) {
+    i = strlen (s) + 2;		/* @ plus domain plus delimiter or NUL */
+    if (adl) {			/* have existing A-D-L? */
+      fs_resize ((void **) &adl,adllen + i);
+      sprintf (adl + adllen - 1,",@%s",s);
+    }
+				/* write initial A-D-L */
+    else sprintf (adl = (char *) fs_get (i),"@%s",s);
+    adllen += i;		/* new A-D-L length */
+    fs_give ((void **) &s);	/* don't need domain any more */
+    rfc822_skipws (&t);		/* skip WS */
+    if (*t != ',') break;	/* put if not comma */
+    t++;			/* skip the comma */
+    rfc822_skipws (&t);		/* skip WS */
+  }
+  if (adl) {			/* got an A-D-L? */
+    if (*t != ':') {		/* make sure syntax good */
+      sprintf (tmp,"Unterminated at-domain-list: %.80s%.80s",adl,t);
+      MM_LOG (tmp,PARSE);
+    }
+    else string = ++t;		/* continue parse from this point */
+  }
+
+				/* parse address spec */
+  if (!(adr = rfc822_parse_addrspec (string,ret,defaulthost))) {
+    if (adl) fs_give ((void **) &adl);
+    return NIL;
+  }
+  if (adl) adr->adl = adl;	/* have an A-D-L? */
+  if (*ret) if (**ret == '>') {	/* make sure terminated OK */
+    ++*ret;			/* skip past the broket */
+    rfc822_skipws (ret);	/* flush trailing WS */
+    if (!**ret) *ret = NIL;	/* wipe pointer if at end of string */
+    return adr;			/* return the address */
+  }
+  sprintf (tmp,"Unterminated mailbox: %.80s@%.80s",adr->mailbox,
+	   *adr->host == '@' ? "<null>" : adr->host);
+  MM_LOG (tmp,PARSE);
+  adr->next = mail_newaddr ();
+  adr->next->mailbox = cpystr ("MISSING_MAILBOX_TERMINATOR");
+  adr->next->host = cpystr (errhst);
+  return adr;			/* return the address */
+}
+
+/* Parse RFC 2822 address-spec
+ * Accepts: string pointer
+ *	    pointer to string pointer to update
+ *	    default host
+ * Returns: address
+ *
+ * Updates string pointer
+ */
+
+ADDRESS *rfc822_parse_addrspec (char *string,char **ret,char *defaulthost)
+{
+  ADDRESS *adr;
+  char c,*s,*t,*v,*end;
+  if (!string) return NIL;	/* no string */
+  rfc822_skipws (&string);	/* flush leading whitespace */
+  if (!*string) return NIL;	/* empty string */
+				/* find end of mailbox */
+  if (!(t = rfc822_parse_word (string,wspecials))) return NIL;
+  adr = mail_newaddr ();	/* create address block */
+  c = *t;			/* remember delimiter */
+  *t = '\0';			/* tie off mailbox */
+				/* copy mailbox */
+  adr->mailbox = rfc822_cpy (string);
+  *t = c;			/* restore delimiter */
+  end = t;			/* remember end of mailbox */
+  rfc822_skipws (&t);		/* skip whitespace */
+  while (*t == '.') {		/* some cretin taking RFC 822 too seriously? */
+    string = ++t;		/* skip past the dot and any WS */
+    rfc822_skipws (&string);
+				/* get next word of mailbox */
+    if (t = rfc822_parse_word (string,wspecials)) {
+      end = t;			/* remember new end of mailbox */
+      c = *t;			/* remember delimiter */
+      *t = '\0';		/* tie off word */
+      s = rfc822_cpy (string);	/* copy successor part */
+      *t = c;			/* restore delimiter */
+				/* build new mailbox */
+      sprintf (v = (char *) fs_get (strlen (adr->mailbox) + strlen (s) + 2),
+	       "%s.%s",adr->mailbox,s);
+      fs_give ((void **) &adr->mailbox);
+      adr->mailbox = v;		/* new host name */
+      rfc822_skipws (&t);	/* skip WS after mailbox */
+    }
+    else {			/* barf */
+      MM_LOG ("Invalid mailbox part after .",PARSE);
+      break;
+    }
+  }
+  t = end;			/* remember delimiter in case no host */
+
+  rfc822_skipws (&end);		/* sniff ahead at what follows */
+#if RFC733			/* RFC 733 used "at" instead of "@" */
+  if (((*end == 'a') || (*end == 'A')) &&
+      ((end[1] == 't') || (end[1] == 'T')) &&
+      ((end[2] == ' ') || (end[2] == '\t') || (end[2] == '\015') ||
+       (end[2] == '\012') || (end[2] == '(')))
+    *++end = '@';
+#endif
+  if (*end != '@') end = t;	/* host name missing */
+				/* otherwise parse host name */
+  else if (!(adr->host = rfc822_parse_domain (++end,&end)))
+    adr->host = cpystr (errhst);
+				/* default host if missing */
+  if (!adr->host) adr->host = cpystr (defaulthost);
+				/* try person name in comments if missing */
+  if (end && !(adr->personal && *adr->personal)) {
+    while (*end == ' ') ++end;	/* see if we can find a person name here */
+    if ((*end == '(') && (s = rfc822_skip_comment (&end,LONGT)) && strlen (s))
+      adr->personal = rfc822_cpy (s);
+    rfc822_skipws (&end);	/* skip any other WS in the normal way */
+  }
+				/* set return to end pointer */
+  *ret = (end && *end) ? end : NIL;
+  return adr;			/* return the address we got */
+}
+
+/* Parse RFC 2822 domain
+ * Accepts: string pointer
+ *	    pointer to return end of domain
+ * Returns: domain name or NIL if failure
+ */
+
+char *rfc822_parse_domain (char *string,char **end)
+{
+  char *ret = NIL;
+  char c,*s,*t,*v;
+  rfc822_skipws (&string);	/* skip whitespace */
+  if (*string == '[') {		/* domain literal? */
+    if (!(*end = rfc822_parse_word (string + 1,"]\\")))
+      MM_LOG ("Empty domain literal",PARSE);
+    else if (**end != ']') MM_LOG ("Unterminated domain literal",PARSE);
+    else {
+      size_t len = ++*end - string;
+      strncpy (ret = (char *) fs_get (len + 1),string,len);
+      ret[len] = '\0';		/* tie off literal */
+    }
+  }
+				/* search for end of host */
+  else if (t = rfc822_parse_word (string,wspecials)) {
+    c = *t;			/* remember delimiter */
+    *t = '\0';			/* tie off host */
+    ret = rfc822_cpy (string);	/* copy host */
+    *t = c;			/* restore delimiter */
+    *end = t;			/* remember end of domain */
+    rfc822_skipws (&t);		/* skip WS after host */
+    while (*t == '.') {		/* some cretin taking RFC 822 too seriously? */
+      string = ++t;		/* skip past the dot and any WS */
+      rfc822_skipws (&string);
+      if (string = rfc822_parse_domain (string,&t)) {
+	*end = t;		/* remember new end of domain */
+	c = *t;			/* remember delimiter */
+	*t = '\0';		/* tie off host */
+	s = rfc822_cpy (string);/* copy successor part */
+	*t = c;			/* restore delimiter */
+				/* build new domain */
+	sprintf (v = (char *) fs_get (strlen (ret) + strlen (s) + 2),
+		 "%s.%s",ret,s);
+	fs_give ((void **) &ret);
+	ret = v;		/* new host name */
+	rfc822_skipws (&t);	/* skip WS after domain */
+      }
+      else {			/* barf */
+	MM_LOG ("Invalid domain part after .",PARSE);
+	break;
+      }
+    }
+  }
+  else MM_LOG ("Missing or invalid host name after @",PARSE);
+  return ret;
+}
+
+/* Parse RFC 2822 phrase
+ * Accepts: string pointer
+ * Returns: pointer to end of phrase
+ */
+
+char *rfc822_parse_phrase (char *s)
+{
+  char *curpos;
+  if (!s) return NIL;		/* no-op if no string */
+				/* find first word of phrase */
+  curpos = rfc822_parse_word (s,NIL);
+  if (!curpos) return NIL;	/* no words means no phrase */
+  if (!*curpos) return curpos;	/* check if string ends with word */
+  s = curpos;			/* sniff past the end of this word and WS */
+  rfc822_skipws (&s);		/* skip whitespace */
+				/* recurse to see if any more */
+  return (s = rfc822_parse_phrase (s)) ? s : curpos;
+}
+
+/* Parse RFC 2822 word
+ * Accepts: string pointer
+ *	    delimiter (or NIL for phrase word parsing)
+ * Returns: pointer to end of word
+ */
+
+char *rfc822_parse_word (char *s,const char *delimiters)
+{
+  char *st,*str;
+  if (!s) return NIL;		/* no string */
+  rfc822_skipws (&s);		/* flush leading whitespace */
+  if (!*s) return NIL;		/* empty string */
+  str = s;			/* hunt pointer for strpbrk */
+  while (T) {			/* look for delimiter, return if none */
+    if (!(st = strpbrk (str,delimiters ? delimiters : wspecials)))
+      return str + strlen (str);
+				/* ESC in phrase */
+    if (!delimiters && (*st == I2C_ESC)) {
+      str = ++st;		/* always skip past ESC */
+      switch (*st) {		/* special hack for RFC 1468 (ISO-2022-JP) */
+      case I2C_MULTI:		/* multi byte sequence */
+	switch (*++st) {
+	case I2CS_94x94_JIS_OLD:/* old JIS (1978) */
+	case I2CS_94x94_JIS_NEW:/* new JIS (1983) */
+	  str = ++st;		/* skip past the shift to JIS */
+	  while (st = strchr (st,I2C_ESC))
+	    if ((*++st == I2C_G0_94) && ((st[1] == I2CS_94_ASCII) ||
+					 (st[1] == I2CS_94_JIS_ROMAN) ||
+					 (st[1] == I2CS_94_JIS_BUGROM))) {
+	      str = st += 2;	/* skip past the shift back to ASCII */
+	      break;
+	    }
+				/* eats entire text if no shift back */
+	  if (!st || !*st) return str + strlen (str);
+	}
+	break;
+      case I2C_G0_94:		/* single byte sequence */
+	switch (st[1]) {
+	case I2CS_94_ASCII:	/* shift to ASCII */
+	case I2CS_94_JIS_ROMAN:	/* shift to JIS-Roman */
+	case I2CS_94_JIS_BUGROM:/* old buggy definition of JIS-Roman */
+	  str = st + 2;		/* skip past the shift */
+	  break;
+	}
+      }
+    }
+
+    else switch (*st) {		/* dispatch based on delimiter */
+    case '"':			/* quoted string */
+				/* look for close quote */
+      while (*++st != '"') switch (*st) {
+      case '\0':		/* unbalanced quoted string */
+	return NIL;		/* sick sick sick */
+      case '\\':		/* quoted character */
+	if (!*++st) return NIL;	/* skip the next character */
+      default:			/* ordinary character */
+	break;			/* no special action */
+      }
+      str = ++st;		/* continue parse */
+      break;
+    case '\\':			/* quoted character */
+      /* This is wrong; a quoted-pair can not be part of a word.  However,
+       * domain-literal is parsed as a word and quoted-pairs can be used
+       * *there*.  Either way, it's pretty pathological.
+       */
+      if (st[1]) {		/* not on NUL though... */
+	str = st + 2;		/* skip quoted character and go on */
+	break;
+      }
+    default:			/* found a word delimiter */
+      return (st == s) ? NIL : st;
+    }
+  }
+}
+
+/* Copy an RFC 2822 format string
+ * Accepts: string
+ * Returns: copy of string
+ */
+
+char *rfc822_cpy (char *src)
+{
+				/* copy and unquote */
+  return rfc822_quote (cpystr (src));
+}
+
+
+/* Unquote an RFC 2822 format string
+ * Accepts: string
+ * Returns: string
+ */
+
+char *rfc822_quote (char *src)
+{
+  char *ret = src;
+  if (strpbrk (src,"\\\"")) {	/* any quoting in string? */
+    char *dst = ret;
+    while (*src) {		/* copy string */
+      if (*src == '\"') src++;	/* skip double quote entirely */
+      else {
+	if (*src == '\\') src++;/* skip over single quote, copy next always */
+	*dst++ = *src++;	/* copy character */
+      }
+    }
+    *dst = '\0';		/* tie off string */
+  }
+  return ret;			/* return our string */
+}
+
+
+/* Copy address list
+ * Accepts: address list
+ * Returns: address list
+ */
+
+ADDRESS *rfc822_cpy_adr (ADDRESS *adr)
+{
+  ADDRESS *dadr;
+  ADDRESS *ret = NIL;
+  ADDRESS *prev = NIL;
+  while (adr) {			/* loop while there's still an MAP adr */
+    dadr = mail_newaddr ();	/* instantiate a new address */
+    if (!ret) ret = dadr;	/* note return */
+    if (prev) prev->next = dadr;/* tie on to the end of any previous */
+    dadr->personal = cpystr (adr->personal);
+    dadr->adl = cpystr (adr->adl);
+    dadr->mailbox = cpystr (adr->mailbox);
+    dadr->host = cpystr (adr->host);
+    prev = dadr;		/* this is now the previous */
+    adr = adr->next;		/* go to next address in list */
+  }
+  return (ret);			/* return the MTP address list */
+}
+
+/* Skips RFC 2822 whitespace
+ * Accepts: pointer to string pointer
+ */
+
+void rfc822_skipws (char **s)
+{
+  while (T) switch (**s) {
+  case ' ': case '\t': case '\015': case '\012':
+    ++*s;			/* skip all forms of LWSP */
+    break;
+  case '(':			/* start of comment */
+    if (rfc822_skip_comment (s,(long) NIL)) break;
+  default:
+    return;			/* end of whitespace */
+  }
+}
+
+
+/* Skips RFC 2822 comment
+ * Accepts: pointer to string pointer
+ *	    trim flag
+ * Returns: pointer to first non-blank character of comment
+ */
+
+char *rfc822_skip_comment (char **s,long trim)
+{
+  char *ret,tmp[MAILTMPLEN];
+  char *s1 = *s;
+  char *t = NIL;
+				/* skip past whitespace */
+  for (ret = ++s1; *ret == ' '; ret++);
+  do switch (*s1) {		/* get character of comment */
+  case '(':			/* nested comment? */
+    if (!rfc822_skip_comment (&s1,(long) NIL)) return NIL;
+    t = --s1;			/* last significant char at end of comment */
+    break;
+  case ')':			/* end of comment? */
+    *s = ++s1;			/* skip past end of comment */
+    if (trim) {			/* if level 0, must trim */
+      if (t) t[1] = '\0';	/* tie off comment string */
+      else *ret = '\0';		/* empty comment */
+    }
+    return ret;
+  case '\\':			/* quote next character? */
+    if (*++s1) {		/* next character non-null? */
+      t = s1;			/* update last significant character pointer */
+      break;			/* all OK */
+    }
+  case '\0':			/* end of string */
+    sprintf (tmp,"Unterminated comment: %.80s",*s);
+    MM_LOG (tmp,PARSE);
+    **s = '\0';			/* nuke duplicate messages in case reparse */
+    return NIL;			/* this is wierd if it happens */
+  case ' ':			/* whitespace isn't significant */
+    break;
+  default:			/* random character */
+    t = s1;			/* update last significant character pointer */
+    break;
+  } while (s1++);
+  return NIL;			/* impossible, but pacify lint et al */
+}
+
+/* Buffered output routines */
+
+
+/* Output character to buffer
+ * Accepts: buffer
+ *	    character to write
+ * Returns: T if success, NIL if error
+ */
+
+static long rfc822_output_char (RFC822BUFFER *buf,int c)
+{
+  if ((buf->cur == buf->end) && !rfc822_output_flush (buf)) return NIL;
+  *buf->cur++ = c;		/* add character, soutr buffer if full */
+  return (buf->cur == buf->end) ? rfc822_output_flush (buf) : LONGT;
+}
+
+
+/* Output data to buffer
+ * Accepts: buffer
+ *	    data to write
+ *	    size of data
+ * Returns: T if success, NIL if error
+ */
+
+static long rfc822_output_data (RFC822BUFFER *buf,char *string,long len)
+{
+  while (len) {			/* until request satified */
+    long i;
+    if (i = min (len,buf->end - buf->cur)) {
+      memcpy (buf->cur,string,i);
+      buf->cur += i;		/* blat data */
+      string += i;
+      len -= i;
+    }
+				/* soutr buffer now if full */
+    if ((len || (buf->cur == buf->end)) && !rfc822_output_flush (buf))
+      return NIL;
+  }
+  return LONGT;
+}
+
+/* Output string to buffer
+ * Accepts: buffer
+ *	    string to write
+ * Returns: T if success, NIL if error
+ */
+
+static long rfc822_output_string (RFC822BUFFER *buf,char *string)
+{
+  return rfc822_output_data (buf,string,strlen (string));
+}
+
+
+/* Flush buffer
+ * Accepts: buffer
+ *	    I/O routine
+ *	    stream for I/O routine
+ * Returns: T if success, NIL if error
+ */
+
+long rfc822_output_flush (RFC822BUFFER *buf)
+{
+  *buf->cur = '\0';		/* tie off buffer at this point */
+  return (*buf->f) (buf->s,buf->cur = buf->beg);
+}
+
+/* Message writing routines */
+
+
+/* Output RFC 822 message
+ * Accepts: temporary buffer as a SIZEDTEXT
+ *	    envelope
+ *	    body
+ *	    I/O routine
+ *	    stream for I/O routine
+ *	    non-zero if 8-bit output desired
+ * Returns: T if successful, NIL if failure
+ *
+ * This routine always uses standard specials for phrases and does not write
+ * bcc entries, since it is called from the SMTP and NNTP routines.  If you
+ * need to do something different you need to arm an rfc822outfull_t and/or
+ * rfc822out_t function.
+ */
+
+long rfc822_output_full (RFC822BUFFER *buf,ENVELOPE *env,BODY *body,long ok8)
+{
+  rfc822outfull_t r822of =
+    (rfc822outfull_t) mail_parameters (NIL,GET_RFC822OUTPUTFULL,NIL);
+  rfc822out_t r822o = (rfc822out_t) mail_parameters (NIL,GET_RFC822OUTPUT,NIL);
+				/* call external RFC 2822 output generator */
+  if (r822of) return (*r822of) (buf,env,body,ok8);
+  else if (r822o) return (*r822o) (buf->cur,env,body,buf->f,buf->s,ok8);
+				/* encode body as necessary */
+  if (ok8) rfc822_encode_body_8bit (env,body);
+  else rfc822_encode_body_7bit (env,body);
+				/* output header and body */
+  return rfc822_output_header (buf,env,body,NIL,NIL) &&
+    rfc822_output_text (buf,body) && rfc822_output_flush (buf);
+}
+
+/* Output RFC 822 header
+ * Accepts: buffer
+ *	    envelope
+ *	    body
+ *	    non-standard specials to be used for phrases if non-NIL
+ *	    flags (non-zero to include bcc
+ * Returns: T if success, NIL if failure
+ */
+
+long rfc822_output_header (RFC822BUFFER *buf,ENVELOPE *env,BODY *body,
+			   const char *specials,long flags)
+{
+  long i = env->remail ? strlen (env->remail) : 0;
+  return			/* write header */
+    (!i ||		      /* snip extra CRLF from remail header */
+     rfc822_output_data (buf,env->remail,
+			 ((i > 4) && (env->remail[i-4] == '\015')) ?
+			 i - 2 : i)) &&
+    rfc822_output_header_line (buf,"Newsgroups",i,env->newsgroups) &&
+    rfc822_output_header_line (buf,"Date",i,env->date) &&
+    rfc822_output_address_line (buf,"From",i,env->from,specials) &&
+    rfc822_output_address_line (buf,"Sender",i,env->sender,specials) &&
+    rfc822_output_address_line (buf,"Reply-To",i,env->reply_to,specials) &&
+    rfc822_output_header_line (buf,"Subject",i,env->subject) &&
+    ((env->bcc && !(env->to || env->cc)) ?
+     rfc822_output_string (buf,"To: undisclosed recipients: ;\015\012") :
+     LONGT) &&
+    rfc822_output_address_line (buf,"To",i,env->to,specials) &&
+    rfc822_output_address_line (buf,"cc",i,env->cc,specials) &&
+    (flags ? rfc822_output_address_line (buf,"bcc",i,env->bcc,specials) : T) &&
+    rfc822_output_header_line (buf,"In-Reply-To",i,env->in_reply_to) &&
+    rfc822_output_header_line (buf,"Message-ID",i,env->message_id) &&
+    rfc822_output_header_line (buf,"Followup-to",i,env->followup_to) &&
+    rfc822_output_header_line (buf,"References",i,env->references) &&
+    (env->remail || !body ||
+     (rfc822_output_string (buf,"MIME-Version: 1.0\015\012") &&
+      rfc822_output_body_header (buf,body))) &&
+				/* write terminating blank line */
+    rfc822_output_string (buf,"\015\012");
+}
+
+/* Output RFC 2822 header text line
+ * Accepts: buffer
+ *	    pointer to header type
+ *	    non-NIL if resending
+ *	    pointer to text
+ * Returns: T if success, NIL if failure
+ */
+
+long rfc822_output_header_line (RFC822BUFFER *buf,char *type,long resent,
+				char *text)
+{
+  return !text ||
+    ((resent ? rfc822_output_string (buf,resentprefix) : LONGT) &&
+     rfc822_output_string (buf,type) && rfc822_output_string (buf,": ") &&
+     rfc822_output_string (buf,text) && rfc822_output_string (buf,"\015\012"));
+}
+
+
+/* Output RFC 2822 header address line
+ * Accepts: buffer
+ *	    pointer to header type
+ *	    non-NIL if resending
+ *	    address(s) to interpret
+ *	    non-standard specials to be used for phrases if non-NIL
+ * Returns: T if success, NIL if failure
+ */
+
+long rfc822_output_address_line (RFC822BUFFER *buf,char *type,long resent,
+				 ADDRESS *adr,const char *specials)
+{
+  long pretty = strlen (type);
+  return !adr ||
+    ((resent ? rfc822_output_string (buf,resentprefix) : LONGT) &&
+     rfc822_output_data (buf,type,pretty) && rfc822_output_string (buf,": ") &&
+     rfc822_output_address_list (buf,adr,
+				 resent ? pretty + sizeof (RESENTPREFIX) - 1 :
+				 pretty,specials) &&
+     rfc822_output_string (buf,"\015\012"));
+}
+
+/* Output RFC 2822 address list
+ * Accepts: buffer
+ *	    pointer to address list
+ *	    non-zero if pretty-printing
+ *	    non-standard specials to be used for phrases if non-NIL
+ * Returns: T if success, NIL if failure
+ */
+
+long rfc822_output_address_list (RFC822BUFFER *buf,ADDRESS *adr,long pretty,
+				 const char *specials)
+{
+  long n;
+				/* default to rspecials */
+  if (!specials) specials = rspecials;
+  for (n = 0; adr; adr = adr->next) {
+    char *base = buf->cur;
+    if (adr->host) {		/* ordinary address? */
+      if (!(pretty && n)) {	/* suppress if pretty and in group */
+	if (			/* use phrase <route-addr> if phrase */
+#if RFC822
+	    adr->adl ||		/* or A-D-L */
+#endif
+	    (adr->personal && *adr->personal)) {
+	  if (!((adr->personal ? rfc822_output_cat (buf,adr->personal,
+						    rspecials) : LONGT) &&
+		rfc822_output_string (buf," <") &&
+		rfc822_output_address (buf,adr) &&
+		rfc822_output_string (buf,">"))) return NIL;
+	}
+	else if (!rfc822_output_address (buf,adr)) return NIL;
+	if (adr->next && adr->next->mailbox &&
+	    !rfc822_output_string (buf,", ")) return NIL;
+      }
+    }
+    else if (adr->mailbox) {	/* start of group? */
+				/* yes, write group */
+      if (!(rfc822_output_cat (buf,adr->mailbox,rspecials) &&
+	    rfc822_output_string (buf,": "))) return NIL;
+      ++n;			/* in a group now */
+    }
+    else if (n) {		/* must be end of group (but be paranoid) */
+      if (!rfc822_output_char (buf,';') ||
+	  ((!--n && adr->next && adr->next->mailbox) &&
+	   !rfc822_output_string (buf,", "))) return NIL;
+    }
+    if (pretty && adr->next &&	/* pretty printing? */
+	((pretty += ((buf->cur > base) ? buf->cur - base :
+		     (buf->end - base) + (buf->cur - buf->beg))) >= 78)) {
+      if (!(rfc822_output_string (buf,"\015\012") &&
+	    rfc822_output_string (buf,RFC822CONT))) return NIL;
+      base = buf->cur;	/* update base for pretty printing */
+      pretty = sizeof (RFC822CONT) - 1;
+    }
+  }
+  return LONGT;
+}
+
+/* Write RFC 2822 route-address to string
+ * Accepts: buffer
+ *	    pointer to single address
+ * Returns: T if success, NIL if failure
+ */
+
+long rfc822_output_address (RFC822BUFFER *buf,ADDRESS *adr)
+{
+  return !adr || !adr->host ||
+    (
+#if RFC822			/* old code with A-D-L support */
+     (!adr->adl || (rfc822_output_string (buf,adr->adl) &&
+		    rfc822_output_char (buf,':'))) &&
+#endif
+     rfc822_output_cat (buf,adr->mailbox,NIL) &&
+     ((*adr->host == '@') ||	/* unless null host (HIGHLY discouraged!) */
+      (rfc822_output_char (buf,'@') &&
+       rfc822_output_cat (buf,adr->host,NIL))));
+}
+
+
+/* Output RFC 2822 string with concatenation
+ * Accepts: buffer
+ *	    string to concatenate
+ *	    list of special characters or NIL for dot-atom format
+ * Returns: T if success, NIL if failure
+ */
+
+long rfc822_output_cat (RFC822BUFFER *buf,char *src,const char *specials)
+{
+  char *s;
+  if (!*src ||			/* empty string or any specials present? */
+      (specials ? (T && strpbrk (src,specials)) :
+       (strpbrk (src,wspecials) || (*src == '.') || strstr (src,"..") ||
+	(src[strlen (src) - 1] == '.')))) {
+				/* yes, write as quoted string*/
+    if (!rfc822_output_char (buf,'"')) return NIL;
+				/* embedded quote characters? */
+    for (; s = strpbrk (src,"\\\""); src = s + 1) {
+				/* yes, insert quoting */
+      if (!(rfc822_output_data (buf,src,s-src) &&
+	    rfc822_output_char (buf,'\\') &&
+	    rfc822_output_char (buf,*s))) return NIL;
+    }
+				/* return string and trailing quote*/
+    return rfc822_output_string (buf,src) && rfc822_output_char (buf,'"');
+  }
+				/* easy case */
+  return rfc822_output_string (buf,src);
+}
+
+/* Output MIME parameter list
+ * Accepts: buffer
+ *	    parameter list
+ * Returns: T if success, NIL if failure
+ */
+
+long rfc822_output_parameter (RFC822BUFFER *buf,PARAMETER *param)
+{
+  while (param) {
+    if (rfc822_output_string (buf,"; ") &&
+	rfc822_output_string (buf,param->attribute) &&
+	rfc822_output_char (buf,'=') &&
+	rfc822_output_cat (buf,param->value,tspecials)) param = param->next;
+    else return NIL;
+  }
+  return LONGT;
+}
+
+
+/* Output RFC 2822 stringlist
+ * Accepts: buffer
+ *	    stringlist
+ * Returns: T if success, NIL if failure
+ */
+
+long rfc822_output_stringlist (RFC822BUFFER *buf,STRINGLIST *stl)
+{
+  while (stl)
+    if (!rfc822_output_cat (buf,(char *) stl->text.data,tspecials) ||
+	((stl = stl->next) && !rfc822_output_string (buf,", ")))
+      return NIL;
+  return LONGT;
+}
+
+/* Output body content header
+ * Accepts: buffer
+ *	    body to interpret
+ * Returns: T if success, NIL if failure
+ */
+
+long rfc822_output_body_header (RFC822BUFFER *buf,BODY *body)
+{
+  return			/* type and subtype*/
+    rfc822_output_string (buf,"Content-Type: ") &&
+    rfc822_output_string (buf,body_types[body->type]) &&
+    rfc822_output_char (buf,'/') &&
+    rfc822_output_string (buf,body->subtype ? body->subtype :
+			  rfc822_default_subtype (body->type)) &&
+				/* parameters (w/ US-ASCII default */
+    (body->parameter ? rfc822_output_parameter (buf,body->parameter) :
+     ((body->type != TYPETEXT) ||
+      (rfc822_output_string (buf,"; CHARSET=") &&
+       rfc822_output_string (buf,(body->encoding == ENC7BIT) ?
+			     "US-ASCII" : "X-UNKNOWN")))) &&
+    (!body->encoding ||	    /* note: 7BIT never output as encoding! */
+     (rfc822_output_string (buf,"\015\012Content-Transfer-Encoding: ") &&
+      rfc822_output_string (buf,body_encodings[body->encoding]))) &&
+    (!body->id ||		/* identification */
+     (rfc822_output_string (buf,"\015\012Content-ID: ") &&
+      rfc822_output_string (buf,body->id))) &&
+    (!body->description ||	/* description */
+     (rfc822_output_string (buf,"\015\012Content-Description: ") &&
+      rfc822_output_string (buf,body->description))) &&
+    (!body->md5 ||		/* MD5 checksum */
+     (rfc822_output_string (buf,"\015\012Content-MD5: ") &&
+      rfc822_output_string (buf,body->md5))) &&
+    (!body->language ||		/* language */
+     (rfc822_output_string (buf,"\015\012Content-Language: ") &&
+      rfc822_output_stringlist (buf,body->language))) &&
+    (!body->location ||		/* location */
+     (rfc822_output_string (buf,"\015\012Content-Location: ") &&
+      rfc822_output_string (buf,body->location))) &&
+    (!body->disposition.type ||	/* disposition */
+     (rfc822_output_string (buf,"\015\012Content-Disposition: ") &&
+      rfc822_output_string (buf,body->disposition.type) &&
+      rfc822_output_parameter (buf,body->disposition.parameter))) &&
+    rfc822_output_string (buf,"\015\012");
+}
+
+/* Encode a body for 7BIT transmittal
+ * Accepts: envelope
+ *	    body
+ */
+
+void rfc822_encode_body_7bit (ENVELOPE *env,BODY *body)
+{
+  void *f;
+  PART *part;
+  PARAMETER **param;
+  if (body) switch (body->type) {
+  case TYPEMULTIPART:		/* multi-part */
+    for (param = &body->parameter;
+	 *param && strcmp ((*param)->attribute,"BOUNDARY");
+	 param = &(*param)->next);
+    if (!*param) {		/* cookie not set up yet? */
+      char tmp[MAILTMPLEN];	/* make cookie not in BASE64 or QUOTEPRINT*/
+      sprintf (tmp,"%lu-%lu-%lu=:%lu",(unsigned long) gethostid (),
+	       (unsigned long) random (),(unsigned long) time (0),
+	       (unsigned long) getpid ());
+      (*param) = mail_newbody_parameter ();
+      (*param)->attribute = cpystr ("BOUNDARY");
+      (*param)->value = cpystr (tmp);
+    }
+    part = body->nested.part;	/* encode body parts */
+    do rfc822_encode_body_7bit (env,&part->body);
+    while (part = part->next);	/* until done */
+    break;
+  case TYPEMESSAGE:		/* encapsulated message */
+    switch (body->encoding) {
+    case ENC7BIT:
+      break;
+    case ENC8BIT:
+      MM_LOG ("8-bit included message in 7-bit message body",PARSE);
+      break;
+    case ENCBINARY:
+      MM_LOG ("Binary included message in 7-bit message body",PARSE);
+      break;
+    default:
+      fatal ("Invalid rfc822_encode_body_7bit message encoding");
+    }
+    break;			/* can't change encoding */
+  default:			/* all else has some encoding */
+    switch (body->encoding) {
+    case ENC8BIT:		/* encode 8BIT into QUOTED-PRINTABLE */
+				/* remember old 8-bit contents */
+      f = (void *) body->contents.text.data;
+      body->contents.text.data =
+	rfc822_8bit (body->contents.text.data,
+		     body->contents.text.size,&body->contents.text.size);
+      body->encoding = ENCQUOTEDPRINTABLE;
+      fs_give (&f);		/* flush old binary contents */
+      break;
+    case ENCBINARY:		/* encode binary into BASE64 */
+				/* remember old binary contents */
+      f = (void *) body->contents.text.data;
+      body->contents.text.data =
+	rfc822_binary ((void *) body->contents.text.data,
+		       body->contents.text.size,&body->contents.text.size);
+      body->encoding = ENCBASE64;
+      fs_give (&f);		/* flush old binary contents */
+    default:			/* otherwise OK */
+      break;
+    }
+    break;
+  }
+}
+
+/* Encode a body for 8BIT transmittal
+ * Accepts: envelope
+ *	    body
+ */
+
+void rfc822_encode_body_8bit (ENVELOPE *env,BODY *body)
+{
+  void *f;
+  PART *part;
+  PARAMETER **param;
+  if (body) switch (body->type) {
+  case TYPEMULTIPART:		/* multi-part */
+    for (param = &body->parameter;
+	 *param && strcmp ((*param)->attribute,"BOUNDARY");
+	 param = &(*param)->next);
+    if (!*param) {		/* cookie not set up yet? */
+      char tmp[MAILTMPLEN];	/* make cookie not in BASE64 or QUOTEPRINT*/
+      sprintf (tmp,"%lu-%lu-%lu=:%lu",(unsigned long) gethostid (),
+	       (unsigned long) random (),(unsigned long) time (0),
+	       (unsigned long) getpid ());
+      (*param) = mail_newbody_parameter ();
+      (*param)->attribute = cpystr ("BOUNDARY");
+      (*param)->value = cpystr (tmp);
+    }
+    part = body->nested.part;	/* encode body parts */
+    do rfc822_encode_body_8bit (env,&part->body);
+    while (part = part->next);	/* until done */
+    break;
+  case TYPEMESSAGE:		/* encapsulated message */
+    switch (body->encoding) {
+    case ENC7BIT:
+    case ENC8BIT:
+      break;
+    case ENCBINARY:
+      MM_LOG ("Binary included message in 8-bit message body",PARSE);
+      break;
+    default:
+      fatal ("Invalid rfc822_encode_body_7bit message encoding");
+    }
+    break;			/* can't change encoding */
+  default:			/* other type, encode binary into BASE64 */
+    if (body->encoding == ENCBINARY) {
+				/* remember old binary contents */
+      f = (void *) body->contents.text.data;
+      body->contents.text.data =
+	rfc822_binary ((void *) body->contents.text.data,
+		       body->contents.text.size,&body->contents.text.size);
+      body->encoding = ENCBASE64;
+      fs_give (&f);		/* flush old binary contents */
+    }
+    break;
+  }
+}
+
+/* Output RFC 822 text
+ * Accepts: buffer
+ *	    body
+ * Returns: T if successful, NIL if failure
+ */
+
+long rfc822_output_text (RFC822BUFFER *buf,BODY *body)
+{
+				/* MULTIPART gets special handling */
+  if (body->type == TYPEMULTIPART) {
+    char *cookie,tmp[MAILTMPLEN];
+    PARAMETER *param;
+    PART *part;
+				/* find cookie */
+    for (param = body->parameter; param && strcmp (param->attribute,"BOUNDARY");
+	 param = param->next);
+    if (param) cookie = param->value;
+    else {		  /* make cookie not in BASE64 or QUOTEPRINT*/
+      sprintf (cookie = tmp,"%lu-%lu-%lu=:%lu",(unsigned long) gethostid (),
+	       (unsigned long) random (),(unsigned long) time (0),
+	       (unsigned long) getpid ());
+      (param = mail_newbody_parameter ())->attribute = cpystr ("BOUNDARY");
+      param->value = cpystr (tmp);
+      param->next = body->parameter;
+      body->parameter = param;
+    }
+				/* output each part */
+    for (part = body->nested.part; part; part = part->next)
+      if (!(rfc822_output_string (buf,"--") &&
+	    rfc822_output_string (buf,cookie) &&
+	    rfc822_output_string (buf,"\015\012") &&
+	    rfc822_output_body_header (buf,&part->body) &&
+	    rfc822_output_string (buf,"\015\012") &&
+	    rfc822_output_text (buf,&part->body))) return NIL;
+				/* output trailing cookie */
+    return rfc822_output_string (buf,"--") &&
+      rfc822_output_string (buf,cookie) &&
+      rfc822_output_string (buf,"--\015\012");
+  }
+				/* output segment and trailing CRLF */
+  return (!body->contents.text.data ||
+	  rfc822_output_string (buf,(char *) body->contents.text.data)) &&
+    rfc822_output_string (buf,"\015\012");
+}
+
+/* Body contents encoding/decoding routines */
+
+
+/* Convert BASE64 contents to binary
+ * Accepts: source
+ *	    length of source
+ *	    pointer to return destination length
+ * Returns: destination as binary or NIL if error
+ */
+
+#define WSP 0176		/* NUL, TAB, LF, FF, CR, SPC */
+#define JNK 0177
+#define PAD 0100
+
+void *rfc822_base64 (unsigned char *src,unsigned long srcl,unsigned long *len)
+{
+  char c,*s,tmp[MAILTMPLEN];
+  void *ret = fs_get ((size_t) ((*len = 4 + ((srcl * 3) / 4))) + 1);
+  char *d = (char *) ret;
+  int e;
+  static char decode[256] = {
+   WSP,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,WSP,WSP,JNK,WSP,WSP,JNK,JNK,
+   JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,
+   WSP,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,076,JNK,JNK,JNK,077,
+   064,065,066,067,070,071,072,073,074,075,JNK,JNK,JNK,PAD,JNK,JNK,
+   JNK,000,001,002,003,004,005,006,007,010,011,012,013,014,015,016,
+   017,020,021,022,023,024,025,026,027,030,031,JNK,JNK,JNK,JNK,JNK,
+   JNK,032,033,034,035,036,037,040,041,042,043,044,045,046,047,050,
+   051,052,053,054,055,056,057,060,061,062,063,JNK,JNK,JNK,JNK,JNK,
+   JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,
+   JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,
+   JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,
+   JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,
+   JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,
+   JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,
+   JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,
+   JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK,JNK
+  };
+				/* initialize block */
+  memset (ret,0,((size_t) *len) + 1);
+  *len = 0;			/* in case we return an error */
+
+				/* simple-minded decode */
+  for (e = 0; srcl--; ) switch (c = decode[*src++]) {
+  default:			/* valid BASE64 data character */
+    switch (e++) {		/* install based on quantum position */
+    case 0:
+      *d = c << 2;		/* byte 1: high 6 bits */
+      break;
+    case 1:
+      *d++ |= c >> 4;		/* byte 1: low 2 bits */
+      *d = c << 4;		/* byte 2: high 4 bits */
+      break;
+    case 2:
+      *d++ |= c >> 2;		/* byte 2: low 4 bits */
+      *d = c << 6;		/* byte 3: high 2 bits */
+      break;
+    case 3:
+      *d++ |= c;		/* byte 3: low 6 bits */
+      e = 0;			/* reinitialize mechanism */
+      break;
+    }
+    break;
+  case WSP:			/* whitespace */
+    break;
+  case PAD:			/* padding */
+    switch (e++) {		/* check quantum position */
+    case 3:			/* one = is good enough in quantum 3 */
+				/* make sure no data characters in remainder */
+      for (; srcl; --srcl) switch (decode[*src++]) {
+				/* ignore space, junk and extraneous padding */
+      case WSP: case JNK: case PAD:
+	break;
+      default:			/* valid BASE64 data character */
+	/* This indicates bad MIME.  One way that it can be caused is if
+	   a single-section message was BASE64 encoded and then something
+	   (e.g. a mailing list processor) appended text.  The problem is
+	   that in 1 out of 3 cases, there is no padding and hence no way
+	   to detect the end of the data.  Consequently, prudent software
+	   will always encapsulate a BASE64 segment inside a MULTIPART.
+	   */
+	sprintf (tmp,"Possible data truncation in rfc822_base64(): %.80s",
+		 (char *) src - 1);
+	if (s = strpbrk (tmp,"\015\012")) *s = NIL;
+	mm_log (tmp,PARSE);
+	srcl = 1;		/* don't issue any more messages */
+	break;
+      }
+      break;
+    case 2:			/* expect a second = in quantum 2 */
+      if (srcl && (*src == '=')) break;
+    default:			/* impossible quantum position */
+      fs_give (&ret);
+      return NIL;
+    }
+    break;
+  case JNK:			/* junk character */
+    fs_give (&ret);
+    return NIL;
+  }
+  *len = d - (char *) ret;	/* calculate data length */
+  *d = '\0';			/* NUL terminate just in case */
+  return ret;			/* return the string */
+}
+
+/* Convert binary contents to BASE64
+ * Accepts: source
+ *	    length of source
+ *	    pointer to return destination length
+ * Returns: destination as BASE64
+ */
+
+unsigned char *rfc822_binary (void *src,unsigned long srcl,unsigned long *len)
+{
+  unsigned char *ret,*d;
+  unsigned char *s = (unsigned char *) src;
+  char *v = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  unsigned long i = ((srcl + 2) / 3) * 4;
+  *len = i += 2 * ((i / 60) + 1);
+  d = ret = (unsigned char *) fs_get ((size_t) ++i);
+				/* process tuplets */
+  for (i = 0; srcl >= 3; s += 3, srcl -= 3) {
+    *d++ = v[s[0] >> 2];	/* byte 1: high 6 bits (1) */
+				/* byte 2: low 2 bits (1), high 4 bits (2) */
+    *d++ = v[((s[0] << 4) + (s[1] >> 4)) & 0x3f];
+				/* byte 3: low 4 bits (2), high 2 bits (3) */
+    *d++ = v[((s[1] << 2) + (s[2] >> 6)) & 0x3f];
+    *d++ = v[s[2] & 0x3f];	/* byte 4: low 6 bits (3) */
+    if ((++i) == 15) {		/* output 60 characters? */
+      i = 0;			/* restart line break count, insert CRLF */
+      *d++ = '\015'; *d++ = '\012';
+    }
+  }
+  if (srcl) {
+    *d++ = v[s[0] >> 2];	/* byte 1: high 6 bits (1) */
+				/* byte 2: low 2 bits (1), high 4 bits (2) */
+    *d++ = v[((s[0] << 4) + (--srcl ? (s[1] >> 4) : 0)) & 0x3f];
+				/* byte 3: low 4 bits (2), high 2 bits (3) */
+    *d++ = srcl ? v[((s[1] << 2) + (--srcl ? (s[2] >> 6) : 0)) & 0x3f] : '=';
+				/* byte 4: low 6 bits (3) */
+    *d++ = srcl ? v[s[2] & 0x3f] : '=';
+    if (srcl) srcl--;		/* count third character if processed */
+    if ((++i) == 15) {		/* output 60 characters? */
+      i = 0;			/* restart line break count, insert CRLF */
+      *d++ = '\015'; *d++ = '\012';
+    }
+  }
+  *d++ = '\015'; *d++ = '\012';	/* insert final CRLF */
+  *d = '\0';			/* tie off string */
+  if (((unsigned long) (d - ret)) != *len) fatal ("rfc822_binary logic flaw");
+  return ret;			/* return the resulting string */
+}
+
+/* Convert QUOTED-PRINTABLE contents to 8BIT
+ * Accepts: source
+ *	    length of source
+ * 	    pointer to return destination length
+ * Returns: destination as 8-bit text or NIL if error
+ */
+
+unsigned char *rfc822_qprint (unsigned char *src,unsigned long srcl,
+			      unsigned long *len)
+{
+  char tmp[MAILTMPLEN];
+  unsigned int bogon = NIL;
+  unsigned char *ret = (unsigned char *) fs_get ((size_t) srcl + 1);
+  unsigned char *d = ret;
+  unsigned char *t = d;
+  unsigned char *s = src;
+  unsigned char c,e;
+  *len = 0;			/* in case we return an error */
+				/* until run out of characters */
+  while (((unsigned long) (s - src)) < srcl) {
+    switch (c = *s++) {		/* what type of character is it? */
+    case '=':			/* quoting character */
+      if (((unsigned long) (s - src)) < srcl) switch (c = *s++) {
+      case '\0':		/* end of data */
+	s--;			/* back up pointer */
+	break;
+      case '\015':		/* non-significant line break */
+	if ((((unsigned long) (s - src)) < srcl) && (*s == '\012')) s++;
+      case '\012':		/* bare LF */
+	t = d;			/* accept any leading spaces */
+	break;
+      default:			/* two hex digits then */
+	if (!(isxdigit (c) && (((unsigned long) (s - src)) < srcl) &&
+	      (e = *s++) && isxdigit (e))) {
+	  /* This indicates bad MIME.  One way that it can be caused is if
+	     a single-section message was QUOTED-PRINTABLE encoded and then
+	     something (e.g. a mailing list processor) appended text.  The
+	     problem is that there is no way to determine where the encoded
+	     data ended and the appended crud began.  Consequently, prudent
+	     software will always encapsulate a QUOTED-PRINTABLE segment
+	     inside a MULTIPART.
+	   */
+	  if (!bogon++) {	/* only do this once */
+	    sprintf (tmp,"Invalid quoted-printable sequence: =%.80s",
+		   (char *) s - 1);
+	    mm_log (tmp,PARSE);
+	  }
+	  *d++ = '=';		/* treat = as ordinary character */
+	  *d++ = c;		/* and the character following */
+	  t = d;		/* note point of non-space */
+	  break;
+	}
+	*d++ = hex2byte (c,e);	/* merge the two hex digits */
+	t = d;			/* note point of non-space */
+	break;
+      }
+      break;
+    case ' ':			/* space, possibly bogus */
+      *d++ = c;			/* stash the space but don't update s */
+      break;
+    case '\015':		/* end of line */
+    case '\012':		/* bare LF */
+      d = t;			/* slide back to last non-space, drop in */
+    default:
+      *d++ = c;			/* stash the character */
+      t = d;			/* note point of non-space */
+    }      
+  }
+  *d = '\0';			/* tie off results */
+  *len = d - ret;		/* calculate length */
+  return ret;			/* return the string */
+}
+
+/* Convert 8BIT contents to QUOTED-PRINTABLE
+ * Accepts: source
+ *	    length of source
+ * 	    pointer to return destination length
+ * Returns: destination as quoted-printable text
+ */
+
+#define MAXL (size_t) 75	/* 76th position only used by continuation = */
+
+unsigned char *rfc822_8bit (unsigned char *src,unsigned long srcl,
+			    unsigned long *len)
+{
+  unsigned long lp = 0;
+  unsigned char *ret = (unsigned char *)
+    fs_get ((size_t) (3*srcl + 3*(((3*srcl)/MAXL) + 1)));
+  unsigned char *d = ret;
+  char *hex = "0123456789ABCDEF";
+  unsigned char c;
+  while (srcl--) {		/* for each character */
+				/* true line break? */
+    if (((c = *src++) == '\015') && (*src == '\012') && srcl) {
+      *d++ = '\015'; *d++ = *src++; srcl--;
+      lp = 0;			/* reset line count */
+    }
+    else {			/* not a line break */
+				/* quoting required? */
+      if (iscntrl (c) || (c == 0x7f) || (c & 0x80) || (c == '=') ||
+	  ((c == ' ') && (*src == '\015'))) {
+	if ((lp += 3) > MAXL) {	/* yes, would line overflow? */
+	  *d++ = '='; *d++ = '\015'; *d++ = '\012';
+	  lp = 3;		/* set line count */
+	}
+	*d++ = '=';		/* quote character */
+	*d++ = hex[c >> 4];	/* high order 4 bits */
+	*d++ = hex[c & 0xf];	/* low order 4 bits */
+      }
+      else {			/* ordinary character */
+	if ((++lp) > MAXL) {	/* would line overflow? */
+	  *d++ = '='; *d++ = '\015'; *d++ = '\012';
+	  lp = 1;		/* set line count */
+	}
+	*d++ = c;		/* ordinary character */
+      }
+    }
+  }
+  *d = '\0';			/* tie off destination */
+  *len = d - ret;		/* calculate true size */
+				/* try to give some space back */
+  fs_resize ((void **) &ret,(size_t) *len + 1);
+  return ret;
+}
+
+/* Legacy Routines */
+
+/*
+ * WARNING: These routines are for compatibility with old software only.
+ *
+ * Their use in new software is to be avoided.
+ *
+ * These interfaces do not provide satisfactory buffer checking.  In
+ * versions of c-client prior to imap-2005, they did not provide any
+ * buffer checking at all.
+ *
+ * As a half-hearted attempt, these new compatability functions for the
+ * legacy interfaces limit what they write to size SENDBUFLEN and will
+ * fatal() if more than that is written.  However, that isn't good enough
+ * since several of these functions *append* to the buffer, and return an
+ * updated pointer.  Consequently, there is no way of knowing what the
+ * actual available space is in the buffer, yet the function will still
+ * write up to SENDBUFLEN bytes even if there is much less space actually
+ * available.  The result is a buffer overflow.
+ *
+ * You won't get a buffer overflow if you never attempt to append using
+ * these interfaces, but you can get the fatal() if it tries to write
+ * more than SENDBUFLEN bytes.
+ *
+ * To avoid this problem, use the corresponding rfc822_output_???()
+ * functions instead, e.g., rfc822_output_address() instead of
+ * rfc822_address().
+ *
+ */
+
+/* Flush routine, only called if overflow
+ * Accepts: stream
+ *	    string to output
+ * Returns: never
+ */
+
+static long rfc822_legacy_soutr (void *stream,char *string)
+{
+  fatal ("rfc822.c legacy routine buffer overflow");
+  return NIL;
+}
+
+/* Legacy write RFC 2822 header from message structure
+ * Accepts: scratch buffer to write into
+ *	    message envelope
+ *	    message body
+ */
+
+void rfc822_header (char *header,ENVELOPE *env,BODY *body)
+{
+  RFC822BUFFER buf;
+				/* write at start of buffer */
+  buf.end = (buf.beg = buf.cur = header) + SENDBUFLEN - 1;
+  buf.f = rfc822_legacy_soutr;
+  buf.s = NIL;
+  rfc822_output_header (&buf,env,body,NIL,NIL);
+  *buf.cur = '\0';		/* tie off buffer */
+}
+
+
+/* Legacy write RFC 2822 text from header line
+ * Accepts: pointer to destination string pointer
+ *	    pointer to header type
+ *	    message to interpret
+ *	    pointer to text
+ */
+
+void rfc822_header_line (char **header,char *type,ENVELOPE *env,char *text)
+{
+  RFC822BUFFER buf;
+				/* append to buffer */
+  buf.end = (buf.beg = buf.cur = *header + strlen (*header)) + SENDBUFLEN - 1;
+  buf.f = rfc822_legacy_soutr;
+  buf.s = NIL;
+  rfc822_output_header_line (&buf,type,env->remail ? LONGT : NIL,text);
+  *(*header = buf.cur) = '\0';	/* tie off buffer */
+}
+
+/* Legacy write RFC 2822 address from header line
+ * Accepts: pointer to destination string pointer
+ *	    pointer to header type
+ *	    message to interpret
+ *	    address to interpret
+ */
+
+void rfc822_address_line (char **header,char *type,ENVELOPE *env,ADDRESS *adr)
+{
+  RFC822BUFFER buf;
+				/* append to buffer */
+  buf.end = (buf.beg = buf.cur = *header + strlen (*header)) + SENDBUFLEN - 1;
+  buf.f = rfc822_legacy_soutr;
+  buf.s = NIL;
+  rfc822_output_address_line (&buf,type,env->remail ? LONGT : NIL,adr,NIL);
+  *(*header = buf.cur) = '\0';	/* tie off buffer */
+}
+
+
+/* Legacy write RFC 2822 address list
+ * Accepts: pointer to destination string
+ *	    address to interpret
+ *	    header base if pretty-printing
+ * Returns: end of destination string
+ */
+
+char *rfc822_write_address_full (char *dest,ADDRESS *adr,char *base)
+{
+  RFC822BUFFER buf;
+				/* append to buffer */
+  buf.end = (buf.beg = buf.cur = dest + strlen (dest)) + SENDBUFLEN - 1;
+  buf.f = rfc822_legacy_soutr;
+  buf.s = NIL;
+  rfc822_output_address_list (&buf,adr,base ? dest - base : 0,NIL);
+  *buf.cur = '\0';		/* tie off buffer */
+  return buf.cur;
+}
+
+
+/* Legacy write RFC 2822 route-address to string
+ * Accepts: pointer to destination string
+ *	    address to interpret
+ */
+
+void rfc822_address (char *dest,ADDRESS *adr)
+{
+  RFC822BUFFER buf;
+				/* append to buffer */
+  buf.end = (buf.beg = buf.cur = dest + strlen (dest)) + SENDBUFLEN - 1;
+  buf.f = rfc822_legacy_soutr;
+  buf.s = NIL;
+  rfc822_output_address (&buf,adr);
+  *buf.cur = '\0';		/* tie off buffer */
+}
+
+/* Concatenate RFC 2822 string
+ * Accepts: pointer to destination string
+ *	    pointer to string to concatenate
+ *	    list of special characters or NIL for dot-atom format
+ */
+
+void rfc822_cat (char *dest,char *src,const char *specials)
+{
+  RFC822BUFFER buf;
+				/* append to buffer */
+  buf.end = (buf.beg = buf.cur = dest + strlen (dest)) + SENDBUFLEN - 1;
+  buf.f = rfc822_legacy_soutr;
+  buf.s = NIL;
+  rfc822_output_cat (&buf,src,specials);
+  *buf.cur = '\0';		/* tie off buffer */
+}
+
+
+/* Legacy write body content header
+ * Accepts: pointer to destination string pointer
+ *	    pointer to body to interpret
+ */
+
+void rfc822_write_body_header (char **dst,BODY *body)
+{
+  RFC822BUFFER buf;
+				/* append to buffer */
+  buf.end = (buf.beg = buf.cur = *dst + strlen (*dst)) + SENDBUFLEN - 1;
+  buf.f = rfc822_legacy_soutr;
+  buf.s = NIL;
+  rfc822_output_body_header (&buf,body);
+  *(*dst = buf.cur) = '\0';	/* tie off buffer */
+}
+
+/* Legacy output RFC 822 message
+ * Accepts: temporary buffer
+ *	    envelope
+ *	    body
+ *	    I/O routine
+ *	    stream for I/O routine
+ *	    non-zero if 8-bit output desired
+ * Returns: T if successful, NIL if failure
+ */
+
+long rfc822_output (char *t,ENVELOPE *env,BODY *body,soutr_t f,void *s,
+		    long ok8bit)
+{
+  long ret;
+  rfc822out_t r822o = (rfc822out_t) mail_parameters (NIL,GET_RFC822OUTPUT,NIL);
+				/* call external RFC 2822 output generator */
+  if (r822o) ret = (*r822o) (t,env,body,f,s,ok8bit);
+  else {			/* output generator not armed */
+    RFC822BUFFER buf;		/* use our own buffer rather than trust */
+    char tmp[SENDBUFLEN+1];	/*  client to give us a big enough one */
+    buf.f = f;
+    buf.s = s;
+    buf.end = (buf.beg = buf.cur = t) + SENDBUFLEN - 1;
+    tmp[SENDBUFLEN] = '\0';	/* must have additional guard byte */
+    ret = rfc822_output_full (&buf,env,body,ok8bit);
+  }
+  return ret;
+}
+
+
+/* Legacy output RFC 822 body
+ * Accepts: body
+ *	    I/O routine
+ *	    stream for I/O routine
+ * Returns: T if successful, NIL if failure
+ */
+
+long rfc822_output_body (BODY *body,soutr_t f,void *s)
+{
+  RFC822BUFFER buf;
+  char tmp[SENDBUFLEN+1];
+  buf.f = f;
+  buf.s = s;
+  buf.end = (buf.beg = buf.cur = tmp) + SENDBUFLEN;
+  tmp[SENDBUFLEN] = '\0';	/* must have additional guard byte */
+  return rfc822_output_text (&buf,body) && rfc822_output_flush (&buf);
+}
diff --git a/imap/src/c-client/rfc822.h b/imap/src/c-client/rfc822.h
new file mode 100644
index 00000000..0621732a
--- /dev/null
+++ b/imap/src/c-client/rfc822.h
@@ -0,0 +1,127 @@
+/* ========================================================================
+ * Copyright 1988-2006 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:	RFC 2822 and MIME routines
+ *
+ * Author:	Mark Crispin
+ *		Networks and Distributed Computing
+ *		Computing & Communications
+ *		University of Washington
+ *		Administration Building, AG-44
+ *		Seattle, WA  98195
+ *		Internet: MRC@CAC.Washington.EDU
+ *
+ * Date:	27 July 1988
+ * Last Edited:	30 August 2006
+ *
+ * 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 NationalInstitutes of Health
+ * under grant number RR-00785.
+ */
+
+#define MAXGROUPDEPTH 50	/* RFC [2]822 doesn't allow any group nesting */
+#define MAXMIMEDEPTH 50		/* more than any sane MIMEgram */
+
+/* Output buffering for RFC [2]822 */
+
+typedef long (*soutr_t) (void *stream,char *string);
+typedef long (*rfc822out_t) (char *tmp,ENVELOPE *env,BODY *body,soutr_t f,
+			     void *s,long ok8bit);
+
+typedef struct rfc822buffer {
+  soutr_t f;			/* I/O flush routine */
+  void *s;			/* stream for I/O routine */
+  char *beg;			/* start of buffer */
+  char *cur;			/* current buffer pointer */
+  char *end;			/* end of buffer */
+} RFC822BUFFER;
+
+typedef long (*rfc822outfull_t) (RFC822BUFFER *buf,ENVELOPE *env,BODY *body,
+				 long ok8bit);
+
+/* Function prototypes */
+
+char *rfc822_default_subtype (unsigned short type);
+void rfc822_parse_msg_full (ENVELOPE **en,BODY **bdy,char *s,unsigned long i,
+			    STRING *bs,char *host,unsigned long depth,
+			    unsigned long flags);
+void rfc822_parse_content (BODY *body,STRING *bs,char *h,unsigned long depth,
+			   unsigned long flags);
+void rfc822_parse_content_header (BODY *body,char *name,char *s);
+void rfc822_parse_parameter (PARAMETER **par,char *text);
+void rfc822_parse_adrlist (ADDRESS **lst,char *string,char *host);
+ADDRESS *rfc822_parse_address (ADDRESS **lst,ADDRESS *last,char **string,
+			       char *defaulthost,unsigned long depth);
+ADDRESS *rfc822_parse_group (ADDRESS **lst,ADDRESS *last,char **string,
+			     char *defaulthost,unsigned long depth);
+ADDRESS *rfc822_parse_mailbox (char **string,char *defaulthost);
+long rfc822_phraseonly (char *end);
+ADDRESS *rfc822_parse_routeaddr (char *string,char **ret,char *defaulthost);
+ADDRESS *rfc822_parse_addrspec (char *string,char **ret,char *defaulthost);
+char *rfc822_parse_domain (char *string,char **end);
+char *rfc822_parse_phrase (char *string);
+char *rfc822_parse_word (char *string,const char *delimiters);
+char *rfc822_cpy (char *src);
+char *rfc822_quote (char *src);
+ADDRESS *rfc822_cpy_adr (ADDRESS *adr);
+void rfc822_skipws (char **s);
+char *rfc822_skip_comment (char **s,long trim);
+
+long rfc822_output_full (RFC822BUFFER *buf,ENVELOPE *env,BODY *body,long ok8);
+long rfc822_output_flush (RFC822BUFFER *buf);
+long rfc822_output_header (RFC822BUFFER *buf,ENVELOPE *env,BODY *body,
+			   const char *specials,long flags);
+long rfc822_output_header_line (RFC822BUFFER *buf,char *type,long resent,
+				char *text);
+long rfc822_output_address_line (RFC822BUFFER *buf,char *type,long resent,
+				 ADDRESS *adr,const char *specials);
+long rfc822_output_address_list (RFC822BUFFER *buf,ADDRESS *adr,long pretty,
+				 const char *specials);
+long rfc822_output_address (RFC822BUFFER *buf,ADDRESS *adr);
+long rfc822_output_cat (RFC822BUFFER *buf,char *src,const char *specials);
+long rfc822_output_parameter (RFC822BUFFER *buf,PARAMETER *param);
+long rfc822_output_stringlist (RFC822BUFFER *buf,STRINGLIST *stl);
+long rfc822_output_body_header (RFC822BUFFER *buf,BODY *body);
+void rfc822_encode_body_7bit (ENVELOPE *env,BODY *body);
+void rfc822_encode_body_8bit (ENVELOPE *env,BODY *body);
+long rfc822_output_text (RFC822BUFFER *buf,BODY *body);
+void *rfc822_base64 (unsigned char *src,unsigned long srcl,unsigned long *len);
+unsigned char *rfc822_binary (void *src,unsigned long srcl,unsigned long *len);
+unsigned char *rfc822_qprint (unsigned char *src,unsigned long srcl,
+			      unsigned long *len);
+unsigned char *rfc822_8bit (unsigned char *src,unsigned long srcl,
+			    unsigned long *len);
+
+/* Legacy routines for compatibility with the past */
+
+void rfc822_header (char *header,ENVELOPE *env,BODY *body);
+void rfc822_header_line (char **header,char *type,ENVELOPE *env,char *text);
+void rfc822_address_line (char **header,char *type,ENVELOPE *env,ADDRESS *adr);
+char *rfc822_write_address_full (char *dest,ADDRESS *adr,char *base);
+void rfc822_address (char *dest,ADDRESS *adr);
+void rfc822_cat (char *dest,char *src,const char *specials);
+void rfc822_write_body_header (char **header,BODY *body);
+long rfc822_output (char *t,ENVELOPE *env,BODY *body,soutr_t f,void *s,
+		    long ok8bit);
+long rfc822_output_body (BODY *body,soutr_t f,void *s);
+
+
+#define rfc822_write_address(dest,adr) \
+  rfc822_write_address_full (dest,adr,NIL)
+
+#define rfc822_parse_msg(en,bdy,s,i,bs,host,flags) \
+  rfc822_parse_msg_full (en,bdy,s,i,bs,host,0,flags)
diff --git a/imap/src/c-client/smanager.c b/imap/src/c-client/smanager.c
new file mode 100644
index 00000000..cee659ff
--- /dev/null
+++ b/imap/src/c-client/smanager.c
@@ -0,0 +1,129 @@
+/* ========================================================================
+ * Copyright 1988-2006 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:	Subscription Manager
+ *
+ * Author:	Mark Crispin
+ *		Networks and Distributed Computing
+ *		Computing & Communications
+ *		University of Washington
+ *		Administration Building, AG-44
+ *		Seattle, WA  98195
+ *		Internet: MRC@CAC.Washington.EDU
+ *
+ * Date:	3 December 1992
+ * Last Edited:	6 December 2006
+ */
+
+
+#include <stdio.h>
+#include <ctype.h>
+#include "c-client.h"
+
+/* Subscribe to mailbox
+ * Accepts: mailbox name
+ * Returns: T on success, NIL on failure
+ */
+
+long sm_subscribe (char *mailbox)
+{
+  FILE *f;
+  char *s,db[MAILTMPLEN],tmp[MAILTMPLEN];
+				/* canonicalize INBOX */
+  if (!compare_cstring (mailbox,"INBOX")) mailbox = "INBOX";
+  SUBSCRIPTIONFILE (db);	/* open subscription database */
+  if (f = fopen (db,"r")) {	/* make sure not already there */
+    while (fgets (tmp,MAILTMPLEN,f)) {
+      if (s = strchr (tmp,'\n')) *s = '\0';
+      if (!strcmp (tmp,mailbox)) {/* already subscribed? */
+	sprintf (tmp,"Already subscribed to mailbox %.80s",mailbox);
+	MM_LOG (tmp,ERROR);
+	fclose (f);
+	return NIL;
+      }
+    }
+    fclose (f);
+  }
+  if (!(f = fopen (db,"a"))) {	/* append new entry */
+    MM_LOG ("Can't append to subscription database",ERROR);
+    return NIL;
+  }
+  fprintf (f,"%s\n",mailbox);
+  return (fclose (f) == EOF) ? NIL : T;
+}
+
+/* Unsubscribe from mailbox
+ * Accepts: mailbox name
+ * Returns: T on success, NIL on failure
+ */
+
+long sm_unsubscribe (char *mailbox)
+{
+  FILE *f,*tf;
+  char *s,tmp[MAILTMPLEN],old[MAILTMPLEN],newname[MAILTMPLEN];
+  int found = NIL;
+				/* canonicalize INBOX */
+  if (!compare_cstring (mailbox,"INBOX")) mailbox = "INBOX";
+  SUBSCRIPTIONFILE (old);	/* make file names */
+  SUBSCRIPTIONTEMP (newname);
+  if (!(f = fopen (old,"r")))	/* open subscription database */
+    MM_LOG ("No subscriptions",ERROR);
+  else if (!(tf = fopen (newname,"w"))) {
+    MM_LOG ("Can't create subscription temporary file",ERROR);
+    fclose (f);
+  }
+  else {
+    while (fgets (tmp,MAILTMPLEN,f)) {
+      if (s = strchr (tmp,'\n')) *s = '\0';
+      if (strcmp (tmp,mailbox)) fprintf (tf,"%s\n",tmp);
+      else found = T;		/* found the name */
+    }
+    fclose (f);
+    if (fclose (tf) == EOF)
+      MM_LOG ("Can't write subscription temporary file",ERROR);
+    else if (!found) {
+      sprintf (tmp,"Not subscribed to mailbox %.80s",mailbox);
+      MM_LOG (tmp,ERROR);	/* error if at end */
+    }
+    else if (!unlink (old) && !rename (newname,old)) return LONGT;
+    else MM_LOG ("Can't update subscription database",ERROR);
+  }
+  return NIL;
+}
+
+/* Read subscription database
+ * Accepts: pointer to subscription database handle (handle NIL if first time)
+ * Returns: character string for subscription database or NIL if done
+ */
+
+static char sbname[MAILTMPLEN];
+
+char *sm_read (void **sdb)
+{
+  FILE *f = (FILE *) *sdb;
+  char *s;
+  if (!f) {			/* first time through? */
+    SUBSCRIPTIONFILE (sbname);	/* open subscription database */
+				/* make sure not already there */
+    if (f = fopen (sbname,"r")) *sdb = (void *) f;
+    else return NIL;
+  }
+  if (fgets (sbname,MAILTMPLEN,f)) {
+    if (s = strchr (sbname,'\n')) *s = '\0';
+    return sbname;
+  }
+  fclose (f);			/* all done */
+  *sdb = NIL;			/* zap sdb */
+  return NIL;
+}
diff --git a/imap/src/c-client/smtp.c b/imap/src/c-client/smtp.c
new file mode 100644
index 00000000..0a3cf489
--- /dev/null
+++ b/imap/src/c-client/smtp.c
@@ -0,0 +1,793 @@
+/* ========================================================================
+ * 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:	Simple Mail Transfer Protocol (SMTP) routines
+ *
+ * Author:	Mark Crispin
+ *		Networks and Distributed Computing
+ *		Computing & Communications
+ *		University of Washington
+ *		Administration Building, AG-44
+ *		Seattle, WA  98195
+ *		Internet: MRC@CAC.Washington.EDU
+ *
+ * Date:	27 July 1988
+ * Last Edited:	28 January 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 "c-client.h"
+
+/* Constants */
+
+#define SMTPSSLPORT (long) 465	/* former assigned SSL TCP contact port */
+#define SMTPGREET (long) 220	/* SMTP successful greeting */
+#define SMTPAUTHED (long) 235	/* SMTP successful authentication */
+#define SMTPOK (long) 250	/* SMTP OK code */
+#define SMTPAUTHREADY (long) 334/* SMTP ready for authentication */
+#define SMTPREADY (long) 354	/* SMTP ready for data */
+#define SMTPSOFTFATAL (long) 421/* SMTP soft fatal code */
+#define SMTPWANTAUTH (long) 505	/* SMTP authentication needed */
+#define SMTPWANTAUTH2 (long) 530/* SMTP authentication needed */
+#define SMTPUNAVAIL (long) 550	/* SMTP mailbox unavailable */
+#define SMTPHARDERROR (long) 554/* SMTP miscellaneous hard failure */
+
+
+/* Convenient access to protocol-specific data */
+
+#define ESMTP stream->protocol.esmtp
+
+
+/* Function prototypes */
+
+void *smtp_challenge (void *s,unsigned long *len);
+long smtp_response (void *s,char *response,unsigned long size);
+long smtp_auth (SENDSTREAM *stream,NETMBX *mb,char *tmp);
+long smtp_rcpt (SENDSTREAM *stream,ADDRESS *adr,long *error);
+long smtp_send (SENDSTREAM *stream,char *command,char *args);
+long smtp_reply (SENDSTREAM *stream);
+long smtp_ehlo (SENDSTREAM *stream,char *host,NETMBX *mb);
+long smtp_fake (SENDSTREAM *stream,char *text);
+static long smtp_seterror (SENDSTREAM *stream,long code,char *text);
+long smtp_soutr (void *stream,char *s);
+
+/* Mailer parameters */
+
+static unsigned long smtp_maxlogintrials = MAXLOGINTRIALS;
+static long smtp_port = 0;	/* default port override */
+static long smtp_sslport = 0;
+
+
+#ifndef RFC2821
+#define RFC2821			/* RFC 2821 compliance */
+#endif
+
+/* SMTP limits, current as of RFC 2821 */
+
+#define SMTPMAXLOCALPART 64
+#define SMTPMAXDOMAIN 255
+#define SMTPMAXPATH 256
+
+
+/* I have seen local parts of more than 64 octets, in spite of the SMTP
+ * limits.  So, we'll have a more generous limit that's still guaranteed
+ * not to pop the buffer, and let the server worry about it.  As of this
+ * writing, it comes out to 240.  Anyone with a mailbox name larger than
+ * that is in serious need of a life or at least a new ISP!  23 June 1998
+ */
+
+#define MAXLOCALPART ((MAILTMPLEN - (SMTPMAXDOMAIN + SMTPMAXPATH + 32)) / 2)
+
+/* Mail Transfer Protocol manipulate driver parameters
+ * Accepts: function code
+ *	    function-dependent value
+ * Returns: function-dependent return value
+ */
+
+void *smtp_parameters (long function,void *value)
+{
+  switch ((int) function) {
+  case SET_MAXLOGINTRIALS:
+    smtp_maxlogintrials = (unsigned long) value;
+    break;
+  case GET_MAXLOGINTRIALS:
+    value = (void *) smtp_maxlogintrials;
+    break;
+  case SET_SMTPPORT:
+    smtp_port = (long) value;
+    break;
+  case GET_SMTPPORT:
+    value = (void *) smtp_port;
+    break;
+  case SET_SSLSMTPPORT:
+    smtp_sslport = (long) value;
+    break;
+  case GET_SSLSMTPPORT:
+    value = (void *) smtp_sslport;
+    break;
+  default:
+    value = NIL;		/* error case */
+    break;
+  }
+  return value;
+}
+
+/* Mail Transfer Protocol open connection
+ * Accepts: network driver
+ *	    service host list
+ *	    port number
+ *	    service name
+ *	    SMTP open options
+ * Returns: SEND stream on success, NIL on failure
+ */
+
+SENDSTREAM *smtp_open_full (NETDRIVER *dv,char **hostlist,char *service,
+			    unsigned long port,long options)
+{
+  SENDSTREAM *stream = NIL;
+  long reply;
+  char *s,tmp[MAILTMPLEN];
+  NETSTREAM *netstream;
+  NETMBX mb;
+  if (!(hostlist && *hostlist)) mm_log ("Missing SMTP service host",ERROR);
+				/* maximum domain name is 64 characters */
+  else do if (strlen (*hostlist) < SMTPMAXDOMAIN) {
+    sprintf (tmp,"{%.1000s}",*hostlist);
+    if (!mail_valid_net_parse_work (tmp,&mb,service ? service : "smtp") ||
+	mb.anoflag || mb.readonlyflag) {
+      sprintf (tmp,"Invalid host specifier: %.80s",*hostlist);
+      mm_log (tmp,ERROR);
+    }
+    else {			/* light tryssl flag if requested */
+      mb.trysslflag = (options & SOP_TRYSSL) ? T : NIL;
+				/* explicit port overrides all */
+      if (mb.port) port = mb.port;
+				/* else /submit overrides port argument */
+      else if (!compare_cstring (mb.service,"submit")) {
+	port = SUBMITTCPPORT;	/* override port, use IANA name */
+	strcpy (mb.service,"submission");
+      }
+				/* else port argument overrides SMTP port */
+      else if (!port) port = smtp_port ? smtp_port : SMTPTCPPORT;
+      if (netstream =		/* try to open ordinary connection */
+	  net_open (&mb,dv,port,
+		    (NETDRIVER *) mail_parameters (NIL,GET_SSLDRIVER,NIL),
+		    "*smtps",smtp_sslport ? smtp_sslport : SMTPSSLPORT)) {
+	stream = (SENDSTREAM *) memset (fs_get (sizeof (SENDSTREAM)),0,
+					sizeof (SENDSTREAM));
+	stream->netstream = netstream;
+	stream->host = cpystr ((long) mail_parameters (NIL,GET_TRUSTDNS,NIL) ?
+			       net_host (netstream) : mb.host);
+	stream->debug = (mb.dbgflag || (options & OP_DEBUG)) ? T : NIL;
+	if (options & SOP_SECURE) mb.secflag = T;
+				/* get name of local host to use */
+	s = compare_cstring ("localhost",mb.host) ?
+	  net_localhost (netstream) : "localhost";
+
+	do reply = smtp_reply (stream);
+	while ((reply < 100) || (stream->reply[3] == '-'));
+	if (reply != SMTPGREET){/* get SMTP greeting */
+	  sprintf (tmp,"SMTP greeting failure: %.80s",stream->reply);
+	  mm_log (tmp,ERROR);
+	  stream = smtp_close (stream);
+	}
+				/* try EHLO first, then HELO */
+	else if (((reply = smtp_ehlo (stream,s,&mb)) != SMTPOK) &&
+		 ((reply = smtp_send (stream,"HELO",s)) != SMTPOK)) {
+	  sprintf (tmp,"SMTP hello failure: %.80s",stream->reply);
+	  mm_log (tmp,ERROR);
+	  stream = smtp_close (stream);
+	}
+	else {
+	  NETDRIVER *ssld =(NETDRIVER *)mail_parameters(NIL,GET_SSLDRIVER,NIL);
+	  sslstart_t stls = (sslstart_t) mail_parameters(NIL,GET_SSLSTART,NIL);
+	  ESMTP.ok = T;		/* ESMTP server, start TLS if present */
+	  if (!dv && stls && ESMTP.service.starttls &&
+	      !mb.sslflag && !mb.notlsflag &&
+	      (smtp_send (stream,"STARTTLS",NIL) == SMTPGREET)) {
+	    mb.tlsflag = T;	/* TLS OK, get into TLS at this end */
+	    stream->netstream->dtb = ssld;
+				/* TLS started, negotiate it */
+	    if (!(stream->netstream->stream = (*stls)
+		  (stream->netstream->stream,mb.host,
+		   (mb.tlssslv23 ? NIL : NET_TLSCLIENT) |
+		   (mb.novalidate ? NET_NOVALIDATECERT:NIL)))){
+				/* TLS negotiation failed after STARTTLS */
+	      sprintf (tmp,"Unable to negotiate TLS with this server: %.80s",
+		       mb.host);
+	      mm_log (tmp,ERROR);
+				/* close without doing QUIT */
+	      if (stream->netstream) net_close (stream->netstream);
+	      stream->netstream = NIL;
+	      stream = smtp_close (stream);
+	    }
+				/* TLS OK, re-negotiate EHLO */
+	    else if ((reply = smtp_ehlo (stream,s,&mb)) != SMTPOK) {
+	      sprintf (tmp,"SMTP EHLO failure after STARTTLS: %.80s",
+		       stream->reply);
+	      mm_log (tmp,ERROR);
+	      stream = smtp_close (stream);
+	    }
+	    else ESMTP.ok = T;	/* TLS OK and EHLO successful */
+	  }
+	  else if (mb.tlsflag) {/* user specified /tls but can't do it */
+	    sprintf (tmp,"TLS unavailable with this server: %.80s",mb.host);
+	    mm_log (tmp,ERROR);
+	    stream = smtp_close (stream);
+	  }
+
+				/* remote name for authentication */
+	  if (stream && ((mb.secflag || mb.user[0]))) {
+	    if (ESMTP.auth) {	/* use authenticator? */
+	      if ((long) mail_parameters (NIL,GET_TRUSTDNS,NIL)) {
+				/* remote name for authentication */
+		strncpy (mb.host,
+			 (long) mail_parameters (NIL,GET_SASLUSESPTRNAME,NIL) ?
+			 net_remotehost (netstream) : net_host (netstream),
+			 NETMAXHOST-1);
+		mb.host[NETMAXHOST-1] = '\0';
+	      }
+	      if (!smtp_auth (stream,&mb,tmp)) stream = smtp_close (stream);
+	    }
+	    else {		/* no available authenticators? */
+	      sprintf (tmp,"%sSMTP authentication not available: %.80s",
+		       mb.secflag ? "Secure " : "",mb.host);
+	      mm_log (tmp,ERROR);
+	      stream = smtp_close (stream);
+	    }
+	  }
+	}
+      }
+    }
+  } while (!stream && *++hostlist);
+  if (stream) {			/* set stream options if have a stream */
+    if (options &(SOP_DSN | SOP_DSN_NOTIFY_FAILURE | SOP_DSN_NOTIFY_DELAY |
+		  SOP_DSN_NOTIFY_SUCCESS | SOP_DSN_RETURN_FULL)) {
+      ESMTP.dsn.want = T;
+      if (options & SOP_DSN_NOTIFY_FAILURE) ESMTP.dsn.notify.failure = T;
+      if (options & SOP_DSN_NOTIFY_DELAY) ESMTP.dsn.notify.delay = T;
+      if (options & SOP_DSN_NOTIFY_SUCCESS) ESMTP.dsn.notify.success = T;
+      if (options & SOP_DSN_RETURN_FULL) ESMTP.dsn.full = T;
+    }
+    if (options & SOP_8BITMIME) ESMTP.eightbit.want = T;
+  }
+  return stream;
+}
+
+/* SMTP authenticate
+ * Accepts: stream to login
+ *	    parsed network mailbox structure
+ *	    scratch buffer
+ *	    place to return user name
+ * Returns: T on success, NIL on failure
+ */
+
+long smtp_auth (SENDSTREAM *stream,NETMBX *mb,char *tmp)
+{
+  unsigned long trial,auths;
+  char *lsterr = NIL;
+  char usr[MAILTMPLEN];
+  AUTHENTICATOR *at;
+  long ret = NIL;
+  for (auths = ESMTP.auth, stream->saslcancel = NIL;
+       !ret && stream->netstream && auths &&
+       (at = mail_lookup_auth (find_rightmost_bit (&auths) + 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';		/* empty buffer */
+    if (stream->netstream) do {
+      if (lsterr) {
+	sprintf (tmp,"Retrying %s authentication after %.80s",at->name,lsterr);
+	mm_log (tmp,WARN);
+	fs_give ((void **) &lsterr);
+      }
+      stream->saslcancel = NIL;
+      if (smtp_send (stream,"AUTH",at->name) == SMTPAUTHREADY) {
+				/* hide client authentication responses */
+	if (!(at->flags & AU_SECURE)) stream->sensitive = T;
+	if ((*at->client) (smtp_challenge,smtp_response,"smtp",mb,stream,
+			   &trial,usr)) {
+	  if (stream->replycode == SMTPAUTHED) {
+	    ESMTP.auth = NIL;	/* disable authenticators */
+	    ret = LONGT;
+	  }
+				/* if main program requested cancellation */
+	  else if (!trial) mm_log ("SMTP Authentication cancelled",ERROR);
+	}
+	stream->sensitive = NIL;/* unhide */
+      }
+				/* remember response if error and no cancel */
+      if (!ret && trial) lsterr = cpystr (stream->reply);
+    } while (!ret && stream->netstream && trial &&
+	     (trial < smtp_maxlogintrials));
+  }
+  if (lsterr) {			/* previous authenticator failed? */
+    if (!stream->saslcancel) {	/* don't do this if a cancel */
+      sprintf (tmp,"Can not authenticate to SMTP server: %.80s",lsterr);
+      mm_log (tmp,ERROR);
+    }
+    fs_give ((void **) &lsterr);
+  }
+  return ret;			/* authentication failed */
+}
+
+/* Get challenge to authenticator in binary
+ * Accepts: stream
+ *	    pointer to returned size
+ * Returns: challenge or NIL if not challenge
+ */
+
+void *smtp_challenge (void *s,unsigned long *len)
+{
+  char tmp[MAILTMPLEN];
+  void *ret = NIL;
+  SENDSTREAM *stream = (SENDSTREAM *) s;
+  if ((stream->replycode == SMTPAUTHREADY) &&
+      !(ret = rfc822_base64 ((unsigned char *) stream->reply + 4,
+			     strlen (stream->reply + 4),len))) {
+    sprintf (tmp,"SMTP SERVER BUG (invalid challenge): %.80s",stream->reply+4);
+    mm_log (tmp,ERROR);
+  }
+  return ret;
+}
+
+
+/* Send authenticator response in BASE64
+ * Accepts: MAIL stream
+ *	    string to send
+ *	    length of string
+ * Returns: T, always
+ */
+
+long smtp_response (void *s,char *response,unsigned long size)
+{
+  SENDSTREAM *stream = (SENDSTREAM *) s;
+  unsigned long i,j;
+  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 */
+      i = smtp_send (stream,t,NIL);
+      fs_give ((void **) &t);
+    }
+    else i = smtp_send (stream,"",NIL);
+  }
+  else {			/* abort requested */
+    i = smtp_send (stream,"*",NIL);
+    stream->saslcancel = T;	/* mark protocol-requested SASL cancel */
+  }
+  return LONGT;
+}
+
+/* Mail Transfer Protocol close connection
+ * Accepts: SEND stream
+ * Returns: NIL always
+ */
+
+SENDSTREAM *smtp_close (SENDSTREAM *stream)
+{
+  if (stream) {			/* send "QUIT" */
+    if (stream->netstream) {	/* do close actions if have netstream */
+      smtp_send (stream,"QUIT",NIL);
+      if (stream->netstream)	/* could have been closed during "QUIT" */
+        net_close (stream->netstream);
+    }
+				/* clean up */
+    if (stream->host) fs_give ((void **) &stream->host);
+    if (stream->reply) fs_give ((void **) &stream->reply);
+    if (ESMTP.dsn.envid) fs_give ((void **) &ESMTP.dsn.envid);
+    if (ESMTP.atrn.domains) fs_give ((void **) &ESMTP.atrn.domains);
+    fs_give ((void **) &stream);/* flush the stream */
+  }
+  return NIL;
+}
+
+/* Mail Transfer Protocol deliver mail
+ * Accepts: SEND stream
+ *	    delivery option (MAIL, SEND, SAML, SOML)
+ *	    message envelope
+ *	    message body
+ * Returns: T on success, NIL on failure
+ */
+
+long smtp_mail (SENDSTREAM *stream,char *type,ENVELOPE *env,BODY *body)
+{
+  RFC822BUFFER buf;
+  char tmp[SENDBUFLEN+1];
+  long error = NIL;
+  long retry = NIL;
+  buf.f = smtp_soutr;		/* initialize buffer */
+  buf.s = stream->netstream;
+  buf.end = (buf.beg = buf.cur = tmp) + SENDBUFLEN;
+  tmp[SENDBUFLEN] = '\0';	/* must have additional null guard byte */
+  if (!(env->to || env->cc || env->bcc)) {
+  				/* no recipients in request */
+    smtp_seterror (stream,SMTPHARDERROR,"No recipients specified");
+    return NIL;
+  }
+  do {				/* make sure stream is in good shape */
+    smtp_send (stream,"RSET",NIL);
+    if (retry) {		/* need to retry with authentication? */
+      NETMBX mb;
+				/* yes, build remote name for authentication */
+      sprintf (tmp,"{%.200s/smtp%s}<none>",
+	       (long) mail_parameters (NIL,GET_TRUSTDNS,NIL) ?
+	       ((long) mail_parameters (NIL,GET_SASLUSESPTRNAME,NIL) ?
+		net_remotehost (stream->netstream) :
+		net_host (stream->netstream)) :
+	       stream->host,
+	       (stream->netstream->dtb ==
+		(NETDRIVER *) mail_parameters (NIL,GET_SSLDRIVER,NIL)) ?
+	       "/ssl" : "");
+      mail_valid_net_parse (tmp,&mb);
+      if (!smtp_auth (stream,&mb,tmp)) return NIL;
+      retry = NIL;		/* no retry at this point */
+    }
+
+    strcpy (tmp,"FROM:<");	/* compose "MAIL FROM:<return-path>" */
+#ifdef RFC2821
+    if (env->return_path && env->return_path->host &&
+	!((strlen (env->return_path->mailbox) > SMTPMAXLOCALPART) ||
+	  (strlen (env->return_path->host) > SMTPMAXDOMAIN))) {
+      rfc822_cat (tmp,env->return_path->mailbox,NIL);
+      sprintf (tmp + strlen (tmp),"@%s",env->return_path->host);
+    }
+#else				/* old code with A-D-L support */
+    if (env->return_path && env->return_path->host &&
+	!((env->return_path->adl &&
+	   (strlen (env->return_path->adl) > SMTPMAXPATH)) ||
+	  (strlen (env->return_path->mailbox) > SMTPMAXLOCALPART) ||
+	  (strlen (env->return_path->host) > SMTPMAXDOMAIN)))
+      rfc822_address (tmp,env->return_path);
+#endif
+    strcat (tmp,">");
+    if (ESMTP.ok) {
+      if (ESMTP.eightbit.ok && ESMTP.eightbit.want)
+	strcat (tmp," BODY=8BITMIME");
+      if (ESMTP.dsn.ok && ESMTP.dsn.want) {
+	strcat (tmp,ESMTP.dsn.full ? " RET=FULL" : " RET=HDRS");
+	if (ESMTP.dsn.envid)
+	  sprintf (tmp + strlen (tmp)," ENVID=%.100s",ESMTP.dsn.envid);
+      }
+    }
+				/* send "MAIL FROM" command */
+    switch (smtp_send (stream,type,tmp)) {
+    case SMTPUNAVAIL:		/* mailbox unavailable? */
+    case SMTPWANTAUTH:		/* wants authentication? */
+    case SMTPWANTAUTH2:
+      if (ESMTP.auth) retry = T;/* yes, retry with authentication */
+    case SMTPOK:		/* looks good */
+      break;
+    default:			/* other failure */
+      return NIL;
+    }
+				/* negotiate the recipients */
+    if (!retry && env->to) retry = smtp_rcpt (stream,env->to,&error);
+    if (!retry && env->cc) retry = smtp_rcpt (stream,env->cc,&error);
+    if (!retry && env->bcc) retry = smtp_rcpt (stream,env->bcc,&error);
+    if (!retry && error) {	/* any recipients failed? */
+      smtp_send (stream,"RSET",NIL);
+      smtp_seterror (stream,SMTPHARDERROR,"One or more recipients failed");
+      return NIL;
+    }
+  } while (retry);
+				/* negotiate data command */
+  if (!(smtp_send (stream,"DATA",NIL) == SMTPREADY)) return NIL;
+				/* send message data */
+  if (!rfc822_output_full (&buf,env,body,
+			   ESMTP.eightbit.ok && ESMTP.eightbit.want)) {
+    smtp_fake (stream,"SMTP connection broken (message data)");
+    return NIL;			/* can't do much else here */
+  }
+				/* send trailing dot */
+  return (smtp_send (stream,".",NIL) == SMTPOK) ? LONGT : NIL;
+}
+
+/* Simple Mail Transfer Protocol send VERBose
+ * Accepts: SMTP stream
+ * Returns: T if successful, else NIL
+ *
+ * Descriptive text formerly in [al]pine sources:
+ * At worst, this command may cause the SMTP connection to get nuked.  Modern
+ * sendmail's recognize it, and possibly other SMTP implementations (the "ON"
+ * arg is for PMDF).  What's more, if it works, the reply code and accompanying
+ * text may vary from server to server.
+ */
+
+long smtp_verbose (SENDSTREAM *stream)
+{
+				/* accept any 2xx reply code */
+  return ((smtp_send (stream,"VERB","ON") / (long) 100) == 2) ? LONGT : NIL;
+}
+
+/* Internal routines */
+
+
+/* Simple Mail Transfer Protocol send recipient
+ * Accepts: SMTP stream
+ *	    address list
+ *	    pointer to error flag
+ * Returns: T if should retry, else NIL
+ */
+
+long smtp_rcpt (SENDSTREAM *stream,ADDRESS *adr,long *error)
+{
+ char *s,tmp[2*MAILTMPLEN],orcpt[MAILTMPLEN];
+  while (adr) {			/* for each address on the list */
+				/* clear any former error */
+    if (adr->error) fs_give ((void **) &adr->error);
+    if (adr->host) {		/* ignore group syntax */
+				/* enforce SMTP limits to protect the buffer */
+      if (strlen (adr->mailbox) > MAXLOCALPART) {
+	adr->error = cpystr ("501 Recipient name too long");
+	*error = T;
+      }
+      else if ((strlen (adr->host) > SMTPMAXDOMAIN)) {
+	adr->error = cpystr ("501 Recipient domain too long");
+	*error = T;
+      }
+#ifndef RFC2821			/* old code with A-D-L support */
+      else if (adr->adl && (strlen (adr->adl) > SMTPMAXPATH)) {
+	adr->error = cpystr ("501 Path too long");
+	*error = T;
+      }
+#endif
+
+      else {
+	strcpy (tmp,"TO:<");	/* compose "RCPT TO:<return-path>" */
+#ifdef RFC2821
+	rfc822_cat (tmp,adr->mailbox,NIL);
+	sprintf (tmp + strlen (tmp),"@%s>",adr->host);
+#else				/* old code with A-D-L support */
+	rfc822_address (tmp,adr);
+	strcat (tmp,">");
+#endif
+				/* want notifications */
+	if (ESMTP.ok && ESMTP.dsn.ok && ESMTP.dsn.want) {
+				/* yes, start with prefix */
+	  strcat (tmp," NOTIFY=");
+	  s = tmp + strlen (tmp);
+	  if (ESMTP.dsn.notify.failure) strcat (s,"FAILURE,");
+	  if (ESMTP.dsn.notify.delay) strcat (s,"DELAY,");
+	  if (ESMTP.dsn.notify.success) strcat (s,"SUCCESS,");
+				/* tie off last comma */
+	  if (*s) s[strlen (s) - 1] = '\0';
+	  else strcat (tmp,"NEVER");
+	  if (adr->orcpt.addr) {
+	    sprintf (orcpt,"%.498s;%.498s",
+		     adr->orcpt.type ? adr->orcpt.type : "rfc822",
+		     adr->orcpt.addr);
+	    sprintf (tmp + strlen (tmp)," ORCPT=%.500s",orcpt);
+	  }
+	}
+	switch (smtp_send (stream,"RCPT",tmp)) {
+	case SMTPOK:		/* looks good */
+	  break;
+	case SMTPUNAVAIL:	/* mailbox unavailable? */
+	case SMTPWANTAUTH:	/* wants authentication? */
+	case SMTPWANTAUTH2:
+	  if (ESMTP.auth) return T;
+	default:		/* other failure */
+	  *error = T;		/* note that an error occurred */
+	  adr->error = cpystr (stream->reply);
+	}
+      }
+    }
+    adr = adr->next;		/* do any subsequent recipients */
+  }
+  return NIL;			/* no retry called for */
+}
+
+/* Simple Mail Transfer Protocol send command
+ * Accepts: SEND stream
+ *	    text
+ * Returns: reply code
+ */
+
+long smtp_send (SENDSTREAM *stream,char *command,char *args)
+{
+  long ret;
+  char *s = (char *) fs_get (strlen (command) + (args ? strlen (args) + 1 : 0)
+			     + 3);
+				/* build the complete command */
+  if (args) sprintf (s,"%s %s",command,args);
+  else strcpy (s,command);
+  if (stream->debug) mail_dlog (s,stream->sensitive);
+  strcat (s,"\015\012");
+				/* send the command */
+  if (stream->netstream && net_soutr (stream->netstream,s)) {
+    do stream->replycode = smtp_reply (stream);
+    while ((stream->replycode < 100) || (stream->reply[3] == '-'));
+    ret = stream->replycode;
+  }
+  else ret = smtp_fake (stream,"SMTP connection broken (command)");
+  fs_give ((void **) &s);
+  return ret;
+}
+
+
+/* Simple Mail Transfer Protocol get reply
+ * Accepts: SMTP stream
+ * Returns: reply code
+ */
+
+long smtp_reply (SENDSTREAM *stream)
+{
+  smtpverbose_t pv = (smtpverbose_t) mail_parameters (NIL,GET_SMTPVERBOSE,NIL);
+  long reply;
+				/* flush old reply */
+  if (stream->reply) fs_give ((void **) &stream->reply);
+  				/* get reply */
+  if (stream->netstream && (stream->reply = net_getline (stream->netstream))) {
+    if (stream->debug) mm_dlog (stream->reply);
+				/* return response code */
+    reply = atol (stream->reply);
+    if (pv && (reply < 100)) (*pv) (stream->reply);
+  }
+  else reply = smtp_fake (stream,"SMTP connection broken (reply)");
+  return reply;
+}
+
+/* Simple Mail Transfer Protocol send EHLO
+ * Accepts: SMTP stream
+ *	    host name to use in EHLO
+ *	    NETMBX structure
+ * Returns: reply code
+ */
+
+long smtp_ehlo (SENDSTREAM *stream,char *host,NETMBX *mb)
+{
+  unsigned long i,j;
+  long flags = (mb->secflag ? AU_SECURE : NIL) |
+    (mb->authuser[0] ? AU_AUTHUSER : NIL);
+  char *s,*t,*r,tmp[MAILTMPLEN];
+				/* clear ESMTP data */
+  memset (&ESMTP,0,sizeof (ESMTP));
+  if (mb->loser) return 500;	/* never do EHLO if a loser */
+  sprintf (tmp,"EHLO %s",host);	/* build the complete command */
+  if (stream->debug) mm_dlog (tmp);
+  strcat (tmp,"\015\012");
+				/* send the command */
+  if (!net_soutr (stream->netstream,tmp))
+    return smtp_fake (stream,"SMTP connection broken (EHLO)");
+				/* got an OK reply? */
+  do if ((i = smtp_reply (stream)) == SMTPOK) {
+				/* hack for AUTH= */
+    if (stream->reply[4] && stream->reply[5] && stream->reply[6] &&
+	stream->reply[7] && (stream->reply[8] == '=')) stream->reply[8] = ' ';
+				/* get option code */
+    if (!(s = strtok_r (stream->reply+4," ",&r)));
+				/* have option, does it have a value */
+    else if ((t = strtok_r (NIL," ",&r)) && *t) {
+				/* EHLO options which take arguments */
+      if (!compare_cstring (s,"SIZE")) {
+	if (isdigit (*t)) ESMTP.size.limit = strtoul (t,&t,10);
+	ESMTP.size.ok = T;
+      }
+      else if (!compare_cstring (s,"DELIVERBY")) {
+	if (isdigit (*t)) ESMTP.deliverby.minby = strtoul (t,&t,10);
+	ESMTP.deliverby.ok = T;
+      }
+      else if (!compare_cstring (s,"ATRN")) {
+	ESMTP.atrn.domains = cpystr (t);
+	ESMTP.atrn.ok = T;
+      }
+      else if (!compare_cstring (s,"AUTH"))
+	do if ((j = mail_lookup_auth_name (t,flags)) &&
+	       (--j < MAXAUTHENTICATORS)) ESMTP.auth |= (1 << j);
+	while ((t = strtok_r (NIL," ",&r)) && *t);
+    }
+				/* EHLO options which do not take arguments */
+    else if (!compare_cstring (s,"SIZE")) ESMTP.size.ok = T;
+    else if (!compare_cstring (s,"8BITMIME")) ESMTP.eightbit.ok = T;
+    else if (!compare_cstring (s,"DSN")) ESMTP.dsn.ok = T;
+    else if (!compare_cstring (s,"ATRN")) ESMTP.atrn.ok = T;
+    else if (!compare_cstring (s,"SEND")) ESMTP.service.send = T;
+    else if (!compare_cstring (s,"SOML")) ESMTP.service.soml = T;
+    else if (!compare_cstring (s,"SAML")) ESMTP.service.saml = T;
+    else if (!compare_cstring (s,"EXPN")) ESMTP.service.expn = T;
+    else if (!compare_cstring (s,"HELP")) ESMTP.service.help = T;
+    else if (!compare_cstring (s,"TURN")) ESMTP.service.turn = T;
+    else if (!compare_cstring (s,"ETRN")) ESMTP.service.etrn = T;
+    else if (!compare_cstring (s,"STARTTLS")) ESMTP.service.starttls = T;
+    else if (!compare_cstring (s,"RELAY")) ESMTP.service.relay = T;
+    else if (!compare_cstring (s,"PIPELINING")) ESMTP.service.pipe = T;
+    else if (!compare_cstring (s,"ENHANCEDSTATUSCODES"))
+      ESMTP.service.ensc = T;
+    else if (!compare_cstring (s,"BINARYMIME")) ESMTP.service.bmime = T;
+    else if (!compare_cstring (s,"CHUNKING")) ESMTP.service.chunk = T;
+  }
+  while ((i < 100) || (stream->reply[3] == '-'));
+				/* disable LOGIN if PLAIN also advertised */
+  if ((j = mail_lookup_auth_name ("PLAIN",NIL)) && (--j < MAXAUTHENTICATORS) &&
+      (ESMTP.auth & (1 << j)) &&
+      (j = mail_lookup_auth_name ("LOGIN",NIL)) && (--j < MAXAUTHENTICATORS))
+    ESMTP.auth &= ~(1 << j);
+  return i;			/* return the response code */
+}
+
+/* Simple Mail Transfer Protocol set fake error and abort
+ * Accepts: SMTP stream
+ *	    error text
+ * Returns: SMTPSOFTFATAL, always
+ */
+
+long smtp_fake (SENDSTREAM *stream,char *text)
+{
+  if (stream->netstream) {	/* close net connection if still open */
+    net_close (stream->netstream);
+    stream->netstream = NIL;
+  }
+				/* set last error */
+  return smtp_seterror (stream,SMTPSOFTFATAL,text);
+}
+
+
+/* Simple Mail Transfer Protocol set error
+ * Accepts: SMTP stream
+ *	    SMTP error code
+ *	    error text
+ * Returns: error code
+ */
+
+static long smtp_seterror (SENDSTREAM *stream,long code,char *text)
+{
+				/* flush any old reply */
+  if (stream->reply ) fs_give ((void **) &stream->reply);
+  				/* set up pseudo-reply string */
+  stream->reply = (char *) fs_get (20+strlen (text));
+  sprintf (stream->reply,"%ld %s",code,text);
+  return code;			/* return error code */
+}
+
+
+/* Simple Mail Transfer Protocol filter mail
+ * Accepts: stream
+ *	    string
+ * Returns: T on success, NIL on failure
+ */
+
+long smtp_soutr (void *stream,char *s)
+{
+  char c,*t;
+				/* "." on first line */
+  if (s[0] == '.') net_sout (stream,".",1);
+				/* find lines beginning with a "." */
+  while (t = strstr (s,"\015\012.")) {
+    c = *(t += 3);		/* remember next character after "." */
+    *t = '\0';			/* tie off string */
+				/* output prefix */
+    if (!net_sout (stream,s,t-s)) return NIL;
+    *t = c;			/* restore delimiter */
+    s = t - 1;			/* push pointer up to the "." */
+  }
+				/* output remainder of text */
+  return *s ? net_soutr (stream,s) : T;
+}
diff --git a/imap/src/c-client/smtp.h b/imap/src/c-client/smtp.h
new file mode 100644
index 00000000..4be82db4
--- /dev/null
+++ b/imap/src/c-client/smtp.h
@@ -0,0 +1,76 @@
+/* ========================================================================
+ * Copyright 1988-2007 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:	Simple Mail Transfer Protocol (SMTP) routines
+ *
+ * Author:	Mark Crispin
+ *		Networks and Distributed Computing
+ *		Computing & Communications
+ *		University of Washington
+ *		Administration Building, AG-44
+ *		Seattle, WA  98195
+ *		Internet: MRC@CAC.Washington.EDU
+ *
+ * Date:	27 July 1988
+ * Last Edited:	15 August 2007
+ *
+ * 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 NationalInstitutes of Health
+ * under grant number RR-00785.
+ */
+
+/* Constants (should be in smtp.c) */
+
+#define SMTPTCPPORT (long) 25	/* assigned TCP contact port */
+#define SUBMITTCPPORT (long) 587/* assigned TCP contact port */
+
+
+/* SMTP open options
+ * For compatibility with the past, SOP_DEBUG must always be 1.
+ */
+
+#define SOP_DEBUG (long) 1	/* debug protocol negotiations */
+#define SOP_DSN (long) 2	/* DSN requested */
+				/* DSN notification, none set mean NEVER */
+#define SOP_DSN_NOTIFY_FAILURE (long) 4
+#define SOP_DSN_NOTIFY_DELAY (long) 8
+#define SOP_DSN_NOTIFY_SUCCESS (long) 16
+				/* DSN return full msg vs. header */
+
+#define SOP_DSN_RETURN_FULL (long) 32
+#define SOP_8BITMIME (long) 64	/* 8-bit MIME requested */
+#define SOP_SECURE (long) 256	/* don't do non-secure authentication */
+#define SOP_TRYSSL (long) 512	/* try SSL first */
+#define SOP_TRYALT SOP_TRYSSL	/* old name */
+				/* reserved for application use */
+#define SOP_RESERVED (unsigned long) 0xff000000
+
+
+/* Compatibility support names */
+
+#define smtp_open(hostlist,options) \
+  smtp_open_full (NIL,hostlist,"smtp",NIL,options)
+
+
+/* Function prototypes */
+
+void *smtp_parameters (long function,void *value);
+SENDSTREAM *smtp_open_full (NETDRIVER *dv,char **hostlist,char *service,
+			    unsigned long port,long options);
+SENDSTREAM *smtp_close (SENDSTREAM *stream);
+long smtp_mail (SENDSTREAM *stream,char *type,ENVELOPE *msg,BODY *body);
+long smtp_verbose (SENDSTREAM *stream);
diff --git a/imap/src/c-client/sslio.h b/imap/src/c-client/sslio.h
new file mode 100644
index 00000000..8063f3fc
--- /dev/null
+++ b/imap/src/c-client/sslio.h
@@ -0,0 +1,70 @@
+/* ========================================================================
+ * Copyright 1988-2006 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:	SSL routines
+ *
+ * Author:	Mark Crispin
+ *		Networks and Distributed Computing
+ *		Computing & Communications
+ *		University of Washington
+ *		Administration Building, AG-44
+ *		Seattle, WA  98195
+ *		Internet: MRC@CAC.Washington.EDU
+ *
+ * Date:	7 February 2001
+ * Last Edited:	30 August 2006
+ */
+
+/* SSL driver */
+
+struct ssl_driver {		/* must parallel NETDRIVER in mail.h */
+  SSLSTREAM *(*open) (char *host,char *service,unsigned long port);
+  SSLSTREAM *(*aopen) (NETMBX *mb,char *service,char *usrbuf);
+  char *(*getline) (SSLSTREAM *stream);
+  long (*getbuffer) (SSLSTREAM *stream,unsigned long size,char *buffer);
+  long (*soutr) (SSLSTREAM *stream,char *string);
+  long (*sout) (SSLSTREAM *stream,char *string,unsigned long size);
+  void (*close) (SSLSTREAM *stream);
+  char *(*host) (SSLSTREAM *stream);
+  char *(*remotehost) (SSLSTREAM *stream);
+  unsigned long (*port) (SSLSTREAM *stream);
+  char *(*localhost) (SSLSTREAM *stream);
+};
+
+
+/* SSL stdio stream */
+
+typedef struct ssl_stdiostream {
+  SSLSTREAM *sslstream;		/* SSL stream */
+  int octr;			/* output counter */
+  char *optr;			/* output pointer */
+  char obuf[SSLBUFLEN];		/* output buffer */
+} SSLSTDIOSTREAM;
+
+
+/* Function prototypes */
+
+SSLSTREAM *ssl_open (char *host,char *service,unsigned long port);
+SSLSTREAM *ssl_aopen (NETMBX *mb,char *service,char *usrbuf);
+char *ssl_getline (SSLSTREAM *stream);
+long ssl_getbuffer (SSLSTREAM *stream,unsigned long size,char *buffer);
+long ssl_getdata (SSLSTREAM *stream);
+long ssl_soutr (SSLSTREAM *stream,char *string);
+long ssl_sout (SSLSTREAM *stream,char *string,unsigned long size);
+void ssl_close (SSLSTREAM *stream);
+char *ssl_host (SSLSTREAM *stream);
+char *ssl_remotehost (SSLSTREAM *stream);
+unsigned long ssl_port (SSLSTREAM *stream);
+char *ssl_localhost (SSLSTREAM *stream);
+long ssl_server_input_wait (long seconds);
diff --git a/imap/src/c-client/tcp.h b/imap/src/c-client/tcp.h
new file mode 100644
index 00000000..b9f095a8
--- /dev/null
+++ b/imap/src/c-client/tcp.h
@@ -0,0 +1,59 @@
+/* ========================================================================
+ * Copyright 1988-2007 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:	TCP/IP routines
+ *
+ * Author:	Mark Crispin
+ *		Networks and Distributed Computing
+ *		Computing & Communications
+ *		University of Washington
+ *		Administration Building, AG-44
+ *		Seattle, WA  98195
+ *		Internet: MRC@CAC.Washington.EDU
+ *
+ * Date:	1 August 1988
+ * Last Edited:	31 January 2007
+ */
+
+
+/* Dummy definition overridden by TCP routines */
+
+#ifndef TCPSTREAM
+#define TCPSTREAM void
+#endif
+
+
+/* Function prototypes */
+
+void *tcp_parameters (long function,void *value);
+TCPSTREAM *tcp_open (char *host,char *service,unsigned long port);
+TCPSTREAM *tcp_aopen (NETMBX *mb,char *service,char *usrbuf);
+char *tcp_getline (TCPSTREAM *stream);
+long tcp_getbuffer (TCPSTREAM *stream,unsigned long size,char *buffer);
+long tcp_getdata (TCPSTREAM *stream);
+long tcp_soutr (TCPSTREAM *stream,char *string);
+long tcp_sout (TCPSTREAM *stream,char *string,unsigned long size);
+void tcp_close (TCPSTREAM *stream);
+char *tcp_host (TCPSTREAM *stream);
+char *tcp_remotehost (TCPSTREAM *stream);
+unsigned long tcp_port (TCPSTREAM *stream);
+char *tcp_localhost (TCPSTREAM *stream);
+char *tcp_clientaddr (void);
+char *tcp_clienthost (void);
+long tcp_clientport (void);
+char *tcp_serveraddr (void);
+char *tcp_serverhost (void);
+long tcp_serverport (void);
+char *tcp_canonical (char *name);
+long tcp_isclienthost (char *host);
diff --git a/imap/src/c-client/utf8.c b/imap/src/c-client/utf8.c
new file mode 100644
index 00000000..8fda7ffd
--- /dev/null
+++ b/imap/src/c-client/utf8.c
@@ -0,0 +1,2554 @@
+/* ========================================================================
+ * 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:	UTF-8 routines
+ *
+ * Author:	Mark Crispin
+ *		Networks and Distributed Computing
+ *		Computing & Communications
+ *		University of Washington
+ *		Administration Building, AG-44
+ *		Seattle, WA  98195
+ *		Internet: MRC@CAC.Washington.EDU
+ *
+ * Date:	11 June 1997
+ * Last Edited:	17 January 2008
+ */
+
+
+#include <stdio.h>
+#include <ctype.h>
+#include "c-client.h"
+
+/*	*** IMPORTANT ***
+ *
+ *  There is a very important difference between "character set" and "charset",
+ * and the comments in this file reflect these differences.  A "character set"
+ * (also known as "coded character set") is a mapping between codepoints and
+ * characters.  A "charset" is as defined in MIME, and incorporates one or more
+ * coded character sets in a character encoding scheme.  See RFC 2130 for more
+ * details.
+ */
+
+
+/* Character set conversion tables */
+
+#include "iso_8859.c"		/* 8-bit single-byte coded graphic */
+#include "koi8_r.c"		/* Cyrillic - Russia */
+#include "koi8_u.c"		/* Cyrillic - Ukraine */
+#include "tis_620.c"		/* Thai */
+#include "viscii.c"		/* Vietnamese */
+#include "windows.c"		/* Windows */
+#include "ibm.c"		/* IBM */
+#include "gb_2312.c"		/* Chinese (PRC) - simplified */
+#include "gb_12345.c"		/* Chinese (PRC) - traditional */
+#include "jis_0208.c"		/* Japanese - basic */
+#include "jis_0212.c"		/* Japanese - supplementary */
+#include "ksc_5601.c"		/* Korean */
+#include "big5.c"		/* Taiwanese (ROC) - industrial standard */
+#include "cns11643.c"		/* Taiwanese (ROC) - national standard */
+
+
+#include "widths.c"		/* Unicode character widths */
+#include "tmap.c"		/* Unicode titlecase mapping */
+#include "decomtab.c"		/* Unicode decomposions */
+
+/* EUC parameters */
+
+#ifdef GBTOUNICODE		/* PRC simplified Chinese */
+static const struct utf8_eucparam gb_param = {
+  BASE_GB2312_KU,BASE_GB2312_TEN,MAX_GB2312_KU,MAX_GB2312_TEN,
+  (void *) gb2312tab};
+#endif
+
+
+#ifdef GB12345TOUNICODE		/* PRC traditional Chinese */
+static const struct utf8_eucparam gbt_param = {
+  BASE_GB12345_KU,BASE_GB12345_TEN,MAX_GB12345_KU,MAX_GB12345_TEN,
+  (void *) gb12345tab};
+#endif
+
+
+#ifdef BIG5TOUNICODE		/* ROC traditional Chinese */
+static const struct utf8_eucparam big5_param[] = {
+  {BASE_BIG5_KU,BASE_BIG5_TEN_0,MAX_BIG5_KU,MAX_BIG5_TEN_0,(void *) big5tab},
+  {BASE_BIG5_KU,BASE_BIG5_TEN_1,MAX_BIG5_KU,MAX_BIG5_TEN_1,NIL}
+};
+#endif
+
+
+#ifdef JISTOUNICODE		/* Japanese */
+static const struct utf8_eucparam jis_param[] = {
+  {BASE_JIS0208_KU,BASE_JIS0208_TEN,MAX_JIS0208_KU,MAX_JIS0208_TEN,
+     (void *) jis0208tab},
+  {MIN_KANA_8,0,MAX_KANA_8,0,(void *) KANA_8},
+#ifdef JIS0212TOUNICODE		/* Japanese extended */
+  {BASE_JIS0212_KU,BASE_JIS0212_TEN,MAX_JIS0212_KU,MAX_JIS0212_TEN,
+     (void *) jis0212tab}
+#else
+  {0,0,0,0,NIL}
+#endif
+};
+#endif
+
+
+#ifdef KSCTOUNICODE		/* Korean */
+static const struct utf8_eucparam ksc_param = {
+  BASE_KSC5601_KU,BASE_KSC5601_TEN,MAX_KSC5601_KU,MAX_KSC5601_TEN,
+  (void *) ksc5601tab};
+#endif
+
+/* List of supported charsets */
+
+static const CHARSET utf8_csvalid[] = {
+  {"US-ASCII",CT_ASCII,CF_PRIMARY | CF_DISPLAY | CF_POSTING,
+   NIL,NIL,NIL},
+  {"UTF-8",CT_UTF8,CF_PRIMARY | CF_DISPLAY | CF_POSTING,
+   NIL,SC_UNICODE,NIL},
+  {"UTF-7",CT_UTF7,CF_PRIMARY | CF_POSTING | CF_UNSUPRT,
+   NIL,SC_UNICODE,"UTF-8"},
+  {"ISO-8859-1",CT_1BYTE0,CF_PRIMARY | CF_DISPLAY | CF_POSTING,
+   NIL,SC_LATIN_1,NIL},
+  {"ISO-8859-2",CT_1BYTE,CF_PRIMARY | CF_DISPLAY | CF_POSTING,
+   (void *) iso8859_2tab,SC_LATIN_2,NIL},
+  {"ISO-8859-3",CT_1BYTE,CF_PRIMARY | CF_DISPLAY | CF_POSTING,
+   (void *) iso8859_3tab,SC_LATIN_3,NIL},
+  {"ISO-8859-4",CT_1BYTE,CF_PRIMARY | CF_DISPLAY | CF_POSTING,
+   (void *) iso8859_4tab,SC_LATIN_4,NIL},
+  {"ISO-8859-5",CT_1BYTE,CF_PRIMARY | CF_DISPLAY | CF_POSTING,
+   (void *) iso8859_5tab,SC_CYRILLIC,"KOI8-R"},
+  {"ISO-8859-6",CT_1BYTE,CF_PRIMARY | CF_DISPLAY | CF_POSTING,
+   (void *) iso8859_6tab,SC_ARABIC,NIL},
+  {"ISO-8859-7",CT_1BYTE,CF_PRIMARY | CF_DISPLAY | CF_POSTING,
+   (void *) iso8859_7tab,SC_GREEK,NIL},
+  {"ISO-8859-8",CT_1BYTE,CF_PRIMARY | CF_DISPLAY | CF_POSTING,
+   (void *) iso8859_8tab,SC_HEBREW,NIL},
+  {"ISO-8859-9",CT_1BYTE,CF_PRIMARY | CF_DISPLAY | CF_POSTING,
+   (void *) iso8859_9tab,SC_LATIN_5,NIL},
+  {"ISO-8859-10",CT_1BYTE,CF_PRIMARY | CF_DISPLAY | CF_POSTING,
+   (void *) iso8859_10tab,SC_LATIN_6,NIL},
+  {"ISO-8859-11",CT_1BYTE,CF_PRIMARY | CF_DISPLAY | CF_POSTING,
+   (void *) iso8859_11tab,SC_THAI,NIL},
+#if 0				/* ISO 8859-12 reserved for ISCII(?) */
+  {"ISO-8859-12",CT_1BYTE,CF_PRIMARY | CF_DISPLAY | CF_POSTING,
+   (void *) iso8859_12tab,NIL,NIL},
+#endif
+  {"ISO-8859-13",CT_1BYTE,CF_PRIMARY | CF_DISPLAY | CF_POSTING,
+   (void *) iso8859_13tab,SC_LATIN_7,NIL},
+  {"ISO-8859-14",CT_1BYTE,CF_PRIMARY | CF_DISPLAY | CF_POSTING,
+   (void *) iso8859_14tab,SC_LATIN_8,NIL},
+  {"ISO-8859-15",CT_1BYTE,CF_PRIMARY | CF_DISPLAY | CF_POSTING,
+   (void *) iso8859_15tab,SC_LATIN_9,NIL},
+  {"ISO-8859-16",CT_1BYTE,CF_PRIMARY | CF_DISPLAY | CF_POSTING,
+   (void *) iso8859_16tab,SC_LATIN_10,NIL},
+  {"KOI8-R",CT_1BYTE,CF_PRIMARY | CF_DISPLAY | CF_POSTING,
+   (void *) koi8rtab,SC_CYRILLIC,NIL},
+  {"KOI8-U",CT_1BYTE,CF_PRIMARY | CF_DISPLAY | CF_POSTING,
+   (void *) koi8utab,SC_CYRILLIC | SC_UKRANIAN,NIL},
+  {"KOI8-RU",CT_1BYTE,CF_DISPLAY,
+   (void *) koi8utab,SC_CYRILLIC | SC_UKRANIAN,"KOI8-U"},
+  {"TIS-620",CT_1BYTE,CF_PRIMARY | CF_DISPLAY | CF_POSTING,
+   (void *) tis620tab,SC_THAI,"ISO-8859-11"},
+  {"VISCII",CT_1BYTE8,CF_PRIMARY | CF_DISPLAY | CF_POSTING,
+   (void *) visciitab,SC_VIETNAMESE,NIL},
+
+#ifdef GBTOUNICODE
+  {"GBK",CT_DBYTE,CF_PRIMARY | CF_DISPLAY | CF_POSTING,
+     (void *) &gb_param,SC_CHINESE_SIMPLIFIED,NIL},
+  {"GB2312",CT_DBYTE,CF_PRIMARY | CF_DISPLAY | CF_POSTING,
+   (void *) &gb_param,SC_CHINESE_SIMPLIFIED,"GBK"},
+  {"CN-GB",CT_DBYTE,CF_DISPLAY,
+     (void *) &gb_param,SC_CHINESE_SIMPLIFIED,"GBK"},
+#ifdef CNS1TOUNICODE
+  {"ISO-2022-CN",CT_2022,CF_PRIMARY | CF_UNSUPRT,
+     NIL,SC_CHINESE_SIMPLIFIED | SC_CHINESE_TRADITIONAL,
+   NIL},
+#endif
+#endif
+#ifdef GB12345TOUNICODE
+  {"CN-GB-12345",CT_DBYTE,CF_PRIMARY | CF_DISPLAY,
+     (void *) &gbt_param,SC_CHINESE_TRADITIONAL,"BIG5"},
+#endif
+#ifdef BIG5TOUNICODE
+  {"BIG5",CT_DBYTE2,CF_PRIMARY | CF_DISPLAY | CF_POSTING,
+     (void *) big5_param,SC_CHINESE_TRADITIONAL,NIL},
+  {"CN-BIG5",CT_DBYTE2,CF_DISPLAY,
+     (void *) big5_param,SC_CHINESE_TRADITIONAL,"BIG5"},
+  {"BIG-5",CT_DBYTE2,CF_DISPLAY,
+     (void *) big5_param,SC_CHINESE_TRADITIONAL,"BIG5"},
+#endif
+#ifdef JISTOUNICODE
+  {"ISO-2022-JP",CT_2022,CF_PRIMARY | CF_DISPLAY | CF_POSTING,
+     NIL,SC_JAPANESE,NIL},
+  {"EUC-JP",CT_EUC,CF_PRIMARY | CF_DISPLAY,
+     (void *) jis_param,SC_JAPANESE,"ISO-2022-JP"},
+  {"SHIFT_JIS",CT_SJIS,CF_PRIMARY | CF_DISPLAY,
+     NIL,SC_JAPANESE,"ISO-2022-JP"},
+  {"SHIFT-JIS",CT_SJIS,CF_PRIMARY | CF_DISPLAY,
+     NIL,SC_JAPANESE,"ISO-2022-JP"},
+#ifdef JIS0212TOUNICODE
+  {"ISO-2022-JP-1",CT_2022,CF_UNSUPRT,
+     NIL,SC_JAPANESE,"ISO-2022-JP"},
+#ifdef GBTOUNICODE
+#ifdef KSCTOUNICODE
+  {"ISO-2022-JP-2",CT_2022,CF_UNSUPRT,
+     NIL,
+     SC_LATIN_1 | SC_LATIN_2 | SC_LATIN_3 | SC_LATIN_4 | SC_LATIN_5 |
+       SC_LATIN_6 | SC_LATIN_7 | SC_LATIN_8 | SC_LATIN_9 | SC_LATIN_10 |
+	 SC_ARABIC | SC_CYRILLIC | SC_GREEK | SC_HEBREW | SC_THAI |
+	   SC_VIETNAMESE | SC_CHINESE_SIMPLIFIED | SC_JAPANESE | SC_KOREAN
+#ifdef CNS1TOUNICODE
+	     | SC_CHINESE_TRADITIONAL
+#endif
+	       ,"UTF-8"},
+#endif
+#endif
+#endif
+#endif
+
+#ifdef KSCTOUNICODE
+  {"ISO-2022-KR",CT_2022,CF_PRIMARY | CF_DISPLAY | CF_UNSUPRT,
+     NIL,SC_KOREAN,"EUC-KR"},
+  {"EUC-KR",CT_DBYTE,CF_PRIMARY | CF_DISPLAY | CF_POSTING,
+     (void *) &ksc_param,SC_KOREAN,NIL},
+  {"KSC5601",CT_DBYTE,CF_PRIMARY | CF_DISPLAY,
+     (void *) &ksc_param,SC_KOREAN,"EUC-KR"},
+  {"KSC_5601",CT_DBYTE,CF_PRIMARY | CF_DISPLAY,
+     (void *) &ksc_param,SC_KOREAN,"EUC-KR"},
+  {"KS_C_5601-1987",CT_DBYTE,CF_DISPLAY,
+     (void *) &ksc_param,SC_KOREAN,"EUC-KR"},
+  {"KS_C_5601-1989",CT_DBYTE,CF_DISPLAY,
+     (void *) &ksc_param,SC_KOREAN,"EUC-KR"},
+  {"KS_C_5601-1992",CT_DBYTE,CF_DISPLAY,
+     (void *) &ksc_param,SC_KOREAN,"EUC-KR"},
+  {"KS_C_5601-1997",CT_DBYTE,CF_DISPLAY,
+     (void *) &ksc_param,SC_KOREAN,"EUC-KR"},
+#endif
+
+				/* deep sigh */
+  {"WINDOWS-874",CT_1BYTE,CF_PRIMARY | CF_DISPLAY,
+     (void *) windows_874tab,SC_THAI,"ISO-8859-11"},
+  {"CP874",CT_1BYTE,CF_DISPLAY,
+     (void *) windows_874tab,SC_THAI,"ISO-8859-11"},
+#ifdef GBTOUNICODE
+  {"WINDOWS-936",CT_DBYTE,CF_PRIMARY | CF_DISPLAY,
+     (void *) &gb_param,SC_CHINESE_SIMPLIFIED,"GBK"},
+  {"CP936",CT_DBYTE,CF_DISPLAY,
+     (void *) &gb_param,SC_CHINESE_SIMPLIFIED,"GBK"},
+#endif
+#ifdef KSCTOUNICODE
+  {"WINDOWS-949",CT_DBYTE,CF_PRIMARY | CF_DISPLAY,
+     (void *) &ksc_param,SC_KOREAN,"EUC-KR"},
+  {"CP949",CT_DBYTE,CF_DISPLAY,
+     (void *) &ksc_param,SC_KOREAN,"EUC-KR"},
+  {"X-WINDOWS-949",CT_DBYTE,CF_PRIMARY | CF_DISPLAY,
+     (void *) &ksc_param,SC_KOREAN,"EUC-KR"},
+#endif
+  {"WINDOWS-1250",CT_1BYTE,CF_PRIMARY | CF_DISPLAY,
+     (void *) windows_1250tab,SC_LATIN_2,"ISO-8859-2"},
+  {"CP1250",CT_1BYTE,CF_DISPLAY,
+     (void *) windows_1250tab,SC_LATIN_2,"ISO-8859-2"},
+  {"WINDOWS-1251",CT_1BYTE,CF_PRIMARY | CF_DISPLAY | CF_POSTING,
+     (void *) windows_1251tab,SC_CYRILLIC,"KOI8-R"},
+  {"CP1251",CT_1BYTE,CF_DISPLAY,
+     (void *) windows_1251tab,SC_CYRILLIC,"KOI8-R"},
+  {"WINDOWS-1252",CT_1BYTE,CF_PRIMARY | CF_DISPLAY,
+     (void *) windows_1252tab,SC_LATIN_1,"ISO-8859-1"},
+  {"CP1252",CT_1BYTE,CF_DISPLAY,
+     (void *) windows_1252tab,SC_LATIN_1,"ISO-8859-1"},
+  {"WINDOWS-1253",CT_1BYTE,CF_PRIMARY | CF_DISPLAY,
+     (void *) windows_1253tab,SC_GREEK,"ISO-8859-7"},
+  {"CP1253",CT_1BYTE,CF_DISPLAY,
+     (void *) windows_1253tab,SC_GREEK,"ISO-8859-7"},
+  {"WINDOWS-1254",CT_1BYTE,CF_PRIMARY | CF_DISPLAY,
+     (void *) windows_1254tab,SC_LATIN_5,"ISO-8859-9"},
+  {"CP1254",CT_1BYTE,CF_DISPLAY,
+     (void *) windows_1254tab,SC_LATIN_5,"ISO-8859-9"},
+  {"WINDOWS-1255",CT_1BYTE,CF_PRIMARY | CF_DISPLAY,
+     (void *) windows_1255tab,SC_HEBREW,"ISO-8859-8"},
+  {"CP1255",CT_1BYTE,CF_DISPLAY,
+     (void *) windows_1255tab,SC_HEBREW,"ISO-8859-8"},
+  {"WINDOWS-1256",CT_1BYTE,CF_PRIMARY | CF_DISPLAY,
+     (void *) windows_1256tab,SC_ARABIC,"ISO-8859-6"},
+  {"CP1256",CT_1BYTE,CF_DISPLAY,
+     (void *) windows_1256tab,SC_ARABIC,"ISO-8859-6"},
+  {"WINDOWS-1257",CT_1BYTE,CF_PRIMARY | CF_DISPLAY,
+     (void *) windows_1257tab,SC_LATIN_7,"ISO-8859-13"},
+  {"CP1257",CT_1BYTE,CF_DISPLAY,
+     (void *) windows_1257tab,SC_LATIN_7,"ISO-8859-13"},
+  {"WINDOWS-1258",CT_1BYTE,CF_PRIMARY | CF_DISPLAY,
+     (void *) windows_1258tab,SC_VIETNAMESE,"VISCII"},
+  {"CP1258",CT_1BYTE,CF_DISPLAY,
+     (void *) windows_1258tab,SC_VIETNAMESE,"VISCII"},
+
+				/* deeper sigh */
+  {"IBM367",CT_ASCII,CF_PRIMARY | CF_DISPLAY,
+     NIL,NIL,"US-ASCII"},
+  {"IBM437",CT_1BYTE,CF_PRIMARY | CF_DISPLAY,
+     (void *) ibm_437tab,SC_LATIN_1,"ISO-8859-1"},
+  {"IBM737",CT_1BYTE,CF_PRIMARY | CF_DISPLAY,
+     (void *) ibm_737tab,SC_GREEK,"ISO-8859-7"},
+  {"IBM775",CT_1BYTE,CF_PRIMARY | CF_DISPLAY,
+     (void *) ibm_775tab,SC_LATIN_7,"ISO-8859-13"},
+  {"IBM850",CT_1BYTE,CF_PRIMARY | CF_DISPLAY,
+     (void *) ibm_850tab,SC_LATIN_1,"ISO-8859-1"},
+  {"IBM852",CT_1BYTE,CF_PRIMARY | CF_DISPLAY,
+     (void *) ibm_852tab,SC_LATIN_2,"ISO-8859-2"},
+  {"IBM855",CT_1BYTE,CF_PRIMARY | CF_DISPLAY,
+     (void *) ibm_855tab,SC_CYRILLIC,"ISO-8859-5"},
+  {"IBM857",CT_1BYTE,CF_PRIMARY | CF_DISPLAY,
+     (void *) ibm_857tab,SC_LATIN_5,"ISO-8859-9"},
+  {"IBM860",CT_1BYTE,CF_PRIMARY | CF_DISPLAY,
+     (void *) ibm_860tab,SC_LATIN_1,"ISO-8859-1"},
+  {"IBM861",CT_1BYTE,CF_PRIMARY | CF_DISPLAY,
+     (void *) ibm_861tab,SC_LATIN_6,"ISO-8859-10"},
+  {"IBM862",CT_1BYTE,CF_PRIMARY | CF_DISPLAY,
+     (void *) ibm_862tab,SC_HEBREW,"ISO-8859-8"},
+  {"IBM863",CT_1BYTE,CF_PRIMARY | CF_DISPLAY,
+     (void *) ibm_863tab,SC_LATIN_1,"ISO-8859-1"},
+  {"IBM864",CT_1BYTE,CF_PRIMARY | CF_DISPLAY,
+     (void *) ibm_864tab,SC_ARABIC,"ISO-8859-6"},
+  {"IBM865",CT_1BYTE,CF_PRIMARY | CF_DISPLAY,
+     (void *) ibm_865tab,SC_LATIN_6,"ISO-8859-10"},
+  {"IBM866",CT_1BYTE,CF_PRIMARY | CF_DISPLAY,
+     (void *) ibm_866tab,SC_CYRILLIC,"KOI8-R"},
+  {"IBM869",CT_1BYTE,CF_PRIMARY | CF_DISPLAY,
+     (void *) ibm_869tab,SC_GREEK,"ISO-8859-7"},
+  {"IBM874",CT_1BYTE,CF_PRIMARY | CF_DISPLAY,
+     (void *) ibm_874tab,SC_THAI,"ISO-8859-11"},
+				/* deepest sigh */
+  {"ANSI_X3.4-1968",CT_ASCII,CF_DISPLAY,
+     NIL,NIL,"US-ASCII"},
+  {"UNICODE-1-1-UTF-7",CT_UTF7,CF_UNSUPRT,
+     NIL,SC_UNICODE,"UTF-8"},
+				/* these should never appear in email */
+  {"UCS-2",CT_UCS2,CF_PRIMARY | CF_DISPLAY | CF_NOEMAIL,
+     NIL,SC_UNICODE,"UTF-8"},
+  {"UCS-4",CT_UCS4,CF_PRIMARY | CF_DISPLAY | CF_NOEMAIL,
+     NIL,SC_UNICODE,"UTF-8"},
+  {"UTF-16",CT_UTF16,CF_PRIMARY | CF_DISPLAY | CF_NOEMAIL,
+     NIL,SC_UNICODE,"UTF-8"},
+  NIL
+};
+
+/* Non-Unicode Script table */
+
+static const SCRIPT utf8_scvalid[] = {
+  {"Arabic",NIL,SC_ARABIC},
+  {"Chinese Simplified","China, Singapore",SC_CHINESE_SIMPLIFIED},
+  {"Chinese Traditional","Taiwan, Hong Kong, Macao",SC_CHINESE_TRADITIONAL},
+  {"Cyrillic",NIL,SC_CYRILLIC},
+  {"Cyrillic Ukranian",NIL,SC_UKRANIAN},
+  {"Greek",NIL,SC_GREEK},
+  {"Hebrew",NIL,SC_HEBREW},
+  {"Japanese",NIL,SC_JAPANESE},
+  {"Korean",NIL,SC_KOREAN},
+  {"Latin-1","Western Europe",SC_LATIN_1},
+  {"Latin-2","Eastern Europe",SC_LATIN_2},
+  {"Latin-3","Southern Europe",SC_LATIN_3},
+  {"Latin-4","Northern Europe",SC_LATIN_4},
+  {"Latin-5","Turkish",SC_LATIN_5},
+  {"Latin-6","Nordic",SC_LATIN_6},
+  {"Latin-7","Baltic",SC_LATIN_7},
+  {"Latin-8","Celtic",SC_LATIN_8},
+  {"Latin-9","Euro",SC_LATIN_9},
+  {"Latin-10","Balkan",SC_LATIN_10},
+  {"Thai",NIL,SC_THAI},
+  {"Vietnamese",NIL,SC_VIETNAMESE},
+  NIL
+};
+
+/* Look up script name or return entire table
+ * Accepts: script name or NIL
+ * Returns: pointer to script table entry or NIL if unknown
+ */
+
+SCRIPT *utf8_script (char *script)
+{
+  unsigned long i;
+  if (!script) return (SCRIPT *) &utf8_scvalid[0];
+  else if (*script && (strlen (script) < 128))
+    for (i = 0; utf8_scvalid[i].name; i++)
+      if (!compare_cstring (script,utf8_scvalid[i].name))
+	return (SCRIPT *) &utf8_scvalid[i];
+  return NIL;			/* failed */
+}
+
+
+/* Look up charset name or return entire table
+ * Accepts: charset name or NIL
+ * Returns: charset table entry or NIL if unknown
+ */
+
+const CHARSET *utf8_charset (char *charset)
+{
+  unsigned long i;
+  if (!charset) return (CHARSET *) &utf8_csvalid[0];
+  else if (*charset && (strlen (charset) < 128))
+    for (i = 0; utf8_csvalid[i].name; i++)
+      if (!compare_cstring (charset,utf8_csvalid[i].name))
+	return (CHARSET *) &utf8_csvalid[i];
+  return NIL;			/* failed */
+}
+
+/* Validate charset and generate error message if invalid
+ * Accepts: bad character set
+ * Returns: NIL if good charset, else error message string
+ */
+
+#define BADCSS "[BADCHARSET ("
+#define BADCSE ")] Unknown charset: "
+
+char *utf8_badcharset (char *charset)
+{
+  char *msg = NIL;
+  if (!utf8_charset (charset)) {
+    char *s,*t;
+    unsigned long i,j;
+				/* calculate size of header, trailer, and bad
+				 * charset plus charset names */
+    for (i = 0, j = sizeof (BADCSS) + sizeof (BADCSE) + strlen (charset) - 2;
+	 utf8_csvalid[i].name; i++)
+      j += strlen (utf8_csvalid[i].name) + 1;
+				/* not built right */
+    if (!i) fatal ("No valid charsets!");
+				/* header */
+    for (s = msg = (char *) fs_get (j), t = BADCSS; *t; *s++ = *t++);
+				/* each charset */
+    for (i = 0; utf8_csvalid[i].name; *s++ = ' ', i++)
+      for (t = utf8_csvalid[i].name; *t; *s++ = *t++);
+				/* back over last space, trailer */
+    for (t = BADCSE, --s; *t; *s++ = *t++);
+				/* finally bogus charset */
+    for (t = charset; *t; *s++ = *t++);
+    *s++ = '\0';		/* finally tie off string */
+    if (s != (msg + j)) fatal ("charset msg botch");
+  }
+  return msg;
+}
+
+/* Convert charset labelled sized text to UTF-8
+ * Accepts: source sized text
+ *	    charset
+ *	    pointer to returned sized text if non-NIL
+ *	    flags
+ * Returns: T if successful, NIL if failure
+ */
+
+long utf8_text (SIZEDTEXT *text,char *charset,SIZEDTEXT *ret,long flags)
+{
+  ucs4cn_t cv = (flags & U8T_CASECANON) ? ucs4_titlecase : NIL;
+  ucs4de_t de = (flags & U8T_DECOMPOSE) ? ucs4_decompose_recursive : NIL;
+  const CHARSET *cs = (charset && *charset) ?
+    utf8_charset (charset) : utf8_infercharset (text);
+  if (cs) return (text && ret) ? utf8_text_cs (text,cs,ret,cv,de) : LONGT;
+  if (ret) {			/* no conversion possible */
+    ret->data = text->data;	/* so return source */
+    ret->size = text->size;
+  }
+  return NIL;			/* failure */
+}
+
+
+/* Operations used in converting data */
+
+#define UTF8_COUNT_BMP(count,c,cv,de) {		\
+  void *more = NIL;				\
+  if (cv) c = (*cv) (c);			\
+  if (de) c = (*de) (c,&more);			\
+  do count += UTF8_SIZE_BMP(c);			\
+  while (more && (c = (*de) (U8G_ERROR,&more)));\
+}
+
+#define UTF8_WRITE_BMP(b,c,cv,de) {		\
+  void *more = NIL;				\
+  if (cv) c = (*cv) (c);			\
+  if (de) c = (*de) (c,&more);			\
+  do UTF8_PUT_BMP (b,c)				\
+  while (more && (c = (*de) (U8G_ERROR,&more)));\
+}
+
+#define UTF8_COUNT(count,c,cv,de) {		\
+  void *more = NIL;				\
+  if (cv) c = (*cv) (c);			\
+  if (de) c = (*de) (c,&more);			\
+  do count += utf8_size (c);			\
+  while (more && (c = (*de) (U8G_ERROR,&more)));\
+}
+
+#define UTF8_WRITE(b,c,cv,de) {			\
+  void *more = NIL;				\
+  if (cv) c = (*cv) (c);			\
+  if (de) c = (*de) (c,&more);			\
+  do b = utf8_put (b,c);			\
+  while (more && (c = (*de) (U8G_ERROR,&more)));\
+}
+
+/* Convert sized text to UTF-8 given CHARSET block
+ * Accepts: source sized text
+ *	    CHARSET block
+ *	    pointer to returned sized text 
+ *	    canonicalization function
+ *	    decomposition function
+ * Returns: T if successful, NIL if failure
+ */
+
+long utf8_text_cs (SIZEDTEXT *text,const CHARSET *cs,SIZEDTEXT *ret,
+		   ucs4cn_t cv,ucs4de_t de)
+{
+  ret->data = text->data;	/* default to source */
+  ret->size = text->size;
+  switch (cs->type) {		/* convert if type known */
+  case CT_ASCII:		/* 7-bit ASCII no table */
+  case CT_UTF8:			/* variable UTF-8 encoded Unicode no table */
+    if (cv || de) utf8_text_utf8 (text,ret,cv,de);
+    break;
+  case CT_1BYTE0:		/* 1 byte no table */
+    utf8_text_1byte0 (text,ret,cv,de);
+    break;
+  case CT_1BYTE:		/* 1 byte ASCII + table 0x80-0xff */
+    utf8_text_1byte (text,ret,cs->tab,cv,de);
+    break;
+  case CT_1BYTE8:		/* 1 byte table 0x00 - 0xff */
+    utf8_text_1byte8 (text,ret,cs->tab,cv,de);
+    break;
+  case CT_EUC:			/* 2 byte ASCII + utf8_eucparam base/CS2/CS3 */
+    utf8_text_euc (text,ret,cs->tab,cv,de);
+    break;
+  case CT_DBYTE:		/* 2 byte ASCII + utf8_eucparam */
+    utf8_text_dbyte (text,ret,cs->tab,cv,de);
+    break;
+  case CT_DBYTE2:		/* 2 byte ASCII + utf8_eucparam plane1/2 */
+    utf8_text_dbyte2 (text,ret,cs->tab,cv,de);
+    break;
+  case CT_UTF7:			/* variable UTF-7 encoded Unicode no table */
+    utf8_text_utf7 (text,ret,cv,de);
+    break;
+  case CT_UCS2:			/* 2 byte 16-bit Unicode no table */
+    utf8_text_ucs2 (text,ret,cv,de);
+    break;
+  case CT_UCS4:			/* 4 byte 32-bit Unicode no table */
+    utf8_text_ucs4 (text,ret,cv,de);
+    break;
+  case CT_UTF16:		/* variable UTF-16 encoded Unicode no table */
+    utf8_text_utf16 (text,ret,cv,de);
+    break;
+  case CT_2022:			/* variable ISO-2022 encoded no table*/
+    utf8_text_2022 (text,ret,cv,de);
+    break;
+  case CT_SJIS:			/* 2 byte Shift-JIS encoded JIS no table */
+    utf8_text_sjis (text,ret,cv,de);
+    break;
+  default:			/* unknown character set type */
+    return NIL;
+  }
+  return LONGT;			/* return success */
+}
+
+/* Reverse mapping routines
+ *
+ * These routines only support character sets, not all possible charsets.  In
+ * particular, they do not support any Unicode encodings or ISO 2022.
+ *
+ * As a special dispensation, utf8_cstext() and utf8_cstocstext() support
+ * support ISO-2022-JP if EUC-JP can be reverse mapped; and utf8_rmaptext()
+ * will generated ISO-2022-JP using an EUC-JP rmap if flagged to do so.
+ *
+ * No attempt is made to map "equivalent" Unicode characters or Unicode
+ * characters that have the same glyph; nor is there any attempt to handle
+ * combining characters or otherwise do any stringprep.  Maybe later.
+ */
+
+
+/* Convert UTF-8 sized text to charset
+ * Accepts: source sized text
+ *	    destination charset
+ *	    pointer to returned sized text
+ *	    substitute character if not in cs, else NIL to return failure
+ * Returns: T if successful, NIL if failure
+ */
+
+
+long utf8_cstext (SIZEDTEXT *text,char *charset,SIZEDTEXT *ret,
+		  unsigned long errch)
+{
+  short iso2022jp = !compare_cstring (charset,"ISO-2022-JP");
+  unsigned short *rmap = utf8_rmap (iso2022jp ? "EUC-JP" : charset);
+  return rmap ? utf8_rmaptext (text,rmap,ret,errch,iso2022jp) : NIL;
+}
+
+/* Convert charset labelled sized text to another charset
+ * Accepts: source sized text
+ *	    source charset
+ *	    pointer to returned sized text
+ *	    destination charset
+ *	    substitute character if not in dest cs, else NIL to return failure
+ * Returns: T if successful, NIL if failure
+ *
+ * This routine has the same restricts as utf8_cstext().
+ */
+
+long utf8_cstocstext (SIZEDTEXT *src,char *sc,SIZEDTEXT *dst,char *dc,
+		      unsigned long errch)
+{
+  SIZEDTEXT utf8;
+  const CHARSET *scs,*dcs;
+  unsigned short *rmap;
+  long ret = NIL;
+  long iso2022jp;
+				/* lookup charsets and reverse map */
+  if ((dc && (dcs = utf8_charset (dc))) &&
+      (rmap = (iso2022jp = ((dcs->type == CT_2022) &&
+			    !compare_cstring (dcs->name,"ISO-2022-JP"))) ?
+       utf8_rmap ("EUC-JP") : utf8_rmap_cs (dcs)) &&
+      (scs = (sc && *sc) ? utf8_charset (sc) : utf8_infercharset (src))) {
+				/* init temporary buffer */
+    memset (&utf8,NIL,sizeof (SIZEDTEXT));
+				/* source cs equivalent to dest cs? */
+    if ((scs->type == dcs->type) && (scs->tab == dcs->tab)) {
+      dst->data = src->data;	/* yes, just copy pointers */
+      dst->size = src->size;
+      ret = LONGT;
+    }
+				/* otherwise do the conversion */
+    else ret = (utf8_text_cs (src,scs,&utf8,NIL,NIL) &&
+		utf8_rmaptext (&utf8,rmap,dst,errch,iso2022jp));
+				/* flush temporary buffer */
+    if (utf8.data && (utf8.data != src->data) && (utf8.data != dst->data))
+      fs_give ((void **) &utf8.data);
+  }
+  return ret;
+}
+
+/* Cached rmap */
+
+static const CHARSET *currmapcs = NIL;
+static unsigned short *currmap = NIL;
+
+
+/* Cache and return map for UTF-8 -> character set
+ * Accepts: character set name
+ * Returns: cached map if character set found, else NIL
+ */
+
+unsigned short *utf8_rmap (char *charset)
+{
+  return (currmapcs && !compare_cstring (charset,currmapcs->name)) ? currmap :
+    utf8_rmap_cs (utf8_charset (charset));
+}
+
+
+/* Cache and return map for UTF-8 -> character set given CHARSET block
+ * Accepts: CHARSET block
+ * Returns: cached map if character set found, else NIL
+ */
+
+unsigned short *utf8_rmap_cs (const CHARSET *cs)
+{
+  unsigned short *ret = NIL;
+  if (!cs);			/* have charset? */
+  else if (cs == currmapcs) ret = currmap;
+  else if (ret = utf8_rmap_gen (cs,currmap)) {
+    currmapcs = cs;
+    currmap = ret;
+  }
+  return ret;
+}
+
+/* Return map for UTF-8 -> character set given CHARSET block
+ * Accepts: CHARSET block
+ *	    old map to recycle
+ * Returns: map if character set found, else NIL
+ */
+
+unsigned short *utf8_rmap_gen (const CHARSET *cs,unsigned short *oldmap)
+{
+  unsigned short u,*tab,*rmap;
+  unsigned int i,m,ku,ten;
+  struct utf8_eucparam *param,*p2;
+  switch (cs->type) {		/* is a character set? */
+  case CT_ASCII:		/* 7-bit ASCII no table */
+  case CT_1BYTE0:		/* 1 byte no table */
+  case CT_1BYTE:		/* 1 byte ASCII + table 0x80-0xff */
+  case CT_1BYTE8:		/* 1 byte table 0x00 - 0xff */
+  case CT_EUC:			/* 2 byte ASCII + utf8_eucparam base/CS2/CS3 */
+  case CT_DBYTE:		/* 2 byte ASCII + utf8_eucparam */
+  case CT_DBYTE2:		/* 2 byte ASCII + utf8_eucparam plane1/2 */
+  case CT_SJIS:			/* 2 byte Shift-JIS */
+    rmap = oldmap ? oldmap :	/* recycle old map if supplied else make new */
+      (unsigned short *) fs_get (65536 * sizeof (unsigned short));
+				/* initialize table for ASCII */
+    for (i = 0; i < 128; i++) rmap[i] = (unsigned short) i;
+				/* populate remainder of table with NOCHAR */
+#define NOCHARBYTE (NOCHAR & 0xff)
+#if NOCHAR - ((NOCHARBYTE << 8) | NOCHARBYTE)
+    while (i < 65536) rmap[i++] = NOCHAR;
+#else
+    memset (rmap + 128,NOCHARBYTE,(65536 - 128) * sizeof (unsigned short));
+#endif
+    break;
+  default:			/* unsupported charset type */
+    rmap = NIL;			/* no map possible */
+  }
+  if (rmap) {			/* have a map? */
+    switch (cs->type) {		/* additional reverse map actions */
+    case CT_1BYTE0:		/* 1 byte no table */
+      for (i = 128; i < 256; i++) rmap[i] = (unsigned short) i;
+      break;
+    case CT_1BYTE:		/* 1 byte ASCII + table 0x80-0xff */
+      for (tab = (unsigned short *) cs->tab,i = 128; i < 256; i++)
+	if (tab[i & BITS7] != UBOGON) rmap[tab[i & BITS7]] = (unsigned short)i;
+      break;
+    case CT_1BYTE8:		/* 1 byte table 0x00 - 0xff */
+      for (tab = (unsigned short *) cs->tab,i = 0; i < 256; i++)
+	if (tab[i] != UBOGON) rmap[tab[i]] = (unsigned short) i;
+      break;
+    case CT_EUC:		/* 2 byte ASCII + utf8_eucparam base/CS2/CS3 */
+      for (param = (struct utf8_eucparam *) cs->tab,
+	     tab = (unsigned short *) param->tab, ku = 0;
+	   ku < param->max_ku; ku++)
+	for (ten = 0; ten < param->max_ten; ten++)
+	  if ((u = tab[(ku * param->max_ten) + ten]) != UBOGON)
+	    rmap[u] = ((ku + param->base_ku) << 8) +
+	      (ten + param->base_ten) + 0x8080;
+      break;
+
+    case CT_DBYTE:		/* 2 byte ASCII + utf8_eucparam */
+      for (param = (struct utf8_eucparam *) cs->tab,
+	     tab = (unsigned short *) param->tab, ku = 0;
+	   ku < param->max_ku; ku++)
+	for (ten = 0; ten < param->max_ten; ten++)
+	  if ((u = tab[(ku * param->max_ten) + ten]) != UBOGON)
+	    rmap[u] = ((ku + param->base_ku) << 8) + (ten + param->base_ten);
+      break;
+    case CT_DBYTE2:		/* 2 byte ASCII + utf8_eucparam plane1/2 */
+      param = (struct utf8_eucparam *) cs->tab;
+      p2 = param + 1;		/* plane 2 parameters */
+				/* only ten parameters should differ */
+      if ((param->base_ku != p2->base_ku) || (param->max_ku != p2->max_ku))
+	fatal ("ku definition error for CT_DBYTE2 charset");
+				/* total codepoints in each ku */
+      m = param->max_ten + p2->max_ten;
+      tab = (unsigned short *) param->tab;
+      for (ku = 0; ku < param->max_ku; ku++) {
+	for (ten = 0; ten < param->max_ten; ten++)
+	  if ((u = tab[(ku * m) + ten]) != UBOGON)
+	    rmap[u] = ((ku + param->base_ku) << 8) + (ten + param->base_ten);
+	for (ten = 0; ten < p2->max_ten; ten++)
+	  if ((u = tab[(ku * m) + param->max_ten + ten]) != UBOGON)
+	    rmap[u] = ((ku + param->base_ku) << 8) + (ten + p2->base_ten);
+      }
+      break;
+    case CT_SJIS:		/* 2 byte Shift-JIS */
+      for (ku = 0; ku < MAX_JIS0208_KU; ku++)
+	for (ten = 0; ten < MAX_JIS0208_TEN; ten++)
+	  if ((u = jis0208tab[ku][ten]) != UBOGON) {
+	    int sku = ku + BASE_JIS0208_KU;
+	    int sten = ten + BASE_JIS0208_TEN;
+	    rmap[u] = ((((sku + 1) >> 1) + ((sku < 95) ? 112 : 176)) << 8) +
+	      sten + ((sku % 2) ? ((sten > 95) ? 32 : 31) : 126);
+	  }
+				/* JIS Roman */
+      rmap[UCS2_YEN] = JISROMAN_YEN;
+      rmap[UCS2_OVERLINE] = JISROMAN_OVERLINE;
+				/* JIS hankaku katakana */
+      for (u = 0; u < (MAX_KANA_8 - MIN_KANA_8); u++)
+	rmap[UCS2_KATAKANA + u] = MIN_KANA_8 + u;
+      break;
+    }
+				/* hack: map NBSP to SP if otherwise no map */
+    if (rmap[0x00a0] == NOCHAR) rmap[0x00a0] = rmap[0x0020];
+  }
+  return rmap;			/* return map */
+}
+
+/* Convert UTF-8 sized text to charset using rmap
+ * Accepts: source sized text
+ *	    conversion rmap
+ *	    pointer to returned sized text
+ *	    substitute character if not in rmap, else NIL to return failure
+ *	    ISO-2022-JP conversion flag
+ * Returns T if successful, NIL if failure
+ *
+ * This routine doesn't try to convert to all possible charsets; in particular
+ * it doesn't support other Unicode encodings or any ISO 2022 other than
+ * ISO-2022-JP.
+ */
+
+long utf8_rmaptext (SIZEDTEXT *text,unsigned short *rmap,SIZEDTEXT *ret,
+		    unsigned long errch,long iso2022jp)
+{
+  unsigned long i,u,c;
+				/* get size of buffer */
+  if (i = utf8_rmapsize (text,rmap,errch,iso2022jp)) {
+    unsigned char *s = text->data;
+    unsigned char *t = ret->data = (unsigned char *) fs_get (i);
+    ret->size = i - 1;		/* number of octets in destination buffer */
+				/* start non-zero ISO-2022-JP state at 1 */
+    if (iso2022jp) iso2022jp = 1;
+				/* convert string, ignore BOM */
+    for (i = text->size; i;) if ((u = utf8_get (&s,&i)) != UCS2_BOM) {
+				/* substitute error character for NOCHAR */
+      if ((u & U8GM_NONBMP) || ((c = rmap[u]) == NOCHAR)) c = errch;
+      switch (iso2022jp) {	/* depends upon ISO 2022 mode */
+      case 0:			/* ISO 2022 not in effect */
+				/* two-byte character */
+	if (c > 0xff) *t++ = (unsigned char) (c >> 8);
+				/* single-byte or low-byte of two-byte */
+	*t++ = (unsigned char) (c & 0xff);
+	break;
+      case 1:			/* ISO 2022 Roman */
+				/* <ch> */
+	if (c < 0x80) *t++ = (unsigned char) c;
+	else {			/* JIS character */
+	  *t++ = I2C_ESC;	/* ESC $ B <hi> <lo> */
+	  *t++ = I2C_MULTI;
+	  *t++ = I2CS_94x94_JIS_NEW;
+	  *t++ = (unsigned char) (c >> 8) & 0x7f;
+	  *t++ = (unsigned char) c & 0x7f;
+	  iso2022jp = 2;	/* shift to ISO 2022 JIS */
+	}
+	break;
+      case 2:			/* ISO 2022 JIS */
+	if (c > 0x7f) {		/* <hi> <lo> */
+	  *t++ = (unsigned char) (c >> 8) & 0x7f;
+	  *t++ = (unsigned char) c & 0x7f;
+	}
+	else {			/* ASCII character */
+	  *t++ = I2C_ESC;	/* ESC ( J <ch> */
+	  *t++ = I2C_G0_94;
+	  *t++ = I2CS_94_JIS_ROMAN;
+	  *t++ = (unsigned char) c;
+	  iso2022jp = 1;	/* shift to ISO 2022 Roman */
+	}
+	break;
+      }
+    }
+    if (iso2022jp == 2) {	/* ISO-2022-JP string must end in Roman */
+      *t++ = I2C_ESC;		/* ESC ( J */
+      *t++ = I2C_G0_94;
+      *t++ = I2CS_94_JIS_ROMAN;
+    }
+    *t++ = NIL;			/* tie off returned data */
+    return LONGT;		/* return success */
+  }
+  ret->data = NIL;
+  ret->size = 0;
+  return NIL;			/* failure */
+}
+
+/* Calculate size of convertsion of UTF-8 sized text to charset using rmap
+ * Accepts: source sized text
+ *	    conversion rmap
+ *	    pointer to returned sized text
+ *	    substitute character if not in rmap, else NIL to return failure
+ *	    ISO-2022-JP conversion flag
+ * Returns size+1 if successful, NIL if failure
+ *
+ * This routine doesn't try to handle to all possible charsets; in particular
+ * it doesn't support other Unicode encodings or any ISO 2022 other than
+ * ISO-2022-JP.
+ */
+
+unsigned long utf8_rmapsize (SIZEDTEXT *text,unsigned short *rmap,
+			     unsigned long errch,long iso2022jp)
+{
+  unsigned long i,u,c;
+  unsigned long ret = 1;	/* terminating NUL */
+  unsigned char *s = text->data;
+  if (iso2022jp) iso2022jp = 1;	/* start non-zero ISO-2022-JP state at 1 */
+  for (i = text->size; i;) if ((u = utf8_get (&s,&i)) != UCS2_BOM) {
+    if ((u & U8GM_NONBMP) || (((c = rmap[u]) == NOCHAR) && !(c = errch)))
+      return NIL;		/* not in BMP, or NOCHAR and no err char */
+    switch (iso2022jp) {	/* depends upon ISO 2022 mode */
+    case 0:			/* ISO 2022 not in effect */
+      ret += (c > 0xff) ? 2 : 1;
+      break;
+    case 1:			/* ISO 2022 Roman */
+      if (c < 0x80) ret += 1;	/* <ch> */
+      else {			/* JIS character */
+	ret += 5;		/* ESC $ B <hi> <lo> */
+	iso2022jp = 2;		/* shift to ISO 2022 JIS */
+      }
+      break;
+    case 2:			/* ISO 2022 JIS */
+      if (c > 0x7f) ret += 2;	/* <hi> <lo> */
+      else {			/* ASCII character */
+	ret += 4;		/* ESC ( J <ch> */
+	iso2022jp = 1;		/* shift to ISO 2022 Roman */
+      }
+      break;
+    }
+  }
+  if (iso2022jp == 2) {		/* ISO-2022-JP string must end in Roman */
+    ret += 3;			/* ESC ( J */
+    iso2022jp = 1;		/* reset state to Roman */
+  }
+  return ret;
+}
+
+/* Convert UCS-4 to charset using rmap
+ * Accepts: source UCS-4 character(s)
+ *	    numver of UCS-4 characters
+ *	    conversion rmap
+ *	    pointer to returned sized text
+ *	    substitute character if not in rmap, else NIL to return failure
+ * Returns T if successful, NIL if failure
+ *
+ * Currently only supports BMP characters, and does not support ISO-2022
+ */
+
+long ucs4_rmaptext (unsigned long *ucs4,unsigned long len,unsigned short *rmap,
+		    SIZEDTEXT *ret,unsigned long errch)
+{
+  long size = ucs4_rmaplen (ucs4,len,rmap,errch);
+  return (size >= 0) ?		/* build in newly-created buffer */
+    ucs4_rmapbuf (ret->data = (unsigned char *) fs_get ((ret->size = size) +1),
+		  ucs4,len,rmap,errch) : NIL;
+}
+
+/* Return size of UCS-4 string converted to other CS via rmap
+ * Accepts: source UCS-4 character(s)
+ *	    numver of UCS-4 characters
+ *	    conversion rmap
+ *	    substitute character if not in rmap, else NIL to return failure
+ * Returns: length if success, negative if failure (no-convert)
+ */
+
+long ucs4_rmaplen (unsigned long *ucs4,unsigned long len,unsigned short *rmap,
+		   unsigned long errch)
+{
+  long ret;
+  unsigned long i,u,c;
+				/* count non-BOM characters */
+  for (ret = 0,i = 0; i < len; ++i) if ((u = ucs4[i]) != UCS2_BOM) {
+    if ((u & U8GM_NONBMP) || (((c = rmap[u]) == NOCHAR) && !(c = errch)))
+      return -1;		/* not in BMP, or NOCHAR and no err char? */
+    ret += (c > 0xff) ? 2 : 1;
+  }
+  return ret;
+}
+
+
+/* Stuff buffer with UCS-4 string converted to other CS via rmap
+ * Accepts: destination buffer
+ *	    source UCS-4 character(s)
+ *	    number of UCS-4 characters
+ *	    conversion rmap
+ *	    substitute character if not in rmap, else NIL to return failure
+ * Returns: T, always
+ */
+
+long ucs4_rmapbuf (unsigned char *t,unsigned long *ucs4,unsigned long len,
+		   unsigned short *rmap,unsigned long errch)
+{
+  unsigned long i,u,c;
+				/* convert non-BOM characters */
+  for (i = 0; i < len; ++i) if ((u = ucs4[i]) != UCS2_BOM) {
+				/* substitute error character for NOCHAR */
+    if ((u & U8GM_NONBMP) || ((c = rmap[u]) == NOCHAR)) c = errch;
+				/* two-byte character? */
+    if (c > 0xff) *t++ = (unsigned char) (c >> 8);
+				/* single-byte or low-byte of two-byte */
+    *t++ = (unsigned char) (c & 0xff);
+  }
+  *t++ = NIL;			/* tie off returned data */
+  return LONGT;
+}
+
+/* Return UCS-4 Unicode character from UTF-8 string
+ * Accepts: pointer to string
+ *	    remaining octets in string
+ * Returns: UCS-4 character with pointer and count updated
+ *	    or error code with pointer and count unchanged
+ */
+
+unsigned long utf8_get (unsigned char **s,unsigned long *i)
+{
+  unsigned char *t = *s;
+  unsigned long j = *i;
+				/* decode raw UTF-8 string */
+  unsigned long ret = utf8_get_raw (&t,&j);
+  if (ret & U8G_ERROR);		/* invalid raw UTF-8 decoding? */
+				/* no, is it surrogate? */
+  else if ((ret >= UTF16_SURR) && (ret <= UTF16_MAXSURR)) ret = U8G_SURROGA;
+				/* or in non-Unicode ISO 10646 space? */
+  else if (ret > UCS4_MAXUNICODE) ret = U8G_NOTUNIC;
+  else {
+    *s = t;			/* all is well, update pointer */
+    *i = j;			/* and counter */
+  }
+  return ret;			/* return value */
+}
+
+/* Return raw (including non-Unicode) UCS-4 character from UTF-8 string
+ * Accepts: pointer to string
+ *	    remaining octets in string
+ * Returns: UCS-4 character with pointer and count updated
+ *	    or error code with pointer and count unchanged
+ */
+
+unsigned long utf8_get_raw (unsigned char **s,unsigned long *i)
+{
+  unsigned char c,c1;
+  unsigned char *t = *s;
+  unsigned long j = *i;
+  unsigned long ret = U8G_NOTUTF8;
+  int more = 0;
+  do {				/* make sure have source octets available */
+    if (!j--) return more ? U8G_ENDSTRI : U8G_ENDSTRG;
+				/* UTF-8 continuation? */
+    else if (((c = *t++) > 0x7f) && (c < 0xc0)) {
+				/* continuation when not in progress */
+      if (!more) return U8G_BADCONT;
+      --more;			/* found a continuation octet */
+      ret <<= 6;		/* shift current value by 6 bits */
+      ret |= c & 0x3f;		/* merge continuation octet */
+    }
+				/* incomplete UTF-8 character */
+    else if (more) return U8G_INCMPLT;
+    else {			/* start of sequence */
+      c1 = j ? *t : 0xbf;	/* assume valid continuation if incomplete */
+      if (c < 0x80) ret = c;	/* U+0000 - U+007f */
+      else if (c < 0xc2);	/* c0 and c1 never valid */
+      else if (c < 0xe0) {	/* U+0080 - U+07ff */
+	if (c &= 0x1f) more = 1;
+      }
+      else if (c < 0xf0) {	/* U+0800 - U+ffff */
+	if ((c &= 0x0f) || (c1 >= 0xa0)) more = 2;
+      }
+      else if (c < 0xf8) {	/* U+10000 - U+10ffff (and 110000 - 1fffff) */
+	if ((c &= 0x07) || (c1 >= 0x90)) more = 3;
+      }
+      else if (c < 0xfc) {	/* ISO 10646 200000 - 3ffffff */
+	if ((c &= 0x03) || (c1 >= 0x88)) more = 4;
+      }
+      else if (c < 0xfe) {	/* ISO 10646 4000000 - 7fffffff */
+	if ((c &= 0x01) || (c1 >= 0x84)) more = 5;
+      }
+				/* fe and ff never valid */
+      if (more) {		/* multi-octet, make sure more to come */
+	if (!j) return U8G_ENDSTRI;
+	ret = c;		/* continuation needed, save start bits */
+      }
+    }
+  } while (more);
+  if (!(ret & U8G_ERROR)) {	/* success return? */
+    *s = t;			/* yes, update pointer */
+    *i = j;			/* and counter */
+  }
+  return ret;			/* return value */
+}
+
+/* Return UCS-4 character from named charset string
+ * Accepts: charset
+ *	    pointer to string
+ *	    remaining octets in string
+ * Returns: UCS-4 character with pointer and count updated, negative if error
+ *
+ * Error codes are the same as utf8_get().
+ */
+
+unsigned long ucs4_cs_get (CHARSET *cs,unsigned char **s,unsigned long *i)
+{
+  unsigned char c,c1,ku,ten;
+  unsigned long ret,d;
+  unsigned char *t = *s;
+  unsigned long j = *i;
+  struct utf8_eucparam *p1,*p2,*p3;
+  if (j--) c = *t++;		/* get first octet */
+  else return U8G_ENDSTRG;	/* empty string */
+  switch (cs->type) {		/* convert if type known */
+  case CT_UTF8:			/* variable UTF-8 encoded Unicode no table */
+    return utf8_get (s,i);
+  case CT_ASCII:		/* 7-bit ASCII no table */
+    if (c >= 0x80) return U8G_NOTUTF8;
+  case CT_1BYTE0:		/* 1 byte no table */
+    ret = c;			/* identity */
+    break;
+  case CT_1BYTE:		/* 1 byte ASCII + table 0x80-0xff */
+    ret = (c > 0x80) ? ((unsigned short *) cs->tab)[c & BITS7] : c;
+    break;
+  case CT_1BYTE8:		/* 1 byte table 0x00 - 0xff */
+    ret = ((unsigned short *) cs->tab)[c];
+    break;
+
+  case CT_EUC:			/* 2 byte ASCII + utf8_eucparam base/CS2/CS3 */
+    if (c & BIT8) {
+      p1 = (struct utf8_eucparam *) cs->tab;
+      p2 = p1 + 1;
+      p3 = p1 + 2;
+      if (j--) c1 = *t++;	/* get second octet */
+      else return U8G_ENDSTRI;
+      if (!(c1 & BIT8)) return U8G_NOTUTF8;
+      switch (c) {		/* check 8bit code set */
+      case EUC_CS2:		/* CS2 */
+	if (p2->base_ku) {	/* CS2 set up? */
+	  if (p2->base_ten) {	/* yes, multibyte? */
+	    if (j--) c = *t++;	/* get second octet */
+	    else return U8G_ENDSTRI;
+	    if ((c & BIT8) &&
+		((ku = (c1 & BITS7) - p2->base_ku) < p2->max_ku) &&
+		((ten = (c & BITS7) - p2->base_ten) < p2->max_ten)) {
+	      ret = ((unsigned short *) p2->tab)[(ku*p2->max_ten) + ten];
+	      break;
+	    }
+	  }
+	  else if ((c1 >= p2->base_ku) && (c1 < p2->max_ku)) {
+	    ret = c1 + ((unsigned long) p2->tab);
+	    break;
+	  }
+	}
+	return U8G_NOTUTF8;	/* CS2 not set up or bogus */
+      case EUC_CS3:		/* CS3 */
+	if (p3->base_ku) {	/* CS3 set up? */
+	  if (p3->base_ten) {	/* yes, multibyte? */
+	    if (j--) c = *t++;	/* get second octet */
+	    else return U8G_ENDSTRI;
+	    if ((c & BIT8) &&
+		((ku = (c1 & BITS7) - p3->base_ku) < p3->max_ku) &&
+		((ten = (c & BITS7) - p3->base_ten) < p3->max_ten)) {
+	      ret = ((unsigned short *) p3->tab)[(ku*p3->max_ten) + ten];
+	      break;
+	    }
+	  }
+	  else if ((c1 >= p3->base_ku) && (c1 < p3->max_ku)) {
+	    ret = c1 + ((unsigned long) p3->tab);
+	    break;
+	  }
+	}
+	return U8G_NOTUTF8;	/* CS3 not set up or bogus */
+      default:
+	if (((ku = (c & BITS7) - p1->base_ku) >= p1->max_ku) ||
+	    ((ten = (c1 & BITS7) - p1->base_ten) >= p1->max_ten))
+	  return U8G_NOTUTF8;
+	ret = ((unsigned short *) p1->tab)[(ku*p1->max_ten) + ten];
+		/* special hack for JIS X 0212: merge rows less than 10 */
+	if ((ret == UBOGON) && ku && (ku < 10) && p3->tab && p3->base_ten)
+	  ret = ((unsigned short *) p3->tab)
+	    [((ku - (p3->base_ku - p1->base_ku))*p3->max_ten) + ten];
+	break;
+      }
+    }
+    else ret = c;		/* ASCII character */
+    break;
+
+  case CT_DBYTE:		/* 2 byte ASCII + utf8_eucparam */
+    if (c & BIT8) {		/* double-byte character? */
+      p1 = (struct utf8_eucparam *) cs->tab;
+      if (j--) c1 = *t++;	/* get second octet */
+      else return U8G_ENDSTRI;
+      if (((ku = c - p1->base_ku) < p1->max_ku) &&
+	  ((ten = c1 - p1->base_ten) < p1->max_ten))
+	ret = ((unsigned short *) p1->tab)[(ku*p1->max_ten) + ten];
+      else return U8G_NOTUTF8;
+    }
+    else ret = c;		/* ASCII character */
+    break;
+  case CT_DBYTE2:		/* 2 byte ASCII + utf8_eucparam plane1/2 */
+    if (c & BIT8) {		/* double-byte character? */
+      p1 = (struct utf8_eucparam *) cs->tab;
+      p2 = p1 + 1;
+      if (j--) c1 = *t++;	/* get second octet */
+      else return U8G_ENDSTRI;
+      if (c1 & BIT8) {		/* high vs. low plane */
+	if ((ku = c - p2->base_ku) < p2->max_ku &&
+	    ((ten = c1 - p2->base_ten) < p2->max_ten))
+	  ret = ((unsigned short *) p1->tab)
+	    [(ku*(p1->max_ten + p2->max_ten)) + p1->max_ten + ten];
+	else return U8G_NOTUTF8;
+      }
+      else if ((ku = c - p1->base_ku) < p1->max_ku &&
+	       ((ten = c1 - p1->base_ten) < p1->max_ten))
+	  ret = ((unsigned short *) p1->tab)
+	    [(ku*(p1->max_ten + p2->max_ten)) + ten];
+      else return U8G_NOTUTF8;
+    }
+    else ret = c;		/* ASCII character */
+    break;
+  case CT_SJIS:			/* 2 byte Shift-JIS encoded JIS no table */
+				/* compromise - do yen sign but not overline */
+    if (!(c & BIT8)) ret = (c == JISROMAN_YEN) ? UCS2_YEN : c;
+				/* half-width katakana? */
+    else if ((c >= MIN_KANA_8) && (c < MAX_KANA_8)) ret = c + KANA_8;
+    else {			/* Shift-JIS */
+      if (j--) c1 = *t++;	/* get second octet */
+      else return U8G_ENDSTRI;
+      SJISTOJIS (c,c1);
+      c = JISTOUNICODE (c,c1,ku,ten);
+    }
+    break;
+
+  case CT_UCS2:			/* 2 byte 16-bit Unicode no table */
+    ret = c << 8;
+    if (j--) c = *t++;		/* get second octet */
+    else return U8G_ENDSTRI;	/* empty string */
+    ret |= c;
+    break;
+  case CT_UCS4:			/* 4 byte 32-bit Unicode no table */
+    if (c & 0x80) return U8G_NOTUTF8;
+    if (j < 3) return U8G_ENDSTRI;
+    j -= 3;			/* count three octets */
+    ret = c << 24;
+    ret |= (*t++) << 16;
+    ret |= (*t++) << 8;
+    ret |= (*t++);
+    break;
+  case CT_UTF16:		/* variable UTF-16 encoded Unicode no table */
+    ret = c << 8;
+    if (j--) c = *t++;		/* get second octet */
+    else return U8G_ENDSTRI;	/* empty string */
+    ret |= c;
+				/* surrogate? */
+    if ((ret >= UTF16_SURR) && (ret <= UTF16_MAXSURR)) {
+				/* invalid first surrogate */
+      if ((ret > UTF16_SURRHEND) || (j < 2)) return U8G_NOTUTF8;
+      j -= 2;			/* count two octets */
+      d = (*t++) << 8;		/* first octet of second surrogate */
+      d |= *t++;		/* second octet of second surrogate */
+      if ((d < UTF16_SURRL) || (d > UTF16_SURRLEND)) return U8G_NOTUTF8;
+      ret = UTF16_BASE + ((ret & UTF16_MASK) << UTF16_SHIFT) +
+	(d & UTF16_MASK);
+    }
+    break;
+  default:			/* unknown/unsupported character set type */
+    return U8G_NOTUTF8;
+  }
+  *s = t;			/* update pointer and counter */
+  *i = j;
+  return ret;
+}
+
+/* Produce charset validity map for BMP
+ * Accepts: list of charsets to map
+ * Returns: validity map, indexed by BMP codepoint
+ *
+ * Bit 0x1 is the "not-CJK" character bit
+ */
+
+unsigned long *utf8_csvalidmap (char *charsets[])
+{
+  unsigned short u,*tab;
+  unsigned int m,ku,ten;
+  unsigned long i,csi,csb;
+  struct utf8_eucparam *param,*p2;
+  char *s;
+  const CHARSET *cs;
+  unsigned long *ret = (unsigned long *)
+    fs_get (i = 0x10000 * sizeof (unsigned long));
+  memset (ret,0,i);		/* zero the entire vector */
+				/* mark all the non-CJK codepoints */
+	/* U+0000 - U+2E7F non-CJK */
+  for (i = 0; i < 0x2E7F; ++i) ret[i] = 0x1;
+	/* U+2E80 - U+2EFF CJK Radicals Supplement
+	 * U+2F00 - U+2FDF Kangxi Radicals
+	 * U+2FE0 - U+2FEF unassigned
+	 * U+2FF0 - U+2FFF Ideographic Description Characters
+	 * U+3000 - U+303F CJK Symbols and Punctuation
+	 * U+3040 - U+309F Hiragana
+	 * U+30A0 - U+30FF Katakana
+	 * U+3100 - U+312F BoPoMoFo
+	 * U+3130 - U+318F Hangul Compatibility Jamo
+	 * U+3190 - U+319F Kanbun
+	 * U+31A0 - U+31BF BoPoMoFo Extended
+	 * U+31C0 - U+31EF CJK Strokes
+	 * U+31F0 - U+31FF Katakana Phonetic Extensions
+	 * U+3200 - U+32FF Enclosed CJK Letters and Months
+	 * U+3300 - U+33FF CJK Compatibility
+	 * U+3400 - U+4DBF CJK Unified Ideographs Extension A
+	 * U+4DC0 - U+4DFF Yijing Hexagram Symbols
+	 * U+4E00 - U+9FFF CJK Unified Ideographs
+	 * U+A000 - U+A48F Yi Syllables
+	 * U+A490 - U+A4CF Yi Radicals
+	 * U+A700 - U+A71F Modifier Tone Letters
+	 */
+  for (i = 0xa720; i < 0xabff; ++i) ret[i] = 0x1;
+	/* U+AC00 - U+D7FF Hangul Syllables */
+  for (i = 0xd800; i < 0xf8ff; ++i) ret[i] = 0x1;
+	/* U+F900 - U+FAFF CJK Compatibility Ideographs */
+  for (i = 0xfb00; i < 0xfe2f; ++i) ret[i] = 0x1;
+	/* U+FE30 - U+FE4F CJK Compatibility Forms
+	 * U+FE50 - U+FE6F Small Form Variants (for CNS 11643)
+	 */
+  for (i = 0xfe70; i < 0xfeff; ++i) ret[i] = 0x1;
+	/* U+FF00 - U+FFEF CJK Compatibility Ideographs */
+  for (i = 0xfff0; i < 0x10000; ++i) ret[i] = 0x1;
+
+				/* for each supplied charset */
+  for (csi = 1; ret && charsets && (s = charsets[csi - 1]); ++csi) {
+				/* substitute EUC-JP for ISO-2022-JP */
+    if (!compare_cstring (s,"ISO-2022-JP")) s = "EUC-JP";
+				/* look up charset */
+    if (cs = utf8_charset (s)) {
+      csb = 1 << csi;		/* charset bit */
+      switch (cs->type) {
+      case CT_ASCII:		/* 7-bit ASCII no table */
+      case CT_1BYTE0:		/* 1 byte no table */
+      case CT_1BYTE:		/* 1 byte ASCII + table 0x80-0xff */
+      case CT_1BYTE8:		/* 1 byte table 0x00 - 0xff */
+      case CT_EUC:		/* 2 byte ASCII + utf8_eucparam base/CS2/CS3 */
+      case CT_DBYTE:		/* 2 byte ASCII + utf8_eucparam */
+      case CT_DBYTE2:		/* 2 byte ASCII + utf8_eucparam plane1/2 */
+      case CT_SJIS:		/* 2 byte Shift-JIS */
+				/* supported charset type, all ASCII is OK */
+	for (i = 0; i < 128; ++i) ret[i] |= csb;
+	break;
+      default:			/* unsupported charset type */
+	fs_give ((void **) &ret);
+	break;
+      }
+				/* now do additional operations */
+      if (ret) switch (cs->type) {
+      case CT_1BYTE0:		/* 1 byte no table */
+	for (i = 128; i < 256; i++) ret[i] |= csb;
+	break;
+      case CT_1BYTE:		/* 1 byte ASCII + table 0x80-0xff */
+	for (tab = (unsigned short *) cs->tab,i = 128; i < 256; i++)
+	  if (tab[i & BITS7] != UBOGON) ret[tab[i & BITS7]] |= csb;
+	break;
+      case CT_1BYTE8:		/* 1 byte table 0x00 - 0xff */
+	for (tab = (unsigned short *) cs->tab,i = 0; i < 256; i++)
+	  if (tab[i] != UBOGON) ret[tab[i]] |= csb;
+      break;
+      case CT_EUC:		/* 2 byte ASCII + utf8_eucparam base/CS2/CS3 */
+	for (param = (struct utf8_eucparam *) cs->tab,
+	       tab = (unsigned short *) param->tab, ku = 0;
+	     ku < param->max_ku; ku++)
+	  for (ten = 0; ten < param->max_ten; ten++)
+	    if ((u = tab[(ku * param->max_ten) + ten]) != UBOGON)
+	      ret[u] |= csb;
+	break;
+
+      case CT_DBYTE:		/* 2 byte ASCII + utf8_eucparam */
+	for (param = (struct utf8_eucparam *) cs->tab,
+	       tab = (unsigned short *) param->tab, ku = 0;
+	     ku < param->max_ku; ku++)
+	  for (ten = 0; ten < param->max_ten; ten++)
+	    if ((u = tab[(ku * param->max_ten) + ten]) != UBOGON)
+	      ret[u] |= csb;
+      break;
+      case CT_DBYTE2:		/* 2 byte ASCII + utf8_eucparam plane1/2 */
+	param = (struct utf8_eucparam *) cs->tab;
+	p2 = param + 1;		/* plane 2 parameters */
+				/* only ten parameters should differ */
+	if ((param->base_ku != p2->base_ku) || (param->max_ku != p2->max_ku))
+	  fatal ("ku definition error for CT_DBYTE2 charset");
+				/* total codepoints in each ku */
+	m = param->max_ten + p2->max_ten;
+	tab = (unsigned short *) param->tab;
+	for (ku = 0; ku < param->max_ku; ku++) {
+	  for (ten = 0; ten < param->max_ten; ten++)
+	    if ((u = tab[(ku * m) + ten]) != UBOGON)
+	      ret[u] |= csb;
+	  for (ten = 0; ten < p2->max_ten; ten++)
+	    if ((u = tab[(ku * m) + param->max_ten + ten]) != UBOGON)
+	      ret[u] |= csb;
+	}
+	break;
+      case CT_SJIS:		/* 2 byte Shift-JIS */
+	for (ku = 0; ku < MAX_JIS0208_KU; ku++)
+	  for (ten = 0; ten < MAX_JIS0208_TEN; ten++)
+	    if ((u = jis0208tab[ku][ten]) != UBOGON) ret[u] |= csb;
+				/* JIS hankaku katakana */
+	for (u = 0; u < (MAX_KANA_8 - MIN_KANA_8); u++)
+	  ret[UCS2_KATAKANA + u] |= csb;
+	break;
+      }
+    }
+				/* invalid charset, punt */
+    else fs_give ((void **) &ret);
+  }
+  return ret;
+}
+
+/* Infer charset from unlabelled sized text
+ * Accepts: sized text
+ * Returns: charset if one inferred, or NIL if unknown
+ */
+
+const CHARSET *utf8_infercharset (SIZEDTEXT *src)
+{
+  long iso2022jp = NIL;
+  long eightbit = NIL;
+  unsigned long i;
+				/* look for ISO 2022 */
+  if (src) for (i = 0; i < src->size; i++) {
+				/* ESC sequence? */
+    if ((src->data[i] == I2C_ESC) && (++i < src->size)) switch (src->data[i]) {
+    case I2C_MULTI:		/* yes, multibyte? */
+      if (++i < src->size) switch (src->data[i]) {
+      case I2CS_94x94_JIS_OLD:	/* JIS X 0208-1978 */
+      case I2CS_94x94_JIS_NEW:	/* JIS X 0208-1983 */
+      case I2CS_94x94_JIS_EXT:	/* JIS X 0212-1990 (kludge...) */
+	iso2022jp = T;		/* found an ISO-2022-JP sequence */
+	break;
+      default:			/* other multibyte */
+	return NIL;		/* definitely invalid */
+      }
+      break;
+    case I2C_G0_94:		/* single byte */
+      if (++i < src->size) switch (src->data[i]) {
+      case I2CS_94_JIS_BUGROM:	/* in case old buggy software */
+      case I2CS_94_JIS_ROMAN:	/* JIS X 0201-1976 left half */
+      case I2CS_94_ASCII:	/* ASCII */
+      case I2CS_94_BRITISH:	/* good enough for gov't work */
+	break;
+      default:			/* other 94 single byte */
+	return NIL;		/* definitely invalid */
+      }
+    }
+				/* if possible UTF-8 and not ISO-2022-JP */
+    else if (!iso2022jp && (eightbit >= 0) && (src->data[i] & BIT8) &&
+	     (eightbit = utf8_validate (src->data + i,src->size - i)) > 0)
+      i += eightbit - 1;	/* skip past all but last of UTF-8 char */
+  }
+				/* ISO-2022-JP overrides other guesses */
+  if (iso2022jp) return utf8_charset ("ISO-2022-JP");
+  if (eightbit > 0) return utf8_charset ("UTF-8");
+  return eightbit ? NIL : utf8_charset ("US-ASCII");
+}
+
+
+/* Validate that character at this position is UTF-8
+ * Accepts: string pointer
+ *	    size of remaining string
+ * Returns: size of UTF-8 character in octets or -1 if not UTF-8
+ */
+
+long utf8_validate (unsigned char *s,unsigned long i)
+{
+  unsigned long j = i;
+  return (utf8_get (&s,&i) & U8G_ERROR) ? -1 : j - i;
+}
+
+/* Convert ISO 8859-1 to UTF-8
+ * Accepts: source sized text
+ *	    pointer to return sized text
+ *	    canonicalization function
+ */
+
+void utf8_text_1byte0 (SIZEDTEXT *text,SIZEDTEXT *ret,ucs4cn_t cv,ucs4de_t de)
+{
+  unsigned long i;
+  unsigned char *s;
+  unsigned int c;
+  for (ret->size = i = 0; i < text->size;) {
+    c = text->data[i++];
+    UTF8_COUNT_BMP (ret->size,c,cv,de)
+  }
+  (s = ret->data = (unsigned char *) fs_get (ret->size + 1))[ret->size] =NIL;
+  for (i = 0; i < text->size;) {
+    c = text->data[i++];
+    UTF8_WRITE_BMP (s,c,cv,de)	/* convert UCS-2 to UTF-8 */
+  }
+}
+
+
+/* Convert single byte ASCII+8bit character set sized text to UTF-8
+ * Accepts: source sized text
+ *	    pointer to return sized text
+ *	    conversion table
+ *	    canonicalization function
+ */
+
+void utf8_text_1byte (SIZEDTEXT *text,SIZEDTEXT *ret,void *tab,ucs4cn_t cv,
+		      ucs4de_t de)
+{
+  unsigned long i;
+  unsigned char *s;
+  unsigned int c;
+  unsigned short *tbl = (unsigned short *) tab;
+  for (ret->size = i = 0; i < text->size;) {
+    if ((c = text->data[i++]) & BIT8) c = tbl[c & BITS7];
+    UTF8_COUNT_BMP (ret->size,c,cv,de)
+  }
+  (s = ret->data = (unsigned char *) fs_get (ret->size + 1))[ret->size] =NIL;
+  for (i = 0; i < text->size;) {
+    if ((c = text->data[i++]) & BIT8) c = tbl[c & BITS7];
+    UTF8_WRITE_BMP (s,c,cv,de)	/* convert UCS-2 to UTF-8 */
+  }
+}
+
+/* Convert single byte 8bit character set sized text to UTF-8
+ * Accepts: source sized text
+ *	    pointer to return sized text
+ *	    conversion table
+ *	    canonicalization function
+ */
+
+void utf8_text_1byte8 (SIZEDTEXT *text,SIZEDTEXT *ret,void *tab,ucs4cn_t cv,
+		       ucs4de_t de)
+{
+  unsigned long i;
+  unsigned char *s;
+  unsigned int c;
+  unsigned short *tbl = (unsigned short *) tab;
+  for (ret->size = i = 0; i < text->size;) {
+    c = tbl[text->data[i++]];
+    UTF8_COUNT_BMP (ret->size,c,cv,de)
+  }
+  (s = ret->data = (unsigned char *) fs_get (ret->size + 1))[ret->size] =NIL;
+  for (i = 0; i < text->size;) {
+    c = tbl[text->data[i++]];
+    UTF8_WRITE_BMP (s,c,cv,de)	/* convert UCS-2 to UTF-8 */
+  }
+}
+
+/* Convert EUC sized text to UTF-8
+ * Accepts: source sized text
+ *	    pointer to return sized text
+ *	    EUC parameter table
+ *	    canonicalization function
+ */
+
+void utf8_text_euc (SIZEDTEXT *text,SIZEDTEXT *ret,void *tab,ucs4cn_t cv,
+		    ucs4de_t de)
+{
+  unsigned long i;
+  unsigned char *s;
+  unsigned int pass,c,c1,ku,ten;
+  struct utf8_eucparam *p1 = (struct utf8_eucparam *) tab;
+  struct utf8_eucparam *p2 = p1 + 1;
+  struct utf8_eucparam *p3 = p1 + 2;
+  unsigned short *t1 = (unsigned short *) p1->tab;
+  unsigned short *t2 = (unsigned short *) p2->tab;
+  unsigned short *t3 = (unsigned short *) p3->tab;
+  for (pass = 0,s = NIL,ret->size = 0; pass <= 1; pass++) {
+    for (i = 0; i < text->size;) {
+				/* not CS0? */
+      if ((c = text->data[i++]) & BIT8) {
+				/* yes, must have another high byte */
+	if ((i >= text->size) || !((c1 = text->data[i++]) & BIT8))
+	  c = UBOGON;		/* out of space or bogon */
+	else switch (c) {	/* check 8bit code set */
+	case EUC_CS2:		/* CS2 */
+	  if (p2->base_ku) {	/* CS2 set up? */
+	    if (p2->base_ten)	/* yes, multibyte? */
+	      c = ((i < text->size) && ((c = text->data[i++]) & BIT8) &&
+		   ((ku = (c1 & BITS7) - p2->base_ku) < p2->max_ku) &&
+		   ((ten = (c & BITS7) - p2->base_ten) < p2->max_ten)) ?
+		     t2[(ku*p2->max_ten) + ten] : UBOGON;
+	    else c = ((c1 >= p2->base_ku) && (c1 < p2->max_ku)) ?
+	      c1 + ((unsigned long) p2->tab) : UBOGON;
+	  }	  
+	  else {		/* CS2 not set up */
+	    c = UBOGON;		/* swallow byte, say bogon */
+	    if (i < text->size) i++;
+	  }
+	  break;
+	case EUC_CS3:		/* CS3 */
+	  if (p3->base_ku) {	/* CS3 set up? */
+	    if (p3->base_ten)	/* yes, multibyte? */
+	      c = ((i < text->size) && ((c = text->data[i++]) & BIT8) &&
+		   ((ku = (c1 & BITS7) - p3->base_ku) < p3->max_ku) &&
+		   ((ten = (c & BITS7) - p3->base_ten) < p3->max_ten)) ?
+		     t3[(ku*p3->max_ten) + ten] : UBOGON;
+	    else c = ((c1 >= p3->base_ku) && (c1 < p3->max_ku)) ?
+	      c1 + ((unsigned long) p3->tab) : UBOGON;
+	  }	  
+	  else {		/* CS3 not set up */
+	    c = UBOGON;		/* swallow byte, say bogon */
+	    if (i < text->size) i++;
+	  }
+	  break;
+
+	default:
+	  if (((ku = (c & BITS7) - p1->base_ku) >= p1->max_ku) ||
+	      ((ten = (c1 & BITS7) - p1->base_ten) >= p1->max_ten)) c = UBOGON;
+	  else if (((c = t1[(ku*p1->max_ten) + ten]) == UBOGON) &&
+		   /* special hack for JIS X 0212: merge rows less than 10 */
+		   ku && (ku < 10) && t3 && p3->base_ten)
+	    c = t3[((ku - (p3->base_ku - p1->base_ku))*p3->max_ten) + ten];
+	}
+      }
+				/* convert if second pass */
+      if (pass) UTF8_WRITE_BMP (s,c,cv,de)
+      else UTF8_COUNT_BMP (ret->size,c,cv,de);
+    }
+    if (!pass) (s = ret->data = (unsigned char *)
+		fs_get (ret->size + 1))[ret->size] =NIL;
+  }
+}
+
+
+/* Convert ASCII + double-byte sized text to UTF-8
+ * Accepts: source sized text
+ *	    pointer to return sized text
+ *	    conversion table
+ *	    canonicalization function
+ */
+
+void utf8_text_dbyte (SIZEDTEXT *text,SIZEDTEXT *ret,void *tab,ucs4cn_t cv,
+		      ucs4de_t de)
+{
+  unsigned long i;
+  unsigned char *s;
+  unsigned int c,c1,ku,ten;
+  struct utf8_eucparam *p1 = (struct utf8_eucparam *) tab;
+  unsigned short *t1 = (unsigned short *) p1->tab;
+  for (ret->size = i = 0; i < text->size;) {
+    if ((c = text->data[i++]) & BIT8) {
+				/* special hack for GBK: 0x80 is Euro */
+      if ((c == 0x80) && (t1 == (unsigned short *) gb2312tab)) c = UCS2_EURO;
+      else c = ((i < text->size) && (c1 = text->data[i++]) &&
+		((ku = c - p1->base_ku) < p1->max_ku) &&
+		((ten = c1 - p1->base_ten) < p1->max_ten)) ?
+	     t1[(ku*p1->max_ten) + ten] : UBOGON;
+    }
+    UTF8_COUNT_BMP (ret->size,c,cv,de)
+  }
+  (s = ret->data = (unsigned char *) fs_get (ret->size + 1))[ret->size] = NIL;
+  for (i = 0; i < text->size;) {
+    if ((c = text->data[i++]) & BIT8) {
+				/* special hack for GBK: 0x80 is Euro */
+      if ((c == 0x80) && (t1 == (unsigned short *) gb2312tab)) c = UCS2_EURO;
+      else c = ((i < text->size) && (c1 = text->data[i++]) &&
+		((ku = c - p1->base_ku) < p1->max_ku) &&
+		((ten = c1 - p1->base_ten) < p1->max_ten)) ?
+	     t1[(ku*p1->max_ten) + ten] : UBOGON;
+    }
+    UTF8_WRITE_BMP (s,c,cv,de)	/* convert UCS-2 to UTF-8 */
+  }
+}
+
+/* Convert ASCII + double byte 2 plane sized text to UTF-8
+ * Accepts: source sized text
+ *	    pointer to return sized text
+ *	    conversion table
+ *	    canonicalization function
+ */
+
+void utf8_text_dbyte2 (SIZEDTEXT *text,SIZEDTEXT *ret,void *tab,ucs4cn_t cv,
+		       ucs4de_t de)
+{
+  unsigned long i;
+  unsigned char *s;
+  unsigned int c,c1,ku,ten;
+  struct utf8_eucparam *p1 = (struct utf8_eucparam *) tab;
+  struct utf8_eucparam *p2 = p1 + 1;
+  unsigned short *t = (unsigned short *) p1->tab;
+  for (ret->size = i = 0; i < text->size;) {
+    if ((c = text->data[i++]) & BIT8) {
+      if ((i >= text->size) || !(c1 = text->data[i++]))
+	c = UBOGON;		/* out of space or bogon */
+      else if (c1 & BIT8)	/* high vs. low plane */
+	c = ((ku = c - p2->base_ku) < p2->max_ku &&
+	     ((ten = c1 - p2->base_ten) < p2->max_ten)) ?
+	       t[(ku*(p1->max_ten + p2->max_ten)) + p1->max_ten + ten] :UBOGON;
+      else c = ((ku = c - p1->base_ku) < p1->max_ku &&
+		((ten = c1 - p1->base_ten) < p1->max_ten)) ?
+		  t[(ku*(p1->max_ten + p2->max_ten)) + ten] : UBOGON;
+    }
+    UTF8_COUNT_BMP (ret->size,c,cv,de)
+  }
+  (s = ret->data = (unsigned char *) fs_get (ret->size + 1))[ret->size] = NIL;
+  for (i = 0; i < text->size;) {
+    if ((c = text->data[i++]) & BIT8) {
+      if ((i >= text->size) || !(c1 = text->data[i++]))
+	c = UBOGON;		/* out of space or bogon */
+      else if (c1 & BIT8)	/* high vs. low plane */
+	c = ((ku = c - p2->base_ku) < p2->max_ku &&
+	     ((ten = c1 - p2->base_ten) < p2->max_ten)) ?
+	       t[(ku*(p1->max_ten + p2->max_ten)) + p1->max_ten + ten] :UBOGON;
+      else c = ((ku = c - p1->base_ku) < p1->max_ku &&
+		((ten = c1 - p1->base_ten) < p1->max_ten)) ?
+		  t[(ku*(p1->max_ten + p2->max_ten)) + ten] : UBOGON;
+    }
+    UTF8_WRITE_BMP (s,c,cv,de)	/* convert UCS-2 to UTF-8 */
+  }
+}
+
+#ifdef JISTOUNICODE		/* Japanese */
+/* Convert Shift JIS sized text to UTF-8
+ * Accepts: source sized text
+ *	    pointer to return sized text
+ *	    canonicalization function
+ */
+
+void utf8_text_sjis (SIZEDTEXT *text,SIZEDTEXT *ret,ucs4cn_t cv,
+		     ucs4de_t de)
+{
+  unsigned long i;
+  unsigned char *s;
+  unsigned int c,c1,ku,ten;
+  for (ret->size = i = 0; i < text->size;) {
+    if ((c = text->data[i++]) & BIT8) {
+				/* half-width katakana */
+      if ((c >= MIN_KANA_8) && (c < MAX_KANA_8)) c += KANA_8;
+      else if (i >= text->size) c = UBOGON;
+      else {			/* Shift-JIS */
+	c1 = text->data[i++];
+	SJISTOJIS (c,c1);
+	c = JISTOUNICODE (c,c1,ku,ten);
+      }
+    }
+				/* compromise - do yen sign but not overline */
+    else if (c == JISROMAN_YEN) c = UCS2_YEN;
+    UTF8_COUNT_BMP (ret->size,c,cv,de)
+  }
+  (s = ret->data = (unsigned char *) fs_get (ret->size + 1))[ret->size] = NIL;
+  for (i = 0; i < text->size;) {
+    if ((c = text->data[i++]) & BIT8) {
+				/* half-width katakana */
+      if ((c >= MIN_KANA_8) && (c < MAX_KANA_8)) c += KANA_8;
+      else {			/* Shift-JIS */
+	c1 = text->data[i++];
+	SJISTOJIS (c,c1);
+	c = JISTOUNICODE (c,c1,ku,ten);
+      }
+    }
+				/* compromise - do yen sign but not overline */
+    else if (c == JISROMAN_YEN) c = UCS2_YEN;
+    UTF8_WRITE_BMP (s,c,cv,de)	/* convert UCS-2 to UTF-8 */
+  }
+}
+#endif
+
+/* Convert ISO-2022 sized text to UTF-8
+ * Accepts: source sized text
+ *	    pointer to returned sized text
+ *	    canonicalization function
+ */
+
+void utf8_text_2022 (SIZEDTEXT *text,SIZEDTEXT *ret,ucs4cn_t cv,ucs4de_t de)
+{
+  unsigned long i;
+  unsigned char *s;
+  unsigned int pass,state,c,co,gi,gl,gr,g[4],ku,ten;
+  for (pass = 0,s = NIL,ret->size = 0; pass <= 1; pass++) {
+    gi = 0;			/* quell compiler warnings */
+    state = I2S_CHAR;		/* initialize engine */
+    g[0]= g[2] = I2CS_ASCII;	/* G0 and G2 are ASCII */
+    g[1]= g[3] = I2CS_ISO8859_1;/* G1 and G3 are ISO-8850-1 */
+    gl = I2C_G0; gr = I2C_G1;	/* left is G0, right is G1 */
+    for (i = 0; i < text->size;) {
+      c = text->data[i++];
+      switch (state) {		/* dispatch based upon engine state */
+      case I2S_ESC:		/* ESC seen */
+	switch (c) {		/* process intermediate character */
+	case I2C_MULTI:		/* multibyte character? */
+	  state = I2S_MUL;	/* mark multibyte flag seen */
+	  break;
+        case I2C_SS2:		/* single shift GL to G2 */
+	case I2C_SS2_ALT:	/* Taiwan SeedNet */
+	  gl |= I2C_SG2;
+	  break;
+        case I2C_SS3:		/* single shift GL to G3 */
+	case I2C_SS3_ALT:	/* Taiwan SeedNet */
+	  gl |= I2C_SG3;
+	  break;
+        case I2C_LS2:		/* shift GL to G2 */
+	  gl = I2C_G2;
+	  break;
+        case I2C_LS3:		/* shift GL to G3 */
+	  gl = I2C_G3;
+	  break;
+        case I2C_LS1R:		/* shift GR to G1 */
+	  gr = I2C_G1;
+	  break;
+        case I2C_LS2R:		/* shift GR to G2 */
+	  gr = I2C_G2;
+	  break;
+        case I2C_LS3R:		/* shift GR to G3 */
+	  gr = I2C_G3;
+	  break;
+	case I2C_G0_94: case I2C_G1_94: case I2C_G2_94:	case I2C_G3_94:
+	  g[gi = c - I2C_G0_94] = (state == I2S_MUL) ? I2CS_94x94 : I2CS_94;
+	  state = I2S_INT;	/* ready for character set */
+	  break;
+	case I2C_G0_96:	case I2C_G1_96: case I2C_G2_96:	case I2C_G3_96:
+	  g[gi = c - I2C_G0_96] = (state == I2S_MUL) ? I2CS_96x96 : I2CS_96;
+	  state = I2S_INT;	/* ready for character set */
+	  break;
+	default:		/* bogon */
+	  if (pass) *s++ = I2C_ESC,*s++ = c;
+	  else ret->size += 2;
+	  state = I2S_CHAR;	/* return to previous state */
+	}
+	break;
+
+      case I2S_MUL:		/* ESC $ */
+	switch (c) {		/* process multibyte intermediate character */
+	case I2C_G0_94: case I2C_G1_94: case I2C_G2_94:	case I2C_G3_94:
+	  g[gi = c - I2C_G0_94] = I2CS_94x94;
+	  state = I2S_INT;	/* ready for character set */
+	  break;
+	case I2C_G0_96:	case I2C_G1_96: case I2C_G2_96:	case I2C_G3_96:
+	  g[gi = c - I2C_G0_96] = I2CS_96x96;
+	  state = I2S_INT;	/* ready for character set */
+	  break;
+	default:		/* probably omitted I2CS_94x94 */
+	  g[gi = I2C_G0] = I2CS_94x94 | c;
+	  state = I2S_CHAR;	/* return to character state */
+	}
+	break;
+      case I2S_INT:
+	state = I2S_CHAR;	/* return to character state */
+	g[gi] |= c;		/* set character set */
+	break;
+
+      case I2S_CHAR:		/* character data */
+	switch (c) {
+	case I2C_ESC:		/* ESC character */
+	  state = I2S_ESC;	/* see if ISO-2022 prefix */
+	  break;
+	case I2C_SI:		/* shift GL to G0 */
+	  gl = I2C_G0;
+	  break;
+	case I2C_SO:		/* shift GL to G1 */
+	  gl = I2C_G1;
+	  break;
+        case I2C_SS2_ALT:	/* single shift GL to G2 */
+	case I2C_SS2_ALT_7:
+	  gl |= I2C_SG2;
+	  break;
+        case I2C_SS3_ALT:	/* single shift GL to G3 */
+	case I2C_SS3_ALT_7:
+	  gl |= I2C_SG3;
+	  break;
+
+	default:		/* ordinary character */
+	  co = c;		/* note original character */
+	  if (gl & (3 << 2)) {	/* single shifted? */
+	    gi = g[gl >> 2];	/* get shifted character set */
+	    gl &= 0x3;		/* cancel shift */
+	  }
+				/* select left or right half */
+	  else gi = (c & BIT8) ? g[gr] : g[gl];
+	  c &= BITS7;		/* make 7-bit */
+	  switch (gi) {		/* interpret in character set */
+	  case I2CS_ASCII:	/* ASCII */
+	    break;		/* easy! */
+	  case I2CS_BRITISH:	/* British ASCII */
+				/* Pound sterling sign */
+	    if (c == BRITISH_POUNDSTERLING) c = UCS2_POUNDSTERLING;
+	    break;
+	  case I2CS_JIS_ROMAN:	/* JIS Roman */
+	  case I2CS_JIS_BUGROM:	/* old bugs */
+	    switch (c) {	/* two exceptions to ASCII */
+	    case JISROMAN_YEN:	/* Yen sign */
+	      c = UCS2_YEN;
+	      break;
+				/* overline */
+	    case JISROMAN_OVERLINE:
+	      c = UCS2_OVERLINE;
+	      break;
+	    }
+	    break;
+	  case I2CS_JIS_KANA:	/* JIS hankaku katakana */
+	    if ((c >= MIN_KANA_7) && (c < MAX_KANA_7)) c += KANA_7;
+	    break;
+
+	  case I2CS_ISO8859_1:	/* Latin-1 (West European) */
+	    c |= BIT8;		/* just turn on high bit */
+	    break;
+	  case I2CS_ISO8859_2:	/* Latin-2 (Czech, Slovak) */
+	    c = iso8859_2tab[c];
+	    break;
+	  case I2CS_ISO8859_3:	/* Latin-3 (Dutch, Turkish) */
+	    c = iso8859_3tab[c];
+	    break;
+	  case I2CS_ISO8859_4:	/* Latin-4 (Scandinavian) */
+	    c = iso8859_4tab[c];
+	    break;
+	  case I2CS_ISO8859_5:	/* Cyrillic */
+	    c = iso8859_5tab[c];
+	    break;
+	  case I2CS_ISO8859_6:	/* Arabic */
+	    c = iso8859_6tab[c];
+	    break;
+	  case I2CS_ISO8859_7:	/* Greek */
+	    c = iso8859_7tab[c];
+	    break;
+	  case I2CS_ISO8859_8:	/* Hebrew */
+	    c = iso8859_8tab[c];
+	    break;
+	  case I2CS_ISO8859_9:	/* Latin-5 (Finnish, Portuguese) */
+	    c = iso8859_9tab[c];
+	    break;
+	  case I2CS_TIS620:	/* Thai */
+	    c = tis620tab[c];
+	    break;
+	  case I2CS_ISO8859_10:	/* Latin-6 (Northern Europe) */
+	    c = iso8859_10tab[c];
+	    break;
+	  case I2CS_ISO8859_13:	/* Latin-7 (Baltic) */
+	    c = iso8859_13tab[c];
+	    break;
+	  case I2CS_VSCII:	/* Vietnamese */
+	    c = visciitab[c];
+	    break;
+	  case I2CS_ISO8859_14:	/* Latin-8 (Celtic) */
+	    c = iso8859_14tab[c];
+	    break;
+	  case I2CS_ISO8859_15:	/* Latin-9 (Euro) */
+	    c = iso8859_15tab[c];
+	    break;
+	  case I2CS_ISO8859_16:	/* Latin-10 (Baltic) */
+	    c = iso8859_16tab[c];
+	    break;
+
+	  default:		/* all other character sets */
+				/* multibyte character set */
+	    if ((gi & I2CS_MUL) && !(c & BIT8) && isgraph (c)) {
+	      c = (i < text->size) ? text->data[i++] : 0;
+	      switch (gi) {
+#ifdef GBTOUNICODE
+	      case I2CS_GB:	/* GB 2312 */
+		co |= BIT8;	/* make into EUC */
+		c |= BIT8;
+		c = GBTOUNICODE (co,c,ku,ten);
+		break;
+#endif
+#ifdef JISTOUNICODE
+	      case I2CS_JIS_OLD:/* JIS X 0208-1978 */
+	      case I2CS_JIS_NEW:/* JIS X 0208-1983 */
+		c = JISTOUNICODE (co,c,ku,ten);
+		break;
+#endif
+#ifdef JIS0212TOUNICODE
+	      case I2CS_JIS_EXT:/* JIS X 0212-1990 */
+		c = JIS0212TOUNICODE (co,c,ku,ten);
+		break;
+#endif
+#ifdef KSCTOUNICODE
+	      case I2CS_KSC:	/* KSC 5601 */
+		co |= BIT8;	/* make into EUC */
+		c |= BIT8;
+		c = KSCTOUNICODE (co,c,ku,ten);
+		break;
+#endif
+#ifdef CNS1TOUNICODE
+	      case I2CS_CNS1:	/* CNS 11643 plane 1 */
+		c = CNS1TOUNICODE (co,c,ku,ten);
+		break;
+#endif
+#ifdef CNS2TOUNICODE
+	      case I2CS_CNS2:	/* CNS 11643 plane 2 */
+		c = CNS2TOUNICODE (co,c,ku,ten);
+		break;
+#endif
+#ifdef CNS3TOUNICODE
+	      case I2CS_CNS3:	/* CNS 11643 plane 3 */
+		c = CNS3TOUNICODE (co,c,ku,ten);
+		break;
+#endif
+#ifdef CNS4TOUNICODE
+	      case I2CS_CNS4:	/* CNS 11643 plane 4 */
+		c = CNS4TOUNICODE (co,c,ku,ten);
+		break;
+#endif
+#ifdef CNS5TOUNICODE
+	      case I2CS_CNS5:	/* CNS 11643 plane 5 */
+		c = CNS5TOUNICODE (co,c,ku,ten);
+		break;
+#endif
+#ifdef CNS6TOUNICODE
+	      case I2CS_CNS6:	/* CNS 11643 plane 6 */
+		c = CNS6TOUNICODE (co,c,ku,ten);
+		break;
+#endif
+#ifdef CNS7TOUNICODE
+	      case I2CS_CNS7:	/* CNS 11643 plane 7 */
+		c = CNS7TOUNICODE (co,c,ku,ten);
+		break;
+#endif
+	      default:		/* unknown multibyte, treat as UCS-2 */
+		c |= (co << 8);	/* wrong, but nothing else to do */
+		break;
+	      }
+	    }
+	    else c = co;	/* unknown single byte, treat as 8859-1 */
+	  }
+				/* convert if second pass */
+	  if (pass) UTF8_WRITE_BMP (s,c,cv,de)
+	  else UTF8_COUNT_BMP (ret->size,c,cv,de);
+	}
+      }
+    }
+    if (!pass) (s = ret->data = (unsigned char *)
+		fs_get (ret->size + 1))[ret->size] = NIL;
+    else if (((unsigned long) (s - ret->data)) != ret->size)
+      fatal ("ISO-2022 to UTF-8 botch");
+  }
+}
+
+/* Convert UTF-7 sized text to UTF-8
+ * Accepts: source sized text
+ *	    pointer to returned sized text
+ *	    canonicalization function
+ */
+
+void utf8_text_utf7 (SIZEDTEXT *text,SIZEDTEXT *ret,ucs4cn_t cv,ucs4de_t de)
+{
+  unsigned long i;
+  unsigned char *s;
+  unsigned int c,c1,d,uc,pass,e,e1,state,surrh;
+  for (pass = 0,s = NIL,ret->size = 0; pass <= 1; pass++) {
+    c1 = d = uc = e = e1 = 0;
+    for (i = 0,state = NIL; i < text->size;) {
+      c = text->data[i++];	/* get next byte */
+      switch (state) {
+      case U7_PLUS:		/* previous character was + */
+	if (c == '-') {		/* +- means textual + */
+	  c = '+';
+	  state = U7_ASCII;	/* revert to ASCII */
+	  break;
+	}
+	state = U7_UNICODE;	/* enter Unicode state */
+	e = e1 = 0;		/* initialize Unicode quantum position */
+      case U7_UNICODE:		/* Unicode state */
+	if (c == '-') state = U7_MINUS;
+	else {			/* decode Unicode */
+	  /* don't use isupper/islower since this is ASCII only */
+	  if ((c >= 'A') && (c <= 'Z')) c -= 'A';
+	  else if ((c >= 'a') && (c <= 'z')) c -= 'a' - 26;
+	  else if (isdigit (c)) c -= '0' - 52;
+	  else if (c == '+') c = 62;
+	  else if (c == '/') c = 63;
+	  else state = U7_ASCII;/* end of modified BASE64 */
+	}
+	break;
+      case U7_MINUS:		/* previous character was absorbed - */
+	state = U7_ASCII;	/* revert to ASCII */
+      case U7_ASCII:		/* ASCII state */
+	if (c == '+') state = U7_PLUS;
+	break;
+      }
+
+      switch (state) {		/* store character if in character mode */
+      case U7_UNICODE:		/* Unicode */
+	switch (e++) {		/* install based on BASE64 state */
+	case 0:
+	  c1 = c << 2;		/* byte 1: high 6 bits */
+	  break;
+	case 1:
+	  d = c1 | (c >> 4);	/* byte 1: low 2 bits */
+	  c1 = c << 4;		/* byte 2: high 4 bits */
+	  break;
+	case 2:
+	  d = c1 | (c >> 2);	/* byte 2: low 4 bits */
+	  c1 = c << 6;		/* byte 3: high 2 bits */
+	  break;
+	case 3:
+	  d = c | c1;		/* byte 3: low 6 bits */
+	  e = 0;		/* reinitialize mechanism */
+	  break;
+	}
+	if (e == 1) break;	/* done if first BASE64 state */
+	if (!e1) {		/* first byte of UCS-2 character */
+	  uc = (d & 0xff) << 8;	/* note first byte */
+	  e1 = T;		/* enter second UCS-2 state */
+	  break;		/* done */
+	}
+	c = uc | (d & 0xff);	/* build UCS-2 character */
+	e1 = NIL;		/* back to first UCS-2 state, drop in */
+				/* surrogate pair?  */
+	if ((c >= UTF16_SURR) && (c <= UTF16_MAXSURR)) {
+				/* save high surrogate for later */
+	  if (c < UTF16_SURRL) surrh = c;
+	  else c = UTF16_BASE + ((surrh & UTF16_MASK) << UTF16_SHIFT) +
+		 (c & UTF16_MASK);
+	  break;		/* either way with surrogates, we're done */
+	}
+      case U7_ASCII:		/* just install if ASCII */
+				/* convert if second pass */
+	if (pass) UTF8_WRITE_BMP (s,c,cv,de)
+	else UTF8_COUNT_BMP (ret->size,c,cv,de);
+      }
+    }
+    if (!pass) (s = ret->data = (unsigned char *)
+		fs_get (ret->size + 1))[ret->size] = NIL;
+    else if (((unsigned long) (s - ret->data)) != ret->size)
+      fatal ("UTF-7 to UTF-8 botch");
+  }
+}
+
+
+/* Convert UTF-8 sized text to UTF-8
+ * Accepts: source sized text
+ *	    pointer to returned sized text
+ *	    canonicalization function
+ */
+
+void utf8_text_utf8 (SIZEDTEXT *text,SIZEDTEXT *ret,ucs4cn_t cv,ucs4de_t de)
+{
+  unsigned long i,c;
+  unsigned char *s,*t;
+  for (ret->size = 0, t = text->data, i = text->size; i;) {
+    if ((c = utf8_get (&t,&i)) & U8G_ERROR) {
+      ret->data = text->data;	/* conversion failed */
+      ret->size = text->size;
+      return;
+    }
+    UTF8_COUNT (ret->size,c,cv,de)
+  }
+  (s = ret->data = (unsigned char *) fs_get (ret->size + 1))[ret->size] =NIL;
+  for (t = text->data, i = text->size; i;) {
+    c = utf8_get (&t,&i);
+    UTF8_WRITE (s,c,cv,de)	/* convert UCS-4 to UTF-8 */
+  }
+  if (((unsigned long) (s - ret->data)) != ret->size)
+    fatal ("UTF-8 to UTF-8 botch");
+}
+
+/* Convert UCS-2 sized text to UTF-8
+ * Accepts: source sized text
+ *	    pointer to returned sized text
+ *	    canonicalization function
+ */
+
+void utf8_text_ucs2 (SIZEDTEXT *text,SIZEDTEXT *ret,ucs4cn_t cv,ucs4de_t de)
+{
+  unsigned long i;
+  unsigned char *s,*t;
+  unsigned int c;
+  for (ret->size = 0, t = text->data, i = text->size / 2; i; --i) {
+    c = *t++ << 8;
+    c |= *t++;
+    UTF8_COUNT_BMP (ret->size,c,cv,de);
+  }
+  (s = ret->data = (unsigned char *) fs_get (ret->size + 1))[ret->size] = NIL;
+  for (t = text->data, i = text->size / 2; i; --i) {
+    c = *t++ << 8;
+    c |= *t++;
+    UTF8_WRITE_BMP (s,c,cv,de)	/* convert UCS-2 to UTF-8 */
+  }
+  if (((unsigned long) (s - ret->data)) != ret->size)
+    fatal ("UCS-2 to UTF-8 botch");
+}
+
+
+/* Convert UCS-4 sized text to UTF-8
+ * Accepts: source sized text
+ *	    pointer to returned sized text
+ *	    canonicalization function
+ */
+
+void utf8_text_ucs4 (SIZEDTEXT *text,SIZEDTEXT *ret,ucs4cn_t cv,ucs4de_t de)
+{
+  unsigned long i;
+  unsigned char *s,*t;
+  unsigned long c;
+  for (ret->size = 0, t = text->data, i = text->size / 4; i; --i) {
+    c = *t++ << 24; c |= *t++ << 16; c |= *t++ << 8; c |= *t++;
+    UTF8_COUNT (ret->size,c,cv,de);
+  }
+  (s = ret->data = (unsigned char *) fs_get (ret->size + 1))[ret->size] = NIL;
+  for (t = text->data, i = text->size / 2; i; --i) {
+    c = *t++ << 24; c |= *t++ << 16; c |= *t++ << 8; c |= *t++;
+    UTF8_WRITE (s,c,cv,de)	/* convert UCS-4 to UTF-8 */
+  }
+  if (((unsigned long) (s - ret->data)) != ret->size)
+    fatal ("UCS-4 to UTF-8 botch");
+}
+
+/* Convert UTF-16 sized text to UTF-8
+ * Accepts: source sized text
+ *	    pointer to returned sized text
+ *	    canonicalization function
+ */
+
+void utf8_text_utf16 (SIZEDTEXT *text,SIZEDTEXT *ret,ucs4cn_t cv,ucs4de_t de)
+{
+  unsigned long i;
+  unsigned char *s,*t;
+  unsigned long c,d;
+  for (ret->size = 0, t = text->data, i = text->size / 2; i; --i) {
+    c = *t++ << 8;
+    c |= *t++;
+				/* possible surrogate? */
+    if ((c >= UTF16_SURR) && (c <= UTF16_MAXSURR)) {
+				/* invalid first surrogate */
+      if ((c > UTF16_SURRHEND) || !i) c = UBOGON;
+      else {			/* get second surrogate */
+	d = *t++ << 8;
+	d |= *t++;
+	--i;			/* swallowed another 16-bits */
+				/* invalid second surrogate */
+	if ((d < UTF16_SURRL) || (d > UTF16_SURRLEND)) c = UBOGON;
+	else c = UTF16_BASE + ((c & UTF16_MASK) << UTF16_SHIFT) +
+	       (d & UTF16_MASK);
+      }
+    }
+    UTF8_COUNT (ret->size,c,cv,de);
+  }
+  (s = ret->data = (unsigned char *) fs_get (ret->size + 1))[ret->size] = NIL;
+  for (t = text->data, i = text->size / 2; i; --i) {
+    c = *t++ << 8;
+    c |= *t++;
+				/* possible surrogate? */
+    if ((c >= UTF16_SURR) && (c <= UTF16_MAXSURR)) {
+				/* invalid first surrogate */
+      if ((c > UTF16_SURRHEND) || !i) c = UBOGON;
+      else {			/* get second surrogate */
+	d = *t++ << 8;
+	d |= *t++;
+	--i;			/* swallowed another 16-bits */
+				/* invalid second surrogate */
+	if ((d < UTF16_SURRL) || (d > UTF16_SURRLEND)) c = UBOGON;
+	else c = UTF16_BASE + ((c & UTF16_MASK) << UTF16_SHIFT) +
+	       (d & UTF16_MASK);
+      }
+    }
+    UTF8_WRITE (s,c,cv,de)	/* convert UCS-4 to UTF-8 */
+  }
+  if (((unsigned long) (s - ret->data)) != ret->size)
+    fatal ("UTF-16 to UTF-8 botch");
+}
+
+/* Size of UCS-4 character, possibly not in BMP, as UTF-8 octets
+ * Accepts: character
+ * Returns: size (0 means bogon)
+ *
+ * Use UTF8_SIZE macro if known to be in the BMP
+ */
+
+unsigned long utf8_size (unsigned long c)
+{
+  if (c < 0x80) return 1;
+  else if (c < 0x800) return 2;
+  else if (c < 0x10000) return 3;
+  else if (c < 0x200000) return 4;
+  else if (c < 0x4000000) return 5;
+  else if (c < 0x80000000) return 6;
+  return 0;
+}
+
+
+/* Put UCS-4 character, possibly not in BMP, as UTF-8 octets
+ * Accepts: destination string pointer
+ *	    character
+ * Returns: updated destination pointer
+ *
+ * Use UTF8_PUT_BMP macro if known to be in the BMP
+ */
+
+unsigned char *utf8_put (unsigned char *s,unsigned long c)
+{
+  unsigned char mark[6] = {0x00,0xc0,0xe0,0xf0,0xf8,0xfc};
+  unsigned long size = utf8_size (c);
+  switch (size) {
+  case 6:
+    s[5] = 0x80 | (unsigned char) (c & 0x3f);
+    c >>= 6;
+  case 5:
+    s[4] = 0x80 | (unsigned char) (c & 0x3f);
+    c >>= 6;
+  case 4:
+    s[3] = 0x80 | (unsigned char) (c & 0x3f);
+    c >>= 6;
+  case 3:
+    s[2] = 0x80 | (unsigned char) (c & 0x3f);
+    c >>= 6;
+  case 2:
+    s[1] = 0x80 | (unsigned char) (c & 0x3f);
+    c >>= 6;
+  case 1:
+    *s = mark[size-1] | (unsigned char) (c & 0x7f);
+    break;
+  }
+  return s + size;
+}
+
+/* Return title case of a fixed-width UCS-4 character
+ * Accepts: character
+ * Returns: title case of character
+ */
+
+unsigned long ucs4_titlecase (unsigned long c)
+{
+  if (c <= UCS4_TMAPMAX) return ucs4_tmaptab[c];
+  if (c < UCS4_TMAPHIMIN) return c;
+  if (c <= UCS4_TMAPHIMAX) return c - UCS4_TMAPHIMAP;
+  if (c < UCS4_TMAPDESERETMIN) return c;
+  if (c <= UCS4_TMAPDESERETMAX) return c - UCS4_TMAPDESERETMAP;
+  return c;
+}
+
+
+/* Return width of a fixed-width UCS-4 character in planes 0-2
+ * Accepts: character
+ * Returns: width (0, 1, 2) or negative error condition if not valid
+ */
+
+long ucs4_width (unsigned long c)
+{
+  long ret;
+				/* out of range, not-a-char, or surrogates */
+  if ((c > UCS4_MAXUNICODE) || ((c & 0xfffe) == 0xfffe) ||
+      ((c >= UTF16_SURR) && (c <= UTF16_MAXSURR))) ret = U4W_NOTUNCD;
+				/* private-use */
+  else if (c >= UCS4_PVTBASE) ret = U4W_PRIVATE;
+				/* SSP are not printing characters */
+  else if (c >= UCS4_SSPBASE) ret = U4W_SSPCHAR;
+				/* unassigned planes */
+  else if (c >= UCS4_UNABASE) ret = U4W_UNASSGN;
+				/* SIP and reserved plane 3 are wide */
+  else if (c >= UCS4_SIPBASE) ret = 2;
+#if (UCS4_WIDLEN != UCS4_SIPBASE)
+#error "UCS4_WIDLEN != UCS4_SIPBASE"
+#endif
+				/* C0/C1 controls */
+  else if ((c <= UCS2_C0CONTROLEND) ||
+	   ((c >= UCS2_C1CONTROL) && (c <= UCS2_C1CONTROLEND)))
+    ret = U4W_CONTROL;
+				/* BMP and SMP get value from table */
+  else switch (ret = (ucs4_widthtab[(c >> 2)] >> ((3 - (c & 0x3)) << 1)) &0x3){
+  case 0:			/* zero-width */
+    if (c == 0x00ad) ret = 1;	/* force U+00ad (SOFT HYPHEN) to width 1 */
+  case 1:			/* single-width */
+  case 2:			/* double-width */
+    break;
+  case 3:			/* ambiguous width */
+    ret = (c >= 0x2100) ? 2 : 1;/* need to do something better than this */
+    break;
+  }
+  return ret;
+}
+
+/* Return screen width of UTF-8 string
+ * Accepts: string
+ * Returns: width or negative if not valid UTF-8
+ */
+
+long utf8_strwidth (unsigned char *s)
+{
+  unsigned long c,i,ret;
+				/* go through string */
+  for (ret = 0; *s; ret += ucs4_width (c)) {
+    /* It's alright to give a fake value for the byte count to utf8_get()
+     * since the null of a null-terminated string will stop processing anyway.
+     */
+    i = 6;			/* fake value */
+    if ((c = utf8_get (&s,&i)) & U8G_ERROR) return -1;
+  }
+  return ret;
+}
+
+
+/* Return screen width of UTF-8 text
+ * Accepts: SIZEDTEXT to string
+ * Returns: width or negative if not valid UTF-8
+ */
+
+long utf8_textwidth (SIZEDTEXT *utf8)
+{
+  unsigned long c;
+  unsigned char *s = utf8->data;
+  unsigned long i = utf8->size;
+  unsigned long ret = 0;
+  while (i) {			/* while there's a string to process */
+    if ((c = utf8_get (&s,&i)) & U8G_ERROR) return -1;
+    ret += ucs4_width (c);
+  }
+  return ret;
+}
+
+/* Decomposition (phew!) */
+
+#define MORESINGLE 1		/* single UCS-4 tail value */
+#define MOREMULTIPLE 2		/* multiple UCS-2 tail values */
+
+struct decomposemore {
+  short type;			/* type of more */
+  union {
+    unsigned long single;	/* single decomposed value */
+    struct {			/* multiple BMP values */
+      unsigned short *next;
+      unsigned long count;
+    } multiple;
+  } data;
+};
+
+#define RECURSIVEMORE struct recursivemore
+
+RECURSIVEMORE {
+  struct decomposemore *more;
+  RECURSIVEMORE *next;
+};
+
+
+/* Return decomposition of a UCS-4 character
+ * Accepts: character or U8G_ERROR to return next from "more"
+ *	    pointer to returned more
+ * Returns: [next] decomposed value, more set if still more decomposition
+ */
+
+unsigned long ucs4_decompose (unsigned long c,void **more)
+{
+  unsigned long i,ix,ret;
+  struct decomposemore *m;
+  if (c & U8G_ERROR) {		/* want to chase more? */
+				/* do sanity check */
+    if (m = (struct decomposemore *) *more) switch (m->type) {
+    case MORESINGLE:		/* single value */
+      ret = m->data.single;
+      fs_give (more);		/* no more decomposition */
+      break;
+    case MOREMULTIPLE:		/* multiple value */
+      ret = *m->data.multiple.next++;
+      if (!--m->data.multiple.count) fs_give (more);
+      break;
+    default:			/* uh-oh */
+      fatal ("invalid more block argument to ucs4_decompose!");
+    }
+    else fatal ("no more block provided to ucs4_decompose!");
+  }
+
+  else {			/* start decomposition */
+    *more = NIL;		/* initially set no more */
+				/* BMP low decompositions */
+    if (c < UCS4_BMPLOMIN) ret = c;
+				/* fix this someday */
+    else if (c == UCS4_BMPLOMIN) ret = ucs4_dbmplotab[0];
+    else if (c <= UCS4_BMPLOMAX) {
+				/* within range - have a decomposition? */
+      if (i = ucs4_dbmploixtab[c - UCS4_BMPLOMIN]) {
+				/* get first value of decomposition */
+	ret = ucs4_dbmplotab[ix = i & UCS4_BMPLOIXMASK];
+				/* has continuation? */
+	if (i & UCS4_BMPLOSIZEMASK) {
+	  m = (struct decomposemore *)
+	    (*more = memset (fs_get (sizeof (struct decomposemore)),0,
+			    sizeof (struct decomposemore)));
+	  m->type = MOREMULTIPLE;
+	  m->data.multiple.next = &ucs4_dbmplotab[++ix];
+	  m->data.multiple.count = i >> UCS4_BMPLOSIZESHIFT;
+	}
+      }
+      else ret = c;		/* in range but doesn't decompose */
+    }
+				/* BMP CJK compatibility */
+    else if (c < UCS4_BMPCJKMIN) ret = c;
+    else if (c <= UCS4_BMPCJKMAX) {
+      if (!(ret = ucs4_bmpcjk1decomptab[c - UCS4_BMPCJKMIN])) ret = c;
+    }
+				/* BMP CJK compatibility - some not in BMP */
+#if UCS4_BMPCJK2MIN - (UCS4_BMPCJKMAX + 1)
+    else if (c < UCS4_BMPCJK2MIN) ret = c;
+#endif
+    else if (c <= UCS4_BMPCJK2MAX)
+      ret = ucs4_bmpcjk2decomptab[c - UCS4_BMPCJK2MIN];
+				/* BMP high decompositions */
+    else if (c < UCS4_BMPHIMIN) ret = c;
+    else if (c <= UCS4_BMPHIMAX) {
+				/* within range - have a decomposition? */
+      if (i = ucs4_dbmphiixtab[c - UCS4_BMPHIMIN]) {
+				/* get first value of decomposition */
+	ret = ucs4_dbmphitab[ix = i & UCS4_BMPHIIXMASK];
+				/* has continuation? */
+	if (i & UCS4_BMPHISIZEMASK) {
+	  m = (struct decomposemore *)
+	    (*more = memset (fs_get (sizeof (struct decomposemore)),0,
+			    sizeof (struct decomposemore)));
+	  m->type = MOREMULTIPLE;
+	  m->data.multiple.next = &ucs4_dbmphitab[++ix];
+	  m->data.multiple.count = i >> UCS4_BMPHISIZESHIFT;
+	}
+      }
+      else ret = c;		/* in range but doesn't decompose */
+    }
+
+				/* BMP half and full width forms */
+    else if (c < UCS4_BMPHALFFULLMIN) ret = c;
+    else if (c <= UCS4_BMPHALFFULLMAX) {
+      if (!(ret = ucs4_bmphalffulldecomptab[c - UCS4_BMPHALFFULLMIN])) ret = c;
+    }
+				/* SMP music */
+    else if (c < UCS4_SMPMUSIC1MIN) ret = c;
+    else if (c <= UCS4_SMPMUSIC1MAX) {
+      ret = ucs4_smpmusic1decomptab[c -= UCS4_SMPMUSIC1MIN][0];
+      m = (struct decomposemore *)
+	(*more = memset (fs_get (sizeof (struct decomposemore)),0,
+			 sizeof (struct decomposemore)));
+      m->type = MORESINGLE;
+      m->data.single = ucs4_smpmusic1decomptab[c][1];
+    }
+    else if (c < UCS4_SMPMUSIC2MIN) ret = c;
+    else if (c <= UCS4_SMPMUSIC2MAX) {
+      ret = ucs4_smpmusic2decomptab[c -= UCS4_SMPMUSIC2MIN][0];
+      m = (struct decomposemore *)
+	(*more = memset (fs_get (sizeof (struct decomposemore)),0,
+			 sizeof (struct decomposemore)));
+      m->type = MORESINGLE;
+      m->data.single = ucs4_smpmusic2decomptab[c][1];
+    }
+				/* SMP mathematical forms */
+    else if (c < UCS4_SMPMATHMIN) ret = c;
+    else if (c <= UCS4_SMPMATHMAX) {
+      if (!(ret = ucs4_smpmathdecomptab[c - UCS4_SMPMATHMIN])) ret = c;
+    }
+				/* CJK compatibility ideographs in SIP */
+    else if (!(ret = ((c >= UCS4_SIPMIN) && (c <= UCS4_SIPMAX)) ?
+	       ucs4_sipdecomptab[c - UCS4_SIPMIN] : c)) ret = c;
+  }
+  return ret;
+}
+
+/* Return recursive decomposition of a UCS-4 character
+ * Accepts: character or U8G_ERROR to return next from "more"
+ *	    pointer to returned more
+ * Returns: [next] decomposed value, more set if still more decomposition
+ */
+
+unsigned long ucs4_decompose_recursive (unsigned long c,void **more)
+{
+  unsigned long c1;
+  void *m,*mn;
+  RECURSIVEMORE *mr;
+  if (c & U8G_ERROR) {		/* want to chase more? */
+    mn = NIL;
+    if (mr = (RECURSIVEMORE *) *more) switch (mr->more->type) {
+    case MORESINGLE:		/* decompose single value */
+      c = ucs4_decompose_recursive (mr->more->data.single,&mn);
+      *more = mr->next;		/* done with this more, remove it */
+      fs_give ((void **) &mr->more);
+      fs_give ((void **) &mr);
+      break;
+    case MOREMULTIPLE:		/* decompose current value in multiple */
+      c = ucs4_decompose_recursive (*mr->more->data.multiple.next++,&mn);
+				/* if done with this multiple decomposition */
+      if (!--mr->more->data.multiple.count) {
+	*more = mr->next;	/* done with this more, remove it */
+	fs_give ((void **) &mr->more);
+	fs_give ((void **) &mr);
+      }
+      break;
+    default:			/* uh-oh */
+      fatal ("invalid more block argument to ucs4_decompose_recursive!");
+    }
+    else fatal ("no more block provided to ucs4_decompose_recursive!");
+    if (mr = mn) {		/* did this value recurse on us? */
+      mr->next = *more;		/* yes, insert new more at head */
+      *more = mr;
+    }
+  }
+  else {			/* start decomposition */
+    *more = NIL;		/* initially set no more */
+    mr = NIL;
+    do {			/* repeatedly decompose this codepoint */
+      c = ucs4_decompose (c1 = c,&m);
+      if (m) {			/* multi-byte decomposition */
+	if (c1 == c) fatal ("endless multiple decomposition!");
+				/* create a block to stash this more */
+	mr = memset (fs_get (sizeof (RECURSIVEMORE)),0,sizeof (RECURSIVEMORE));
+	mr->more = m;		/* note the expansion */
+	mr->next = *more;	/* old list is the tail */
+	*more = mr;		/* and this is the new head */
+      }
+    } while (c1 != c);		/* until nothing more to decompose */
+  }
+  return c;
+}
diff --git a/imap/src/c-client/utf8.h b/imap/src/c-client/utf8.h
new file mode 100644
index 00000000..105f856d
--- /dev/null
+++ b/imap/src/c-client/utf8.h
@@ -0,0 +1,584 @@
+/* ========================================================================
+ * 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:	UTF-8 routines
+ *
+ * Author:	Mark Crispin
+ *		Networks and Distributed Computing
+ *		Computing & Communications
+ *		University of Washington
+ *		Administration Building, AG-44
+ *		Seattle, WA  98195
+ *		Internet: MRC@CAC.Washington.EDU
+ *
+ * Date:	11 June 1997
+ * Last Edited:	17 January 2008
+ */
+
+/* UTF-8 size and conversion routines from UCS-2 values (thus in the BMP).
+ * Don't use these if UTF-16 data (surrogate pairs) are an issue.
+ * For UCS-4 values, use the utf8_size() and utf8_put() functions.
+ */
+
+#define UTF8_SIZE_BMP(c) ((c & 0xff80) ? ((c & 0xf800) ? 3 : 2) : 1)
+
+#define UTF8_PUT_BMP(b,c) {				\
+  if (c & 0xff80) {		/* non-ASCII? */	\
+    if (c & 0xf800) {		/* three byte code */	\
+      *b++ = 0xe0 | (c >> 12);				\
+      *b++ = 0x80 | ((c >> 6) & 0x3f);			\
+    }							\
+    else *b++ = 0xc0 | ((c >> 6) & 0x3f);		\
+    *b++ = 0x80 | (c & 0x3f); 				\
+  }							\
+  else *b++ = c;					\
+}
+
+/* utf8_text() flag values */
+
+#define U8T_CASECANON 2		/* canonicalize case */
+#define U8T_DECOMPOSE 4		/* decompose */
+				/* full canonicalization */
+#define U8T_CANONICAL (U8T_CASECANON | U8T_DECOMPOSE)
+
+
+/* utf8_get() return values */
+
+				/* 0x0000 - 0xffff BMP plane */
+#define U8GM_NONBMP 0xffff0000	/* mask for non-BMP values */
+				/* 0x10000 - 0x10ffff extended planes */
+				/* 0x110000 - 0x7ffffff non-Unicode */
+#define U8G_ERROR 0x80000000	/* error flag */
+#define U8G_BADCONT U8G_ERROR+1	/* continuation when not in progress */
+#define U8G_INCMPLT U8G_ERROR+2	/* incomplete UTF-8 character */
+#define U8G_NOTUTF8 U8G_ERROR+3	/* not a valid UTF-8 octet */
+#define U8G_ENDSTRG U8G_ERROR+4	/* end of string */
+#define U8G_ENDSTRI U8G_ERROR+5	/* end of string w/ incomplete UTF-8 char */
+#define U8G_SURROGA U8G_ERROR+6	/* surrogate codepoint */
+#define U8G_NOTUNIC U8G_ERROR+7	/* non-Unicode codepoint */
+
+
+/* ucs4_width() return values */
+
+#define U4W_ERROR 0x80000000	/* error flags */
+#define U4W_NOTUNCD U4W_ERROR+1	/* not a Unicode char */
+#define U4W_PRIVATE U4W_ERROR+2	/* private-space plane */
+#define U4W_SSPCHAR U4W_ERROR+3	/* Supplementary Special-purpose Plane */
+#define U4W_UNASSGN U4W_ERROR+4	/* unassigned space plane */
+#define U4W_CONTROL U4W_ERROR+5	/* C0/C1 control */
+#define U4W_CTLSRGT U4W_CONTROL	/* in case legacy code references this */
+
+/* ISO-2022 engine states */
+
+#define I2S_CHAR 0		/* character */
+#define I2S_ESC 1		/* previous character was ESC */
+#define I2S_MUL 2		/* previous character was multi-byte code */
+#define I2S_INT 3		/* previous character was intermediate */
+
+
+/* ISO-2022 Gn selections */
+
+#define I2C_G0 0		/* G0 */
+#define I2C_G1 1		/* G1 */
+#define I2C_G2 2		/* G2 */
+#define I2C_G3 3		/* G3 */
+#define I2C_SG2 (2 << 2)	/* single shift G2 */
+#define I2C_SG3 (3 << 2)	/* single shift G2 */
+
+
+/* ISO-2022 octet definitions */
+
+#define I2C_ESC 0x1b		/* ESCape */
+
+	/* Intermediate character */
+#define I2C_STRUCTURE 0x20	/* announce code structure */
+#define I2C_C0 0x21		/* C0 */
+#define I2C_C1 0x22		/* C1 */
+#define I2C_CONTROL 0x23	/* single control function */
+#define I2C_MULTI 0x24		/* multi-byte character set */
+#define I2C_OTHER 0x25		/* other coding system */
+#define I2C_REVISED 0x26	/* revised registration */
+#define I2C_G0_94 0x28		/* G0 94-character set */
+#define I2C_G1_94 0x29		/* G1 94-character set */
+#define I2C_G2_94 0x2A		/* G2 94-character set */
+#define I2C_G3_94 0x2B		/* G3 94-character set */
+#define I2C_G0_96 0x2C		/* (not in ISO-2022) G0 96-character set */
+#define I2C_G1_96 0x2D		/* G1 96-character set */
+#define I2C_G2_96 0x2E		/* G2 96-character set */
+#define I2C_G3_96 0x2F		/* G3 96-character set */
+
+	/* Locking shifts */
+#define I2C_SI 0x0f		/* lock shift to G0 (Shift In) */
+#define I2C_SO 0x0e		/* lock shift to G1 (Shift Out) */
+	/* prefixed by ESC */
+#define I2C_LS2 0x6e		/* lock shift to G2 */
+#define I2C_LS3 0x6f		/* lock shift to G3 */
+#define I2C_LS1R 0x7e		/* lock shift GR to G1 */
+#define I2C_LS2R 0x7d		/* lock shift GR to G2 */
+#define I2C_LS3R 0x7c		/* lock shift GR to G3 */
+
+	/* Single shifts */
+#define I2C_SS2_ALT 0x8e	/* single shift to G2 (SS2) */
+#define I2C_SS3_ALT 0x8f	/* single shift to G3 (SS3) */
+#define I2C_SS2_ALT_7 0x19	/* single shift to G2 (SS2) */
+#define I2C_SS3_ALT_7 0x1d	/* single shift to G3 (SS3) */
+	/* prefixed by ESC */
+#define I2C_SS2 0x4e		/* single shift to G2 (SS2) */
+#define I2C_SS3 0x4f		/* single shift to G3 (SS3) */
+
+/* 94 character sets */
+
+				/* 4/0 ISO 646 IRV */
+#define I2CS_94_BRITISH 0x41	/* 4/1 ISO 646 British */
+#define I2CS_94_ASCII 0x42	/* 4/2 ISO 646 USA (ASCII) */
+				/* 4/3 NATS Finland/Sweden (primary) */
+				/* 4/4 NATS Finland/Sweden (secondary) */
+				/* 4/5 NATS Denmark/Norway (primary) */
+				/* 4/6 NATS Denmark/Norway (secondary) */
+				/* 4/7 ISO 646 Swedish SEN 850200 */
+				/* 4/8 ISO 646 Swedish names */
+#define I2CS_94_JIS_BUGROM 0x48	/* 4/8 some buggy software does this */
+#define I2CS_94_JIS_KANA 0x49	/* 4/9 JIS X 0201-1976 right half */
+#define I2CS_94_JIS_ROMAN 0x4a	/* 4/a JIS X 0201-1976 left half */
+				/* 4/b ISO 646 German */
+				/* 4/c ISO 646 Portuguese (Olivetti) */
+				/* 4/d ISO 6438 African */
+				/* 4/e ISO 5427 Cyrillic (Honeywell-Bull) */
+				/* 4/f DIN 31624 extended bibliography  */
+				/* 5/0 ISO 5426-1980 Bibliography */
+				/* 5/1 ISO 5427-1981 Cyrillic*/
+				/* 5/2 ISO 646 French (withdrawn) */
+				/* 5/3 ISO 5428-1980 Greek bibliography */
+				/* 5/4 GB 1988-80 Chinese */
+				/* 5/5 Latin-Greek (Honeywell-Bull) */
+				/* 5/6 UK Viewdata/Teletext */
+				/* 5/7 INIS (IRV subset) */
+				/* 5/8 ISO 5428 Greek Bibliography */
+				/* 5/9 ISO 646 Italian (Olivetti) */
+				/* 5/a ISO 646 Spanish (Olivetti) */
+				/* 5/b Greek (Olivetti) */
+				/* 5/c Latin-Greek (Olivetti) */
+				/* 5/d INIS non-standard extension */
+				/* 5/e INIS Cyrillic extension */
+				/* 5/f Arabic CODAR-U IERA */
+				/* 6/0 ISO 646 Norwegian */
+				/* 6/1 Norwegian version 2 (withdrawn) */
+				/* 6/2 Videotex supplementary */
+				/* 6/3 Videotex supplementary #2 */
+				/* 6/4 Videotex supplementary #3 */
+				/* 6/5 APL */
+				/* 6/6 ISO 646 French */
+				/* 6/7 ISO 646 Portuguese (IBM) */
+				/* 6/8 ISO 646 Spanish (IBM) */
+				/* 6/9 ISO 646 Hungarian */
+				/* 6/a Greek ELOT (withdrawn) */
+				/* 6/b ISO 9036 Arabic 7-bit */
+				/* 6/c ISO 646 IRV supplementary set */
+				/* 6/d JIS C6229-1984 OCR-A */
+				/* 6/e JIS C6229-1984 OCR-B */
+				/* 6/f JIS C6229-1984 OCR-B additional */
+				/* 7/0 JIS C6229-1984 hand-printed */
+				/* 7/1 JIS C6229-1984 additional hand-printd */
+				/* 7/2 JIS C6229-1984 katakana hand-printed */
+				/* 7/3 E13B Japanese graphic */
+				/* 7/4 Supplementary Videotex (withdrawn) */
+				/* 7/5 Teletex primary CCITT T.61 */
+				/* 7/6 Teletex secondary CCITT T.61 */
+				/* 7/7 CSA Z 243.4-1985 Alternate primary #1 */
+				/* 7/8 CSA Z 243.4-1985 Alternate primary #2 */
+				/* 7/9 Mosaic CCITT T.101 */
+				/* 7/a Serbocroatian/Slovenian Latin */
+				/* 7/b Serbocroatian Cyrillic */
+				/* 7/c Supplementary CCITT T.101 */
+				/* 7/d Macedonian Cyrillic */
+
+/* 94 character sets - second intermediate byte */
+
+				/* 4/0 Greek primary CCITT */
+				/* 4/1 Cuba */
+				/* 4/2 ISO/IEC 646 invariant */
+				/* 4/3 Irish Gaelic 7-bit */
+				/* 4/4 Turkmen */
+
+
+/* 94x94 character sets */
+
+#define I2CS_94x94_JIS_OLD 0x40	/* 4/0 JIS X 0208-1978 */
+#define I2CS_94x94_GB 0x41	/* 4/1 GB 2312 */
+#define I2CS_94x94_JIS_NEW 0x42	/* 4/2 JIS X 0208-1983 */
+#define I2CS_94x94_KSC 0x43	/* 4/3 KSC 5601 */
+#define I2CS_94x94_JIS_EXT 0x44	/* 4/4 JIS X 0212-1990 */
+				/* 4/5 CCITT Chinese */
+				/* 4/6 Blisssymbol Graphic */
+#define I2CS_94x94_CNS1 0x47	/* 4/7 CNS 11643 plane 1 */
+#define I2CS_94x94_CNS2 0x48	/* 4/8 CNS 11643 plane 2 */
+#define I2CS_94x94_CNS3 0x49	/* 4/9 CNS 11643 plane 3 */
+#define I2CS_94x94_CNS4 0x4a	/* 4/a CNS 11643 plane 4 */
+#define I2CS_94x94_CNS5 0x4b	/* 4/b CNS 11643 plane 5 */
+#define I2CS_94x94_CNS6 0x4c	/* 4/c CNS 11643 plane 6 */
+#define I2CS_94x94_CNS7 0x4d	/* 4/d CNS 11643 plane 7 */
+				/* 4/e DPRK (North Korea) KGCII */
+				/* 4/f JGCII plane 1 */
+				/* 5/0 JGCII plane 2 */
+
+/* 96 character sets */
+
+#define I2CS_96_ISO8859_1 0x41	/* 4/1 Latin-1 (Western Europe) */
+#define I2CS_96_ISO8859_2 0x42	/* 4/2 Latin-2 (Czech, Slovak) */
+#define I2CS_96_ISO8859_3 0x43	/* 4/3 Latin-3 (Dutch, Turkish) */
+#define I2CS_96_ISO8859_4 0x44	/* 4/4 Latin-4 (Scandinavian) */
+				/* 4/5 CSA Z 243.4-1985 */
+#define I2CS_96_ISO8859_7 0x46	/* 4/6 Greek */
+#define I2CS_96_ISO8859_6 0x47	/* 4/7 Arabic */
+#define I2CS_96_ISO8859_8 0x48	/* 4/8 Hebrew */
+				/* 4/9 Czechoslovak CSN 369103 */
+				/* 4/a Supplementary Latin and non-alpha */
+				/* 4/b Technical */
+#define I2CS_96_ISO8859_5 0x4c	/* 4/c Cyrillic */
+#define I2CS_96_ISO8859_9 0x4d	/* 4/d Latin-5 (Finnish, Portuguese) */
+				/* 4/e ISO 6937-2 residual */
+				/* 4/f Basic Cyrillic */
+				/* 5/0 Supplementary Latin 1, 2 and 5 */
+				/* 5/1 Basic Box */
+				/* 5/2 Supplementary ISO/IEC 6937 : 1992 */
+				/* 5/3 CCITT Hebrew supplementary */
+#define I2CS_96_TIS620 0x54	/* 5/4 TIS 620 */
+				/* 5/5 Arabic/French/German */
+#define I2CS_96_ISO8859_10 0x56	/* 5/6 Latin-6 (Northern Europe) */
+				/* 5/7 ??? */
+				/* 5/8 Sami (Lappish) supplementary */
+#define I2CS_96_ISO8859_13 0x59	/* 5/9 Latin-7 (Baltic) */
+#define I2CS_96_VSCII 0x5a	/* 5/a Vietnamese */
+				/* 5/b Technical #1 IEC 1289 */
+#define I2CS_96_ISO8859_14 0x5c	/* 5/c Latin-8 (Celtic) */
+				/* 5/d Sami supplementary Latin */
+				/* 5/e Latin/Hebrew */
+				/* 5/f Celtic supplementary Latin */
+				/* 6/0 Uralic supplementary Cyrillic */
+				/* 6/1 Volgaic supplementary Cyrillic */
+#define I2CS_96_ISO8859_15 0x62	/* 6/2 Latin-9 (Euro) */
+				/* 6/3 Latin-1 with Euro */
+				/* 6/4 Latin-4 with Euro */
+				/* 6/5 Latin-7 with Euro */
+#define I2CS_96_ISO8859_16 0x66	/* 6/6 Latin-10 (Balkan) */
+				/* 6/7 Ogham */
+				/* 6/8 Sami supplementary Latin #2 */
+				/* 7/d Supplementary Mosaic for CCITT 101 */
+
+/* 96x96 character sets */
+
+/* Types of character sets */
+
+#define I2CS_94 0x000		/* 94 character set */
+#define I2CS_96 0x100		/* 96 character set */
+#define I2CS_MUL 0x200		/* multi-byte */
+#define I2CS_94x94 (I2CS_MUL | I2CS_94)
+#define I2CS_96x96 (I2CS_MUL | I2CS_96)
+
+
+/* Character set identifiers stored in Gn */
+
+#define I2CS_BRITISH (I2CS_94 | I2CS_94_BRITISH)
+#define I2CS_ASCII (I2CS_94 | I2CS_94_ASCII)
+#define I2CS_JIS_BUGROM (I2CS_94 | I2CS_94_JIS_BUGROM)
+#define I2CS_JIS_KANA (I2CS_94 | I2CS_94_JIS_KANA)
+#define I2CS_JIS_ROMAN (I2CS_94 | I2CS_94_JIS_ROMAN)
+#define I2CS_JIS_OLD (I2CS_94x94 | I2CS_94x94_JIS_OLD)
+#define I2CS_GB (I2CS_94x94 | I2CS_94x94_GB)
+#define I2CS_JIS_NEW (I2CS_94x94 | I2CS_94x94_JIS_NEW)
+#define I2CS_KSC (I2CS_94x94 | I2CS_94x94_KSC)
+#define I2CS_JIS_EXT (I2CS_94x94 | I2CS_94x94_JIS_EXT)
+#define I2CS_CNS1 (I2CS_94x94 | I2CS_94x94_CNS1)
+#define I2CS_CNS2 (I2CS_94x94 | I2CS_94x94_CNS2)
+#define I2CS_CNS3 (I2CS_94x94 | I2CS_94x94_CNS3)
+#define I2CS_CNS4 (I2CS_94x94 | I2CS_94x94_CNS4)
+#define I2CS_CNS5 (I2CS_94x94 | I2CS_94x94_CNS5)
+#define I2CS_CNS6 (I2CS_94x94 | I2CS_94x94_CNS6)
+#define I2CS_CNS7 (I2CS_94x94 | I2CS_94x94_CNS7)
+#define I2CS_ISO8859_1 (I2CS_96 | I2CS_96_ISO8859_1)
+#define I2CS_ISO8859_2 (I2CS_96 | I2CS_96_ISO8859_2)
+#define I2CS_ISO8859_3 (I2CS_96 | I2CS_96_ISO8859_3)
+#define I2CS_ISO8859_4 (I2CS_96 | I2CS_96_ISO8859_4)
+#define I2CS_ISO8859_7 (I2CS_96 | I2CS_96_ISO8859_7)
+#define I2CS_ISO8859_6 (I2CS_96 | I2CS_96_ISO8859_6)
+#define I2CS_ISO8859_8 (I2CS_96 | I2CS_96_ISO8859_8)
+#define I2CS_ISO8859_5 (I2CS_96 | I2CS_96_ISO8859_5)
+#define I2CS_ISO8859_9 (I2CS_96 | I2CS_96_ISO8859_9)
+#define I2CS_TIS620 (I2CS_96 | I2CS_96_TIS620)
+#define I2CS_ISO8859_10 (I2CS_96 | I2CS_96_ISO8859_10)
+#define I2CS_ISO8859_13 (I2CS_96 | I2CS_96_ISO8859_13)
+#define I2CS_VSCII (I2CS_96 | I2CS_96_VSCII)
+#define I2CS_ISO8859_14 (I2CS_96 | I2CS_96_ISO8859_14)
+#define I2CS_ISO8859_15 (I2CS_96 | I2CS_96_ISO8859_15)
+#define I2CS_ISO8859_16 (I2CS_96 | I2CS_96_ISO8859_16)
+
+
+/* Miscellaneous ISO 2022 definitions */
+
+#define EUC_CS2 0x8e		/* single shift CS2 */
+#define EUC_CS3 0x8f		/* single shift CS3 */
+
+#define BITS7 0x7f		/* 7-bit value mask */
+#define BIT8 0x80		/* 8th bit mask */
+
+/* The following saves us from having to have yet more charset tables */
+
+/* Unicode codepoints */
+
+#define UCS2_C0CONTROL 0x00	/* first C0 control */
+#define UCS2_C0CONTROLEND 0x1F	/* last C0 control */
+#define UCS2_C1CONTROL 0x80	/* first C1 control */
+#define UCS2_C1CONTROLEND 0x9F	/* last C1 control */
+
+				/* ISO 646 substituted Unicode codepoints */
+#define UCS2_POUNDSTERLING 0x00a3
+#define UCS2_YEN 0x00a5
+#define UCS2_OVERLINE 0x203e
+#define UCS2_EURO 0x20ac
+#define UCS2_KATAKANA 0xff61	/* first katakana codepoint */
+#define UCS2_BOM 0xfeff		/* byte order mark */
+#define UCS2_BOGON 0xfffd	/* replacement character */
+				/* next two codepoints are not Unicode chars */
+#define UCS2_BOMCHECK 0xfffe	/* used to check byte order with UCS2_BOM */
+#define UCS2_NOTCHAR 0xffff	/* not a character */
+
+#define UCS4_BMPBASE 0x0000	/* Basic Multilingual Plane */
+#define UCS4_SMPBASE 0x10000	/* Supplementary Multilinugual Plane */
+#define UCS4_SIPBASE 0x20000	/* Supplementary Ideographic Plane */
+				/* EastAsianWidth says plane 3 is wide */
+#define UCS4_UNABASE 0x40000	/* unassigned space */
+#define UCS4_SSPBASE 0xe0000	/* Supplementary Special-purpose Plane */
+#define UCS4_PVTBASE 0xf0000	/* private-space (two planes) */
+#define UCS4_MAXUNICODE 0x10ffff/* highest Unicode codepoint */
+
+#define UTF16_BASE 0x10000	/* base of codepoints needing surrogates */
+#define UTF16_SHIFT 10		/* surrogate shift */
+#define UTF16_MASK 0x3ff	/* surrogate mask */
+#define UTF16_SURR 0xd800	/* UTF-16 surrogate area */
+#define UTF16_SURRH 0xd800	/* UTF-16 first high surrogate */
+#define UTF16_SURRHEND 0xdbff	/* UTF-16 last high surrogate */
+#define UTF16_SURRL 0xdc00	/* UTF-16 first low surrogate */
+#define UTF16_SURRLEND 0xdfff	/* UTF-16 last low surrogate */
+#define UTF16_MAXSURR 0xdfff	/* end of UTF-16 surrogates */
+
+
+/* UBOGON is used to represent a codepoint in a character set which does not
+ * map to Unicode.  It is also used for mapping failures, e.g. incomplete
+ * shift sequences.  This name has the same text width as 0x????, for
+ * convenience in the mapping tables.
+ *
+ * NOCHAR is used to represent a codepoint in Unicode which does not map to
+ * the target character set in a reverse mapping table.  This name has the
+ * same text width as 0x???? in case we ever add static reverse mapping tables.
+ */
+
+#define UBOGON UCS2_BOGON
+#define NOCHAR UCS2_NOTCHAR
+
+/* Codepoints in non-Unicode character sets */
+
+/* Codepoints in ISO 646 character sets */
+
+/* British ASCII codepoints */
+
+#define BRITISH_POUNDSTERLING 0x23
+
+/* JIS Roman codepoints */
+
+#define JISROMAN_YEN 0x5c
+#define JISROMAN_OVERLINE 0x7e
+
+
+/* Hankaku katakana codepoints & parameters
+ *
+ * In earlier versions, MAX_KANA_7 and MAX_KANA_8 were the maximum codepoint
+ * values.  Although this made sense, it was confusing with the "max ku" and
+ * "max ten" values used in the double-byte tables; there are 1-origin, but
+ * the calculated values used for "ku" and "ten" are 0-origin (derived by
+ * substracting the "base").  What this all meant is that for double byte
+ * characters the limit test is of the form (value < max_ku), but for single
+ * byte characters (which used the same cell to hold the max ku) the limit
+ * test was (value <= max_ku).
+ *
+ * By making MAX_KANA_[78] be maximum+1, the same (value < max_ku) limit test
+ * is used throughout.  - 6/15/2006
+ */
+
+#define MIN_KANA_7 0x21
+#define MAX_KANA_7 0x60		/* maximum value + 1 */
+#define KANA_7 (UCS2_KATAKANA - MIN_KANA_7)
+#define MIN_KANA_8 (MIN_KANA_7 | BIT8)
+#define MAX_KANA_8 (MAX_KANA_7 | BIT8)
+#define KANA_8 (UCS2_KATAKANA - MIN_KANA_8)
+
+/* Charset scripts */
+
+/*  The term "script" is used here in a very loose sense, enough to make
+ * purists cringe.  Basically, the idea is to give the main program some
+ * idea of how it should treat the characters of text in a charset with
+ * respect to font, drawing routines, etc.
+ *
+ *  In some cases, "script" is associated with a charset; in other cases,
+ * it's more closely tied to a language.
+ */
+
+#define SC_UNICODE 0x1		/* Unicode */
+#define SC_LATIN_1 0x10		/* Western Europe */
+#define SC_LATIN_2 0x20		/* Eastern Europe */
+#define SC_LATIN_3 0x40		/* Southern Europe */
+#define SC_LATIN_4 0x80		/* Northern Europe */
+#define SC_LATIN_5 0x100	/* Turkish */
+#define SC_LATIN_6 0x200	/* Nordic */
+#define SC_LATIN_7 0x400	/* Baltic */
+#define SC_LATIN_8 0x800	/* Celtic */
+#define SC_LATIN_9 0x1000	/* Euro */
+#define SC_LATIN_0 SC_LATIN_9	/* colloquial name for Latin-9 */
+#define SC_ARABIC 0x2000
+#define SC_CYRILLIC 0x4000
+#define SC_GREEK 0x8000
+#define SC_HEBREW 0x10000
+#define SC_THAI 0x20000
+#define SC_UKRANIAN 0x40000
+#define SC_LATIN_10 0x80000	/* Balkan */
+#define SC_VIETNAMESE 0x100000
+#define SC_CHINESE_SIMPLIFIED 0x1000000
+#define SC_CHINESE_TRADITIONAL 0x2000000
+#define SC_JAPANESE 0x4000000
+#define SC_KOREAN 0x8000000
+
+
+/* Script table */
+
+typedef struct utf8_scent {
+  char *name;			/* script name */
+  char *description;		/* script description */
+  unsigned long script;		/* script bitmask */
+} SCRIPT;
+
+/* Character set table support */
+
+typedef struct utf8_csent {
+  char *name;			/* charset name */
+  unsigned short type;		/* type of charset */
+  unsigned short flags;		/* charset flags */
+  void *tab;			/* additional data */
+  unsigned long script;		/* script(s) implemented by this charset */
+  char *preferred;		/* preferred charset over this one */
+} CHARSET;
+
+
+struct utf8_eucparam {
+  unsigned int base_ku : 8;	/* base row */
+  unsigned int base_ten : 8;	/* base column */
+  unsigned int max_ku : 8;	/* maximum row */
+  unsigned int max_ten : 8;	/* maximum column */
+  void *tab;			/* conversion table */
+};
+
+
+/* Charset types */
+
+#define CT_UNKNOWN 0		/* unknown 8-bit */
+#define CT_ASCII 1		/* 7-bit ASCII no table */
+#define CT_UCS2 2		/* 2 byte 16-bit Unicode no table */
+#define CT_UCS4 3		/* 4 byte 32-bit Unicode no table */
+#define CT_1BYTE0 10		/* 1 byte ISO 8859-1 no table */
+#define CT_1BYTE 11		/* 1 byte ASCII + table 0x80-0xff */
+#define CT_1BYTE8 12		/* 1 byte table 0x00 - 0xff */
+#define CT_EUC 100		/* 2 byte ASCII + utf8_eucparam base/CS2/CS3 */
+#define CT_DBYTE 101		/* 2 byte ASCII + utf8_eucparam */
+#define CT_DBYTE2 102		/* 2 byte ASCII + utf8_eucparam plane1/2 */
+#define CT_UTF16 1000		/* variable UTF-16 encoded Unicode no table */
+#define CT_UTF8 1001		/* variable UTF-8 encoded Unicode no table */
+#define CT_UTF7 1002		/* variable UTF-7 encoded Unicode no table */
+#define CT_2022 10000		/* variable ISO-2022 encoded no table */
+#define CT_SJIS 10001		/* 2 byte Shift-JIS encoded JIS no table */
+
+
+/* Character set flags */
+
+#define CF_PRIMARY 0x1		/* primary name for this charset */
+#define CF_DISPLAY 0x2		/* charset used in displays */
+#define CF_POSTING 0x4		/* charset used in email posting */
+#define CF_UNSUPRT 0x8		/* charset unsupported (can't convert to it) */
+#define CF_NOEMAIL 0x10		/* charset not used in email */
+
+
+/* UTF-7 engine states */
+
+#define U7_ASCII 0		/* ASCII character */
+#define U7_PLUS 1		/* plus seen */
+#define U7_UNICODE 2		/* Unicode characters */
+#define U7_MINUS 3		/* absorbed minus seen */
+
+/* Function prototypes */
+
+typedef unsigned long (*ucs4cn_t) (unsigned long c);
+typedef unsigned long (*ucs4de_t) (unsigned long c,void **more);
+
+SCRIPT *utf8_script (char *script);
+const CHARSET *utf8_charset (char *charset);
+char *utf8_badcharset (char *charset);
+long utf8_text (SIZEDTEXT *text,char *charset,SIZEDTEXT *ret,long flags);
+long utf8_text_cs (SIZEDTEXT *text,const CHARSET *cs,SIZEDTEXT *ret,
+		   ucs4cn_t cv,ucs4de_t de);
+long utf8_cstext (SIZEDTEXT *text,char *charset,SIZEDTEXT *ret,
+		  unsigned long errch);
+long utf8_cstocstext (SIZEDTEXT *text,char *sc,SIZEDTEXT *ret,char *dc,
+		      unsigned long errch);
+unsigned short *utf8_rmap (char *charset);
+unsigned short *utf8_rmap_cs (const CHARSET *cs);
+unsigned short *utf8_rmap_gen (const CHARSET *cs,unsigned short *oldmap);
+long utf8_rmaptext (SIZEDTEXT *text,unsigned short *rmap,SIZEDTEXT *ret,
+		    unsigned long errch,long iso2022jp);
+unsigned long utf8_rmapsize (SIZEDTEXT *text,unsigned short *rmap,
+			     unsigned long errch,long iso2022jp);
+long ucs4_rmaptext (unsigned long *ucs4,unsigned long len,unsigned short *rmap,
+		    SIZEDTEXT *ret,unsigned long errch);
+long ucs4_rmaplen (unsigned long *ucs4,unsigned long len,unsigned short *rmap,
+		   unsigned long errch);
+long ucs4_rmapbuf (unsigned char *t,unsigned long *ucs4,unsigned long len,
+		   unsigned short *rmap,unsigned long errch);
+unsigned long utf8_get (unsigned char **s,unsigned long *i);
+unsigned long utf8_get_raw (unsigned char **s,unsigned long *i);
+unsigned long ucs4_cs_get (CHARSET *cs,unsigned char **s,unsigned long *i);
+unsigned long *utf8_csvalidmap (char *charsets[]);
+const CHARSET *utf8_infercharset (SIZEDTEXT *src);
+long utf8_validate (unsigned char *s,unsigned long i);
+void utf8_text_1byte0 (SIZEDTEXT *text,SIZEDTEXT *ret,ucs4cn_t cv,ucs4de_t de);
+void utf8_text_1byte (SIZEDTEXT *text,SIZEDTEXT *ret,void *tab,ucs4cn_t cv,
+		      ucs4de_t de);
+void utf8_text_1byte8 (SIZEDTEXT *text,SIZEDTEXT *ret,void *tab,ucs4cn_t cv,
+		       ucs4de_t de);
+void utf8_text_euc (SIZEDTEXT *text,SIZEDTEXT *ret,void *tab,ucs4cn_t cv,
+		    ucs4de_t de);
+void utf8_text_dbyte (SIZEDTEXT *text,SIZEDTEXT *ret,void *tab,ucs4cn_t cv,
+		      ucs4de_t de);
+void utf8_text_dbyte2 (SIZEDTEXT *text,SIZEDTEXT *ret,void *tab,ucs4cn_t cv,
+		       ucs4de_t de);
+void utf8_text_sjis (SIZEDTEXT *text,SIZEDTEXT *ret,ucs4cn_t cv,ucs4de_t de);
+void utf8_text_2022 (SIZEDTEXT *text,SIZEDTEXT *ret,ucs4cn_t cv,ucs4de_t de);
+void utf8_text_utf7 (SIZEDTEXT *text,SIZEDTEXT *ret,ucs4cn_t cv,ucs4de_t de);
+void utf8_text_utf8 (SIZEDTEXT *text,SIZEDTEXT *ret,ucs4cn_t cv,ucs4de_t de);
+void utf8_text_ucs2 (SIZEDTEXT *text,SIZEDTEXT *ret,ucs4cn_t cv,ucs4de_t de);
+void utf8_text_ucs4 (SIZEDTEXT *text,SIZEDTEXT *ret,ucs4cn_t cv,ucs4de_t de);
+void utf8_text_utf16 (SIZEDTEXT *text,SIZEDTEXT *ret,ucs4cn_t cv,ucs4de_t de);
+unsigned long utf8_size (unsigned long c);
+unsigned char *utf8_put (unsigned char *s,unsigned long c);
+unsigned long ucs4_titlecase (unsigned long c);
+long ucs4_width (unsigned long c);
+long utf8_strwidth (unsigned char *s);
+long utf8_textwidth (SIZEDTEXT *utf8);
+unsigned long ucs4_decompose (unsigned long c,void **more);
+unsigned long ucs4_decompose_recursive (unsigned long c,void **more);
diff --git a/imap/src/c-client/utf8aux.c b/imap/src/c-client/utf8aux.c
new file mode 100644
index 00000000..5138987b
--- /dev/null
+++ b/imap/src/c-client/utf8aux.c
@@ -0,0 +1,449 @@
+/* ========================================================================
+ * Copyright 1988-2007 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:	UTF-8 auxillary routines (c-client and MIME2 support)
+ *
+ * Author:	Mark Crispin
+ *		Networks and Distributed Computing
+ *		Computing & Communications
+ *		University of Washington
+ *		Administration Building, AG-44
+ *		Seattle, WA  98195
+ *		Internet: MRC@CAC.Washington.EDU
+ *
+ * Date:	11 June 1997
+ * Last Edited:	12 October 2007
+ */
+
+
+#include <stdio.h>
+#include <ctype.h>
+#include "c-client.h"
+
+/* Convert charset labelled stringlist to UTF-8 in place
+ * Accepts: string list
+ *	    charset
+ */
+
+static void utf8_stringlist (STRINGLIST *st,char *charset)
+{
+  SIZEDTEXT txt;
+				/* convert entire stringstruct */
+  if (st) do if (utf8_text (&st->text,charset,&txt,U8T_CANONICAL)) {
+    fs_give ((void **) &st->text.data);
+    st->text.data = txt.data; /* transfer this text */
+    st->text.size = txt.size;
+  } while (st = st->next);
+}
+
+
+/* Convert charset labelled searchpgm to UTF-8 in place
+ * Accepts: search program
+ *	    charset
+ */
+
+void utf8_searchpgm (SEARCHPGM *pgm,char *charset)
+{
+  SIZEDTEXT txt;
+  SEARCHHEADER *hl;
+  SEARCHOR *ol;
+  SEARCHPGMLIST *pl;
+  if (pgm) {			/* must have a search program */
+    utf8_stringlist (pgm->bcc,charset);
+    utf8_stringlist (pgm->cc,charset);
+    utf8_stringlist (pgm->from,charset);
+    utf8_stringlist (pgm->to,charset);
+    utf8_stringlist (pgm->subject,charset);
+    for (hl = pgm->header; hl; hl = hl->next) {
+      if (utf8_text (&hl->line,charset,&txt,U8T_CANONICAL)) {
+	fs_give ((void **) &hl->line.data);
+	hl->line.data = txt.data;
+	hl->line.size = txt.size;
+      }
+      if (utf8_text (&hl->text,charset,&txt,U8T_CANONICAL)) {
+	fs_give ((void **) &hl->text.data);
+	hl->text.data = txt.data;
+	hl->text.size = txt.size;
+      }
+    }
+    utf8_stringlist (pgm->body,charset);
+    utf8_stringlist (pgm->text,charset);
+    for (ol = pgm->or; ol; ol = ol->next) {
+      utf8_searchpgm (ol->first,charset);
+      utf8_searchpgm (ol->second,charset);
+    }
+    for (pl = pgm->not; pl; pl = pl->next) utf8_searchpgm (pl->pgm,charset);
+    utf8_stringlist (pgm->return_path,charset);
+    utf8_stringlist (pgm->sender,charset);
+    utf8_stringlist (pgm->reply_to,charset);
+    utf8_stringlist (pgm->in_reply_to,charset);
+    utf8_stringlist (pgm->message_id,charset);
+    utf8_stringlist (pgm->newsgroups,charset);
+    utf8_stringlist (pgm->followup_to,charset);
+    utf8_stringlist (pgm->references,charset);
+  }
+}
+
+/* Convert MIME-2 sized text to UTF-8
+ * Accepts: source sized text
+ *	    charset
+ *	    flags (same as utf8_text())
+ * Returns: T if successful, NIL if failure
+ */
+
+#define MINENCWORD 9
+#define MAXENCWORD 75
+
+/* This resizing algorithm is stupid, but hopefully it should never be triggered
+ * except for a pathological header.  The main concern is that we don't get a
+ * buffer overflow.
+ */
+
+#define DSIZE 65536		/* real headers should never be this big */
+#define FUZZ 10			/* paranoia fuzz */
+
+long utf8_mime2text (SIZEDTEXT *src,SIZEDTEXT *dst,long flags)
+{
+  unsigned char *s,*se,*e,*ee,*t,*te;
+  char *cs,*ce,*ls;
+  SIZEDTEXT txt,rtxt;
+  unsigned long i;
+  size_t dsize = min (DSIZE,((src->size / 4) + 1) * 9);
+				/* always create buffer if canonicalizing */
+  dst->data = (flags & U8T_CANONICAL) ?
+    (unsigned char *) fs_get ((size_t) dsize) : NIL;
+  dst->size = 0;		/* nothing written yet */
+				/* look for encoded words */
+  for (s = src->data, se = src->data + src->size; s < se; s++) {
+    if (((se - s) > MINENCWORD) && (*s == '=') && (s[1] == '?') &&
+      (cs = (char *) mime2_token (s+2,se,(unsigned char **) &ce)) &&
+	(e = mime2_token ((unsigned char *) ce+1,se,&ee)) &&
+	(te = mime2_text (t = e+2,se)) && (ee == e + 1) &&
+	((te - s) < MAXENCWORD)) {
+      if (mime2_decode (e,t,te,&txt)) {
+	*ce = '\0';		/* temporarily tie off charset */
+	if (ls = strchr (cs,'*')) *ls = '\0';
+				/* convert to UTF-8 as best we can */
+	if (!utf8_text (&txt,cs,&rtxt,flags)) utf8_text (&txt,NIL,&rtxt,flags);
+	if (dst->data) {	/* make sure existing buffer fits */
+	  while (dsize <= (dst->size + rtxt.size + FUZZ)) {
+	    dsize += DSIZE;	/* kick it up */
+	    fs_resize ((void **) &dst->data,dsize);
+	  }
+	}
+	else {			/* make a new buffer */
+	  while (dsize <= (dst->size + rtxt.size)) dsize += DSIZE;
+	  memcpy (dst->data = (unsigned char *) fs_get (dsize),src->data,
+		  dst->size = s - src->data);
+	}
+	for (i = 0; i < rtxt.size; i++) dst->data[dst->size++] = rtxt.data[i];
+
+				/* all done with converted text */
+	if (rtxt.data != txt.data) fs_give ((void **) &rtxt.data);
+	if (ls) *ls = '*';	/* restore language tag delimiter */
+	*ce = '?';		/* restore charset delimiter */
+				/* all done with decoded text */
+	fs_give ((void **) &txt.data);
+	s = te+1;		/* continue scan after encoded word */
+				/* skip leading whitespace */
+	for (t = s + 1; (t < se) && ((*t == ' ') || (*t == '\t')); t++);
+				/* see if likely continuation encoded word */
+	if (t < (se - MINENCWORD)) switch (*t) {
+	case '=':		/* possible encoded word? */
+	  if (t[1] == '?') s = t - 1;
+	  break;
+	case '\015':		/* CR, eat a following LF */
+	  if (t[1] == '\012') t++;
+	case '\012':		/* possible end of logical line */
+	  if ((t[1] == ' ') || (t[1] == '\t')) {
+	    do t++;
+	    while ((t < (se - MINENCWORD)) && ((t[1] == ' ')||(t[1] == '\t')));
+	    if ((t < (se - MINENCWORD)) && (t[1] == '=') && (t[2] == '?'))
+	      s = t;		/* definitely looks like continuation */
+	  }
+	}
+      }
+      else {			/* restore original text */
+	if (dst->data) fs_give ((void **) &dst->data);
+	dst->data = src->data;
+	dst->size = src->size;
+	return NIL;		/* syntax error: MIME-2 decoding failure */
+      }
+    }
+    else do if (dst->data) {	/* stash ASCII characters until LWSP */
+      if (dsize < (dst->size + FUZZ)) {
+	dsize += DSIZE;		/* kick it up */
+	fs_resize ((void **) &dst->data,dsize);
+      }
+      /* kludge: assumes ASCII doesn't decompose and titlecases to one byte */
+      dst->data[dst->size++] = (flags & U8T_CASECANON) ?
+	(unsigned char) ucs4_titlecase (*s) : *s;
+    }
+    while ((*s != ' ') && (*s != '\t') && (*s != '\015') && (*s != '\012') &&
+	   (++s < se));
+  }
+  if (dst->data) dst->data[dst->size] = '\0';
+  else {			/* nothing converted, return identity */
+    dst->data = src->data;
+    dst->size = src->size;
+  }
+  return T;			/* success */
+}
+
+/* Decode MIME-2 text
+ * Accepts: Encoding
+ *	    text
+ *	    text end
+ *	    destination sized text
+ * Returns: T if successful, else NIL
+ */
+
+long mime2_decode (unsigned char *e,unsigned char *t,unsigned char *te,
+		   SIZEDTEXT *txt)
+{
+  unsigned char *q;
+  txt->data = NIL;		/* initially no returned data */
+  switch (*e) {			/* dispatch based upon encoding */
+  case 'Q': case 'q':		/* sort-of QUOTED-PRINTABLE */
+    txt->data = (unsigned char *) fs_get ((size_t) (te - t) + 1);
+    for (q = t,txt->size = 0; q < te; q++) switch (*q) {
+    case '=':			/* quoted character */
+				/* both must be hex */
+      if (!isxdigit (q[1]) || !isxdigit (q[2])) {
+	fs_give ((void **) &txt->data);
+	return NIL;		/* syntax error: bad quoted character */
+      }
+				/* assemble character */
+      txt->data[txt->size++] = hex2byte (q[1],q[2]);
+      q += 2;			/* advance past quoted character */
+      break;
+    case '_':			/* convert to space */
+      txt->data[txt->size++] = ' ';
+      break;
+    default:			/* ordinary character */
+      txt->data[txt->size++] = *q;
+      break;
+    }
+    txt->data[txt->size] = '\0';
+    break;
+  case 'B': case 'b':		/* BASE64 */
+    if (txt->data = (unsigned char *) rfc822_base64 (t,te - t,&txt->size))
+      break;
+  default:			/* any other encoding is unknown */
+    return NIL;			/* syntax error: unknown encoding */
+  }
+  return T;
+}
+
+/* Get MIME-2 token from encoded word
+ * Accepts: current text pointer
+ *	    text limit pointer
+ *	    pointer to returned end pointer
+ * Returns: current text pointer & end pointer if success, else NIL
+ */
+
+unsigned char *mime2_token (unsigned char *s,unsigned char *se,
+			    unsigned char **t)
+{
+  for (*t = s; **t != '?'; ++*t) {
+    if ((*t < se) && isgraph (**t)) switch (**t) {
+    case '(': case ')': case '<': case '>': case '@': case ',': case ';':
+    case ':': case '\\': case '"': case '/': case '[': case ']': case '.':
+    case '=':
+      return NIL;		/* none of these are valid in tokens */
+    }
+    else return NIL;		/* out of text or CTL or space */
+  }
+  return s;
+}
+
+
+/* Get MIME-2 text from encoded word
+ * Accepts: current text pointer
+ *	    text limit pointer
+ *	    pointer to returned end pointer
+ * Returns: end pointer if success, else NIL
+ */
+
+unsigned char *mime2_text (unsigned char *s,unsigned char *se)
+{
+  unsigned char *t = se - 1;
+				/* search for closing ?, make sure valid */
+  while ((s < t) && (*s != '?') && isgraph (*s++));
+  return ((s < t) && (*s == '?') && (s[1] == '=') &&
+	  ((se == (s + 2)) || (s[2] == ' ') || (s[2] == '\t') ||
+	   (s[2] == '\015') || (s[2] == '\012'))) ? s : NIL;
+}
+
+/* Convert UTF-16 string to Modified Base64
+ * Accepts: destination pointer
+ *	    source string
+ *	    source length in octets
+ * Returns: updated destination pointer
+ */
+
+static unsigned char *utf16_to_mbase64 (unsigned char *t,unsigned char *s,
+					size_t i)
+{
+  char *v = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+,";
+  *t++ = '&';			/* write shift-in */
+  while (i >= 3) {		/* process tuplets */
+    *t++ = v[s[0] >> 2];	/* byte 1: high 6 bits (1) */
+				/* byte 2: low 2 bits (1), high 4 bits (2) */
+    *t++ = v[((s[0] << 4) + (s[1] >> 4)) & 0x3f];
+				/* byte 3: low 4 bits (2), high 2 bits (3) */
+    *t++ = v[((s[1] << 2) + (s[2] >> 6)) & 0x3f];
+    *t++ = v[s[2] & 0x3f];	/* byte 4: low 6 bits (3) */
+    s += 3;
+    i -= 3;
+  }
+  if (i) {
+    *t++ = v[s[0] >> 2];	/* byte 1: high 6 bits (1) */
+				/* byte 2: low 2 bits (1), high 4 bits (2) */
+    *t++ = v[((s[0] << 4) + (--i ? (s[1] >> 4) : 0)) & 0x3f];
+				/* byte 3: low 4 bits (2) */
+    if (i) *t++ = v[(s[1] << 2) & 0x3f];
+  }
+  *t++ = '-';			/* write shift-out */
+  return t;
+}
+
+
+/* Poot a UTF-16 value to a buffer
+ * Accepts: buffer pointer
+ *	    value
+ * Returns: updated pointer
+ */
+
+static unsigned char *utf16_poot (unsigned char *s,unsigned long c)
+{
+  *s++ = (unsigned char) (c >> 8);
+  *s++ = (unsigned char) (c & 0xff);
+  return s;
+}
+
+/* Convert UTF-8 to Modified UTF-7
+ * Accepts: UTF-8 string
+ * Returns: Modified UTF-7 string on success, NIL if invalid UTF-8
+ */
+
+#define MAXUNIUTF8 4		/* maximum length of Unicode UTF-8 sequence */
+
+unsigned char *utf8_to_mutf7 (unsigned char *src)
+{
+  unsigned char *u16buf,*utf16;
+  unsigned char *ret,*t;
+  unsigned long j,c;
+  unsigned char *s = src;
+  unsigned long i = 0;
+  int nonascii = 0;
+  while (*s) {			/* pass one: count destination octets */
+    if (*s & 0x80) {		/* non-ASCII character? */
+      j = MAXUNIUTF8;		/* get single UCS-4 codepoint */
+      if ((c = utf8_get (&s,&j)) & U8G_ERROR) return NIL;
+				/* tally number of UTF-16 octets */
+      nonascii += (c & U8GM_NONBMP) ? 4 : 2;
+    }
+    else {			/* ASCII character */
+      if (nonascii) {		/* add pending Modified BASE64 size + shifts */
+	i += ((nonascii / 3) * 4) + ((j = nonascii % 3) ? j + 1 : 0) + 2;
+	nonascii = 0;		/* back to ASCII */
+      }
+      if (*s == '&') i += 2;	/* two octets if the escape */
+      else ++i;			/* otherwise just count another octet */
+      ++s;			/* advance to next source octet */
+    }
+  }
+  if (nonascii)			/* add pending Modified BASE64 size + shifts */
+    i += ((nonascii / 3) * 4) + ((j = nonascii % 3) ? j + 1 : 0) + 2;
+
+				/* create return buffer */
+  t = ret = (unsigned char *) fs_get (i + 1);
+				/* and scratch buffer */
+  utf16 = u16buf = (unsigned char *) fs_get (i + 1);
+  for (s = src; *s;) {		/* pass two: copy destination octets */
+    if (*s & 0x80) {		/* non-ASCII character? */
+      j = MAXUNIUTF8;		/* get single UCS-4 codepoint */
+      if ((c = utf8_get (&s,&j)) & U8G_ERROR) return NIL;
+      if (c & U8GM_NONBMP) {	/* non-BMP? */
+	c -= UTF16_BASE;	/* yes, convert to surrogate */
+	utf16 = utf16_poot (utf16_poot (utf16,(c >> UTF16_SHIFT)+UTF16_SURRH),
+			    (c & UTF16_MASK) + UTF16_SURRL);
+      }
+      else utf16 = utf16_poot (utf16,c);
+    }
+    else {			/* ASCII character */
+      if (utf16 != u16buf) {	/* add pending Modified BASE64 size + shifts */
+	t = utf16_to_mbase64 (t,u16buf,utf16 - u16buf);
+	utf16 = u16buf;		/* reset buffer */
+      }
+      *t++ = *s;		/* copy the character */
+      if (*s == '&') *t++ = '-';/* special sequence if the escape */
+      ++s;			/* advance to next source octet */
+    }
+  }
+				/* add pending Modified BASE64 size + shifts */
+  if (utf16 != u16buf) t = utf16_to_mbase64 (t,u16buf,utf16 - u16buf);
+  *t = '\0';			/* tie off destination */
+  if (i != (t - ret)) fatal ("utf8_to_mutf7 botch");
+  fs_give ((void **) &u16buf);
+  return ret;
+}
+
+/* Convert Modified UTF-7 to UTF-8
+ * Accepts: Modified UTF-7 string
+ * Returns: UTF-8 string on success, NIL if invalid Modified UTF-7
+ */
+
+unsigned char *utf8_from_mutf7 (unsigned char *src)
+{
+  SIZEDTEXT utf8,utf7;
+  unsigned char *s;
+  int mbase64 = 0;
+				/* disallow bogus strings */
+  if (mail_utf7_valid (src)) return NIL;
+				/* initialize SIZEDTEXTs */
+  memset (&utf7,0,sizeof (SIZEDTEXT));
+  memset (&utf8,0,sizeof (SIZEDTEXT));
+				/* make copy of source */
+  for (s = cpytxt (&utf7,src,strlen (src)); *s; ++s) switch (*s) {
+  case '&':			/* Modified UTF-7 uses & instead of + */
+    *s = '+';
+    mbase64 = T;		/* note that we are in Modified BASE64 */
+    break;
+  case '+':			/* temporarily swap text + to & */
+    if (!mbase64) *s = '&';
+    break;
+  case '-':			/* shift back to ASCII */
+    mbase64 = NIL;
+    break;
+  case ',':			/* Modified UTF-7 uses , instead of / ... */
+    if (mbase64) *s = '/';	/* ...in Modified BASE64 */
+    break;
+  }
+				/* do the conversion */
+  utf8_text_utf7 (&utf7,&utf8,NIL,NIL);
+				/* no longer need copy of source */
+  fs_give ((void **) &utf7.data);
+				/* post-process: switch & and + */
+  for (s = utf8.data; *s; ++s) switch (*s) {
+  case '&':
+    *s = '+';
+    break;
+  case '+':
+    *s = '&';
+    break;
+  }
+  return utf8.data;
+}
diff --git a/imap/src/c-client/utf8aux.h b/imap/src/c-client/utf8aux.h
new file mode 100644
index 00000000..beb55057
--- /dev/null
+++ b/imap/src/c-client/utf8aux.h
@@ -0,0 +1,44 @@
+/* ========================================================================
+ * Copyright 1988-2007 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:	UTF-8 auxillary routines (c-client and MIME2 support)
+ *
+ * Author:	Mark Crispin
+ *		Networks and Distributed Computing
+ *		Computing & Communications
+ *		University of Washington
+ *		Administration Building, AG-44
+ *		Seattle, WA  98195
+ *		Internet: MRC@CAC.Washington.EDU
+ *
+ * Date:	11 June 1997
+ * Last Edited:	9 October 2007
+ */
+
+
+/* Following routines are in utf8aux.c as these depend upon c-client.
+ * Splitting these routines out makes it possible for pico to link with utf8.o
+ * and a few rump routines (e.g., fs_get()) but not all the rest of c-client
+ * (which pico does not need).
+ */
+
+void utf8_searchpgm (SEARCHPGM *pgm,char *charset);
+long utf8_mime2text (SIZEDTEXT *src,SIZEDTEXT *dst,long flags);
+unsigned char *mime2_token (unsigned char *s,unsigned char *se,
+			    unsigned char **t);
+unsigned char *mime2_text (unsigned char *s,unsigned char *se);
+long mime2_decode (unsigned char *e,unsigned char *t,unsigned char *te,
+		   SIZEDTEXT *txt);
+unsigned char *utf8_to_mutf7 (unsigned char *src);
+unsigned char *utf8_from_mutf7 (unsigned char *src);