Initial Alpine Version

1 files changed, 1629 insertions, 0 deletions

diff --git a/pith/ablookup.c b/pith/ablookup.c
new file mode 100644
index 00000000..63ff9133
--- /dev/null
+++ b/pith/ablookup.c
@@ -0,0 +1,1629 @@
+#if !defined(lint) && !defined(DOS)
+static char rcsid[] = "$Id: ablookup.c 1266 2009-07-14 18:39:12Z hubert@u.washington.edu $";
+#endif
+
+/*
+ * ========================================================================
+ * Copyright 2006-2009 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"	/* for os-dep and pith defs/includes */
+#include "../pith/debug.h"
+#include "../pith/util.h"
+#include "../pith/adrbklib.h"
+#include "../pith/copyaddr.h"
+#include "../pith/status.h"
+#include "../pith/conf.h"
+#include "../pith/search.h"
+#include "../pith/abdlc.h"
+#include "../pith/addrstring.h"
+#include "../pith/ablookup.h"
+#include "../pith/options.h"
+#include "../pith/takeaddr.h"
+#ifdef	ENABLE_LDAP
+#include "../pith/ldap.h"
+#endif	/* ENABLE_LDAP */
+
+
+/*
+ * Internal prototypes
+ */
+int   addr_is_in_addrbook(PerAddrBook *, ADDRESS *);
+ABOOK_ENTRY_S *adrbk_list_of_possible_trie_completions(AdrBk_Trie *, AdrBk *, char *, unsigned);
+void  gather_abook_entry_list(AdrBk *, AdrBk_Trie *, char *, ABOOK_ENTRY_S **, unsigned);
+void  add_addr_to_return_list(ADDRESS *, unsigned, char *, int, COMPLETE_S **);
+
+
+/*
+ * Given an address, try to find the first nickname that goes with it.
+ * Copies that nickname into the passed in buffer, which is assumed to
+ * be at least MAX_NICKNAME+1 in length.  Returns NULL if it can't be found,
+ * else it returns a pointer to the buffer.
+ */
+char *
+get_nickname_from_addr(struct mail_address *adr, char *buffer, size_t buflen)
+{
+    AdrBk_Entry *abe;
+    char        *ret = NULL;
+    SAVE_STATE_S state;
+    jmp_buf	 save_jmp_buf;
+    int         *save_nesting_level;
+    ADDRESS     *copied_adr;
+
+    state.savep = NULL;
+    state.stp = NULL;
+    state.dlc_to_warp_to = NULL;
+    copied_adr = copyaddr(adr);
+
+    if(ps_global->remote_abook_validity > 0)
+      (void)adrbk_check_and_fix_all(ab_nesting_level == 0, 0, 0);
+
+    save_nesting_level = cpyint(ab_nesting_level);
+    memcpy(save_jmp_buf, addrbook_changed_unexpectedly, sizeof(jmp_buf));
+    if(setjmp(addrbook_changed_unexpectedly)){
+	ret = NULL;
+	if(state.savep)
+	  fs_give((void **)&(state.savep));
+	if(state.stp)
+	  fs_give((void **)&(state.stp));
+	if(state.dlc_to_warp_to)
+	  fs_give((void **)&(state.dlc_to_warp_to));
+
+	q_status_message(SM_ORDER, 3, 5, _("Resetting address book..."));
+	dprint((1,
+	    "RESETTING address book... get_nickname_from_addr()!\n"));
+	addrbook_reset();
+	ab_nesting_level = *save_nesting_level;
+    }
+
+    ab_nesting_level++;
+    init_ab_if_needed();
+
+    if(pith_opt_save_and_restore)
+      (*pith_opt_save_and_restore)(SAR_SAVE, &state);
+
+    abe = address_to_abe(copied_adr);
+
+    if(copied_adr)
+      mail_free_address(&copied_adr);
+
+    if(abe && abe->nickname && abe->nickname[0]){
+	strncpy(buffer, abe->nickname, buflen-1);
+	buffer[buflen-1] = '\0';
+	ret = buffer;
+    }
+
+    if(pith_opt_save_and_restore)
+      (*pith_opt_save_and_restore)(SAR_RESTORE, &state);
+
+    memcpy(addrbook_changed_unexpectedly, save_jmp_buf, sizeof(jmp_buf));
+    ab_nesting_level--;
+
+    if(save_nesting_level)
+      fs_give((void **)&save_nesting_level);
+
+    return(ret);
+}
+
+
+/*
+ * Given an address, try to find the first fcc that goes with it.
+ * Copies that fcc into the passed in buffer.
+ * Returns NULL if it can't be found, else it returns a pointer to the buffer.
+ */
+char *
+get_fcc_from_addr(struct mail_address *adr, char *buffer, size_t buflen)
+{
+    AdrBk_Entry *abe;
+    char        *ret = NULL;
+    SAVE_STATE_S state;
+    jmp_buf	 save_jmp_buf;
+    int         *save_nesting_level;
+    ADDRESS     *copied_adr;
+
+    state.savep = NULL;
+    state.stp = NULL;
+    state.dlc_to_warp_to = NULL;
+    copied_adr = copyaddr(adr);
+
+    if(ps_global->remote_abook_validity > 0)
+      (void)adrbk_check_and_fix_all(ab_nesting_level == 0, 0, 0);
+
+    save_nesting_level = cpyint(ab_nesting_level);
+    memcpy(save_jmp_buf, addrbook_changed_unexpectedly, sizeof(jmp_buf));
+    if(setjmp(addrbook_changed_unexpectedly)){
+	ret = NULL;
+	if(state.savep)
+	  fs_give((void **)&(state.savep));
+	if(state.stp)
+	  fs_give((void **)&(state.stp));
+	if(state.dlc_to_warp_to)
+	  fs_give((void **)&(state.dlc_to_warp_to));
+
+	q_status_message(SM_ORDER, 3, 5, _("Resetting address book..."));
+	dprint((1,
+	    "RESETTING address book... get_fcc_from_addr()!\n"));
+	addrbook_reset();
+	ab_nesting_level = *save_nesting_level;
+    }
+
+    ab_nesting_level++;
+    init_ab_if_needed();
+
+    if(pith_opt_save_and_restore)
+      (*pith_opt_save_and_restore)(SAR_SAVE, &state);
+
+    abe = address_to_abe(copied_adr);
+
+    if(copied_adr)
+      mail_free_address(&copied_adr);
+
+    if(abe && abe->fcc && abe->fcc[0]){
+	if(!strcmp(abe->fcc, "\"\""))
+	  buffer[0] = '\0';
+	else{
+	    strncpy(buffer, abe->fcc, buflen-1);
+	    buffer[buflen-1] = '\0';
+	}
+
+	ret = buffer;
+    }
+
+    if(pith_opt_save_and_restore)
+      (*pith_opt_save_and_restore)(SAR_RESTORE, &state);
+
+    memcpy(addrbook_changed_unexpectedly, save_jmp_buf, sizeof(jmp_buf));
+    ab_nesting_level--;
+
+    if(save_nesting_level)
+      fs_give((void **)&save_nesting_level);
+
+    return(ret);
+}
+
+
+/*
+ * Given an address, try to find the first address book entry that
+ * matches it and return all the other fields in the passed in pointers.
+ * Caller needs to free the four fields.
+ * Returns -1 if it can't be found, 0 if it is found.
+ */
+int
+get_contactinfo_from_addr(struct mail_address *adr, char **nick, char **full, char **fcc, char **comment)
+{
+    AdrBk_Entry *abe;
+    int          ret = -1;
+    SAVE_STATE_S state;
+    jmp_buf	 save_jmp_buf;
+    int         *save_nesting_level;
+    ADDRESS     *copied_adr;
+
+    state.savep = NULL;
+    state.stp = NULL;
+    state.dlc_to_warp_to = NULL;
+    copied_adr = copyaddr(adr);
+
+    if(ps_global->remote_abook_validity > 0)
+      (void)adrbk_check_and_fix_all(ab_nesting_level == 0, 0, 0);
+
+    save_nesting_level = cpyint(ab_nesting_level);
+    memcpy(save_jmp_buf, addrbook_changed_unexpectedly, sizeof(jmp_buf));
+    if(setjmp(addrbook_changed_unexpectedly)){
+	ret = -1;
+	if(state.savep)
+	  fs_give((void **)&(state.savep));
+	if(state.stp)
+	  fs_give((void **)&(state.stp));
+	if(state.dlc_to_warp_to)
+	  fs_give((void **)&(state.dlc_to_warp_to));
+
+	q_status_message(SM_ORDER, 3, 5, _("Resetting address book..."));
+	dprint((1,
+	    "RESETTING address book... get_contactinfo_from_addr()!\n"));
+	addrbook_reset();
+	ab_nesting_level = *save_nesting_level;
+    }
+
+    ab_nesting_level++;
+    init_ab_if_needed();
+
+    if(pith_opt_save_and_restore)
+      (*pith_opt_save_and_restore)(SAR_SAVE, &state);
+
+    abe = address_to_abe(copied_adr);
+
+    if(copied_adr)
+      mail_free_address(&copied_adr);
+
+    if(abe){
+	if(nick && abe->nickname && abe->nickname[0])
+	  *nick = cpystr(abe->nickname);
+
+	if(full && abe->fullname && abe->fullname[0])
+	  *full = cpystr(abe->fullname);
+
+	if(fcc && abe->fcc && abe->fcc[0])
+	  *fcc = cpystr(abe->fcc);
+
+	if(comment && abe->extra && abe->extra[0])
+	  *comment = cpystr(abe->extra);
+
+	ret = 0;
+    }
+
+    if(pith_opt_save_and_restore)
+      (*pith_opt_save_and_restore)(SAR_RESTORE, &state);
+
+    memcpy(addrbook_changed_unexpectedly, save_jmp_buf, sizeof(jmp_buf));
+    ab_nesting_level--;
+
+    if(save_nesting_level)
+      fs_give((void **)&save_nesting_level);
+
+    return(ret);
+}
+
+
+/*
+ * This is a very special-purpose routine.
+ * It implements the From or Reply-To address is in the Address Book
+ * part of Pattern matching.
+ */
+void
+address_in_abook(MAILSTREAM *stream, SEARCHSET *searchset,
+			 int inabook, PATTERN_S *abooks)
+{
+    char         *savebits;
+    MESSAGECACHE *mc;
+    long          i, count = 0L;
+    SEARCHSET    *s, *ss;
+    ADDRESS      *from, *reply_to, *sender, *to, *cc;
+    int           is_there, adrbknum, *abooklist = NULL, positive_match;
+    PATTERN_S    *pat;
+    PerAddrBook  *pab;
+    ENVELOPE     *e;
+    SAVE_STATE_S  state;
+    jmp_buf	  save_jmp_buf;
+    int          *save_nesting_level;
+
+    if(!stream)
+      return;
+
+    /* everything that matches remains a match */
+    if(inabook == IAB_EITHER)
+      return;
+
+    state.savep          = NULL;
+    state.stp            = NULL;
+    state.dlc_to_warp_to = NULL;
+
+    /*
+     * This may call build_header_line recursively because we may be in
+     * build_header_line now. So we have to preserve and restore the
+     * sequence bits since we want to use them here.
+     */
+    savebits = (char *) fs_get((stream->nmsgs+1) * sizeof(char));
+
+    for(i = 1L; i <= stream->nmsgs; i++){
+	if((mc = mail_elt(stream, i)) != NULL){
+	    savebits[i] = mc->sequence;
+	    mc->sequence = 0;
+	}
+    }
+
+    /*
+     * Build a searchset so we can look at all the envelopes
+     * we need to look at but only those we need to look at.
+     * Everything with the searched bit set is still a
+     * possibility, so restrict to that set.
+     */
+
+    for(s = searchset; s; s = s->next)
+      for(i = s->first; i <= s->last; i++)
+	if(i > 0L && i <= stream->nmsgs
+	   && (mc=mail_elt(stream, i)) && mc->searched){
+	    mc->sequence = 1;
+	    count++;
+	}
+
+    ss = build_searchset(stream);
+
+    /*
+     * We save the address book state here so we don't have to do it
+     * each time through the loop below.
+     */
+    if(ss){
+	if(ps_global->remote_abook_validity > 0)
+	  (void)adrbk_check_and_fix_all(ab_nesting_level == 0, 0, 0);
+
+	save_nesting_level = cpyint(ab_nesting_level);
+	memcpy(save_jmp_buf, addrbook_changed_unexpectedly, sizeof(jmp_buf));
+	if(setjmp(addrbook_changed_unexpectedly)){
+	    if(state.savep)
+	      fs_give((void **)&(state.savep));
+	    if(state.stp)
+	      fs_give((void **)&(state.stp));
+	    if(state.dlc_to_warp_to)
+	      fs_give((void **)&(state.dlc_to_warp_to));
+
+	    q_status_message(SM_ORDER, 3, 5, _("Resetting address book..."));
+	    dprint((1,
+		"RESETTING address book... address_in_abook()!\n"));
+	    addrbook_reset();
+	    ab_nesting_level = *save_nesting_level;
+	}
+
+	ab_nesting_level++;
+	init_ab_if_needed();
+
+	if(pith_opt_save_and_restore)
+	  (*pith_opt_save_and_restore)(SAR_SAVE, &state);
+
+	if(as.n_addrbk > 0){
+	    abooklist = (int *) fs_get(as.n_addrbk * sizeof(*abooklist));
+	    memset((void *) abooklist, 0, as.n_addrbk * sizeof(*abooklist));
+	}
+
+	if(abooklist)
+	  switch(inabook & IAB_TYPE_MASK){
+	    case IAB_YES:
+	    case IAB_NO:
+	      for(adrbknum = 0; adrbknum < as.n_addrbk; adrbknum++)
+	        abooklist[adrbknum] = 1;
+
+	      break;
+
+	    case IAB_SPEC_YES:
+	    case IAB_SPEC_NO:
+	      /* figure out which address books we're going to look in */
+	      for(adrbknum = 0; adrbknum < as.n_addrbk; adrbknum++){
+		  pab = &as.adrbks[adrbknum];
+		  /*
+		   * For each address book, check all of the address books
+		   * in the pattern's list to see if they are it.
+		   */
+		  for(pat = abooks; pat; pat = pat->next){
+		      if(!strcmp(pab->abnick, pat->substring)
+			 || !strcmp(pab->filename, pat->substring)){
+			  abooklist[adrbknum] = 1;
+			  break;
+		      }
+		  }
+	      }
+
+	      break;
+	   }
+
+	switch(inabook & IAB_TYPE_MASK){
+	  case IAB_YES:
+	  case IAB_SPEC_YES:
+	    positive_match = 1;
+	    break;
+
+	  case IAB_NO:
+	  case IAB_SPEC_NO:
+	    positive_match = 0;
+	    break;
+	}
+    }
+
+    if(count){
+	SEARCHSET    **sset;
+
+	mail_parameters(NULL, SET_FETCHLOOKAHEADLIMIT, (void *) count);
+
+	/*
+	 * This causes the lookahead to fetch precisely
+	 * the messages we want (in the searchset) instead
+	 * of just fetching the next 20 sequential
+	 * messages. If the searching so far has caused
+	 * a sparse searchset in a large mailbox, the
+	 * difference can be substantial.
+	 * This resets automatically after the first fetch.
+	 */
+	sset = (SEARCHSET **) mail_parameters(stream,
+					      GET_FETCHLOOKAHEAD,
+					      (void *) stream);
+	if(sset)
+	  *sset = ss;
+    }
+
+    for(s = ss; s; s = s->next){
+	for(i = s->first; i <= s->last; i++){
+	    if(i <= 0L || i > stream->nmsgs)
+	      continue;
+
+	    e = pine_mail_fetchenvelope(stream, i);
+
+	    from = e ? e->from : NULL;
+	    reply_to = e ? e->reply_to : NULL;
+	    sender = e ? e->sender : NULL;
+	    to = e ? e->to : NULL;
+	    cc = e ? e->cc : NULL;
+
+	    is_there = 0;
+	    for(adrbknum = 0; !is_there && adrbknum < as.n_addrbk; adrbknum++){
+		if(!abooklist[adrbknum])
+		  continue;
+		
+		pab = &as.adrbks[adrbknum];
+		is_there = ((inabook & IAB_FROM) && addr_is_in_addrbook(pab, from))
+			   || ((inabook & IAB_REPLYTO) && addr_is_in_addrbook(pab, reply_to))
+			   || ((inabook & IAB_SENDER) && addr_is_in_addrbook(pab, sender))
+			   || ((inabook & IAB_TO) && addr_is_in_addrbook(pab, to))
+			   || ((inabook & IAB_CC) && addr_is_in_addrbook(pab, cc));
+	    }
+
+	    if(positive_match){
+		/*
+		 * We matched up until now. If it isn't there, then it
+		 * isn't a match. If it is there, leave the searched bit
+		 * set.
+		 */
+		if(!is_there && i > 0L && i <= stream->nmsgs && (mc = mail_elt(stream, i)))
+		  mc->searched = NIL;
+	    }
+	    else{
+		if(is_there && i > 0L && i <= stream->nmsgs && (mc = mail_elt(stream, i)))
+		  mc->searched = NIL;
+	    }
+	}
+    }
+
+    if(ss){
+	if(pith_opt_save_and_restore)
+	  (*pith_opt_save_and_restore)(SAR_RESTORE, &state);
+
+	memcpy(addrbook_changed_unexpectedly, save_jmp_buf, sizeof(jmp_buf));
+	ab_nesting_level--;
+
+	if(save_nesting_level)
+	  fs_give((void **)&save_nesting_level);
+    }
+
+    /* restore sequence bits */
+    for(i = 1L; i <= stream->nmsgs; i++)
+      if((mc = mail_elt(stream, i)) != NULL)
+        mc->sequence = savebits[i];
+
+    fs_give((void **) &savebits);
+
+    if(ss)
+      mail_free_searchset(&ss);
+
+    if(abooklist)
+      fs_give((void **) &abooklist);
+}
+
+
+/*
+ * Given two addresses, check to see if either is in the address book.
+ * Returns 1 if yes, 0 if not found.
+ */
+int
+addr_is_in_addrbook(PerAddrBook *pab, struct mail_address *addr)
+{
+    AdrBk_Entry *abe = NULL;
+    int          ret = 0;
+    char         abuf[MAX_ADDR_FIELD+1];
+
+    if(!(pab && addr && addr->mailbox))
+      return(ret);
+
+    if(addr){
+	strncpy(abuf, addr->mailbox, sizeof(abuf)-1);
+	abuf[sizeof(abuf)-1] = '\0';
+	if(addr->host && addr->host[0]){
+	    strncat(abuf, "@", sizeof(abuf)-strlen(abuf)-1);
+	    strncat(abuf, addr->host, sizeof(abuf)-strlen(abuf)-1);
+	}
+
+	if(pab->ostatus != Open && pab->ostatus != NoDisplay)
+	  init_abook(pab, NoDisplay);
+	
+	abe = adrbk_lookup_by_addr(pab->address_book, abuf,
+				   (adrbk_cntr_t *) NULL);
+    }
+
+    ret = abe ? 1 : 0;
+
+    return(ret);
+}
+
+
+/*
+ * Look through addrbooks for nickname, opening addrbooks first
+ * if necessary.  It is assumed that the caller will restore the
+ * state of the addrbooks if desired.
+ *
+ * Args: nickname       -- the nickname to lookup
+ *       clearrefs      -- clear reference bits before lookup
+ *       which_addrbook -- If matched, addrbook number it was found in.
+ *       not_here       -- If non-negative, skip looking in this abook.
+ *
+ * Results: A pointer to an AdrBk_Entry is returned, or NULL if not found.
+ * Stop at first match (so order of addrbooks is important).
+ */
+AdrBk_Entry *
+adrbk_lookup_with_opens_by_nick(char *nickname, int clearrefs, int *which_addrbook, int not_here)
+{
+    AdrBk_Entry *abe = (AdrBk_Entry *)NULL;
+    int i;
+    PerAddrBook *pab;
+
+    dprint((5, "- adrbk_lookup_with_opens_by_nick(%s) -\n",
+	nickname ? nickname : "?"));
+
+    for(i = 0; i < as.n_addrbk; i++){
+
+	if(i == not_here)
+	  continue;
+
+	pab = &as.adrbks[i];
+
+	if(pab->ostatus != Open && pab->ostatus != NoDisplay)
+	  init_abook(pab, NoDisplay);
+
+	if(clearrefs)
+	  adrbk_clearrefs(pab->address_book);
+
+	abe = adrbk_lookup_by_nick(pab->address_book,
+		    nickname,
+		    (adrbk_cntr_t *)NULL);
+	if(abe)
+	  break;
+    }
+
+    if(abe && which_addrbook)
+      *which_addrbook = i;
+
+    return(abe);
+}
+
+
+/*
+ * Find the addressbook entry that matches the argument address.
+ * Searches through all addressbooks looking for the match.
+ * Opens addressbooks if necessary.  It is assumed that the caller
+ * will restore the state of the addrbooks if desired.
+ *
+ * Args: addr -- the address we're trying to match
+ *
+ * Returns:  NULL -- no match found
+ *           abe  -- a pointer to the addrbook entry that matches
+ */
+AdrBk_Entry *
+address_to_abe(struct mail_address *addr)
+{
+    register PerAddrBook *pab;
+    int adrbk_number;
+    AdrBk_Entry *abe = NULL;
+    char *abuf = NULL;
+
+    if(!(addr && addr->mailbox))
+      return (AdrBk_Entry *)NULL;
+
+    abuf = (char *)fs_get((MAX_ADDR_FIELD + 1) * sizeof(char));
+
+    strncpy(abuf, addr->mailbox, MAX_ADDR_FIELD);
+    abuf[MAX_ADDR_FIELD] = '\0';
+    if(addr->host && addr->host[0]){
+	strncat(abuf, "@", MAX_ADDR_FIELD+1-1-strlen(abuf));
+	strncat(abuf, addr->host, MAX_ADDR_FIELD+1-1-strlen(abuf));
+    }
+
+    /* for each addressbook */
+    for(adrbk_number = 0; adrbk_number < as.n_addrbk; adrbk_number++){
+
+	pab = &as.adrbks[adrbk_number];
+
+	if(pab->ostatus != Open && pab->ostatus != NoDisplay)
+	  init_abook(pab, NoDisplay);
+
+	abe = adrbk_lookup_by_addr(pab->address_book,
+				   abuf,
+				   (adrbk_cntr_t *)NULL);
+	if(abe)
+	  break;
+    }
+
+    if(abuf)
+      fs_give((void **)&abuf);
+
+    return(abe);
+}
+
+
+/*
+ * Turn an AdrBk_Entry into an address list
+ *
+ * Args: abe      -- the AdrBk_Entry
+ *       dl       -- the corresponding dl
+ *       abook    -- which addrbook the abe is in (only used for type ListEnt)
+ *       how_many -- The number of addresses is returned here
+ *
+ * Result:  allocated address list or NULL
+ */
+ADDRESS *
+abe_to_address(AdrBk_Entry *abe, AddrScrn_Disp *dl, AdrBk *abook, int *how_many)
+{
+    char          *fullname, *tmp_a_string;
+    char          *list, *l1, **l2;
+    char          *fakedomain = "@";
+    ADDRESS       *addr = NULL;
+    size_t         length;
+    int            count = 0;
+
+    if(!dl || !abe)
+      return(NULL);
+
+    fullname = (abe->fullname && abe->fullname[0]) ? abe->fullname : NULL;
+
+    switch(dl->type){
+      case Simple:
+	/* rfc822_parse_adrlist feels free to destroy input so send copy */
+	tmp_a_string = cpystr(abe->addr.addr);
+	rfc822_parse_adrlist(&addr, tmp_a_string, fakedomain);
+
+	if(tmp_a_string)
+	  fs_give((void **)&tmp_a_string);
+
+	if(addr && fullname){
+#ifdef	ENABLE_LDAP
+	    if(strncmp(addr->mailbox, RUN_LDAP, LEN_RL) != 0)
+#endif	/* ENABLE_LDAP */
+	    {
+		if(addr->personal)
+		  fs_give((void **)&addr->personal);
+
+		addr->personal = adrbk_formatname(fullname, NULL, NULL);
+	    }
+	}
+
+	if(addr)
+	  count++;
+
+        break;
+
+      case ListEnt:
+	/* rfc822_parse_adrlist feels free to destroy input so send copy */
+	tmp_a_string = cpystr(listmem_from_dl(abook, dl));
+	rfc822_parse_adrlist(&addr, tmp_a_string, fakedomain);
+	if(tmp_a_string)
+	  fs_give((void **)&tmp_a_string);
+
+	if(addr)
+	  count++;
+
+        break;
+
+      case ListHead:
+	length = 0;
+	for(l2 = abe->addr.list; *l2; l2++)
+	  length += (strlen(*l2) + 1);
+
+	list = (char *)fs_get(length + 1);
+	l1 = list;
+	for(l2 = abe->addr.list; *l2; l2++){
+	    if(l1 != list && length-(l1-list) > 0)
+	      *l1++ = ',';
+
+	    strncpy(l1, *l2, length-(l1-list));
+	    list[length] = '\0';
+	    l1 += strlen(l1);
+	    count++;
+	}
+
+	rfc822_parse_adrlist(&addr, list, fakedomain);
+	if(list)
+	  fs_give((void **)&list);
+
+        break;
+      
+      default:
+	dprint((1, "default case in abe_to_address, shouldn't happen\n"));
+	break;
+    } 
+
+    if(how_many)
+      *how_many = count;
+
+    return(addr);
+}
+
+
+/*
+ * Turn an AdrBk_Entry into a nickname (if it has a nickname) or a
+ * formatted addr_string which has been rfc1522 decoded.
+ *
+ * Args: abe      -- the AdrBk_Entry
+ *       dl       -- the corresponding dl
+ *       abook    -- which addrbook the abe is in (only used for type ListEnt)
+ *
+ * Result:  allocated string is returned
+ */
+char *
+abe_to_nick_or_addr_string(AdrBk_Entry *abe, AddrScrn_Disp *dl, int abook_num)
+{
+    ADDRESS       *addr;
+    char          *a_string;
+
+    if(!dl || !abe)
+      return(cpystr(""));
+
+    if((dl->type == Simple || dl->type == ListHead)
+       && abe->nickname && abe->nickname[0]){
+	char *fname;
+	int   which_addrbook;
+
+	/*
+	 * We prefer to pass back the nickname since that allows the
+	 * caller to keep track of which entry the address came from.
+	 * This is useful in build_address so that the fcc line can
+	 * be kept correct. However, if the nickname is also present in
+	 * another addressbook then we have to be careful. If that other
+	 * addressbook comes before this one then passing back the nickname
+	 * will cause the wrong entry to get used. So check for that
+	 * and pass back the addr_string in that case.
+	 */
+	if((fname = addr_lookup(abe->nickname, &which_addrbook, abook_num)) != NULL){
+	    fs_give((void **)&fname);
+	    if(which_addrbook >= abook_num)
+	      return(cpystr(abe->nickname));
+	}
+	else
+	  return(cpystr(abe->nickname));
+    }
+
+    addr = abe_to_address(abe, dl, as.adrbks[abook_num].address_book, NULL);
+    a_string = addr_list_string(addr, NULL, 0); /* always returns a string */
+    if(addr)
+      mail_free_address(&addr);
+    
+    return(a_string);
+}
+
+
+/*
+ * Check to see if address is that of the current user running pine
+ *
+ * Args: a  -- Address to check
+ *       ps -- The pine_state structure
+ *
+ * Result: returns 1 if it matches, 0 otherwise.
+ *
+ * The mailbox must match the user name and the hostname must match.
+ * In matching the hostname, matches occur if the hostname in the address
+ * is blank, or if it matches the local hostname, or the full hostname
+ * with qualifying domain, or the qualifying domain without a specific host.
+ * Note, there is a very small chance that we will err on the
+ * non-conservative side here.  That is, we may decide two addresses are
+ * the same even though they are different (because we do case-insensitive
+ * compares on the mailbox).  That might cause a reply not to be sent to
+ * somebody because they look like they are us.  This should be very,
+ * very rare.
+ *
+ * It is also considered a match if any of the addresses in alt-addresses
+ * matches a.  The check there is simpler.  It parses each address in
+ * the list, adding maildomain if there wasn't a domain, and compares
+ * mailbox and host in the ADDRESS's for equality.
+ */
+int
+address_is_us(struct mail_address *a, struct pine *ps)
+{
+    char **t;
+    int ret;
+    char addrstr[500];
+
+    if(!a || a->mailbox == NULL || !ps)
+      ret = 0;
+
+    /* at least LHS must match, but case-independent */
+    else if(strucmp(a->mailbox, ps->VAR_USER_ID) == 0
+
+                      && /* and hostname matches */
+
+    /* hostname matches if it's not there, */
+    (a->host == NULL ||
+       /* or if hostname and userdomain (the one user sets) match exactly, */
+      ((ps->userdomain && a->host && strucmp(a->host,ps->userdomain) == 0) ||
+
+              /*
+               * or if(userdomain is either not set or it is set to be
+               * the same as the localdomain or hostname) and (the hostname
+               * of the address matches either localdomain or hostname)
+               */
+             ((ps->userdomain == NULL ||
+               strucmp(ps->userdomain, ps->localdomain) == 0 ||
+               strucmp(ps->userdomain, ps->hostname) == 0) &&
+              (strucmp(a->host, ps->hostname) == 0 ||
+               strucmp(a->host, ps->localdomain) == 0)))))
+      ret = 1;
+
+    /*
+     * If no match yet, check to see if it matches any of the alternate
+     * addresses the user has specified.
+     */
+    else if(!ps_global->VAR_ALT_ADDRS ||
+	    !ps_global->VAR_ALT_ADDRS[0] ||
+	    !ps_global->VAR_ALT_ADDRS[0][0])
+	ret = 0;  /* none defined */
+
+    else{
+	ret = 0;
+	if(a && a->host && a->mailbox)
+	  snprintf(addrstr, sizeof(addrstr), "%s@%s", a->mailbox, a->host);
+
+	for(t = ps_global->VAR_ALT_ADDRS; !ret && t[0] && t[0][0]; t++){
+	    char    *alt;
+	    regex_t reg;
+	    int err;
+	    char ebuf[200];
+
+	    alt  = (*t);
+
+	    if(F_ON(F_DISABLE_REGEX, ps_global) || !contains_regex_special_chars(alt)){
+		ADDRESS *alt_addr;
+		char    *alt2;
+
+		alt2 = cpystr(alt);
+		alt_addr = NULL;
+		rfc822_parse_adrlist(&alt_addr, alt2, ps_global->maildomain);
+		if(alt2)
+		  fs_give((void **) &alt2);
+
+		if(address_is_same(a, alt_addr))
+		  ret = 1;
+
+		if(alt_addr)
+		  mail_free_address(&alt_addr);
+	    }
+	    else{
+		/* treat alt as a regular expression */
+		ebuf[0] = '\0';
+		if(!(err=regcomp(&reg, alt, REG_ICASE | REG_NOSUB | REG_EXTENDED))){
+		    err = regexec(&reg, addrstr, 0, NULL, 0);
+		    if(err == 0)
+		      ret = 1;
+		    else if(err != REG_NOMATCH){
+			regerror(err, &reg, ebuf, sizeof(ebuf));
+			if(ebuf[0])
+			  dprint((2, "- address_is_us regexec error: %s (%s)", ebuf, alt));
+		    }
+
+		    regfree(&reg);
+		}
+		else{
+		    regerror(err, &reg, ebuf, sizeof(ebuf));
+		    if(ebuf[0])
+		      dprint((2, "- address_is_us regcomp error: %s (%s)", ebuf, alt));
+		}
+	    }
+	}
+    }
+
+    return(ret);
+}
+
+
+/*
+ * In an ad hoc way try to decide if str is meant to be a regular
+ * expression or not. Dot doesn't count * as regex stuff because
+ * we're worried about addresses.
+ *
+ * Returns 0 or 1
+ */
+int
+contains_regex_special_chars(char *str)
+{
+    char special_chars[] = {'*', '|',  '+', '?', '{', '[', '^', '$', '\\',  '\0'};
+    char *c;
+
+    if(!str)
+      return 0;
+
+    /*
+     * If any of special_chars are in str consider it a regex expression.
+     */
+    for(c = special_chars; *c; c++)
+      if(strindex(str, *c))
+        return 1;
+
+    return 0;
+}
+
+
+/*
+ * Compare the two addresses, and return true if they're the same,
+ * false otherwise
+ *
+ * Args: a -- First address for comparison
+ *       b -- Second address for comparison
+ *
+ * Result: returns 1 if it matches, 0 otherwise.
+ */
+int
+address_is_same(struct mail_address *a, struct mail_address *b)
+{
+    return(a && b && a->mailbox && b->mailbox && a->host && b->host
+	   && strucmp(a->mailbox, b->mailbox) == 0
+	   && strucmp(a->host, b->host) == 0);
+}
+
+
+/*
+ * Returns nonzero if the two address book entries are equal.
+ * Returns zero if not equal.
+ */
+int
+abes_are_equal(AdrBk_Entry *a, AdrBk_Entry *b)
+{
+    int    result = 0;
+    char **alist, **blist;
+    char  *addra, *addrb;
+
+    if(a && b &&
+       a->tag == b->tag &&
+       ((!a->nickname && !b->nickname) ||
+	(a->nickname && b->nickname && strcmp(a->nickname,b->nickname) == 0)) &&
+       ((!a->fullname && !b->fullname) ||
+	(a->fullname && b->fullname && strcmp(a->fullname,b->fullname) == 0)) &&
+       ((!a->fcc && !b->fcc) ||
+	(a->fcc && b->fcc && strcmp(a->fcc,b->fcc) == 0)) &&
+       ((!a->extra && !b->extra) ||
+	(a->extra && b->extra && strcmp(a->extra,b->extra) == 0))){
+
+	/* If we made it in here, they still might be equal. */
+	if(a->tag == Single)
+	  result = strcmp(a->addr.addr,b->addr.addr) == 0;
+	else{
+	    alist = a->addr.list;
+	    blist = b->addr.list;
+	    if(!alist && !blist)
+	      result = 1;
+	    else{
+		/* compare the whole lists */
+		addra = *alist;
+		addrb = *blist;
+		while(addra && addrb && strcmp(addra,addrb) == 0){
+		    alist++;
+		    blist++;
+		    addra = *alist;
+		    addrb = *blist;
+		}
+
+		if(!addra && !addrb)
+		  result = 1;
+	    }
+	}
+    }
+
+    return(result);
+}
+
+
+/*
+ *  Interface to address book lookups for callers outside or inside this file.
+ *
+ * Args: nickname       -- The nickname to look up
+ *       which_addrbook -- If matched, addrbook number it was found in.
+ *       not_here       -- If non-negative, skip looking in this abook.
+ *
+ * Result: returns NULL or the corresponding fullname.  The fullname is
+ * allocated here so the caller must free it.
+ *
+ * This opens the address books if they haven't been opened and restores
+ * them to the state they were in upon entry.
+ */
+char *
+addr_lookup(char *nickname, int *which_addrbook, int not_here)
+{
+    AdrBk_Entry  *abe;
+    SAVE_STATE_S  state;
+    char         *fullname;
+
+    dprint((9, "- addr_lookup(%s) -\n",nickname ? nickname : "nil"));
+
+    init_ab_if_needed();
+
+    if(pith_opt_save_and_restore)
+      (*pith_opt_save_and_restore)(SAR_SAVE, &state);
+
+    abe = adrbk_lookup_with_opens_by_nick(nickname,0,which_addrbook,not_here);
+
+    fullname = (abe && abe->fullname) ? cpystr(abe->fullname) : NULL;
+
+    if(pith_opt_save_and_restore)
+      (*pith_opt_save_and_restore)(SAR_RESTORE, &state);
+
+    return(fullname);
+}
+
+
+/*
+ * Look in all of the address books for all of the possible entries
+ * that match the query string. The matches can be for the nickname,
+ * for the fullname, or for the address@host part of the address.
+ * All of the matches are at the starts of the strings, not a general
+ * substring match. This is not true anymore. Fullname matches can be
+ * at the start of the fullname or starting after a space in the fullname.
+ * If flags has ALC_INCLUDE_LDAP defined then LDAP
+ * entries are added to the end of the list. The LDAP queries are done
+ * only for those servers that have the 'impl' feature turned on, which
+ * means that lookups should be done implicitly. This feature also
+ * controls whether or not lookups should be done when typing carriage
+ * return (instead of this which is TAB).
+ *
+ * Args     query  -- What the user has typed so far
+ *
+ * Returns a list of possibilities for the given query string.
+ *
+ * Caller needs to free the answer.
+ */
+COMPLETE_S *
+adrbk_list_of_completions(char *query, MAILSTREAM *stream, imapuid_t uid, int flags)
+{
+    int i;
+    SAVE_STATE_S  state;
+    PerAddrBook  *pab;
+    ABOOK_ENTRY_S *list, *list2, *biglist = NULL;
+    COMPLETE_S *return_list = NULL, *last_one_added = NULL, *new, *cp, *dp, *dprev;
+    BuildTo toaddr;
+    ADDRESS *addr;
+    char buf[1000];
+    char *newaddr = NULL, *simple_addr = NULL, *fcc = NULL;
+    ENVELOPE *env = NULL;
+    BODY *body = NULL;
+
+    init_ab_if_needed();
+
+    if(pith_opt_save_and_restore)
+      (*pith_opt_save_and_restore)(SAR_SAVE, &state);
+
+    for(i = 0; i < as.n_addrbk; i++){
+
+	pab = &as.adrbks[i];
+
+	if(pab->ostatus != Open && pab->ostatus != NoDisplay)
+	  init_abook(pab, NoDisplay);
+
+	list = adrbk_list_of_possible_completions(pab ? pab->address_book : NULL, query);
+	combine_abook_entry_lists(&biglist, list);
+    }
+
+    /*
+     * Eliminate duplicates by NO_NEXTing the entrynums.
+     */
+    for(list = biglist; list; list = list->next)
+      /* eliminate any dups further along in the list */
+      if(list->entrynum != NO_NEXT)
+	for(list2 = list->next; list2; list2 = list2->next)
+	  if(list2->entrynum ==  list->entrynum){
+	      list2->entrynum = NO_NEXT;
+	      list->matches_bitmap |= list2->matches_bitmap;
+	  }
+
+    /* build the return list */
+    for(list = biglist; list; list = list->next)
+      if(list->entrynum != NO_NEXT){
+	  fcc = NULL;
+	  toaddr.type = Abe;
+	  toaddr.arg.abe = adrbk_get_ae(list->ab, list->entrynum);
+	  if(our_build_address(toaddr, &newaddr, NULL, &fcc, NULL) == 0){
+	      char    *reverse_fullname = NULL;
+
+	      /*
+	       * ALC_FULL is a regular FullName match and that will be
+	       * captured in the full_address field. If there was also
+	       * an ALC_REVFULL match that means that the user has the
+	       * FullName entered in their addrbook as Last, First and
+	       * that is where the match was. We want to put that in
+	       * the completions structure in the rev_fullname field.
+	       */
+	      if(list->matches_bitmap & ALC_REVFULL
+	         && toaddr.arg.abe
+		 && toaddr.arg.abe->fullname && toaddr.arg.abe->fullname[0]
+		 && toaddr.arg.abe->fullname[0] != '"'
+		 && strindex(toaddr.arg.abe->fullname, ',') != NULL){
+
+		  reverse_fullname = toaddr.arg.abe->fullname;
+	      }
+
+	      if(flags & ALC_INCLUDE_ADDRS){
+		  if(toaddr.arg.abe && toaddr.arg.abe->tag == Single
+		     && toaddr.arg.abe->addr.addr && toaddr.arg.abe->addr.addr[0]){
+		      char    *tmp_a_string;
+		      char    *fakedomain = "@";
+
+		      tmp_a_string = cpystr(toaddr.arg.abe->addr.addr);
+		      addr = NULL;
+		      rfc822_parse_adrlist(&addr, tmp_a_string, fakedomain);
+		      if(tmp_a_string)
+			fs_give((void **) &tmp_a_string);
+		     
+		      if(addr){
+			  if(addr->mailbox && addr->host
+			     && !(addr->host[0] == '@' && addr->host[1] == '\0'))
+			    simple_addr = simple_addr_string(addr, buf, sizeof(buf));
+
+			  mail_free_address(&addr);
+		      }
+		  }
+	      }
+
+	      new = new_complete_s(toaddr.arg.abe ? toaddr.arg.abe->nickname : NULL,
+				   newaddr, simple_addr, reverse_fullname, fcc,
+				   list->matches_bitmap | ALC_ABOOK);
+
+	      /* add to end of list */
+	      if(return_list == NULL){
+		  return_list = new;
+		  last_one_added = new;
+	      }
+	      else{
+		  last_one_added->next = new;
+		  last_one_added = new;
+	      }
+	  }
+
+	  if(newaddr)
+	    fs_give((void **) &newaddr);
+      }
+
+    if(pith_opt_save_and_restore)
+      (*pith_opt_save_and_restore)(SAR_RESTORE, &state);
+
+    free_abook_entry_s(&biglist);
+
+#ifdef	ENABLE_LDAP
+    if(flags & ALC_INCLUDE_LDAP){
+	LDAP_SERV_RES_S *head_of_result_list = NULL, *res;
+	LDAP_CHOOSE_S cs;
+	WP_ERR_S wp_err;
+	LDAPMessage *e;
+
+	memset(&wp_err, 0, sizeof(wp_err));
+
+	/*
+	 * This lookup covers all servers with the impl bit set.
+	 * It uses the regular LDAP search parameters that the
+	 * user has set, not necessarily just a prefix match
+	 * like the rest of the address completion above.
+	 */
+	head_of_result_list = ldap_lookup_all_work(query, as.n_serv, 0, NULL, &wp_err);
+	for(res = head_of_result_list; res; res = res->next){
+	  for(e = ldap_first_entry(res->ld, res->res);
+	      e != NULL;
+	      e = ldap_next_entry(res->ld, e)){
+	    simple_addr = newaddr = NULL;
+	    cs.ld = res->ld;
+	    cs.selected_entry = e;
+	    cs.info_used = res->info_used;
+	    cs.serv = res->serv;
+	    addr = address_from_ldap(&cs);
+	    if(addr){
+		add_addr_to_return_list(addr, ALC_LDAP, query, flags, &return_list);
+		mail_free_address(&addr);
+	    }
+	  }
+	}
+
+	if(wp_err.error)
+	  fs_give((void **) &wp_err.error);
+
+	if(head_of_result_list)
+	  free_ldap_result_list(&head_of_result_list);
+    }
+#endif	/* ENABLE_LDAP */
+
+    /* add from current message */
+    if(uid > 0 && stream)
+      env = pine_mail_fetch_structure(stream, uid, &body, FT_UID);
+
+    /* from the envelope addresses */
+    if(env){
+	for(addr = env->from; addr; addr = addr->next)
+	  add_addr_to_return_list(addr, ALC_CURR, query, flags, &return_list);
+
+	for(addr = env->reply_to; addr; addr = addr->next)
+	  add_addr_to_return_list(addr, ALC_CURR, query, flags, &return_list);
+
+	for(addr = env->sender; addr; addr = addr->next)
+	  add_addr_to_return_list(addr, ALC_CURR, query, flags, &return_list);
+
+	for(addr = env->to; addr; addr = addr->next)
+	  add_addr_to_return_list(addr, ALC_CURR, query, flags, &return_list);
+
+	for(addr = env->cc; addr; addr = addr->next)
+	  add_addr_to_return_list(addr, ALC_CURR, query, flags, &return_list);
+
+	/*
+	 * May as well search the body for addresses.
+	 * Use this function written for TakeAddr.
+	 */
+	if(body){
+	    TA_S *talist = NULL, *tp;
+
+	    if(grab_addrs_from_body(stream, mail_msgno(stream,uid), body, &talist) > 0){
+		if(talist){
+
+		    /* rewind to start */
+		    while(talist->prev)
+		      talist = talist->prev;
+
+		    for(tp = talist; tp; tp = tp->next){
+			addr = tp->addr;
+			if(addr)
+			  add_addr_to_return_list(addr, ALC_CURR, query, flags, &return_list);
+		    }
+
+		    free_talines(&talist);
+		}
+	    }
+	}
+    }
+
+    
+    /*
+     * Check for and eliminate some duplicates.
+     * The criteria for deciding what is a duplicate is
+     * kind of ad hoc.
+     */
+    for(cp = return_list; cp; cp = cp->next)
+      for(dprev = cp, dp = cp->next; dp; ){
+        if(cp->full_address && dp->full_address
+	   && !strucmp(dp->full_address, cp->full_address)
+	   && (((cp->matches_bitmap & ALC_ABOOK)
+	        && (dp->matches_bitmap & ALC_ABOOK)
+	        && (!(dp->matches_bitmap & ALC_NICK && dp->nickname && dp->nickname[0])
+		    || ((!cp->addr && !dp->addr) || (cp->addr && dp->addr && !strucmp(cp->addr, dp->addr)))))
+	       ||
+	       (dp->matches_bitmap & ALC_CURR)
+	       ||
+	       (dp->matches_bitmap & ALC_LDAP
+	        && dp->matches_bitmap & (ALC_FULL | ALC_ADDR))
+	       ||
+	       (cp->matches_bitmap == dp->matches_bitmap
+	        && (!(dp->matches_bitmap & ALC_NICK && dp->nickname && dp->nickname[0])
+		    || (dp->nickname && cp->nickname
+		        && !strucmp(cp->nickname, dp->nickname)))))){
+	    /*
+	     * dp is equivalent to cp so eliminate dp
+	     */
+	    dprev->next = dp->next;
+	    dp->next = NULL;
+	    free_complete_s(&dp);
+	    dp = dprev;
+	}
+
+	dprev = dp;
+	dp = dp->next;
+      }
+
+    return(return_list);
+}
+
+
+void
+add_addr_to_return_list(ADDRESS *addr, unsigned bitmap, char *query,
+			int flags, COMPLETE_S **return_list)
+{
+    char buf[1000];
+    char *newaddr = NULL;
+    char *simple_addr = NULL;
+    COMPLETE_S *new = NULL, *cp;
+    ADDRESS *savenext;
+
+    if(return_list && query && addr && addr->mailbox && addr->host){
+
+	savenext = addr->next;
+	addr->next = NULL;
+	newaddr = addr_list_string(addr, NULL, 0);
+	addr->next = savenext;
+
+	/*
+	 * If the start of the full_address actually matches the query
+	 * string then mark this as ALC_FULL. This might be helpful
+	 * when deciding on the longest unambiguous match.
+	 */
+	if(newaddr && newaddr[0] && !struncmp(newaddr, query, strlen(query)))
+	  bitmap |= ALC_FULL;
+
+	if(newaddr && newaddr[0] && flags & ALC_INCLUDE_ADDRS){
+	    if(addr->mailbox && addr->host
+	       && !(addr->host[0] == '@' && addr->host[1] == '\0'))
+	      simple_addr = simple_addr_string(addr, buf, sizeof(buf));
+
+	    if(simple_addr && !simple_addr[0])
+	      simple_addr = NULL;
+
+	    if(simple_addr && !struncmp(simple_addr, query, strlen(query)))
+	      bitmap |= ALC_ADDR;
+	}
+
+	/*
+	 * We used to require && bitmap & (ALC_FULL | ALC_ADDR) before
+	 * we would add a match but we think that we should match
+	 * other stuff that matches (like middle names), too, unless we
+	 * are adding an address from the current message.
+	 */
+	if((newaddr && newaddr[0])
+	   && (!(bitmap & ALC_CURR) || bitmap & (ALC_FULL | ALC_ADDR))){
+	    new = new_complete_s(NULL, newaddr, simple_addr, NULL, NULL, bitmap);
+
+	    /* add to end of list */
+	    if(*return_list == NULL){
+		*return_list = new;
+	    }
+	    else{
+		for(cp = *return_list; cp->next; cp = cp->next)
+		  ;
+
+		cp->next = new;
+	    }
+	}
+
+	if(newaddr)
+	  fs_give((void **) &newaddr);
+    }
+}
+
+
+/*
+ * nick = nickname
+ * full = whole thing, like Some Body <someb@there.org>
+ * addr = address part, like someb@there.org
+ */
+COMPLETE_S *
+new_complete_s(char *nick, char *full, char *addr,
+	       char *rev_fullname, char *fcc, unsigned matches_bitmap)
+{
+    COMPLETE_S *new = NULL;
+
+    new = (COMPLETE_S *) fs_get(sizeof(*new));
+    memset((void *) new, 0, sizeof(*new));
+    new->nickname = nick ? cpystr(nick) : NULL;
+    new->full_address = full ? cpystr(full) : NULL;
+    new->addr = addr ? cpystr(addr) : NULL;
+    new->rev_fullname = rev_fullname ? cpystr(rev_fullname) : NULL;
+    new->fcc = fcc ? cpystr(fcc) : NULL;
+    new->matches_bitmap = matches_bitmap;
+
+    return(new);
+}
+
+
+void
+free_complete_s(COMPLETE_S **compptr)
+{
+    if(compptr && *compptr){
+	if((*compptr)->next)
+	  free_complete_s(&(*compptr)->next);
+
+	if((*compptr)->nickname)
+	  fs_give((void **) &(*compptr)->nickname);
+
+	if((*compptr)->full_address)
+	  fs_give((void **) &(*compptr)->full_address);
+
+	if((*compptr)->addr)
+	  fs_give((void **) &(*compptr)->addr);
+
+	if((*compptr)->rev_fullname)
+	  fs_give((void **) &(*compptr)->rev_fullname);
+
+	if((*compptr)->fcc)
+	  fs_give((void **) &(*compptr)->fcc);
+
+	fs_give((void **) compptr);
+    }
+}
+
+
+ABOOK_ENTRY_S *
+new_abook_entry_s(AdrBk *ab, a_c_arg_t numarg, unsigned bit)
+{
+    ABOOK_ENTRY_S *new = NULL;
+    adrbk_cntr_t entrynum;
+
+    entrynum = (adrbk_cntr_t) numarg;
+
+    new = (ABOOK_ENTRY_S *) fs_get(sizeof(*new));
+    memset((void *) new, 0, sizeof(*new));
+    new->ab = ab;
+    new->entrynum = entrynum;
+    new->matches_bitmap = bit;
+
+    return(new);
+}
+
+
+void
+free_abook_entry_s(ABOOK_ENTRY_S **aep)
+{
+    if(aep && *aep){
+	if((*aep)->next)
+	  free_abook_entry_s(&(*aep)->next);
+
+	fs_give((void **) aep);
+    }
+}
+
+
+/*
+ * Add the second list to the end of the first.
+ */
+void
+combine_abook_entry_lists(ABOOK_ENTRY_S **first, ABOOK_ENTRY_S *second)
+{
+    ABOOK_ENTRY_S *sl;
+
+    if(!second)
+      return;
+
+    if(first){
+	if(*first){
+	    for(sl = *first; sl->next; sl = sl->next)
+	      ;
+
+	    sl->next = second;
+	}
+	else
+	  *first = second;
+    }
+}
+
+
+ABOOK_ENTRY_S *
+adrbk_list_of_possible_completions(AdrBk *ab, char *prefix)
+{
+    ABOOK_ENTRY_S *list = NULL, *biglist = NULL;
+
+    if(!ab || !prefix)
+      return(biglist);
+
+    if(ab->nick_trie){
+	list = adrbk_list_of_possible_trie_completions(ab->nick_trie, ab, prefix, ALC_NICK);
+	combine_abook_entry_lists(&biglist, list);
+    }
+
+    if(ab->full_trie){
+	list = adrbk_list_of_possible_trie_completions(ab->full_trie, ab, prefix, ALC_FULL);
+	combine_abook_entry_lists(&biglist, list);
+    }
+
+    if(ab->addr_trie){
+	list = adrbk_list_of_possible_trie_completions(ab->addr_trie, ab, prefix, ALC_ADDR);
+	combine_abook_entry_lists(&biglist, list);
+    }
+
+    if(ab->revfull_trie){
+	list = adrbk_list_of_possible_trie_completions(ab->revfull_trie, ab, prefix, ALC_REVFULL);
+	combine_abook_entry_lists(&biglist, list);
+    }
+
+    return(biglist);
+}
+
+
+/*
+ * Look in this address book for all nicknames, addresses, or fullnames
+ * which begin with the prefix prefix, and return an allocated
+ * list of them.
+ */
+ABOOK_ENTRY_S *
+adrbk_list_of_possible_trie_completions(AdrBk_Trie *trie, AdrBk *ab, char *prefix,
+					unsigned bit)
+{
+    AdrBk_Trie *t;
+    char        *p, *lookthisup;
+    char         buf[1000];
+    ABOOK_ENTRY_S *list = NULL;
+
+    if(!ab || !prefix || !trie)
+      return(list);
+
+    t = trie;
+
+    /* make lookup case independent */
+
+    for(p = prefix; *p && !(*p & 0x80) && islower((unsigned char) *p); p++)
+      ;
+
+    if(*p){
+	strncpy(buf, prefix, sizeof(buf));
+	buf[sizeof(buf)-1] = '\0';
+	for(p = buf; *p; p++)
+	  if(!(*p & 0x80) && isupper((unsigned char) *p))
+	    *p = tolower(*p);
+
+	lookthisup = buf;
+    }
+    else
+      lookthisup = prefix;
+
+    p = lookthisup;
+
+    while(*p){
+	/* search for character at this level */
+	while(t->value != *p){
+	    if(t->right == NULL)
+	      return(list);		/* no match */
+
+	    t = t->right;
+	}
+
+	if(*++p == '\0')		/* matched through end of prefix */
+	  break;
+
+	/* need to go down to match next character */
+	if(t->down == NULL)		/* no match */
+	  return(list);
+
+	t = t->down;
+    }
+
+    /*
+     * If we get here that means we found at least
+     * one entry that matches up through prefix.
+     * Gather_abook_list recursively adds the nicknames starting at
+     * this node.
+     */
+    if(t->entrynum != NO_NEXT){
+	/*
+	 * Add it to the list.
+	 */
+	list = new_abook_entry_s(ab, t->entrynum, bit);
+    }
+
+    gather_abook_entry_list(ab, t->down, prefix, &list, bit);
+
+    return(list);
+}
+
+
+void
+gather_abook_entry_list(AdrBk *ab, AdrBk_Trie *node, char *prefix, ABOOK_ENTRY_S **list, unsigned bit)
+{
+  char *next_prefix = NULL;
+  size_t l;
+  ABOOK_ENTRY_S *newlist = NULL;
+
+  if(node){
+    if(node->entrynum != NO_NEXT || node->down || node->right){
+      l = strlen(prefix ? prefix : "");
+      if(node->entrynum != NO_NEXT){
+	/*
+	 * Add it to the list.
+	 */
+	newlist = new_abook_entry_s(ab, node->entrynum, bit);
+	combine_abook_entry_lists(list, newlist);
+      }
+
+      /* same prefix for node->right */
+      if(node->right)
+        gather_abook_entry_list(ab, node->right, prefix, list, bit);
+
+      /* prefix is one longer for node->down */
+      if(node->down){
+	next_prefix = (char *) fs_get((l+2) * sizeof(char));
+	strncpy(next_prefix, prefix ? prefix : "", l+2);
+	next_prefix[l] = node->value;
+	next_prefix[l+1] = '\0';
+	gather_abook_entry_list(ab, node->down, next_prefix, list, bit);
+
+	if(next_prefix)
+	  fs_give((void **) &next_prefix);
+      }
+    }
+  }
+}