Initial Alpine Version

1 files changed, 1111 insertions, 0 deletions

diff --git a/pith/imap.c b/pith/imap.c
new file mode 100644
index 00000000..ea4c5b1f
--- /dev/null
+++ b/pith/imap.c
@@ -0,0 +1,1111 @@
+#if !defined(lint) && !defined(DOS)
+static char rcsid[] = "$Id: imap.c 1142 2008-08-13 17:22:21Z hubert@u.washington.edu $";
+#endif
+
+/*
+ * ========================================================================
+ * Copyright 2006-2008 University of Washington
+ * Copyright 2013 Eduardo Chappa
+ *
+ * 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
+ *
+ * ========================================================================
+ */
+
+#include "../pith/headers.h"
+#include "../pith/imap.h"
+#include "../pith/msgno.h"
+#include "../pith/state.h"
+#include "../pith/flag.h"
+#include "../pith/pineelt.h"
+#include "../pith/status.h"
+#include "../pith/conftype.h"
+#include "../pith/context.h"
+#include "../pith/thread.h"
+#include "../pith/mailview.h"
+#include "../pith/mailpart.h"
+#include "../pith/mailindx.h"
+#include "../pith/mailcmd.h"
+#include "../pith/save.h"
+#include "../pith/util.h"
+#include "../pith/stream.h"
+#include "../pith/newmail.h"
+#include "../pith/icache.h"
+#include "../pith/options.h"
+
+#ifdef _WINDOWS
+#include "../pico/osdep/mswin.h"
+#endif
+
+
+/*
+ * Internal prototypes
+ */
+long  imap_seq_exec(MAILSTREAM *, char *, long (*)(MAILSTREAM *, long, void *), void *);
+long  imap_seq_exec_append(MAILSTREAM *, long, void *);
+char *ps_get(size_t);
+
+
+/*
+ * Exported globals setup by searching functions to tell mm_searched
+ * where to put message numbers that matched the search criteria,
+ * and to allow mm_searched to return number of matches.
+ */
+MAILSTREAM *mm_search_stream;
+long	    mm_search_count  = 0L;
+MAILSTATUS  mm_status_result;
+
+MM_LIST_S  *mm_list_info;
+
+MMLOGIN_S  *mm_login_list     = NULL;
+MMLOGIN_S  *cert_failure_list = NULL;
+
+/*
+ * Instead of storing cached passwords in free storage, store them in this
+ * private space. This makes it easier and more reliable when we want
+ * to zero this space out. We only store passwords here (char *) so we
+ * don't need to worry about alignment.
+ */
+static	volatile char private_store[1024];
+
+static	int        critical_depth = 0;
+
+/* hook to hang callback on "current" message expunge */
+void (*pith_opt_current_expunged)(long unsigned int);
+
+#ifdef	SIGINT
+RETSIGTYPE (*hold_int)(int);
+#endif
+
+#ifdef	SIGTERM
+RETSIGTYPE (*hold_term)(int);
+#endif
+
+#ifdef	SIGHUP
+RETSIGTYPE (*hold_hup)(int);
+#endif
+
+#ifdef	SIGUSR2
+RETSIGTYPE (*hold_usr2)(int);
+#endif
+
+
+
+/*---------------------------------------------------------------------- 
+        receive notification that search found something           
+
+ Input:  mail stream and message number of located item
+
+ Result: nothing, not used by pine
+  ----*/
+void
+mm_searched(MAILSTREAM *stream, long unsigned int rawno)
+{
+    MESSAGECACHE *mc;
+
+    if(rawno > 0L && stream && rawno <= stream->nmsgs
+       && (mc = mail_elt(stream, rawno))){
+	mc->searched = 1;
+	if(stream == mm_search_stream)
+	  mm_search_count++;
+    }
+}
+
+
+/*----------------------------------------------------------------------
+       receive notification of new mail from imap daemon
+
+   Args: stream -- The stream the message count report is for.
+         number -- The number of messages now in folder.
+ 
+  Result: Sets value in pine state indicating new mailbox size
+
+     Called when the number of messages in the mailbox goes up.  This
+ may also be called as a result of an expunge. It increments the
+ new_mail_count based on a the difference between the current idea of
+ the maximum number of messages and what mm_exists claims. The new mail
+ notification is done in newmail.c
+
+ Only worry about the cases when the number grows, as mm_expunged
+ handles shrinkage...
+
+ ----*/
+void
+mm_exists(MAILSTREAM *stream, long unsigned int number)
+{
+    long     new_this_call, n;
+    int	     exbits = 0, lflags = 0;
+    MSGNO_S *msgmap;
+
+#ifdef DEBUG
+    if(ps_global->debug_imap > 1 || ps_global->debugmem)
+      dprint((3, "=== mm_exists(%lu,%s) called ===\n", number,
+     !stream ? "(no stream)" : !stream->mailbox ? "(null)" : stream->mailbox));
+#endif
+
+    msgmap = sp_msgmap(stream);
+    if(!msgmap)
+      return;
+
+    if(mn_get_nmsgs(msgmap) != (long) number){
+	sp_set_mail_box_changed(stream, 1);
+	/* titlebar will be affected */
+	if(ps_global->mail_stream == stream)
+	  ps_global->mangled_header = 1;
+    }
+
+    if(mn_get_nmsgs(msgmap) < (long) number){
+	new_this_call = (long) number - mn_get_nmsgs(msgmap);
+	sp_set_new_mail_count(stream,
+			      sp_new_mail_count(stream) + new_this_call);
+	sp_set_recent_since_visited(stream,
+			      sp_recent_since_visited(stream) + new_this_call);
+
+	mn_add_raw(msgmap, new_this_call);
+
+	/*
+	 * Set local "recent" and "hidden" bits...
+	 */
+	for(n = 0; n < new_this_call; n++, number--){
+	    if(msgno_exceptions(stream, number, "0", &exbits, FALSE))
+	      exbits |= MSG_EX_RECENT;
+	    else
+	      exbits = MSG_EX_RECENT;
+
+	    msgno_exceptions(stream, number, "0", &exbits, TRUE);
+
+	    if(SORT_IS_THREADED(msgmap))
+	      lflags |= MN_USOR;
+
+	    /*
+	     * If we're zoomed, then hide this message too since
+	     * it couldn't have possibly been selected yet...
+	     */
+	    lflags |= (any_lflagged(msgmap, MN_HIDE) ? MN_HIDE : 0);
+	    if(lflags)
+	      set_lflag(stream, msgmap, mn_get_total(msgmap) - n, lflags, 1);
+	}
+    }
+}
+
+
+/*----------------------------------------------------------------------
+    Receive notification from IMAP that a single message has been expunged
+
+   Args: stream -- The stream/folder the message is expunged from
+         rawno  -- The raw message number that was expunged
+
+mm_expunged is always called on an expunge.  Simply remove all 
+reference to the expunged message, shifting internal mappings as
+necessary.
+  ----*/
+void
+mm_expunged(MAILSTREAM *stream, long unsigned int rawno)
+{
+    MESSAGECACHE *mc;
+    long          i;
+    int           is_current = 0;
+    MSGNO_S      *msgmap;
+
+#ifdef DEBUG
+    if(ps_global->debug_imap > 1 || ps_global->debugmem)
+      dprint((3, "mm_expunged(%s,%lu)\n",
+	       stream
+		? (stream->mailbox
+		    ? stream->mailbox
+		    : "(no stream)")
+		: "(null)", rawno));
+#endif
+
+    msgmap = sp_msgmap(stream);
+    if(!msgmap)
+      return;
+
+    if(ps_global->mail_stream == stream)
+      is_current++;
+
+    if((i = mn_raw2m(msgmap, (long) rawno)) != 0L){
+	dprint((7, "mm_expunged: rawno=%lu msgno=%ld nmsgs=%ld max_msgno=%ld flagged_exld=%ld\n", rawno, i, mn_get_nmsgs(msgmap), mn_get_total(msgmap), msgmap->flagged_exld));
+
+	sp_set_mail_box_changed(stream, 1);
+	sp_set_expunge_count(stream, sp_expunge_count(stream) + 1);
+
+	if(is_current){
+	    reset_check_point(stream);
+	    ps_global->mangled_header = 1;
+
+	    /* flush invalid cache entries */
+	    while(i <= mn_get_total(msgmap))
+	      clear_index_cache_ent(stream, i++, 0);
+
+	    /* let app know what happened */
+	    if(pith_opt_current_expunged)
+	      (*pith_opt_current_expunged)(rawno);
+	}
+    }
+    else{
+	dprint((7,
+	       "mm_expunged: rawno=%lu was excluded, flagged_exld was %d\n",
+	       rawno, msgmap->flagged_exld));
+	dprint((7, "             nmsgs=%ld max_msgno=%ld\n",
+	       mn_get_nmsgs(msgmap), mn_get_total(msgmap)));
+	if(rawno > 0L && rawno <= stream->nmsgs)
+	  mc = mail_elt(stream, rawno);
+
+	if(!mc){
+	    dprint((7, "             cannot get mail_elt(%lu)\n",
+		   rawno));
+	}
+	else if(!mc->sparep){
+	    dprint((7, "             mail_elt(%lu)->sparep is NULL\n",
+		   rawno));
+	}
+	else{
+	    dprint((7, "             mail_elt(%lu)->sparep->excluded=%d\n",
+		    rawno, (int) (((PINELT_S *) mc->sparep)->excluded)));
+	}
+    }
+
+    if(SORT_IS_THREADED(msgmap)
+       && (SEP_THRDINDX()
+	   || ps_global->thread_disp_style != THREAD_NONE)){
+	long cur;
+
+	/*
+	 * When we're sorting with a threaded method an expunged
+	 * message may cause the rest of the sort to be wrong. This
+	 * isn't so bad if we're just looking at the index. However,
+	 * it also causes the thread tree (PINETHRD_S) to become
+	 * invalid, so if we're using a threading view we need to
+	 * sort in order to fix the tree and to protect fetch_thread().
+	 */
+	sp_set_need_to_rethread(stream, 1);
+
+	/*
+	 * If we expunged the current message which was a member of the
+	 * viewed thread, and the adjustment to current will take us
+	 * out of that thread, fix it if we can, by backing current up
+	 * into the thread. We'd like to just check after mn_flush_raw
+	 * below but the problem is that the elts won't change until
+	 * after we return from mm_expunged. So we have to manually
+	 * check the other messages for CHID2 flags instead of thinking
+	 * that we can expunge the current message and then check. It won't
+	 * work because the elt will still refer to the expunged message.
+	 */
+	if(sp_viewing_a_thread(stream)
+	   && get_lflag(stream, NULL, rawno, MN_CHID2)
+	   && mn_total_cur(msgmap) == 1
+	   && mn_is_cur(msgmap, mn_raw2m(msgmap, (long) rawno))
+	   && (cur = mn_get_cur(msgmap)) > 1L
+	   && cur < mn_get_total(msgmap)
+	   && !get_lflag(stream, msgmap, cur + 1L, MN_CHID2)
+	   && get_lflag(stream, msgmap, cur - 1L, MN_CHID2))
+	  mn_set_cur(msgmap, cur - 1L);
+    }
+
+    /*
+     * Keep on top of our special flag counts.
+     * 
+     * NOTE: This is allowed since mail_expunged releases
+     * data for this message after the callback.
+     */
+    if(rawno > 0L && rawno <= stream->nmsgs && (mc = mail_elt(stream, rawno))){
+      PINELT_S *pelt = (PINELT_S *) mc->sparep;
+
+      if(pelt){
+	if(pelt->hidden)
+	  msgmap->flagged_hid--;
+
+	if(pelt->excluded)
+	  msgmap->flagged_exld--;
+
+	if(pelt->selected)
+	  msgmap->flagged_tmp--;
+
+	if(pelt->colhid)
+	  msgmap->flagged_chid--;
+
+	if(pelt->colhid2)
+	  msgmap->flagged_chid2--;
+
+	if(pelt->collapsed)
+	  msgmap->flagged_coll--;
+
+	if(pelt->tmp)
+	  msgmap->flagged_stmp--;
+
+	if(pelt->unsorted)
+	  msgmap->flagged_usor--;
+
+	if(pelt->searched)
+	  msgmap->flagged_srch--;
+
+	if(pelt->hidden || pelt->colhid)
+	  msgmap->flagged_invisible--;
+
+	free_pine_elt(&mc->sparep);
+      }
+    }
+
+    /*
+     * if it's in the sort array, flush it, otherwise
+     * decrement raw sequence numbers greater than "rawno"
+     */
+    mn_flush_raw(msgmap, (long) rawno);
+}
+
+
+void
+mm_flags(MAILSTREAM *stream, long unsigned int rawno)
+{
+    /*
+     * The idea here is to clean up any data pine might have cached
+     * that has anything to do with the indicated message number.
+     */
+    if(stream == ps_global->mail_stream){
+	long        msgno, t;
+	PINETHRD_S *thrd;
+
+	if(scores_are_used(SCOREUSE_GET) & SCOREUSE_STATEDEP)
+	  clear_msg_score(stream, rawno);
+
+	msgno = mn_raw2m(sp_msgmap(stream), (long) rawno);
+
+	/* if in thread index */
+	if(THRD_INDX()){
+	    if((thrd = fetch_thread(stream, rawno))
+	       && thrd->top
+	       && (thrd = fetch_thread(stream, thrd->top))
+	       && thrd->rawno
+	       && (t = mn_raw2m(sp_msgmap(stream), thrd->rawno)))
+	      clear_index_cache_ent(stream, t, 0);
+	}
+	else if(THREADING()){
+	    if(msgno > 0L)
+	      clear_index_cache_ent(stream, msgno, 0);
+
+	    /*
+	     * If a parent is collapsed, clear that parent's
+	     * index cache entry.
+	     */
+	    if((thrd = fetch_thread(stream, rawno)) && thrd->parent){
+		thrd = fetch_thread(stream, thrd->parent);
+		while(thrd){
+		    if(get_lflag(stream, NULL, thrd->rawno, MN_COLL)
+		       && (t = mn_raw2m(sp_msgmap(stream), (long) thrd->rawno)))
+		      clear_index_cache_ent(stream, t, 0);
+
+		    if(thrd->parent)
+		      thrd = fetch_thread(stream, thrd->parent);
+		    else
+		      thrd = NULL;
+		}
+	    }
+	}
+	else if(msgno > 0L)
+	  clear_index_cache_ent(stream, msgno, 0);
+
+	if(msgno && mn_is_cur(sp_msgmap(stream), msgno))
+	  ps_global->mangled_header = 1;
+    }
+	    
+    /*
+     * We count up flag changes here. The
+     * dont_count_flagchanges variable tries to prevent us from
+     * counting when we're just fetching flags.
+     */
+    if(!(ps_global->dont_count_flagchanges
+	 && stream == ps_global->mail_stream)){
+	int exbits;
+
+	check_point_change(stream);
+
+	/* we also note flag changes for filtering purposes */
+	if(msgno_exceptions(stream, rawno, "0", &exbits, FALSE))
+	  exbits |= MSG_EX_STATECHG;
+	else
+	  exbits = MSG_EX_STATECHG;
+
+	msgno_exceptions(stream, rawno, "0", &exbits, TRUE);
+    }
+}
+
+
+void
+mm_list(MAILSTREAM *stream, int delimiter, char *mailbox, long int attributes)
+{
+#ifdef DEBUG
+    if(ps_global->debug_imap > 2 || ps_global->debugmem)
+      dprint((5, "mm_list \"%s\": delim: '%c', %s%s%s%s%s%s\n",
+	       mailbox ? mailbox : "?", delimiter ? delimiter : 'X',
+	       (attributes & LATT_NOINFERIORS) ? ", no inferiors" : "",
+	       (attributes & LATT_NOSELECT) ? ", no select" : "",
+	       (attributes & LATT_MARKED) ? ", marked" : "",
+	       (attributes & LATT_UNMARKED) ? ", unmarked" : "",
+	       (attributes & LATT_HASCHILDREN) ? ", has children" : "",
+	       (attributes & LATT_HASNOCHILDREN) ? ", has no children" : ""));
+#endif
+
+    if(!mm_list_info->stream || stream == mm_list_info->stream)
+      (*mm_list_info->filter)(stream, mailbox, delimiter,
+			      attributes, mm_list_info->data,
+			      mm_list_info->options);
+}
+
+
+void
+mm_lsub(MAILSTREAM *stream, int delimiter, char *mailbox, long int attributes)
+{
+#ifdef DEBUG
+    if(ps_global->debug_imap > 2 || ps_global->debugmem)
+      dprint((5, "LSUB \"%s\": delim: '%c', %s%s%s%s%s%s\n",
+	       mailbox ? mailbox : "?", delimiter ? delimiter : 'X',
+	       (attributes & LATT_NOINFERIORS) ? ", no inferiors" : "",
+	       (attributes & LATT_NOSELECT) ? ", no select" : "",
+	       (attributes & LATT_MARKED) ? ", marked" : "",
+	       (attributes & LATT_UNMARKED) ? ", unmarked" : "",
+	       (attributes & LATT_HASCHILDREN) ? ", has children" : "",
+	       (attributes & LATT_HASNOCHILDREN) ? ", has no children" : ""));
+#endif
+
+    if(!mm_list_info->stream || stream == mm_list_info->stream)
+      (*mm_list_info->filter)(stream, mailbox, delimiter,
+			      attributes, mm_list_info->data,
+			      mm_list_info->options);
+}
+
+
+void
+mm_status(MAILSTREAM *stream, char *mailbox, MAILSTATUS *status)
+{
+    /*
+     * We implement mail_status for the #move namespace by adding a wrapper
+     * routine, pine_mail_status. It may have to call the real mail_status
+     * twice for #move folders and combine the results. It sets
+     * pine_cached_status to point to a local status variable to store the
+     * intermediate results.
+     */
+    if(status){
+	if(pine_cached_status != NULL)
+	  *pine_cached_status = *status;
+	else
+	  mm_status_result = *status;
+    }
+
+#ifdef DEBUG
+    if(status){
+	if(pine_cached_status)
+	  dprint((2,
+		 "mm_status: Preliminary pass for #move\n"));
+
+	dprint((2, "mm_status: Mailbox \"%s\"",
+	       mailbox ? mailbox : "?"));
+	if(status->flags & SA_MESSAGES)
+	  dprint((2, ", %lu messages", status->messages));
+
+	if(status->flags & SA_RECENT)
+	  dprint((2, ", %lu recent", status->recent));
+
+	if(status->flags & SA_UNSEEN)
+	  dprint((2, ", %lu unseen", status->unseen));
+
+	if(status->flags & SA_UIDVALIDITY)
+	  dprint((2, ", %lu UID validity", status->uidvalidity));
+
+	if(status->flags & SA_UIDNEXT)
+	  dprint((2, ", %lu next UID", status->uidnext));
+
+	dprint((2, "\n"));
+    }
+#endif
+}
+
+
+/*----------------------------------------------------------------------
+      Write imap debugging information into log file
+
+   Args: strings -- the string for the debug file
+
+ Result: message written to the debug log file
+  ----*/
+void
+mm_dlog(char *string)
+{
+    char *p, *q = NULL, save, *continued;
+    int   more = 1;
+
+#ifdef	_WINDOWS
+    mswin_imaptelemetry(string);
+#endif
+#ifdef	DEBUG
+    continued = "";
+    p = string;
+#ifdef DEBUGJOURNAL
+    /* because string can be really long and we don't want to lose any of it */
+    if(p)
+      more = 1;
+
+    while(more){
+	if(q){
+	    *q = save;
+	    p = q;
+	    continued = "(Continuation line) ";
+	}
+
+	if(strlen(p) > 63000){
+	    q = p + 60000;
+	    save = *q;
+	    *q = '\0';
+	}
+	else
+	  more = 0;
+#endif
+	dprint(((ps_global->debug_imap >= 4 && debug < 4) ? debug : 4,
+		"IMAP DEBUG %s%s: %s\n",
+		continued ? continued : "",
+		debug_time(1, ps_global->debug_timestamp), p ? p : "?"));
+#ifdef DEBUGJOURNAL
+    }
+#endif
+#endif
+}
+
+
+/*----------------------------------------------------------------------
+     Ignore signals when imap is running through critical code
+
+ Args: stream -- The stream on which critical operation is proceeding
+ ----*/
+
+void 
+mm_critical(MAILSTREAM *stream)
+{
+    stream = stream; /* For compiler complaints that this isn't used */
+
+    if(++critical_depth == 1){
+
+#ifdef	SIGHUP
+	hold_hup  = signal(SIGHUP, SIG_IGN);
+#endif
+#ifdef	SIGUSR2
+	hold_usr2 = signal(SIGUSR2, SIG_IGN);
+#endif
+#ifdef	SIGINT
+	hold_int  = signal(SIGINT, SIG_IGN);
+#endif
+#ifdef	SIGTERM
+	hold_term = signal(SIGTERM, SIG_IGN);
+#endif
+    }
+
+    dprint((9, "IMAP critical (depth now %d) on %s\n",
+              critical_depth,
+	      (stream && stream->mailbox) ? stream->mailbox : "<no folder>" ));
+}
+
+
+/*----------------------------------------------------------------------
+   Reset signals after critical imap code
+ ----*/
+void
+mm_nocritical(MAILSTREAM *stream)
+{ 
+    stream = stream; /* For compiler complaints that this isn't used */
+
+    if(--critical_depth == 0){
+
+#ifdef	SIGHUP
+	(void)signal(SIGHUP, hold_hup);
+#endif
+#ifdef	SIGUSR2
+	(void)signal(SIGUSR2, hold_usr2);
+#endif
+#ifdef	SIGINT
+	(void)signal(SIGINT, hold_int);
+#endif
+#ifdef	SIGTERM
+	(void)signal(SIGTERM, hold_term);
+#endif
+    }
+
+    critical_depth = MAX(critical_depth, 0);
+
+    dprint((9, "Done with IMAP critical (depth now %d) on %s\n",
+              critical_depth,
+	      (stream && stream->mailbox) ? stream->mailbox : "<no folder>" ));
+}
+
+
+void
+mm_fatal(char *message)
+{
+    panic(message);
+}
+
+
+char *
+imap_referral(MAILSTREAM *stream, char *ref, long int code)
+{
+    char *buf = NULL;
+
+    if(ref && !struncmp(ref, "imap://", 7)){
+	char *folder = NULL;
+	imapuid_t uid_val, uid;
+	int rv;
+
+	rv = url_imap_folder(ref, &folder, &uid, &uid_val, NULL, 1);
+	switch(code){
+	  case REFAUTHFAILED :
+	  case REFAUTH :
+	    if((rv & URL_IMAP_IMAILBOXLIST) && (rv & URL_IMAP_ISERVERONLY))
+	      buf = cpystr(folder);
+
+	    break;
+
+	  case REFSELECT :
+	  case REFCREATE :
+	  case REFDELETE :
+	  case REFRENAME :
+	  case REFSUBSCRIBE :
+	  case REFUNSUBSCRIBE :
+	  case REFSTATUS :
+	  case REFCOPY :
+	  case REFAPPEND :
+	    if(rv & URL_IMAP_IMESSAGELIST)
+	      buf = cpystr(folder);
+
+	    break;
+
+	  default :
+	    break;
+	}
+
+	if(folder)
+	  fs_give((void **) &folder);
+    }
+
+    return(buf);
+}
+
+
+long
+imap_proxycopy(MAILSTREAM *stream, char *sequence, char *mailbox, long int flags)
+{
+    SE_APP_S args;
+    long ret;
+
+    args.folder = mailbox;
+    args.flags  = flags;
+
+    if(pith_opt_save_size_changed_prompt)
+      (*pith_opt_save_size_changed_prompt)(0L, SSCP_INIT);
+
+    ret = imap_seq_exec(stream, sequence, imap_seq_exec_append, &args);
+
+    if(pith_opt_save_size_changed_prompt)
+      (*pith_opt_save_size_changed_prompt)(0L, SSCP_END);
+
+    return(ret);
+}
+
+
+long
+imap_seq_exec(MAILSTREAM *stream, char *sequence,
+	      long int (*func)(MAILSTREAM *, long int, void *),
+	      void *args)
+{
+    unsigned long i,j,x;
+
+    while (*sequence) {		/* while there is something to parse */
+	if (*sequence == '*') {	/* maximum message */
+	    if(!(i = stream->nmsgs)){
+		mm_log ("No messages, so no maximum message number",ERROR);
+		return(0L);
+	    }
+
+	    sequence++;		/* skip past * */
+	}
+	else if (!(i = strtoul ((const char *) sequence,&sequence,10))
+		 || (i > stream->nmsgs)){
+	    mm_log ("Sequence invalid",ERROR);
+	    return(0L);
+	}
+
+	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 ((const char *) sequence,&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;
+	    }
+
+	    while (i <= j)
+	      if(!(*func)(stream, i++, args))
+		return(0L);
+
+	    break;
+	  case ',':			/* single message */
+	    ++sequence;		/* skip the delimiter, fall into end case */
+	  case '\0':		/* end of sequence */
+	    if(!(*func)(stream, i, args))
+	      return(0L);
+
+	    break;
+	  default:			/* anything else is a syntax error! */
+	    mm_log ("Sequence syntax error",ERROR);
+	    return NIL;
+	}
+    }
+
+    return T;			/* successfully parsed sequence */
+}
+
+
+long
+imap_seq_exec_append(MAILSTREAM *stream, long int msgno, void *args)
+{
+    char	 *save_folder, *flags = NULL, date[64];
+    CONTEXT_S    *cntxt = NULL;
+    int		  our_stream = 0;
+    long	  rv = 0L;
+    MAILSTREAM   *save_stream;
+    SE_APP_S	 *sa = (SE_APP_S *) args;
+    MESSAGECACHE *mc;
+    STORE_S      *so;
+
+    save_folder = (strucmp(sa->folder, ps_global->inbox_name) == 0)
+		    ? ps_global->VAR_INBOX_PATH : sa->folder;
+
+    save_stream = save_msg_stream(cntxt, save_folder, &our_stream);
+
+    if((so = so_get(CharStar, NULL, WRITE_ACCESS)) != NULL){
+	/* store flags before the fetch so UNSEEN bit isn't flipped */
+	mc = (msgno > 0L && stream && msgno <= stream->nmsgs)
+		? mail_elt(stream, msgno) : NULL;
+
+	flags = flag_string(stream, msgno, F_ANS|F_FWD|F_FLAG|F_SEEN|F_KEYWORD);
+	if(mc && mc->day)
+	  mail_date(date, mc);
+	else
+	  *date = '\0';
+
+	rv = save_fetch_append(stream, msgno, NULL,
+			       save_stream, save_folder, NULL,
+			       mc ? mc->rfc822_size : 0L, flags, date, so);
+	if(flags)
+	  fs_give((void **) &flags);
+
+	if(rv < 0 || sp_expunge_count(stream)){
+	    cmd_cancelled("Attached message Save");
+	    rv = 0L;
+	}
+	/* else whatever broke in save_fetch_append shoulda bitched */
+
+	so_give(&so);
+    }
+    else{
+	dprint((1, "Can't allocate store for save: %s\n",
+		   error_description(errno)));
+	q_status_message(SM_ORDER | SM_DING, 3, 4,
+			 "Problem creating space for message text.");
+    }
+
+    if(our_stream)
+      mail_close(save_stream);
+
+    return(rv);
+}
+
+
+
+/*----------------------------------------------------------------------
+      Get login and password from user for IMAP login
+  
+  Args:  mb -- The mail box property struct
+         user   -- Buffer to return the user name in 
+         passwd -- Buffer to return the passwd in
+         trial  -- The trial number or number of attempts to login
+    user is at least size NETMAXUSER
+    passwd is apparently at least MAILTMPLEN, but mrc has asked us to
+      use a max size of about 100 instead
+
+ Result: username and password passed back to imap
+  ----*/
+void
+mm_login(NETMBX *mb, char *user, char *pwd, long int trial)
+{
+    mm_login_work(mb, user, pwd, trial, NULL, NULL);
+}
+
+
+/*----------------------------------------------------------------------
+   Exported method to retrieve logged in user name associated with stream
+
+   Args: host -- host to find associated login name with.
+
+ Result: 
+  ----*/
+char *
+cached_user_name(char *host)
+{
+    MMLOGIN_S *l;
+    STRLIST_S *h;
+
+    if((l = mm_login_list) && host)
+      do
+	for(h = l->hosts; h; h = h->next)
+	  if(!strucmp(host, h->name))
+	    return(l->user);
+      while((l = l->next) != NULL);
+
+    return(NULL);
+}
+
+
+int
+imap_same_host(STRLIST_S *hl1, STRLIST_S *hl2)
+{
+    STRLIST_S *lp;
+
+    for( ; hl1; hl1 = hl1->next)
+      for(lp = hl2; lp; lp = lp->next)
+      if(!strucmp(hl1->name, lp->name))
+	return(TRUE);
+
+    return(FALSE);
+}
+
+
+/*
+ * For convenience, we use the same m_list structure (but a different
+ * instance) for storing a list of hosts we've asked the user about when
+ * SSL validation fails. If this function returns TRUE, that means we
+ * have previously asked the user about this host. Ok_novalidate == 1 means
+ * the user said yes, it was ok. Ok_novalidate == 0 means the user
+ * said no. Warned means we warned them already.
+ */
+int
+imap_get_ssl(MMLOGIN_S *m_list, STRLIST_S *hostlist, int *ok_novalidate, int *warned)
+{
+    MMLOGIN_S *l;
+    
+    for(l = m_list; l; l = l->next)
+      if(imap_same_host(l->hosts, hostlist)){
+	  if(ok_novalidate)
+	    *ok_novalidate = l->ok_novalidate;
+
+	  if(warned)
+	    *warned = l->warned;
+
+	  return(TRUE);
+      }
+
+    return(FALSE);
+}
+
+
+/*
+ * Just trying to guess the username the user might want to use on this
+ * host, the user will confirm.
+ */
+char *
+imap_get_user(MMLOGIN_S *m_list, STRLIST_S *hostlist)
+{
+    MMLOGIN_S *l;
+    
+    for(l = m_list; l; l = l->next)
+      if(imap_same_host(l->hosts, hostlist))
+	return(l->user);
+
+    return(NULL);
+}
+
+
+/*
+ * If we have a matching hostname, username, and altflag in our cache,
+ * attempt to login with the password from the cache.
+ */
+int
+imap_get_passwd(MMLOGIN_S *m_list, char *passwd, char *user, STRLIST_S *hostlist, int altflag)
+{
+    MMLOGIN_S *l;
+    
+    dprint((9,
+	       "imap_get_passwd: checking user=%s alt=%d host=%s%s%s\n",
+	       user ? user : "(null)",
+	       altflag,
+	       hostlist->name ? hostlist->name : "",
+	       (hostlist->next && hostlist->next->name) ? ", " : "",
+	       (hostlist->next && hostlist->next->name) ? hostlist->next->name
+						        : ""));
+    for(l = m_list; l; l = l->next)
+      if(imap_same_host(l->hosts, hostlist)
+	 && *user
+	 && !strcmp(user, l->user)
+	 && l->altflag == altflag){
+	  if(passwd){
+	      strncpy(passwd, l->passwd, NETMAXPASSWD);
+	      passwd[NETMAXPASSWD-1] = '\0';
+	  }
+	  dprint((9, "imap_get_passwd: match\n"));
+	  dprint((10, "imap_get_passwd: trying passwd=\"%s\"\n",
+		      passwd ? passwd : "?"));
+	  return(TRUE);
+      }
+
+    dprint((9, "imap_get_passwd: no match\n"));
+    return(FALSE);
+}
+
+
+
+void
+imap_set_passwd(MMLOGIN_S **l, char *passwd, char *user, STRLIST_S *hostlist,
+	        int altflag, int ok_novalidate, int warned)
+{
+    STRLIST_S **listp;
+    size_t      len;
+
+    dprint((9, "imap_set_passwd\n"));
+    for(; *l; l = &(*l)->next)
+      if(imap_same_host((*l)->hosts, hostlist)
+	 && !strcmp(user, (*l)->user)
+	 && altflag == (*l)->altflag){
+	if(strcmp(passwd, (*l)->passwd) ||
+	   (*l)->ok_novalidate != ok_novalidate ||
+	   (*l)->warned != warned)
+	  break;
+	else
+	  return;
+      }
+
+    if(!*l){
+	*l = (MMLOGIN_S *)fs_get(sizeof(MMLOGIN_S));
+	memset(*l, 0, sizeof(MMLOGIN_S));
+    }
+
+    len = strlen(passwd);
+    if(!(*l)->passwd || strlen((*l)->passwd) < len)
+      (*l)->passwd = ps_get(len+1);
+
+    strncpy((*l)->passwd, passwd, len+1);
+
+    (*l)->altflag = altflag;
+    (*l)->ok_novalidate = ok_novalidate;
+    (*l)->warned = warned;
+
+    if(!(*l)->user)
+      (*l)->user = cpystr(user);
+
+    dprint((9, "imap_set_passwd: user=%s altflag=%d\n",
+	   (*l)->user ? (*l)->user : "?",
+	   (*l)->altflag));
+
+    for( ; hostlist; hostlist = hostlist->next){
+	for(listp = &(*l)->hosts;
+	    *listp && strucmp((*listp)->name, hostlist->name);
+	    listp = &(*listp)->next)
+	  ;
+
+	if(!*listp){
+	    *listp = new_strlist(hostlist->name);
+	    dprint((9, "imap_set_passwd: host=%s\n",
+		       (*listp)->name ? (*listp)->name : "?"));
+	}
+    }
+
+    dprint((10, "imap_set_passwd: passwd=\"%s\"\n",
+	   passwd ? passwd : "?"));
+}
+
+
+
+void
+imap_flush_passwd_cache(int dumpcache)
+{
+    size_t len;
+    volatile char *p;
+
+    /* equivalent of memset but can't be optimized away */
+    len = sizeof(private_store);
+    p = private_store;
+    while(len-- > 0)
+      *p++ = '\0';
+
+    if(dumpcache){
+	MMLOGIN_S *l;
+
+	while((l = mm_login_list) != NULL){
+	    mm_login_list = mm_login_list->next;
+	    if(l->user)
+	      fs_give((void **) &l->user);
+
+	    free_strlist(&l->hosts);
+
+	    fs_give((void **) &l);
+	}
+
+	while((l = cert_failure_list) != NULL){
+	    cert_failure_list = cert_failure_list->next;
+	    if(l->user)
+	      fs_give((void **) &l->user);
+
+	    free_strlist(&l->hosts);
+
+	    fs_give((void **) &l);
+	}
+    }
+}
+
+
+/*
+ * Mimics fs_get except it only works for char * (no alignment hacks), it
+ * stores in a static array so it is easy to zero it out (that's the whole
+ * purpose), allocations always happen at the end (no free).
+ * If we go past array limit, we don't break, we just use free storage.
+ * Should be awfully rare, though.
+ */
+char *
+ps_get(size_t size)
+{
+    static char *last  = (char *) private_store;
+    char        *block = NULL;
+
+    /* there is enough space */
+    if(size <= sizeof(private_store) - (last - (char *) private_store)){
+	block = last;
+	last += size;
+    }
+    else{
+	dprint((2,
+		   "Out of password caching space in private_store\n"));
+	dprint((2,
+		   "Using free storage instead\n"));
+	block = fs_get(size);
+    }
+
+    return(block);
+}