tests: Adjusted most of the tests to mmh.
[mmh] / uip / mhshowsbr.c
1 /*
2 ** mhshowsbr.c -- routines to display the contents of MIME messages
3 **
4 ** This code is Copyright (c) 2002, by the authors of nmh.  See the
5 ** COPYRIGHT file in the root directory of the nmh distribution for
6 ** complete copyright information.
7 */
8
9 #include <h/mh.h>
10 #include <fcntl.h>
11 #include <h/signals.h>
12 #include <errno.h>
13 #include <setjmp.h>
14 #include <signal.h>
15 #include <h/tws.h>
16 #include <h/mime.h>
17 #include <h/mhparse.h>
18 #include <h/utils.h>
19 #include <sys/wait.h>
20
21 extern int debugsw;
22
23 int nolist   = 0;
24 char *formsw = NULL;
25
26
27 /* mhparse.c */
28 int pidcheck(int);
29
30 /* mhmisc.c */
31 int part_ok(CT, int);
32 int type_ok(CT, int);
33 void content_error(char *, CT, char *, ...);
34 void flush_errors(void);
35
36 /* mhlistsbr.c */
37 int list_switch(CT, int, int, int);
38 int list_content(CT, int, int, int);
39
40 /*
41 ** prototypes
42 */
43 void show_all_messages(CT *);
44 int show_content_aux(CT, int, char *, char *);
45
46 /*
47 ** static prototypes
48 */
49 static void show_single_message(CT, char *);
50 static void DisplayMsgHeader(CT, char *);
51 static int show_switch(CT, int);
52 static int show_content(CT, int);
53 static int show_content_aux2(CT, int, char *, char *, int, int, int);
54 static int show_text(CT, int);
55 static int show_multi(CT, int);
56 static int show_multi_internal(CT, int);
57 static int show_multi_aux(CT, int, char *);
58 static int show_message_rfc822(CT, int);
59 static int show_partial(CT, int);
60 static int show_external(CT, int);
61
62
63 /*
64 ** Top level entry point to show/display a group of messages
65 */
66
67 void
68 show_all_messages(CT *cts)
69 {
70         CT ct, *ctp;
71
72         /*
73         ** If form is not specified, then get default form
74         ** for showing headers of MIME messages.
75         */
76         if (!formsw)
77                 formsw = getcpy(etcpath("mhl.headers"));
78
79         /*
80         ** If form is "mhl.null", suppress display of header.
81         */
82         if (strcmp(formsw, "mhl.null")==0)
83                 formsw = NULL;
84
85         for (ctp = cts; *ctp; ctp++) {
86                 ct = *ctp;
87
88                 if (!type_ok(ct, 1)) {  /* top-level type */
89                         continue;
90                 }
91                 if (cts[1]) {
92                         if (ctp != cts) {
93                                 printf("\n\n");
94                         }
95                         printf(">>> Message %s\n\n", ct->c_file);
96                 }
97                 show_single_message(ct, formsw);
98         }
99 }
100
101
102 /*
103 ** Entry point to show/display a single message
104 */
105
106 static void
107 show_single_message(CT ct, char *form)
108 {
109         /*
110         ** Allow user executable bit so that temporary directories created by
111         ** the viewer (e.g., lynx) are going to be accessible
112         */
113         umask(ct->c_umask & ~(0100));
114
115         /*
116         ** If you have a format file, then display
117         ** the message headers.
118         */
119         if (form)
120                 DisplayMsgHeader(ct, form);
121
122         /* Show the body of the message */
123         show_switch(ct, 0);
124
125         if (ct->c_fp) {
126                 fclose(ct->c_fp);
127                 ct->c_fp = NULL;
128         }
129         if (ct->c_ceclosefnx)
130                 (*ct->c_ceclosefnx) (ct);
131
132         flush_errors();
133 }
134
135
136 /*
137 ** Use mhl to show the header fields
138 */
139 static void
140 DisplayMsgHeader(CT ct, char *form)
141 {
142         pid_t child_id;
143         int vecp;
144         char *vec[8];
145
146         vecp = 0;
147         vec[vecp++] = "mhl";
148         vec[vecp++] = "-form";
149         vec[vecp++] = form;
150         vec[vecp++] = "-nobody";
151         vec[vecp++] = ct->c_file;
152         vec[vecp] = NULL;
153
154         fflush(stdout);
155
156         switch (child_id = fork()) {
157         case NOTOK:
158                 adios("fork", "unable to");
159                 /* NOTREACHED */
160
161         case OK:
162                 execvp("mhl", vec);
163                 fprintf(stderr, "unable to exec ");
164                 perror("mhl");
165                 _exit(-1);
166                 /* NOTREACHED */
167
168         default:
169                 pidcheck(pidwait(child_id, NOTOK));
170                 break;
171         }
172 }
173
174
175 /*
176 ** Switching routine.  Call the correct routine
177 ** based on content type.
178 */
179
180 static int
181 show_switch(CT ct, int alternate)
182 {
183         switch (ct->c_type) {
184         case CT_MULTIPART:
185                 return show_multi(ct, alternate);
186                 break;
187
188         case CT_MESSAGE:
189                 switch (ct->c_subtype) {
190                         case MESSAGE_PARTIAL:
191                                 return show_partial(ct, alternate);
192                                 break;
193
194                         case MESSAGE_EXTERNAL:
195                                 return show_external(ct, alternate);
196                                 break;
197
198                         case MESSAGE_RFC822:
199                         default:
200                                 return show_message_rfc822(ct, alternate);
201                                 break;
202                 }
203                 break;
204
205         case CT_TEXT:
206                 return show_text(ct, alternate);
207                 break;
208
209         case CT_AUDIO:
210         case CT_IMAGE:
211         case CT_VIDEO:
212         case CT_APPLICATION:
213                 return show_content(ct, alternate);
214                 break;
215
216         default:
217                 adios(NULL, "unknown content type %d", ct->c_type);
218                 break;
219         }
220
221         return 0;  /* NOT REACHED */
222 }
223
224
225 /*
226 ** Generic method for displaying content
227 */
228
229 static int
230 show_content(CT ct, int alternate)
231 {
232         char *cp, buffer[BUFSIZ];
233         CI ci = &ct->c_ctinfo;
234
235         /* Check for mhshow-show-type/subtype */
236         snprintf(buffer, sizeof(buffer), "mhshow-show-%s/%s",
237                                 ci->ci_type, ci->ci_subtype);
238         if ((cp = context_find(buffer)) && *cp != '\0')
239                 return show_content_aux(ct, alternate, cp, NULL);
240
241         /* Check for mhshow-show-type */
242         snprintf(buffer, sizeof(buffer), "mhshow-show-%s", ci->ci_type);
243         if ((cp = context_find(buffer)) && *cp != '\0')
244                 return show_content_aux(ct, alternate, cp, NULL);
245
246         if ((cp = ct->c_showproc))
247                 return show_content_aux(ct, alternate, cp, NULL);
248
249         /* complain if we are not a part of a multipart/alternative */
250         if (!alternate)
251                 return show_content_aux(ct, alternate, "%l", NULL);
252
253         return NOTOK;
254 }
255
256
257 /*
258 ** Parse the display string for displaying generic content
259 */
260 int
261 show_content_aux(CT ct, int alternate, char *cp, char *cracked)
262 {
263         int fd, len, buflen, quoted;
264         int xstdin, xlist;
265         char *bp, *pp, *file, buffer[BUFSIZ];
266         CI ci = &ct->c_ctinfo;
267
268         if (!ct->c_ceopenfnx) {
269                 if (!alternate)
270                         content_error(NULL, ct,
271                                         "don't know how to decode content");
272
273                 return NOTOK;
274         }
275
276         file = NULL;
277         if ((fd = (*ct->c_ceopenfnx) (ct, &file)) == NOTOK)
278                 return NOTOK;
279         if (ct->c_showproc && strcmp(ct->c_showproc, "true")==0)
280                 return (alternate ? DONE : OK);
281
282         xlist  = 0;
283         xstdin = 0;
284
285         if (cracked) {
286                 strncpy(buffer, cp, sizeof(buffer));
287                 goto got_command;
288         }
289
290         /* get buffer ready to go */
291         bp = buffer;
292         buflen = sizeof(buffer) - 1;
293         bp[0] = bp[buflen] = '\0';
294         quoted = 0;
295
296         /* Now parse display string */
297         for ( ; *cp && buflen > 0; cp++) {
298                 if (*cp == '%') {
299                         pp = bp;
300
301                         switch (*++cp) {
302                         case 'a':
303                                 /* insert parameters from Content-Type field */
304                                 {
305                                 char **ap, **ep;
306                                 char *s = "";
307
308                                 for (ap = ci->ci_attrs, ep = ci->ci_values;
309                                                 *ap; ap++, ep++) {
310                                         snprintf(bp, buflen, "%s%s=\"%s\"",
311                                                         s, *ap, *ep);
312                                         len = strlen(bp);
313                                         bp += len;
314                                         buflen -= len;
315                                         s = " ";
316                                 }
317                                 }
318                                 break;
319
320                         case 'c':
321                                 /* insert charset */
322                                 strncpy(bp, ct->c_charset ? ct->c_charset :
323                                                 "US-ASCII", buflen);
324                                 break;
325
326                         case 'd':
327                                 /* insert content description */
328                                 if (ct->c_descr) {
329                                         char *s;
330
331                                         s = trimcpy(ct->c_descr);
332                                         strncpy(bp, s, buflen);
333                                         free(s);
334                                 }
335                                 break;
336
337                         case 'F':
338                                 /* %f, and stdin is terminal not content */
339                                 xstdin = 1;
340                                 /* and fall... */
341
342                         case 'f':
343                                 /* insert filename containing content */
344                                 snprintf(bp, buflen, "'%s'", file);
345                                 /*
346                                 ** since we've quoted the file argument,
347                                 ** set things up to look past it, to avoid
348                                 ** problems with the quoting logic below.
349                                 ** (I know, I should figure out what's
350                                 ** broken with the quoting logic, but..)
351                                 */
352                                 len = strlen(bp);
353                                 buflen -= len;
354                                 bp += len;
355                                 pp = bp;
356                                 break;
357
358                         case 'l':
359                                 /*
360                                 ** display listing prior to displaying content
361                                 */
362                                 xlist = !nolist;
363                                 break;
364
365                         case 's':
366                                 /* insert subtype of content */
367                                 strncpy(bp, ci->ci_subtype, buflen);
368                                 break;
369
370                         case '%':
371                                 /* insert character % */
372                                 goto raw;
373
374                         default:
375                                 *bp++ = *--cp;
376                                 *bp = '\0';
377                                 buflen--;
378                                 continue;
379                         }
380                         len = strlen(bp);
381                         bp += len;
382                         buflen -= len;
383
384                         /* Did we actually insert something? */
385                         if (bp != pp) {
386                                 /*
387                                 ** Insert single quote if not inside quotes
388                                 ** already
389                                 */
390                                 if (!quoted && buflen) {
391                                         len = strlen(pp);
392                                         memmove(pp + 1, pp, len);
393                                         *pp++ = '\'';
394                                         buflen--;
395                                         bp++;
396                                 }
397                                 /* Escape existing quotes */
398                                 while ((pp = strchr(pp, '\'')) && buflen > 3) {
399                                         len = strlen(pp++);
400                                         memmove(pp + 3, pp, len);
401                                         *pp++ = '\\';
402                                         *pp++ = '\'';
403                                         *pp++ = '\'';
404                                         buflen -= 3;
405                                         bp += 3;
406                                 }
407                                 /*
408                                 ** If pp is still set, that means we ran
409                                 ** out of space.
410                                 */
411                                 if (pp)
412                                         buflen = 0;
413                                 if (!quoted && buflen) {
414                                         *bp++ = '\'';
415                                         *bp = '\0';
416                                         buflen--;
417                                 }
418                         }
419                 } else {
420 raw:
421                         *bp++ = *cp;
422                         *bp = '\0';
423                         buflen--;
424
425                         if (*cp == '\'')
426                                 quoted = !quoted;
427                 }
428         }
429
430 got_command:
431         return show_content_aux2(ct, alternate, cracked, buffer,
432                         fd, xlist, xstdin);
433 }
434
435
436 /*
437 ** Routine to actually display the content
438 */
439 static int
440 show_content_aux2(CT ct, int alternate, char *cracked,
441         char *buffer, int fd, int xlist, int xstdin)
442 {
443         pid_t child_id;
444
445         if (debugsw || cracked) {
446                 fflush(stdout);
447
448                 fprintf(stderr, "%s msg %s", cracked ? "storing" : "show",
449                                  ct->c_file);
450                 if (ct->c_partno)
451                         fprintf(stderr, " part %s", ct->c_partno);
452                 if (cracked)
453                         fprintf(stderr, " using command (cd %s; %s)\n",
454                                         cracked, buffer);
455                 else
456                         fprintf(stderr, " using command %s\n", buffer);
457         }
458
459         if (xlist) {
460                 if (ct->c_type == CT_MULTIPART)
461                         list_content(ct, -1, 0, 0);
462                 else
463                         list_switch(ct, -1, 0, 0);
464         }
465
466         fflush(stdout);
467
468         switch (child_id = fork()) {
469         case NOTOK:
470                 advise("fork", "unable to");
471                 (*ct->c_ceclosefnx) (ct);
472                 return NOTOK;
473
474         case OK:
475                 if (cracked)
476                         chdir(cracked);
477                 if (!xstdin)
478                         dup2(fd, 0);
479                 close(fd);
480                 execlp("/bin/sh", "/bin/sh", "-c", buffer, NULL);
481                 fprintf(stderr, "unable to exec ");
482                 perror("/bin/sh");
483                 _exit(-1);
484                 /* NOTREACHED */
485
486         default:
487                 pidcheck(pidXwait(child_id, NULL));
488
489                 if (fd != NOTOK)
490                         (*ct->c_ceclosefnx) (ct);
491                 return (alternate ? DONE : OK);
492         }
493 }
494
495
496 /*
497 ** show content of type "text"
498 */
499
500 static int
501 show_text(CT ct, int alternate)
502 {
503         char *cp, buffer[BUFSIZ];
504         CI ci = &ct->c_ctinfo;
505
506         /* Check for mhshow-show-type/subtype */
507         snprintf(buffer, sizeof(buffer), "mhshow-show-%s/%s",
508                         ci->ci_type, ci->ci_subtype);
509         if ((cp = context_find(buffer)) && *cp != '\0')
510                 return show_content_aux(ct, alternate, cp, NULL);
511
512         /* Check for mhshow-show-type */
513         snprintf(buffer, sizeof(buffer), "mhshow-show-%s", ci->ci_type);
514         if ((cp = context_find(buffer)) && *cp != '\0')
515                 return show_content_aux(ct, alternate, cp, NULL);
516
517         /*
518         ** Use default method if content is text/plain, or if
519         ** if it is not a text part of a multipart/alternative
520         */
521         if (!alternate || ct->c_subtype == TEXT_PLAIN) {
522                 if (ct->c_charset && !is_native_charset(ct->c_charset)) {
523                         snprintf(buffer, sizeof(buffer), "%%liconv -f '%s'",
524                                         ct->c_charset);
525                 } else {
526                         snprintf(buffer, sizeof(buffer), "%%lcat");
527                 }
528                 ct->c_showproc = getcpy(buffer);
529                 return show_content_aux(ct, alternate, ct->c_showproc, NULL);
530         }
531
532         return NOTOK;
533 }
534
535
536 /*
537 ** show message body of type "multipart"
538 */
539
540 static int
541 show_multi(CT ct, int alternate)
542 {
543         char *cp, buffer[BUFSIZ];
544         CI ci = &ct->c_ctinfo;
545
546         /* Check for mhshow-show-type/subtype */
547         snprintf(buffer, sizeof(buffer), "mhshow-show-%s/%s",
548                         ci->ci_type, ci->ci_subtype);
549         if ((cp = context_find(buffer)) && *cp != '\0')
550                 return show_multi_aux(ct, alternate, cp);
551
552         /* Check for mhshow-show-type */
553         snprintf(buffer, sizeof(buffer), "mhshow-show-%s", ci->ci_type);
554         if ((cp = context_find(buffer)) && *cp != '\0')
555                 return show_multi_aux(ct, alternate, cp);
556
557         if ((cp = ct->c_showproc))
558                 return show_multi_aux(ct, alternate, cp);
559
560         /*
561         ** Use default method to display this multipart content
562         ** if it is not a (nested) part of a multipart/alternative,
563         ** or if it is one of the known subtypes of multipart.
564         */
565         if (!alternate || ct->c_subtype != MULTI_UNKNOWN)
566                 return show_multi_internal(ct, alternate);
567
568         return NOTOK;
569 }
570
571
572 /*
573 ** show message body of subtypes of multipart that
574 ** we understand directly (mixed, alternate, etc...)
575 */
576
577 static int
578 show_multi_internal(CT ct, int alternate)
579 {
580         int alternating, nowalternate, result;
581         struct multipart *m = (struct multipart *) ct->c_ctparams;
582         struct part *part;
583         CT p;
584
585         alternating = 0;
586         nowalternate = alternate;
587
588         if (ct->c_subtype == MULTI_ALTERNATE) {
589                 nowalternate = 1;
590                 alternating  = 1;
591         }
592
593         /*
594         ** Other possible multipart types are:
595         ** - multipart/parallel
596         ** - multipart/mixed
597         ** - multipart/digest
598         ** - unknown subtypes of multipart (treat as mixed per rfc2046)
599         */
600
601         /*
602         ** alternate   -> we are a part inside an multipart/alternative
603         ** alternating -> we are a multipart/alternative
604         */
605
606         result = alternate ? NOTOK : OK;
607
608         for (part = m->mp_parts; part; part = part->mp_next) {
609                 p = part->mp_part;
610
611                 if (part_ok(p, 1) && type_ok(p, 1)) {
612                         int inneresult;
613
614                         inneresult = show_switch(p, nowalternate);
615                         switch (inneresult) {
616                         case NOTOK:
617                                 if (alternate && !alternating) {
618                                         result = NOTOK;
619                                         goto out;
620                                 }
621                                 continue;
622
623                         case OK:
624                         case DONE:
625                                 if (alternating) {
626                                         result = DONE;
627                                         break;
628                                 }
629                                 if (alternate) {
630                                         alternate = nowalternate = 0;
631                                         if (result == NOTOK)
632                                                 result = inneresult;
633                                 }
634                                 continue;
635                         }
636                         break;
637                 }
638         }
639
640         if (alternating && !part) {
641                 if (!alternate)
642                         content_error(NULL, ct, "don't know how to display any of the contents");
643                 result = NOTOK;
644                 goto out;
645         }
646 out:
647         return result;
648 }
649
650
651 /*
652 ** Parse display string for multipart content
653 ** and use external program to display it.
654 */
655
656 static int
657 show_multi_aux(CT ct, int alternate, char *cp)
658 {
659         int len, buflen, quoted;
660         int xlist;
661         char *bp, *pp, *file, buffer[BUFSIZ];
662         struct multipart *m = (struct multipart *) ct->c_ctparams;
663         struct part *part;
664         CI ci = &ct->c_ctinfo;
665         CT p;
666
667         for (part = m->mp_parts; part; part = part->mp_next) {
668                 p = part->mp_part;
669
670                 if (!p->c_ceopenfnx) {
671                         if (!alternate)
672                                 content_error(NULL, p, "don't know how to decode content");
673                         return NOTOK;
674                 }
675
676                 if (p->c_storage == NULL) {
677                         file = NULL;
678                         if ((*p->c_ceopenfnx) (p, &file) == NOTOK)
679                                 return NOTOK;
680
681                         /* I'm not sure if this is necessary? */
682                         p->c_storage = getcpy(file);
683
684                         if (p->c_showproc && strcmp(p->c_showproc, "true")==0)
685                                 return (alternate ? DONE : OK);
686                         (*p->c_ceclosefnx) (p);
687                 }
688         }
689
690         xlist = 0;
691
692         /* get buffer ready to go */
693         bp = buffer;
694         buflen = sizeof(buffer) - 1;
695         bp[0] = bp[buflen] = '\0';
696         quoted = 0;
697
698         /* Now parse display string */
699         for ( ; *cp && buflen > 0; cp++) {
700                 if (*cp == '%') {
701                         pp = bp;
702                         switch (*++cp) {
703                         case 'a':
704                                 /* insert parameters from Content-Type field */
705                                 {
706                                 char **ap, **ep;
707                                 char *s = "";
708
709                                 for (ap = ci->ci_attrs, ep = ci->ci_values;
710                                                 *ap; ap++, ep++) {
711                                         snprintf(bp, buflen, "%s%s=\"%s\"",
712                                                         s, *ap, *ep);
713                                         len = strlen(bp);
714                                         bp += len;
715                                         buflen -= len;
716                                         s = " ";
717                                 }
718                                 }
719                                 break;
720
721                         case 'c':
722                                 /* insert charset */
723                                 strncpy(bp, ct->c_charset ? ct->c_charset :
724                                                 "US-ASCII", buflen);
725                                 break;
726
727                         case 'd':
728                                 /* insert content description */
729                                 if (ct->c_descr) {
730                                         char *s;
731
732                                         s = trimcpy(ct->c_descr);
733                                         strncpy(bp, s, buflen);
734                                         free(s);
735                                 }
736                                 break;
737
738                         case 'F':
739                         case 'f':
740                                 /* insert filename(s) containing content */
741                         {
742                                 char *s = "";
743
744                                 for (part = m->mp_parts; part;
745                                                 part = part->mp_next) {
746                                         p = part->mp_part;
747
748                                         snprintf(bp, buflen, "%s'%s'",
749                                                         s, p->c_storage);
750                                         len = strlen(bp);
751                                         bp += len;
752                                         buflen -= len;
753                                         s = " ";
754                                 }
755                                 /*
756                                 ** set our starting pointer back to bp,
757                                 ** to avoid requoting the filenames we
758                                 ** just added
759                                 */
760                                 pp = bp;
761                         }
762                         break;
763
764                         case 'l':
765                                 /*
766                                 ** display listing prior to displaying content
767                                 */
768                                 xlist = !nolist;
769                                 break;
770
771                         case 's':
772                                 /* insert subtype of content */
773                                 strncpy(bp, ci->ci_subtype, buflen);
774                                 break;
775
776                         case '%':
777                                 /* insert character % */
778                                 goto raw;
779
780                         default:
781                                 *bp++ = *--cp;
782                                 *bp = '\0';
783                                 buflen--;
784                                 continue;
785                         }
786                         len = strlen(bp);
787                         bp += len;
788                         buflen -= len;
789
790                         /* Did we actually insert something? */
791                         if (bp != pp) {
792                                 /*
793                                 ** Insert single quote if not inside quotes
794                                 ** already
795                                 */
796                                 if (!quoted && buflen) {
797                                         len = strlen(pp);
798                                         memmove(pp + 1, pp, len);
799                                         *pp++ = '\'';
800                                         buflen--;
801                                         bp++;
802                                 }
803                                 /* Escape existing quotes */
804                                 while ((pp = strchr(pp, '\'')) && buflen > 3) {
805                                         len = strlen(pp++);
806                                         memmove(pp + 3, pp, len);
807                                         *pp++ = '\\';
808                                         *pp++ = '\'';
809                                         *pp++ = '\'';
810                                         buflen -= 3;
811                                         bp += 3;
812                                 }
813                                 /*
814                                 ** If pp is still set, that means we ran
815                                 ** out of space.
816                                 */
817                                 if (pp)
818                                         buflen = 0;
819                                 if (!quoted && buflen) {
820                                         *bp++ = '\'';
821                                         *bp = '\0';
822                                         buflen--;
823                                 }
824                         }
825                 } else {
826 raw:
827                         *bp++ = *cp;
828                         *bp = '\0';
829                         buflen--;
830
831                         if (*cp == '\'')
832                                 quoted = !quoted;
833                 }
834         }
835
836         return show_content_aux2(ct, alternate, NULL, buffer,
837                         NOTOK, xlist, 0);
838 }
839
840
841 /*
842 ** show content of type "message/rfc822"
843 */
844
845 static int
846 show_message_rfc822(CT ct, int alternate)
847 {
848         char *cp, buffer[BUFSIZ];
849         CI ci = &ct->c_ctinfo;
850
851         /* Check for mhshow-show-type/subtype */
852         snprintf(buffer, sizeof(buffer), "mhshow-show-%s/%s",
853                                 ci->ci_type, ci->ci_subtype);
854         if ((cp = context_find(buffer)) && *cp != '\0')
855                 return show_content_aux(ct, alternate, cp, NULL);
856
857         /* Check for mhshow-show-type */
858         snprintf(buffer, sizeof(buffer), "mhshow-show-%s", ci->ci_type);
859         if ((cp = context_find(buffer)) && *cp != '\0')
860                 return show_content_aux(ct, alternate, cp, NULL);
861
862         if ((cp = ct->c_showproc))
863                 return show_content_aux(ct, alternate, cp, NULL);
864
865         /* default method for message/rfc822 */
866         if (ct->c_subtype == MESSAGE_RFC822) {
867                 cp = (ct->c_showproc = getcpy("%lshow -file %F"));
868                 return show_content_aux(ct, alternate, cp, NULL);
869         }
870
871         /* complain if we are not a part of a multipart/alternative */
872         if (!alternate)
873                 return show_content_aux(ct, alternate, "%l", NULL);
874
875         return NOTOK;
876 }
877
878
879 /*
880 ** Show content of type "message/partial".
881 */
882
883 static int
884 show_partial(CT ct, int alternate)
885 {
886         show_content_aux(ct, alternate, "%l", NULL);
887         puts("in order to display this message, you must reassemble it");
888         return NOTOK;
889 }
890
891
892 /*
893 ** Show how to retrieve content of type "message/external".
894 */
895 static int
896 show_external(CT ct, int alternate)
897 {
898         char **ap, **ep;
899         char *msg;
900         FILE *fp;
901         char buf[BUFSIZ];
902
903         msg = add("You need to fetch the contents yourself:\n", NULL);
904         ap = ct->c_ctinfo.ci_attrs;
905         ep = ct->c_ctinfo.ci_values;
906         for (; *ap; ap++, ep++) {
907                 msg = add(concat("\t", *ap, ": ", *ep, NULL), msg);
908         }
909         if (!(fp = fopen(ct->c_file, "r"))) {
910                 adios(ct->c_file, "unable to open");
911         }
912         fseek(fp, ct->c_begin, SEEK_SET);
913         while (!feof(fp) && ftell(fp) < ct->c_end) {
914                 if (!fgets(buf, sizeof buf, fp)) {
915                         adios(ct->c_file, "unable to read");
916                 }
917                 *strchr(buf, '\n') = '\0';
918                 if (!*buf) {
919                         continue;  /* skip empty lines */
920                 }
921                 msg = add(concat("\t", buf, "\n", NULL), msg);
922         }
923         fclose(fp);
924         show_content_aux(ct, alternate, "%l", NULL);
925         fputs(msg, stdout);
926         return OK;
927 }