citadel/modules/imap/imap_fetch.c

   1 /*
   2  * $Id$
   3  *
   4  * Implements the FETCH command in IMAP.
   5  * This is a good example of the protocol's gratuitous complexity.
   6  *
   7  */
   8
   9
  10 #include "sysdep.h"
  11 #include <stdlib.h>
  12 #include <unistd.h>
  13 #include <stdio.h>
  14 #include <fcntl.h>
  15 #include <signal.h>
  16 #include <pwd.h>
  17 #include <errno.h>
  18 #include <sys/types.h>
  19
  20 #if TIME_WITH_SYS_TIME
  21 # include <sys/time.h>
  22 # include <time.h>
  23 #else
  24 # if HAVE_SYS_TIME_H
  25 #  include <sys/time.h>
  26 # else
  27 #  include <time.h>
  28 # endif
  29 #endif
  30
  31 #include <sys/wait.h>
  32 #include <ctype.h>
  33 #include <string.h>
  34 #include <limits.h>
  35 #include <libcitadel.h>
  36 #include "citadel.h"
  37 #include "server.h"
  38 #include "sysdep_decls.h"
  39 #include "citserver.h"
  40 #include "support.h"
  41 #include "config.h"
  42 #include "room_ops.h"
  43 #include "user_ops.h"
  44 #include "policy.h"
  45 #include "database.h"
  46 #include "msgbase.h"
  47 #include "internet_addressing.h"
  48 #include "serv_imap.h"
  49 #include "imap_tools.h"
  50 #include "imap_fetch.h"
  51 #include "genstamp.h"
  52 #include "ctdl_module.h"
  53
  54
  55
  56 /*
  57  * Individual field functions for imap_do_fetch_msg() ...
  58  */
  59
  60 void imap_fetch_uid(int seq) {
  61         cprintf("UID %ld", IMAP->msgids[seq-1]);
  62 }
  63
  64 void imap_fetch_flags(int seq) {
  65         int num_flags_printed = 0;
  66         cprintf("FLAGS (");
  67         if (IMAP->flags[seq] & IMAP_DELETED) {
  68                 if (num_flags_printed > 0) cprintf(" ");
  69                 cprintf("\\Deleted");
  70                 ++num_flags_printed;
  71         }
  72         if (IMAP->flags[seq] & IMAP_SEEN) {
  73                 if (num_flags_printed > 0) cprintf(" ");
  74                 cprintf("\\Seen");
  75                 ++num_flags_printed;
  76         }
  77         if (IMAP->flags[seq] & IMAP_ANSWERED) {
  78                 if (num_flags_printed > 0) cprintf(" ");
  79                 cprintf("\\Answered");
  80                 ++num_flags_printed;
  81         }
  82         if (IMAP->flags[seq] & IMAP_RECENT) {
  83                 if (num_flags_printed > 0) cprintf(" ");
  84                 cprintf("\\Recent");
  85                 ++num_flags_printed;
  86         }
  87         cprintf(")");
  88 }
  89
  90 void imap_fetch_internaldate(struct CtdlMessage *msg) {
  91         char buf[SIZ];
  92         time_t msgdate;
  93
  94         if (!msg) return;
  95         if (msg->cm_fields['T'] != NULL) {
  96                 msgdate = atol(msg->cm_fields['T']);
  97         }
  98         else {
  99                 msgdate = time(NULL);
 100         }
 101
 102         datestring(buf, sizeof buf, msgdate, DATESTRING_IMAP);
 103         cprintf("INTERNALDATE \"%s\"", buf);
 104 }
 105
 106
 107 /*
 108  * Fetch RFC822-formatted messages.
 109  *
 110  * 'whichfmt' should be set to one of:
 111  *      "RFC822"        entire message
 112  *      "RFC822.HEADER" headers only (with trailing blank line)
 113  *      "RFC822.SIZE"   size of translated message
 114  *      "RFC822.TEXT"   body only (without leading blank line)
 115  */
 116 void imap_fetch_rfc822(long msgnum, char *whichfmt) {
 117         char buf[SIZ];
 118         char *ptr = NULL;
 119         size_t headers_size, text_size, total_size;
 120         size_t bytes_to_send = 0;
 121         struct MetaData smi;
 122         int need_to_rewrite_metadata = 0;
 123         int need_body = 0;
 124
 125         /* Determine whether this particular fetch operation requires
 126          * us to fetch the message body from disk.  If not, we can save
 127          * on some disk operations...
 128          */
 129         if ( (!strcasecmp(whichfmt, "RFC822"))
 130            || (!strcasecmp(whichfmt, "RFC822.TEXT")) ) {
 131                 need_body = 1;
 132         }
 133
 134         /* If this is an RFC822.SIZE fetch, first look in the message's
 135          * metadata record to see if we've saved that information.
 136          */
 137         if (!strcasecmp(whichfmt, "RFC822.SIZE")) {
 138                 GetMetaData(&smi, msgnum);
 139                 if (smi.meta_rfc822_length > 0L) {
 140                         cprintf("RFC822.SIZE %ld", smi.meta_rfc822_length);
 141                         return;
 142                 }
 143                 need_to_rewrite_metadata = 1;
 144                 need_body = 1;
 145         }
 146
 147         /* Cache the most recent RFC822 FETCH because some clients like to
 148          * fetch in pieces, and we don't want to have to go back to the
 149          * message store for each piece.  We also burn the cache if the
 150          * client requests something that involves reading the message
 151          * body, but we haven't fetched the body yet.
 152          */
 153         if ((IMAP->cached_rfc822_data != NULL)
 154            && (IMAP->cached_rfc822_msgnum == msgnum)
 155            && (IMAP->cached_rfc822_withbody || (!need_body)) ) {
 156                 /* Good to go! */
 157         }
 158         else if (IMAP->cached_rfc822_data != NULL) {
 159                 /* Some other message is cached -- free it */
 160                 free(IMAP->cached_rfc822_data);
 161                 IMAP->cached_rfc822_data = NULL;
 162                 IMAP->cached_rfc822_msgnum = (-1);
 163                 IMAP->cached_rfc822_len = 0;
 164         }
 165
 166         /* At this point, we now can fetch and convert the message iff it's not
 167          * the one we had cached.
 168          */
 169         if (IMAP->cached_rfc822_data == NULL) {
 170                 /*
 171                  * Load the message into memory for translation & measurement
 172                  */
 173                 CC->redirect_buffer = malloc(SIZ);
 174                 CC->redirect_len = 0;
 175                 CC->redirect_alloc = SIZ;
 176                 CtdlOutputMsg(msgnum, MT_RFC822,
 177                         (need_body ? HEADERS_ALL : HEADERS_FAST),
 178                         0, 1, NULL, SUPPRESS_ENV_TO
 179                 );
 180                 if (!need_body) cprintf("\r\n");        /* extra trailing newline */
 181                 IMAP->cached_rfc822_data = CC->redirect_buffer;
 182                 IMAP->cached_rfc822_len = CC->redirect_len;
 183                 IMAP->cached_rfc822_msgnum = msgnum;
 184                 IMAP->cached_rfc822_withbody = need_body;
 185                 CC->redirect_buffer = NULL;
 186                 CC->redirect_len = 0;
 187                 CC->redirect_alloc = 0;
 188                 if ( (need_to_rewrite_metadata) && (IMAP->cached_rfc822_len > 0) ) {
 189                         smi.meta_rfc822_length = (long)IMAP->cached_rfc822_len;
 190                         PutMetaData(&smi);
 191                 }
 192         }
 193
 194         /*
 195          * Now figure out where the headers/text break is.  IMAP considers the
 196          * intervening blank line to be part of the headers, not the text.
 197          */
 198         headers_size = 0;
 199         text_size = 0;
 200         total_size = 0;
 201
 202         if (need_body) {
 203                 ptr = IMAP->cached_rfc822_data;
 204                 do {
 205                         ptr = memreadline(ptr, buf, sizeof buf);
 206                         if (*ptr != 0) {
 207                                 striplt(buf);
 208                                 if (IsEmptyStr(buf)) {
 209                                         headers_size = ptr - IMAP->cached_rfc822_data;
 210                                 }
 211                         }
 212                 } while ( (headers_size == 0) && (*ptr != 0) );
 213
 214                 total_size = IMAP->cached_rfc822_len;
 215                 text_size = total_size - headers_size;
 216         }
 217         else {
 218                 headers_size = IMAP->cached_rfc822_len;
 219                 total_size = IMAP->cached_rfc822_len;
 220                 text_size = 0;
 221         }
 222
 223         CtdlLogPrintf(CTDL_DEBUG,
 224                 "RFC822: headers=" SIZE_T_FMT
 225                 ", text=" SIZE_T_FMT
 226                 ", total=" SIZE_T_FMT "\n",
 227                 headers_size, text_size, total_size);
 228
 229         if (!strcasecmp(whichfmt, "RFC822.SIZE")) {
 230                 cprintf("RFC822.SIZE " SIZE_T_FMT, total_size);
 231                 return;
 232         }
 233
 234         else if (!strcasecmp(whichfmt, "RFC822")) {
 235                 ptr = IMAP->cached_rfc822_data;
 236                 bytes_to_send = total_size;
 237         }
 238
 239         else if (!strcasecmp(whichfmt, "RFC822.HEADER")) {
 240                 ptr = IMAP->cached_rfc822_data;
 241                 bytes_to_send = headers_size;
 242         }
 243
 244         else if (!strcasecmp(whichfmt, "RFC822.TEXT")) {
 245                 ptr = &IMAP->cached_rfc822_data[headers_size];
 246                 bytes_to_send = text_size;
 247         }
 248
 249         cprintf("%s {" SIZE_T_FMT "}\r\n", whichfmt, bytes_to_send);
 250         client_write(ptr, bytes_to_send);
 251 }
 252
 253
 254
 255 /*
 256  * Load a specific part of a message into the temp file to be output to a
 257  * client.  FIXME we can handle parts like "2" and "2.1" and even "2.MIME"
 258  * but we still can't handle "2.HEADER" (which might not be a problem).
 259  *
 260  * Note: mime_parser() was called with dont_decode set to 1, so we have the
 261  * luxury of simply spewing without having to re-encode.
 262  */
 263 void imap_load_part(char *name, char *filename, char *partnum, char *disp,
 264                     void *content, char *cbtype, char *cbcharset, size_t length, char *encoding,
 265                     char *cbid, void *cbuserdata)
 266 {
 267         char mbuf2[SIZ];
 268         char *desired_section;
 269
 270         desired_section = (char *)cbuserdata;
 271
 272         if (!strcasecmp(partnum, desired_section)) {
 273                 client_write(content, length);
 274         }
 275
 276         snprintf(mbuf2, sizeof mbuf2, "%s.MIME", partnum);
 277
 278         if (!strcasecmp(desired_section, mbuf2)) {
 279                 cprintf("Content-type: %s", cbtype);
 280                 if (!IsEmptyStr(cbcharset))
 281                         cprintf("; charset=\"%s\"", cbcharset);
 282                 if (!IsEmptyStr(name))
 283                         cprintf("; name=\"%s\"", name);
 284                 cprintf("\r\n");
 285                 if (!IsEmptyStr(encoding))
 286                         cprintf("Content-Transfer-Encoding: %s\r\n", encoding);
 287                 if (!IsEmptyStr(encoding)) {
 288                         cprintf("Content-Disposition: %s", disp);
 289                         if (!IsEmptyStr(filename)) {
 290                                 cprintf("; filename=\"%s\"", filename);
 291                         }
 292                         cprintf("\r\n");
 293                 }
 294                 cprintf("Content-Length: %ld\r\n", (long)length);
 295                 cprintf("\r\n");
 296         }
 297
 298
 299 }
 300
 301
 302 /*
 303  * Called by imap_fetch_envelope() to output the "From" field.
 304  * This is in its own function because its logic is kind of complex.  We
 305  * really need to make this suck less.
 306  */
 307 void imap_output_envelope_from(struct CtdlMessage *msg) {
 308         char user[SIZ], node[SIZ], name[SIZ];
 309
 310         if (!msg) return;
 311
 312         /* For anonymous messages, it's so easy! */
 313         if (!is_room_aide() && (msg->cm_anon_type == MES_ANONONLY)) {
 314                 cprintf("((\"----\" NIL \"x\" \"x.org\")) ");
 315                 return;
 316         }
 317         if (!is_room_aide() && (msg->cm_anon_type == MES_ANONOPT)) {
 318                 cprintf("((\"anonymous\" NIL \"x\" \"x.org\")) ");
 319                 return;
 320         }
 321
 322         /* For everything else, we do stuff. */
 323         cprintf("((");                          /* open double-parens */
 324         imap_strout(msg->cm_fields['A']);       /* personal name */
 325         cprintf(" NIL ");                       /* source route (not used) */
 326
 327
 328         if (msg->cm_fields['F'] != NULL) {
 329                 process_rfc822_addr(msg->cm_fields['F'], user, node, name);
 330                 imap_strout(user);              /* mailbox name (user id) */
 331                 cprintf(" ");
 332                 if (!strcasecmp(node, config.c_nodename)) {
 333                         imap_strout(config.c_fqdn);
 334                 }
 335                 else {
 336                         imap_strout(node);              /* host name */
 337                 }
 338         }
 339         else {
 340                 imap_strout(msg->cm_fields['A']); /* mailbox name (user id) */
 341                 cprintf(" ");
 342                 imap_strout(msg->cm_fields['N']);       /* host name */
 343         }
 344
 345         cprintf(")) ");                         /* close double-parens */
 346 }
 347
 348
 349
 350 /*
 351  * Output an envelope address (or set of addresses) in the official,
 352  * convoluted, braindead format.  (Note that we can't use this for
 353  * the "From" address because its data may come from a number of different
 354  * fields.  But we can use it for "To" and possibly others.
 355  */
 356 void imap_output_envelope_addr(char *addr) {
 357         char individual_addr[256];
 358         int num_addrs;
 359         int i;
 360         char user[256];
 361         char node[256];
 362         char name[256];
 363
 364         if (addr == NULL) {
 365                 cprintf("NIL ");
 366                 return;
 367         }
 368
 369         if (IsEmptyStr(addr)) {
 370                 cprintf("NIL ");
 371                 return;
 372         }
 373
 374         cprintf("(");
 375
 376         /* How many addresses are listed here? */
 377         num_addrs = num_tokens(addr, ',');
 378
 379         /* Output them one by one. */
 380         for (i=0; i<num_addrs; ++i) {
 381                 extract_token(individual_addr, addr, i, ',', sizeof individual_addr);
 382                 striplt(individual_addr);
 383                 process_rfc822_addr(individual_addr, user, node, name);
 384                 cprintf("(");
 385                 imap_strout(name);
 386                 cprintf(" NIL ");
 387                 imap_strout(user);
 388                 cprintf(" ");
 389                 imap_strout(node);
 390                 cprintf(")");
 391                 if (i < (num_addrs-1)) cprintf(" ");
 392         }
 393
 394         cprintf(") ");
 395 }
 396
 397
 398 /*
 399  * Implements the ENVELOPE fetch item
 400  *
 401  * Note that the imap_strout() function can cleverly output NULL fields as NIL,
 402  * so we don't have to check for that condition like we do elsewhere.
 403  */
 404 void imap_fetch_envelope(struct CtdlMessage *msg) {
 405         char datestringbuf[SIZ];
 406         time_t msgdate;
 407         char *fieldptr = NULL;
 408
 409         if (!msg) return;
 410
 411         /* Parse the message date into an IMAP-format date string */
 412         if (msg->cm_fields['T'] != NULL) {
 413                 msgdate = atol(msg->cm_fields['T']);
 414         }
 415         else {
 416                 msgdate = time(NULL);
 417         }
 418         datestring(datestringbuf, sizeof datestringbuf,
 419                 msgdate, DATESTRING_IMAP);
 420
 421         /* Now start spewing data fields.  The order is important, as it is
 422          * defined by the protocol specification.  Nonexistent fields must
 423          * be output as NIL, existent fields must be quoted or literalled.
 424          * The imap_strout() function conveniently does all this for us.
 425          */
 426         cprintf("ENVELOPE (");
 427
 428         /* Date */
 429         imap_strout(datestringbuf);
 430         cprintf(" ");
 431
 432         /* Subject */
 433         imap_strout(msg->cm_fields['U']);
 434         cprintf(" ");
 435
 436         /* From */
 437         imap_output_envelope_from(msg);
 438
 439         /* Sender (default to same as 'From' if not present) */
 440         fieldptr = rfc822_fetch_field(msg->cm_fields['M'], "Sender");
 441         if (fieldptr != NULL) {
 442                 imap_output_envelope_addr(fieldptr);
 443                 free(fieldptr);
 444         }
 445         else {
 446                 imap_output_envelope_from(msg);
 447         }
 448
 449         /* Reply-to */
 450         fieldptr = rfc822_fetch_field(msg->cm_fields['M'], "Reply-to");
 451         if (fieldptr != NULL) {
 452                 imap_output_envelope_addr(fieldptr);
 453                 free(fieldptr);
 454         }
 455         else {
 456                 imap_output_envelope_from(msg);
 457         }
 458
 459         /* To */
 460         imap_output_envelope_addr(msg->cm_fields['R']);
 461
 462         /* Cc (we do it this way because there might be a legacy non-Citadel Cc: field present) */
 463         fieldptr = msg->cm_fields['Y'];
 464         if (fieldptr != NULL) {
 465                 imap_output_envelope_addr(fieldptr);
 466         }
 467         else {
 468                 fieldptr = rfc822_fetch_field(msg->cm_fields['M'], "Cc");
 469                 imap_output_envelope_addr(fieldptr);
 470                 if (fieldptr != NULL) free(fieldptr);
 471         }
 472
 473         /* Bcc */
 474         fieldptr = rfc822_fetch_field(msg->cm_fields['M'], "Bcc");
 475         imap_output_envelope_addr(fieldptr);
 476         if (fieldptr != NULL) free(fieldptr);
 477
 478         /* In-reply-to */
 479         fieldptr = rfc822_fetch_field(msg->cm_fields['M'], "In-reply-to");
 480         imap_strout(fieldptr);
 481         cprintf(" ");
 482         if (fieldptr != NULL) free(fieldptr);
 483
 484         /* message ID */
 485         imap_strout(msg->cm_fields['I']);
 486
 487         cprintf(")");
 488 }
 489
 490 /*
 491  * This function is called only when CC->redirect_buffer contains a set of
 492  * RFC822 headers with no body attached.  Its job is to strip that set of
 493  * headers down to *only* the ones we're interested in.
 494  */
 495 void imap_strip_headers(char *section) {
 496         char buf[SIZ];
 497         char *which_fields = NULL;
 498         int doing_headers = 0;
 499         int headers_not = 0;
 500         char *parms[SIZ];
 501         int num_parms = 0;
 502         int i;
 503         char *boiled_headers = NULL;
 504         int ok = 0;
 505         int done_headers = 0;
 506         char *ptr = NULL;
 507
 508         if (CC->redirect_buffer == NULL) return;
 509
 510         which_fields = strdup(section);
 511
 512         if (!strncasecmp(which_fields, "HEADER.FIELDS", 13))
 513                 doing_headers = 1;
 514         if (!strncasecmp(which_fields, "HEADER.FIELDS.NOT", 17))
 515                 headers_not = 1;
 516
 517         for (i=0; which_fields[i]; ++i) {
 518                 if (which_fields[i]=='(')
 519                         strcpy(which_fields, &which_fields[i+1]);
 520         }
 521         for (i=0; which_fields[i]; ++i) {
 522                 if (which_fields[i]==')') {
 523                         which_fields[i] = 0;
 524                         break;
 525                 }
 526         }
 527         num_parms = imap_parameterize(parms, which_fields);
 528
 529         boiled_headers = malloc(CC->redirect_alloc);
 530         strcpy(boiled_headers, "");
 531
 532         ptr = CC->redirect_buffer;
 533         ok = 0;
 534         do {
 535                 ptr = memreadline(ptr, buf, sizeof buf);
 536                 if (!isspace(buf[0])) {
 537                         ok = 0;
 538                         if (doing_headers == 0) ok = 1;
 539                         else {
 540                                 if (headers_not) ok = 1;
 541                                 else ok = 0;
 542                                 for (i=0; i<num_parms; ++i) {
 543                                         if ( (!strncasecmp(buf, parms[i],
 544                                            strlen(parms[i]))) &&
 545                                            (buf[strlen(parms[i])]==':') ) {
 546                                                 if (headers_not) ok = 0;
 547                                                 else ok = 1;
 548                                         }
 549                                 }
 550                         }
 551                 }
 552
 553                 if (ok) {
 554                         strcat(boiled_headers, buf);
 555                         strcat(boiled_headers, "\r\n");
 556                 }
 557
 558                 if (IsEmptyStr(buf)) done_headers = 1;
 559                 if (buf[0]=='\r') done_headers = 1;
 560                 if (buf[0]=='\n') done_headers = 1;
 561                 if (*ptr == 0) done_headers = 1;
 562         } while (!done_headers);
 563
 564         strcat(boiled_headers, "\r\n");
 565
 566         /* Now save it back (it'll always be smaller) */
 567         strcpy(CC->redirect_buffer, boiled_headers);
 568         CC->redirect_len = strlen(boiled_headers);
 569
 570         free(which_fields);
 571         free(boiled_headers);
 572 }
 573
 574
 575 /*
 576  * Implements the BODY and BODY.PEEK fetch items
 577  */
 578 void imap_fetch_body(long msgnum, char *item, int is_peek) {
 579         struct CtdlMessage *msg = NULL;
 580         char section[SIZ];
 581         char partial[SIZ];
 582         int is_partial = 0;
 583         size_t pstart, pbytes;
 584         int loading_body_now = 0;
 585         int need_body = 1;
 586         int burn_the_cache = 0;
 587
 588         /* extract section */
 589         safestrncpy(section, item, sizeof section);
 590         if (strchr(section, '[') != NULL) {
 591                 stripallbut(section, '[', ']');
 592         }
 593         CtdlLogPrintf(CTDL_DEBUG, "Section is: %s%s\n",
 594                 section,
 595                 IsEmptyStr(section) ? "(empty)" : "");
 596
 597         /* Burn the cache if we don't have the same section of the
 598          * same message again.
 599          */
 600         if (IMAP->cached_body != NULL) {
 601                 if (IMAP->cached_bodymsgnum != msgnum) {
 602                         burn_the_cache = 1;
 603                 }
 604                 else if ( (!IMAP->cached_body_withbody) && (need_body) ) {
 605                         burn_the_cache = 1;
 606                 }
 607                 else if (strcasecmp(IMAP->cached_bodypart, section)) {
 608                         burn_the_cache = 1;
 609                 }
 610                 if (burn_the_cache) {
 611                         /* Yup, go ahead and burn the cache. */
 612                         free(IMAP->cached_body);
 613                         IMAP->cached_body_len = 0;
 614                         IMAP->cached_body = NULL;
 615                         IMAP->cached_bodymsgnum = (-1);
 616                         strcpy(IMAP->cached_bodypart, "");
 617                 }
 618         }
 619
 620         /* extract partial */
 621         safestrncpy(partial, item, sizeof partial);
 622         if (strchr(partial, '<') != NULL) {
 623                 stripallbut(partial, '<', '>');
 624                 is_partial = 1;
 625         }
 626         if (is_partial == 0) strcpy(partial, "");
 627         /* if (!IsEmptyStr(partial)) CtdlLogPrintf(CTDL_DEBUG, "Partial is %s\n", partial); */
 628
 629         if (IMAP->cached_body == NULL) {
 630                 CC->redirect_buffer = malloc(SIZ);
 631                 CC->redirect_len = 0;
 632                 CC->redirect_alloc = SIZ;
 633                 loading_body_now = 1;
 634                 msg = CtdlFetchMessage(msgnum, (need_body ? 1 : 0));
 635         }
 636
 637         /* Now figure out what the client wants, and get it */
 638
 639         if (!loading_body_now) {
 640                 /* What we want is already in memory */
 641         }
 642
 643         else if ( (!strcmp(section, "1")) && (msg->cm_format_type != 4) ) {
 644                 CtdlOutputPreLoadedMsg(msg, MT_RFC822, HEADERS_NONE, 0, 1, SUPPRESS_ENV_TO);
 645         }
 646
 647         else if (!strcmp(section, "")) {
 648                 CtdlOutputPreLoadedMsg(msg, MT_RFC822, HEADERS_ALL, 0, 1, SUPPRESS_ENV_TO);
 649         }
 650
 651         /*
 652          * If the client asked for just headers, or just particular header
 653          * fields, strip it down.
 654          */
 655         else if (!strncasecmp(section, "HEADER", 6)) {
 656                 /* This used to work with HEADERS_FAST, but then Apple got stupid with their
 657                  * IMAP library and this broke Mail.App and iPhone Mail, so we had to change it
 658                  * to HEADERS_ONLY so the trendy hipsters with their iPhones can read mail.
 659                  */
 660                 CtdlOutputPreLoadedMsg(msg, MT_RFC822, HEADERS_ONLY, 0, 1, SUPPRESS_ENV_TO);
 661                 imap_strip_headers(section);
 662         }
 663
 664         /*
 665          * Strip it down if the client asked for everything _except_ headers.
 666          */
 667         else if (!strncasecmp(section, "TEXT", 4)) {
 668                 CtdlOutputPreLoadedMsg(msg, MT_RFC822, HEADERS_NONE, 0, 1, SUPPRESS_ENV_TO);
 669         }
 670
 671         /*
 672          * Anything else must be a part specifier.
 673          * (Note value of 1 passed as 'dont_decode' so client gets it encoded)
 674          */
 675         else {
 676                 mime_parser(msg->cm_fields['M'], NULL,
 677                                 *imap_load_part, NULL, NULL,
 678                                 section,
 679                                 1);
 680         }
 681
 682         if (loading_body_now) {
 683                 IMAP->cached_body = CC->redirect_buffer;
 684                 IMAP->cached_body_len = CC->redirect_len;
 685                 IMAP->cached_bodymsgnum = msgnum;
 686                 IMAP->cached_body_withbody = need_body;
 687                 strcpy(IMAP->cached_bodypart, section);
 688                 CC->redirect_buffer = NULL;
 689                 CC->redirect_len = 0;
 690                 CC->redirect_alloc = 0;
 691         }
 692
 693         if (is_partial == 0) {
 694                 cprintf("BODY[%s] {" SIZE_T_FMT "}\r\n", section, IMAP->cached_body_len);
 695                 pstart = 0;
 696                 pbytes = IMAP->cached_body_len;
 697         }
 698         else {
 699                 sscanf(partial, SIZE_T_FMT "." SIZE_T_FMT, &pstart, &pbytes);
 700                 if (pbytes > (IMAP->cached_body_len - pstart)) {
 701                         pbytes = IMAP->cached_body_len - pstart;
 702                 }
 703                 cprintf("BODY[%s]<" SIZE_T_FMT "> {" SIZE_T_FMT "}\r\n", section, pstart, pbytes);
 704         }
 705
 706         /* Here we go -- output it */
 707         client_write(&IMAP->cached_body[pstart], pbytes);
 708
 709         if (msg != NULL) {
 710                 CtdlFreeMessage(msg);
 711         }
 712
 713         /* Mark this message as "seen" *unless* this is a "peek" operation */
 714         if (is_peek == 0) {
 715                 CtdlSetSeen(&msgnum, 1, 1, ctdlsetseen_seen, NULL, NULL);
 716         }
 717 }
 718
 719 /*
 720  * Called immediately before outputting a multipart bodystructure
 721  */
 722 void imap_fetch_bodystructure_pre(
 723                 char *name, char *filename, char *partnum, char *disp,
 724                 void *content, char *cbtype, char *cbcharset, size_t length, char *encoding,
 725                 char *cbid, void *cbuserdata
 726                 ) {
 727
 728         cprintf("(");
 729 }
 730
 731
 732
 733 /*
 734  * Called immediately after outputting a multipart bodystructure
 735  */
 736 void imap_fetch_bodystructure_post(
 737                 char *name, char *filename, char *partnum, char *disp,
 738                 void *content, char *cbtype, char *cbcharset, size_t length, char *encoding,
 739                 char *cbid, void *cbuserdata
 740                 ) {
 741
 742         char subtype[128];
 743
 744         cprintf(" ");
 745
 746         /* disposition */
 747         extract_token(subtype, cbtype, 1, '/', sizeof subtype);
 748         imap_strout(subtype);
 749
 750         /* body language */
 751         /* cprintf(" NIL"); We thought we needed this at one point, but maybe we don't... */
 752
 753         cprintf(")");
 754 }
 755
 756
 757
 758 /*
 759  * Output the info for a MIME part in the format required by BODYSTRUCTURE.
 760  *
 761  */
 762 void imap_fetch_bodystructure_part(
 763                 char *name, char *filename, char *partnum, char *disp,
 764                 void *content, char *cbtype, char *cbcharset, size_t length, char *encoding,
 765                 char *cbid, void *cbuserdata
 766                 ) {
 767
 768         int have_cbtype = 0;
 769         int have_encoding = 0;
 770         int lines = 0;
 771         size_t i;
 772         char cbmaintype[128];
 773         char cbsubtype[128];
 774
 775         if (cbtype != NULL) if (!IsEmptyStr(cbtype)) have_cbtype = 1;
 776         if (have_cbtype) {
 777                 extract_token(cbmaintype, cbtype, 0, '/', sizeof cbmaintype);
 778                 extract_token(cbsubtype, cbtype, 1, '/', sizeof cbsubtype);
 779         }
 780         else {
 781                 strcpy(cbmaintype, "TEXT");
 782                 strcpy(cbsubtype, "PLAIN");
 783         }
 784
 785         cprintf("(");
 786         imap_strout(cbmaintype);                                        /* body type */
 787         cprintf(" ");
 788         imap_strout(cbsubtype);                                         /* body subtype */
 789         cprintf(" ");
 790
 791         cprintf("(");                                                   /* begin body parameter list */
 792
 793         /* "NAME" must appear as the first parameter.  This is not required by IMAP,
 794          * but the Asterisk voicemail application blindly assumes that NAME will be in
 795          * the first position.  If it isn't, it rejects the message.
 796          */
 797         if (name != NULL) if (!IsEmptyStr(name)) {
 798                 cprintf("\"NAME\" ");
 799                 imap_strout(name);
 800                 cprintf(" ");
 801         }
 802
 803         cprintf("\"CHARSET\" ");
 804         if (cbcharset == NULL) {
 805                 imap_strout("US-ASCII");
 806         }
 807         else if (cbcharset[0] == 0) {
 808                 imap_strout("US-ASCII");
 809         }
 810         else {
 811                 imap_strout(cbcharset);
 812         }
 813         cprintf(") ");                                                  /* end body parameter list */
 814
 815         cprintf("NIL ");                                                /* Body ID */
 816         cprintf("NIL ");                                                /* Body description */
 817
 818         if (encoding != NULL) if (encoding[0] != 0)  have_encoding = 1;
 819         if (have_encoding) {
 820                 imap_strout(encoding);
 821         }
 822         else {
 823                 imap_strout("7BIT");
 824         }
 825         cprintf(" ");
 826
 827         /* The next field is the size of the part in bytes. */
 828         cprintf("%ld ", (long)length);  /* bytes */
 829
 830         /* The next field is the number of lines in the part, if and only
 831          * if the part is TEXT.  More gratuitous complexity.
 832          */
 833         if (!strcasecmp(cbmaintype, "TEXT")) {
 834                 if (length) for (i=0; i<length; ++i) {
 835                         if (((char *)content)[i] == '\n') ++lines;
 836                 }
 837                 cprintf("%d ", lines);
 838         }
 839
 840         /* More gratuitous complexity */
 841         if ((!strcasecmp(cbmaintype, "MESSAGE"))
 842            && (!strcasecmp(cbsubtype, "RFC822"))) {
 843                 /* FIXME: message/rfc822 also needs to output the envelope structure,
 844                  * body structure, and line count of the encapsulated message.  Fortunately
 845                  * there are not yet any clients depending on this, so we can get away
 846                  * with not implementing it for now.
 847                  */
 848         }
 849
 850         /* MD5 value of body part; we can get away with NIL'ing this */
 851         cprintf("NIL ");
 852
 853         /* Disposition */
 854         if (disp == NULL) {
 855                 cprintf("NIL");
 856         }
 857         else if (IsEmptyStr(disp)) {
 858                 cprintf("NIL");
 859         }
 860         else {
 861                 cprintf("(");
 862                 imap_strout(disp);
 863                 if (filename != NULL) if (!IsEmptyStr(filename)) {
 864                         cprintf(" (\"FILENAME\" ");
 865                         imap_strout(filename);
 866                         cprintf(")");
 867                 }
 868                 cprintf(")");
 869         }
 870
 871         /* Body language (not defined yet) */
 872         cprintf(" NIL)");
 873 }
 874
 875
 876
 877 /*
 878  * Spew the BODYSTRUCTURE data for a message.
 879  *
 880  */
 881 void imap_fetch_bodystructure (long msgnum, char *item,
 882                 struct CtdlMessage *msg) {
 883         char *rfc822 = NULL;
 884         char *rfc822_body = NULL;
 885         size_t rfc822_len;
 886         size_t rfc822_headers_len;
 887         size_t rfc822_body_len;
 888         char *ptr = NULL;
 889         char buf[SIZ];
 890         int lines = 0;
 891
 892         /* Handle NULL message gracefully */
 893         if (msg == NULL) {
 894                 cprintf("BODYSTRUCTURE (\"TEXT\" \"PLAIN\" "
 895                         "(\"CHARSET\" \"US-ASCII\") NIL NIL "
 896                         "\"7BIT\" 0 0)");
 897                 return;
 898         }
 899
 900         /* For non-RFC822 (ordinary Citadel) messages, this is short and
 901          * sweet...
 902          */
 903         if (msg->cm_format_type != FMT_RFC822) {
 904
 905                 /* *sigh* We have to RFC822-format the message just to be able
 906                  * to measure it.  FIXME use smi cached fields if possible
 907                  */
 908
 909                 CC->redirect_buffer = malloc(SIZ);
 910                 CC->redirect_len = 0;
 911                 CC->redirect_alloc = SIZ;
 912                 CtdlOutputPreLoadedMsg(msg, MT_RFC822, 0, 0, 1, SUPPRESS_ENV_TO);
 913                 rfc822 = CC->redirect_buffer;
 914                 rfc822_len = CC->redirect_len;
 915                 CC->redirect_buffer = NULL;
 916                 CC->redirect_len = 0;
 917                 CC->redirect_alloc = 0;
 918
 919                 ptr = rfc822;
 920                 do {
 921                         ptr = memreadline(ptr, buf, sizeof buf);
 922                         ++lines;
 923                         if ((IsEmptyStr(buf)) && (rfc822_body == NULL)) {
 924                                 rfc822_body = ptr;
 925                         }
 926                 } while (*ptr != 0);
 927
 928                 rfc822_headers_len = rfc822_body - rfc822;
 929                 rfc822_body_len = rfc822_len - rfc822_headers_len;
 930                 free(rfc822);
 931
 932                 cprintf("BODYSTRUCTURE (\"TEXT\" \"PLAIN\" "
 933                         "(\"CHARSET\" \"US-ASCII\") NIL NIL "
 934                         "\"7BIT\" " SIZE_T_FMT " %d)", rfc822_body_len, lines);
 935
 936                 return;
 937         }
 938
 939         /* For messages already stored in RFC822 format, we have to parse. */
 940         cprintf("BODYSTRUCTURE ");
 941         mime_parser(msg->cm_fields['M'],
 942                         NULL,
 943                         *imap_fetch_bodystructure_part, /* part */
 944                         *imap_fetch_bodystructure_pre,  /* pre-multi */
 945                         *imap_fetch_bodystructure_post, /* post-multi */
 946                         NULL,
 947                         1);     /* don't decode -- we want it as-is */
 948 }
 949
 950
 951 /*
 952  * imap_do_fetch() calls imap_do_fetch_msg() to output the data of an
 953  * individual message, once it has been selected for output.
 954  */
 955 void imap_do_fetch_msg(int seq, int num_items, char **itemlist) {
 956         int i;
 957         struct CtdlMessage *msg = NULL;
 958         int body_loaded = 0;
 959
 960         /* Don't attempt to fetch bogus messages or UID's */
 961         if (seq < 1) return;
 962         if (IMAP->msgids[seq-1] < 1L) return;
 963
 964         buffer_output();
 965         cprintf("* %d FETCH (", seq);
 966
 967         for (i=0; i<num_items; ++i) {
 968
 969                 /* Fetchable without going to the message store at all */
 970                 if (!strcasecmp(itemlist[i], "UID")) {
 971                         imap_fetch_uid(seq);
 972                 }
 973                 else if (!strcasecmp(itemlist[i], "FLAGS")) {
 974                         imap_fetch_flags(seq-1);
 975                 }
 976
 977                 /* Potentially fetchable from cache, if the client requests
 978                  * stuff from the same message several times in a row.
 979                  */
 980                 else if (!strcasecmp(itemlist[i], "RFC822")) {
 981                         imap_fetch_rfc822(IMAP->msgids[seq-1], itemlist[i]);
 982                 }
 983                 else if (!strcasecmp(itemlist[i], "RFC822.HEADER")) {
 984                         imap_fetch_rfc822(IMAP->msgids[seq-1], itemlist[i]);
 985                 }
 986                 else if (!strcasecmp(itemlist[i], "RFC822.SIZE")) {
 987                         imap_fetch_rfc822(IMAP->msgids[seq-1], itemlist[i]);
 988                 }
 989                 else if (!strcasecmp(itemlist[i], "RFC822.TEXT")) {
 990                         imap_fetch_rfc822(IMAP->msgids[seq-1], itemlist[i]);
 991                 }
 992
 993                 /* BODY fetches do their own fetching and caching too. */
 994                 else if (!strncasecmp(itemlist[i], "BODY[", 5)) {
 995                         imap_fetch_body(IMAP->msgids[seq-1], itemlist[i], 0);
 996                 }
 997                 else if (!strncasecmp(itemlist[i], "BODY.PEEK[", 10)) {
 998                         imap_fetch_body(IMAP->msgids[seq-1], itemlist[i], 1);
 999                 }
1000
1001                 /* Otherwise, load the message into memory.
1002                  */
1003                 else if (!strcasecmp(itemlist[i], "BODYSTRUCTURE")) {
1004                         if ((msg != NULL) && (!body_loaded)) {
1005                                 CtdlFreeMessage(msg);   /* need the whole thing */
1006                                 msg = NULL;
1007                         }
1008                         if (msg == NULL) {
1009                                 msg = CtdlFetchMessage(IMAP->msgids[seq-1], 1);
1010                                 body_loaded = 1;
1011                         }
1012                         imap_fetch_bodystructure(IMAP->msgids[seq-1],
1013                                         itemlist[i], msg);
1014                 }
1015                 else if (!strcasecmp(itemlist[i], "ENVELOPE")) {
1016                         if (msg == NULL) {
1017                                 msg = CtdlFetchMessage(IMAP->msgids[seq-1], 0);
1018                                 body_loaded = 0;
1019                         }
1020                         imap_fetch_envelope(msg);
1021                 }
1022                 else if (!strcasecmp(itemlist[i], "INTERNALDATE")) {
1023                         if (msg == NULL) {
1024                                 msg = CtdlFetchMessage(IMAP->msgids[seq-1], 0);
1025                                 body_loaded = 0;
1026                         }
1027                         imap_fetch_internaldate(msg);
1028                 }
1029
1030                 if (i != num_items-1) cprintf(" ");
1031         }
1032
1033         cprintf(")\r\n");
1034         unbuffer_output();
1035         if (msg != NULL) {
1036                 CtdlFreeMessage(msg);
1037         }
1038 }
1039
1040
1041
1042 /*
1043  * imap_fetch() calls imap_do_fetch() to do its actual work, once it's
1044  * validated and boiled down the request a bit.
1045  */
1046 void imap_do_fetch(int num_items, char **itemlist) {
1047         int i;
1048
1049         if (IMAP->num_msgs > 0) {
1050                 for (i = 0; i < IMAP->num_msgs; ++i) {
1051
1052                         /* Abort the fetch loop if the session breaks.
1053                          * This is important for users who keep mailboxes
1054                          * that are too big *and* are too impatient to
1055                          * let them finish loading.  :)
1056                          */
1057                         if (CC->kill_me) return;
1058
1059                         /* Get any message marked for fetch. */
1060                         if (IMAP->flags[i] & IMAP_SELECTED) {
1061                                 imap_do_fetch_msg(i+1, num_items, itemlist);
1062                         }
1063                 }
1064         }
1065 }
1066
1067
1068
1069 /*
1070  * Back end for imap_handle_macros()
1071  * Note that this function *only* looks at the beginning of the string.  It
1072  * is not a generic search-and-replace function.
1073  */
1074 void imap_macro_replace(char *str, char *find, char *replace) {
1075         char holdbuf[SIZ];
1076         int findlen;
1077
1078         findlen = strlen(find);
1079
1080         if (!strncasecmp(str, find, findlen)) {
1081                 if (str[findlen]==' ') {
1082                         strcpy(holdbuf, &str[findlen+1]);
1083                         strcpy(str, replace);
1084                         strcat(str, " ");
1085                         strcat(str, holdbuf);
1086                 }
1087                 if (str[findlen]==0) {
1088                         strcpy(holdbuf, &str[findlen+1]);
1089                         strcpy(str, replace);
1090                 }
1091         }
1092 }
1093
1094
1095
1096 /*
1097  * Handle macros embedded in FETCH data items.
1098  * (What the heck are macros doing in a wire protocol?  Are we trying to save
1099  * the computer at the other end the trouble of typing a lot of characters?)
1100  */
1101 void imap_handle_macros(char *str) {
1102         int i;
1103         int nest = 0;
1104
1105         for (i=0; str[i]; ++i) {
1106                 if (str[i]=='(') ++nest;
1107                 if (str[i]=='[') ++nest;
1108                 if (str[i]=='<') ++nest;
1109                 if (str[i]=='{') ++nest;
1110                 if (str[i]==')') --nest;
1111                 if (str[i]==']') --nest;
1112                 if (str[i]=='>') --nest;
1113                 if (str[i]=='}') --nest;
1114
1115                 if (nest <= 0) {
1116                         imap_macro_replace(&str[i],
1117                                 "ALL",
1118                                 "FLAGS INTERNALDATE RFC822.SIZE ENVELOPE"
1119                         );
1120                         imap_macro_replace(&str[i],
1121                                 "BODY",
1122                                 "BODYSTRUCTURE"
1123                         );
1124                         imap_macro_replace(&str[i],
1125                                 "FAST",
1126                                 "FLAGS INTERNALDATE RFC822.SIZE"
1127                         );
1128                         imap_macro_replace(&str[i],
1129                                 "FULL",
1130                                 "FLAGS INTERNALDATE RFC822.SIZE ENVELOPE BODY"
1131                         );
1132                 }
1133         }
1134 }
1135
1136
1137 /*
1138  * Break out the data items requested, possibly a parenthesized list.
1139  * Returns the number of data items, or -1 if the list is invalid.
1140  * NOTE: this function alters the string it is fed, and uses it as a buffer
1141  * to hold the data for the pointers it returns.
1142  */
1143 int imap_extract_data_items(char **argv, char *items) {
1144         int num_items = 0;
1145         int nest = 0;
1146         int i;
1147         char *start;
1148         long initial_len;
1149
1150         /* Convert all whitespace to ordinary space characters. */
1151         for (i=0; items[i]; ++i) {
1152                 if (isspace(items[i])) items[i]=' ';
1153         }
1154
1155         /* Strip leading and trailing whitespace, then strip leading and
1156          * trailing parentheses if it's a list
1157          */
1158         striplt(items);
1159         if ( (items[0]=='(') && (items[strlen(items)-1]==')') ) {
1160                 items[strlen(items)-1] = 0;
1161                 strcpy(items, &items[1]);
1162                 striplt(items);
1163         }
1164
1165         /* Parse any macro data items */
1166         imap_handle_macros(items);
1167
1168         /*
1169          * Now break out the data items.  We throw in one trailing space in
1170          * order to avoid having to break out the last one manually.
1171          */
1172         strcat(items, " ");
1173         start = items;
1174         initial_len = strlen(items);
1175         for (i=0; i<initial_len; ++i) {
1176                 if (items[i]=='(') ++nest;
1177                 if (items[i]=='[') ++nest;
1178                 if (items[i]=='<') ++nest;
1179                 if (items[i]=='{') ++nest;
1180                 if (items[i]==')') --nest;
1181                 if (items[i]==']') --nest;
1182                 if (items[i]=='>') --nest;
1183                 if (items[i]=='}') --nest;
1184
1185                 if (nest <= 0) if (items[i]==' ') {
1186                         items[i] = 0;
1187                         argv[num_items++] = start;
1188                         start = &items[i+1];
1189                 }
1190         }
1191
1192         return(num_items);
1193
1194 }
1195
1196
1197 /*
1198  * One particularly hideous aspect of IMAP is that we have to allow the client
1199  * to specify arbitrary ranges and/or sets of messages to fetch.  Citadel IMAP
1200  * handles this by setting the IMAP_SELECTED flag for each message specified in
1201  * the ranges/sets, then looping through the message array, outputting messages
1202  * with the flag set.  We don't bother returning an error if an out-of-range
1203  * number is specified (we just return quietly) because any client braindead
1204  * enough to request a bogus message number isn't going to notice the
1205  * difference anyway.
1206  *
1207  * This function clears out the IMAP_SELECTED bits, then sets that bit for each
1208  * message included in the specified range.
1209  *
1210  * Set is_uid to 1 to fetch by UID instead of sequence number.
1211  */
1212 void imap_pick_range(char *supplied_range, int is_uid) {
1213         int i;
1214         int num_sets;
1215         int s;
1216         char setstr[SIZ], lostr[SIZ], histr[SIZ];
1217         long lo, hi;
1218         char actual_range[SIZ];
1219         struct citimap *Imap;
1220
1221         /*
1222          * Handle the "ALL" macro
1223          */
1224         if (!strcasecmp(supplied_range, "ALL")) {
1225                 safestrncpy(actual_range, "1:*", sizeof actual_range);
1226         }
1227         else {
1228                 safestrncpy(actual_range, supplied_range, sizeof actual_range);
1229         }
1230
1231         Imap = IMAP;
1232         /*
1233          * Clear out the IMAP_SELECTED flags for all messages.
1234          */
1235         for (i = 0; i < Imap->num_msgs; ++i) {
1236                 Imap->flags[i] = Imap->flags[i] & ~IMAP_SELECTED;
1237         }
1238
1239         /*
1240          * Now set it for all specified messages.
1241          */
1242         num_sets = num_tokens(actual_range, ',');
1243         for (s=0; s<num_sets; ++s) {
1244                 extract_token(setstr, actual_range, s, ',', sizeof setstr);
1245
1246                 extract_token(lostr, setstr, 0, ':', sizeof lostr);
1247                 if (num_tokens(setstr, ':') >= 2) {
1248                         extract_token(histr, setstr, 1, ':', sizeof histr);
1249                         if (!strcmp(histr, "*")) snprintf(histr, sizeof histr, "%ld", LONG_MAX);
1250                 }
1251                 else {
1252                         safestrncpy(histr, lostr, sizeof histr);
1253                 }
1254                 lo = atol(lostr);
1255                 hi = atol(histr);
1256
1257                 /* Loop through the array, flipping bits where appropriate */
1258                 for (i = 1; i <= Imap->num_msgs; ++i) {
1259                         if (is_uid) {   /* fetch by sequence number */
1260                                 if ( (Imap->msgids[i-1]>=lo)
1261                                    && (Imap->msgids[i-1]<=hi)) {
1262                                         Imap->flags[i-1] |= IMAP_SELECTED;
1263                                 }
1264                         }
1265                         else {          /* fetch by uid */
1266                                 if ( (i>=lo) && (i<=hi)) {
1267                                         Imap->flags[i-1] |= IMAP_SELECTED;
1268                                 }
1269                         }
1270                 }
1271         }
1272
1273 }
1274
1275
1276
1277 /*
1278  * This function is called by the main command loop.
1279  */
1280 void imap_fetch(int num_parms, char *parms[]) {
1281         char items[SIZ];
1282         char *itemlist[512];
1283         int num_items;
1284         int i;
1285
1286         if (num_parms < 4) {
1287                 cprintf("%s BAD invalid parameters\r\n", parms[0]);
1288                 return;
1289         }
1290
1291         imap_pick_range(parms[2], 0);
1292
1293         strcpy(items, "");
1294         for (i=3; i<num_parms; ++i) {
1295                 strcat(items, parms[i]);
1296                 if (i < (num_parms-1)) strcat(items, " ");
1297         }
1298
1299         num_items = imap_extract_data_items(itemlist, items);
1300         if (num_items < 1) {
1301                 cprintf("%s BAD invalid data item list\r\n", parms[0]);
1302                 return;
1303         }
1304
1305         imap_do_fetch(num_items, itemlist);
1306         cprintf("%s OK FETCH completed\r\n", parms[0]);
1307 }
1308
1309 /*
1310  * This function is called by the main command loop.
1311  */
1312 void imap_uidfetch(int num_parms, char *parms[]) {
1313         char items[SIZ];
1314         char *itemlist[512];
1315         int num_items;
1316         int i;
1317         int have_uid_item = 0;
1318
1319         if (num_parms < 5) {
1320                 cprintf("%s BAD invalid parameters\r\n", parms[0]);
1321                 return;
1322         }
1323
1324         imap_pick_range(parms[3], 1);
1325
1326         strcpy(items, "");
1327         for (i=4; i<num_parms; ++i) {
1328                 strcat(items, parms[i]);
1329                 if (i < (num_parms-1)) strcat(items, " ");
1330         }
1331
1332         num_items = imap_extract_data_items(itemlist, items);
1333         if (num_items < 1) {
1334                 cprintf("%s BAD invalid data item list\r\n", parms[0]);
1335                 return;
1336         }
1337
1338         /* If the "UID" item was not included, we include it implicitly
1339          * (at the beginning) because this is a UID FETCH command
1340          */
1341         for (i=0; i<num_items; ++i) {
1342                 if (!strcasecmp(itemlist[i], "UID")) ++have_uid_item;
1343         }
1344         if (have_uid_item == 0) {
1345                 memmove(&itemlist[1], &itemlist[0], (sizeof(itemlist[0]) * num_items));
1346                 ++num_items;
1347                 itemlist[0] = "UID";
1348         }
1349
1350         imap_do_fetch(num_items, itemlist);
1351         cprintf("%s OK UID FETCH completed\r\n", parms[0]);
1352 }
1353
1354