parse.c

   1 /*
   2  * Copyright (C) 1996-2000 Michael R. Elkins <me@mutt.org>
   3  *
   4  *     This program is free software; you can redistribute it and/or modify
   5  *     it under the terms of the GNU General Public License as published by
   6  *     the Free Software Foundation; either version 2 of the License, or
   7  *     (at your option) any later version.
   8  *
   9  *     This program is distributed in the hope that it will be useful,
  10  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *     GNU General Public License for more details.
  13  *
  14  *     You should have received a copy of the GNU General Public License
  15  *     along with this program; if not, write to the Free Software
  16  *     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  17  */
  18
  19 #if HAVE_CONFIG_H
  20 # include "config.h"
  21 #endif
  22
  23 #include "mutt.h"
  24 #include "mutt_regex.h"
  25 #include "mailbox.h"
  26 #include "mime.h"
  27 #include "rfc2047.h"
  28 #include "rfc2231.h"
  29 #include "mutt_crypt.h"
  30 #include "url.h"
  31
  32 #include <string.h>
  33 #include <ctype.h>
  34 #include <sys/stat.h>
  35 #include <stdlib.h>
  36
  37 /* Reads an arbitrarily long header field, and looks ahead for continuation
  38  * lines.  ``line'' must point to a dynamically allocated string; it is
  39  * increased if more space is required to fit the whole line.
  40  */
  41 static char *read_rfc822_line (FILE *f, char *line, size_t *linelen)
  42 {
  43   char *buf = line;
  44   char ch;
  45   size_t offset = 0;
  46
  47   FOREVER
  48   {
  49     if (fgets (buf, *linelen - offset, f) == NULL ||    /* end of file or */
  50         (ISSPACE (*line) && !offset))                   /* end of headers */
  51     {
  52       *line = 0;
  53       return (line);
  54     }
  55
  56     buf += strlen (buf) - 1;
  57     if (*buf == '\n')
  58     {
  59       /* we did get a full line. remove trailing space */
  60       while (ISSPACE (*buf))
  61         *buf-- = 0;     /* we cannot come beyond line's beginning because
  62                          * it begins with a non-space */
  63
  64       /* check to see if the next line is a continuation line */
  65       if ((ch = fgetc (f)) != ' ' && ch != '\t')
  66       {
  67         ungetc (ch, f);
  68         return (line); /* next line is a separate header field or EOH */
  69       }
  70
  71       /* eat tabs and spaces from the beginning of the continuation line */
  72       while ((ch = fgetc (f)) == ' ' || ch == '\t')
  73         ;
  74       ungetc (ch, f);
  75       *++buf = ' '; /* string is still terminated because we removed
  76                        at least one whitespace char above */
  77     }
  78
  79     buf++;
  80     offset = buf - line;
  81     if (*linelen < offset + STRING)
  82     {
  83       /* grow the buffer */
  84       *linelen += STRING;
  85       safe_realloc (&line, *linelen);
  86       buf = line + offset;
  87     }
  88   }
  89   /* not reached */
  90 }
  91
  92 LIST *mutt_parse_references (char *s, int in_reply_to)
  93 {
  94   LIST *t, *lst = NULL;
  95   int m, n = 0;
  96   char *o = NULL, *new, *at;
  97
  98   while ((s = strtok (s, " \t;")) != NULL)
  99   {
 100     /*
 101      * some mail clients add other garbage besides message-ids, so do a quick
 102      * check to make sure this looks like a valid message-id
 103      * some idiotic clients also break their message-ids between lines, deal
 104      * with that too (give up if it's more than two lines, though)
 105      */
 106     t = NULL;
 107     new = NULL;
 108
 109     if (*s == '<')
 110     {
 111       n = strlen (s);
 112       if (s[n-1] != '>')
 113       {
 114         o = s;
 115         s = NULL;
 116         continue;
 117       }
 118
 119       new = safe_strdup (s);
 120     }
 121     else if (o)
 122     {
 123       m = strlen (s);
 124       if (s[m - 1] == '>')
 125       {
 126         new = safe_malloc (sizeof (char) * (n + m + 1));
 127         strcpy (new, o);        /* __STRCPY_CHECKED__ */
 128         strcpy (new + n, s);    /* __STRCPY_CHECKED__ */
 129       }
 130     }
 131     if (new)
 132     {
 133       /* make sure that this really does look like a message-id.
 134        * it should have exactly one @, and if we're looking at
 135        * an in-reply-to header, make sure that the part before
 136        * the @ has more than eight characters or it's probably
 137        * an email address
 138        */
 139       if (!(at = strchr (new, '@')) || strchr (at + 1, '@')
 140           || (in_reply_to && at - new <= 8))
 141         FREE (&new);
 142       else
 143       {
 144         t = (LIST *) safe_malloc (sizeof (LIST));
 145         t->data = new;
 146         t->next = lst;
 147         lst = t;
 148       }
 149     }
 150     o = NULL;
 151     s = NULL;
 152   }
 153
 154   return (lst);
 155 }
 156
 157 int mutt_check_encoding (const char *c)
 158 {
 159   if (ascii_strncasecmp ("7bit", c, sizeof ("7bit")-1) == 0)
 160     return (ENC7BIT);
 161   else if (ascii_strncasecmp ("8bit", c, sizeof ("8bit")-1) == 0)
 162     return (ENC8BIT);
 163   else if (ascii_strncasecmp ("binary", c, sizeof ("binary")-1) == 0)
 164     return (ENCBINARY);
 165   else if (ascii_strncasecmp ("quoted-printable", c, sizeof ("quoted-printable")-1) == 0)
 166     return (ENCQUOTEDPRINTABLE);
 167   else if (ascii_strncasecmp ("base64", c, sizeof("base64")-1) == 0)
 168     return (ENCBASE64);
 169   else if (ascii_strncasecmp ("x-uuencode", c, sizeof("x-uuencode")-1) == 0)
 170     return (ENCUUENCODED);
 171 #ifdef SUN_ATTACHMENT
 172   else if (ascii_strncasecmp ("uuencode", c, sizeof("uuencode")-1) == 0)
 173     return (ENCUUENCODED);
 174 #endif
 175   else
 176     return (ENCOTHER);
 177 }
 178
 179 static PARAMETER *parse_parameters (const char *s)
 180 {
 181   PARAMETER *head = 0, *cur = 0, *new;
 182   char buffer[LONG_STRING];
 183   const char *p;
 184   size_t i;
 185
 186   dprint (2, (debugfile, "parse_parameters: `%s'\n", s));
 187
 188   while (*s)
 189   {
 190     if ((p = strpbrk (s, "=;")) == NULL)
 191     {
 192       dprint(1, (debugfile, "parse_parameters: malformed parameter: %s\n", s));
 193       goto bail;
 194     }
 195
 196     /* if we hit a ; now the parameter has no value, just skip it */
 197     if (*p != ';')
 198     {
 199       i = p - s;
 200
 201       new = mutt_new_parameter ();
 202
 203       new->attribute = safe_malloc (i + 1);
 204       memcpy (new->attribute, s, i);
 205       new->attribute[i] = 0;
 206
 207       /* remove whitespace from the end of the attribute name */
 208       while (ISSPACE (new->attribute[--i]))
 209         new->attribute[i] = 0;
 210
 211       s = p + 1; /* skip over the = */
 212       SKIPWS (s);
 213
 214       if (*s == '"')
 215       {
 216         int state_ascii = 1;
 217         s++;
 218         for (i=0; *s && i < sizeof (buffer) - 1; i++, s++)
 219         {
 220           if (!option (OPTSTRICTMIME)) {
 221             /* As iso-2022-* has a characer of '"' with non-ascii state,
 222              * ignore it. */
 223             if (*s == 0x1b && i < sizeof (buffer) - 2)
 224             {
 225               if (s[1] == '(' && (s[2] == 'B' || s[2] == 'J'))
 226                 state_ascii = 1;
 227               else
 228                 state_ascii = 0;
 229             }
 230           }
 231           if (state_ascii && *s == '"')
 232             break;
 233           if (*s == '\\')
 234           {
 235             /* Quote the next character */
 236             buffer[i] = s[1];
 237             if (!*++s)
 238               break;
 239           }
 240           else
 241             buffer[i] = *s;
 242         }
 243         buffer[i] = 0;
 244         if (*s)
 245           s++; /* skip over the " */
 246       }
 247       else
 248       {
 249         for (i=0; *s && *s != ' ' && *s != ';' && i < sizeof (buffer) - 1; i++, s++)
 250           buffer[i] = *s;
 251         buffer[i] = 0;
 252       }
 253
 254       new->value = safe_strdup (buffer);
 255
 256       dprint (2, (debugfile, "parse_parameter: `%s' = `%s'\n",
 257                   new->attribute ? new->attribute : "",
 258                   new->value ? new->value : ""));
 259
 260       /* Add this parameter to the list */
 261       if (head)
 262       {
 263         cur->next = new;
 264         cur = cur->next;
 265       }
 266       else
 267         head = cur = new;
 268     }
 269     else
 270     {
 271       dprint (1, (debugfile, "parse_parameters(): parameter with no value: %s\n", s));
 272       s = p;
 273     }
 274
 275     /* Find the next parameter */
 276     if (*s != ';' && (s = strchr (s, ';')) == NULL)
 277         break; /* no more parameters */
 278
 279     do
 280     {
 281       s++;
 282
 283       /* Move past any leading whitespace */
 284       SKIPWS (s);
 285     }
 286     while (*s == ';'); /* skip empty parameters */
 287   }
 288
 289   bail:
 290
 291   rfc2231_decode_parameters (&head);
 292   return (head);
 293 }
 294
 295 int mutt_check_mime_type (const char *s)
 296 {
 297   if (ascii_strcasecmp ("text", s) == 0)
 298     return TYPETEXT;
 299   else if (ascii_strcasecmp ("multipart", s) == 0)
 300     return TYPEMULTIPART;
 301 #ifdef SUN_ATTACHMENT
 302   else if (ascii_strcasecmp ("x-sun-attachment", s) == 0)
 303     return TYPEMULTIPART;
 304 #endif
 305   else if (ascii_strcasecmp ("application", s) == 0)
 306     return TYPEAPPLICATION;
 307   else if (ascii_strcasecmp ("message", s) == 0)
 308     return TYPEMESSAGE;
 309   else if (ascii_strcasecmp ("image", s) == 0)
 310     return TYPEIMAGE;
 311   else if (ascii_strcasecmp ("audio", s) == 0)
 312     return TYPEAUDIO;
 313   else if (ascii_strcasecmp ("video", s) == 0)
 314     return TYPEVIDEO;
 315   else if (ascii_strcasecmp ("model", s) == 0)
 316     return TYPEMODEL;
 317   else
 318     return TYPEOTHER;
 319 }
 320
 321 void mutt_parse_content_type (char *s, BODY *ct)
 322 {
 323   char *pc;
 324   char *subtype;
 325
 326   FREE (&ct->subtype);
 327   mutt_free_parameter(&ct->parameter);
 328
 329   /* First extract any existing parameters */
 330   if ((pc = strchr(s, ';')) != NULL)
 331   {
 332     *pc++ = 0;
 333     while (*pc && ISSPACE (*pc))
 334       pc++;
 335     ct->parameter = parse_parameters(pc);
 336
 337     /* Some pre-RFC1521 gateways still use the "name=filename" convention,
 338      * but if a filename has already been set in the content-disposition,
 339      * let that take precedence, and don't set it here */
 340     if ((pc = mutt_get_parameter( "name", ct->parameter)) != 0 && !ct->filename)
 341       ct->filename = safe_strdup(pc);
 342
 343 #ifdef SUN_ATTACHMENT
 344     /* this is deep and utter perversion */
 345     if ((pc = mutt_get_parameter ("conversions", ct->parameter)) != 0)
 346       ct->encoding = mutt_check_encoding (pc);
 347 #endif
 348
 349   }
 350
 351   /* Now get the subtype */
 352   if ((subtype = strchr(s, '/')))
 353   {
 354     *subtype++ = '\0';
 355     for(pc = subtype; *pc && !ISSPACE(*pc) && *pc != ';'; pc++)
 356       ;
 357     *pc = '\0';
 358     ct->subtype = safe_strdup (subtype);
 359   }
 360
 361   /* Finally, get the major type */
 362   ct->type = mutt_check_mime_type (s);
 363
 364 #ifdef SUN_ATTACHMENT
 365   if (ascii_strcasecmp ("x-sun-attachment", s) == 0)
 366       ct->subtype = safe_strdup ("x-sun-attachment");
 367 #endif
 368
 369   if (ct->type == TYPEOTHER)
 370   {
 371     ct->xtype = safe_strdup (s);
 372   }
 373
 374   if (ct->subtype == NULL)
 375   {
 376     /* Some older non-MIME mailers (i.e., mailtool, elm) have a content-type
 377      * field, so we can attempt to convert the type to BODY here.
 378      */
 379     if (ct->type == TYPETEXT)
 380       ct->subtype = safe_strdup ("plain");
 381     else if (ct->type == TYPEAUDIO)
 382       ct->subtype = safe_strdup ("basic");
 383     else if (ct->type == TYPEMESSAGE)
 384       ct->subtype = safe_strdup ("rfc822");
 385     else if (ct->type == TYPEOTHER)
 386     {
 387       char buffer[SHORT_STRING];
 388
 389       ct->type = TYPEAPPLICATION;
 390       snprintf (buffer, sizeof (buffer), "x-%s", s);
 391       ct->subtype = safe_strdup (buffer);
 392     }
 393     else
 394       ct->subtype = safe_strdup ("x-unknown");
 395   }
 396
 397   /* Default character set for text types. */
 398   if (ct->type == TYPETEXT)
 399   {
 400     if (!(pc = mutt_get_parameter ("charset", ct->parameter)))
 401       mutt_set_parameter ("charset", option (OPTSTRICTMIME) ? "us-ascii" :
 402                          (const char *) mutt_get_first_charset (AssumedCharset),
 403                          &ct->parameter);
 404   }
 405
 406 }
 407
 408 static void parse_content_disposition (char *s, BODY *ct)
 409 {
 410   PARAMETER *parms;
 411
 412   if (!ascii_strncasecmp ("inline", s, 6))
 413     ct->disposition = DISPINLINE;
 414   else if (!ascii_strncasecmp ("form-data", s, 9))
 415     ct->disposition = DISPFORMDATA;
 416   else
 417     ct->disposition = DISPATTACH;
 418
 419   /* Check to see if a default filename was given */
 420   if ((s = strchr (s, ';')) != NULL)
 421   {
 422     s++;
 423     SKIPWS (s);
 424     if ((s = mutt_get_parameter ("filename", (parms = parse_parameters (s)))) != 0)
 425       mutt_str_replace (&ct->filename, s);
 426     if ((s = mutt_get_parameter ("name", parms)) != 0)
 427       ct->form_name = safe_strdup (s);
 428     mutt_free_parameter (&parms);
 429   }
 430 }
 431
 432 /* args:
 433  *      fp      stream to read from
 434  *
 435  *      digest  1 if reading subparts of a multipart/digest, 0
 436  *              otherwise
 437  */
 438
 439 BODY *mutt_read_mime_header (FILE *fp, int digest)
 440 {
 441   BODY *p = mutt_new_body();
 442   char *c;
 443   char *line = safe_malloc (LONG_STRING);
 444   size_t linelen = LONG_STRING;
 445
 446   p->hdr_offset  = ftell(fp);
 447
 448   p->encoding    = ENC7BIT; /* default from RFC1521 */
 449   p->type        = digest ? TYPEMESSAGE : TYPETEXT;
 450   p->disposition = DISPINLINE;
 451
 452   while (*(line = read_rfc822_line (fp, line, &linelen)) != 0)
 453   {
 454     /* Find the value of the current header */
 455     if ((c = strchr (line, ':')))
 456     {
 457       *c = 0;
 458       c++;
 459       SKIPWS (c);
 460       if (!*c)
 461       {
 462         dprint (1, (debugfile, "mutt_read_mime_header(): skipping empty header field: %s\n", line));
 463         continue;
 464       }
 465     }
 466     else
 467     {
 468       dprint (1, (debugfile, "read_mime_header: bogus MIME header: %s\n", line));
 469       break;
 470     }
 471
 472     if (!ascii_strncasecmp ("content-", line, 8))
 473     {
 474       if (!ascii_strcasecmp ("type", line + 8))
 475         mutt_parse_content_type (c, p);
 476       else if (!ascii_strcasecmp ("transfer-encoding", line + 8))
 477         p->encoding = mutt_check_encoding (c);
 478       else if (!ascii_strcasecmp ("disposition", line + 8))
 479         parse_content_disposition (c, p);
 480       else if (!ascii_strcasecmp ("description", line + 8))
 481       {
 482         mutt_str_replace (&p->description, c);
 483         rfc2047_decode (&p->description);
 484       }
 485     }
 486 #ifdef SUN_ATTACHMENT
 487     else if (!ascii_strncasecmp ("x-sun-", line, 6))
 488     {
 489       if (!ascii_strcasecmp ("data-type", line + 6))
 490         mutt_parse_content_type (c, p);
 491       else if (!ascii_strcasecmp ("encoding-info", line + 6))
 492         p->encoding = mutt_check_encoding (c);
 493       else if (!ascii_strcasecmp ("content-lines", line + 6))
 494         mutt_set_parameter ("content-lines", c, &(p->parameter));
 495       else if (!ascii_strcasecmp ("data-description", line + 6))
 496       {
 497         mutt_str_replace (&p->description, c);
 498         rfc2047_decode (&p->description);
 499       }
 500     }
 501 #endif
 502   }
 503   p->offset = ftell (fp); /* Mark the start of the real data */
 504   if (p->type == TYPETEXT && !p->subtype)
 505     p->subtype = safe_strdup ("plain");
 506   else if (p->type == TYPEMESSAGE && !p->subtype)
 507     p->subtype = safe_strdup ("rfc822");
 508
 509   FREE (&line);
 510
 511   return (p);
 512 }
 513
 514 void mutt_parse_part (FILE *fp, BODY *b)
 515 {
 516   char *bound = 0;
 517
 518   switch (b->type)
 519   {
 520     case TYPEMULTIPART:
 521 #ifdef SUN_ATTACHMENT
 522       if ( !ascii_strcasecmp (b->subtype, "x-sun-attachment") )
 523           bound = "--------";
 524       else
 525 #endif
 526           bound = mutt_get_parameter ("boundary", b->parameter);
 527
 528       fseek (fp, b->offset, SEEK_SET);
 529       b->parts =  mutt_parse_multipart (fp, bound,
 530                                         b->offset + b->length,
 531                                         ascii_strcasecmp ("digest", b->subtype) == 0);
 532       break;
 533
 534     case TYPEMESSAGE:
 535       if (b->subtype)
 536       {
 537         fseek (fp, b->offset, SEEK_SET);
 538         if (mutt_is_message_type(b->type, b->subtype))
 539           b->parts = mutt_parse_messageRFC822 (fp, b);
 540         else if (ascii_strcasecmp (b->subtype, "external-body") == 0)
 541           b->parts = mutt_read_mime_header (fp, 0);
 542         else
 543           return;
 544       }
 545       break;
 546
 547     default:
 548       return;
 549   }
 550
 551   /* try to recover from parsing error */
 552   if (!b->parts)
 553   {
 554     b->type = TYPETEXT;
 555     mutt_str_replace (&b->subtype, "plain");
 556   }
 557 }
 558
 559 /* parse a MESSAGE/RFC822 body
 560  *
 561  * args:
 562  *      fp              stream to read from
 563  *
 564  *      parent          structure which contains info about the message/rfc822
 565  *                      body part
 566  *
 567  * NOTE: this assumes that `parent->length' has been set!
 568  */
 569
 570 BODY *mutt_parse_messageRFC822 (FILE *fp, BODY *parent)
 571 {
 572   BODY *msg;
 573
 574   parent->hdr = mutt_new_header ();
 575   parent->hdr->offset = ftell (fp);
 576   parent->hdr->env = mutt_read_rfc822_header (fp, parent->hdr, 0, 0);
 577   msg = parent->hdr->content;
 578
 579   /* ignore the length given in the content-length since it could be wrong
 580      and we already have the info to calculate the correct length */
 581   /* if (msg->length == -1) */
 582   msg->length = parent->length - (msg->offset - parent->offset);
 583
 584   /* if body of this message is empty, we can end up with a negative length */
 585   if (msg->length < 0)
 586     msg->length = 0;
 587
 588   mutt_parse_part(fp, msg);
 589   return (msg);
 590 }
 591
 592 /* parse a multipart structure
 593  *
 594  * args:
 595  *      fp              stream to read from
 596  *
 597  *      boundary        body separator
 598  *
 599  *      end_off         length of the multipart body (used when the final
 600  *                      boundary is missing to avoid reading too far)
 601  *
 602  *      digest          1 if reading a multipart/digest, 0 otherwise
 603  */
 604
 605 BODY *mutt_parse_multipart (FILE *fp, const char *boundary, long end_off, int digest)
 606 {
 607 #ifdef SUN_ATTACHMENT
 608   int lines;
 609 #endif
 610   int blen, len, crlf = 0;
 611   char buffer[LONG_STRING];
 612   BODY *head = 0, *last = 0, *new = 0;
 613   int i;
 614   int final = 0; /* did we see the ending boundary? */
 615
 616   if (!boundary)
 617   {
 618     mutt_error _("multipart message has no boundary parameter!");
 619     return (NULL);
 620   }
 621
 622   blen = mutt_strlen (boundary);
 623   while (ftell (fp) < end_off && fgets (buffer, LONG_STRING, fp) != NULL)
 624   {
 625     len = mutt_strlen (buffer);
 626
 627     crlf =  (len > 1 && buffer[len - 2] == '\r') ? 1 : 0;
 628
 629     if (buffer[0] == '-' && buffer[1] == '-' &&
 630         mutt_strncmp (buffer + 2, boundary, blen) == 0)
 631     {
 632       if (last)
 633       {
 634         last->length = ftell (fp) - last->offset - len - 1 - crlf;
 635         if (last->parts && last->parts->length == 0)
 636           last->parts->length = ftell (fp) - last->parts->offset - len - 1 - crlf;
 637         /* if the body is empty, we can end up with a -1 length */
 638         if (last->length < 0)
 639           last->length = 0;
 640       }
 641
 642       /* Remove any trailing whitespace, up to the length of the boundary */
 643       for (i = len - 1; ISSPACE (buffer[i]) && i >= blen + 2; i--)
 644         buffer[i] = 0;
 645
 646       /* Check for the end boundary */
 647       if (mutt_strcmp (buffer + blen + 2, "--") == 0)
 648       {
 649         final = 1;
 650         break; /* done parsing */
 651       }
 652       else if (buffer[2 + blen] == 0)
 653       {
 654         new = mutt_read_mime_header (fp, digest);
 655
 656 #ifdef SUN_ATTACHMENT
 657         if (mutt_get_parameter ("content-lines", new->parameter)) {
 658           for (lines = atoi(mutt_get_parameter ("content-lines", new->parameter));
 659                lines; lines-- )
 660              if (ftell (fp) >= end_off || fgets (buffer, LONG_STRING, fp) == NULL)
 661                break;
 662         }
 663 #endif
 664
 665         /*
 666          * Consistency checking - catch
 667          * bad attachment end boundaries
 668          */
 669
 670         if(new->offset > end_off)
 671         {
 672           mutt_free_body(&new);
 673           break;
 674         }
 675         if (head)
 676         {
 677           last->next = new;
 678           last = new;
 679         }
 680         else
 681           last = head = new;
 682       }
 683     }
 684   }
 685
 686   /* in case of missing end boundary, set the length to something reasonable */
 687   if (last && last->length == 0 && !final)
 688     last->length = end_off - last->offset;
 689
 690   /* parse recursive MIME parts */
 691   for(last = head; last; last = last->next)
 692     mutt_parse_part(fp, last);
 693
 694   return (head);
 695 }
 696
 697 static const char *uncomment_timezone (char *buf, size_t buflen, const char *tz)
 698 {
 699   char *p;
 700   size_t len;
 701
 702   if (*tz != '(')
 703     return tz; /* no need to do anything */
 704   tz++;
 705   SKIPWS (tz);
 706   if ((p = strpbrk (tz, " )")) == NULL)
 707     return tz;
 708   len = p - tz;
 709   if (len > buflen - 1)
 710     len = buflen - 1;
 711   memcpy (buf, tz, len);
 712   buf[len] = 0;
 713   return buf;
 714 }
 715
 716 static struct tz_t
 717 {
 718   char tzname[5];
 719   unsigned char zhours;
 720   unsigned char zminutes;
 721   unsigned char zoccident; /* west of UTC? */
 722 }
 723 TimeZones[] =
 724 {
 725   { "aat",   1,  0, 1 }, /* Atlantic Africa Time */
 726   { "adt",   4,  0, 0 }, /* Arabia DST */
 727   { "ast",   3,  0, 0 }, /* Arabia */
 728 /*{ "ast",   4,  0, 1 },*/ /* Atlantic */
 729   { "bst",   1,  0, 0 }, /* British DST */
 730   { "cat",   1,  0, 0 }, /* Central Africa */
 731   { "cdt",   5,  0, 1 },
 732   { "cest",  2,  0, 0 }, /* Central Europe DST */
 733   { "cet",   1,  0, 0 }, /* Central Europe */
 734   { "cst",   6,  0, 1 },
 735 /*{ "cst",   8,  0, 0 },*/ /* China */
 736 /*{ "cst",   9, 30, 0 },*/ /* Australian Central Standard Time */
 737   { "eat",   3,  0, 0 }, /* East Africa */
 738   { "edt",   4,  0, 1 },
 739   { "eest",  3,  0, 0 }, /* Eastern Europe DST */
 740   { "eet",   2,  0, 0 }, /* Eastern Europe */
 741   { "egst",  0,  0, 0 }, /* Eastern Greenland DST */
 742   { "egt",   1,  0, 1 }, /* Eastern Greenland */
 743   { "est",   5,  0, 1 },
 744   { "gmt",   0,  0, 0 },
 745   { "gst",   4,  0, 0 }, /* Presian Gulf */
 746   { "hkt",   8,  0, 0 }, /* Hong Kong */
 747   { "ict",   7,  0, 0 }, /* Indochina */
 748   { "idt",   3,  0, 0 }, /* Israel DST */
 749   { "ist",   2,  0, 0 }, /* Israel */
 750 /*{ "ist",   5, 30, 0 },*/ /* India */
 751   { "jst",   9,  0, 0 }, /* Japan */
 752   { "kst",   9,  0, 0 }, /* Korea */
 753   { "mdt",   6,  0, 1 },
 754   { "met",   1,  0, 0 }, /* this is now officially CET */
 755   { "msd",   4,  0, 0 }, /* Moscow DST */
 756   { "msk",   3,  0, 0 }, /* Moscow */
 757   { "mst",   7,  0, 1 },
 758   { "nzdt", 13,  0, 0 }, /* New Zealand DST */
 759   { "nzst", 12,  0, 0 }, /* New Zealand */
 760   { "pdt",   7,  0, 1 },
 761   { "pst",   8,  0, 1 },
 762   { "sat",   2,  0, 0 }, /* South Africa */
 763   { "smt",   4,  0, 0 }, /* Seychelles */
 764   { "sst",  11,  0, 1 }, /* Samoa */
 765 /*{ "sst",   8,  0, 0 },*/ /* Singapore */
 766   { "utc",   0,  0, 0 },
 767   { "wat",   0,  0, 0 }, /* West Africa */
 768   { "west",  1,  0, 0 }, /* Western Europe DST */
 769   { "wet",   0,  0, 0 }, /* Western Europe */
 770   { "wgst",  2,  0, 1 }, /* Western Greenland DST */
 771   { "wgt",   3,  0, 1 }, /* Western Greenland */
 772   { "wst",   8,  0, 0 }, /* Western Australia */
 773 };
 774
 775 /* parses a date string in RFC822 format:
 776  *
 777  * Date: [ weekday , ] day-of-month month year hour:minute:second timezone
 778  *
 779  * This routine assumes that `h' has been initialized to 0.  the `timezone'
 780  * field is optional, defaulting to +0000 if missing.
 781  */
 782 time_t mutt_parse_date (const char *s, HEADER *h)
 783 {
 784   int count = 0;
 785   char *t;
 786   int hour, min, sec;
 787   struct tm tm;
 788   int i;
 789   int tz_offset = 0;
 790   int zhours = 0;
 791   int zminutes = 0;
 792   int zoccident = 0;
 793   const char *ptz;
 794   char tzstr[SHORT_STRING];
 795   char scratch[SHORT_STRING];
 796
 797   /* Don't modify our argument. Fixed-size buffer is ok here since
 798    * the date format imposes a natural limit.
 799    */
 800
 801   strfcpy (scratch, s, sizeof (scratch));
 802
 803   /* kill the day of the week, if it exists. */
 804   if ((t = strchr (scratch, ',')))
 805     t++;
 806   else
 807     t = scratch;
 808   SKIPWS (t);
 809
 810   memset (&tm, 0, sizeof (tm));
 811
 812   while ((t = strtok (t, " \t")) != NULL)
 813   {
 814     switch (count)
 815     {
 816       case 0: /* day of the month */
 817         if (!isdigit ((unsigned char) *t))
 818           return (-1);
 819         tm.tm_mday = atoi (t);
 820         if (tm.tm_mday > 31)
 821           return (-1);
 822         break;
 823
 824       case 1: /* month of the year */
 825         if ((i = mutt_check_month (t)) < 0)
 826           return (-1);
 827         tm.tm_mon = i;
 828         break;
 829
 830       case 2: /* year */
 831         tm.tm_year = atoi (t);
 832         if (tm.tm_year < 50)
 833           tm.tm_year += 100;
 834         else if (tm.tm_year >= 1900)
 835           tm.tm_year -= 1900;
 836         break;
 837
 838       case 3: /* time of day */
 839         if (sscanf (t, "%d:%d:%d", &hour, &min, &sec) == 3)
 840           ;
 841         else if (sscanf (t, "%d:%d", &hour, &min) == 2)
 842           sec = 0;
 843         else
 844         {
 845           dprint(1, (debugfile, "parse_date: could not process time format: %s\n", t));
 846           return(-1);
 847         }
 848         tm.tm_hour = hour;
 849         tm.tm_min = min;
 850         tm.tm_sec = sec;
 851         break;
 852
 853       case 4: /* timezone */
 854         /* sometimes we see things like (MST) or (-0700) so attempt to
 855          * compensate by uncommenting the string if non-RFC822 compliant
 856          */
 857         ptz = uncomment_timezone (tzstr, sizeof (tzstr), t);
 858
 859         if (*ptz == '+' || *ptz == '-')
 860         {
 861           if (ptz[1] && ptz[2] && ptz[3] && ptz[4]
 862               && isdigit ((unsigned char) ptz[1]) && isdigit ((unsigned char) ptz[2])
 863               && isdigit ((unsigned char) ptz[3]) && isdigit ((unsigned char) ptz[4]))
 864           {
 865             zhours = (ptz[1] - '0') * 10 + (ptz[2] - '0');
 866             zminutes = (ptz[3] - '0') * 10 + (ptz[4] - '0');
 867
 868             if (ptz[0] == '-')
 869               zoccident = 1;
 870           }
 871         }
 872         else
 873         {
 874           struct tz_t *tz;
 875
 876           tz = bsearch (ptz, TimeZones, sizeof TimeZones/sizeof (struct tz_t),
 877                         sizeof (struct tz_t),
 878                         (int (*)(const void *, const void *)) ascii_strcasecmp
 879                         /* This is safe to do: A pointer to a struct equals
 880                          * a pointer to its first element*/);
 881
 882           if (tz)
 883           {
 884             zhours = tz->zhours;
 885             zminutes = tz->zminutes;
 886             zoccident = tz->zoccident;
 887           }
 888
 889           /* ad hoc support for the European MET (now officially CET) TZ */
 890           if (ascii_strcasecmp (t, "MET") == 0)
 891           {
 892             if ((t = strtok (NULL, " \t")) != NULL)
 893             {
 894               if (!ascii_strcasecmp (t, "DST"))
 895                 zhours++;
 896             }
 897           }
 898         }
 899         tz_offset = zhours * 3600 + zminutes * 60;
 900         if (!zoccident)
 901           tz_offset = -tz_offset;
 902         break;
 903     }
 904     count++;
 905     t = 0;
 906   }
 907
 908   if (count < 4) /* don't check for missing timezone */
 909   {
 910     dprint(1,(debugfile, "parse_date(): error parsing date format, using received time\n"));
 911     return (-1);
 912   }
 913
 914   if (h)
 915   {
 916     h->zhours = zhours;
 917     h->zminutes = zminutes;
 918     h->zoccident = zoccident;
 919   }
 920
 921   return (mutt_mktime (&tm, 0) + tz_offset);
 922 }
 923
 924 /* extract the first substring that looks like a message-id */
 925 static char *extract_message_id (const char *s)
 926 {
 927   const char *p;
 928   char *r;
 929   size_t l;
 930
 931   if ((s = strchr (s, '<')) == NULL || (p = strchr (s, '>')) == NULL)
 932     return (NULL);
 933   l = (size_t)(p - s) + 1;
 934   r = safe_malloc (l + 1);
 935   memcpy (r, s, l);
 936   r[l] = 0;
 937   return (r);
 938 }
 939
 940 void mutt_parse_mime_message (CONTEXT *ctx, HEADER *cur)
 941 {
 942   MESSAGE *msg;
 943
 944   if (cur->content->type != TYPEMESSAGE && cur->content->type != TYPEMULTIPART)
 945     return; /* nothing to do */
 946
 947   if (cur->content->parts)
 948     return; /* The message was parsed earlier. */
 949
 950   if ((msg = mx_open_message (ctx, cur->msgno)))
 951   {
 952     mutt_parse_part (msg->fp, cur->content);
 953
 954     if (WithCrypto)
 955       cur->security = crypt_query (cur->content);
 956
 957     mx_close_message (&msg);
 958   }
 959 }
 960
 961 int mutt_parse_rfc822_line (ENVELOPE *e, HEADER *hdr, char *line, char *p, short user_hdrs, short weed,
 962                             short do_2047, LIST **lastp)
 963 {
 964   int matched = 0;
 965   LIST *last = NULL;
 966
 967   if (lastp)
 968     last = *lastp;
 969
 970   switch (ascii_tolower (line[0]))
 971   {
 972     case 'a':
 973     if (ascii_strcasecmp (line+1, "pparently-to") == 0)
 974     {
 975       e->to = rfc822_parse_adrlist (e->to, p);
 976       matched = 1;
 977     }
 978     else if (ascii_strcasecmp (line+1, "pparently-from") == 0)
 979     {
 980       e->from = rfc822_parse_adrlist (e->from, p);
 981       matched = 1;
 982     }
 983     break;
 984
 985     case 'b':
 986     if (ascii_strcasecmp (line+1, "cc") == 0)
 987     {
 988       e->bcc = rfc822_parse_adrlist (e->bcc, p);
 989       matched = 1;
 990     }
 991     break;
 992
 993     case 'c':
 994     if (ascii_strcasecmp (line+1, "c") == 0)
 995     {
 996       e->cc = rfc822_parse_adrlist (e->cc, p);
 997       matched = 1;
 998     }
 999     else if (ascii_strncasecmp (line + 1, "ontent-", 7) == 0)
1000     {
1001       if (ascii_strcasecmp (line+8, "type") == 0)
1002       {
1003         if (hdr)
1004           mutt_parse_content_type (p, hdr->content);
1005         matched = 1;
1006       }
1007       else if (ascii_strcasecmp (line+8, "transfer-encoding") == 0)
1008       {
1009         if (hdr)
1010           hdr->content->encoding = mutt_check_encoding (p);
1011         matched = 1;
1012       }
1013       else if (ascii_strcasecmp (line+8, "length") == 0)
1014       {
1015         if (hdr)
1016         {
1017           if ((hdr->content->length = atoi (p)) < 0)
1018             hdr->content->length = -1;
1019         }
1020         matched = 1;
1021       }
1022       else if (ascii_strcasecmp (line+8, "description") == 0)
1023       {
1024         if (hdr)
1025         {
1026           mutt_str_replace (&hdr->content->description, p);
1027           rfc2047_decode (&hdr->content->description);
1028         }
1029         matched = 1;
1030       }
1031       else if (ascii_strcasecmp (line+8, "disposition") == 0)
1032       {
1033         if (hdr)
1034           parse_content_disposition (p, hdr->content);
1035         matched = 1;
1036       }
1037     }
1038     break;
1039
1040     case 'd':
1041     if (!ascii_strcasecmp ("ate", line + 1))
1042     {
1043       mutt_str_replace (&e->date, p);
1044       if (hdr)
1045         hdr->date_sent = mutt_parse_date (p, hdr);
1046       matched = 1;
1047     }
1048     break;
1049
1050     case 'e':
1051     if (!ascii_strcasecmp ("xpires", line + 1) &&
1052         hdr && mutt_parse_date (p, NULL) < time (NULL))
1053       hdr->expired = 1;
1054     break;
1055
1056     case 'f':
1057     if (!ascii_strcasecmp ("rom", line + 1))
1058     {
1059       e->from = rfc822_parse_adrlist (e->from, p);
1060       matched = 1;
1061     }
1062 #ifdef USE_NNTP
1063     else if (!mutt_strcasecmp (line+1, "ollowup-to"))
1064     {
1065       if (!e->followup_to)
1066       {
1067         mutt_remove_trailing_ws (p);
1068         e->followup_to = safe_strdup (mutt_skip_whitespace (p));
1069       }
1070       matched = 1;
1071     }
1072 #endif
1073     break;
1074
1075     case 'i':
1076     if (!ascii_strcasecmp (line+1, "n-reply-to"))
1077     {
1078       mutt_free_list (&e->in_reply_to);
1079       e->in_reply_to = mutt_parse_references (p, 1);
1080       matched = 1;
1081     }
1082     break;
1083
1084     case 'l':
1085     if (!ascii_strcasecmp (line + 1, "ines"))
1086     {
1087       if (hdr)
1088       {
1089         hdr->lines = atoi (p);
1090
1091         /*
1092          * HACK - mutt has, for a very short time, produced negative
1093          * Lines header values.  Ignore them.
1094          */
1095         if (hdr->lines < 0)
1096           hdr->lines = 0;
1097       }
1098
1099       matched = 1;
1100     }
1101     else if (!ascii_strcasecmp (line + 1, "ist-Post"))
1102     {
1103       /* RFC 2369.  FIXME: We should ignore whitespace, but don't. */
1104       if (strncmp (p, "NO", 2))
1105       {
1106         char *beg, *end;
1107         for (beg = strchr (p, '<'); beg; beg = strchr (end, ','))
1108         {
1109           ++beg;
1110           if (!(end = strchr (beg, '>')))
1111             break;
1112
1113           /* Take the first mailto URL */
1114           if (url_check_scheme (beg) == U_MAILTO)
1115           {
1116             FREE (&e->list_post);
1117             e->list_post = mutt_substrdup (beg, end);
1118             break;
1119           }
1120         }
1121       }
1122       matched = 1;
1123     }
1124     break;
1125
1126     case 'm':
1127     if (!ascii_strcasecmp (line + 1, "ime-version"))
1128     {
1129       if (hdr)
1130         hdr->mime = 1;
1131       matched = 1;
1132     }
1133     else if (!ascii_strcasecmp (line + 1, "essage-id"))
1134     {
1135       /* We add a new "Message-Id:" when building a message */
1136       FREE (&e->message_id);
1137       e->message_id = extract_message_id (p);
1138       matched = 1;
1139     }
1140     else if (!ascii_strncasecmp (line + 1, "ail-", 4))
1141     {
1142       if (!ascii_strcasecmp (line + 5, "reply-to"))
1143       {
1144         /* override the Reply-To: field */
1145         rfc822_free_address (&e->reply_to);
1146         e->reply_to = rfc822_parse_adrlist (e->reply_to, p);
1147         matched = 1;
1148       }
1149       else if (!ascii_strcasecmp (line + 5, "followup-to"))
1150       {
1151         e->mail_followup_to = rfc822_parse_adrlist (e->mail_followup_to, p);
1152         matched = 1;
1153       }
1154     }
1155     break;
1156
1157 #ifdef USE_NNTP
1158     case 'n':
1159     if (!mutt_strcasecmp (line + 1, "ewsgroups"))
1160     {
1161       FREE (&e->newsgroups);
1162       mutt_remove_trailing_ws (p);
1163       e->newsgroups = safe_strdup (mutt_skip_whitespace (p));
1164       matched = 1;
1165     }
1166     break;
1167 #endif
1168
1169     case 'o':
1170     /* field `Organization:' saves only for pager! */
1171     if (!mutt_strcasecmp (line + 1, "rganization"))
1172     {
1173       if (!e->organization && mutt_strcasecmp (p, "unknown"))
1174         e->organization = safe_strdup (p);
1175     }
1176     break;
1177
1178     case 'r':
1179     if (!ascii_strcasecmp (line + 1, "eferences"))
1180     {
1181       mutt_free_list (&e->references);
1182       e->references = mutt_parse_references (p, 0);
1183       matched = 1;
1184     }
1185     else if (!ascii_strcasecmp (line + 1, "eply-to"))
1186     {
1187       e->reply_to = rfc822_parse_adrlist (e->reply_to, p);
1188       matched = 1;
1189     }
1190     else if (!ascii_strcasecmp (line + 1, "eturn-path"))
1191     {
1192       e->return_path = rfc822_parse_adrlist (e->return_path, p);
1193       matched = 1;
1194     }
1195     else if (!ascii_strcasecmp (line + 1, "eceived"))
1196     {
1197       if (hdr && !hdr->received)
1198       {
1199         char *d = strchr (p, ';');
1200
1201         if (d)
1202           hdr->received = mutt_parse_date (d + 1, NULL);
1203       }
1204     }
1205     break;
1206
1207     case 's':
1208     if (!ascii_strcasecmp (line + 1, "ubject"))
1209     {
1210       if (!e->subject)
1211         e->subject = safe_strdup (p);
1212       matched = 1;
1213     }
1214     else if (!ascii_strcasecmp (line + 1, "ender"))
1215     {
1216       e->sender = rfc822_parse_adrlist (e->sender, p);
1217       matched = 1;
1218     }
1219     else if (!ascii_strcasecmp (line + 1, "tatus"))
1220     {
1221       if (hdr)
1222       {
1223         while (*p)
1224         {
1225           switch(*p)
1226           {
1227             case 'r':
1228             hdr->replied = 1;
1229             break;
1230             case 'O':
1231               hdr->old = 1;
1232             break;
1233             case 'R':
1234             hdr->read = 1;
1235             break;
1236           }
1237           p++;
1238         }
1239       }
1240       matched = 1;
1241     }
1242     else if ((!ascii_strcasecmp ("upersedes", line + 1) ||
1243               !ascii_strcasecmp ("upercedes", line + 1)) && hdr)
1244       e->supersedes = safe_strdup (p);
1245     break;
1246
1247     case 't':
1248     if (ascii_strcasecmp (line+1, "o") == 0)
1249     {
1250       e->to = rfc822_parse_adrlist (e->to, p);
1251       matched = 1;
1252     }
1253     break;
1254
1255     case 'x':
1256     if (ascii_strcasecmp (line+1, "-status") == 0)
1257     {
1258       if (hdr)
1259       {
1260         while (*p)
1261         {
1262           switch (*p)
1263           {
1264             case 'A':
1265             hdr->replied = 1;
1266             break;
1267             case 'D':
1268             hdr->deleted = 1;
1269             break;
1270             case 'F':
1271             hdr->flagged = 1;
1272             break;
1273             default:
1274             break;
1275           }
1276           p++;
1277         }
1278       }
1279       matched = 1;
1280     }
1281     else if (ascii_strcasecmp (line+1, "-label") == 0)
1282     {
1283       e->x_label = safe_strdup(p);
1284       matched = 1;
1285     }
1286 #ifdef USE_NNTP
1287     else if (!mutt_strcasecmp (line + 1, "-comment-to"))
1288     {
1289       if (!e->x_comment_to)
1290         e->x_comment_to = safe_strdup (p);
1291       matched = 1;
1292     }
1293     else if (!mutt_strcasecmp (line + 1, "ref"))
1294     {
1295       if (!e->xref)
1296         e->xref = safe_strdup (p);
1297       matched = 1;
1298     }
1299 #endif
1300
1301     default:
1302     break;
1303   }
1304
1305   /* Keep track of the user-defined headers */
1306   if (!matched && user_hdrs)
1307   {
1308     /* restore the original line */
1309     line[strlen (line)] = ':';
1310
1311     if (weed && option (OPTWEED) && mutt_matches_ignore (line, Ignore)
1312         && !mutt_matches_ignore (line, UnIgnore))
1313       goto done;
1314
1315     if (last)
1316     {
1317       last->next = mutt_new_list ();
1318       last = last->next;
1319     }
1320     else
1321       last = e->userhdrs = mutt_new_list ();
1322     last->data = safe_strdup (line);
1323     if (do_2047)
1324       rfc2047_decode (&last->data);
1325   }
1326
1327   done:
1328
1329   *lastp = last;
1330   return matched;
1331 }
1332
1333
1334 /* mutt_read_rfc822_header() -- parses a RFC822 header
1335  *
1336  * Args:
1337  *
1338  * f            stream to read from
1339  *
1340  * hdr          header structure of current message (optional).
1341  *
1342  * user_hdrs    If set, store user headers.  Used for recall-message and
1343  *              postpone modes.
1344  *
1345  * weed         If this parameter is set and the user has activated the
1346  *              $weed option, honor the header weed list for user headers.
1347  *              Used for recall-message.
1348  *
1349  * Returns:     newly allocated envelope structure.  You should free it by
1350  *              mutt_free_envelope() when envelope stay unneeded.
1351  */
1352 ENVELOPE *mutt_read_rfc822_header (FILE *f, HEADER *hdr, short user_hdrs,
1353                                    short weed)
1354 {
1355   ENVELOPE *e = mutt_new_envelope();
1356   LIST *last = NULL;
1357   char *line = safe_malloc (LONG_STRING);
1358   char *p;
1359   long loc;
1360   int matched;
1361   size_t linelen = LONG_STRING;
1362   char buf[LONG_STRING+1];
1363
1364   if (hdr)
1365   {
1366     if (hdr->content == NULL)
1367     {
1368       hdr->content = mutt_new_body ();
1369
1370       /* set the defaults from RFC1521 */
1371       hdr->content->type        = TYPETEXT;
1372       hdr->content->subtype     = safe_strdup ("plain");
1373       hdr->content->encoding    = ENC7BIT;
1374       hdr->content->length      = -1;
1375
1376       /* RFC 2183 says this is arbitrary */
1377       hdr->content->disposition = DISPINLINE;
1378     }
1379   }
1380
1381   while ((loc = ftell (f)),
1382           *(line = read_rfc822_line (f, line, &linelen)) != 0)
1383   {
1384     matched = 0;
1385
1386     if ((p = strpbrk (line, ": \t")) == NULL || *p != ':')
1387     {
1388       char return_path[LONG_STRING];
1389       time_t t;
1390
1391       /* some bogus MTAs will quote the original "From " line */
1392       if (mutt_strncmp (">From ", line, 6) == 0)
1393         continue; /* just ignore */
1394       else if (is_from (line, return_path, sizeof (return_path), &t))
1395       {
1396         /* MH somtimes has the From_ line in the middle of the header! */
1397         if (hdr && !hdr->received)
1398           hdr->received = t - mutt_local_tz (t);
1399         continue;
1400       }
1401
1402       fseek (f, loc, 0);
1403       break; /* end of header */
1404     }
1405
1406     *buf = '\0';
1407
1408     if (mutt_match_spam_list(line, SpamList, buf, sizeof(buf)))
1409     {
1410       if (!mutt_match_rx_list(line, NoSpamList))
1411       {
1412
1413         /* if spam tag already exists, figure out how to amend it */
1414         if (e->spam && *buf)
1415         {
1416           /* If SpamSep defined, append with separator */
1417           if (SpamSep)
1418           {
1419             mutt_buffer_addstr(e->spam, SpamSep);
1420             mutt_buffer_addstr(e->spam, buf);
1421           }
1422
1423           /* else overwrite */
1424           else
1425           {
1426             e->spam->dptr = e->spam->data;
1427             *e->spam->dptr = '\0';
1428             mutt_buffer_addstr(e->spam, buf);
1429           }
1430         }
1431
1432         /* spam tag is new, and match expr is non-empty; copy */
1433         else if (!e->spam && *buf)
1434         {
1435           e->spam = mutt_buffer_from(NULL, buf);
1436         }
1437
1438         /* match expr is empty; plug in null string if no existing tag */
1439         else if (!e->spam)
1440         {
1441           e->spam = mutt_buffer_from(NULL, "");
1442         }
1443
1444         if (e->spam && e->spam->data)
1445           dprint(5, (debugfile, "p822: spam = %s\n", e->spam->data));
1446       }
1447     }
1448
1449     *p = 0;
1450     p++;
1451     SKIPWS (p);
1452     if (!*p)
1453       continue; /* skip empty header fields */
1454
1455     matched = mutt_parse_rfc822_line (e, hdr, line, p, user_hdrs, weed, 1, &last);
1456
1457   }
1458
1459   FREE (&line);
1460
1461   if (hdr)
1462   {
1463     hdr->content->hdr_offset = hdr->offset;
1464     hdr->content->offset = ftell (f);
1465
1466     /* do RFC2047 decoding */
1467     rfc2047_decode_adrlist (e->from);
1468     rfc2047_decode_adrlist (e->to);
1469     rfc2047_decode_adrlist (e->cc);
1470     rfc2047_decode_adrlist (e->bcc);
1471     rfc2047_decode_adrlist (e->reply_to);
1472     rfc2047_decode_adrlist (e->mail_followup_to);
1473     rfc2047_decode_adrlist (e->return_path);
1474     rfc2047_decode_adrlist (e->sender);
1475
1476     if (e->subject)
1477     {
1478       regmatch_t pmatch[1];
1479
1480       rfc2047_decode (&e->subject);
1481
1482       if (regexec (ReplyRegexp.rx, e->subject, 1, pmatch, 0) == 0)
1483         e->real_subj = e->subject + pmatch[0].rm_eo;
1484       else
1485         e->real_subj = e->subject;
1486     }
1487
1488     /* check for missing or invalid date */
1489     if (hdr->date_sent <= 0)
1490     {
1491       dprint(1,(debugfile,"read_rfc822_header(): no date found, using received time from msg separator\n"));
1492       hdr->date_sent = hdr->received;
1493     }
1494   }
1495
1496   return (e);
1497 }
1498
1499 ADDRESS *mutt_parse_adrlist (ADDRESS *p, const char *s)
1500 {
1501   const char *q;
1502
1503   /* check for a simple whitespace separated list of addresses */
1504   if ((q = strpbrk (s, "\"<>():;,\\")) == NULL)
1505   {
1506     char tmp[HUGE_STRING];
1507     char *r;
1508
1509     strfcpy (tmp, s, sizeof (tmp));
1510     r = tmp;
1511     while ((r = strtok (r, " \t")) != NULL)
1512     {
1513       p = rfc822_parse_adrlist (p, r);
1514       r = NULL;
1515     }
1516   }
1517   else
1518     p = rfc822_parse_adrlist (p, s);
1519
1520   return p;
1521 }