handler.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 #include <stdlib.h>
  20 #include <string.h>
  21 #include <unistd.h>
  22 #include <ctype.h>
  23 #include <sys/wait.h>
  24 #include <sys/stat.h>
  25
  26 #include "mutt.h"
  27 #include "mutt_curses.h"
  28 #include "rfc1524.h"
  29 #include "keymap.h"
  30 #include "mime.h"
  31 #include "copy.h"
  32 #include "charset.h"
  33 #include "mutt_crypt.h"
  34
  35
  36 #define BUFI_SIZE 1000
  37 #define BUFO_SIZE 2000
  38
  39
  40 typedef void handler_f (BODY *, STATE *);
  41 typedef handler_f *handler_t;
  42
  43 int Index_hex[128] = {
  44     -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
  45     -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
  46     -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
  47      0, 1, 2, 3,  4, 5, 6, 7,  8, 9,-1,-1, -1,-1,-1,-1,
  48     -1,10,11,12, 13,14,15,-1, -1,-1,-1,-1, -1,-1,-1,-1,
  49     -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
  50     -1,10,11,12, 13,14,15,-1, -1,-1,-1,-1, -1,-1,-1,-1,
  51     -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1
  52 };
  53
  54 int Index_64[128] = {
  55     -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
  56     -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
  57     -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,62, -1,-1,-1,63,
  58     52,53,54,55, 56,57,58,59, 60,61,-1,-1, -1,-1,-1,-1,
  59     -1, 0, 1, 2,  3, 4, 5, 6,  7, 8, 9,10, 11,12,13,14,
  60     15,16,17,18, 19,20,21,22, 23,24,25,-1, -1,-1,-1,-1,
  61     -1,26,27,28, 29,30,31,32, 33,34,35,36, 37,38,39,40,
  62     41,42,43,44, 45,46,47,48, 49,50,51,-1, -1,-1,-1,-1
  63 };
  64
  65 static void state_prefix_put (const char *d, size_t dlen, STATE *s)
  66 {
  67   if (s->prefix)
  68     while (dlen--)
  69       state_prefix_putc (*d++, s);
  70   else
  71     fwrite (d, dlen, 1, s->fpout);
  72 }
  73
  74 void mutt_convert_to_state(iconv_t cd, char *bufi, size_t *l, STATE *s)
  75 {
  76   char bufo[BUFO_SIZE];
  77   ICONV_CONST char *ib;
  78   char *ob;
  79   size_t ibl, obl;
  80
  81   if (!bufi)
  82   {
  83     if (cd != (iconv_t)(-1))
  84     {
  85       ob = bufo, obl = sizeof (bufo);
  86       iconv (cd, 0, 0, &ob, &obl);
  87       if (ob != bufo)
  88         state_prefix_put (bufo, ob - bufo, s);
  89     }
  90     if (Quotebuf[0] != '\0')
  91       state_prefix_putc ('\n', s);
  92     return;
  93   }
  94
  95   if (cd == (iconv_t)(-1))
  96   {
  97     state_prefix_put (bufi, *l, s);
  98     *l = 0;
  99     return;
 100   }
 101
 102   ib = bufi, ibl = *l;
 103   for (;;)
 104   {
 105     ob = bufo, obl = sizeof (bufo);
 106     mutt_iconv (cd, &ib, &ibl, &ob, &obl, 0, "?");
 107     if (ob == bufo)
 108       break;
 109     state_prefix_put (bufo, ob - bufo, s);
 110   }
 111   memmove (bufi, ib, ibl);
 112   *l = ibl;
 113 }
 114
 115 void mutt_decode_xbit (STATE *s, long len, int istext, iconv_t cd)
 116 {
 117   int c, ch;
 118   char bufi[BUFI_SIZE];
 119   size_t l = 0;
 120
 121   if (istext)
 122   {
 123     state_set_prefix(s);
 124
 125     while ((c = fgetc(s->fpin)) != EOF && len--)
 126     {
 127       if(c == '\r' && len)
 128       {
 129         if((ch = fgetc(s->fpin)) == '\n')
 130         {
 131           c = ch;
 132           len--;
 133         }
 134         else
 135           ungetc(ch, s->fpin);
 136       }
 137
 138       bufi[l++] = c;
 139       if (l == sizeof (bufi))
 140         mutt_convert_to_state (cd, bufi, &l, s);
 141     }
 142
 143     mutt_convert_to_state (cd, bufi, &l, s);
 144     mutt_convert_to_state (cd, 0, 0, s);
 145
 146     state_reset_prefix (s);
 147   }
 148   else
 149     mutt_copy_bytes (s->fpin, s->fpout, len);
 150 }
 151
 152 static int qp_decode_triple (char *s, char *d)
 153 {
 154   /* soft line break */
 155   if (*s == '=' && !(*(s+1)))
 156     return 1;
 157
 158   /* quoted-printable triple */
 159   if (*s == '=' &&
 160       isxdigit ((unsigned char) *(s+1)) &&
 161       isxdigit ((unsigned char) *(s+2)))
 162   {
 163     *d = (hexval (*(s+1)) << 4) | hexval (*(s+2));
 164     return 0;
 165   }
 166
 167   /* something else */
 168   return -1;
 169 }
 170
 171 static void qp_decode_line (char *dest, char *src, size_t *l,
 172                             int last)
 173 {
 174   char *d, *s;
 175   char c;
 176
 177   int kind;
 178   int soft = 0;
 179
 180   /* decode the line */
 181
 182   for (d = dest, s = src; *s;)
 183   {
 184     switch ((kind = qp_decode_triple (s, &c)))
 185     {
 186       case  0: *d++ = c; s += 3; break; /* qp triple */
 187       case -1: *d++ = *s++;      break; /* single character */
 188       case  1: soft = 1; s++;    break; /* soft line break */
 189     }
 190   }
 191
 192   if (!soft && last == '\n')
 193     *d++ = '\n';
 194
 195   *d = '\0';
 196   *l = d - dest;
 197 }
 198
 199 /*
 200  * Decode an attachment encoded with quoted-printable.
 201  *
 202  * Why doesn't this overflow any buffers?  First, it's guaranteed
 203  * that the length of a line grows when you _en_-code it to
 204  * quoted-printable.  That means that we always can store the
 205  * result in a buffer of at most the _same_ size.
 206  *
 207  * Now, we don't special-case if the line we read with fgets()
 208  * isn't terminated.  We don't care about this, since STRING > 78,
 209  * so corrupted input will just be corrupted a bit more.  That
 210  * implies that STRING+1 bytes are always sufficient to store the
 211  * result of qp_decode_line.
 212  *
 213  * Finally, at soft line breaks, some part of a multibyte character
 214  * may have been left over by mutt_convert_to_state().  This shouldn't
 215  * be more than 6 characters, so STRING + 7 should be sufficient
 216  * memory to store the decoded data.
 217  *
 218  * Just to make sure that I didn't make some off-by-one error
 219  * above, we just use STRING*2 for the target buffer's size.
 220  *
 221  */
 222
 223 void mutt_decode_quoted (STATE *s, long len, int istext, iconv_t cd)
 224 {
 225   char line[STRING];
 226   char decline[2*STRING];
 227   size_t l = 0;
 228   size_t linelen;      /* number of input bytes in `line' */
 229   size_t l3;
 230
 231   int last;    /* store the last character in the input line */
 232
 233   if (istext)
 234     state_set_prefix(s);
 235
 236   while (len > 0)
 237   {
 238     last = 0;
 239
 240     /*
 241      * It's ok to use a fixed size buffer for input, even if the line turns
 242      * out to be longer than this.  Just process the line in chunks.  This
 243      * really shouldn't happen according the MIME spec, since Q-P encoded
 244      * lines are at most 76 characters, but we should be liberal about what
 245      * we accept.
 246      */
 247     if (fgets (line, MIN ((ssize_t)sizeof (line), len + 1), s->fpin) == NULL)
 248       break;
 249
 250     linelen = strlen(line);
 251     len -= linelen;
 252
 253     /*
 254      * inspect the last character we read so we can tell if we got the
 255      * entire line.
 256      */
 257     last = linelen ? line[linelen - 1] : 0;
 258
 259     /* chop trailing whitespace if we got the full line */
 260     if (last == '\n')
 261     {
 262       while (linelen > 0 && ISSPACE (line[linelen-1]))
 263        linelen--;
 264       line[linelen]=0;
 265     }
 266
 267     /* decode and do character set conversion */
 268     qp_decode_line (decline + l, line, &l3, last);
 269     l += l3;
 270     mutt_convert_to_state (cd, decline, &l, s);
 271   }
 272
 273   mutt_convert_to_state (cd, 0, 0, s);
 274   state_reset_prefix(s);
 275 }
 276
 277 void mutt_decode_base64 (STATE *s, long len, int istext, iconv_t cd)
 278 {
 279   char buf[5];
 280   int c1, c2, c3, c4, ch, cr = 0, i;
 281   char bufi[BUFI_SIZE];
 282   size_t l = 0;
 283
 284   buf[4] = 0;
 285
 286   if (istext)
 287     state_set_prefix(s);
 288
 289   while (len > 0)
 290   {
 291     for (i = 0 ; i < 4 && len > 0 ; len--)
 292     {
 293       if ((ch = fgetc (s->fpin)) == EOF)
 294         break;
 295       if (ch >= 0 && ch < 128 && (base64val(ch) != -1 || ch == '='))
 296         buf[i++] = ch;
 297     }
 298     if (i != 4)
 299     {
 300       dprint (2, (debugfile, "%s:%d [mutt_decode_base64()]: "
 301                   "didn't get a multiple of 4 chars.\n", __FILE__, __LINE__));
 302       break;
 303     }
 304
 305     c1 = base64val (buf[0]);
 306     c2 = base64val (buf[1]);
 307     ch = (c1 << 2) | (c2 >> 4);
 308
 309     if (cr && ch != '\n')
 310       bufi[l++] = '\r';
 311
 312     cr = 0;
 313
 314     if (istext && ch == '\r')
 315       cr = 1;
 316     else
 317       bufi[l++] = ch;
 318
 319     if (buf[2] == '=')
 320       break;
 321     c3 = base64val (buf[2]);
 322     ch = ((c2 & 0xf) << 4) | (c3 >> 2);
 323
 324     if (cr && ch != '\n')
 325       bufi[l++] = '\r';
 326
 327     cr = 0;
 328
 329     if (istext && ch == '\r')
 330       cr = 1;
 331     else
 332       bufi[l++] = ch;
 333
 334     if (buf[3] == '=') break;
 335     c4 = base64val (buf[3]);
 336     ch = ((c3 & 0x3) << 6) | c4;
 337
 338     if (cr && ch != '\n')
 339       bufi[l++] = '\r';
 340     cr = 0;
 341
 342     if (istext && ch == '\r')
 343       cr = 1;
 344     else
 345       bufi[l++] = ch;
 346
 347     if (l + 8 >= sizeof (bufi))
 348       mutt_convert_to_state (cd, bufi, &l, s);
 349   }
 350
 351   if (cr) bufi[l++] = '\r';
 352
 353   mutt_convert_to_state (cd, bufi, &l, s);
 354   mutt_convert_to_state (cd, 0, 0, s);
 355
 356   state_reset_prefix(s);
 357 }
 358
 359 unsigned char decode_byte (char ch)
 360 {
 361   if (ch == 96)
 362     return 0;
 363   return ch - 32;
 364 }
 365
 366 void mutt_decode_uuencoded (STATE *s, long len, int istext, iconv_t cd)
 367 {
 368   char tmps[SHORT_STRING];
 369   char linelen, c, l, out;
 370   char *pt;
 371   char bufi[BUFI_SIZE];
 372   size_t k = 0;
 373
 374   if(istext)
 375     state_set_prefix(s);
 376
 377   while(len > 0)
 378   {
 379     if ((fgets(tmps, sizeof(tmps), s->fpin)) == NULL)
 380       return;
 381     len -= mutt_strlen(tmps);
 382     if ((!mutt_strncmp (tmps, "begin", 5)) && ISSPACE (tmps[5]))
 383       break;
 384   }
 385   while(len > 0)
 386   {
 387     if ((fgets(tmps, sizeof(tmps), s->fpin)) == NULL)
 388       return;
 389     len -= mutt_strlen(tmps);
 390     if (!mutt_strncmp (tmps, "end", 3))
 391       break;
 392     pt = tmps;
 393     linelen = decode_byte (*pt);
 394     pt++;
 395     for (c = 0; c < linelen;)
 396     {
 397       for (l = 2; l <= 6; l += 2)
 398       {
 399         out = decode_byte (*pt) << l;
 400         pt++;
 401         out |= (decode_byte (*pt) >> (6 - l));
 402         bufi[k++] = out;
 403         c++;
 404         if (c == linelen)
 405           break;
 406       }
 407       mutt_convert_to_state (cd, bufi, &k, s);
 408       pt++;
 409     }
 410   }
 411
 412   mutt_convert_to_state (cd, bufi, &k, s);
 413   mutt_convert_to_state (cd, 0, 0, s);
 414
 415   state_reset_prefix(s);
 416 }
 417
 418 /* ----------------------------------------------------------------------------
 419  * A (not so) minimal implementation of RFC1563.
 420  */
 421
 422 #define IndentSize (4)
 423
 424 enum { RICH_PARAM=0, RICH_BOLD, RICH_UNDERLINE, RICH_ITALIC, RICH_NOFILL,
 425   RICH_INDENT, RICH_INDENT_RIGHT, RICH_EXCERPT, RICH_CENTER, RICH_FLUSHLEFT,
 426   RICH_FLUSHRIGHT, RICH_COLOR, RICH_LAST_TAG };
 427
 428 static struct {
 429   const char *tag_name;
 430   int index;
 431 } EnrichedTags[] = {
 432   { "param",            RICH_PARAM },
 433   { "bold",             RICH_BOLD },
 434   { "italic",           RICH_ITALIC },
 435   { "underline",        RICH_UNDERLINE },
 436   { "nofill",           RICH_NOFILL },
 437   { "excerpt",          RICH_EXCERPT },
 438   { "indent",           RICH_INDENT },
 439   { "indentright",      RICH_INDENT_RIGHT },
 440   { "center",           RICH_CENTER },
 441   { "flushleft",        RICH_FLUSHLEFT },
 442   { "flushright",       RICH_FLUSHRIGHT },
 443   { "flushboth",        RICH_FLUSHLEFT },
 444   { "color",            RICH_COLOR },
 445   { "x-color",          RICH_COLOR },
 446   { NULL,               -1 }
 447 };
 448
 449 struct enriched_state
 450 {
 451   char *buffer;
 452   char *line;
 453   char *param;
 454   size_t buff_len;
 455   size_t line_len;
 456   size_t line_used;
 457   size_t line_max;
 458   size_t indent_len;
 459   size_t word_len;
 460   size_t buff_used;
 461   size_t param_used;
 462   size_t param_len;
 463   int tag_level[RICH_LAST_TAG];
 464   int WrapMargin;
 465   STATE *s;
 466 };
 467
 468 static void enriched_wrap (struct enriched_state *stte)
 469 {
 470   int x;
 471   int extra;
 472
 473   if (stte->line_len)
 474   {
 475     if (stte->tag_level[RICH_CENTER] || stte->tag_level[RICH_FLUSHRIGHT])
 476     {
 477       /* Strip trailing white space */
 478       size_t y = stte->line_used - 1;
 479
 480       while (y && ISSPACE (stte->line[y]))
 481       {
 482         stte->line[y] = '\0';
 483         y--;
 484         stte->line_used--;
 485         stte->line_len--;
 486       }
 487       if (stte->tag_level[RICH_CENTER])
 488       {
 489         /* Strip leading whitespace */
 490         y = 0;
 491
 492         while (stte->line[y] && ISSPACE (stte->line[y]))
 493           y++;
 494         if (y)
 495         {
 496           size_t z;
 497
 498           for (z = y ; z <= stte->line_used; z++)
 499           {
 500             stte->line[z - y] = stte->line[z];
 501           }
 502
 503           stte->line_len -= y;
 504           stte->line_used -= y;
 505         }
 506       }
 507     }
 508
 509     extra = stte->WrapMargin - stte->line_len - stte->indent_len -
 510       (stte->tag_level[RICH_INDENT_RIGHT] * IndentSize);
 511     if (extra > 0)
 512     {
 513       if (stte->tag_level[RICH_CENTER])
 514       {
 515         x = extra / 2;
 516         while (x)
 517         {
 518           state_putc (' ', stte->s);
 519           x--;
 520         }
 521       }
 522       else if (stte->tag_level[RICH_FLUSHRIGHT])
 523       {
 524         x = extra-1;
 525         while (x)
 526         {
 527           state_putc (' ', stte->s);
 528           x--;
 529         }
 530       }
 531     }
 532     state_puts (stte->line, stte->s);
 533   }
 534
 535   state_putc ('\n', stte->s);
 536   stte->line[0] = '\0';
 537   stte->line_len = 0;
 538   stte->line_used = 0;
 539   stte->indent_len = 0;
 540   if (stte->s->prefix)
 541   {
 542     state_puts (stte->s->prefix, stte->s);
 543     stte->indent_len += mutt_strlen (stte->s->prefix);
 544   }
 545
 546   if (stte->tag_level[RICH_EXCERPT])
 547   {
 548     x = stte->tag_level[RICH_EXCERPT];
 549     while (x)
 550     {
 551       if (stte->s->prefix)
 552       {
 553         state_puts (stte->s->prefix, stte->s);
 554             stte->indent_len += mutt_strlen (stte->s->prefix);
 555       }
 556       else
 557       {
 558         state_puts ("> ", stte->s);
 559         stte->indent_len += mutt_strlen ("> ");
 560       }
 561       x--;
 562     }
 563   }
 564   else
 565     stte->indent_len = 0;
 566   if (stte->tag_level[RICH_INDENT])
 567   {
 568     x = stte->tag_level[RICH_INDENT] * IndentSize;
 569     stte->indent_len += x;
 570     while (x)
 571     {
 572       state_putc (' ', stte->s);
 573       x--;
 574     }
 575   }
 576 }
 577
 578 static void enriched_flush (struct enriched_state *stte, int wrap)
 579 {
 580   if (!stte->tag_level[RICH_NOFILL] && (stte->line_len + stte->word_len >
 581       (stte->WrapMargin - (stte->tag_level[RICH_INDENT_RIGHT] * IndentSize) -
 582        stte->indent_len)))
 583     enriched_wrap (stte);
 584
 585   if (stte->buff_used)
 586   {
 587     stte->buffer[stte->buff_used] = '\0';
 588     stte->line_used += stte->buff_used;
 589     if (stte->line_used > stte->line_max)
 590     {
 591       stte->line_max = stte->line_used;
 592       safe_realloc (&stte->line, stte->line_max + 1);
 593     }
 594     strcat (stte->line, stte->buffer);  /* __STRCAT_CHECKED__ */
 595     stte->line_len += stte->word_len;
 596     stte->word_len = 0;
 597     stte->buff_used = 0;
 598   }
 599   if (wrap)
 600     enriched_wrap(stte);
 601 }
 602
 603
 604 static void enriched_putc (int c, struct enriched_state *stte)
 605 {
 606   if (stte->tag_level[RICH_PARAM])
 607   {
 608     if (stte->tag_level[RICH_COLOR])
 609     {
 610       if (stte->param_used + 1 >= stte->param_len)
 611         safe_realloc (&stte->param, (stte->param_len += STRING));
 612
 613       stte->param[stte->param_used++] = c;
 614     }
 615     return; /* nothing to do */
 616   }
 617
 618   /* see if more space is needed (plus extra for possible rich characters) */
 619   if (stte->buff_len < stte->buff_used + 3)
 620   {
 621     stte->buff_len += LONG_STRING;
 622     safe_realloc (&stte->buffer, stte->buff_len + 1);
 623   }
 624
 625   if ((!stte->tag_level[RICH_NOFILL] && ISSPACE (c)) || c == '\0' )
 626   {
 627     if (c == '\t')
 628       stte->word_len += 8 - (stte->line_len + stte->word_len) % 8;
 629     else
 630       stte->word_len++;
 631
 632     stte->buffer[stte->buff_used++] = c;
 633     enriched_flush (stte, 0);
 634   }
 635   else
 636   {
 637     if (stte->s->flags & M_DISPLAY)
 638     {
 639       if (stte->tag_level[RICH_BOLD])
 640       {
 641         stte->buffer[stte->buff_used++] = c;
 642         stte->buffer[stte->buff_used++] = '\010';
 643         stte->buffer[stte->buff_used++] = c;
 644       }
 645       else if (stte->tag_level[RICH_UNDERLINE])
 646       {
 647
 648         stte->buffer[stte->buff_used++] = '_';
 649         stte->buffer[stte->buff_used++] = '\010';
 650         stte->buffer[stte->buff_used++] = c;
 651       }
 652       else if (stte->tag_level[RICH_ITALIC])
 653       {
 654         stte->buffer[stte->buff_used++] = c;
 655         stte->buffer[stte->buff_used++] = '\010';
 656         stte->buffer[stte->buff_used++] = '_';
 657       }
 658       else
 659       {
 660         stte->buffer[stte->buff_used++] = c;
 661       }
 662     }
 663     else
 664     {
 665       stte->buffer[stte->buff_used++] = c;
 666     }
 667     stte->word_len++;
 668   }
 669 }
 670
 671 static void enriched_puts (char *s, struct enriched_state *stte)
 672 {
 673   char *c;
 674
 675   if (stte->buff_len < stte->buff_used + mutt_strlen(s))
 676   {
 677     stte->buff_len += LONG_STRING;
 678     safe_realloc (&stte->buffer, stte->buff_len + 1);
 679   }
 680   c = s;
 681   while (*c)
 682   {
 683     stte->buffer[stte->buff_used++] = *c;
 684     c++;
 685   }
 686 }
 687
 688 static void enriched_set_flags (const char *tag, struct enriched_state *stte)
 689 {
 690   const char *tagptr = tag;
 691   int i, j;
 692
 693   if (*tagptr == '/')
 694     tagptr++;
 695
 696   for (i = 0, j = -1; EnrichedTags[i].tag_name; i++)
 697     if (ascii_strcasecmp (EnrichedTags[i].tag_name,tagptr) == 0)
 698     {
 699       j = EnrichedTags[i].index;
 700       break;
 701     }
 702
 703   if (j != -1)
 704   {
 705     if (j == RICH_CENTER || j == RICH_FLUSHLEFT || j == RICH_FLUSHRIGHT)
 706       enriched_flush (stte, 1);
 707
 708     if (*tag == '/')
 709     {
 710       if (stte->tag_level[j]) /* make sure not to go negative */
 711         stte->tag_level[j]--;
 712       if ((stte->s->flags & M_DISPLAY) && j == RICH_PARAM && stte->tag_level[RICH_COLOR])
 713       {
 714         stte->param[stte->param_used] = '\0';
 715         if (!ascii_strcasecmp(stte->param, "black"))
 716         {
 717           enriched_puts("\033[30m", stte);
 718         }
 719         else if (!ascii_strcasecmp(stte->param, "red"))
 720         {
 721           enriched_puts("\033[31m", stte);
 722         }
 723         else if (!ascii_strcasecmp(stte->param, "green"))
 724         {
 725           enriched_puts("\033[32m", stte);
 726         }
 727         else if (!ascii_strcasecmp(stte->param, "yellow"))
 728         {
 729           enriched_puts("\033[33m", stte);
 730         }
 731         else if (!ascii_strcasecmp(stte->param, "blue"))
 732         {
 733           enriched_puts("\033[34m", stte);
 734         }
 735         else if (!ascii_strcasecmp(stte->param, "magenta"))
 736         {
 737           enriched_puts("\033[35m", stte);
 738         }
 739         else if (!ascii_strcasecmp(stte->param, "cyan"))
 740         {
 741           enriched_puts("\033[36m", stte);
 742         }
 743         else if (!ascii_strcasecmp(stte->param, "white"))
 744         {
 745           enriched_puts("\033[37m", stte);
 746         }
 747       }
 748       if ((stte->s->flags & M_DISPLAY) && j == RICH_COLOR)
 749       {
 750         enriched_puts("\033[0m", stte);
 751       }
 752
 753       /* flush parameter buffer when closing the tag */
 754       if (j == RICH_PARAM)
 755       {
 756         stte->param_used = 0;
 757         stte->param[0] = '\0';
 758       }
 759     }
 760     else
 761       stte->tag_level[j]++;
 762
 763     if (j == RICH_EXCERPT)
 764       enriched_flush(stte, 1);
 765   }
 766 }
 767
 768 void text_enriched_handler (BODY *a, STATE *s)
 769 {
 770   enum {
 771     TEXT, LANGLE, TAG, BOGUS_TAG, NEWLINE, ST_EOF, DONE
 772   } state = TEXT;
 773
 774   long bytes = a->length;
 775   struct enriched_state stte;
 776   int c = 0;
 777   int tag_len = 0;
 778   char tag[LONG_STRING + 1];
 779
 780   memset (&stte, 0, sizeof (stte));
 781   stte.s = s;
 782   stte.WrapMargin = ((s->flags & M_DISPLAY) ? (COLS-4) : ((COLS-4)<72)?(COLS-4):72);
 783   stte.line_max = stte.WrapMargin * 4;
 784   stte.line = (char *) safe_calloc (1, stte.line_max + 1);
 785   stte.param = (char *) safe_calloc (1, STRING);
 786
 787   stte.param_len = STRING;
 788   stte.param_used = 0;
 789
 790   if (s->prefix)
 791   {
 792     state_puts (s->prefix, s);
 793     stte.indent_len += mutt_strlen (s->prefix);
 794   }
 795
 796   while (state != DONE)
 797   {
 798     if (state != ST_EOF)
 799     {
 800       if (!bytes || (c = fgetc (s->fpin)) == EOF)
 801         state = ST_EOF;
 802       else
 803         bytes--;
 804     }
 805
 806     switch (state)
 807     {
 808       case TEXT :
 809         switch (c)
 810         {
 811           case '<' :
 812             state = LANGLE;
 813             break;
 814
 815           case '\n' :
 816             if (stte.tag_level[RICH_NOFILL])
 817             {
 818               enriched_flush (&stte, 1);
 819             }
 820             else
 821             {
 822               enriched_putc (' ', &stte);
 823               state = NEWLINE;
 824             }
 825             break;
 826
 827           default:
 828             enriched_putc (c, &stte);
 829         }
 830         break;
 831
 832       case LANGLE :
 833         if (c == '<')
 834         {
 835           enriched_putc (c, &stte);
 836           state = TEXT;
 837           break;
 838         }
 839         else
 840         {
 841           tag_len = 0;
 842           state = TAG;
 843         }
 844         /* Yes, fall through (it wasn't a <<, so this char is first in TAG) */
 845       case TAG :
 846         if (c == '>')
 847         {
 848           tag[tag_len] = '\0';
 849           enriched_set_flags (tag, &stte);
 850           state = TEXT;
 851         }
 852         else if (tag_len < LONG_STRING)  /* ignore overly long tags */
 853           tag[tag_len++] = c;
 854         else
 855           state = BOGUS_TAG;
 856         break;
 857
 858       case BOGUS_TAG :
 859         if (c == '>')
 860           state = TEXT;
 861         break;
 862
 863       case NEWLINE :
 864         if (c == '\n')
 865           enriched_flush (&stte, 1);
 866         else
 867         {
 868           ungetc (c, s->fpin);
 869           bytes++;
 870           state = TEXT;
 871         }
 872         break;
 873
 874       case ST_EOF :
 875         enriched_putc ('\0', &stte);
 876         enriched_flush (&stte, 1);
 877         state = DONE;
 878         break;
 879
 880       case DONE: /* not reached, but gcc complains if this is absent */
 881         break;
 882     }
 883   }
 884
 885   state_putc ('\n', s); /* add a final newline */
 886
 887   FREE (&(stte.buffer));
 888   FREE (&(stte.line));
 889   FREE (&(stte.param));
 890 }
 891
 892 /*
 893  * An implementation of RFC 2646.
 894  *
 895  * NOTE: This still has to be made UTF-8 aware.
 896  *
 897  */
 898
 899 #define FLOWED_MAX 77
 900
 901 static void flowed_quote (STATE *s, int level)
 902 {
 903   int i;
 904
 905   if (s->prefix)
 906   {
 907     if (option (OPTTEXTFLOWED))
 908       level++;
 909     else
 910       state_puts (s->prefix, s);
 911   }
 912
 913   for (i = 0; i < level; i++)
 914     state_putc ('>', s);
 915 }
 916
 917 static int flowed_maybe_quoted (char *cont)
 918 {
 919   return regexec ((regex_t *) QuoteRegexp.rx, cont, 0, NULL, 0) == 0;
 920 }
 921
 922 static void flowed_stuff (STATE *s, char *cont, int level)
 923 {
 924   if (!option (OPTTEXTFLOWED) && !(s->flags & M_DISPLAY))
 925     return;
 926
 927   if (s->flags & M_DISPLAY)
 928   {
 929     /*
 930      * Hack: If we are in the beginning of the line and there is
 931      * some text on the line which looks like it's quoted, turn off
 932      * ANSI colors, so quote coloring doesn't affect this line.
 933      */
 934     if (*cont && !level && !mutt_strcmp (Pager, "builtin") && flowed_maybe_quoted (cont))
 935       state_puts ("\033[0m",s);
 936   }
 937   else if ((!(s->flags & M_PRINTING)) &&
 938            ((*cont == ' ') || (*cont == '>') || (!level && !mutt_strncmp (cont, "From ", 5))))
 939     state_putc (' ', s);
 940 }
 941
 942 static char *flowed_skip_indent (char *prefix, char *cont)
 943 {
 944   for (; *cont == ' ' || *cont == '\t'; cont++)
 945     *prefix++ = *cont;
 946   *prefix = '\0';
 947   return cont;
 948 }
 949
 950 static int flowed_visual_strlen (char *l, int i)
 951 {
 952   int j;
 953   for (j = 0; *l; l++)
 954   {
 955     if (*l == '\t')
 956       j += 8 - ((i + j) % 8);
 957     else
 958       j++;
 959   }
 960
 961   return j;
 962 }
 963
 964 static void text_plain_flowed_handler (BODY *a, STATE *s)
 965 {
 966   char line[LONG_STRING];
 967   char indent[LONG_STRING];
 968
 969   int  quoted = -1;
 970   int  last_quoted;
 971   int  full = 1;
 972   int  last_full;
 973   int  col = 0, tmpcol;
 974
 975   int  i_add = 0;
 976   int  add = 0;
 977   int  soft = 0;
 978   int  l, rl;
 979
 980   int  flowed_max;
 981   int  bytes = a->length;
 982   int  actually_wrap = 0;
 983
 984   char *cont = NULL;
 985   char *tail = NULL;
 986   char *lc = NULL;
 987   char *t;
 988
 989   *indent = '\0';
 990
 991   if (s->prefix)
 992     add = 1;
 993
 994   if ((flowed_max = FLOWED_MAX) > COLS - 3)
 995     flowed_max = COLS - 3;
 996   if (flowed_max > COLS - WrapMargin)
 997     flowed_max = COLS - WrapMargin;
 998   if (flowed_max <= 0)
 999     flowed_max = COLS;
1000
1001
1002   while (bytes > 0 && fgets (line, sizeof (line), s->fpin))
1003   {
1004     bytes        -= strlen (line);
1005     tail          = NULL;
1006
1007     last_full     = full;
1008
1009     /*
1010      * If the last line wasn't fully read, this is the
1011      * tail of some line.
1012      */
1013     actually_wrap = !last_full;
1014
1015     if ((t = strrchr (line, '\r')) || (t = strrchr (line, '\n')))
1016     {
1017       *t   = '\0';
1018       full = 1;
1019     }
1020     else if ((t = strrchr (line, ' ')) || (t = strrchr (line, '\t')))
1021     {
1022       /*
1023        * Bad: We have a line of more than LONG_STRING characters.
1024        * (Which SHOULD NOT happen, since lines SHOULD be <= 79
1025        * characters long.)
1026        *
1027        * Try to simulate a soft line break at a word boundary.
1028        * Handle the rest of the line next time.
1029        *
1030        * Give up when we have a single word which is longer than
1031        * LONG_STRING characters.  It will just be split into parts,
1032        * with a hard line break in between.
1033        */
1034
1035       full = 0;
1036       l    = strlen (t + 1);
1037       t[0] = ' ';
1038       t[1] = '\0';
1039
1040       if (l)
1041       {
1042         fseek (s->fpin, -l, SEEK_CUR);
1043         bytes += l;
1044       }
1045     }
1046     else
1047       full = 0;
1048
1049     last_quoted = quoted;
1050
1051     if (last_full)
1052     {
1053       /*
1054        * We are in the beginning of a new line. Determine quote level
1055        * and indentation prefix
1056        */
1057       for (quoted = 0; line[quoted] == '>'; quoted++)
1058         ;
1059
1060       cont = line + quoted;
1061
1062       /* undo space stuffing */
1063       if (*cont == ' ')
1064         cont++;
1065
1066       /* If there is an indentation, record it. */
1067       cont  = flowed_skip_indent (indent, cont);
1068       i_add = flowed_visual_strlen (indent, quoted + add);
1069     }
1070     else
1071     {
1072       /*
1073        * This is just the tail of some over-long line. Keep
1074        * indentation and quote levels.  Don't unstuff.
1075        */
1076       cont = line;
1077     }
1078
1079     /* If we have a change in quoting depth, wrap. */
1080
1081     if (col && last_quoted != quoted && last_quoted >= 0)
1082     {
1083       state_putc ('\n', s);
1084       col = 0;
1085     }
1086
1087     do
1088     {
1089       if (tail)
1090         cont = tail;
1091
1092       SKIPWS (cont);
1093
1094       tail = NULL;
1095       soft = 0;
1096
1097       /* try to find a point for word wrapping */
1098
1099     retry_wrap:
1100       l  = flowed_visual_strlen (cont, quoted + i_add + add + col);
1101       rl = mutt_strlen (cont);
1102       if (quoted + i_add + add + col + l > flowed_max)
1103       {
1104         actually_wrap = 1;
1105
1106         for (tmpcol = quoted + i_add + add + col, t = cont;
1107              *t && tmpcol < flowed_max; t++)
1108         {
1109           if (*t == ' ' || *t == '\t')
1110             tail = t;
1111           if (*t == '\t')
1112             tmpcol = (tmpcol & ~7) + 8;
1113           else
1114             tmpcol++;
1115         }
1116
1117         if (tail)
1118         {
1119           *tail++ = '\0';
1120           soft = 2;
1121         }
1122       }
1123
1124       /* We seem to be desperate.  Get me a new line, and retry. */
1125       if (!tail && (quoted + add + col + i_add + l > flowed_max) && col)
1126       {
1127         state_putc ('\n', s);
1128         col = 0;
1129         goto retry_wrap;
1130       }
1131
1132       /* Detect soft line breaks. */
1133       if (!soft && ascii_strcmp (cont, "-- "))
1134       {
1135         lc = strrchr (cont, ' ');
1136         if (lc && lc[1] == '\0')
1137           soft = 1;
1138       }
1139
1140       /*
1141        * If we are in the beginning of an output line, do quoting
1142        * and stuffing.
1143        *
1144        * We have to temporarily assemble the line since display
1145        * stuffing (i.e., turning off quote coloring) may depend on
1146        * the line's actual content.  You never know what people put
1147        * into their regular expressions.
1148        */
1149       if (!col)
1150       {
1151         char tmp[LONG_STRING];
1152         snprintf (tmp, sizeof (tmp), "%s%s", indent, cont);
1153
1154         flowed_quote (s, quoted);
1155         flowed_stuff (s, tmp, quoted + add);
1156
1157         state_puts (indent, s);
1158       }
1159
1160       /* output the text */
1161       state_puts (cont, s);
1162       col += flowed_visual_strlen (cont, quoted + i_add + add + col);
1163
1164       /* possibly indicate a soft line break */
1165       if (soft == 2)
1166       {
1167         state_putc (' ', s);
1168         col++;
1169       }
1170
1171       /*
1172        * Wrap if this display line corresponds to a
1173        * text line. Don't wrap if we changed the line.
1174        */
1175       if (!soft || (!actually_wrap && full))
1176       {
1177         state_putc ('\n', s);
1178         col = 0;
1179       }
1180     }
1181     while (tail);
1182   }
1183
1184   if (col)
1185     state_putc ('\n', s);
1186
1187 }
1188
1189
1190
1191
1192
1193
1194 #define TXTHTML     1
1195 #define TXTPLAIN    2
1196 #define TXTENRICHED 3
1197
1198 static void alternative_handler (BODY *a, STATE *s)
1199 {
1200   BODY *choice = NULL;
1201   BODY *b;
1202   LIST *t;
1203   char buf[STRING];
1204   int type = 0;
1205   int mustfree = 0;
1206
1207   if (a->encoding == ENCBASE64 || a->encoding == ENCQUOTEDPRINTABLE ||
1208       a->encoding == ENCUUENCODED)
1209   {
1210     struct stat st;
1211     mustfree = 1;
1212     fstat (fileno (s->fpin), &st);
1213     b = mutt_new_body ();
1214     b->length = (long) st.st_size;
1215     b->parts = mutt_parse_multipart (s->fpin,
1216                   mutt_get_parameter ("boundary", a->parameter),
1217                   (long) st.st_size, ascii_strcasecmp ("digest", a->subtype) == 0);
1218   }
1219   else
1220     b = a;
1221
1222   a = b;
1223
1224   /* First, search list of prefered types */
1225   t = AlternativeOrderList;
1226   while (t && !choice)
1227   {
1228     char *c;
1229     int btlen;  /* length of basetype */
1230     int wild;   /* do we have a wildcard to match all subtypes? */
1231
1232     c = strchr (t->data, '/');
1233     if (c)
1234     {
1235       wild = (c[1] == '*' && c[2] == 0);
1236       btlen = c - t->data;
1237     }
1238     else
1239     {
1240       wild = 1;
1241       btlen = mutt_strlen (t->data);
1242     }
1243
1244     if (a && a->parts)
1245       b = a->parts;
1246     else
1247       b = a;
1248     while (b)
1249     {
1250       const char *bt = TYPE(b);
1251       if (!ascii_strncasecmp (bt, t->data, btlen) && bt[btlen] == 0)
1252       {
1253         /* the basetype matches */
1254         if (wild || !ascii_strcasecmp (t->data + btlen + 1, b->subtype))
1255         {
1256           choice = b;
1257         }
1258       }
1259       b = b->next;
1260     }
1261     t = t->next;
1262   }
1263
1264   /* Next, look for an autoviewable type */
1265   if (!choice)
1266   {
1267     if (a && a->parts)
1268       b = a->parts;
1269     else
1270       b = a;
1271     while (b)
1272     {
1273       snprintf (buf, sizeof (buf), "%s/%s", TYPE (b), b->subtype);
1274       if (mutt_is_autoview (b, buf))
1275       {
1276         rfc1524_entry *entry = rfc1524_new_entry ();
1277
1278         if (rfc1524_mailcap_lookup (b, buf, entry, M_AUTOVIEW))
1279         {
1280           choice = b;
1281         }
1282         rfc1524_free_entry (&entry);
1283       }
1284       b = b->next;
1285     }
1286   }
1287
1288   /* Then, look for a text entry */
1289   if (!choice)
1290   {
1291     if (a && a->parts)
1292       b = a->parts;
1293     else
1294       b = a;
1295     while (b)
1296     {
1297       if (b->type == TYPETEXT)
1298       {
1299         if (! ascii_strcasecmp ("plain", b->subtype) && type <= TXTPLAIN)
1300         {
1301           choice = b;
1302           type = TXTPLAIN;
1303         }
1304         else if (! ascii_strcasecmp ("enriched", b->subtype) && type <= TXTENRICHED)
1305         {
1306           choice = b;
1307           type = TXTENRICHED;
1308         }
1309         else if (! ascii_strcasecmp ("html", b->subtype) && type <= TXTHTML)
1310         {
1311           choice = b;
1312           type = TXTHTML;
1313         }
1314       }
1315       b = b->next;
1316     }
1317   }
1318
1319   /* Finally, look for other possibilities */
1320   if (!choice)
1321   {
1322     if (a && a->parts)
1323       b = a->parts;
1324     else
1325       b = a;
1326     while (b)
1327     {
1328       if (mutt_can_decode (b))
1329         choice = b;
1330       b = b->next;
1331     }
1332   }
1333
1334   if (choice)
1335   {
1336     if (s->flags & M_DISPLAY && !option (OPTWEED))
1337     {
1338       fseek (s->fpin, choice->hdr_offset, 0);
1339       mutt_copy_bytes(s->fpin, s->fpout, choice->offset-choice->hdr_offset);
1340     }
1341     mutt_body_handler (choice, s);
1342   }
1343   else if (s->flags & M_DISPLAY)
1344   {
1345     /* didn't find anything that we could display! */
1346     state_mark_attach (s);
1347     state_puts(_("[-- Error:  Could not display any parts of Multipart/Alternative! --]\n"), s);
1348   }
1349
1350   if (mustfree)
1351     mutt_free_body(&a);
1352 }
1353
1354 /* handles message/rfc822 body parts */
1355 void message_handler (BODY *a, STATE *s)
1356 {
1357   struct stat st;
1358   BODY *b;
1359   long off_start;
1360
1361   off_start = ftell (s->fpin);
1362   if (a->encoding == ENCBASE64 || a->encoding == ENCQUOTEDPRINTABLE ||
1363       a->encoding == ENCUUENCODED)
1364   {
1365     fstat (fileno (s->fpin), &st);
1366     b = mutt_new_body ();
1367     b->length = (long) st.st_size;
1368     b->parts = mutt_parse_messageRFC822 (s->fpin, b);
1369   }
1370   else
1371     b = a;
1372
1373   if (b->parts)
1374   {
1375     mutt_copy_hdr (s->fpin, s->fpout, off_start, b->parts->offset,
1376         (((s->flags & M_WEED) || ((s->flags & (M_DISPLAY|M_PRINTING)) && option (OPTWEED))) ? (CH_WEED | CH_REORDER) : 0) |
1377         (s->prefix ? CH_PREFIX : 0) | CH_DECODE | CH_FROM, s->prefix);
1378
1379     if (s->prefix)
1380       state_puts (s->prefix, s);
1381     state_putc ('\n', s);
1382
1383     mutt_body_handler (b->parts, s);
1384   }
1385
1386   if (a->encoding == ENCBASE64 || a->encoding == ENCQUOTEDPRINTABLE ||
1387       a->encoding == ENCUUENCODED)
1388     mutt_free_body (&b);
1389 }
1390
1391 /* returns 1 if decoding the attachment will produce output */
1392 int mutt_can_decode (BODY *a)
1393 {
1394   char type[STRING];
1395
1396   snprintf (type, sizeof (type), "%s/%s", TYPE (a), a->subtype);
1397   if (mutt_is_autoview (a, type))
1398     return (rfc1524_mailcap_lookup (a, type, NULL, M_AUTOVIEW));
1399   else if (a->type == TYPETEXT)
1400     return (1);
1401   else if (a->type == TYPEMESSAGE)
1402     return (1);
1403   else if (a->type == TYPEMULTIPART)
1404   {
1405     BODY *p;
1406
1407     if (WithCrypto)
1408     {
1409       if (ascii_strcasecmp (a->subtype, "signed") == 0 ||
1410           ascii_strcasecmp (a->subtype, "encrypted") == 0)
1411         return (1);
1412     }
1413
1414     for (p = a->parts; p; p = p->next)
1415     {
1416       if (mutt_can_decode (p))
1417         return (1);
1418     }
1419
1420   }
1421   else if (WithCrypto && a->type == TYPEAPPLICATION)
1422   {
1423     if ((WithCrypto & APPLICATION_PGP) && mutt_is_application_pgp(a))
1424       return (1);
1425     if ((WithCrypto & APPLICATION_SMIME) && mutt_is_application_smime(a))
1426       return (1);
1427   }
1428
1429   return (0);
1430 }
1431
1432 void multipart_handler (BODY *a, STATE *s)
1433 {
1434   BODY *b, *p;
1435   char length[5];
1436   struct stat st;
1437   int count;
1438
1439   if (a->encoding == ENCBASE64 || a->encoding == ENCQUOTEDPRINTABLE ||
1440       a->encoding == ENCUUENCODED)
1441   {
1442     fstat (fileno (s->fpin), &st);
1443     b = mutt_new_body ();
1444     b->length = (long) st.st_size;
1445     b->parts = mutt_parse_multipart (s->fpin,
1446                   mutt_get_parameter ("boundary", a->parameter),
1447                   (long) st.st_size, ascii_strcasecmp ("digest", a->subtype) == 0);
1448   }
1449   else
1450     b = a;
1451
1452   for (p = b->parts, count = 1; p; p = p->next, count++)
1453   {
1454     if (s->flags & M_DISPLAY)
1455     {
1456       state_mark_attach (s);
1457       state_printf (s, _("[-- Attachment #%d"), count);
1458       if (p->description || p->filename || p->form_name)
1459       {
1460         state_puts (": ", s);
1461         state_puts (p->description ? p->description :
1462                     p->filename ? p->filename : p->form_name, s);
1463       }
1464       state_puts (" --]\n", s);
1465
1466       mutt_pretty_size (length, sizeof (length), p->length);
1467
1468       state_mark_attach (s);
1469       state_printf (s, _("[-- Type: %s/%s, Encoding: %s, Size: %s --]\n"),
1470                     TYPE (p), p->subtype, ENCODING (p->encoding), length);
1471       if (!option (OPTWEED))
1472       {
1473         fseek (s->fpin, p->hdr_offset, 0);
1474         mutt_copy_bytes(s->fpin, s->fpout, p->offset-p->hdr_offset);
1475       }
1476       else
1477         state_putc ('\n', s);
1478     }
1479     else
1480     {
1481       if (p->description && mutt_can_decode (p))
1482         state_printf (s, "Content-Description: %s\n", p->description);
1483
1484       if (p->form_name)
1485         state_printf(s, "%s: \n", p->form_name);
1486
1487     }
1488     mutt_body_handler (p, s);
1489     state_putc ('\n', s);
1490     if ((s->flags & M_REPLYING)
1491         && (option (OPTINCLUDEONLYFIRST)) && (s->flags & M_FIRSTDONE))
1492       break;
1493   }
1494
1495   if (a->encoding == ENCBASE64 || a->encoding == ENCQUOTEDPRINTABLE ||
1496       a->encoding == ENCUUENCODED)
1497     mutt_free_body (&b);
1498 }
1499
1500 void autoview_handler (BODY *a, STATE *s)
1501 {
1502   rfc1524_entry *entry = rfc1524_new_entry ();
1503   char buffer[LONG_STRING];
1504   char type[STRING];
1505   char command[LONG_STRING];
1506   char tempfile[_POSIX_PATH_MAX] = "";
1507   char *fname;
1508   FILE *fpin = NULL;
1509   FILE *fpout = NULL;
1510   FILE *fperr = NULL;
1511   int piped = FALSE;
1512   pid_t thepid;
1513
1514   snprintf (type, sizeof (type), "%s/%s", TYPE (a), a->subtype);
1515   rfc1524_mailcap_lookup (a, type, entry, M_AUTOVIEW);
1516
1517   fname = safe_strdup (a->filename);
1518   mutt_sanitize_filename (fname, 1);
1519   rfc1524_expand_filename (entry->nametemplate, fname, tempfile, sizeof (tempfile));
1520   FREE (&fname);
1521
1522   if (entry->command)
1523   {
1524     strfcpy (command, entry->command, sizeof (command));
1525
1526     /* rfc1524_expand_command returns 0 if the file is required */
1527     piped = rfc1524_expand_command (a, tempfile, type, command, sizeof (command));
1528
1529     if (s->flags & M_DISPLAY)
1530     {
1531       state_mark_attach (s);
1532       state_printf (s, _("[-- Autoview using %s --]\n"), command);
1533       mutt_message(_("Invoking autoview command: %s"),command);
1534     }
1535
1536     if ((fpin = safe_fopen (tempfile, "w+")) == NULL)
1537     {
1538       mutt_perror ("fopen");
1539       rfc1524_free_entry (&entry);
1540       return;
1541     }
1542
1543     mutt_copy_bytes (s->fpin, fpin, a->length);
1544
1545     if(!piped)
1546     {
1547       safe_fclose (&fpin);
1548       thepid = mutt_create_filter (command, NULL, &fpout, &fperr);
1549     }
1550     else
1551     {
1552       unlink (tempfile);
1553       fflush (fpin);
1554       rewind (fpin);
1555       thepid = mutt_create_filter_fd (command, NULL, &fpout, &fperr,
1556                                       fileno(fpin), -1, -1);
1557     }
1558
1559     if (thepid < 0)
1560     {
1561       mutt_perror _("Can't create filter");
1562       if (s->flags & M_DISPLAY)
1563       {
1564         state_mark_attach (s);
1565         state_printf (s, _("[-- Can't run %s. --]\n"), command);
1566       }
1567       goto bail;
1568     }
1569
1570     if (s->prefix)
1571     {
1572       while (fgets (buffer, sizeof(buffer), fpout) != NULL)
1573       {
1574         state_puts (s->prefix, s);
1575         state_puts (buffer, s);
1576       }
1577       /* check for data on stderr */
1578       if (fgets (buffer, sizeof(buffer), fperr))
1579       {
1580         if (s->flags & M_DISPLAY)
1581         {
1582           state_mark_attach (s);
1583           state_printf (s, _("[-- Autoview stderr of %s --]\n"), command);
1584         }
1585
1586         state_puts (s->prefix, s);
1587         state_puts (buffer, s);
1588         while (fgets (buffer, sizeof(buffer), fperr) != NULL)
1589         {
1590           state_puts (s->prefix, s);
1591           state_puts (buffer, s);
1592         }
1593       }
1594     }
1595     else
1596     {
1597       mutt_copy_stream (fpout, s->fpout);
1598       /* Check for stderr messages */
1599       if (fgets (buffer, sizeof(buffer), fperr))
1600       {
1601         if (s->flags & M_DISPLAY)
1602         {
1603           state_mark_attach (s);
1604           state_printf (s, _("[-- Autoview stderr of %s --]\n"),
1605                         command);
1606         }
1607
1608         state_puts (buffer, s);
1609         mutt_copy_stream (fperr, s->fpout);
1610       }
1611     }
1612
1613   bail:
1614     safe_fclose (&fpout);
1615     safe_fclose (&fperr);
1616
1617     mutt_wait_filter (thepid);
1618     if (piped)
1619       safe_fclose (&fpin);
1620     else
1621       mutt_unlink (tempfile);
1622
1623     if (s->flags & M_DISPLAY)
1624       mutt_clear_error ();
1625   }
1626   rfc1524_free_entry (&entry);
1627 }
1628
1629 static void external_body_handler (BODY *b, STATE *s)
1630 {
1631   const char *access_type;
1632   const char *expiration;
1633   time_t expire;
1634
1635   access_type = mutt_get_parameter ("access-type", b->parameter);
1636   if (!access_type)
1637   {
1638     if (s->flags & M_DISPLAY)
1639     {
1640       state_mark_attach (s);
1641       state_puts (_("[-- Error: message/external-body has no access-type parameter --]\n"), s);
1642     }
1643     return;
1644   }
1645
1646   expiration = mutt_get_parameter ("expiration", b->parameter);
1647   if (expiration)
1648     expire = mutt_parse_date (expiration, NULL);
1649   else
1650     expire = -1;
1651
1652   if (!ascii_strcasecmp (access_type, "x-mutt-deleted"))
1653   {
1654     if (s->flags & (M_DISPLAY|M_PRINTING))
1655     {
1656       char *length;
1657       char pretty_size[10];
1658
1659       state_mark_attach (s);
1660       state_printf (s, _("[-- This %s/%s attachment "),
1661                TYPE(b->parts), b->parts->subtype);
1662       length = mutt_get_parameter ("length", b->parameter);
1663       if (length)
1664       {
1665         mutt_pretty_size (pretty_size, sizeof (pretty_size),
1666                           strtol (length, NULL, 10));
1667         state_printf (s, _("(size %s bytes) "), pretty_size);
1668       }
1669       state_puts (_("has been deleted --]\n"), s);
1670
1671       if (expire != -1)
1672       {
1673         state_mark_attach (s);
1674         state_printf (s, _("[-- on %s --]\n"), expiration);
1675       }
1676       if (b->parts->filename)
1677       {
1678         state_mark_attach (s);
1679         state_printf (s, _("[-- name: %s --]\n"), b->parts->filename);
1680       }
1681
1682       mutt_copy_hdr (s->fpin, s->fpout, ftell (s->fpin), b->parts->offset,
1683                      (option (OPTWEED) ? (CH_WEED | CH_REORDER) : 0) |
1684                      CH_DECODE , NULL);
1685     }
1686   }
1687   else if(expiration && expire < time(NULL))
1688   {
1689     if (s->flags & M_DISPLAY)
1690     {
1691       state_mark_attach (s);
1692       state_printf (s, _("[-- This %s/%s attachment is not included, --]\n"),
1693                     TYPE(b->parts), b->parts->subtype);
1694       state_attach_puts (_("[-- and the indicated external source has --]\n"
1695                            "[-- expired. --]\n"), s);
1696
1697       mutt_copy_hdr(s->fpin, s->fpout, ftell (s->fpin), b->parts->offset,
1698                     (option (OPTWEED) ? (CH_WEED | CH_REORDER) : 0) |
1699                     CH_DECODE, NULL);
1700     }
1701   }
1702   else
1703   {
1704     if (s->flags & M_DISPLAY)
1705     {
1706       state_mark_attach (s);
1707       state_printf (s,
1708                     _("[-- This %s/%s attachment is not included, --]\n"),
1709                     TYPE (b->parts), b->parts->subtype);
1710       state_mark_attach (s);
1711       state_printf (s,
1712                     _("[-- and the indicated access-type %s is unsupported --]\n"),
1713                     access_type);
1714       mutt_copy_hdr (s->fpin, s->fpout, ftell (s->fpin), b->parts->offset,
1715                      (option (OPTWEED) ? (CH_WEED | CH_REORDER) : 0) |
1716                      CH_DECODE , NULL);
1717     }
1718   }
1719 }
1720
1721 void mutt_decode_attachment (BODY *b, STATE *s)
1722 {
1723   int istext = mutt_is_text_part (b);
1724   iconv_t cd = (iconv_t)(-1);
1725
1726   Quotebuf[0] = '\0';
1727
1728   if (istext && s->flags & M_CHARCONV)
1729   {
1730     char *charset = mutt_get_parameter ("charset", b->parameter);
1731     if (charset && Charset)
1732       cd = mutt_iconv_open (Charset, charset, M_ICONV_HOOK_FROM);
1733   }
1734
1735   fseek (s->fpin, b->offset, 0);
1736   switch (b->encoding)
1737   {
1738     case ENCQUOTEDPRINTABLE:
1739       mutt_decode_quoted (s, b->length, istext, cd);
1740       break;
1741     case ENCBASE64:
1742       mutt_decode_base64 (s, b->length, istext, cd);
1743       break;
1744     case ENCUUENCODED:
1745       mutt_decode_uuencoded (s, b->length, istext, cd);
1746       break;
1747     default:
1748       mutt_decode_xbit (s, b->length, istext, cd);
1749       break;
1750   }
1751
1752   if (cd != (iconv_t)(-1))
1753     iconv_close (cd);
1754 }
1755
1756 void mutt_body_handler (BODY *b, STATE *s)
1757 {
1758   int decode = 0;
1759   int plaintext = 0;
1760   FILE *fp = NULL;
1761   char tempfile[_POSIX_PATH_MAX];
1762   handler_t handler = NULL;
1763   long tmpoffset = 0;
1764   size_t tmplength = 0;
1765   char type[STRING];
1766
1767   int oflags = s->flags;
1768
1769   /* first determine which handler to use to process this part */
1770
1771   snprintf (type, sizeof (type), "%s/%s", TYPE (b), b->subtype);
1772   if (mutt_is_autoview (b, type))
1773   {
1774     rfc1524_entry *entry = rfc1524_new_entry ();
1775
1776     if (rfc1524_mailcap_lookup (b, type, entry, M_AUTOVIEW))
1777     {
1778       handler   = autoview_handler;
1779       s->flags &= ~M_CHARCONV;
1780     }
1781     rfc1524_free_entry (&entry);
1782   }
1783   else if (b->type == TYPETEXT)
1784   {
1785     if (ascii_strcasecmp ("plain", b->subtype) == 0)
1786     {
1787       /* avoid copying this part twice since removing the transfer-encoding is
1788        * the only operation needed.
1789        */
1790       if ((WithCrypto & APPLICATION_PGP) && mutt_is_application_pgp (b))
1791         handler = crypt_pgp_application_pgp_handler;
1792       else if (ascii_strcasecmp ("flowed", mutt_get_parameter ("format", b->parameter)) == 0)
1793         handler = text_plain_flowed_handler;
1794       else
1795         plaintext = 1;
1796     }
1797     else if (ascii_strcasecmp ("enriched", b->subtype) == 0)
1798       handler = text_enriched_handler;
1799     else /* text body type without a handler */
1800       plaintext = 1;
1801   }
1802   else if (b->type == TYPEMESSAGE)
1803   {
1804     if(mutt_is_message_type(b->type, b->subtype))
1805       handler = message_handler;
1806     else if (!ascii_strcasecmp ("delivery-status", b->subtype))
1807       plaintext = 1;
1808     else if (!ascii_strcasecmp ("external-body", b->subtype))
1809       handler = external_body_handler;
1810   }
1811   else if (b->type == TYPEMULTIPART)
1812   {
1813     char *p;
1814
1815     if (ascii_strcasecmp ("alternative", b->subtype) == 0)
1816       handler = alternative_handler;
1817     else if (WithCrypto && ascii_strcasecmp ("signed", b->subtype) == 0)
1818     {
1819       p = mutt_get_parameter ("protocol", b->parameter);
1820
1821       if (!p)
1822         mutt_error _("Error: multipart/signed has no protocol.");
1823       else if (s->flags & M_VERIFY)
1824         handler = mutt_signed_handler;
1825     }
1826     else if ((WithCrypto & APPLICATION_PGP)
1827              && mutt_strcasecmp ("encrypted", b->subtype) == 0)
1828     {
1829       p = mutt_get_parameter ("protocol", b->parameter);
1830
1831       if (!p)
1832         mutt_error _("Error: multipart/encrypted has no protocol parameter!");
1833       else if (ascii_strcasecmp ("application/pgp-encrypted", p) == 0)
1834         handler = crypt_pgp_encrypted_handler;
1835     }
1836
1837     if (!handler)
1838       handler = multipart_handler;
1839   }
1840   else if (WithCrypto && b->type == TYPEAPPLICATION)
1841   {
1842     if ((WithCrypto & APPLICATION_PGP) && mutt_is_application_pgp (b))
1843       handler = crypt_pgp_application_pgp_handler;
1844     if ((WithCrypto & APPLICATION_SMIME) && mutt_is_application_smime(b))
1845       handler = crypt_smime_application_smime_handler;
1846   }
1847
1848
1849   if (plaintext || handler)
1850   {
1851     fseek (s->fpin, b->offset, 0);
1852
1853     /* see if we need to decode this part before processing it */
1854     if (b->encoding == ENCBASE64 || b->encoding == ENCQUOTEDPRINTABLE ||
1855         b->encoding == ENCUUENCODED || plaintext ||
1856         mutt_is_text_part (b))                          /* text subtypes may
1857                                                          * require character
1858                                                          * set conversion even
1859                                                          * with 8bit encoding.
1860                                                          */
1861     {
1862       int origType = b->type;
1863       char *savePrefix = NULL;
1864
1865       if (!plaintext)
1866       {
1867         /* decode to a tempfile, saving the original destination */
1868         fp = s->fpout;
1869         mutt_mktemp (tempfile);
1870         if ((s->fpout = safe_fopen (tempfile, "w")) == NULL)
1871         {
1872           mutt_error _("Unable to open temporary file!");
1873           goto bail;
1874         }
1875         /* decoding the attachment changes the size and offset, so save a copy
1876          * of the "real" values now, and restore them after processing
1877          */
1878         tmplength = b->length;
1879         tmpoffset = b->offset;
1880
1881         /* if we are decoding binary bodies, we don't want to prefix each
1882          * line with the prefix or else the data will get corrupted.
1883          */
1884         savePrefix = s->prefix;
1885         s->prefix = NULL;
1886
1887         decode = 1;
1888       }
1889       else
1890         b->type = TYPETEXT;
1891
1892       mutt_decode_attachment (b, s);
1893
1894       if (decode)
1895       {
1896         b->length = ftell (s->fpout);
1897         b->offset = 0;
1898         fclose (s->fpout);
1899
1900         /* restore final destination and substitute the tempfile for input */
1901         s->fpout = fp;
1902         fp = s->fpin;
1903         s->fpin = safe_fopen (tempfile, "r");
1904         unlink (tempfile);
1905
1906         /* restore the prefix */
1907         s->prefix = savePrefix;
1908       }
1909
1910       b->type = origType;
1911     }
1912
1913     /* process the (decoded) body part */
1914     if (handler)
1915     {
1916       handler (b, s);
1917
1918       if (decode)
1919       {
1920         b->length = tmplength;
1921         b->offset = tmpoffset;
1922
1923         /* restore the original source stream */
1924         fclose (s->fpin);
1925         s->fpin = fp;
1926       }
1927     }
1928     s->flags |= M_FIRSTDONE;
1929   }
1930   else if (s->flags & M_DISPLAY)
1931   {
1932     state_mark_attach (s);
1933     state_printf (s, _("[-- %s/%s is unsupported "), TYPE (b), b->subtype);
1934     if (!option (OPTVIEWATTACH))
1935     {
1936       if (km_expand_key (type, sizeof(type),
1937                         km_find_func (MENU_PAGER, OP_VIEW_ATTACHMENTS)))
1938         fprintf (s->fpout, _("(use '%s' to view this part)"), type);
1939       else
1940         fputs (_("(need 'view-attachments' bound to key!)"), s->fpout);
1941     }
1942     fputs (" --]\n", s->fpout);
1943   }
1944
1945   bail:
1946   s->flags = oflags | (s->flags & M_FIRSTDONE);
1947 }