citadel/modules/imap/imap_fetch.c

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