]> code.citadel.org Git - citadel.git/blobdiff - citadel/imap_fetch.c
* extract_token() now expects to be supplied with the size of the
[citadel.git] / citadel / imap_fetch.c
index 360fe09be5deccf10d2f363521c0e75602f979a5..3d59567f39c011e408533365e543fa293013e8c1 100644 (file)
@@ -2,7 +2,7 @@
  * $Id$
  *
  * Implements the FETCH command in IMAP.
- * This command is way too convoluted.  Marc Crispin is a fscking idiot.
+ * This is a good example of the protocol's gratuitous complexity.
  *
  */
 
 #include <pwd.h>
 #include <errno.h>
 #include <sys/types.h>
-#include <sys/time.h>
+
+#if TIME_WITH_SYS_TIME
+# include <sys/time.h>
+# include <time.h>
+#else
+# if HAVE_SYS_TIME_H
+#  include <sys/time.h>
+# else
+#  include <time.h>
+# endif
+#endif
+
 #include <sys/wait.h>
 #include <ctype.h>
 #include <string.h>
 #include <limits.h>
 #include "citadel.h"
 #include "server.h"
-#include <time.h>
 #include "sysdep_decls.h"
 #include "citserver.h"
 #include "support.h"
 #include "config.h"
-#include "dynloader.h"
+#include "serv_extensions.h"
 #include "room_ops.h"
 #include "user_ops.h"
 #include "policy.h"
 
 
 
-struct imap_fetch_part {
-       char desired_section[SIZ];
-       FILE *output_fp;
-};
-
 /*
  * Individual field functions for imap_do_fetch_msg() ...
  */
 
-
-
 void imap_fetch_uid(int seq) {
        cprintf("UID %ld", IMAP->msgids[seq-1]);
 }
 
-void imap_fetch_flags(struct CtdlMessage *msg) {
-       cprintf("FLAGS ()");    /* FIXME do something here */
+void imap_fetch_flags(int seq) {
+       int num_flags_printed = 0;
+       cprintf("FLAGS (");
+       if (IMAP->flags[seq] & IMAP_DELETED) {
+               if (num_flags_printed > 0) cprintf(" ");
+               cprintf("\\Deleted");
+               ++num_flags_printed;
+       }
+       if (IMAP->flags[seq] & IMAP_SEEN) {
+               if (num_flags_printed > 0) cprintf(" ");
+               cprintf("\\Seen");
+               ++num_flags_printed;
+       }
+       if (IMAP->flags[seq] & IMAP_ANSWERED) {
+               if (num_flags_printed > 0) cprintf(" ");
+               cprintf("\\Answered");
+               ++num_flags_printed;
+       }
+       if (IMAP->flags[seq] & IMAP_RECENT) {
+               if (num_flags_printed > 0) cprintf(" ");
+               cprintf("\\Recent");
+               ++num_flags_printed;
+       }
+       cprintf(")");
 }
 
 void imap_fetch_internaldate(struct CtdlMessage *msg) {
@@ -74,7 +99,7 @@ void imap_fetch_internaldate(struct CtdlMessage *msg) {
                msgdate = time(NULL);
        }
 
-       datestring(buf, msgdate, DATESTRING_IMAP);
+       datestring(buf, sizeof buf, msgdate, DATESTRING_IMAP);
        cprintf("INTERNALDATE \"%s\"", buf);
 }
 
@@ -88,78 +113,112 @@ void imap_fetch_internaldate(struct CtdlMessage *msg) {
  *     "RFC822.SIZE"   size of translated message
  *     "RFC822.TEXT"   body only (without leading blank line)
  */
-void imap_fetch_rfc822(int msgnum, char *whichfmt, struct CtdlMessage *msg) {
-       FILE *tmp;
-       char buf[1024];
+void imap_fetch_rfc822(long msgnum, char *whichfmt) {
+       char buf[SIZ];
        char *ptr;
-       long headers_size, text_size, total_size;
-       long bytes_remaining = 0;
-       long blocksize;
+       size_t headers_size, text_size, total_size;
+       size_t bytes_to_send = 0;
+       struct MetaData smi;
+       int need_to_rewrite_metadata = 0;
 
-       tmp = tmpfile();
-       if (tmp == NULL) {
-               lprintf(1, "Cannot open temp file: %s\n", strerror(errno));
-               return;
+       /* If this is an RFC822.SIZE fetch, first look in the message's
+        * metadata record to see if we've saved that information.
+        */
+       if (!strcasecmp(whichfmt, "RFC822.SIZE")) {
+               GetMetaData(&smi, msgnum);
+               if (smi.meta_rfc822_length > 0L) {
+                       cprintf("RFC822.SIZE %ld", smi.meta_rfc822_length);
+                       return;
+               }
+               need_to_rewrite_metadata = 1;
+       }
+       
+       /* Cache the most recent RFC822 FETCH because some clients like to
+        * fetch in pieces, and we don't want to have to go back to the
+        * message store for each piece.
+        */
+       if ((IMAP->cached_rfc822_data != NULL)
+          && (IMAP->cached_rfc822_msgnum == msgnum)) {
+               /* Good to go! */
+       }
+       else if (IMAP->cached_rfc822_data != NULL) {
+               /* Some other message is cached -- free it */
+               free(IMAP->cached_rfc822_data);
+               IMAP->cached_rfc822_data = NULL;
+               IMAP->cached_rfc822_msgnum = (-1);
+               IMAP->cached_rfc822_len = 0;
        }
 
-       /*
-        * Load the message into a temp file for translation and measurement
-        */ 
-       CtdlRedirectOutput(tmp, -1);
-       CtdlOutputPreLoadedMsg(msg, msgnum, MT_RFC822, 0, 0, 1);
-       CtdlRedirectOutput(NULL, -1);
-       if (!is_valid_message(msg)) {
-               lprintf(1, "WARNING: output clobbered the message!\n");
+       /* At this point, we now can fetch and convert the message iff it's not
+        * the one we had cached.
+        */
+       if (IMAP->cached_rfc822_data == NULL) {
+               /*
+                * Load the message into memory for translation & measurement
+                */
+               CC->redirect_buffer = malloc(SIZ);
+               CC->redirect_len = 0;
+               CC->redirect_alloc = SIZ;
+               CtdlOutputMsg(msgnum, MT_RFC822, HEADERS_ALL, 0, 1);
+               IMAP->cached_rfc822_data = CC->redirect_buffer;
+               IMAP->cached_rfc822_len = CC->redirect_len;
+               IMAP->cached_rfc822_msgnum = msgnum;
+               CC->redirect_buffer = NULL;
+               CC->redirect_len = 0;
+               CC->redirect_alloc = 0;
+               if (need_to_rewrite_metadata) {
+                       smi.meta_rfc822_length = (long)IMAP->cached_rfc822_len;
+                       PutMetaData(&smi);
+               }
        }
 
        /*
         * Now figure out where the headers/text break is.  IMAP considers the
         * intervening blank line to be part of the headers, not the text.
         */
-       rewind(tmp);
-       headers_size = 0L;
+       headers_size = 0;
+       text_size = 0;
+       total_size = 0;
+
+       ptr = IMAP->cached_rfc822_data;
        do {
-               ptr = fgets(buf, sizeof buf, tmp);
-               if (ptr != NULL) {
+               ptr = memreadline(ptr, buf, sizeof buf);
+               if (*ptr != 0) {
                        striplt(buf);
-                       if (strlen(buf) == 0) headers_size = ftell(tmp);
+                       if (strlen(buf) == 0) {
+                               headers_size = ptr - IMAP->cached_rfc822_data;
+                       }
                }
-       } while ( (headers_size == 0L) && (ptr != NULL) );
-       fseek(tmp, 0L, SEEK_END);
-       total_size = ftell(tmp);
+       } while ( (headers_size == 0) && (*ptr != 0) );
+
+       total_size = IMAP->cached_rfc822_len;
        text_size = total_size - headers_size;
 
+       lprintf(CTDL_DEBUG, "RFC822: headers=%d, text=%d, total=%d\n",
+               headers_size, text_size, total_size);
+
        if (!strcasecmp(whichfmt, "RFC822.SIZE")) {
-               cprintf("RFC822.SIZE %ld", total_size);
-               fclose(tmp);
+               cprintf("RFC822.SIZE %d", total_size);
                return;
        }
 
        else if (!strcasecmp(whichfmt, "RFC822")) {
-               bytes_remaining = total_size;
-               rewind(tmp);
+               ptr = IMAP->cached_rfc822_data;
+               bytes_to_send = total_size;
        }
 
        else if (!strcasecmp(whichfmt, "RFC822.HEADER")) {
-               bytes_remaining = headers_size;
-               rewind(tmp);
+               ptr = IMAP->cached_rfc822_data;
+               bytes_to_send = headers_size;
        }
 
        else if (!strcasecmp(whichfmt, "RFC822.TEXT")) {
-               bytes_remaining = text_size;
-               fseek(tmp, headers_size, SEEK_SET);
-       }
-
-       cprintf("%s {%ld}\r\n", whichfmt, bytes_remaining);
-       blocksize = sizeof(buf);
-       while (bytes_remaining > 0L) {
-               if (blocksize > bytes_remaining) blocksize = bytes_remaining;
-               fread(buf, blocksize, 1, tmp);
-               client_write(buf, blocksize);
-               bytes_remaining = bytes_remaining - blocksize;
+               ptr = &IMAP->cached_rfc822_data[headers_size];
+               bytes_to_send = text_size;
        }
 
-       fclose(tmp);
+       cprintf("%s {%d}\r\n", whichfmt, bytes_to_send);
+       client_write(ptr, bytes_to_send);
 }
 
 
@@ -177,36 +236,33 @@ void imap_load_part(char *name, char *filename, char *partnum, char *disp,
                    void *content, char *cbtype, size_t length, char *encoding,
                    void *cbuserdata)
 {
-       struct imap_fetch_part *imfp;
-       char mbuf2[1024];
+       char mbuf2[SIZ];
+       char *desired_section;
 
-       imfp = (struct imap_fetch_part *)cbuserdata;
+       desired_section = (char *)cbuserdata;
 
-       if (!strcasecmp(partnum, imfp->desired_section)) {
-               fwrite(content, length, 1, imfp->output_fp);
+       if (!strcasecmp(partnum, desired_section)) {
+               client_write(content, length);
        }
 
-       sprintf(mbuf2, "%s.MIME", partnum);
+       snprintf(mbuf2, sizeof mbuf2, "%s.MIME", partnum);
 
-       if (!strcasecmp(imfp->desired_section, mbuf2)) {
-               fprintf(imfp->output_fp, "Content-type: %s", cbtype);
+       if (!strcasecmp(desired_section, mbuf2)) {
+               cprintf("Content-type: %s", cbtype);
                if (strlen(name) > 0)
-                       fprintf(imfp->output_fp, "; name=\"%s\"", name);
-               fprintf(imfp->output_fp, "\r\n");
+                       cprintf("; name=\"%s\"", name);
+               cprintf("\r\n");
                if (strlen(encoding) > 0)
-                       fprintf(imfp->output_fp,
-                               "Content-Transfer-Encoding: %s\r\n", encoding);
+                       cprintf("Content-Transfer-Encoding: %s\r\n", encoding);
                if (strlen(encoding) > 0) {
-                       fprintf(imfp->output_fp, "Content-Disposition: %s",
-                                       disp);
+                       cprintf("Content-Disposition: %s", disp);
                        if (strlen(filename) > 0) {
-                               fprintf(imfp->output_fp, "; filename=\"%s\"",
-                                       filename);
+                               cprintf("; filename=\"%s\"", filename);
                        }
-                       fprintf(imfp->output_fp, "\r\n");
+                       cprintf("\r\n");
                }
-               fprintf(imfp->output_fp, "Content-Length: %d\r\n", length);
-               fprintf(imfp->output_fp, "\r\n");
+               cprintf("Content-Length: %ld\r\n", (long)length);
+               cprintf("\r\n");
        }
                        
 
@@ -219,12 +275,24 @@ void imap_load_part(char *name, char *filename, char *partnum, char *disp,
  * really need to make this suck less.
  */
 void imap_output_envelope_from(struct CtdlMessage *msg) {
-       char user[1024], node[1024], name[1024];
+       char user[SIZ], node[SIZ], name[SIZ];
+
+       /* For anonymous messages, it's so easy! */
+       if (!is_room_aide() && (msg->cm_anon_type == MES_ANONONLY)) {
+               cprintf("((\"----\" NIL \"x\" \"x.org\")) ");
+               return;
+       }
+       if (!is_room_aide() && (msg->cm_anon_type == MES_ANONOPT)) {
+               cprintf("((\"anonymous\" NIL \"x\" \"x.org\")) ");
+               return;
+       }
 
+       /* For everything else, we do stuff. */
        cprintf("((");                          /* open double-parens */
        imap_strout(msg->cm_fields['A']);       /* personal name */
        cprintf(" NIL ");                       /* source route (not used) */
 
+
        if (msg->cm_fields['F'] != NULL) {
                process_rfc822_addr(msg->cm_fields['F'], user, node, name);
                imap_strout(user);              /* mailbox name (user id) */
@@ -246,12 +314,58 @@ void imap_output_envelope_from(struct CtdlMessage *msg) {
 }
 
 
+
+/*
+ * Output an envelope address (or set of addresses) in the official,
+ * convuluted, braindead format.  (Note that we can't use this for
+ * the "From" address because its data may come from a number of different
+ * fields.  But we can use it for "To" and possibly others.
+ */
+void imap_output_envelope_addr(char *addr) {
+       char individual_addr[256];
+       int num_addrs;
+       int i;
+       char user[256];
+       char node[256];
+       char name[256];
+
+       if (addr == NULL) {
+               cprintf("NIL ");
+               return;
+       }
+
+       if (strlen(addr) == 0) {
+               cprintf("NIL ");
+               return;
+       }
+
+       cprintf("(");
+
+       /* How many addresses are listed here? */
+       num_addrs = num_tokens(addr, ',');
+
+       /* Output them one by one. */
+       for (i=0; i<num_addrs; ++i) {
+               extract_token(individual_addr, addr, i, ',', sizeof individual_addr);
+               striplt(individual_addr);
+               process_rfc822_addr(individual_addr, user, node, name);
+               cprintf("(");
+               imap_strout(name);
+               cprintf(" NIL ");
+               imap_strout(user);
+               cprintf(" ");
+               imap_strout(node);
+               cprintf(")");
+               if (i < (num_addrs-1)) cprintf(" ");
+       }
+
+       cprintf(") ");
+}
+
+
 /*
  * Implements the ENVELOPE fetch item
  * 
- * FIXME ... we only output some of the fields right now.  Definitely need
- *           to do all of them.  Accurately, too.
- *
  * Note that the imap_strout() function can cleverly output NULL fields as NIL,
  * so we don't have to check for that condition like we do elsewhere.
  */
@@ -267,7 +381,8 @@ void imap_fetch_envelope(long msgnum, struct CtdlMessage *msg) {
        else {
                msgdate = time(NULL);
        }
-       datestring(datestringbuf, msgdate, DATESTRING_IMAP);
+       datestring(datestringbuf, sizeof datestringbuf,
+               msgdate, DATESTRING_IMAP);
 
        /* Now start spewing data fields.  The order is important, as it is
         * defined by the protocol specification.  Nonexistent fields must
@@ -287,124 +402,210 @@ void imap_fetch_envelope(long msgnum, struct CtdlMessage *msg) {
        /* From */
        imap_output_envelope_from(msg);
 
-       /* Sender */
-       if (0) {
-               /* FIXME ... check for a *real* Sender: field */
+       /* Sender (default to same as 'From' if not present) */
+       fieldptr = rfc822_fetch_field(msg->cm_fields['M'], "Sender");
+       if (fieldptr != NULL) {
+               imap_output_envelope_addr(fieldptr);
+               free(fieldptr);
        }
        else {
                imap_output_envelope_from(msg);
        }
 
        /* Reply-to */
-       if (0) {
-               /* FIXME ... check for a *real* Reply-to: field */
+       fieldptr = rfc822_fetch_field(msg->cm_fields['M'], "Reply-to");
+       if (fieldptr != NULL) {
+               imap_output_envelope_addr(fieldptr);
+               free(fieldptr);
        }
        else {
                imap_output_envelope_from(msg);
        }
 
-       cprintf("NIL ");        /* to */
+       /* To */
+       imap_output_envelope_addr(msg->cm_fields['R']);
 
-       cprintf("NIL ");        /* cc */
+       /* Cc */
+       fieldptr = rfc822_fetch_field(msg->cm_fields['M'], "Cc");
+       imap_output_envelope_addr(fieldptr);
+       if (fieldptr != NULL) free(fieldptr);
 
-       cprintf("NIL ");        /* bcc */
+       /* Bcc */
+       fieldptr = rfc822_fetch_field(msg->cm_fields['M'], "Bcc");
+       imap_output_envelope_addr(fieldptr);
+       if (fieldptr != NULL) free(fieldptr);
 
        /* In-reply-to */
        fieldptr = rfc822_fetch_field(msg->cm_fields['M'], "In-reply-to");
        imap_strout(fieldptr);
        cprintf(" ");
-       if (fieldptr != NULL) phree(fieldptr);
+       if (fieldptr != NULL) free(fieldptr);
 
        /* message ID */
        imap_strout(msg->cm_fields['I']);
 
-       cprintf(") ");
+       cprintf(")");
 }
 
 
 /*
- * Strip any non header information out of a chunk of RFC822 data on disk
+ * This function is called only when CC->redirect_buffer contains a set of
+ * RFC822 headers with no body attached.  Its job is to strip that set of
+ * headers down to *only* the ones we're interested in.
  */
-void imap_strip_headers(FILE *fp) {
-       char buf[1024];
-
-       rewind(fp);
-       while (fgets(buf, sizeof buf, fp) != NULL) {
-               striplt(buf);
-               if (strlen(buf) == 0) {
-                       fflush(fp);
-                       ftruncate(fileno(fp), ftell(fp));
+void imap_strip_headers(char *section) {
+       char buf[SIZ];
+       char *which_fields = NULL;
+       int doing_headers = 0;
+       int headers_not = 0;
+       char *parms[SIZ];
+        int num_parms = 0;
+       int i;
+       char *boiled_headers = NULL;
+       int ok = 0;
+       int done_headers = 0;
+       char *ptr = NULL;
+
+       if (CC->redirect_buffer == NULL) return;
+
+       which_fields = strdup(section);
+
+       if (!strncasecmp(which_fields, "HEADER.FIELDS", 13))
+               doing_headers = 1;
+       if (!strncasecmp(which_fields, "HEADER.FIELDS.NOT", 17))
+               headers_not = 1;
+
+       for (i=0; i<strlen(which_fields); ++i) {
+               if (which_fields[i]=='(')
+                       strcpy(which_fields, &which_fields[i+1]);
+       }
+       for (i=0; i<strlen(which_fields); ++i) {
+               if (which_fields[i]==')')
+                       which_fields[i] = 0;
+       }
+       num_parms = imap_parameterize(parms, which_fields);
+
+       boiled_headers = malloc(CC->redirect_alloc);
+       strcpy(boiled_headers, "");
+
+       ptr = CC->redirect_buffer;
+       ok = 0;
+       while ( (done_headers == 0) && (ptr = memreadline(ptr, buf, sizeof buf), *ptr != 0) ) {
+               if (!isspace(buf[0])) {
+                       ok = 0;
+                       if (doing_headers == 0) ok = 1;
+                       else {
+                               if (headers_not) ok = 1;
+                               else ok = 0;
+                               for (i=0; i<num_parms; ++i) {
+                                       if ( (!strncasecmp(buf, parms[i],
+                                          strlen(parms[i]))) &&
+                                          (buf[strlen(parms[i])]==':') ) {
+                                               if (headers_not) ok = 0;
+                                               else ok = 1;
+                                       }
+                               }
+                       }
                }
+
+               if (ok) {
+                       strcat(boiled_headers, buf);
+                       strcat(boiled_headers, "\r\n");
+               }
+
+               if (strlen(buf) == 0) done_headers = 1;
+               if (buf[0]=='\r') done_headers = 1;
+               if (buf[0]=='\n') done_headers = 1;
        }
-       fflush(fp);
-       fprintf(fp, "\r\n");    /* add the trailing newline */
-       rewind(fp);
+
+       strcat(boiled_headers, "\r\n");
+
+       /* Now save it back (it'll always be smaller) */
+       strcpy(CC->redirect_buffer, boiled_headers);
+       CC->redirect_len = strlen(boiled_headers);
+
+       free(which_fields);
+       free(boiled_headers);
 }
 
 
 /*
  * Implements the BODY and BODY.PEEK fetch items
  */
-void imap_fetch_body(long msgnum, char *item, int is_peek,
-               struct CtdlMessage *msg) {
-       char section[1024];
-       char partial[1024];
+void imap_fetch_body(long msgnum, char *item, int is_peek) {
+       struct CtdlMessage *msg = NULL;
+       char section[SIZ];
+       char partial[SIZ];
        int is_partial = 0;
-       char buf[1024];
-       int i;
-       FILE *tmp;
-       long bytes_remaining = 0;
-       long blocksize;
-       long pstart, pbytes;
-       struct imap_fetch_part imfp;
+       size_t pstart, pbytes;
+       int loading_body_now = 0;
 
        /* extract section */
-       strcpy(section, item);
-       for (i=0; i<strlen(section); ++i) {
-               if (section[i]=='[') strcpy(section, &section[i+1]);
+       safestrncpy(section, item, sizeof section);
+       if (strchr(section, '[') != NULL) {
+               stripallbut(section, '[', ']');
        }
-       for (i=0; i<strlen(section); ++i) {
-               if (section[i]==']') section[i] = 0;
-       }
-       lprintf(9, "Section is %s\n", section);
+       /* lprintf(CTDL_DEBUG, "Section is: %s%s\n", section, ((strlen(section)==0) ? "(empty)" : "") ); */
 
-       /* extract partial */
-       strcpy(partial, item);
-       for (i=0; i<strlen(partial); ++i) {
-               if (partial[i]=='<') {
-                       strcpy(partial, &partial[i+1]);
-                       is_partial = 1;
+       /* Burn the cache if we don't have the same section of the 
+        * same message again.
+        */
+       if (IMAP->cached_body != NULL) {
+               if ((IMAP->cached_bodymsgnum != msgnum)
+                  || (strcasecmp(IMAP->cached_bodypart, section)) ) {
+                       free(IMAP->cached_body);
+                       IMAP->cached_body_len = 0;
+                       IMAP->cached_body = NULL;
+                       IMAP->cached_bodymsgnum = (-1);
+                       strcpy(IMAP->cached_bodypart, "");
                }
        }
-       for (i=0; i<strlen(partial); ++i) {
-               if (partial[i]=='>') partial[i] = 0;
+
+       /* extract partial */
+       safestrncpy(partial, item, sizeof partial);
+       if (strchr(partial, '<') != NULL) {
+               stripallbut(partial, '<', '>');
+               is_partial = 1;
        }
        if (is_partial == 0) strcpy(partial, "");
-       if (strlen(partial) > 0) lprintf(9, "Partial is %s\n", partial);
-
-       tmp = tmpfile();
-       if (tmp == NULL) {
-               lprintf(1, "Cannot open temp file: %s\n", strerror(errno));
-               return;
+       /* if (strlen(partial) > 0) lprintf(CTDL_DEBUG, "Partial is %s\n", partial); */
+
+       if (IMAP->cached_body == NULL) {
+               CC->redirect_buffer = malloc(SIZ);
+               CC->redirect_len = 0;
+               CC->redirect_alloc = SIZ;
+               loading_body_now = 1;
+               msg = CtdlFetchMessage(msgnum, 1);
        }
 
        /* Now figure out what the client wants, and get it */
 
-       if (!strcmp(section, "")) {             /* the whole thing */
-               CtdlRedirectOutput(tmp, -1);
-               CtdlOutputPreLoadedMsg(msg, msgnum, MT_RFC822, 0, 0, 1);
-               CtdlRedirectOutput(NULL, -1);
+       if (!loading_body_now) {
+               /* What we want is already in memory */
+       }
+
+       else if ( (!strcmp(section, "1")) && (msg->cm_format_type != 4) ) {
+               CtdlOutputPreLoadedMsg(msg, msgnum, MT_RFC822, HEADERS_NONE, 0, 1);
+       }
+
+       else if (!strcmp(section, "")) {
+               CtdlOutputPreLoadedMsg(msg, msgnum, MT_RFC822, HEADERS_ALL, 0, 1);
        }
 
        /*
-        * Be obnoxious and send the entire header, even if the client only
-        * asks for certain fields.  FIXME this shortcut later.
+        * If the client asked for just headers, or just particular header
+        * fields, strip it down.
         */
        else if (!strncasecmp(section, "HEADER", 6)) {
-               CtdlRedirectOutput(tmp, -1);
-               CtdlOutputPreLoadedMsg(msg, msgnum, MT_RFC822, 1, 0, 1);
-               CtdlRedirectOutput(NULL, -1);
-               imap_strip_headers(tmp);
+               CtdlOutputPreLoadedMsg(msg, msgnum, MT_RFC822, HEADERS_ONLY, 0, 1);
+               imap_strip_headers(section);
+       }
+
+       /*
+        * Strip it down if the client asked for everything _except_ headers.
+        */
+       else if (!strncasecmp(section, "TEXT", 4)) {
+               CtdlOutputPreLoadedMsg(msg, msgnum, MT_RFC822, HEADERS_NONE, 0, 1);
        }
 
        /*
@@ -412,47 +613,45 @@ void imap_fetch_body(long msgnum, char *item, int is_peek,
         * (Note value of 1 passed as 'dont_decode' so client gets it encoded)
         */
        else {
-               safestrncpy(imfp.desired_section, section,
-                               sizeof(imfp.desired_section));
-               imfp.output_fp = tmp;
-
                mime_parser(msg->cm_fields['M'], NULL,
                                *imap_load_part, NULL, NULL,
-                               (void *)&imfp,
+                               section,
                                1);
        }
 
-
-       fseek(tmp, 0L, SEEK_END);
-       bytes_remaining = ftell(tmp);
+       if (loading_body_now) {
+               IMAP->cached_body = CC->redirect_buffer;
+               IMAP->cached_body_len = CC->redirect_len;
+               IMAP->cached_bodymsgnum = msgnum;
+               strcpy(IMAP->cached_bodypart, section);
+               CC->redirect_buffer = NULL;
+               CC->redirect_len = 0;
+               CC->redirect_alloc = 0;
+       }
 
        if (is_partial == 0) {
-               rewind(tmp);
-               cprintf("BODY[%s] {%ld}\r\n", section, bytes_remaining);
+               cprintf("BODY[%s] {%d}\r\n", section, IMAP->cached_body_len);
+               pstart = 0;
+               pbytes = IMAP->cached_body_len;
        }
        else {
-               sscanf(partial, "%ld.%ld", &pstart, &pbytes);
-               if ((bytes_remaining - pstart) < pbytes) {
-                       pbytes = bytes_remaining - pstart;
+               sscanf(partial, "%d.%d", &pstart, &pbytes);
+               if (pbytes > (IMAP->cached_body_len - pstart)) {
+                       pbytes = IMAP->cached_body_len - pstart;
                }
-               fseek(tmp, pstart, SEEK_SET);
-               bytes_remaining = pbytes;
-               cprintf("BODY[%s] {%ld}<%ld>\r\n",
-                       section, bytes_remaining, pstart);
+               cprintf("BODY[%s]<%d> {%d}\r\n", section, pstart, pbytes);
        }
 
-       blocksize = sizeof(buf);
-       while (bytes_remaining > 0L) {
-               if (blocksize > bytes_remaining) blocksize = bytes_remaining;
-               fread(buf, blocksize, 1, tmp);
-               client_write(buf, blocksize);
-               bytes_remaining = bytes_remaining - blocksize;
-       }
+       /* Here we go -- output it */
+       client_write(&IMAP->cached_body[pstart], pbytes);
 
-       fclose(tmp);
+       if (msg != NULL) {
+               CtdlFreeMessage(msg);
+       }
 
-       if (is_peek) {
-               /* FIXME set the last read pointer or something */
+       /* Mark this message as "seen" *unless* this is a "peek" operation */
+       if (is_peek == 0) {
+               CtdlSetSeen(msgnum, 1, ctdlsetseen_seen);
        }
 }
 
@@ -479,10 +678,17 @@ void imap_fetch_bodystructure_post(
                void *cbuserdata
                ) {
 
-       char subtype[SIZ];
+       char subtype[128];
+
+       cprintf(" ");
 
-       extract_token(subtype, cbtype, 1, '/');
+       /* disposition */
+       extract_token(subtype, cbtype, 1, '/', sizeof subtype);
        imap_strout(subtype);
+
+       /* body language */
+       cprintf(" NIL");
+
        cprintf(")");
 }
 
@@ -491,7 +697,6 @@ void imap_fetch_bodystructure_post(
 /*
  * Output the info for a MIME part in the format required by BODYSTRUCTURE.
  *
- * FIXME .... this needs oodles of work to get completed.
  */
 void imap_fetch_bodystructure_part(
                char *name, char *filename, char *partnum, char *disp,
@@ -499,39 +704,43 @@ void imap_fetch_bodystructure_part(
                void *cbuserdata
                ) {
 
-       char buf[SIZ];
-
-       cprintf("(");
-
-       if (cbtype == NULL) {
-               cprintf("\"TEXT\" \"PLAIN\" ");
+       int have_cbtype = 0;
+       int have_encoding = 0;
+       int lines = 0;
+       size_t i;
+       char cbmaintype[128];
+       char cbsubtype[128];
+
+       if (cbtype != NULL) if (strlen(cbtype)>0) have_cbtype = 1;
+       if (have_cbtype) {
+               extract_token(cbmaintype, cbtype, 0, '/', sizeof cbmaintype);
+               extract_token(cbsubtype, cbtype, 1, '/', sizeof cbsubtype);
        }
        else {
-               extract_token(buf, cbtype, 0, '/');
-               imap_strout(buf);
-               cprintf(" ");
-               extract_token(buf, cbtype, 1, '/');
-               imap_strout(buf);
-               cprintf(" ");
+               strcpy(cbmaintype, "TEXT");
+               strcpy(cbsubtype, "PLAIN");
        }
 
+       cprintf("(");
+       imap_strout(cbmaintype);
+       cprintf(" ");
+       imap_strout(cbsubtype);
+       cprintf(" ");
+
        cprintf("(\"CHARSET\" \"US-ASCII\"");
 
-       if (name != NULL) {
+       if (name != NULL) if (strlen(name)>0) {
                cprintf(" \"NAME\" ");
                imap_strout(name);
        }
 
-       if (filename != NULL) {
-               cprintf(" \"FILENAME\" ");
-               imap_strout(name);
-       }
-
        cprintf(") ");
 
-       cprintf("NIL NIL ");
+       cprintf("NIL ");        /* Body ID */
+       cprintf("NIL ");        /* Body description */
 
-       if (encoding != NULL) {
+       if (encoding != NULL) if (strlen(encoding) > 0)  have_encoding = 1;
+       if (have_encoding) {
                imap_strout(encoding);
        }
        else {
@@ -539,27 +748,71 @@ void imap_fetch_bodystructure_part(
        }
        cprintf(" ");
 
-       cprintf("%ld ", length);        /* bytes */
-       cprintf("NIL) ");               /* lines */
+       /* The next field is the size of the part in bytes. */
+       cprintf("%ld ", (long)length);  /* bytes */
+
+       /* The next field is the number of lines in the part, if and only
+        * if the part is TEXT.  More gratuitous complexity.
+        */
+       if (!strcasecmp(cbmaintype, "TEXT")) {
+               if (length) for (i=0; i<length; ++i) {
+                       if (((char *)content)[i] == '\n') ++lines;
+               }
+               cprintf("%d ", lines);
+       }
+
+       /* More gratuitous complexity */
+       if ((!strcasecmp(cbmaintype, "MESSAGE"))
+          && (!strcasecmp(cbsubtype, "RFC822"))) {
+               /* FIXME
+                     A body type of type MESSAGE and subtype RFC822
+                     contains, immediately after the basic fields, the
+                     envelope structure, body structure, and size in
+                     text lines of the encapsulated message.
+               */
+       }
+
+       /* MD5 value of body part; we can get away with NIL'ing this */
+       cprintf("NIL ");
 
+       /* Disposition */
+       if (disp == NULL) {
+               cprintf("NIL");
+       }
+       else if (strlen(disp) == 0) {
+               cprintf("NIL");
+       }
+       else {
+               cprintf("(");
+               imap_strout(disp);
+               if (filename != NULL) if (strlen(filename)>0) {
+                       cprintf(" (\"FILENAME\" ");
+                       imap_strout(filename);
+                       cprintf(")");
+               }
+               cprintf(")");
+       }
+
+       /* Body language (not defined yet) */
+       cprintf(" NIL)");
 }
 
 
 
 /*
- * Spew the BODYSTRUCTURE data for a message.  (Do you need a silencer if
- * you're going to shoot a MIME?  Do you need a reason to shoot Mark Crispin?
- * No, and no.)
+ * Spew the BODYSTRUCTURE data for a message.
  *
- * FIXME finish the implementation
  */
 void imap_fetch_bodystructure (long msgnum, char *item,
                struct CtdlMessage *msg) {
-       FILE *tmp;
-       char buf[1024];
-       long lines = 0L;
-       long bytes = 0L;
-
+       char *rfc822 = NULL;
+       char *rfc822_body = NULL;
+       size_t rfc822_len;
+       size_t rfc822_headers_len;
+       size_t rfc822_body_len;
+       char *ptr = NULL;
+       char buf[SIZ];
+       int lines = 0;
 
        /* For non-RFC822 (ordinary Citadel) messages, this is short and
         * sweet...
@@ -567,22 +820,34 @@ void imap_fetch_bodystructure (long msgnum, char *item,
        if (msg->cm_format_type != FMT_RFC822) {
 
                /* *sigh* We have to RFC822-format the message just to be able
-                * to measure it.
+                * to measure it.  FIXME use smi cached fields if possible
                 */
-               tmp = tmpfile();
-               if (tmp == NULL) return;
-               CtdlRedirectOutput(tmp, -1);
+
+               CC->redirect_buffer = malloc(SIZ);
+               CC->redirect_len = 0;
+               CC->redirect_alloc = SIZ;
                CtdlOutputPreLoadedMsg(msg, msgnum, MT_RFC822, 0, 0, 1);
-               CtdlRedirectOutput(NULL, -1);
+               rfc822 = CC->redirect_buffer;
+               rfc822_len = CC->redirect_len;
+               CC->redirect_buffer = NULL;
+               CC->redirect_len = 0;
+               CC->redirect_alloc = 0;
+
+               ptr = rfc822;
+               while (ptr = memreadline(ptr, buf, sizeof buf), *ptr != 0) {
+                       ++lines;
+                       if ((strlen(buf) == 0) && (rfc822_body == NULL)) {
+                               rfc822_body = ptr;
+                       }
+               }
 
-               rewind(tmp);
-               while (fgets(buf, sizeof buf, tmp) != NULL) ++lines;
-               bytes = ftell(tmp);
-               fclose(tmp);
+               rfc822_headers_len = rfc822_body - rfc822;
+               rfc822_body_len = rfc822_len - rfc822_headers_len;
+               free(rfc822);
 
                cprintf("BODYSTRUCTURE (\"TEXT\" \"PLAIN\" "
                        "(\"CHARSET\" \"US-ASCII\") NIL NIL "
-                       "\"7BIT\" %ld %ld)", bytes, lines);
+                       "\"7BIT\" %d %d)", rfc822_body_len, lines);
 
                return;
        }
@@ -595,67 +860,77 @@ void imap_fetch_bodystructure (long msgnum, char *item,
                        *imap_fetch_bodystructure_pre,  /* pre-multi */
                        *imap_fetch_bodystructure_post, /* post-multi */
                        NULL,
-                       0);
+                       1);     /* don't decode -- we want it as-is */
 }
 
 
-
-
-
-
 /*
- * imap_do_fetch() calls imap_do_fetch_msg() to output the deta of an
- * individual message, once it has been successfully loaded from disk.
+ * imap_do_fetch() calls imap_do_fetch_msg() to output the data of an
+ * individual message, once it has been selected for output.
  */
-void imap_do_fetch_msg(int seq, struct CtdlMessage *msg,
-                       int num_items, char **itemlist) {
+void imap_do_fetch_msg(int seq, int num_items, char **itemlist) {
        int i;
+       struct CtdlMessage *msg = NULL;
 
        cprintf("* %d FETCH (", seq);
 
        for (i=0; i<num_items; ++i) {
 
-               if (!strncasecmp(itemlist[i], "BODY[", 5)) {
-                       imap_fetch_body(IMAP->msgids[seq-1], itemlist[i],
-                                       0, msg);
+               /* Fetchable without going to the message store at all */
+               if (!strcasecmp(itemlist[i], "UID")) {
+                       imap_fetch_uid(seq);
+               }
+               else if (!strcasecmp(itemlist[i], "FLAGS")) {
+                       imap_fetch_flags(seq-1);
+               }
+
+               /* Potentially fetchable from cache, if the client requests
+                * stuff from the same message several times in a row.
+                */
+               else if (!strcasecmp(itemlist[i], "RFC822")) {
+                       imap_fetch_rfc822(IMAP->msgids[seq-1], itemlist[i]);
+               }
+               else if (!strcasecmp(itemlist[i], "RFC822.HEADER")) {
+                       imap_fetch_rfc822(IMAP->msgids[seq-1], itemlist[i]);
+               }
+               else if (!strcasecmp(itemlist[i], "RFC822.SIZE")) {
+                       imap_fetch_rfc822(IMAP->msgids[seq-1], itemlist[i]);
+               }
+               else if (!strcasecmp(itemlist[i], "RFC822.TEXT")) {
+                       imap_fetch_rfc822(IMAP->msgids[seq-1], itemlist[i]);
+               }
+
+               /* BODY fetches do their own fetching and caching too. */
+               else if (!strncasecmp(itemlist[i], "BODY[", 5)) {
+                       imap_fetch_body(IMAP->msgids[seq-1], itemlist[i], 0);
                }
                else if (!strncasecmp(itemlist[i], "BODY.PEEK[", 10)) {
-                       imap_fetch_body(IMAP->msgids[seq-1], itemlist[i],
-                                       1, msg);
+                       imap_fetch_body(IMAP->msgids[seq-1], itemlist[i], 1);
                }
+
+               /* Otherwise, load the message into memory.
+                */
                else if (!strcasecmp(itemlist[i], "BODYSTRUCTURE")) {
+                       if (msg == NULL) msg = CtdlFetchMessage(IMAP->msgids[seq-1], 1);
                        imap_fetch_bodystructure(IMAP->msgids[seq-1],
                                        itemlist[i], msg);
                }
                else if (!strcasecmp(itemlist[i], "ENVELOPE")) {
+                       if (msg == NULL) msg = CtdlFetchMessage(IMAP->msgids[seq-1], 1);
                        imap_fetch_envelope(IMAP->msgids[seq-1], msg);
                }
-               else if (!strcasecmp(itemlist[i], "FLAGS")) {
-                       imap_fetch_flags(msg);
-               }
                else if (!strcasecmp(itemlist[i], "INTERNALDATE")) {
+                       if (msg == NULL) msg = CtdlFetchMessage(IMAP->msgids[seq-1], 1);
                        imap_fetch_internaldate(msg);
                }
-               else if (!strcasecmp(itemlist[i], "RFC822")) {
-                       imap_fetch_rfc822(IMAP->msgids[seq-1], itemlist[i], msg);
-               }
-               else if (!strcasecmp(itemlist[i], "RFC822.HEADER")) {
-                       imap_fetch_rfc822(IMAP->msgids[seq-1], itemlist[i], msg);
-               }
-               else if (!strcasecmp(itemlist[i], "RFC822.SIZE")) {
-                       imap_fetch_rfc822(IMAP->msgids[seq-1], itemlist[i], msg);
-               }
-               else if (!strcasecmp(itemlist[i], "RFC822.TEXT")) {
-                       imap_fetch_rfc822(IMAP->msgids[seq-1], itemlist[i], msg);
-               }
-               else if (!strcasecmp(itemlist[i], "UID")) {
-                       imap_fetch_uid(seq);
-               }
 
                if (i != num_items-1) cprintf(" ");
        }
 
        cprintf(")\r\n");
+       if (msg != NULL) {
+               CtdlFreeMessage(msg);
+       }
 }
 
 
@@ -666,18 +941,12 @@ void imap_do_fetch_msg(int seq, struct CtdlMessage *msg,
  */
 void imap_do_fetch(int num_items, char **itemlist) {
        int i;
-       struct CtdlMessage *msg;
-
-       if (IMAP->num_msgs > 0)
-        for (i = 0; i < IMAP->num_msgs; ++i)
-         if (IMAP->flags[i] && IMAP_FETCHED) {
-               msg = CtdlFetchMessage(IMAP->msgids[i]);
-               if (msg != NULL) {
-                       imap_do_fetch_msg(i+1, msg, num_items, itemlist);
-                       CtdlFreeMessage(msg);
-               }
-               else {
-                       cprintf("* %d FETCH <internal error>\r\n", i+1);
+
+       if (IMAP->num_msgs > 0) {
+               for (i = 0; i < IMAP->num_msgs; ++i) {
+                       if (IMAP->flags[i] & IMAP_SELECTED) {
+                               imap_do_fetch_msg(i+1, num_items, itemlist);
+                       }
                }
        }
 }
@@ -690,7 +959,7 @@ void imap_do_fetch(int num_items, char **itemlist) {
  * is not a generic search-and-replace function.
  */
 void imap_macro_replace(char *str, char *find, char *replace) {
-       char holdbuf[1024];
+       char holdbuf[SIZ];
 
        if (!strncasecmp(str, find, strlen(find))) {
                if (str[strlen(find)]==' ') {
@@ -811,34 +1080,41 @@ int imap_extract_data_items(char **argv, char *items) {
 /*
  * One particularly hideous aspect of IMAP is that we have to allow the client
  * to specify arbitrary ranges and/or sets of messages to fetch.  Citadel IMAP
- * handles this by setting the IMAP_FETCHED flag for each message specified in
+ * handles this by setting the IMAP_SELECTED flag for each message specified in
  * the ranges/sets, then looping through the message array, outputting messages
  * with the flag set.  We don't bother returning an error if an out-of-range
  * number is specified (we just return quietly) because any client braindead
  * enough to request a bogus message number isn't going to notice the
  * difference anyway.
  *
- * This function clears out the IMAP_FETCHED bits, then sets that bit for each
+ * This function clears out the IMAP_SELECTED bits, then sets that bit for each
  * message included in the specified range.
  *
  * Set is_uid to 1 to fetch by UID instead of sequence number.
  */
-void imap_pick_range(char *range, int is_uid) {
+void imap_pick_range(char *supplied_range, int is_uid) {
        int i;
        int num_sets;
        int s;
-       char setstr[SIZ], lostr[SIZ], histr[SIZ];       /* was 1024 */
-       int lo, hi;
-       char *actual_range;
+       char setstr[SIZ], lostr[SIZ], histr[SIZ];
+       long lo, hi;
+       char actual_range[SIZ];
 
-       actual_range = range;
-       if (!strcasecmp(range, "ALL")) actual_range = "1:*";
+       /* 
+        * Handle the "ALL" macro
+        */
+       if (!strcasecmp(supplied_range, "ALL")) {
+               safestrncpy(actual_range, "1:*", sizeof actual_range);
+       }
+       else {
+               safestrncpy(actual_range, supplied_range, sizeof actual_range);
+       }
 
        /*
-        * Clear out the IMAP_FETCHED flags for all messages.
+        * Clear out the IMAP_SELECTED flags for all messages.
         */
-       for (i = 1; i <= IMAP->num_msgs; ++i) {
-               IMAP->flags[i-1] = IMAP->flags[i-1] & ~IMAP_FETCHED;
+       for (i = 0; i < IMAP->num_msgs; ++i) {
+               IMAP->flags[i] = IMAP->flags[i] & ~IMAP_SELECTED;
        }
 
        /*
@@ -846,18 +1122,18 @@ void imap_pick_range(char *range, int is_uid) {
         */
        num_sets = num_tokens(actual_range, ',');
        for (s=0; s<num_sets; ++s) {
-               extract_token(setstr, actual_range, s, ',');
+               extract_token(setstr, actual_range, s, ',', sizeof setstr);
 
-               extract_token(lostr, setstr, 0, ':');
+               extract_token(lostr, setstr, 0, ':', sizeof lostr);
                if (num_tokens(setstr, ':') >= 2) {
-                       extract_token(histr, setstr, 1, ':');
-                       if (!strcmp(histr, "*")) sprintf(histr, "%d", INT_MAX);
+                       extract_token(histr, setstr, 1, ':', sizeof histr);
+                       if (!strcmp(histr, "*")) snprintf(histr, sizeof histr, "%ld", LONG_MAX);
                } 
                else {
-                       strcpy(histr, lostr);
+                       safestrncpy(histr, lostr, sizeof histr);
                }
-               lo = atoi(lostr);
-               hi = atoi(histr);
+               lo = atol(lostr);
+               hi = atol(histr);
 
                /* Loop through the array, flipping bits where appropriate */
                for (i = 1; i <= IMAP->num_msgs; ++i) {
@@ -865,17 +1141,18 @@ void imap_pick_range(char *range, int is_uid) {
                                if ( (IMAP->msgids[i-1]>=lo)
                                   && (IMAP->msgids[i-1]<=hi)) {
                                        IMAP->flags[i-1] =
-                                               IMAP->flags[i-1] | IMAP_FETCHED;
+                                               IMAP->flags[i-1] | IMAP_SELECTED;
                                }
                        }
                        else {          /* fetch by uid */
                                if ( (i>=lo) && (i<=hi)) {
                                        IMAP->flags[i-1] =
-                                               IMAP->flags[i-1] | IMAP_FETCHED;
+                                               IMAP->flags[i-1] | IMAP_SELECTED;
                                }
                        }
                }
        }
+
 }
 
 
@@ -884,7 +1161,7 @@ void imap_pick_range(char *range, int is_uid) {
  * This function is called by the main command loop.
  */
 void imap_fetch(int num_parms, char *parms[]) {
-       char items[SIZ];        /* was 1024 */
+       char items[SIZ];
        char *itemlist[SIZ];
        int num_items;
        int i;
@@ -916,7 +1193,7 @@ void imap_fetch(int num_parms, char *parms[]) {
  * This function is called by the main command loop.
  */
 void imap_uidfetch(int num_parms, char *parms[]) {
-       char items[SIZ];        /* was 1024 */
+       char items[SIZ];
        char *itemlist[SIZ];
        int num_items;
        int i;