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