handler.c

   1 /*
   2  * Copyright notice from original mutt:
   3  * Copyright (C) 1996-2000 Michael R. Elkins <me@mutt.org>
   4  *
   5  * This file is part of mutt-ng, see http://www.muttng.org/.
   6  * It's licensed under the GNU General Public License,
   7  * please see the file GPL in the top level source directory.
   8  */
   9
  10 #include <lib-lib/lib-lib.h>
  11
  12 #include <lib-mime/mime.h>
  13 #include <lib-mime/rfc3676.h>
  14
  15 #include <lib-ui/lib-ui.h>
  16
  17 #include <lib-sys/unix.h>
  18
  19 #include "mutt.h"
  20 #include "recvattach.h"
  21 #include "handler.h"
  22 #include "keymap.h"
  23 #include "copy.h"
  24 #include "charset.h"
  25 #include "crypt.h"
  26 #include "state.h"
  27 #include "attach.h"
  28
  29 typedef int handler_f (BODY *, STATE *);
  30 typedef handler_f *handler_t;
  31
  32 static void mutt_decode_xbit (STATE * s, long len, int istext, iconv_t cd)
  33 {
  34   int c, ch;
  35   char bufi[BUFI_SIZE];
  36   ssize_t l = 0;
  37
  38   if (istext) {
  39     state_set_prefix (s);
  40
  41     while ((c = fgetc (s->fpin)) != EOF && len--) {
  42       if (c == '\r' && len) {
  43         if ((ch = fgetc (s->fpin)) == '\n') {
  44           c = ch;
  45           len--;
  46         }
  47         else
  48           ungetc (ch, s->fpin);
  49       }
  50
  51       bufi[l++] = c;
  52       if (l == sizeof (bufi))
  53         mutt_convert_to_state (cd, bufi, &l, s);
  54     }
  55
  56     mutt_convert_to_state (cd, bufi, &l, s);
  57     mutt_convert_to_state (cd, 0, 0, s);
  58
  59     state_reset_prefix (s);
  60   }
  61   else
  62     mutt_copy_bytes (s->fpin, s->fpout, len);
  63 }
  64
  65 static int qp_decode_triple (char *s, char *d)
  66 {
  67   /* soft line break */
  68   if (*s == '=' && !(*(s + 1)))
  69     return 1;
  70
  71   /* quoted-printable triple */
  72   if (*s == '=' &&
  73       isxdigit ((unsigned char) *(s + 1)) &&
  74       isxdigit ((unsigned char) *(s + 2))) {
  75     *d = (hexval (*(s + 1)) << 4) | hexval (*(s + 2));
  76     return 0;
  77   }
  78
  79   /* something else */
  80   return -1;
  81 }
  82
  83 static void qp_decode_line (char *dest, char *src, ssize_t * l, int last)
  84 {
  85   char *d, *s;
  86   char c;
  87
  88   int kind;
  89   int soft = 0;
  90
  91   /* decode the line */
  92
  93   for (d = dest, s = src; *s;) {
  94     switch ((kind = qp_decode_triple (s, &c))) {
  95     case 0:
  96       *d++ = c;
  97       s += 3;
  98       break;                    /* qp triple */
  99     case -1:
 100       *d++ = *s++;
 101       break;                    /* single character */
 102     case 1:
 103       soft = 1;
 104       s++;
 105       break;                    /* soft line break */
 106     }
 107   }
 108
 109   if (!soft && last == '\n')
 110     *d++ = '\n';
 111
 112   *d = '\0';
 113   *l = d - dest;
 114 }
 115
 116 /*
 117  * Decode an attachment encoded with quoted-printable.
 118  *
 119  * Why doesn't this overflow any buffers?  First, it's guaranteed
 120  * that the length of a line grows when you _en_-code it to
 121  * quoted-printable.  That means that we always can store the
 122  * result in a buffer of at most the _same_ size.
 123  *
 124  * Now, we don't special-case if the line we read with fgets()
 125  * isn't terminated.  We don't care about this, since STRING > 78,
 126  * so corrupted input will just be corrupted a bit more.  That
 127  * implies that STRING+1 bytes are always sufficient to store the
 128  * result of qp_decode_line.
 129  *
 130  * Finally, at soft line breaks, some part of a multibyte character
 131  * may have been left over by mutt_convert_to_state().  This shouldn't
 132  * be more than 6 characters, so STRING + 7 should be sufficient
 133  * memory to store the decoded data.
 134  *
 135  * Just to make sure that I didn't make some off-by-one error
 136  * above, we just use STRING*2 for the target buffer's size.
 137  *
 138  */
 139
 140 static void mutt_decode_quoted (STATE * s, long len, int istext, iconv_t cd)
 141 {
 142   char line[10 * STRING];
 143   char decline[20 * STRING];
 144   ssize_t l = 0;
 145   ssize_t linelen;               /* number of input bytes in `line' */
 146   ssize_t l3;
 147
 148   int last;                     /* store the last character in the input line */
 149
 150   if (istext)
 151     state_set_prefix (s);
 152
 153   while (len > 0) {
 154     last = 0;
 155
 156     /*
 157      * It's ok to use a fixed size buffer for input, even if the line turns
 158      * out to be longer than this.  Just process the line in chunks.  This
 159      * really shouldn't happen according the MIME spec, since Q-P encoded
 160      * lines are at most 76 characters, but we should be liberal about what
 161      * we accept.
 162      */
 163     if (fgets (line, MIN ((ssize_t) sizeof (line), len + 1), s->fpin) == NULL)
 164       break;
 165
 166     linelen = m_strlen(line);
 167     len -= linelen;
 168
 169     /*
 170      * inspect the last character we read so we can tell if we got the
 171      * entire line.
 172      */
 173     last = linelen ? line[linelen - 1] : 0;
 174
 175     /* chop trailing whitespace if we got the full line */
 176     if (last == '\n') {
 177       while (linelen > 0 && ISSPACE (line[linelen - 1]))
 178         linelen--;
 179       line[linelen] = 0;
 180     }
 181
 182     /* decode and do character set conversion */
 183     qp_decode_line (decline + l, line, &l3, last);
 184     l += l3;
 185     assert (l < sizeof(decline));
 186     mutt_convert_to_state (cd, decline, &l, s);
 187   }
 188
 189   mutt_convert_to_state (cd, 0, 0, s);
 190   state_reset_prefix (s);
 191 }
 192
 193 static unsigned char decode_byte(int ch)
 194 {
 195     return ch == 96 ? 0 : ch - 32;
 196 }
 197
 198 static void mutt_decode_uuencoded (STATE * s, long len, int istext, iconv_t cd)
 199 {
 200   char tmps[STRING];
 201   char linelen, c, l, out;
 202   char *pt;
 203   char bufi[BUFI_SIZE];
 204   ssize_t k = 0;
 205
 206   if (istext)
 207     state_set_prefix (s);
 208
 209   while (len > 0) {
 210     if ((fgets (tmps, sizeof (tmps), s->fpin)) == NULL)
 211       return;
 212     len -= m_strlen(tmps);
 213     if ((!m_strncmp(tmps, "begin", 5)) && ISSPACE (tmps[5]))
 214       break;
 215   }
 216   while (len > 0) {
 217     if ((fgets (tmps, sizeof (tmps), s->fpin)) == NULL)
 218       return;
 219     len -= m_strlen(tmps);
 220     if (!m_strncmp(tmps, "end", 3))
 221       break;
 222     pt = tmps;
 223     linelen = decode_byte(*pt);
 224     pt++;
 225     for (c = 0; c < linelen;) {
 226       for (l = 2; l <= 6; l += 2) {
 227         out = decode_byte(*pt) << l;
 228         pt++;
 229         out |= (decode_byte(*pt) >> (6 - l));
 230         bufi[k++] = out;
 231         c++;
 232         if (c == linelen)
 233           break;
 234       }
 235       mutt_convert_to_state (cd, bufi, &k, s);
 236       pt++;
 237     }
 238   }
 239
 240   mutt_convert_to_state (cd, bufi, &k, s);
 241   mutt_convert_to_state (cd, 0, 0, s);
 242
 243   state_reset_prefix (s);
 244 }
 245
 246 /* ----------------------------------------------------------------------------
 247  * A (not so) minimal implementation of RFC1563.
 248  */
 249
 250 #define IndentSize (4)
 251
 252 enum { RICH_PARAM = 0, RICH_BOLD, RICH_UNDERLINE, RICH_ITALIC, RICH_NOFILL,
 253   RICH_INDENT, RICH_INDENT_RIGHT, RICH_EXCERPT, RICH_CENTER, RICH_FLUSHLEFT,
 254   RICH_FLUSHRIGHT, RICH_COLOR, RICH_LAST_TAG
 255 };
 256
 257 static struct {
 258   const char *tag_name;
 259   int index;
 260 } EnrichedTags[] = {
 261   {"param", RICH_PARAM},
 262   {"bold", RICH_BOLD},
 263   {"italic", RICH_ITALIC},
 264   {"underline", RICH_UNDERLINE},
 265   {"nofill", RICH_NOFILL},
 266   {"excerpt", RICH_EXCERPT},
 267   {"indent", RICH_INDENT},
 268   {"indentright", RICH_INDENT_RIGHT},
 269   {"center", RICH_CENTER},
 270   {"flushleft", RICH_FLUSHLEFT},
 271   {"flushright", RICH_FLUSHRIGHT},
 272   {"flushboth", RICH_FLUSHLEFT},
 273   {"color", RICH_COLOR},
 274   {"x-color", RICH_COLOR},
 275   {NULL, -1}
 276 };
 277
 278 struct enriched_state {
 279   char *buffer;
 280   char *line;
 281   char *param;
 282   ssize_t buff_len;
 283   ssize_t line_len;
 284   ssize_t line_used;
 285   ssize_t line_max;
 286   ssize_t indent_len;
 287   ssize_t word_len;
 288   ssize_t buff_used;
 289   ssize_t param_used;
 290   ssize_t param_len;
 291   int tag_level[RICH_LAST_TAG];
 292   int WrapMargin;
 293   STATE *s;
 294 };
 295
 296 static void enriched_wrap (struct enriched_state *stte)
 297 {
 298   int x;
 299   int extra;
 300
 301   if (stte->line_len) {
 302     if (stte->tag_level[RICH_CENTER] || stte->tag_level[RICH_FLUSHRIGHT]) {
 303       /* Strip trailing white space */
 304       ssize_t y = stte->line_used - 1;
 305
 306       while (y && ISSPACE (stte->line[y])) {
 307         stte->line[y] = '\0';
 308         y--;
 309         stte->line_used--;
 310         stte->line_len--;
 311       }
 312       if (stte->tag_level[RICH_CENTER]) {
 313         /* Strip leading whitespace */
 314         y = 0;
 315
 316         while (stte->line[y] && ISSPACE (stte->line[y]))
 317           y++;
 318         if (y) {
 319           ssize_t z;
 320
 321           for (z = y; z <= stte->line_used; z++) {
 322             stte->line[z - y] = stte->line[z];
 323           }
 324
 325           stte->line_len -= y;
 326           stte->line_used -= y;
 327         }
 328       }
 329     }
 330
 331     extra = stte->WrapMargin - stte->line_len - stte->indent_len -
 332       (stte->tag_level[RICH_INDENT_RIGHT] * IndentSize);
 333     if (extra > 0) {
 334       if (stte->tag_level[RICH_CENTER]) {
 335         x = extra / 2;
 336         while (x) {
 337           state_putc (' ', stte->s);
 338           x--;
 339         }
 340       }
 341       else if (stte->tag_level[RICH_FLUSHRIGHT]) {
 342         x = extra - 1;
 343         while (x) {
 344           state_putc (' ', stte->s);
 345           x--;
 346         }
 347       }
 348     }
 349     state_puts (stte->line, stte->s);
 350   }
 351
 352   state_putc ('\n', stte->s);
 353   stte->line[0] = '\0';
 354   stte->line_len = 0;
 355   stte->line_used = 0;
 356   stte->indent_len = 0;
 357   if (stte->s->prefix) {
 358     state_puts (stte->s->prefix, stte->s);
 359     stte->indent_len += m_strlen(stte->s->prefix);
 360   }
 361
 362   if (stte->tag_level[RICH_EXCERPT]) {
 363     x = stte->tag_level[RICH_EXCERPT];
 364     while (x) {
 365       if (stte->s->prefix) {
 366         state_puts (stte->s->prefix, stte->s);
 367         stte->indent_len += m_strlen(stte->s->prefix);
 368       }
 369       else {
 370         state_puts ("> ", stte->s);
 371         stte->indent_len += m_strlen("> ");
 372       }
 373       x--;
 374     }
 375   }
 376   else
 377     stte->indent_len = 0;
 378   if (stte->tag_level[RICH_INDENT]) {
 379     x = stte->tag_level[RICH_INDENT] * IndentSize;
 380     stte->indent_len += x;
 381     while (x) {
 382       state_putc (' ', stte->s);
 383       x--;
 384     }
 385   }
 386 }
 387
 388 static void enriched_flush (struct enriched_state *stte, int wrap)
 389 {
 390   if (!stte->tag_level[RICH_NOFILL] && (stte->line_len + stte->word_len >
 391                                         (stte->WrapMargin -
 392                                          (stte->tag_level[RICH_INDENT_RIGHT] *
 393                                           IndentSize) - stte->indent_len)))
 394     enriched_wrap (stte);
 395
 396   if (stte->buff_used) {
 397     stte->buffer[stte->buff_used] = '\0';
 398     stte->line_used += stte->buff_used;
 399     if (stte->line_used > stte->line_max) {
 400       stte->line_max = stte->line_used;
 401       p_realloc(&stte->line, stte->line_max + 1);
 402     }
 403     m_strcat(stte->line, stte->line_max + 1, stte->buffer);
 404     stte->line_len += stte->word_len;
 405     stte->word_len = 0;
 406     stte->buff_used = 0;
 407   }
 408   if (wrap)
 409     enriched_wrap (stte);
 410 }
 411
 412
 413 static void enriched_putc (int c, struct enriched_state *stte)
 414 {
 415   if (stte->tag_level[RICH_PARAM]) {
 416     if (stte->tag_level[RICH_COLOR]) {
 417       if (stte->param_used + 1 >= stte->param_len)
 418         p_realloc(&stte->param, (stte->param_len += STRING));
 419
 420       stte->param[stte->param_used++] = c;
 421     }
 422     return;                     /* nothing to do */
 423   }
 424
 425   /* see if more space is needed (plus extra for possible rich characters) */
 426   if (stte->buff_len < stte->buff_used + 3) {
 427     stte->buff_len += LONG_STRING;
 428     p_realloc(&stte->buffer, stte->buff_len + 1);
 429   }
 430
 431   if ((!stte->tag_level[RICH_NOFILL] && ISSPACE (c)) || c == '\0') {
 432     if (c == '\t')
 433       stte->word_len += 8 - (stte->line_len + stte->word_len) % 8;
 434     else
 435       stte->word_len++;
 436
 437     stte->buffer[stte->buff_used++] = c;
 438     enriched_flush (stte, 0);
 439   }
 440   else {
 441     if (stte->s->flags & M_DISPLAY) {
 442       if (stte->tag_level[RICH_BOLD]) {
 443         stte->buffer[stte->buff_used++] = c;
 444         stte->buffer[stte->buff_used++] = '\010';
 445         stte->buffer[stte->buff_used++] = c;
 446       }
 447       else if (stte->tag_level[RICH_UNDERLINE]) {
 448
 449         stte->buffer[stte->buff_used++] = '_';
 450         stte->buffer[stte->buff_used++] = '\010';
 451         stte->buffer[stte->buff_used++] = c;
 452       }
 453       else if (stte->tag_level[RICH_ITALIC]) {
 454         stte->buffer[stte->buff_used++] = c;
 455         stte->buffer[stte->buff_used++] = '\010';
 456         stte->buffer[stte->buff_used++] = '_';
 457       }
 458       else {
 459         stte->buffer[stte->buff_used++] = c;
 460       }
 461     } else {
 462       stte->buffer[stte->buff_used++] = c;
 463     }
 464     stte->word_len++;
 465   }
 466 }
 467
 468 static void enriched_puts (const char *s, struct enriched_state *stte)
 469 {
 470   const char *p;
 471
 472   if (stte->buff_len < stte->buff_used + m_strlen(s)) {
 473     stte->buff_len += LONG_STRING;
 474     p_realloc(&stte->buffer, stte->buff_len + 1);
 475   }
 476
 477   p = s;
 478   while (*p) {
 479     stte->buffer[stte->buff_used++] = *p++;
 480   }
 481 }
 482
 483 static void enriched_set_flags (const char *tag, struct enriched_state *stte)
 484 {
 485   const char *tagptr = tag;
 486   int i, j;
 487
 488   if (*tagptr == '/')
 489     tagptr++;
 490
 491   for (i = 0, j = -1; EnrichedTags[i].tag_name; i++)
 492     if (ascii_strcasecmp (EnrichedTags[i].tag_name, tagptr) == 0) {
 493       j = EnrichedTags[i].index;
 494       break;
 495     }
 496
 497   if (j != -1) {
 498     if (j == RICH_CENTER || j == RICH_FLUSHLEFT || j == RICH_FLUSHRIGHT)
 499       enriched_flush (stte, 1);
 500
 501     if (*tag == '/') {
 502       if (stte->tag_level[j])   /* make sure not to go negative */
 503         stte->tag_level[j]--;
 504       if ((stte->s->flags & M_DISPLAY) && j == RICH_PARAM
 505           && stte->tag_level[RICH_COLOR]) {
 506         stte->param[stte->param_used] = '\0';
 507         if (!ascii_strcasecmp (stte->param, "black")) {
 508           enriched_puts ("\033[30m", stte);
 509         }
 510         else if (!ascii_strcasecmp (stte->param, "red")) {
 511           enriched_puts ("\033[31m", stte);
 512         }
 513         else if (!ascii_strcasecmp (stte->param, "green")) {
 514           enriched_puts ("\033[32m", stte);
 515         }
 516         else if (!ascii_strcasecmp (stte->param, "yellow")) {
 517           enriched_puts ("\033[33m", stte);
 518         }
 519         else if (!ascii_strcasecmp (stte->param, "blue")) {
 520           enriched_puts ("\033[34m", stte);
 521         }
 522         else if (!ascii_strcasecmp (stte->param, "magenta")) {
 523           enriched_puts ("\033[35m", stte);
 524         }
 525         else if (!ascii_strcasecmp (stte->param, "cyan")) {
 526           enriched_puts ("\033[36m", stte);
 527         }
 528         else if (!ascii_strcasecmp (stte->param, "white")) {
 529           enriched_puts ("\033[37m", stte);
 530         }
 531       }
 532       if ((stte->s->flags & M_DISPLAY) && j == RICH_COLOR) {
 533         enriched_puts ("\033[0m", stte);
 534       }
 535
 536       /* flush parameter buffer when closing the tag */
 537       if (j == RICH_PARAM) {
 538         stte->param_used = 0;
 539         stte->param[0] = '\0';
 540       }
 541     }
 542     else
 543       stte->tag_level[j]++;
 544
 545     if (j == RICH_EXCERPT)
 546       enriched_flush (stte, 1);
 547   }
 548 }
 549
 550 static int text_enriched_handler (BODY * a, STATE * s)
 551 {
 552   enum {
 553     TEXT, LANGLE, TAG, BOGUS_TAG, NEWLINE, ST_EOF, DONE
 554   } state = TEXT;
 555
 556   long bytes = a->length;
 557   struct enriched_state stte;
 558   int c = 0;
 559   int tag_len = 0;
 560   char tag[LONG_STRING + 1];
 561
 562   p_clear(&stte, 1);
 563   stte.s = s;
 564   stte.WrapMargin = ((s->flags & M_DISPLAY) ? (getmaxx(main_w) - 4) :
 565                      ((getmaxx(main_w) - 4) < 72) ? (getmaxx(main_w) - 4) : 72);
 566   stte.line_max = stte.WrapMargin * 4;
 567   stte.line = p_new(char, stte.line_max + 1);
 568   stte.param = p_new(char, STRING);
 569
 570   stte.param_len = STRING;
 571   stte.param_used = 0;
 572
 573   if (s->prefix) {
 574     state_puts (s->prefix, s);
 575     stte.indent_len += m_strlen(s->prefix);
 576   }
 577
 578   while (state != DONE) {
 579     if (state != ST_EOF) {
 580       if (!bytes || (c = fgetc (s->fpin)) == EOF)
 581         state = ST_EOF;
 582       else
 583         bytes--;
 584     }
 585
 586     switch (state) {
 587     case TEXT:
 588       switch (c) {
 589       case '<':
 590         state = LANGLE;
 591         break;
 592
 593       case '\n':
 594         if (stte.tag_level[RICH_NOFILL]) {
 595           enriched_flush (&stte, 1);
 596         }
 597         else {
 598           enriched_putc (' ', &stte);
 599           state = NEWLINE;
 600         }
 601         break;
 602
 603       default:
 604         enriched_putc (c, &stte);
 605       }
 606       break;
 607
 608     case LANGLE:
 609       if (c == '<') {
 610         enriched_putc (c, &stte);
 611         state = TEXT;
 612         break;
 613       }
 614       else {
 615         tag_len = 0;
 616         state = TAG;
 617       }
 618       /* Yes, fall through (it wasn't a <<, so this char is first in TAG) */
 619     case TAG:
 620       if (c == '>') {
 621         tag[tag_len] = '\0';
 622         enriched_set_flags (tag, &stte);
 623         state = TEXT;
 624       }
 625       else if (tag_len < LONG_STRING)   /* ignore overly long tags */
 626         tag[tag_len++] = c;
 627       else
 628         state = BOGUS_TAG;
 629       break;
 630
 631     case BOGUS_TAG:
 632       if (c == '>')
 633         state = TEXT;
 634       break;
 635
 636     case NEWLINE:
 637       if (c == '\n')
 638         enriched_flush (&stte, 1);
 639       else {
 640         ungetc (c, s->fpin);
 641         bytes++;
 642         state = TEXT;
 643       }
 644       break;
 645
 646     case ST_EOF:
 647       enriched_putc ('\0', &stte);
 648       enriched_flush (&stte, 1);
 649       state = DONE;
 650       break;
 651
 652     case DONE:                 /* not reached, but gcc complains if this is absent */
 653       break;
 654     }
 655   }
 656
 657   state_putc ('\n', s);         /* add a final newline */
 658
 659   p_delete(&(stte.buffer));
 660   p_delete(&(stte.line));
 661   p_delete(&(stte.param));
 662
 663   return (0);
 664 }
 665
 666 #define TXTHTML     1
 667 #define TXTPLAIN    2
 668 #define TXTENRICHED 3
 669
 670 static int alternative_handler (BODY * a, STATE * s)
 671 {
 672   BODY *choice = NULL;
 673   BODY *b;
 674   string_list_t *t;
 675   char buf[STRING];
 676   int type = 0;
 677   int mustfree = 0;
 678   int rc = 0;
 679
 680   if (a->encoding == ENCBASE64 || a->encoding == ENCQUOTEDPRINTABLE ||
 681       a->encoding == ENCUUENCODED) {
 682     struct stat st;
 683
 684     mustfree = 1;
 685     fstat (fileno (s->fpin), &st);
 686     b = body_new();
 687     b->length = (long) st.st_size;
 688     b->parts = mutt_parse_multipart(s->fpin,
 689                                     parameter_getval(a->parameter, "boundary"),
 690                                     (long)st.st_size,
 691                                     mime_which_token(a->subtype, -1) == MIME_DIGEST);
 692   }
 693   else
 694     b = a;
 695
 696   a = b;
 697
 698   /* First, search list of prefered types */
 699   t = AlternativeOrderList;
 700   while (t && !choice) {
 701     char *c;
 702     int btlen;                  /* length of basetype */
 703     int wild;                   /* do we have a wildcard to match all subtypes? */
 704
 705     c = strchr (t->data, '/');
 706     if (c) {
 707       wild = (c[1] == '*' && c[2] == 0);
 708       btlen = c - t->data;
 709     }
 710     else {
 711       wild = 1;
 712       btlen = m_strlen(t->data);
 713     }
 714
 715     if (a && a->parts)
 716       b = a->parts;
 717     else
 718       b = a;
 719     while (b) {
 720       const char *bt = TYPE (b);
 721
 722       if (!ascii_strncasecmp (bt, t->data, btlen) && bt[btlen] == 0) {
 723         /* the basetype matches */
 724         if (wild || !ascii_strcasecmp (t->data + btlen + 1, b->subtype)) {
 725           choice = b;
 726         }
 727       }
 728       b = b->next;
 729     }
 730     t = t->next;
 731   }
 732
 733   /* Next, look for an autoviewable type */
 734   if (!choice) {
 735     if (a && a->parts)
 736       b = a->parts;
 737     else
 738       b = a;
 739     while (b) {
 740       snprintf (buf, sizeof (buf), "%s/%s", TYPE (b), b->subtype);
 741       if (mutt_is_autoview (b, buf)) {
 742         rfc1524_entry *entry = rfc1524_entry_new();
 743
 744         if (rfc1524_mailcap_lookup (b, buf, entry, M_AUTOVIEW)) {
 745           choice = b;
 746         }
 747         rfc1524_entry_delete(&entry);
 748       }
 749       b = b->next;
 750     }
 751   }
 752
 753   /* Then, look for a text entry */
 754   if (!choice) {
 755     if (a && a->parts)
 756       b = a->parts;
 757     else
 758       b = a;
 759     while (b) {
 760       if (b->type == TYPETEXT) {
 761         switch (mime_which_token(b->subtype, -1)) {
 762           case MIME_PLAIN:
 763             if (type <= TXTPLAIN) {
 764               choice = b;
 765               type = TXTPLAIN;
 766             }
 767             break;
 768           case MIME_ENRICHED:
 769             if (type <= TXTENRICHED) {
 770               choice = b;
 771               type = TXTENRICHED;
 772             }
 773             break;
 774           case MIME_HTML:
 775             if (type <= TXTHTML) {
 776               choice = b;
 777               type = TXTHTML;
 778             }
 779             break;
 780           default:
 781             break;
 782         }
 783       }
 784       b = b->next;
 785     }
 786   }
 787
 788   /* Finally, look for other possibilities */
 789   if (!choice) {
 790     if (a && a->parts)
 791       b = a->parts;
 792     else
 793       b = a;
 794     while (b) {
 795       if (mutt_can_decode (b))
 796         choice = b;
 797       b = b->next;
 798     }
 799   }
 800
 801   if (choice) {
 802     if (s->flags & M_DISPLAY && !option (OPTWEED)) {
 803       fseeko (s->fpin, choice->hdr_offset, 0);
 804       mutt_copy_bytes (s->fpin, s->fpout,
 805                        choice->offset - choice->hdr_offset);
 806     }
 807     mutt_body_handler (choice, s);
 808   }
 809   else if (s->flags & M_DISPLAY) {
 810     /* didn't find anything that we could display! */
 811     state_mark_attach (s);
 812     state_puts (_("[-- Error:  Could not display any parts of Multipart/Alternative! --]\n"), s);
 813     rc = -1;
 814   }
 815
 816   if (mustfree)
 817     body_list_wipe(&a);
 818
 819   return (rc);
 820 }
 821
 822 /* handles message/rfc822 body parts */
 823 static int message_handler (BODY * a, STATE * s)
 824 {
 825   struct stat st;
 826   BODY *b;
 827   off_t off_start;
 828   int rc = 0;
 829
 830   off_start = ftello (s->fpin);
 831   if (a->encoding == ENCBASE64 || a->encoding == ENCQUOTEDPRINTABLE ||
 832       a->encoding == ENCUUENCODED) {
 833     fstat (fileno (s->fpin), &st);
 834     b = body_new();
 835     b->length = (long) st.st_size;
 836     b->parts = mutt_parse_messageRFC822 (s->fpin, b);
 837   }
 838   else
 839     b = a;
 840
 841   if (b->parts) {
 842     mutt_copy_hdr (s->fpin, s->fpout, off_start, b->parts->offset,
 843                    (((s->flags & M_WEED)
 844                      || ((s->flags & (M_DISPLAY | M_PRINTING))
 845                          && option (OPTWEED))) ? (CH_WEED | CH_REORDER) : 0) |
 846                    (s->prefix ? CH_PREFIX : 0) | CH_DECODE | CH_FROM,
 847                    s->prefix);
 848
 849     if (s->prefix)
 850       state_puts (s->prefix, s);
 851     state_putc ('\n', s);
 852
 853     rc = mutt_body_handler (b->parts, s);
 854   }
 855
 856   if (a->encoding == ENCBASE64 || a->encoding == ENCQUOTEDPRINTABLE ||
 857       a->encoding == ENCUUENCODED)
 858     body_list_wipe(&b);
 859
 860   return (rc);
 861 }
 862
 863 /* returns 1 if decoding the attachment will produce output */
 864 int mutt_can_decode (BODY * a)
 865 {
 866   char type[STRING];
 867
 868   snprintf (type, sizeof (type), "%s/%s", TYPE (a), a->subtype);
 869   if (mutt_is_autoview (a, type))
 870     return (rfc1524_mailcap_lookup (a, type, NULL, M_AUTOVIEW));
 871   else if (a->type == TYPETEXT)
 872     return (1);
 873   else if (a->type == TYPEMESSAGE)
 874     return (1);
 875   else if (a->type == TYPEMULTIPART) {
 876     BODY *p;
 877     int tok = mime_which_token(a->subtype, -1);
 878
 879     if (tok == MIME_SIGNED || tok == MIME_ENCRYPTED)
 880       return 1;
 881
 882     for (p = a->parts; p; p = p->next) {
 883       if (mutt_can_decode (p))
 884         return (1);
 885     }
 886   }
 887   else if (a->type == TYPEAPPLICATION) {
 888     if (mutt_is_application_pgp(a))
 889       return (1);
 890     if (mutt_is_application_smime (a))
 891       return (1);
 892   }
 893
 894   return (0);
 895 }
 896
 897 static int multipart_handler (BODY * a, STATE * s)
 898 {
 899   BODY *b, *p;
 900   char length[5];
 901   struct stat st;
 902   int count;
 903   int rc = 0;
 904
 905   if (a->encoding == ENCBASE64 || a->encoding == ENCQUOTEDPRINTABLE ||
 906       a->encoding == ENCUUENCODED) {
 907     fstat (fileno (s->fpin), &st);
 908     b = body_new();
 909     b->length = (long) st.st_size;
 910     b->parts = mutt_parse_multipart(s->fpin,
 911                                     parameter_getval(a->parameter, "boundary"),
 912                                     (long)st.st_size,
 913                                     mime_which_token(a->subtype, -1) == MIME_DIGEST);
 914   } else {
 915     b = a;
 916   }
 917
 918   for (p = b->parts, count = 1; p; p = p->next, count++) {
 919     if (s->flags & M_DISPLAY) {
 920       state_mark_attach (s);
 921       state_printf (s, _("[-- Attachment #%d"), count);
 922       if (p->description || p->filename || p->form_name) {
 923         state_puts (": ", s);
 924         state_puts (p->description ? p->description :
 925                     p->filename ? p->filename : p->form_name, s);
 926       }
 927       state_puts (" --]\n", s);
 928
 929       mutt_pretty_size (length, sizeof (length), p->length);
 930
 931       state_mark_attach (s);
 932       state_printf (s, _("[-- Type: %s/%s, Encoding: %s, Size: %s --]\n"),
 933                     TYPE (p), p->subtype, ENCODING (p->encoding), length);
 934       if (!option (OPTWEED)) {
 935         fseeko (s->fpin, p->hdr_offset, 0);
 936         mutt_copy_bytes (s->fpin, s->fpout, p->offset - p->hdr_offset);
 937       }
 938       else
 939         state_putc ('\n', s);
 940     }
 941     else {
 942       if (p->description && mutt_can_decode (p))
 943         state_printf (s, "Content-Description: %s\n", p->description);
 944
 945       if (p->form_name)
 946         state_printf (s, "%s: \n", p->form_name);
 947
 948     }
 949     rc = mutt_body_handler (p, s);
 950     state_putc ('\n', s);
 951     if (rc)
 952       break;
 953   }
 954
 955   if (a->encoding == ENCBASE64 || a->encoding == ENCQUOTEDPRINTABLE ||
 956       a->encoding == ENCUUENCODED)
 957     body_list_wipe(&b);
 958
 959   return (rc);
 960 }
 961
 962 static int autoview_handler (BODY * a, STATE * s)
 963 {
 964   rfc1524_entry *entry = rfc1524_entry_new();
 965   char buffer[LONG_STRING];
 966   char type[STRING];
 967   char command[LONG_STRING];
 968   char tempfile[_POSIX_PATH_MAX] = "";
 969   char *fname;
 970   FILE *fpin = NULL;
 971   FILE *fpout = NULL;
 972   FILE *fperr = NULL;
 973   int piped = FALSE;
 974   pid_t thepid;
 975   int rc = 0;
 976
 977   snprintf (type, sizeof (type), "%s/%s", TYPE (a), a->subtype);
 978   rfc1524_mailcap_lookup (a, type, entry, M_AUTOVIEW);
 979
 980   fname = m_strdup(a->filename);
 981   mutt_sanitize_filename (fname, 1);
 982   rfc1524_expand_filename (entry->nametemplate, fname, tempfile,
 983                            sizeof (tempfile));
 984   p_delete(&fname);
 985
 986   if (entry->command) {
 987     m_strcpy(command, sizeof(command), entry->command);
 988
 989     /* rfc1524_expand_command returns 0 if the file is required */
 990     piped =
 991       rfc1524_expand_command (a, tempfile, type, command, sizeof (command));
 992
 993     if (s->flags & M_DISPLAY) {
 994       state_mark_attach (s);
 995       state_printf (s, _("[-- Autoview using %s --]\n"), command);
 996       mutt_message (_("Invoking autoview command: %s"), command);
 997     }
 998
 999     if ((fpin = safe_fopen (tempfile, "w+")) == NULL) {
1000       mutt_perror ("fopen");
1001       rfc1524_entry_delete(&entry);
1002       return (-1);
1003     }
1004
1005     mutt_copy_bytes (s->fpin, fpin, a->length);
1006
1007     if (!piped) {
1008       m_fclose(&fpin);
1009       thepid = mutt_create_filter (command, NULL, &fpout, &fperr);
1010     } else {
1011       unlink (tempfile);
1012       fflush (fpin);
1013       rewind (fpin);
1014       thepid = mutt_create_filter_fd (command, NULL, &fpout, &fperr,
1015                                       fileno (fpin), -1, -1);
1016     }
1017
1018     if (thepid < 0) {
1019       mutt_perror (_("Can't create filter"));
1020
1021       if (s->flags & M_DISPLAY) {
1022         state_mark_attach (s);
1023         state_printf (s, _("[-- Can't run %s. --]\n"), command);
1024       }
1025       rc = -1;
1026       goto bail;
1027     }
1028
1029     if (s->prefix) {
1030       while (fgets (buffer, sizeof (buffer), fpout) != NULL) {
1031         state_puts (s->prefix, s);
1032         state_puts (buffer, s);
1033       }
1034       /* check for data on stderr */
1035       if (fgets (buffer, sizeof (buffer), fperr)) {
1036         if (s->flags & M_DISPLAY) {
1037           state_mark_attach (s);
1038           state_printf (s, _("[-- Autoview stderr of %s --]\n"), command);
1039         }
1040
1041         state_puts (s->prefix, s);
1042         state_puts (buffer, s);
1043         while (fgets (buffer, sizeof (buffer), fperr) != NULL) {
1044           state_puts (s->prefix, s);
1045           state_puts (buffer, s);
1046         }
1047       }
1048     } else {
1049       mutt_copy_stream (fpout, s->fpout);
1050       /* Check for stderr messages */
1051       if (fgets (buffer, sizeof (buffer), fperr)) {
1052         if (s->flags & M_DISPLAY) {
1053           state_mark_attach (s);
1054           state_printf (s, _("[-- Autoview stderr of %s --]\n"), command);
1055         }
1056
1057         state_puts (buffer, s);
1058         mutt_copy_stream (fperr, s->fpout);
1059       }
1060     }
1061
1062   bail:
1063     m_fclose(&fpout);
1064     m_fclose(&fperr);
1065
1066     mutt_wait_filter (thepid);
1067     if (piped)
1068       m_fclose(&fpin);
1069     else
1070       mutt_unlink (tempfile);
1071
1072     if (s->flags & M_DISPLAY)
1073       mutt_clear_error ();
1074   }
1075   rfc1524_entry_delete(&entry);
1076   return (rc);
1077 }
1078
1079 static int external_body_handler (BODY * b, STATE * s)
1080 {
1081   const char *access_type;
1082   const char *expiration;
1083   time_t expire;
1084
1085   access_type = parameter_getval(b->parameter, "access-type");
1086   if (!access_type) {
1087     if (s->flags & M_DISPLAY) {
1088       state_mark_attach (s);
1089       state_puts (_("[-- Error: message/external-body has no access-type parameter --]\n"), s);
1090     }
1091     return (-1);
1092   }
1093
1094   expiration = parameter_getval(b->parameter, "expiration");
1095   if (expiration)
1096     expire = mutt_parse_date (expiration, NULL);
1097   else
1098     expire = -1;
1099
1100   if (mime_which_token(access_type, -1) == MIME_X_MUTT_DELETED) {
1101     if (s->flags & (M_DISPLAY | M_PRINTING)) {
1102       char *length;
1103       char pretty_size[10];
1104
1105       state_mark_attach (s);
1106       state_printf (s, _("[-- This %s/%s attachment "),
1107                     TYPE (b->parts), b->parts->subtype);
1108       length = parameter_getval(b->parameter, "length");
1109       if (length) {
1110         mutt_pretty_size (pretty_size, sizeof (pretty_size),
1111                           strtol (length, NULL, 10));
1112         state_printf (s, _("(size %s bytes) "), pretty_size);
1113       }
1114       state_puts (_("has been deleted --]\n"), s);
1115
1116       if (expire != -1) {
1117         state_mark_attach (s);
1118         state_printf (s, _("[-- on %s --]\n"), expiration);
1119       }
1120       if (b->parts->filename) {
1121         state_mark_attach (s);
1122         state_printf (s, _("[-- name: %s --]\n"), b->parts->filename);
1123       }
1124
1125       mutt_copy_hdr (s->fpin, s->fpout, ftello (s->fpin), b->parts->offset,
1126                      (option (OPTWEED) ? (CH_WEED | CH_REORDER) : 0) |
1127                      CH_DECODE, NULL);
1128     }
1129   }
1130   else if (expiration && expire < time (NULL)) {
1131     if (s->flags & M_DISPLAY) {
1132       state_mark_attach (s);
1133       state_printf (s, _("[-- This %s/%s attachment is not included, --]\n"),
1134                     TYPE (b->parts), b->parts->subtype);
1135       state_attach_puts (_("[-- and the indicated external source has --]\n"
1136                            "[-- expired. --]\n"), s);
1137
1138       mutt_copy_hdr (s->fpin, s->fpout, ftello (s->fpin), b->parts->offset,
1139                      (option (OPTWEED) ? (CH_WEED | CH_REORDER) : 0) |
1140                      CH_DECODE, NULL);
1141     }
1142   } else {
1143     if (s->flags & M_DISPLAY) {
1144       state_mark_attach (s);
1145       state_printf (s,
1146                     _("[-- This %s/%s attachment is not included, --]\n"),
1147                     TYPE (b->parts), b->parts->subtype);
1148       state_mark_attach (s);
1149       state_printf (s,
1150                     _
1151                     ("[-- and the indicated access-type %s is unsupported --]\n"),
1152                     access_type);
1153       mutt_copy_hdr (s->fpin, s->fpout, ftello (s->fpin), b->parts->offset,
1154                      (option (OPTWEED) ? (CH_WEED | CH_REORDER) : 0) |
1155                      CH_DECODE, NULL);
1156     }
1157   }
1158   return (0);
1159 }
1160
1161 static void mutt_decode_base64(STATE *s, long len, int istext, iconv_t cd)
1162 {
1163   char buf[5];
1164   int c1, c2, c3, c4, ch, cr = 0, i;
1165   char bufi[BUFI_SIZE];
1166   ssize_t l = 0;
1167
1168   buf[4] = 0;
1169
1170   if (istext)
1171     state_set_prefix (s);
1172
1173   while (len > 0) {
1174     for (i = 0; i < 4 && len > 0; len--) {
1175       if ((ch = fgetc (s->fpin)) == EOF)
1176         break;
1177       if (base64val(ch) >= 0 || ch == '=')
1178         buf[i++] = ch;
1179     }
1180     if (i != 4) {
1181       break;
1182     }
1183
1184     c1 = base64val(buf[0]);
1185     c2 = base64val(buf[1]);
1186     ch = (c1 << 2) | (c2 >> 4);
1187
1188     if (cr && ch != '\n')
1189       bufi[l++] = '\r';
1190
1191     cr = 0;
1192
1193     if (istext && ch == '\r')
1194       cr = 1;
1195     else
1196       bufi[l++] = ch;
1197
1198     if (buf[2] == '=')
1199       break;
1200     c3 = base64val(buf[2]);
1201     ch = ((c2 & 0xf) << 4) | (c3 >> 2);
1202
1203     if (cr && ch != '\n')
1204       bufi[l++] = '\r';
1205
1206     cr = 0;
1207
1208     if (istext && ch == '\r')
1209       cr = 1;
1210     else
1211       bufi[l++] = ch;
1212
1213     if (buf[3] == '=')
1214       break;
1215     c4 = base64val(buf[3]);
1216     ch = ((c3 & 0x3) << 6) | c4;
1217
1218     if (cr && ch != '\n')
1219       bufi[l++] = '\r';
1220     cr = 0;
1221
1222     if (istext && ch == '\r')
1223       cr = 1;
1224     else
1225       bufi[l++] = ch;
1226
1227     if (l + 8 >= ssizeof (bufi))
1228       mutt_convert_to_state (cd, bufi, &l, s);
1229   }
1230
1231   if (cr)
1232     bufi[l++] = '\r';
1233
1234   mutt_convert_to_state (cd, bufi, &l, s);
1235   mutt_convert_to_state (cd, 0, 0, s);
1236
1237   state_reset_prefix (s);
1238 }
1239
1240 void mutt_decode_attachment (BODY * b, STATE * s)
1241 {
1242   int istext = mutt_is_text_part (b);
1243   iconv_t cd = MUTT_ICONV_ERROR;
1244
1245   Quotebuf[0] = '\0';
1246
1247   if (istext) {
1248     if (s->flags & M_CHARCONV) {
1249       const char *charset = parameter_getval(b->parameter, "charset");
1250
1251       if (!charset)
1252         charset = charset_getfirst(mod_cset.assumed_charset);
1253       if (charset && mod_cset.charset)
1254         cd = mutt_iconv_open (mod_cset.charset, charset, M_ICONV_HOOK_FROM);
1255     } else {
1256       if (b->file_charset)
1257         cd = mutt_iconv_open (mod_cset.charset, b->file_charset, M_ICONV_HOOK_FROM);
1258     }
1259   }
1260
1261   fseeko (s->fpin, b->offset, 0);
1262   switch (b->encoding) {
1263   case ENCQUOTEDPRINTABLE:
1264     mutt_decode_quoted(s, b->length,
1265                        istext || mutt_is_application_pgp(b), cd);
1266     break;
1267   case ENCBASE64:
1268     mutt_decode_base64(s, b->length,
1269                        istext || mutt_is_application_pgp(b), cd);
1270     break;
1271   case ENCUUENCODED:
1272     mutt_decode_uuencoded(s, b->length,
1273                           istext || mutt_is_application_pgp(b), cd);
1274     break;
1275   default:
1276     mutt_decode_xbit(s, b->length,
1277                      istext || mutt_is_application_pgp(b), cd);
1278     break;
1279   }
1280
1281   if (cd != MUTT_ICONV_ERROR)
1282     iconv_close (cd);
1283 }
1284
1285 int mutt_body_handler (BODY * b, STATE * s)
1286 {
1287   int decode = 0;
1288   int plaintext = 0;
1289   FILE *fp = NULL;
1290   char tempfile[_POSIX_PATH_MAX];
1291   handler_t handler = NULL;
1292   long tmpoffset = 0;
1293   ssize_t tmplength = 0;
1294   char type[STRING];
1295   int rc = 0;
1296
1297   int oflags = s->flags;
1298   int tok = mime_which_token(b->subtype, -1);
1299
1300   /* first determine which handler to use to process this part */
1301
1302   snprintf (type, sizeof (type), "%s/%s", TYPE (b), b->subtype);
1303   if (mutt_is_autoview (b, type)) {
1304     rfc1524_entry *entry = rfc1524_entry_new();
1305
1306     if (rfc1524_mailcap_lookup (b, type, entry, M_AUTOVIEW)) {
1307       handler = autoview_handler;
1308       s->flags &= ~M_CHARCONV;
1309     }
1310     rfc1524_entry_delete(&entry);
1311   }
1312   else if (b->type == TYPETEXT) {
1313     if (tok == MIME_PLAIN) {
1314       /* avoid copying this part twice since removing the transfer-encoding is
1315        * the only operation needed.
1316        */
1317       if (mutt_is_application_pgp (b))
1318         handler = crypt_pgp_application_pgp_handler;
1319       else
1320         if (!ascii_strcasecmp("flowed", parameter_getval(b->parameter, "format")))
1321           handler = rfc3676_handler;
1322       else
1323         plaintext = 1;
1324     }
1325     else if (tok == MIME_ENRICHED)
1326       handler = text_enriched_handler;
1327     else                        /* text body type without a handler */
1328       plaintext = 1;
1329   }
1330   else if (b->type == TYPEMESSAGE) {
1331     if (mutt_is_message_type (b))
1332       handler = message_handler;
1333     else if (tok == MIME_DELIVERY_STATUS)
1334       plaintext = 1;
1335     else if (tok == MIME_EXTERNAL_BODY)
1336       handler = external_body_handler;
1337   }
1338   else if (b->type == TYPEMULTIPART) {
1339     char *p;
1340
1341     if (tok == MIME_ALTERNATIVE)
1342       handler = alternative_handler;
1343     else if (tok == MIME_SIGNED) {
1344       p = parameter_getval(b->parameter, "protocol");
1345
1346       if (!p)
1347         mutt_error (_("Error: multipart/signed has no protocol."));
1348
1349       else if (s->flags & M_VERIFY)
1350         handler = mutt_signed_handler;
1351     }
1352     else if (tok == MIME_ENCRYPTED) {
1353       p = parameter_getval(b->parameter, "protocol");
1354
1355       if (!p)
1356         mutt_error(_("Error: multipart/encrypted has no protocol parameter!"));
1357       else if (mime_which_token(p, -1) == MIME_APPLICATION_PGP_ENCRYPTED)
1358         handler = crypt_pgp_encrypted_handler;
1359     }
1360
1361     if (!handler)
1362       handler = multipart_handler;
1363   }
1364   else if (b->type == TYPEAPPLICATION) {
1365     if (mutt_is_application_pgp (b))
1366       handler = crypt_pgp_application_pgp_handler;
1367     if (mutt_is_application_smime (b))
1368       handler = crypt_smime_application_smime_handler;
1369   }
1370
1371   if (plaintext || handler) {
1372     fseeko (s->fpin, b->offset, 0);
1373
1374     /* see if we need to decode this part before processing it */
1375     if (b->encoding == ENCBASE64 || b->encoding == ENCQUOTEDPRINTABLE
1376     ||  b->encoding == ENCUUENCODED || plaintext || mutt_is_text_part (b)) {
1377         /* text subtypes may require character set conversion even with 8bit
1378            encoding.  */
1379       int origType = b->type;
1380       char *savePrefix = NULL;
1381
1382       if (!plaintext) {
1383         /* decode to a tempfile, saving the original destination */
1384         fp = s->fpout;
1385         s->fpout = m_tempfile(tempfile, sizeof(tempfile), NONULL(mod_core.tmpdir), NULL);
1386         if (!s->fpout) {
1387           mutt_error _("Unable to open temporary file!");
1388           goto bail;
1389         }
1390         /* decoding the attachment changes the size and offset, so save a copy
1391          * of the "real" values now, and restore them after processing
1392          */
1393         tmplength = b->length;
1394         tmpoffset = b->offset;
1395
1396         /* if we are decoding binary bodies, we don't want to prefix each
1397          * line with the prefix or else the data will get corrupted.
1398          */
1399         savePrefix = s->prefix;
1400         s->prefix = NULL;
1401
1402         decode = 1;
1403       } else {
1404         b->type = TYPETEXT;
1405       }
1406
1407       mutt_decode_attachment (b, s);
1408
1409       if (decode) {
1410         b->length = ftello (s->fpout);
1411         b->offset = 0;
1412         m_fclose(&s->fpout);
1413
1414         /* restore final destination and substitute the tempfile for input */
1415         s->fpout = fp;
1416         fp = s->fpin;
1417         s->fpin = safe_fopen (tempfile, "r");
1418         unlink (tempfile);
1419
1420         /* restore the prefix */
1421         s->prefix = savePrefix;
1422       }
1423
1424       b->type = origType;
1425     }
1426
1427     /* process the (decoded) body part */
1428     if (handler) {
1429       rc = handler (b, s);
1430
1431       if (decode) {
1432         b->length = tmplength;
1433         b->offset = tmpoffset;
1434
1435         /* restore the original source stream */
1436         m_fclose(&s->fpin);
1437         s->fpin = fp;
1438       }
1439     }
1440   }
1441   else if (s->flags & M_DISPLAY) {
1442     state_mark_attach (s);
1443     state_printf (s, _("[-- %s/%s is unsupported "), TYPE (b), b->subtype);
1444     if (!option (OPTVIEWATTACH)) {
1445       if (km_expand_key
1446           (type, sizeof (type),
1447            km_find_func (MENU_PAGER, OP_VIEW_ATTACHMENTS)))
1448         fprintf (s->fpout, _("(use '%s' to view this part)"), type);
1449       else
1450         fputs (_("(need 'view-attachments' bound to key!)"), s->fpout);
1451     }
1452     fputs (" --]\n", s->fpout);
1453   }
1454
1455 bail:
1456   s->flags = oflags;
1457   return (rc);
1458 }