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