]> diplodocus.org Git - nmh/blob - docs/historical/mh-6.8.5/uip/RCS/mhn.c,v
projects / nmh / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
sbr/mts.c: Delete mmdlm2; use same-valued mmdlm1 instead.
[nmh] / docs / historical / mh-6.8.5 / uip / RCS / mhn.c,v
1 head 2.42;
2 access;
3 symbols;
4 locks; strict;
5 comment @ * @;
6
7
8 2.42
9 date 95.12.06.22.32.29; author jromine; state Exp;
10 branches;
11 next 2.41;
12
13 2.41
14 date 95.12.06.21.05.46; author jromine; state Exp;
15 branches;
16 next 2.40;
17
18 2.40
19 date 95.12.06.21.03.37; author jromine; state Exp;
20 branches;
21 next 2.39;
22
23 2.39
24 date 95.12.06.21.02.05; author jromine; state Exp;
25 branches;
26 next 2.38;
27
28 2.38
29 date 95.12.06.20.55.31; author jromine; state Exp;
30 branches;
31 next 2.37;
32
33 2.37
34 date 95.12.06.19.20.22; author jromine; state Exp;
35 branches;
36 next 2.36;
37
38 2.36
39 date 94.04.21.19.23.38; author jromine; state Exp;
40 branches;
41 next 2.35;
42
43 2.35
44 date 93.10.26.22.17.44; author jromine; state Exp;
45 branches;
46 next 2.34;
47
48 2.34
49 date 93.10.26.20.15.00; author jromine; state Exp;
50 branches;
51 next 2.33;
52
53 2.33
54 date 93.10.26.20.11.27; author jromine; state Exp;
55 branches;
56 next 2.32;
57
58 2.32
59 date 93.10.26.15.56.01; author jromine; state Exp;
60 branches;
61 next 2.31;
62
63 2.31
64 date 93.10.26.15.51.19; author jromine; state Exp;
65 branches;
66 next 2.30;
67
68 2.30
69 date 93.10.26.15.44.42; author jromine; state Exp;
70 branches;
71 next 2.29;
72
73 2.29
74 date 93.10.26.15.41.33; author jromine; state Exp;
75 branches;
76 next 2.28;
77
78 2.28
79 date 93.10.25.19.58.19; author jromine; state Exp;
80 branches;
81 next 2.27;
82
83 2.27
84 date 93.10.25.19.32.05; author jromine; state Exp;
85 branches;
86 next 2.26;
87
88 2.26
89 date 93.09.09.22.38.43; author jromine; state Exp;
90 branches;
91 next 2.25;
92
93 2.25
94 date 93.09.01.21.46.58; author jromine; state Exp;
95 branches;
96 next 2.24;
97
98 2.24
99 date 93.09.01.20.50.03; author jromine; state Exp;
100 branches;
101 next 2.23;
102
103 2.23
104 date 93.08.25.17.26.22; author jromine; state Exp;
105 branches;
106 next 2.22;
107
108 2.22
109 date 93.08.20.15.52.01; author jromine; state Exp;
110 branches;
111 next 2.21;
112
113 2.21
114 date 92.12.15.00.20.22; author jromine; state Exp;
115 branches;
116 next 2.20;
117
118 2.20
119 date 92.12.14.17.10.25; author jromine; state Exp;
120 branches;
121 next 2.19;
122
123 2.19
124 date 92.12.10.22.27.15; author jromine; state Exp;
125 branches;
126 next 2.18;
127
128 2.18
129 date 92.12.09.19.23.22; author jromine; state Exp;
130 branches;
131 next 2.17;
132
133 2.17
134 date 92.12.03.21.58.18; author jromine; state Exp;
135 branches;
136 next 2.16;
137
138 2.16
139 date 92.12.02.18.50.39; author jromine; state Exp;
140 branches;
141 next 2.15;
142
143 2.15
144 date 92.11.24.18.21.54; author jromine; state Exp;
145 branches;
146 next 2.14;
147
148 2.14
149 date 92.11.24.17.18.52; author jromine; state Exp;
150 branches;
151 next 2.13;
152
153 2.13
154 date 92.11.24.17.18.04; author jromine; state Exp;
155 branches;
156 next 2.12;
157
158 2.12
159 date 92.11.23.19.07.08; author jromine; state Exp;
160 branches;
161 next 2.11;
162
163 2.11
164 date 92.11.23.19.05.18; author jromine; state Exp;
165 branches;
166 next 2.10;
167
168 2.10
169 date 92.11.23.19.04.27; author jromine; state Exp;
170 branches;
171 next 2.9;
172
173 2.9
174 date 92.11.11.17.57.04; author jromine; state Exp;
175 branches;
176 next 2.8;
177
178 2.8
179 date 92.11.09.17.46.01; author jromine; state Exp;
180 branches;
181 next 2.7;
182
183 2.7
184 date 92.11.09.17.45.19; author jromine; state Exp;
185 branches;
186 next 2.6;
187
188 2.6
189 date 92.11.06.03.24.40; author jromine; state Exp;
190 branches;
191 next 2.5;
192
193 2.5
194 date 92.11.04.00.47.59; author jromine; state Exp;
195 branches;
196 next 2.4;
197
198 2.4
199 date 92.11.02.17.01.08; author jromine; state Exp;
200 branches;
201 next 2.3;
202
203 2.3
204 date 92.10.26.16.58.47; author jromine; state Exp;
205 branches;
206 next 2.2;
207
208 2.2
209 date 92.10.20.20.30.08; author jromine; state Exp;
210 branches;
211 next 2.1;
212
213 2.1
214 date 92.10.20.16.26.29; author jromine; state Exp;
215 branches;
216 next 2.0;
217
218 2.0
219 date 92.10.20.16.24.21; author jromine; state Exp;
220 branches;
221 next 1.7;
222
223 1.7
224 date 92.05.19.21.01.53; author jromine; state Exp;
225 branches;
226 next 1.6;
227
228 1.6
229 date 92.03.03.17.13.54; author jromine; state Exp;
230 branches;
231 next 1.5;
232
233 1.5
234 date 92.02.18.17.36.22; author jromine; state Exp;
235 branches;
236 next 1.4;
237
238 1.4
239 date 92.02.14.16.22.17; author jromine; state Exp;
240 branches;
241 next 1.3;
242
243 1.3
244 date 92.02.07.16.07.46; author jromine; state Exp;
245 branches;
246 next 1.2;
247
248 1.2
249 date 92.02.07.03.44.12; author jromine; state Exp;
250 branches;
251 next 1.1;
252
253 1.1
254 date 92.01.31.16.28.15; author jromine; state Exp;
255 branches;
256 next ;
257
258
259 desc
260 @multimedia MH
261 @
262
263
264 2.42
265 log
266 @rename si_value for Solaris 2.x
267 @
268 text
269 @/* mhn.c - multi-media MH */
270 #ifndef lint
271 static char ident[] = "@@(#)$Id: mhn.c,v 2.41 1995/12/06 21:05:46 jromine Exp jromine $";
272 #endif /* lint */
273
274 #include "../h/mh.h"
275 #include <ctype.h>
276 #include <errno.h>
277 #include <setjmp.h>
278 #include <signal.h>
279 #include <stdio.h>
280 #include "../zotnet/mts.h"
281 #include <sys/types.h>
282 #include <sys/stat.h>
283 #ifdef BSD42
284 #include <sys/wait.h>
285 #endif
286 #ifdef LOCALE
287 #include <locale.h>
288 #endif
289
290 /* \f */
291
292 static struct swit switches[] = {
293 #define AUTOSW 0
294 "auto", 0,
295 #define NAUTOSW 1
296 "noauto", 0,
297
298 #define CACHESW 2
299 "cache", 0,
300 #define NCACHESW 3
301 "nocache", 0,
302
303 #define CHECKSW 4
304 "check", 0,
305 #define NCHECKSW 5
306 "nocheck", 0,
307
308 #define DEBUGSW 6
309 "debug", -5,
310
311 #define EBCDICSW 7
312 "ebcdicsafe", 0,
313 #define NEBCDICSW 8
314 "noebcdicsafe", 0,
315
316 #define FILESW 9 /* interface from show */
317 "file file", 0,
318
319 #define FORMSW 10
320 "form formfile", 4,
321
322 #define HEADSW 11
323 "headers", 0,
324 #define NHEADSW 12
325 "noheaders", 0,
326
327 #define LISTSW 13
328 "list", 0,
329 #define NLISTSW 14
330 "nolist", 0,
331
332 #define PARTSW 15
333 "part number", 0,
334
335 #define PAUSESW 16
336 "pause", 0,
337 #define NPAUSESW 17
338 "nopause", 0,
339
340 #define RCACHESW 18
341 "rcache policy", 0,
342
343 #define SIZESW 19
344 "realsize", 0,
345 #define NSIZESW 20
346 "norealsize", 0,
347
348 #define RFC934SW 21
349 "rfc934mode", 0,
350 #define NRFC934SW 22
351 "norfc934mode", 0,
352
353 #define SERIALSW 23
354 "serialonly", 0,
355 #define NSERIALSW 24
356 "noserialonly", 0,
357
358 #define SHOWSW 25
359 "show", 0,
360 #define NSHOWSW 26
361 "noshow", 0,
362
363 #define STORESW 27
364 "store", 0,
365 #define NSTORESW 28
366 "nostore", 0,
367
368 #define TYPESW 29
369 "type content", 0,
370
371 #define VERBSW 30
372 "verbose", 0,
373 #define NVERBSW 31
374 "noverbose", 0,
375
376 #define WCACHESW 32
377 "wcache policy", 0,
378
379 #define HELPSW 33
380 "help", 4,
381
382 #define PROGSW 34
383 "moreproc program", -4,
384 #define NPROGSW 35
385 "nomoreproc", -3,
386
387 #define LENSW 36
388 "length lines", -4,
389 #define WIDSW 37
390 "width columns", -4,
391
392 #define VIAMSW 38
393 "viamail mailpath", -7,
394 #define VIASSW 39
395 "viasubj subject", -7,
396 #define VIAPSW 40
397 "viaparm arguments", -7,
398 #define VIADSW 41
399 "viadesc text", -7,
400 #define VIACSW 42
401 "viacmnt text", -7,
402 #define VIAZSW 43
403 "viadelay seconds", -8,
404 #define VIAFSW 44
405 "viafrom mailpath", -7,
406
407 NULL, 0
408 };
409
410 /* \f */
411
412 #define NPARTS 50
413 #define NTYPES 20
414
415 static struct swit caches[] = {
416 #define CACHE_NEVER 0
417 "never", 0,
418 #define CACHE_PRIVATE 1
419 "private", 0,
420 #define CACHE_PUBLIC 2
421 "public", 0,
422 #define CACHE_ASK 3
423 "ask", 0,
424
425 NULL, 0
426 };
427
428 static int autosw = 0;
429 static int cachesw = 0;
430 static int checksw = 0;
431 int debugsw = 0;
432 static int ebcdicsw = 0;
433 static char *formsw = NULLCP;
434 static int headsw = 1;
435 static int listsw = 0;
436 static int nolist = 0;
437 static int nomore = 0;
438 static int npart = 0;
439 static char *parts[NPARTS + 1];
440 static int pausesw = 1;
441 static char *progsw = NULLCP;
442 static int rcachesw = CACHE_ASK;
443 static int rfc934sw = 1;
444 static int serialsw = 0;
445 static int showsw = 0;
446 static int sizesw = 1;
447 static int storesw = 0;
448 static int ntype = 0;
449 static char *types[NTYPES + 1];
450 int verbosw = 0;
451 static int wcachesw = CACHE_ASK;
452
453 static int endian = 0;
454 static char *mm_charset = NULL;
455
456 static int xpid = 0;
457 static int userrs = 0;
458
459 static char *cache_public;
460 static char *cache_private;
461 static int cwdlen;
462 static char *cwd;
463 static char *dir;
464 static char *errs = NULL;
465 static char *tmp;
466
467
468 extern int errno;
469 #ifndef BSD44
470 extern int sys_nerr;
471 extern char *sys_errlist[];
472 #endif
473
474 off_t lseek ();
475 time_t time ();
476
477 /* \f */
478
479 #define LSTFMT1 "%4s %-5s %-24s %5s %-36s\n"
480
481 #define LSTFMT2a "%4d "
482 #define LSTFMT2b "%-5s %-24.24s "
483 #define LSTFMT2c1 "%5lu"
484 #define LSTFMT2c2 "%4lu%c"
485 #define LSTFMT2c3 "huge "
486 #define LSTFMT2c4 " "
487 #define LSTFMT2d1 " %-36.36s"
488 #define LSTFMT2d2 "\t %-65.65s\n"
489
490 static void build_comp ();
491
492 typedef struct CTinfo {
493 char *ci_type;
494 char *ci_subtype;
495
496 #define NPARMS 10
497 char *ci_attrs[NPARMS + 2];
498 char *ci_values[NPARMS];
499
500 char *ci_comment;
501
502 char *ci_magic;
503 } CTInfo, *CI;
504 #define NULLCI ((CI) 0)
505
506 static int get_ctinfo ();
507 static int get_comment ();
508
509
510 typedef struct Content {
511 char *c_partno; /* within multipart content */
512
513 char *c_vrsn; /* Body-Version: */
514
515 char *c_ctline; /* Content-Type: */
516 CTInfo c_ctinfo;
517
518 int c_type; /* internal form */
519 #define CT_UNKNOWN 0x00
520 #define CT_APPLICATION 0x01
521 #define CT_AUDIO 0x02
522 #define CT_IMAGE 0x03
523 #define CT_MESSAGE 0x04
524 #define CT_MULTIPART 0x05
525 #define CT_TEXT 0x06
526 #define CT_VIDEO 0x07
527 #define CT_EXTENSION 0x08
528
529 int c_subtype; /* filled-in by c_ctinitfnx */
530 caddr_t c_ctparams; /* .. */
531 caddr_t c_ctextern; /* .. */
532 char *c_showproc; /* default, if not in profile */
533 char *c_termproc; /* for charset madness... */
534 char *c_storeproc; /* overrides profile entry, if any */
535
536 int (*c_ctinitfnx) (); /* parse content */
537 int (*c_ctlistfnx) (); /* list content */
538 int (*c_ctshowfnx) (); /* show content */
539 int (*c_ctstorefnx) (); /* store content */
540 int (*c_ctfreefnx) (); /* free content-specific structures */
541
542
543 char *c_celine; /* Content-Transfer-Encoding: */
544
545 int c_encoding; /* internal form */
546 #define CE_UNKNOWN 0x00
547 #define CE_BASE64 0x01
548 #define CE_QUOTED 0x02
549 #define CE_8BIT 0x03
550 #define CE_7BIT 0x04
551 #define CE_BINARY 0x05
552 #define CE_EXTENSION 0x06
553 #define CE_EXTERNAL 0x07 /* for external-body */
554
555 caddr_t c_ceparams; /* filled-in by encoding initfnx */
556
557 int (*c_ceopenfnx) (); /* get a stream to decoded contents */
558 int (*c_ceclosefnx) (); /* release stream */
559 int (*c_celistfnx) (); /* list decoding info */
560 unsigned long
561 (*c_cesizefnx) (); /* size of decoded contents */
562 int (*c_cefreefnx) (); /* free encoding-specific structures */
563
564
565 char *c_id; /* Content-ID: */
566 char *c_descr; /* Content-Description: */
567
568 int c_digested; /* Content-MD5: */
569 unsigned char c_digest[16]; /* .. */
570
571 FILE *c_fp; /* read contents (stream) */
572 char *c_file; /* read contents (file) */
573 int c_unlink; /* remove file when done? */
574 int c_umask; /* associated umask */
575 long c_begin; /* where content starts in file */
576 long c_end; /* .. ends */
577
578 int c_pid; /* process doing display */
579 char *c_storage; /* write contents (file) */
580
581 int c_rfc934; /* rfc934 compatibility */
582 } Content, *CT;
583 #define NULLCT ((CT) 0)
584
585 static CT get_content ();
586 static int list_content (), show_content (), store_content ();
587 static int cache_content ();
588 static int user_content (), compose_content (), output_content ();
589 static void free_content (), flush_errors (), set_id ();
590
591 #if defined(__STDC__) && defined(VSPRINTF)
592 static void content_error (char *, register CT, char *, ...);
593 #else
594 static void content_error ();
595 #endif
596
597 static int init_encoding (), type_ok (), copy_some_headers (), set_endian ();
598 static int make_intermediates ();
599 static int find_cache (), find_cache_aux (), find_cache_aux2 ();
600 static int write7Bit (), writeQuoted (), writeBase64 (), writeBase64aux ();
601 static int writeDigest (), readDigest ();
602 static int via_mail (), via_post (), pidcheck ();
603
604 static CT *cts = NULL;
605
606
607 #define quitser pipeser
608 static TYPESIG pipeser ();
609 static char *fgetstr ();
610
611 /* \f */
612
613 /* ARGSUSED */
614
615 main (argc, argv)
616 int argc;
617 char **argv;
618 {
619 int f6 = 0,
620 msgp = 0,
621 msgnum,
622 *icachesw;
623 char *cp,
624 *f1 = NULL,
625 *f2 = NULL,
626 *f3 = NULL,
627 *f4 = NULL,
628 *f5 = NULL,
629 *f7 = NULL,
630 *file = NULL,
631 *folder = NULL,
632 *maildir,
633 buf[100],
634 **ap,
635 **argp,
636 *arguments[MAXARGS],
637 *msgs[MAXARGS];
638 struct msgs *mp;
639 register CT ct,
640 *ctp;
641 FILE *fp;
642
643 #ifdef LOCALE
644 setlocale(LC_ALL, "");
645 #endif
646 invo_name = r1bindex (argv[0], '/');
647 if (argv[1] && uprf (argv[1], "-via"))
648 m_foil (NULLCP);
649 if ((cp = m_find (invo_name)) != NULL) {
650 ap = brkstring (cp = getcpy (cp), " ", "\n");
651 ap = copyip (ap, arguments);
652 }
653 else
654 ap = arguments;
655 (void) copyip (argv + 1, ap);
656 argp = arguments;
657
658 /* \f */
659
660 while (cp = *argp++) {
661 if (*cp == '-')
662 switch (smatch (++cp, switches)) {
663 case AMBIGSW:
664 ambigsw (cp, switches);
665 done (1);
666 case UNKWNSW:
667 adios (NULLCP, "-%s unknown", cp);
668 case HELPSW:
669 (void) sprintf (buf, "%s [+folder] [msgs] [switches]",
670 invo_name);
671 help (buf, switches);
672 done (1);
673
674 case AUTOSW:
675 autosw++;
676 continue;
677 case NAUTOSW:
678 autosw = 0;
679 continue;
680
681 case CACHESW:
682 cachesw++;
683 continue;
684 case NCACHESW:
685 cachesw = 0;
686 continue;
687
688 case RCACHESW:
689 icachesw = &rcachesw;
690 goto do_cache;
691 case WCACHESW:
692 icachesw = &wcachesw;
693 do_cache: ;
694 if (!(cp = *argp++) || *cp == '-')
695 adios (NULLCP, "missing argument to %s", argp[-2]);
696 switch (*icachesw = smatch (cp, caches)) {
697 case AMBIGSW:
698 ambigsw (cp, caches);
699 done (1);
700 case UNKWNSW:
701 adios (NULLCP, "%s unknown", cp);
702 default:
703 break;
704 }
705 continue;
706
707 case CHECKSW:
708 checksw++;
709 continue;
710 case NCHECKSW:
711 checksw = 0;
712 continue;
713
714 case DEBUGSW:
715 debugsw++;
716 continue;
717
718 case EBCDICSW:
719 ebcdicsw++;
720 continue;
721 case NEBCDICSW:
722 ebcdicsw = 0;
723 continue;
724
725 case FORMSW:
726 if (!(cp = *argp++) || *cp == '-')
727 adios (NULLCP, "missing argument to %s", argp[-2]);
728 if (formsw)
729 free (formsw);
730 formsw = getcpy (libpath (cp));
731 continue;
732
733 case HEADSW:
734 headsw++;
735 continue;
736 case NHEADSW:
737 headsw = 0;
738 continue;
739
740 case LISTSW:
741 listsw++;
742 continue;
743 case NLISTSW:
744 listsw = 0;
745 continue;
746
747 case PARTSW:
748 if (!(cp = *argp++) || *cp == '-')
749 adios (NULLCP, "missing argument to %s", argp[-2]);
750 if (npart >= NPARTS)
751 adios (NULLCP,
752 "too many parts (starting with %s), %d max",
753 cp, NPARTS);
754 parts[npart++] = cp;
755 continue;
756
757 case PAUSESW:
758 pausesw++;
759 continue;
760 case NPAUSESW:
761 pausesw = 0;
762 continue;
763
764 case RFC934SW:
765 rfc934sw++;
766 continue;
767 case NRFC934SW:
768 rfc934sw = 0;
769 continue;
770
771 case SERIALSW:
772 serialsw++;
773 continue;
774 case NSERIALSW:
775 serialsw = 0;
776 continue;
777
778 case SHOWSW:
779 showsw++;
780 continue;
781 case NSHOWSW:
782 showsw = 0;
783 continue;
784
785 case SIZESW:
786 sizesw++;
787 continue;
788 case NSIZESW:
789 sizesw = 0;
790 continue;
791
792 case STORESW:
793 storesw++;
794 continue;
795 case NSTORESW:
796 storesw = 0;
797 continue;
798
799 case TYPESW:
800 if (!(cp = *argp++) || *cp == '-')
801 adios (NULLCP, "missing argument to %s", argp[-2]);
802 if (ntype >= NTYPES)
803 adios (NULLCP,
804 "too many types (starting with %s), %d max",
805 cp, NTYPES);
806 types[ntype++] = cp;
807 continue;
808
809 case VERBSW:
810 verbosw++;
811 continue;
812 case NVERBSW:
813 verbosw = 0;
814 continue;
815
816 case PROGSW:
817 if (!(progsw = *argp++) || *progsw == '-')
818 adios (NULLCP, "missing argument to %s", argp[-2]);
819 continue;
820 case NPROGSW:
821 nomore++;
822 continue;
823
824 case LENSW:
825 case WIDSW:
826 if (!(cp = *argp++) || *cp == '-')
827 adios (NULLCP, "missing argument to %s", argp[-2]);
828 continue;
829
830 case FILESW:
831 if (!(cp = *argp++) || (*cp == '-' && cp[1]))
832 adios (NULLCP, "missing argument to %s", argp[-2]);
833 file = *cp == '-' ? cp : path (cp, TFILE);
834 continue;
835
836 case VIAMSW:
837 if (!(f1 = *argp++))
838 adios (NULLCP, "missing argument to %s", argp[-2]);
839 continue;
840 case VIASSW:
841 if (!(f2 = *argp++))
842 adios (NULLCP, "missing argument to %s", argp[-2]);
843 continue;
844 case VIAPSW:
845 if (!(f3 = *argp++))
846 adios (NULLCP, "missing argument to %s", argp[-2]);
847 continue;
848 case VIADSW:
849 if (!(f4 = *argp++))
850 adios (NULLCP, "missing argument to %s", argp[-2]);
851 continue;
852 case VIACSW:
853 if (!(f5 = *argp++))
854 adios (NULLCP, "missing argument to %s", argp[-2]);
855 continue;
856 case VIAZSW:
857 if (!(cp = *argp++) || *cp == '-')
858 adios (NULLCP, "missing argument to %s", argp[-2]);
859 if (sscanf (cp, "%d", &f6) != 1 || f6 < 0)
860 f6 = 300;
861 continue;
862 case VIAFSW:
863 if (!(f7 = *argp++))
864 adios (NULLCP, "missing argument to %s", argp[-2]);
865 continue;
866 }
867 if (*cp == '+' || *cp == '@@') {
868 if (folder)
869 adios (NULLCP, "only one folder at a time!");
870 else
871 folder = path (cp + 1, *cp == '+' ? TFOLDER : TSUBCWF);
872 }
873 else
874 msgs[msgp++] = cp;
875 }
876 parts[npart] = NULL, types[ntype] = NULL;
877 if (!formsw)
878 formsw = getcpy (libpath ("mhl.headers"));
879
880 set_endian ();
881
882 /* \f */
883
884 if (f1) {
885 via_mail (f1, f2, f3, f4, f5, f6, f7);
886 /* NOTREACHED */
887 }
888 else
889 if (f2 || f3 || f4 || f5 || f6 || f7)
890 adios (NULLCP, "missing -viamail \"mailpath\" switch");
891
892 if (cp = getenv ("MHN")) {
893 if (fp = fopen (cp, "r")) {
894 m_readefs ((struct node **) 0, fp, cp, 0);
895
896 (void) fclose (fp);
897 }
898 else
899 admonish ("", "unable to read $MHN profile (%s)", cp);
900 }
901 if (fp = fopen (cp = libpath ("mhn_defaults"), "r")) {
902 m_readefs ((struct node **) 0, fp, cp, 0);
903
904 (void) fclose (fp);
905 }
906
907 (void) sprintf (buf, "%s-cache", invo_name);
908 if ((cache_public = m_find (buf)) && *cache_public != '/')
909 cache_public = NULL;
910 (void) sprintf (buf, "%s-private-cache", invo_name);
911 if (!(cache_private = m_find (buf)))
912 cache_private = ".cache";
913 cache_private = getcpy (m_maildir (cache_private));
914
915 cwdlen = strlen (cwd = getcpy (pwd ()));
916 (void) sprintf (buf, "%s-storage", invo_name);
917 dir = getcpy ((cp = m_find (buf)) && *cp ? cp : cwd);
918 tmp = cp && *cp ? concat (cp, "/", invo_name, NULLCP)
919 : add (m_maildir (invo_name), NULLCP);
920
921 if (!m_find ("path"))
922 free (path ("./", TFOLDER));
923
924 if (msgp == 1
925 && !folder
926 && !npart
927 && !cachesw
928 && !showsw
929 && !storesw
930 && !ntype
931 && !file
932 && (cp = getenv ("mhdraft"))
933 && strcmp (cp, msgs[0]) == 0) {
934 build_comp (cp);
935 /* NOTREACHED */
936 }
937
938 if (file) {
939 int stdinP;
940
941 if (msgp)
942 adios (NULLCP, "only one file at a time!");
943
944 if ((cts = (CT *) calloc ((unsigned) 2, sizeof *cts)) == NULL)
945 adios (NULLCP, "out of memory");
946
947 ctp = cts;
948 if (stdinP = (strcmp (file, "-") == 0)) {
949 char buffer[BUFSIZ];
950
951 file = add (m_tmpfil (invo_name), NULLCP);
952
953 if ((fp = fopen (file, "w+")) == NULL)
954 adios (file, "unable to fopen for writing and reading");
955 (void) chmod (file, 0600);
956 while (fgets (buffer, sizeof buffer, stdin))
957 (void) fputs (buffer, fp);
958 (void) fflush (fp);
959
960 if (ferror (stdin)) {
961 (void) unlink (file);
962 adios ("stdin", "error reading");
963 }
964
965 if (ferror (fp)) {
966 (void) unlink (file);
967 adios (file, "error writing");
968 }
969
970 (void) fseek (fp, 0L, 0);
971 }
972 else
973 if ((fp = fopen (file, "r")) == NULL)
974 adios (file, "unable to read");
975
976 if (ct = get_content (fp, file, 1)) {
977 if (stdinP)
978 ct -> c_unlink = 1;
979
980 ct -> c_fp = NULL;
981 if (ct -> c_end == 0L) {
982 (void) fseek (fp, 0L, 2);
983 ct -> c_end = ftell (fp);
984 }
985 if (ct -> c_ctinitfnx && (*ct -> c_ctinitfnx) (ct) == NOTOK)
986 free_content (ct);
987 else
988 *ctp++ = ct;
989 }
990 else
991 advise (NULLCP, "unable to decode %s", file);
992
993 (void) fclose (fp);
994
995 mp = NULL;
996 goto go_to_it;
997 }
998
999 if (!msgp)
1000 msgs[msgp++] = "cur";
1001 if (!folder)
1002 folder = m_getfolder ();
1003 maildir = m_maildir (folder);
1004
1005 if (chdir (maildir) == NOTOK)
1006 adios (maildir, "unable to change directory to");
1007 if (!(mp = m_gmsg (folder)))
1008 adios (NULLCP, "unable to read folder %s", folder);
1009 if (mp -> hghmsg == 0)
1010 adios (NULLCP, "no messages in %s", folder);
1011
1012 for (msgnum = 0; msgnum < msgp; msgnum++)
1013 if (!m_convert (mp, msgs[msgnum]))
1014 done (1);
1015 m_setseq (mp);
1016
1017 if ((cts = (CT *) calloc ((unsigned) (mp -> numsel + 1), sizeof *cts))
1018 == NULL)
1019 adios (NULLCP, "out of memory");
1020
1021 ctp = cts;
1022 for (msgnum = mp -> lowsel; msgnum <= mp -> hghsel; msgnum++)
1023 if (mp -> msgstats[msgnum] & SELECTED) {
1024 char *msgnam;
1025
1026 if ((fp = fopen (msgnam = m_name (msgnum), "r")) == NULL)
1027 adios (msgnam, "unable to read message");
1028
1029 if (ct = get_content (fp, msgnam, 1)) {
1030 ct -> c_fp = NULL;
1031 if (ct -> c_end == 0L) {
1032 (void) fseek (fp, 0L, 2);
1033 ct -> c_end = ftell (fp);
1034 }
1035 if (ct -> c_ctinitfnx && (*ct -> c_ctinitfnx) (ct) == NOTOK)
1036 free_content (ct);
1037 else
1038 *ctp++ = ct;
1039 }
1040 else
1041 advise (NULLCP, "unable to decode message %s", msgnam);
1042
1043 (void) fclose (fp);
1044 }
1045
1046 go_to_it: ;
1047 if (!*cts)
1048 done (1);
1049
1050 if (!listsw && !showsw && !storesw && !cachesw)
1051 showsw++;
1052
1053 /* listsw && showsw -> user wants per-message listing,
1054 so delay until showsw processing
1055
1056 && storesw && sizesw -> evaluating size will cause more work,
1057 so delay until after storesw processing
1058 */
1059 userrs = 1;
1060 (void) signal (SIGQUIT, quitser);
1061 (void) signal (SIGPIPE, pipeser);
1062
1063 for (ctp = cts; ct = *ctp; ctp++)
1064 if (type_ok (ct, 1)
1065 && (ct -> c_ctlistfnx
1066 || ct -> c_ctstorefnx
1067 || ct -> c_ctshowfnx)) {
1068 struct stat st;
1069
1070 if (!ct -> c_umask)
1071 ct -> c_umask = ~(stat (ct -> c_file, &st) != NOTOK
1072 ? (st.st_mode & 0777) : m_gmprot ());
1073 }
1074
1075 if (listsw && !showsw && (!storesw || !sizesw)) {
1076 if (headsw)
1077 printf (LSTFMT1, "msg", "part", "type/subtype", "size",
1078 "description");
1079
1080 for (ctp = cts; ct = *ctp; ctp++)
1081 if (type_ok (ct, 1) && ct -> c_ctlistfnx) {
1082 (void) umask (ct -> c_umask);
1083 (void) (*ct -> c_ctlistfnx) (ct, 1);
1084 if (ct -> c_fp)
1085 (void) fclose (ct -> c_fp), ct -> c_fp = NULL;
1086 if (ct -> c_ceclosefnx)
1087 (*ct -> c_ceclosefnx) (ct);
1088 }
1089
1090 flush_errors ();
1091 }
1092
1093 if (storesw) {
1094 for (ctp = cts; ct = *ctp; ctp++)
1095 if (type_ok (ct, 1) && ct -> c_ctstorefnx) {
1096 (void) umask (ct -> c_umask);
1097 (void) (*ct -> c_ctstorefnx) (ct, NULLCP);
1098 if (ct -> c_fp)
1099 (void) fclose (ct -> c_fp), ct -> c_fp = NULL;
1100 if (ct -> c_ceclosefnx)
1101 (*ct -> c_ceclosefnx) (ct);
1102 }
1103
1104 flush_errors ();
1105 }
1106
1107 if (cachesw) {
1108 for (ctp = cts; ct = *ctp; ctp++)
1109 if (type_ok (ct, 1)) {
1110 cache_content (ct);
1111 if (ct -> c_fp)
1112 (void) fclose (ct -> c_fp), ct -> c_fp = NULL;
1113 if (ct -> c_ceclosefnx)
1114 (*ct -> c_ceclosefnx) (ct);
1115 }
1116
1117 flush_errors ();
1118 }
1119
1120 if (listsw && !showsw && storesw && sizesw) {
1121 if (headsw)
1122 printf (LSTFMT1, "msg", "part", "type/subtype", "size",
1123 "description");
1124
1125 for (ctp = cts; ct = *ctp; ctp++)
1126 if (type_ok (ct, 1) && ct -> c_ctlistfnx) {
1127 (void) umask (ct -> c_umask);
1128 (void) (*ct -> c_ctlistfnx) (ct, 1);
1129 if (ct -> c_fp)
1130 (void) fclose (ct -> c_fp), ct -> c_fp = NULL;
1131 if (ct -> c_ceclosefnx)
1132 (*ct -> c_ceclosefnx) (ct);
1133 }
1134
1135 flush_errors ();
1136 listsw = 0;
1137 }
1138
1139 if (showsw)
1140 for (ctp = cts; ct = *ctp; ctp++) {
1141 #if defined(BSD42) && !defined(WAITINT)
1142 union wait status;
1143 #else
1144 int status;
1145 #endif
1146 TYPESIG (*hstat) (), (*istat) (), (*qstat) (), (*tstat) ();
1147
1148 if (!type_ok (ct, 0))
1149 continue;
1150
1151 (void) umask (ct -> c_umask);
1152
1153 if (listsw) {
1154 if (headsw)
1155 printf (LSTFMT1, "msg", "part", "type/subtype", "size",
1156 "description");
1157
1158 if (ct -> c_ctlistfnx)
1159 (void) (*ct -> c_ctlistfnx) (ct, 1);
1160 }
1161
1162 if (!ct -> c_ctshowfnx) {
1163 if (ct -> c_fp)
1164 (void) fclose (ct -> c_fp), ct -> c_fp = NULL;
1165 if (ct -> c_ceclosefnx)
1166 (*ct -> c_ceclosefnx) (ct);
1167 continue;
1168 }
1169
1170 if (strcmp (formsw, "mhl.null")) {
1171 int child_id,
1172 i,
1173 vecp;
1174 char *vec[8];
1175
1176 vecp = 0;
1177 vec[vecp++] = r1bindex (mhlproc, '/');
1178 vec[vecp++] = "-form";
1179 vec[vecp++] = formsw;
1180 vec[vecp++] = "-nobody";
1181 vec[vecp++] = ct -> c_file;
1182 if (nomore)
1183 vec[vecp++] = "-nomoreproc";
1184 else
1185 if (progsw) {
1186 vec[vecp++] = "-moreproc";
1187 vec[vecp++] = progsw;
1188 }
1189 vec[vecp] = NULL;
1190
1191 (void) fflush (stdout);
1192
1193 for (i = 0; (child_id = vfork ()) == NOTOK && i < 5; i++)
1194 sleep (5);
1195 switch (child_id) {
1196 case NOTOK:
1197 adios ("fork", "unable to");
1198 /* NOTREACHED */
1199
1200 case OK:
1201 (void) execvp (mhlproc, vec);
1202 fprintf (stderr, "unable to exec ");
1203 perror (mhlproc);
1204 _exit (-1);
1205 /* NOTREACHED */
1206
1207 default:
1208 xpid = -child_id;
1209 break;
1210 }
1211 }
1212 else
1213 xpid = 0;
1214
1215 (void) (*ct -> c_ctshowfnx) (ct, 1, 0);
1216 if (ct -> c_fp)
1217 (void) fclose (ct -> c_fp), ct -> c_fp = NULL;
1218 if (ct -> c_ceclosefnx)
1219 (*ct -> c_ceclosefnx) (ct);
1220
1221 hstat = signal (SIGHUP, SIG_IGN);
1222 istat = signal (SIGINT, SIG_IGN);
1223 qstat = signal (SIGQUIT, SIG_IGN);
1224 tstat = signal (SIGTERM, SIG_IGN);
1225
1226 while (wait (&status) != NOTOK) {
1227 #if defined(BSD42) && !defined(WAITINT)
1228 (void) pidcheck (status.w_status);
1229 #else
1230 (void) pidcheck (status);
1231 #endif
1232 continue;
1233 }
1234
1235 (void) signal (SIGHUP, hstat);
1236 (void) signal (SIGINT, istat);
1237 (void) signal (SIGQUIT, qstat);
1238 (void) signal (SIGTERM, tstat);
1239
1240 xpid = 0;
1241
1242 flush_errors ();
1243 }
1244
1245 for (ctp = cts; *ctp; ctp++)
1246 free_content (*ctp);
1247 free ((char *) cts);
1248 cts = NULL;
1249
1250 if (mp) {
1251 m_replace (pfolder, folder);
1252 if (mp -> hghsel != mp -> curmsg)
1253 m_setcur (mp, mp -> hghsel);
1254 m_sync (mp);
1255 m_update ();
1256 }
1257
1258 done (0);
1259 /* NOTREACHED */
1260 }
1261
1262 /* \f */
1263
1264 static TYPESIG pipeser (i)
1265 int i;
1266 {
1267 if (i == SIGQUIT) {
1268 (void) unlink ("core");
1269
1270 (void) fflush (stdout);
1271
1272 fprintf (stderr, "\n");
1273 (void) fflush (stderr);
1274 }
1275
1276 done (1);
1277 /* NOTREACHED */
1278 }
1279
1280 /* \f */
1281
1282 #include "../h/mhn.h"
1283
1284
1285 struct str2init {
1286 char *si_key;
1287 int si_val;
1288 int (*si_init) ();
1289 };
1290
1291
1292 static int InitApplication (), InitMessage (), InitMultiPart (), InitText (),
1293 InitGeneric ();
1294
1295
1296 static struct str2init str2cts[] = {
1297 "application", CT_APPLICATION, InitApplication,
1298 "audio", CT_AUDIO, InitGeneric,
1299 "image", CT_IMAGE, InitGeneric,
1300 "message", CT_MESSAGE, InitMessage,
1301 "multipart", CT_MULTIPART, InitMultiPart,
1302 "text", CT_TEXT, InitText,
1303 "video", CT_VIDEO, InitGeneric,
1304
1305 NULL, CT_EXTENSION, NULL, /* these two must be last! */
1306 NULL, CT_UNKNOWN, NULL,
1307 };
1308
1309
1310 static int InitBase64 (), InitQuoted (), Init7Bit ();
1311
1312 static struct str2init str2ces[] = {
1313 "base64", CE_BASE64, InitBase64,
1314 "quoted-printable", CE_QUOTED, InitQuoted,
1315 "8bit", CE_8BIT, Init7Bit,
1316 "7bit", CE_7BIT, Init7Bit,
1317 "binary", CE_BINARY, NULL,
1318
1319 NULL, CE_EXTENSION, NULL, /* these two must be last! */
1320 NULL, CE_UNKNOWN, NULL,
1321 };
1322
1323 /* \f */
1324
1325 static CT get_content (in, file, toplevel)
1326 FILE *in;
1327 char *file;
1328 int toplevel;
1329 {
1330 int compnum,
1331 state;
1332 char buf[BUFSIZ],
1333 name[NAMESZ];
1334 register CT ct;
1335
1336 if ((ct = (CT) calloc (1, sizeof *ct)) == NULL)
1337 adios (NULLCP, "out of memory");
1338
1339 ct -> c_begin = ftell (ct -> c_fp = in) + 1;
1340 ct -> c_file = add (file, NULLCP);
1341 for (compnum = 1, state = FLD;;) {
1342 switch (state = m_getfld (state, name, buf, sizeof buf, in)) {
1343 case FLD:
1344 case FLDPLUS:
1345 case FLDEOF:
1346 compnum++;
1347
1348 if (uleq (name, VRSN_FIELD)) {
1349 int ucmp;
1350 char c,
1351 *cp,
1352 *dp;
1353
1354 cp = add (buf, NULLCP);
1355 while (state == FLDPLUS) {
1356 state = m_getfld (state, name, buf, sizeof buf, in);
1357 cp = add (buf, cp);
1358 }
1359
1360 if (ct -> c_vrsn) {
1361 /*
1362 advise (NULLCP,
1363 "message %s has multiple %s: fields (%s)",
1364 ct -> c_file, VRSN_FIELD, dp = trimcpy (cp));
1365 free (dp);
1366 */
1367 free (cp);
1368 /*
1369 goto out;
1370 */
1371 goto got_header;
1372 }
1373
1374 ct -> c_vrsn = cp;
1375 while (isspace (*cp))
1376 cp++;
1377 for (dp = index (cp, '\n'); dp; dp = index (dp, '\n'))
1378 *dp++ = ' ';
1379 for (dp = cp + strlen (cp) - 1; dp >= cp; dp--)
1380 if (!isspace (*dp))
1381 break;
1382 *++dp = '\0';
1383 if (debugsw)
1384 fprintf (stderr, "%s: %s\n", VRSN_FIELD, cp);
1385
1386 if (*cp == '(' && get_comment (ct, &cp, 0) == NOTOK)
1387 goto out;
1388
1389 for (dp = cp; istoken (*dp); dp++)
1390 continue;
1391 c = *dp, *dp = '\0';
1392 ucmp = uleq (cp, VRSN_VALUE);
1393 *dp = c;
1394 if (!ucmp)
1395 admonish (NULLCP,
1396 "message %s has unknown value for %s: field (%s)",
1397 ct -> c_file, VRSN_FIELD, cp);
1398 goto got_header;
1399 }
1400
1401 if (uleq (name, TYPE_FIELD)) {
1402 register char *cp;
1403 register struct str2init *s2i;
1404 register CI ci = &ct -> c_ctinfo;
1405
1406 cp = add (buf, NULLCP);
1407 while (state == FLDPLUS) {
1408 state = m_getfld (state, name, buf, sizeof buf, in);
1409 cp = add (buf, cp);
1410 }
1411
1412 if (ct -> c_ctline) {
1413 char *dp = trimcpy (cp);
1414
1415 advise (NULLCP,
1416 "message %s has multiple %s: fields (%s)",
1417 ct -> c_file, TYPE_FIELD, dp);
1418 free (dp);
1419 free (cp);
1420 goto out;
1421 }
1422
1423 if (get_ctinfo (cp, ct, 0) == NOTOK)
1424 goto out;
1425 for (s2i = str2cts; s2i -> si_key; s2i++)
1426 if (uleq (ci -> ci_type, s2i -> si_key))
1427 break;
1428 if (!s2i -> si_key && !uprf (ci -> ci_type, "X-"))
1429 s2i++;
1430 ct -> c_type = s2i -> si_val;
1431 ct -> c_ctinitfnx = s2i -> si_init;
1432 goto got_header;
1433 }
1434
1435 if (uleq (name, ENCODING_FIELD)) {
1436 register char *cp,
1437 *dp;
1438 char c;
1439 register struct str2init *s2i;
1440
1441 cp = add (buf, NULLCP);
1442 while (state == FLDPLUS) {
1443 state = m_getfld (state, name, buf, sizeof buf, in);
1444 cp = add (buf, cp);
1445 }
1446
1447 if (ct -> c_celine) {
1448 advise (NULLCP,
1449 "message %s has multiple %s: fields (%s)",
1450 ct -> c_file, ENCODING_FIELD,
1451 dp = trimcpy (cp));
1452 free (dp);
1453 free (cp);
1454 goto out;
1455 }
1456
1457 ct -> c_celine = cp;
1458 while (isspace (*cp))
1459 cp++;
1460 for (dp = cp; istoken (*dp); dp++)
1461 continue;
1462 c = *dp, *dp = '\0';
1463 for (s2i = str2ces; s2i -> si_key; s2i++)
1464 if (uleq (cp, s2i -> si_key))
1465 break;
1466 if (!s2i -> si_key && !uprf (cp, "X-"))
1467 s2i++;
1468 *dp = c;
1469 ct -> c_encoding = s2i -> si_val;
1470 if (s2i -> si_init && (*s2i -> si_init) (ct) == NOTOK)
1471 goto out;
1472 goto got_header;
1473 }
1474
1475 if (uleq (name, ID_FIELD)) {
1476 ct -> c_id = add (buf, ct -> c_id);
1477 while (state == FLDPLUS) {
1478 state = m_getfld (state, name, buf, sizeof buf, in);
1479 ct -> c_id = add (buf, ct -> c_id);
1480 }
1481 goto got_header;
1482 }
1483
1484 if (uleq (name, DESCR_FIELD)) {
1485 ct -> c_descr = add (buf, ct -> c_descr);
1486 while (state == FLDPLUS) {
1487 state = m_getfld (state, name, buf, sizeof buf, in);
1488 ct -> c_descr = add (buf, ct -> c_descr);
1489 }
1490 goto got_header;
1491 }
1492
1493 if (uleq (name, MD5_FIELD)) {
1494 char *cp,
1495 *dp,
1496 *ep;
1497
1498 cp = add (buf, NULLCP);
1499 while (state == FLDPLUS) {
1500 state = m_getfld (state, name, buf, sizeof buf, in);
1501 cp = add (buf, cp);
1502 }
1503
1504 if (!checksw) {
1505 free (cp);
1506 goto got_header;
1507 }
1508
1509 if (ct -> c_digested) {
1510 advise (NULLCP,
1511 "message %s has multiple %s: fields (%s)",
1512 ct -> c_file, MD5_FIELD,
1513 dp = trimcpy (cp));
1514 free (dp);
1515 free (cp);
1516 goto out;
1517 }
1518
1519 ep = cp;
1520 while (isspace (*cp))
1521 cp++;
1522 for (dp = index (cp, '\n'); dp; dp = index (dp, '\n'))
1523 *dp++ = ' ';
1524 for (dp = cp + strlen (cp) - 1; dp >= cp; dp--)
1525 if (!isspace (*dp))
1526 break;
1527 *++dp = '\0';
1528 if (debugsw)
1529 fprintf (stderr, "%s: %s\n", MD5_FIELD, cp);
1530
1531 if (*cp == '(' && get_comment (ct, &cp, 0) == NOTOK) {
1532 free (ep);
1533 goto out;
1534 }
1535
1536 for (dp = cp; *dp && !isspace (*dp); dp++)
1537 continue;
1538 *dp = '\0';
1539
1540 (void) readDigest (ct, cp);
1541 free (ep);
1542 ct -> c_digested++;
1543 goto got_header;
1544 }
1545
1546 #ifdef notdef
1547 if (uprf (name, XXX_FIELD_PRF))
1548 advise (NULLCP, "unknown field (%s) in message %s",
1549 name, ct -> c_file);
1550 /* and fall... */
1551 #endif
1552
1553 while (state == FLDPLUS)
1554 state = m_getfld (state, name, buf, sizeof buf, in);
1555 got_header: ;
1556 if (state != FLDEOF) {
1557 ct -> c_begin = ftell (in) + 1;
1558 continue;
1559 }
1560 /* else fall... */
1561
1562 case BODY:
1563 case BODYEOF:
1564 ct -> c_begin = ftell (in) - strlen (buf);
1565 break;
1566
1567 case FILEEOF:
1568 ct -> c_begin = ftell (in);
1569 break;
1570
1571 case LENERR:
1572 case FMTERR:
1573 adios (NULLCP, "message format error in component #%d",
1574 compnum);
1575
1576 default:
1577 adios (NULLCP, "getfld() returned %d", state);
1578 }
1579 break;
1580 }
1581
1582 if (!ct -> c_ctline) {
1583 if (toplevel < 0) {
1584 if (get_ctinfo ("message/rfc822", ct, 0) == NOTOK)
1585 goto out;
1586 ct -> c_type = CT_MESSAGE;
1587 ct -> c_ctinitfnx = InitMessage;
1588 }
1589 else {
1590 if (get_ctinfo ("text/plain", ct, 0) == NOTOK)
1591 goto out;
1592 ct -> c_type = CT_TEXT;
1593 ct -> c_ctinitfnx = InitText;
1594 }
1595 }
1596 if (!ct -> c_ctlistfnx)
1597 ct -> c_ctlistfnx = list_content;
1598 if (!ct -> c_ctshowfnx)
1599 ct -> c_ctshowfnx = show_content;
1600 if (!ct -> c_ctstorefnx)
1601 ct -> c_ctstorefnx = store_content;
1602
1603 if (!ct -> c_celine) {
1604 ct -> c_encoding = CE_7BIT;
1605 (void) Init7Bit (ct);
1606 }
1607
1608 return ct;
1609
1610 out:
1611 free_content (ct);
1612 return NULLCT;
1613 }
1614
1615 /* \f */
1616
1617 static int get_ctinfo (cp, ct, magic)
1618 char *cp;
1619 register CT ct;
1620 int magic;
1621 {
1622 int i = strlen (invo_name) + 2;
1623 register char *dp,
1624 **ap,
1625 **ep;
1626 char c;
1627 register CI ci = &ct -> c_ctinfo;
1628
1629 cp = ct -> c_ctline = add (cp, NULLCP);
1630 while (isspace (*cp))
1631 cp++;
1632 for (dp = index (cp, '\n'); dp; dp = index (dp, '\n'))
1633 *dp++ = ' ';
1634 for (dp = cp + strlen (cp) - 1; dp >= cp; dp--)
1635 if (!isspace (*dp))
1636 break;
1637 *++dp = '\0';
1638 if (debugsw)
1639 fprintf (stderr, "%s: %s\n", TYPE_FIELD, cp);
1640
1641 if (*cp == '(' && get_comment (ct, &cp, 1) == NOTOK)
1642 return NOTOK;
1643
1644 for (dp = cp; istoken (*dp); dp++)
1645 continue;
1646 c = *dp, *dp = '\0';
1647 ci -> ci_type = add (cp, NULLCP);
1648 *dp = c, cp = dp;
1649
1650 if (!*ci -> ci_type) {
1651 advise (NULLCP, "invalid %s: field in message %s (empty type)",
1652 TYPE_FIELD, ct -> c_file);
1653 return NOTOK;
1654 }
1655
1656 for (dp = ci -> ci_type; *dp; dp++)
1657 if (isalpha(*dp) && isupper (*dp))
1658 *dp = tolower (*dp);
1659
1660 while (isspace (*cp))
1661 cp++;
1662
1663 if (*cp == '(' && get_comment (ct, &cp, 1) == NOTOK)
1664 return NOTOK;
1665
1666 if (*cp != '/') {
1667 if (!magic)
1668 ci -> ci_subtype = add ("", NULLCP);
1669 goto magic_skip;
1670 }
1671
1672 cp++;
1673 while (isspace (*cp))
1674 cp++;
1675
1676 if (*cp == '(' && get_comment (ct, &cp, 1) == NOTOK)
1677 return NOTOK;
1678
1679 for (dp = cp; istoken (*dp); dp++)
1680 continue;
1681 c = *dp, *dp = '\0';
1682 ci -> ci_subtype = add (cp, NULLCP);
1683 *dp = c, cp = dp;
1684
1685 if (!*ci -> ci_subtype) {
1686 advise (NULLCP,
1687 "invalid %s: field in message %s (empty subtype for \"%s\")",
1688 TYPE_FIELD, ct -> c_file, ci -> ci_type);
1689 return NOTOK;
1690 }
1691
1692 for (dp = ci -> ci_subtype; *dp; dp++)
1693 if (isalpha(*dp) && isupper (*dp))
1694 *dp = tolower (*dp);
1695
1696 magic_skip: ;
1697 while (isspace (*cp))
1698 cp++;
1699
1700 if (*cp == '(' && get_comment (ct, &cp, 1) == NOTOK)
1701 return NOTOK;
1702
1703 ep = (ap = ci -> ci_attrs) + NPARMS;
1704 while (*cp == ';') {
1705 char *vp,
1706 *up;
1707
1708 if (ap >= ep) {
1709 advise (NULLCP,
1710 "too many parameters in message %s's %s: field (%d max)",
1711 ct -> c_file, TYPE_FIELD, NPARMS);
1712 return NOTOK;
1713 }
1714
1715 cp++;
1716 while (isspace (*cp))
1717 cp++;
1718
1719 if (*cp == '(' && get_comment (ct, &cp, 1) == NOTOK)
1720 return NOTOK;
1721
1722 if (*cp == 0) {
1723 advise (NULLCP,
1724 "extraneous trailing ';' in message %s's %s: parameter list",
1725 ct -> c_file, TYPE_FIELD);
1726 return OK;
1727 }
1728
1729 for (dp = cp; istoken (*dp); dp++)
1730 if (isalpha(*dp) && isupper (*dp))
1731 *dp = tolower (*dp);
1732 for (up = dp; isspace (*dp); )
1733 dp++;
1734 if (dp == cp || *dp != '=') {
1735 advise (NULLCP,
1736 "invalid parameter in message %s's %s: field\n%*.*sparameter %s (error detected at offset %d)",
1737 ct -> c_file, TYPE_FIELD, i, i, "", cp, dp - cp);
1738 return NOTOK;
1739 }
1740
1741 vp = (*ap = add (cp, NULLCP)) + (up - cp);
1742 *vp = '\0';
1743 for (dp++; isspace (*dp); )
1744 dp++;
1745 ci -> ci_values[ap - ci -> ci_attrs] = vp = *ap + (dp - cp);
1746 if (*dp == '"') {
1747 for (cp = ++dp, dp = vp;;) {
1748 switch (c = *cp++) {
1749 case '\0':
1750 bad_quote: ;
1751 advise (NULLCP,
1752 "invalid quoted-string in message %s's %s: field\n%*.*s(parameter %s)",
1753 ct -> c_file, TYPE_FIELD, i, i, "", *ap);
1754 return NOTOK;
1755
1756 case '\\':
1757 *dp++ = c;
1758 if ((c = *cp++) == '\0')
1759 goto bad_quote;
1760 /* else fall... */
1761
1762 default:
1763 *dp++ = c;
1764 continue;
1765
1766 case '"':
1767 *dp = '\0';
1768 break;
1769 }
1770 break;
1771 }
1772 }
1773 else {
1774 for (cp = dp, dp = vp; istoken (*cp); cp++, dp++)
1775 continue;
1776 *dp = '\0';
1777 }
1778 if (!*vp) {
1779 advise (NULLCP,
1780 "invalid parameter in message %s's %s: field\n%*.*s(parameter %s)",
1781 ct -> c_file, TYPE_FIELD, i, i, "", *ap);
1782 return NOTOK;
1783 }
1784 ap++;
1785
1786 while (isspace (*cp))
1787 cp++;
1788
1789 if (*cp == '(' && get_comment (ct, &cp, 1) == NOTOK)
1790 return NOTOK;
1791 }
1792
1793 if (magic && *cp == '<') {
1794 if (ct -> c_id)
1795 free (ct -> c_id), ct -> c_id = NULL;
1796
1797 if (!(dp = index (ct -> c_id = ++cp, '>'))) {
1798 advise (NULLCP, "invalid ID in message %s", ct -> c_file);
1799 return NOTOK;
1800 }
1801
1802 c = *dp, *dp = '\0';
1803 if (*ct -> c_id)
1804 ct -> c_id = concat ("<", ct -> c_id, ">\n", NULLCP);
1805 else
1806 ct -> c_id = NULL;
1807 *dp++ = c, cp = dp;
1808
1809 while (isspace (*cp))
1810 cp++;
1811 }
1812
1813 if (magic && *cp == '[') {
1814 ct -> c_descr = ++cp;
1815 for (dp = cp + strlen (cp) - 1; dp >= cp; dp--)
1816 if (*dp == ']')
1817 break;
1818 if (dp < cp) {
1819 advise (NULLCP, "invalid description in message %s", ct -> c_file);
1820 ct -> c_descr = NULL;
1821 return NOTOK;
1822 }
1823
1824 c = *dp, *dp = '\0';
1825 if (*ct -> c_descr)
1826 ct -> c_descr = concat (ct -> c_descr, "\n", NULLCP);
1827 else
1828 ct -> c_descr = NULL;
1829 *dp++ = c, cp = dp;
1830
1831 while (isspace (*cp))
1832 cp++;
1833 }
1834
1835 if (*cp) {
1836 if (magic)
1837 ci -> ci_magic = add (cp, NULLCP);
1838 else
1839 advise (NULLCP,
1840 "extraneous information in message %s's %s: field\n%*.*s(%s)",
1841 ct -> c_file, TYPE_FIELD, i, i, "", cp);
1842 }
1843
1844 return OK;
1845 }
1846
1847 /* \f */
1848
1849 static int get_comment (ct, ap, istype)
1850 CT ct;
1851 char **ap;
1852 int istype;
1853 {
1854 register int i;
1855 register char *bp,
1856 *cp;
1857 char c,
1858 buffer[BUFSIZ],
1859 *dp;
1860 register CI ci = &ct -> c_ctinfo;
1861
1862 cp = *ap;
1863
1864 bp = buffer;
1865 cp++;
1866 for (i = 0;;) {
1867 switch (c = *cp++) {
1868 case '\0':
1869 invalid: ;
1870 advise (NULLCP, "invalid comment in message %s's %s: field",
1871 ct -> c_file, istype ? TYPE_FIELD : VRSN_FIELD);
1872 return NOTOK;
1873
1874 case '\\':
1875 *bp++ = c;
1876 if ((c = *cp++) == '\0')
1877 goto invalid;
1878 *bp++ = c;
1879 continue;
1880
1881 case '(':
1882 i++;
1883 /* and fall... */
1884 default:
1885 *bp++ = c;
1886 continue;
1887
1888 case ')':
1889 if (--i < 0)
1890 break;
1891 *bp++ = c;
1892 continue;
1893 }
1894 break;
1895 }
1896 *bp = '\0';
1897
1898 if (istype) {
1899 if (dp = ci -> ci_comment) {
1900 ci -> ci_comment = concat (dp, " ", buffer, NULLCP);
1901 free (dp);
1902 }
1903 else
1904 ci -> ci_comment = add (buffer, NULLCP);
1905 }
1906
1907 while (isspace (*cp))
1908 cp++;
1909
1910 *ap = cp;
1911
1912 return OK;
1913 }
1914
1915 /* \f */
1916
1917 #define empty(s) ((s) ? (s) : "")
1918
1919
1920 static int list_content (ct, toplevel)
1921 register CT ct;
1922 int toplevel;
1923 {
1924 unsigned long size;
1925 register char **ap,
1926 **ep;
1927 char *cp,
1928 buffer[BUFSIZ];
1929 register CI ci = &ct -> c_ctinfo;
1930
1931 printf (toplevel > 0 ? LSTFMT2a : toplevel < 0 ? "part " : " ",
1932 atoi (r1bindex (empty (ct -> c_file), '/')));
1933 (void) sprintf (buffer, "%s/%s", empty (ci -> ci_type),
1934 empty (ci -> ci_subtype));
1935 printf (LSTFMT2b, empty (ct -> c_partno), buffer);
1936
1937 size = ct -> c_cesizefnx && sizesw ? (*ct -> c_cesizefnx) (ct)
1938 : ct -> c_end - ct -> c_begin;
1939
1940 for (cp = " KMGT"; size > 9999; size >>= 10)
1941 if (!*++cp)
1942 break;
1943 switch (*cp) {
1944 case ' ':
1945 if (size > 0 || ct -> c_encoding != CE_EXTERNAL)
1946 printf (LSTFMT2c1, size);
1947 else
1948 printf (LSTFMT2c4);
1949 break;
1950
1951 default:
1952 printf (LSTFMT2c2, size, *cp);
1953 break;
1954
1955 case '\0':
1956 printf (LSTFMT2c3);
1957 }
1958
1959 if (ct -> c_descr) {
1960 char *dp;
1961
1962 dp = trimcpy (cp = add (ct -> c_descr, NULLCP));
1963 free (cp);
1964 printf (LSTFMT2d1, dp);
1965 free (dp);
1966 }
1967
1968 printf ("\n");
1969
1970 if (verbosw && ci -> ci_comment) {
1971 char *dp;
1972
1973 dp = trimcpy (cp = add (ci -> ci_comment, NULLCP));
1974 free (cp);
1975 (void) sprintf (buffer, "(%s)", dp);
1976 free (dp);
1977 printf (LSTFMT2d2, buffer);
1978 }
1979
1980 if (!debugsw)
1981 return OK;
1982
1983 (void) fflush (stdout);
1984
1985 fprintf (stderr, " partno \"%s\"\n", empty (ct -> c_partno));
1986
1987 if (ct -> c_vrsn)
1988 fprintf (stderr, " %s:%s\n", VRSN_FIELD, ct -> c_vrsn);
1989
1990 if (ct -> c_ctline)
1991 fprintf (stderr, " %s:%s", TYPE_FIELD, ct -> c_ctline);
1992 fprintf (stderr,
1993 " type \"%s\" subtype \"%s\" comment \"%s\" magic \"%s\"\n",
1994 empty (ci -> ci_type), empty (ci -> ci_subtype),
1995 empty (ci -> ci_comment), empty (ci -> ci_magic));
1996 for (ap = ci -> ci_attrs, ep = ci -> ci_values; *ap; ap++, ep++)
1997 fprintf (stderr, " parameter %s=\"%s\"\n", *ap, *ep);
1998 fprintf (stderr,
1999 " type 0x%x subtype 0x%x params 0x%x\n",
2000 ct -> c_type, ct -> c_subtype, ct -> c_ctparams);
2001
2002 fprintf (stderr, " showproc \"%s\"\n", empty (ct -> c_showproc));
2003 fprintf (stderr, " termproc \"%s\"\n", empty (ct -> c_termproc));
2004 fprintf (stderr, " storeproc \"%s\"\n", empty (ct -> c_storeproc));
2005
2006 if (ct -> c_celine)
2007 fprintf (stderr, " %s:%s", ENCODING_FIELD, ct -> c_celine);
2008 fprintf (stderr, " encoding 0x%x params 0x%x\n",
2009 ct -> c_encoding, ct -> c_ceparams);
2010
2011 if (ct -> c_id)
2012 fprintf (stderr, " %s:%s", ID_FIELD, ct -> c_id);
2013 if (ct -> c_descr)
2014 fprintf (stderr, " %s:%s", DESCR_FIELD, ct -> c_descr);
2015
2016 fprintf (stderr, " fp 0x%x file \"%s\" begin %d end %d\n",
2017 ct -> c_fp, empty (ct -> c_file), ct -> c_begin, ct -> c_end);
2018
2019 if (ct -> c_celistfnx)
2020 (void) (*ct -> c_celistfnx) (ct);
2021
2022 return OK;
2023 }
2024 #undef empty
2025
2026 /* \f */
2027
2028 #ifdef VSPRINTF
2029 #ifdef __STDC__
2030 #include <stdarg.h>
2031 #else
2032 #include <varargs.h>
2033 #endif
2034 #endif
2035
2036 #ifdef VSPRINTF
2037 #ifdef __STDC__
2038 static void content_error (char *what, register CT ct, char *fmt, ...)
2039 #else
2040 static void content_error (va_alist)
2041 va_dcl
2042 #endif
2043 #else /* !VSPRINTF */
2044 /* VARARGS3 */
2045 static void content_error (what, ct, fmt, a, b, c, d, e, f)
2046 char *what,
2047 *fmt,
2048 *a,
2049 *b,
2050 *c,
2051 *d,
2052 *e,
2053 *f;
2054 register CT ct;
2055 #endif
2056 {
2057 #ifdef VSPRINTF
2058 va_list arglist;
2059 #endif
2060 #if defined(VSPRINTF) && !defined(__STDC__)
2061 char *what, *fmt;
2062 register CT ct;
2063 #endif
2064 int i;
2065 register char *bp;
2066 char buffer[BUFSIZ];
2067 register CI ci;
2068
2069 bp = buffer;
2070
2071 if (userrs && invo_name && *invo_name) {
2072 (void) sprintf (bp, "%s: ", invo_name);
2073 bp += strlen (bp);
2074 }
2075
2076 #ifdef VSPRINTF
2077 #ifdef __STDC__
2078 va_start (arglist, fmt);
2079 #else
2080 va_start (arglist);
2081 what = va_arg(arglist, char *);
2082 ct = va_arg(arglist, CT);
2083 fmt = va_arg(arglist, char *);
2084 #endif
2085 (void) vsprintf (bp, fmt, arglist);
2086 bp += strlen (bp);
2087 #else
2088 (void) sprintf (bp, fmt, a, b, c, d, e, f);
2089 bp += strlen (bp);
2090 #endif
2091 ci = &ct -> c_ctinfo;
2092
2093 if (what) {
2094 if (*what) {
2095 (void) sprintf (bp, " %s: ", what);
2096 bp += strlen (bp);
2097 }
2098
2099 if (errno > 0 && errno < sys_nerr)
2100 (void) sprintf (bp, "%s", sys_errlist[errno]);
2101 else
2102 (void) sprintf (bp, "Error %d", errno);
2103 bp += strlen (bp);
2104 }
2105
2106 i = strlen (invo_name) + 2;
2107 (void) sprintf (bp, "\n%*.*s(content %s/%s", i, i, "", ci -> ci_type,
2108 ci -> ci_subtype);
2109 bp += strlen (bp);
2110 if (ct -> c_file) {
2111 (void) sprintf (bp, " in message %s", ct -> c_file);
2112 bp += strlen (bp);
2113 if (ct -> c_partno) {
2114 (void) sprintf (bp, ", part %s", ct -> c_partno);
2115 bp += strlen (bp);
2116 }
2117 }
2118 (void) sprintf (bp, ")");
2119 bp += strlen (bp);
2120
2121 if (userrs) {
2122 *bp++ = '\n';
2123 *bp = '\0';
2124
2125 errs = add (buffer, errs);
2126 }
2127 else
2128 advise (NULLCP, "%s", buffer);
2129 }
2130
2131
2132 static void flush_errors ()
2133 {
2134 if (errs) {
2135 (void) fflush (stdout);
2136 fprintf (stderr, "%s", errs);
2137 free (errs);
2138 errs = NULL;
2139 }
2140 }
2141
2142 /* \f */
2143
2144 static jmp_buf intrenv;
2145
2146
2147 /* ARGSUSED */
2148
2149 static TYPESIG intrser (i)
2150 int i;
2151 {
2152 #ifdef BSD42
2153 (void) signal (SIGINT, intrser);
2154 #endif
2155
2156 (void) putchar ('\n');
2157
2158 longjmp (intrenv, DONE);
2159 }
2160
2161 /* \f */
2162
2163 static int show_content_aux (), show_content_aux2 ();
2164
2165
2166 static int show_content (ct, serial, alternate)
2167 register CT ct;
2168 int serial,
2169 alternate;
2170 {
2171 register char *cp;
2172 char buffer[BUFSIZ];
2173 register CI ci = &ct -> c_ctinfo;
2174
2175 (void) sprintf (buffer, "%s-show-%s/%s", invo_name, ci -> ci_type,
2176 ci -> ci_subtype);
2177 if ((cp = m_find (buffer)) == NULL || *cp == 0) {
2178 (void) sprintf (buffer, "%s-show-%s", invo_name, ci -> ci_type);
2179 if (((cp = m_find (buffer)) == NULL || *cp == 0)
2180 && (cp = ct -> c_showproc) == NULL) {
2181 if (!alternate)
2182 content_error (NULLCP, ct,
2183 "don't know how to display content");
2184
2185 return NOTOK;
2186 }
2187 }
2188
2189 return show_content_aux (ct, serial, alternate, cp, NULLCP);
2190 }
2191
2192
2193 static int show_content_aux (ct, serial, alternate, cp, cracked)
2194 register CT ct;
2195 int serial,
2196 alternate;
2197 register char *cp;
2198 char *cracked;
2199 {
2200 int fd,
2201 xlist,
2202 xpause,
2203 xstdin,
2204 xtty;
2205 register char *bp;
2206 char *file,
2207 buffer[BUFSIZ];
2208 register CI ci = &ct -> c_ctinfo;
2209
2210 if (!ct -> c_ceopenfnx) {
2211 if (!alternate)
2212 content_error (NULLCP, ct, "don't know how to decode content");
2213
2214 return NOTOK;
2215 }
2216
2217 file = NULL;
2218 if ((fd = (*ct -> c_ceopenfnx) (ct, &file)) == NOTOK)
2219 return NOTOK;
2220 if (ct -> c_showproc && strcmp (ct -> c_showproc, "true") == 0)
2221 return (alternate ? DONE : OK);
2222
2223 xlist = xpause = xstdin = xtty = 0;
2224 if (cracked) {
2225 (void) strcpy (buffer, cp);
2226 goto got_command;
2227 }
2228 buffer[0] = '\0';
2229 for (bp = buffer; *cp; cp++)
2230 if (*cp == '%') {
2231 switch (*++cp) {
2232 case 'a': /* additional arguments */
2233 {
2234 register char **ap,
2235 **ep;
2236 char *s = "";
2237
2238 for (ap = ci -> ci_attrs, ep = ci -> ci_values;
2239 *ap;
2240 ap++, ep++) {
2241 (void) sprintf (bp, "%s%s=\"%s\"", s, *ap, *ep);
2242 bp += strlen (bp);
2243 s = " ";
2244 }
2245 }
2246 break;
2247
2248 case 'd': /* content description */
2249 if (ct -> c_descr) {
2250 char *s;
2251
2252 (void) strcpy (bp, s = trimcpy (ct -> c_descr));
2253 free (s);
2254 }
2255 break;
2256
2257 case 'e': /* exclusive execution */
2258 xtty = 1;
2259 break;
2260
2261 case 'F': /* %e, %f, and stdin is terminal not content */
2262 xstdin = xtty = 1;
2263 /* and fall... */
2264 case 'f': /* filename */
2265 (void) sprintf (bp, "%s", file);
2266 break;
2267
2268 case 'p': /* pause prior to displaying content */
2269 xpause = pausesw;
2270 /* and fall... */
2271 case 'l': /* display listing prior to displaying
2272 content */
2273 xlist = !nolist;
2274 break;
2275
2276 case 's': /* subtype */
2277 (void) strcpy (bp, ci -> ci_subtype);
2278 break;
2279
2280 case '%':
2281 goto raw;
2282
2283 default:
2284 *bp++ = *--cp;
2285 *bp = '\0';
2286 continue;
2287 }
2288 bp += strlen (bp);
2289 }
2290 else {
2291 raw: ;
2292 *bp++ = *cp;
2293 *bp = '\0';
2294 }
2295 if (ct -> c_termproc) {
2296 char term[BUFSIZ];
2297
2298 (void) strcpy (term, buffer);
2299 (void) sprintf (buffer, ct -> c_termproc, term);
2300 }
2301
2302 got_command: ;
2303 return show_content_aux2 (ct, serial, alternate, cracked, buffer,
2304 fd, xlist, xpause, xstdin, xtty);
2305 }
2306
2307
2308 static int show_content_aux2 (ct, serial, alternate, cracked, buffer,
2309 fd, xlist, xpause, xstdin, xtty)
2310 register CT ct;
2311 int serial,
2312 alternate;
2313 char *cracked,
2314 *buffer;
2315 int fd,
2316 xlist,
2317 xpause,
2318 xstdin,
2319 xtty;
2320 {
2321 int child_id,
2322 i;
2323 char *vec[4],
2324 exec[BUFSIZ + sizeof "exec "];
2325 register CI ci = &ct -> c_ctinfo;
2326
2327 if (debugsw || cracked) {
2328 (void) fflush (stdout);
2329
2330 fprintf (stderr, "%s msg %s", cracked ? "storing" : "show",
2331 ct -> c_file);
2332 if (ct -> c_partno)
2333 fprintf (stderr, " part %s", ct -> c_partno);
2334 if (cracked)
2335 fprintf (stderr, " using command (cd %s; %s)\n", cracked, buffer);
2336 else
2337 fprintf (stderr, " using command %s\n", buffer);
2338 }
2339
2340 if (xpid < 0 || (xtty && xpid)) {
2341 if (xpid < 0)
2342 xpid = -xpid;
2343 (void) pidcheck (pidwait (xpid, NOTOK));
2344 xpid = 0;
2345 }
2346
2347 if (xlist) {
2348 char prompt[BUFSIZ];
2349
2350 if (ct -> c_ctlistfnx) {
2351 if (ct -> c_type == CT_MULTIPART)
2352 (void) list_content (ct, -1);
2353 else
2354 (*ct -> c_ctlistfnx) (ct, -1);
2355
2356 if (xpause && SOprintf ("Press <return> to show content..."))
2357 printf ("Press <return> to show content...");
2358 }
2359 else {
2360 register char *pp;
2361
2362 pp = prompt;
2363 if (ct -> c_descr) {
2364 (void) sprintf (pp, "%s (", ct -> c_descr);
2365 pp += strlen (pp);
2366 }
2367
2368 (void) sprintf (pp, "content %s/%s", ci -> ci_type,
2369 ci -> ci_subtype);
2370 pp += strlen (pp);
2371 if (ct -> c_file) {
2372 (void) sprintf (pp, " in message %s", ct -> c_file);
2373 pp += strlen (pp);
2374 if (ct -> c_partno) {
2375 (void) sprintf (pp, ", part %s", ct -> c_partno);
2376 pp += strlen (pp);
2377 }
2378 }
2379
2380 if (ct -> c_descr) {
2381 (void) sprintf (pp, ")");
2382 pp += strlen (pp);
2383 }
2384
2385 if (!xpause)
2386 printf ("%s\n", prompt);
2387 else
2388 if (SOprintf ("Press <return> to show %s...", prompt))
2389 printf ("Press <return> to show %s...", prompt);
2390 }
2391
2392 if (xpause) {
2393 int intr;
2394 TYPESIG (*istat) ();
2395
2396 istat = signal (SIGINT, intrser);
2397 if ((intr = setjmp (intrenv)) == OK) {
2398 (void) fflush (stdout);
2399 prompt[0] = 0;
2400 (void) read (fileno (stdout), prompt, sizeof prompt);
2401 }
2402 (void) signal (SIGINT, istat);
2403 if (intr != OK || prompt[0] == 'q') {
2404 (void) (*ct -> c_ceclosefnx) (ct);
2405 return (alternate ? DONE : NOTOK);
2406 }
2407 }
2408 }
2409
2410 (void) sprintf (exec, "exec %s", buffer);
2411
2412 vec[0] = "/bin/sh";
2413 vec[1] = "-c";
2414 vec[2] = exec;
2415 vec[3] = NULL;
2416
2417 (void) fflush (stdout);
2418
2419 for (i = 0; (child_id = vfork ()) == NOTOK && i < 5; i++)
2420 sleep (5);
2421 switch (child_id) {
2422 case NOTOK:
2423 advise ("fork", "unable to");
2424 (void) (*ct -> c_ceclosefnx) (ct);
2425 return NOTOK;
2426
2427 case OK:
2428 if (cracked)
2429 (void) chdir (cracked);
2430 if (!xstdin)
2431 (void) dup2 (fd, 0);
2432 (void) close (fd);
2433 (void) execvp ("/bin/sh", vec);
2434 fprintf (stderr, "unable to exec ");
2435 perror ("/bin/sh");
2436 _exit (-1);
2437 /* NOTREACHED */
2438
2439 default:
2440 if (!serial) {
2441 ct -> c_pid = child_id;
2442 if (xtty)
2443 xpid = child_id;
2444 }
2445 else
2446 (void) pidcheck (pidXwait (child_id, NULLCP));
2447
2448 if (fd != NOTOK)
2449 (void) (*ct -> c_ceclosefnx) (ct);
2450 return (alternate ? DONE : OK);
2451 }
2452 }
2453
2454 /* \f */
2455
2456 static int store_content (ct, append)
2457 register CT ct;
2458 char *append;
2459 {
2460 int appending = append && *append;
2461 long last,
2462 pos;
2463 register char *bp,
2464 *cp;
2465 char *file,
2466 buffer[BUFSIZ];
2467 register CI ci = &ct -> c_ctinfo;
2468 FILE *fp;
2469
2470 if (appending) {
2471 (void) strcpy (buffer, append);
2472 goto got_filename;
2473 }
2474
2475 if ((cp = ct -> c_storeproc) == NULL || *cp == 0) {
2476 (void) sprintf (buffer, "%s-store-%s/%s", invo_name, ci -> ci_type,
2477 ci -> ci_subtype);
2478 if ((cp = m_find (buffer)) == NULL || *cp == 0) {
2479 (void) sprintf (buffer, "%s-store-%s", invo_name, ci -> ci_type);
2480 if ((cp = m_find (buffer)) == NULL || *cp == 0)
2481 cp = ct -> c_type == CT_MESSAGE ? "+" : "%m%P.%s";
2482 }
2483 }
2484
2485 switch (*cp) {
2486 case '+':
2487 case '@@':
2488 {
2489 char *folder = cp[1] ? path (cp + 1, *cp == '+' ? TFOLDER
2490 : TSUBCWF)
2491 : m_getfolder ();
2492 struct msgs *mp = NULL;
2493 struct stat st;
2494
2495 if (stat (bp = m_mailpath (folder), &st) == NOTOK) {
2496 int answer;
2497 char *ep;
2498
2499 if (errno != ENOENT) {
2500 advise (bp, "error on folder");
2501 goto losing_folder;
2502 }
2503
2504 ep = concat ("Create folder \"", bp, "\"? ", NULLCP);
2505 answer = getanswer (ep);
2506 free (ep);
2507
2508 if (!answer)
2509 goto losing_folder;
2510 if (!makedir (bp)) {
2511 advise (NULLCP, "unable to create folder %s", bp);
2512 goto losing_folder;
2513 }
2514 }
2515
2516 if (mp = m_gmsg (folder))
2517 (void) sprintf (buffer, "%s/%d", mp -> foldpath,
2518 mp -> hghmsg + 1);
2519 else
2520 advise (NULLCP, "unable to read folder %s", folder);
2521 losing_folder: ;
2522 if (cp[1])
2523 free (folder);
2524 if (mp)
2525 m_fmsg (mp);
2526 else
2527 return NOTOK;
2528 }
2529 goto got_filename;
2530
2531 case '/':
2532 case '|':
2533 case '!':
2534 bp = buffer;
2535 buffer[0] = '\0';
2536 break;
2537
2538 default:
2539 bp = autosw ? cwd : dir;
2540 (void) sprintf (buffer, "%s/", bp[1] ? bp : "");
2541 bp = buffer + strlen (buffer);
2542 break;
2543 }
2544 for (; *cp; cp++)
2545 if (*cp == '%') {
2546 switch (*++cp) {
2547 case 'a': /* additional arguments */
2548 if (buffer[0] != '|' && buffer[0] != '!') {
2549 *bp++ = *--cp;
2550 *bp = '\0';
2551 continue;
2552 }
2553 else {
2554 register char **ap,
2555 **ep;
2556 char *s = "";
2557
2558 for (ap = ci -> ci_attrs, ep = ci -> ci_values;
2559 *ap;
2560 ap++, ep++) {
2561 (void) sprintf (bp, "%s%s=\"%s\"", s, *ap, *ep);
2562 bp += strlen (bp);
2563 s = " ";
2564 }
2565 }
2566 break;
2567
2568 case 'm': /* message */
2569 (void) sprintf (bp, "%s", r1bindex (ct -> c_file, '/'));
2570 break;
2571
2572 case 'P': /* .part */
2573 if (ct -> c_partno)
2574 (void) sprintf (bp, ".%s", ct -> c_partno);
2575 break;
2576
2577 case 'p': /* part */
2578 if (ct -> c_partno)
2579 (void) strcpy (bp, ct -> c_partno);
2580 break;
2581
2582 case 't': /* type */
2583 (void) strcpy (bp, ci -> ci_type);
2584 break;
2585
2586 case 's': /* subtype */
2587 (void) strcpy (bp, ci -> ci_subtype);
2588 break;
2589
2590 case '%':
2591 goto raw;
2592
2593 default:
2594 *bp++ = *--cp;
2595 *bp = '\0';
2596 continue;
2597 }
2598 bp += strlen (bp);
2599 }
2600 else {
2601 raw: ;
2602 *bp++ = *cp;
2603 *bp = '\0';
2604 }
2605 if (buffer[0] == '|' || buffer[0] == '!')
2606 return show_content_aux (ct, 1, 0, buffer + 1, autosw ? cwd : dir);
2607 got_filename: ;
2608
2609 ct -> c_storage = add (buffer, NULLCP);
2610 (void) fflush (stdout);
2611 fprintf (stderr, "storing message %s", ct -> c_file);
2612 if (ct -> c_partno)
2613 fprintf (stderr, " part %s", ct -> c_partno);
2614 fprintf (stderr, " as file %s\n",
2615 strncmp (ct -> c_storage, cwd, cwdlen)
2616 || ct -> c_storage[cwdlen] != '/'
2617 ? ct -> c_storage : ct -> c_storage + cwdlen + 1);
2618 if (index (ct -> c_storage, '/')
2619 && make_intermediates (ct -> c_storage) == NOTOK)
2620 return NOTOK;
2621
2622 if (ct -> c_encoding != CE_7BIT) {
2623 int cc,
2624 fd;
2625
2626 if (!ct -> c_ceopenfnx) {
2627 advise (NULLCP, "don't know how to decode part %s of message %s",
2628 ct -> c_partno, ct -> c_file);
2629 return NOTOK;
2630 }
2631
2632 file = appending || !strcmp (ct -> c_storage, "-") ? NULLCP
2633 : ct -> c_storage;
2634 if ((fd = (*ct -> c_ceopenfnx) (ct, &file)) == NOTOK)
2635 return NOTOK;
2636 if (strcmp (file, ct -> c_storage) == 0) {
2637 (void) (*ct -> c_ceclosefnx) (ct);
2638 return OK;
2639 }
2640
2641 if (!strcmp (ct -> c_storage, "-")) {
2642 int gd;
2643
2644 if ((gd = dup (fileno (stdout))) == NOTOK) {
2645 advise ("stdout", "unable to dup");
2646 losing: ;
2647 (void) (*ct -> c_ceclosefnx) (ct);
2648 return NOTOK;
2649 }
2650 if ((fp = fdopen (gd, appending ? "a" : "w")) == NULL) {
2651 advise ("stdout", "unable to fdopen (%d, \"%s\") from", gd,
2652 appending ? "a" : "w");
2653 (void) close (gd);
2654 goto losing;
2655 }
2656 }
2657 else
2658 if ((fp = fopen (ct -> c_storage, appending ? "a" : "w"))
2659 == NULL) {
2660 advise (ct -> c_storage, "unable to fopen for %s",
2661 appending ? "appending" : "writing");
2662 goto losing;
2663 }
2664
2665 if (append && !*append)
2666 (void) copy_some_headers (fp, ct);
2667
2668 for (;;) {
2669 switch (cc = read (fd, buffer, sizeof buffer)) {
2670 case NOTOK:
2671 advise (file, "error reading content from");
2672 break;
2673
2674 case OK:
2675 break;
2676
2677 default:
2678 (void) fwrite (buffer, sizeof *buffer, cc, fp);
2679 continue;
2680 }
2681 break;
2682 }
2683
2684 (void) (*ct -> c_ceclosefnx) (ct);
2685
2686 if (cc != NOTOK && fflush (fp))
2687 advise (ct -> c_storage, "error writing to");
2688
2689 (void) fclose (fp);
2690
2691 return (cc != NOTOK ? OK : NOTOK);
2692 }
2693
2694 if (!ct -> c_fp && (ct -> c_fp = fopen (ct -> c_file, "r")) == NULL) {
2695 advise (ct -> c_file, "unable to open for reading");
2696 return NOTOK;
2697 }
2698
2699 (void) fseek (ct -> c_fp, pos = ct -> c_begin, 0);
2700 last = ct -> c_end;
2701
2702 if (!strcmp (ct -> c_storage, "-")) {
2703 int gd;
2704
2705 if ((gd = dup (fileno (stdout))) == NOTOK) {
2706 advise ("stdout", "unable to dup");
2707 return NOTOK;
2708 }
2709 if ((fp = fdopen (gd, appending ? "a" : "w")) == NULL) {
2710 advise ("stdout", "unable to fdopen (%d, \"%s\") from", gd,
2711 appending ? "a" : "w");
2712 (void) close (gd);
2713 return NOTOK;
2714 }
2715 }
2716 else
2717 if ((fp = fopen (ct -> c_storage, appending ? "a" : "w")) == NULL) {
2718 advise (ct -> c_storage, "unable to fopen for %s",
2719 appending ? "appending" : "writing");
2720 return NOTOK;
2721 }
2722
2723 if (append && !*append) {
2724 (void) copy_some_headers (fp, ct);
2725 appending = 1;
2726 }
2727 else
2728 appending = 0;
2729
2730 while (fgets (buffer, sizeof buffer - 1, ct -> c_fp)) {
2731 if ((pos += strlen (buffer)) > last) {
2732 int diff = strlen (buffer) - (pos - last);
2733
2734 if (diff >= 0)
2735 buffer[diff] = '\0';
2736 }
2737
2738 if (appending)
2739 switch (buffer[0]) {
2740 case ' ':
2741 case '\t':
2742 if (appending < 0)
2743 buffer[0] = 0;
2744 break;
2745
2746 case '\n':
2747 appending = 0;
2748 break;
2749
2750 default:
2751 if (!uprf (buffer, XXX_FIELD_PRF)
2752 && !uprf (buffer, "Encrypted:")
2753 && !uprf (buffer, "Message-ID:")) {
2754 appending = -1;
2755 buffer[0] = 0;
2756 break;
2757 }
2758 appending = 1;
2759 break;
2760 }
2761
2762 (void) fputs (buffer, fp);
2763 if (pos >= last)
2764 break;
2765 }
2766
2767 if (fflush (fp))
2768 advise (ct -> c_storage, "error writing to");
2769
2770 (void) fclose (fp);
2771
2772 (void) fclose (ct -> c_fp), ct -> c_fp = NULL;
2773
2774 return OK;
2775 }
2776
2777
2778 static int copy_some_headers (out, ct)
2779 FILE *out;
2780 register CT ct;
2781 {
2782 int state;
2783 char buf[BUFSIZ],
2784 name[NAMESZ];
2785 FILE *in;
2786
2787 if ((in = fopen (ct -> c_file, "r")) == NULL) {
2788 advise (ct -> c_file, "unable to open for reading");
2789 return NOTOK;
2790 }
2791
2792 for (state = FLD;;) {
2793 switch (state = m_getfld (state, name, buf, sizeof buf, in)) {
2794 case FLD:
2795 case FLDPLUS:
2796 case FLDEOF:
2797 if (uprf (name, XXX_FIELD_PRF)
2798 || uleq (name, "Encrypted")
2799 || uleq (name, "Message-ID")) {
2800 while (state == FLDPLUS)
2801 state = m_getfld (state, name, buf, sizeof buf, in);
2802 continue;
2803 }
2804
2805 fprintf (out, "%s:%s", name, buf);
2806 while (state == FLDPLUS) {
2807 state = m_getfld (state, name, buf, sizeof buf, in);
2808 (void) fputs (buf, out);
2809 }
2810 if (state != FLDEOF)
2811 continue;
2812 /* else fall... */
2813 case BODY:
2814 case BODYEOF:
2815 case FILEEOF:
2816 break;
2817
2818 case LENERR:
2819 case FMTERR:
2820 default:
2821 break;
2822 }
2823
2824 break;
2825 }
2826
2827 (void) fclose (in);
2828
2829 return OK;
2830 }
2831
2832
2833 static int make_intermediates (file)
2834 char *file;
2835 {
2836 register char *cp;
2837
2838 for (cp = file + 1; cp = index (cp, '/'); cp++) {
2839 struct stat st;
2840
2841 *cp = NULL;
2842
2843 if (stat (file, &st) == NOTOK) {
2844 int answer;
2845 char *ep;
2846
2847 if (errno != ENOENT) {
2848 advise (file, "error on directory");
2849 losing_directory: ;
2850 *cp = '/';
2851 return NOTOK;
2852 }
2853
2854 ep = concat ("Create directory \"", file, "\"? ", NULLCP);
2855 answer = getanswer (ep);
2856 free (ep);
2857
2858 if (!answer)
2859 goto losing_directory;
2860 if (!makedir (file)) {
2861 advise (NULLCP, "unable to create directory %s", file);
2862 goto losing_directory;
2863 }
2864 }
2865
2866 *cp = '/';
2867 }
2868
2869 return OK;
2870 }
2871
2872 /* \f */
2873
2874 static void free_ctinfo (ct)
2875 register CT ct;
2876 {
2877 register char **ap;
2878 register CI ci = &ct -> c_ctinfo;
2879
2880 if (ci -> ci_type)
2881 free (ci -> ci_type);
2882 ci -> ci_type = NULL;
2883 if (ci -> ci_subtype)
2884 free (ci -> ci_subtype);
2885 ci -> ci_subtype = NULL;
2886 for (ap = ci -> ci_attrs; *ap; ap++)
2887 free (*ap), *ap = NULL;
2888 if (ci -> ci_comment)
2889 free (ci -> ci_comment);
2890 ci -> ci_comment = NULL;
2891 if (ci -> ci_magic)
2892 free (ci -> ci_magic);
2893 ci -> ci_magic = NULL;
2894 }
2895
2896
2897 static void free_content (ct)
2898 register CT ct;
2899 {
2900 if (!ct)
2901 return;
2902
2903 if (ct -> c_partno)
2904 free (ct -> c_partno);
2905 ct -> c_partno = NULL;
2906
2907 if (ct -> c_vrsn)
2908 free (ct -> c_vrsn);
2909 ct -> c_vrsn = NULL;
2910
2911 if (ct -> c_ctline)
2912 free (ct -> c_ctline);
2913 ct -> c_ctline = NULL;
2914
2915 free_ctinfo (ct);
2916
2917 if (ct -> c_ctfreefnx)
2918 (void) (*ct -> c_ctfreefnx) (ct);
2919 ct -> c_ctfreefnx = NULL;
2920
2921 if (ct -> c_showproc)
2922 free (ct -> c_showproc);
2923 ct -> c_showproc = NULL;
2924 if (ct -> c_termproc)
2925 free (ct -> c_termproc);
2926 ct -> c_termproc = NULL;
2927 if (ct -> c_storeproc)
2928 free (ct -> c_storeproc);
2929 ct -> c_storeproc = NULL;
2930
2931 if (ct -> c_celine)
2932 free (ct -> c_celine);
2933 ct -> c_celine = NULL;
2934 if (ct -> c_cefreefnx)
2935 (void) (*ct -> c_cefreefnx) (ct, 1);
2936 ct -> c_cefreefnx = NULL;
2937
2938 if (ct -> c_id)
2939 free (ct -> c_id);
2940 ct -> c_id = NULL;
2941 if (ct -> c_descr)
2942 free (ct -> c_descr);
2943 ct -> c_descr = NULL;
2944
2945 if (ct -> c_file) {
2946 if (ct -> c_unlink)
2947 (void) unlink (ct -> c_file);
2948 free (ct -> c_file);
2949 ct -> c_file = NULL;
2950 }
2951 if (ct -> c_fp)
2952 (void) fclose (ct -> c_fp);
2953 ct -> c_fp = NULL;
2954
2955 if (ct -> c_storage)
2956 (void) free (ct -> c_storage);
2957 ct -> c_storage = NULL;
2958
2959 free ((char *) ct);
2960 }
2961
2962 /* \f */
2963
2964 static int part_ok (ct, sP)
2965 register CT ct;
2966 int sP;
2967 {
2968 register char **ap;
2969
2970 if ((ct -> c_type == CT_MULTIPART && (sP || ct -> c_subtype))
2971 || npart == 0)
2972 return 1;
2973
2974 for (ap = parts; *ap; ap++)
2975 if (strcmp (*ap, ct -> c_partno) == 0)
2976 return 1;
2977
2978 return 0;
2979 }
2980
2981
2982
2983 static int type_ok (ct, sP)
2984 register CT ct;
2985 int sP;
2986 {
2987 register char **ap;
2988 char buffer[BUFSIZ];
2989 register CI ci = &ct -> c_ctinfo;
2990
2991 if ((ct -> c_type == CT_MULTIPART && (sP || ct -> c_subtype))
2992 || ntype == 0)
2993 return 1;
2994
2995 (void) sprintf (buffer, "%s/%s", ci -> ci_type, ci -> ci_subtype);
2996 for (ap = types; *ap; ap++)
2997 if (uleq (*ap, ci -> ci_type) || uleq (*ap, buffer))
2998 return 1;
2999
3000 return 0;
3001 }
3002
3003 /* \f CONTENTS */
3004
3005 struct k2v {
3006 char *kv_key;
3007 int kv_value;
3008 };
3009
3010
3011 static int InitGeneric (ct)
3012 register CT ct;
3013 {
3014 register char **ap,
3015 **ep;
3016 register CI ci = &ct -> c_ctinfo;
3017
3018 for (ap = ci -> ci_attrs, ep = ci -> ci_values; *ap; ap++, ep++)
3019 if (autosw && !ct -> c_storeproc && uleq (*ap, "name")) {
3020 register char *cp;
3021
3022 if (*(cp = *ep) != '/'
3023 && *cp != '.'
3024 && *cp != '|'
3025 && *cp != '!'
3026 && !index (cp, '%'))
3027 ct -> c_storeproc = add (cp, NULLCP);
3028 }
3029
3030 return OK;
3031 }
3032
3033 /* \f TEXT */
3034
3035 #define TEXT_UNKNOWN 0x00
3036 #define TEXT_PLAIN 0x01
3037 #define TEXT_RICHTEXT 0x02
3038
3039 struct text {
3040 int tx_charset;
3041 #define CHARSET_UNKNOWN 0x00
3042 #define CHARSET_USASCII 0x01
3043 #define CHARSET_LATIN 0x02
3044 };
3045
3046 static struct k2v Charset[] = {
3047 "us-ascii", CHARSET_USASCII,
3048 "iso-8859-1", CHARSET_LATIN,
3049
3050 NULL, CHARSET_UNKNOWN /* this one must be last! */
3051 };
3052
3053 static int free_text (ct)
3054 register CT ct;
3055 {
3056 register struct text *t = (struct text *) ct -> c_ctparams;
3057
3058 if (!t)
3059 return;
3060
3061 free ((char *) t);
3062 ct -> c_ctparams = NULL;
3063 }
3064
3065
3066 static struct k2v SubText[] = {
3067 "plain", TEXT_PLAIN,
3068 "richtext", TEXT_RICHTEXT,
3069
3070 NULL, TEXT_UNKNOWN /* this one must be last! */
3071 };
3072
3073 static int InitText (ct)
3074 register CT ct;
3075 {
3076 char buffer[BUFSIZ];
3077 register char **ap,
3078 **ep;
3079 register struct k2v *kv;
3080 register CI ci = &ct -> c_ctinfo;
3081
3082 if (!*ci -> ci_subtype) /* XXX: attmail bogosity! */
3083 ci -> ci_subtype = add ("plain", ci -> ci_subtype);
3084 for (kv = SubText; kv -> kv_key; kv++)
3085 if (uleq (ci -> ci_subtype, kv -> kv_key))
3086 break;
3087 if ((ct -> c_subtype = kv -> kv_value) == TEXT_PLAIN) {
3088 (void) sprintf (buffer, "%%p%s '%%F'",
3089 progsw ? progsw
3090 : moreproc && *moreproc ? moreproc : "more");
3091 ct -> c_showproc = add (buffer, NULLCP);
3092 }
3093
3094 for (ap = ci -> ci_attrs, ep = ci -> ci_values; *ap; ap++, ep++)
3095 if (!ct -> c_ctparams && uleq (*ap, "charset")) {
3096 char *cp;
3097 register struct text *t;
3098
3099 if ((t = (struct text *) calloc (1, sizeof *t)) == NULL)
3100 adios (NULLCP, "out of memory");
3101 ct -> c_ctparams = (caddr_t) t;
3102 ct -> c_ctfreefnx = free_text;
3103
3104 for (kv = Charset; kv -> kv_key; kv++)
3105 if (uleq (*ep, kv -> kv_key)) {
3106 (void) sprintf (buffer, "%s-charset-%s", invo_name,
3107 kv -> kv_key);
3108 break;
3109 }
3110 t -> tx_charset = kv -> kv_value;
3111 if (!kv -> kv_key)
3112 (void) sprintf (buffer, "%s-charset-%s", invo_name, *ep);
3113 if ((!mm_charset || !uleq (mm_charset, *ep))
3114 && (cp = m_find (buffer)))
3115 ct -> c_termproc = getcpy (cp);
3116 }
3117 else
3118 if (autosw && !ct -> c_storeproc && uleq (*ap, "name")) {
3119 register char *cp;
3120
3121 if (*(cp = *ep) != '/'
3122 && *cp != '.'
3123 && *cp != '|'
3124 && *cp != '!'
3125 && !index (cp, '%'))
3126 ct -> c_storeproc = add (cp, NULLCP);
3127 }
3128
3129 return OK;
3130 }
3131
3132 /* \f MULTIPART */
3133
3134 #define MULTI_UNKNOWN 0x00
3135 #define MULTI_MIXED 0x01
3136 #define MULTI_ALTERNATE 0x02
3137 #define MULTI_DIGEST 0x03
3138 #define MULTI_PARALLEL 0x04
3139
3140
3141 struct multipart {
3142 char *mp_start;
3143 char *mp_stop;
3144
3145 struct part {
3146 CT mp_part;
3147
3148 struct part *mp_next;
3149 } *mp_parts;
3150 };
3151
3152
3153 static int list_multi (ct, toplevel)
3154 register CT ct;
3155 int toplevel;
3156 {
3157 register struct multipart *m = (struct multipart *) ct -> c_ctparams;
3158 register struct part *part;
3159
3160 (void) list_content (ct, toplevel);
3161
3162 for (part = m -> mp_parts; part; part = part -> mp_next) {
3163 register CT p = part -> mp_part;
3164
3165 if (part_ok (p, 1) && type_ok (p, 1) && p -> c_ctlistfnx)
3166 (void) (*p -> c_ctlistfnx) (p, 0);
3167 }
3168
3169 return OK;
3170 }
3171
3172
3173 static int show_multi (ct, serial, alternate)
3174 register CT ct;
3175 int serial,
3176 alternate;
3177 {
3178 int alternating,
3179 nowalternate,
3180 nowserial,
3181 result;
3182 register struct multipart *m = (struct multipart *) ct -> c_ctparams;
3183 register struct part *part;
3184 register CT p;
3185 TYPESIG (*hstat) (), (*istat) (), (*qstat) (), (*tstat) ();
3186
3187 alternating = 0;
3188 nowalternate = alternate;
3189 switch (ct -> c_subtype) {
3190 case MULTI_PARALLEL:
3191 if (!(nowserial = serialsw)) {
3192 set_signals: ;
3193 hstat = signal (SIGHUP, SIG_IGN);
3194 istat = signal (SIGINT, SIG_IGN);
3195 qstat = signal (SIGQUIT, SIG_IGN);
3196 tstat = signal (SIGTERM, SIG_IGN);
3197 }
3198 break;
3199
3200 case MULTI_ALTERNATE:
3201 nowalternate = alternating = 1;
3202 /* and fall... */
3203 default:
3204 if (!(nowserial = serial))
3205 goto set_signals;
3206 break;
3207 }
3208
3209 /* alternate -> we're inside an alternative
3210 alternating -> we are an alternative
3211 */
3212
3213 result = alternate ? NOTOK : OK;
3214 for (part = m -> mp_parts; part; part = part -> mp_next) {
3215 p = part -> mp_part;
3216
3217 if (part_ok (p, 0) && type_ok (p, 0) && p -> c_ctshowfnx) {
3218 int inneresult;
3219
3220 switch (inneresult = (*p -> c_ctshowfnx) (p, nowserial,
3221 nowalternate)) {
3222 case NOTOK:
3223 if (alternate && !alternating) {
3224 result = NOTOK;
3225 goto out;
3226 }
3227 continue;
3228
3229 case OK:
3230 case DONE:
3231 if (alternating) {
3232 result = DONE;
3233 break;
3234 }
3235 if (alternate) {
3236 alternate = nowalternate = 0;
3237 if (result == NOTOK)
3238 result = inneresult;
3239 }
3240 continue;
3241 }
3242 break;
3243 }
3244 }
3245 if (alternating && !part) {
3246 if (!alternate)
3247 content_error (NULLCP, ct,
3248 "don't know how to display any of the contents");
3249
3250 result = NOTOK;
3251 goto out;
3252 }
3253
3254 if (serial && !nowserial) {
3255 int pid,
3256 kids;
3257 #if defined(BSD42) && !defined(WAITINT)
3258 union wait status;
3259 #else
3260 int status;
3261 #endif
3262
3263 kids = 0;
3264 for (part = m -> mp_parts; part; part = part -> mp_next) {
3265 p = part -> mp_part;
3266
3267 if (p -> c_pid > OK)
3268 if (kill (p -> c_pid, 0) == NOTOK)
3269 p -> c_pid = 0;
3270 else
3271 kids++;
3272 }
3273
3274 while (kids > 0 && (pid = wait (&status)) != NOTOK) {
3275 #if defined(BSD42) && !defined(WAITINT)
3276 (void) pidcheck (status.w_status);
3277 #else
3278 (void) pidcheck (status);
3279 #endif
3280
3281 for (part = m -> mp_parts; part; part = part -> mp_next) {
3282 p = part -> mp_part;
3283
3284 if (xpid == pid)
3285 xpid = 0;
3286 if (p -> c_pid == pid) {
3287 p -> c_pid = 0;
3288 kids--;
3289 break;
3290 }
3291 }
3292 }
3293 }
3294
3295 out: ;
3296 if (!nowserial) {
3297 (void) signal (SIGHUP, hstat);
3298 (void) signal (SIGINT, istat);
3299 (void) signal (SIGQUIT, qstat);
3300 (void) signal (SIGTERM, tstat);
3301 }
3302
3303 return result;
3304 }
3305
3306
3307 static int show_unknown_multi (ct, serial, alternate)
3308 register CT ct;
3309 int serial,
3310 alternate;
3311 {
3312 int xlist,
3313 xpause,
3314 xtty;
3315 register char *bp,
3316 *cp;
3317 char buffer[BUFSIZ];
3318 register struct multipart *m = (struct multipart *) ct -> c_ctparams;
3319 register struct part *part;
3320 register CI ci = &ct -> c_ctinfo;
3321 register CT p;
3322
3323 (void) sprintf (buffer, "%s-show-%s/%s", invo_name, ci -> ci_type,
3324 ci -> ci_subtype);
3325 if ((cp = m_find (buffer)) == NULL || *cp == 0) {
3326 (void) sprintf (buffer, "%s-show-%s", invo_name, ci -> ci_type);
3327 if (((cp = m_find (buffer)) == NULL || *cp == 0)
3328 && (cp = ct -> c_showproc) == NULL) {
3329 if (!alternate)
3330 content_error (NULLCP, ct,
3331 "don't know how to display content");
3332
3333 return NOTOK;
3334 }
3335 }
3336
3337 for (part = m -> mp_parts; part; part = part -> mp_next) {
3338 p = part -> mp_part;
3339
3340 if (!p -> c_ceopenfnx) {
3341 if (!alternate)
3342 content_error (NULLCP, p, "don't know how to decode content");
3343
3344 return NOTOK;
3345 }
3346
3347 if (p -> c_storage == NULL) {
3348 if ((*p -> c_ceopenfnx) (p, &p -> c_storage) == NOTOK)
3349 return NOTOK;
3350
3351 if (p -> c_showproc && strcmp (p -> c_showproc, "true") == 0)
3352 return (alternate ? DONE : OK);
3353 (*p -> c_ceclosefnx) (p);
3354 }
3355 }
3356
3357 xlist = xpause = xtty = 0;
3358 buffer[0] = '\0';
3359 for (bp = buffer; *cp; cp++)
3360 if (*cp == '%') {
3361 switch (*++cp) {
3362 case 'a': /* additional arguments */
3363 {
3364 register char **ap,
3365 **ep;
3366 char *s = "";
3367
3368 for (ap = ci -> ci_attrs, ep = ci -> ci_values;
3369 *ap;
3370 ap++, ep++) {
3371 (void) sprintf (bp, "%s%s=\"%s\"", s, *ap, *ep);
3372 bp += strlen (bp);
3373 s = " ";
3374 }
3375 }
3376 break;
3377
3378 case 'd': /* content description */
3379 if (ct -> c_descr) {
3380 char *s;
3381
3382 (void) strcpy (bp, s = trimcpy (ct -> c_descr));
3383 free (s);
3384 }
3385 break;
3386
3387 case 'e': /* exclusive execution */
3388 xtty = 1;
3389 break;
3390
3391 case 'F': /* %e and %f */
3392 xtty = 1;
3393 /* and fall... */
3394 case 'f': /* filename(s) */
3395 {
3396 char *s = "";
3397
3398 for (part = m -> mp_parts;
3399 part;
3400 part = part -> mp_next) {
3401 p = part -> mp_part;
3402
3403 (void) sprintf (bp, "%s'%s'", s, p -> c_storage);
3404 bp += strlen (bp);
3405 s = " ";
3406 }
3407 }
3408 break;
3409
3410 case 'p': /* pause prior to displaying content */
3411 xpause = pausesw;
3412 /* and fall... */
3413 case 'l': /* display listing prior to displaying
3414 content */
3415 xlist = !nolist;
3416 break;
3417
3418 case 's': /* subtype */
3419 (void) strcpy (bp, ci -> ci_subtype);
3420 break;
3421
3422 case '%':
3423 goto raw;
3424
3425 default:
3426 *bp++ = *--cp;
3427 *bp = '\0';
3428 continue;
3429 }
3430 bp += strlen (bp);
3431 }
3432 else {
3433 raw: ;
3434 *bp++ = *cp;
3435 *bp = '\0';
3436 }
3437 if (ct -> c_termproc) {
3438 char term[BUFSIZ];
3439
3440 (void) strcpy (term, buffer);
3441 (void) sprintf (buffer, ct -> c_termproc, term);
3442 }
3443
3444 return show_content_aux2 (ct, serial, alternate, NULLCP, buffer,
3445 NOTOK, xlist, xpause, 0, xtty);
3446 }
3447
3448
3449 /* ARGSUSED */
3450
3451 static int store_multi (ct, unused)
3452 register CT ct;
3453 char *unused;
3454 {
3455 int result;
3456 register struct multipart *m = (struct multipart *) ct -> c_ctparams;
3457 register struct part *part;
3458
3459 result = NOTOK;
3460 for (part = m -> mp_parts; part; part = part -> mp_next) {
3461 register CT p = part -> mp_part;
3462
3463 if (part_ok (p, 1)
3464 && type_ok (p, 1)
3465 && p -> c_ctstorefnx
3466 && (result = (*p -> c_ctstorefnx) (p, NULLCP)) == OK
3467 && ct -> c_subtype == MULTI_ALTERNATE)
3468 break;
3469 }
3470
3471 return result;
3472 }
3473
3474
3475 static int free_multi (ct)
3476 register CT ct;
3477 {
3478 register struct multipart *m = (struct multipart *) ct -> c_ctparams;
3479 register struct part *part,
3480 *next;
3481
3482 if (!m)
3483 return;
3484
3485 if (m -> mp_start)
3486 free (m -> mp_start);
3487 if (m -> mp_stop)
3488 free (m -> mp_stop);
3489
3490 for (part = m -> mp_parts; part; part = next) {
3491 next = part -> mp_next;
3492
3493 free_content (part -> mp_part);
3494
3495 free ((char *) part);
3496 }
3497 m -> mp_parts = NULL;
3498
3499 free ((char *) m);
3500 ct -> c_ctparams = NULL;
3501 }
3502
3503
3504 static struct k2v SubMultiPart[] = {
3505 "mixed", MULTI_MIXED,
3506 "alternative", MULTI_ALTERNATE,
3507 "digest", MULTI_DIGEST,
3508 "parallel", MULTI_PARALLEL,
3509
3510 NULL, MULTI_UNKNOWN /* this one must be last! */
3511 };
3512
3513 static int InitMultiPart (ct)
3514 register CT ct;
3515 {
3516 int inout;
3517 long last,
3518 pos;
3519 register char *cp,
3520 *dp,
3521 **ap,
3522 **ep;
3523 char *bp,
3524 buffer[BUFSIZ];
3525 register struct multipart *m;
3526 register struct k2v *kv;
3527 register struct part *part,
3528 **next;
3529 register CI ci = &ct -> c_ctinfo;
3530 register CT p;
3531 FILE *fp;
3532
3533 ct -> c_ctshowfnx = NULL;
3534 ct -> c_ctstorefnx = NULL;
3535
3536 if (ct -> c_encoding != CE_7BIT) {
3537 admonish (NULLCP,
3538 "\"%s/%s\" type in message %s should be encoded in 7bit",
3539 ci -> ci_type, ci -> ci_subtype, ct -> c_file);
3540 return NOTOK;
3541 }
3542
3543 for (kv = SubMultiPart; kv -> kv_key; kv++)
3544 if (uleq (ci -> ci_subtype, kv -> kv_key))
3545 break;
3546 ct -> c_subtype = kv -> kv_value;
3547
3548 for (ap = ci -> ci_attrs, ep = ci -> ci_values; *ap; ap++, ep++)
3549 if (uleq (*ap, "boundary")) {
3550 bp = *ep;
3551 break;
3552 }
3553 if (!*ap) {
3554 advise (NULLCP,
3555 "a \"boundary\" parameter is mandatory for \"%s/%s\" type in message %s's %s: field",
3556 ci -> ci_type, ci -> ci_subtype, ct -> c_file, TYPE_FIELD);
3557 return NOTOK;
3558 }
3559
3560 if ((m = (struct multipart *) calloc (1, sizeof *m)) == NULL)
3561 adios (NULLCP, "out of memory");
3562 ct -> c_ctparams = (caddr_t) m;
3563 ct -> c_ctlistfnx = list_multi;
3564 ct -> c_ctshowfnx = ct -> c_subtype != MULTI_UNKNOWN ? show_multi
3565 : show_unknown_multi;
3566 ct -> c_ctstorefnx = store_multi;
3567 ct -> c_ctfreefnx = free_multi;
3568
3569 for (cp = bp; isspace (*cp); cp++)
3570 continue;
3571 if (!*cp) {
3572 advise (NULLCP, "invalid \"boundary\" parameter for \"%s/%s\" type in message %s's %s: field",
3573 ci -> ci_type, ci -> ci_subtype, ct -> c_file, TYPE_FIELD);
3574 return NOTOK;
3575 }
3576 for (cp = bp, dp = cp + strlen (cp) - 1; dp > cp; dp--)
3577 if (!isspace (*dp))
3578 break;
3579 *++dp = '\0';
3580 m -> mp_start = concat (bp, "\n", NULLCP);
3581 m -> mp_stop = concat (bp, "--\n", NULLCP);
3582
3583 if (!ct -> c_fp && (ct -> c_fp = fopen (ct -> c_file, "r")) == NULL) {
3584 advise (ct -> c_file, "unable to open for reading");
3585 return NOTOK;
3586 }
3587
3588 (void) fseek (fp = ct -> c_fp, pos = ct -> c_begin, 0);
3589 last = ct -> c_end;
3590
3591 next = &m -> mp_parts, part = NULL, inout = 1;
3592 while (fgets (buffer, sizeof buffer - 1, fp)) {
3593 if (pos > last)
3594 break;
3595
3596 pos += strlen (buffer);
3597
3598 if (buffer[0] != '-' || buffer[1] != '-')
3599 continue;
3600
3601 if (inout) {
3602 if (strcmp (buffer + 2, m -> mp_start))
3603 continue;
3604
3605 next_part: ;
3606 if ((part = (struct part *) calloc (1, sizeof *part)) == NULL)
3607 adios (NULLCP, "out of memory");
3608 *next = part, next = &part -> mp_next;
3609
3610 if ((p = get_content (fp, ct -> c_file,
3611 rfc934sw && ct -> c_subtype == MULTI_DIGEST
3612 ? -1 : 0)) == NULLCT) {
3613 (void) fclose (ct -> c_fp), ct -> c_fp = NULL;
3614 return NOTOK;
3615 }
3616 p -> c_fp = NULL;
3617
3618 part -> mp_part = p;
3619 (void) fseek (fp, pos = p -> c_begin, 0);
3620 inout = 0;
3621 }
3622 else
3623 if (strcmp (buffer + 2, m -> mp_start) == 0) {
3624 inout = 1;
3625
3626 end_part: ;
3627 p = part -> mp_part;
3628 p -> c_end = ftell (fp) - (strlen (buffer) + 1);
3629 if (p -> c_end < p -> c_begin)
3630 p -> c_begin = p -> c_end;
3631 if (inout)
3632 goto next_part;
3633 goto last_part;
3634 }
3635 else
3636 if (strcmp (buffer + 2, m -> mp_stop) == 0)
3637 goto end_part;
3638 }
3639 advise (NULLCP, "bogus multipart content in message %s", ct -> c_file);
3640 if (!inout && part) {
3641 p = part -> mp_part;
3642 p -> c_end = ct -> c_end;
3643
3644 if (p -> c_begin >= p -> c_end) {
3645 for (next = &m -> mp_parts;
3646 *next != part;
3647 next = &((*next) -> mp_next))
3648 continue;
3649 *next = NULL;
3650 free_content (p);
3651 free ((char *) part);
3652 }
3653 }
3654
3655 last_part: ;
3656 if (ct -> c_subtype == MULTI_ALTERNATE
3657 && m -> mp_parts
3658 && m -> mp_parts -> mp_next) {
3659 register int i;
3660 register struct part **base,
3661 **bmp;
3662
3663 i = 0;
3664 for (part = m -> mp_parts; part; part = part -> mp_next)
3665 i++;
3666 if ((base = (struct part **) calloc ((unsigned) (i + 1), sizeof *base))
3667 == NULL)
3668 adios (NULLCP, "out of memory");
3669 bmp = base;
3670 for (part = m -> mp_parts; part; part = part -> mp_next)
3671 *bmp++ = part;
3672 *bmp = NULL;
3673
3674 next = &m -> mp_parts;
3675 for (bmp--; bmp >= base; bmp--) {
3676 part = *bmp;
3677 *next = part, next = &part -> mp_next;
3678 }
3679 *next = NULL;
3680
3681 free ((char *) base);
3682 }
3683
3684 {
3685 int partnum;
3686 register char *pp;
3687 char partnam[BUFSIZ];
3688
3689 if (ct -> c_partno) {
3690 (void) sprintf (partnam, "%s.", ct -> c_partno);
3691 pp = partnam + strlen (partnam);
3692 }
3693 else
3694 pp = partnam;
3695
3696 for (part = m -> mp_parts, partnum = 1;
3697 part;
3698 part = part -> mp_next, partnum++) {
3699 p = part -> mp_part;
3700
3701 (void) sprintf (pp, "%d", partnum);
3702 p -> c_partno = add (partnam, NULLCP);
3703
3704 if (p -> c_ctinitfnx && (*p -> c_ctinitfnx) (p) == NOTOK) {
3705 (void) fclose (ct -> c_fp), ct -> c_fp = NULL;
3706 return NOTOK;
3707 }
3708 }
3709 }
3710
3711 (void) fclose (ct -> c_fp), ct -> c_fp = NULL;
3712
3713 return OK;
3714 }
3715
3716 /* \f MESSAGE */
3717
3718 #define MESSAGE_UNKNOWN 0x00
3719 #define MESSAGE_RFC822 0x01
3720 #define MESSAGE_PARTIAL 0x02
3721 #define MESSAGE_EXTERNAL 0x03
3722
3723
3724 struct partial {
3725 char *pm_partid;
3726
3727 int pm_partno;
3728 int pm_maxno;
3729
3730 int pm_marked;
3731 int pm_stored;
3732 };
3733
3734
3735 static int list_partial (ct, toplevel)
3736 register CT ct;
3737 int toplevel;
3738 {
3739 register struct partial *p = (struct partial *) ct -> c_ctparams;
3740
3741 (void) list_content (ct, toplevel);
3742 if (verbosw) {
3743 printf ("\t [message %s, part %d", p -> pm_partid, p -> pm_partno);
3744 if (p -> pm_maxno)
3745 printf (" of %d", p -> pm_maxno);
3746 printf ("]\n");
3747 }
3748
3749 return OK;
3750 }
3751
3752
3753 static int ct_compar (a, b)
3754 CT *a,
3755 *b;
3756 {
3757 register struct partial *am = (struct partial *) ((*a) -> c_ctparams);
3758 register struct partial *bm = (struct partial *) ((*b) -> c_ctparams);
3759
3760 return (am -> pm_marked - bm -> pm_marked);
3761 }
3762
3763
3764 /* ARGSUSED */
3765
3766 static int store_partial (ct, unused)
3767 register CT ct;
3768 char *unused;
3769 {
3770 int cur,
3771 hi,
3772 i;
3773 register CT p,
3774 *ctp,
3775 *ctq;
3776 CT *base;
3777 struct partial *qm = (struct partial *) ct -> c_ctparams;
3778
3779 if (qm -> pm_stored)
3780 return OK;
3781
3782 hi = i = 0;
3783 for (ctp = cts; p = *ctp; ctp++)
3784 if (p -> c_type == CT_MESSAGE && p -> c_subtype == ct -> c_subtype) {
3785 register struct partial *pm = (struct partial *) p -> c_ctparams;
3786
3787 if (!pm -> pm_stored
3788 && strcmp (qm -> pm_partid, pm -> pm_partid) == 0) {
3789 pm -> pm_marked = pm -> pm_partno;
3790 if (pm -> pm_maxno)
3791 hi = pm -> pm_maxno;
3792 pm -> pm_stored = 1;
3793 i++;
3794 }
3795 else
3796 pm -> pm_marked = 0;
3797 }
3798 if (hi == 0) {
3799 advise (NULLCP, "missing (at least) last part of multipart message");
3800 return NOTOK;
3801 }
3802
3803 if ((base = (CT *) calloc ((unsigned) (i + 1), sizeof *base)) == NULL)
3804 adios (NULLCP, "out of memory");
3805
3806 ctq = base;
3807 for (ctp = cts; p = *ctp; ctp++)
3808 if (p -> c_type == CT_MESSAGE && p -> c_subtype == ct -> c_subtype) {
3809 register struct partial *pm = (struct partial *) p -> c_ctparams;
3810
3811 if (pm -> pm_marked)
3812 *ctq++ = p;
3813 }
3814 *ctq = NULL;
3815
3816 if (i > 1)
3817 qsort ((char *) base, i, sizeof *base, ct_compar);
3818
3819 cur = 1;
3820 for (ctq = base; p = *ctq; ctq++) {
3821 register struct partial *pm = (struct partial *) p -> c_ctparams;
3822
3823 if (pm -> pm_marked != cur) {
3824 if (pm -> pm_marked == cur - 1) {
3825 admonish (NULLCP,
3826 "duplicate part %d of %d part multipart message",
3827 pm -> pm_marked, hi);
3828 continue;
3829 }
3830
3831 missing_part: ;
3832 advise (NULLCP,
3833 "missing %spart %d of %d part multipart message",
3834 cur != hi ? "(at least) " : "", cur, hi);
3835 goto losing;
3836 }
3837 else
3838 cur++;
3839 }
3840 if (hi != --cur) {
3841 cur = hi;
3842 goto missing_part;
3843 }
3844
3845 ctq = base;
3846 ct = *ctq++;
3847 if (store_content (ct, "") == NOTOK) {
3848 losing: ;
3849 free ((char *) base);
3850 return NOTOK;
3851 }
3852
3853 for (; p = *ctq; ctq++)
3854 if (store_content (p, ct -> c_storage) == NOTOK)
3855 goto losing;
3856
3857 free ((char *) base);
3858 return OK;
3859 }
3860
3861
3862 static int free_partial (ct)
3863 register CT ct;
3864 {
3865 register struct partial *p = (struct partial *) ct -> c_ctparams;
3866
3867 if (!p)
3868 return;
3869
3870 if (p -> pm_partid)
3871 free (p -> pm_partid);
3872
3873 free ((char *) p);
3874 ct -> c_ctparams = NULL;
3875 }
3876
3877
3878 struct exbody {
3879 CT eb_parent;
3880 CT eb_content;
3881 char *eb_partno;
3882
3883 char *eb_access;
3884 int eb_flags;
3885
3886 char *eb_name;
3887 char *eb_permission;
3888
3889 char *eb_site;
3890 char *eb_dir;
3891 char *eb_mode;
3892 unsigned long
3893 eb_size;
3894
3895 char *eb_server;
3896 char *eb_subject;
3897 char *eb_body;
3898 };
3899
3900
3901 static int openFile ();
3902 static int openFTP ();
3903 static int openMail ();
3904
3905 /* NOTE WELL: si_key MUST NOT have value of NOTOK */
3906
3907 static struct str2init str2methods[] = {
3908 "afs", 1, openFile,
3909 "anon-ftp", 1, openFTP,
3910 "ftp", 0, openFTP,
3911 "local-file", 0, openFile,
3912 "mail-server", 0, openMail,
3913
3914 NULL
3915 };
3916
3917
3918 static int params_external (ct, composing)
3919 register CT ct;
3920 int composing;
3921 {
3922 register char **ap,
3923 **ep;
3924 register struct exbody *e = (struct exbody *) ct -> c_ctparams;
3925 register CI ci = &ct -> c_ctinfo;
3926
3927 for (ap = ci -> ci_attrs, ep = ci -> ci_values; *ap; ap++, ep++) {
3928 if (uleq (*ap, "access-type")) {
3929 register struct str2init *s2i;
3930 register CT p = e -> eb_content;
3931
3932 for (s2i = str2methods; s2i -> si_key; s2i++)
3933 if (uleq (*ep, s2i -> si_key))
3934 break;
3935 if (!s2i -> si_key) {
3936 e -> eb_access = *ep;
3937 e -> eb_flags = NOTOK;
3938 p -> c_encoding = CE_EXTERNAL;
3939 continue;
3940 }
3941 e -> eb_access = s2i -> si_key;
3942 e -> eb_flags = s2i -> si_val;
3943 p -> c_encoding = CE_EXTERNAL;
3944 if (init_encoding (p, s2i -> si_init) == NOTOK)
3945 return NOTOK;
3946 continue;
3947 }
3948 if (uleq (*ap, "name")) {
3949 e -> eb_name = *ep;
3950 continue;
3951 }
3952 if (uleq (*ap, "permission")) {
3953 e -> eb_permission = *ep;
3954 continue;
3955 }
3956 if (uleq (*ap, "site")) {
3957 e -> eb_site = *ep;
3958 continue;
3959 }
3960 if (uleq (*ap, "directory")) {
3961 e -> eb_dir = *ep;
3962 continue;
3963 }
3964 if (uleq (*ap, "mode")) {
3965 e -> eb_mode = *ep;
3966 continue;
3967 }
3968 if (uleq (*ap, "size")) {
3969 (void) sscanf (*ep, "%lu", &e -> eb_size);
3970 continue;
3971 }
3972 if (uleq (*ap, "server")) {
3973 e -> eb_server = *ep;
3974 continue;
3975 }
3976 if (uleq (*ap, "subject")) {
3977 e -> eb_subject = *ep;
3978 continue;
3979 }
3980 if (composing && uleq (*ap, "body")) {
3981 e -> eb_body = getcpy (*ep);
3982 continue;
3983 }
3984 }
3985
3986 if (!e -> eb_access) {
3987 advise (NULLCP,
3988 "invalid parameters for \"%s/%s\" type in message %s's %s field",
3989 ci -> ci_type, ci -> ci_subtype,
3990 ct -> c_file, TYPE_FIELD);
3991 return NOTOK;
3992 }
3993
3994 return OK;
3995 }
3996
3997 static int list_external (ct, toplevel)
3998 register CT ct;
3999 int toplevel;
4000 {
4001 register struct exbody *e = (struct exbody *) ct -> c_ctparams;
4002
4003 (void) list_content (ct, toplevel);
4004 if (verbosw) {
4005 if (e -> eb_name)
4006 printf ("\t retrieve %s\n", e -> eb_name);
4007 if (e -> eb_dir)
4008 printf ("\t in directory %s\n", e -> eb_dir);
4009 if (e -> eb_site)
4010 printf ("\t from %s\n", e -> eb_site);
4011 if (e -> eb_server)
4012 printf ("\t from mailbox %s\n", e -> eb_server);
4013 if (e -> eb_subject)
4014 printf ("\t with subject %s\n", e -> eb_subject);
4015 printf ("\t using %s", e -> eb_access);
4016 if (e -> eb_mode)
4017 printf (" (in %s mode)", e -> eb_mode);
4018 if (e -> eb_permission)
4019 printf (" (permission %s)", e -> eb_permission);
4020 if (e -> eb_flags == NOTOK)
4021 printf (" [service unavailable]");
4022 printf ("\n");
4023 }
4024 (void) list_content (e -> eb_content, 0);
4025
4026 return OK;
4027 }
4028
4029
4030 static int show_external (ct, serial, alternate)
4031 register CT ct;
4032 int serial,
4033 alternate;
4034 {
4035 register struct exbody *e = (struct exbody *) ct -> c_ctparams;
4036 register CT p = e -> eb_content;
4037
4038 if (!type_ok (p, 0))
4039 return OK;
4040
4041 if (p -> c_ctshowfnx)
4042 return (*p -> c_ctshowfnx) (p, serial, alternate);
4043
4044 content_error (NULLCP, p, "don't know how to display content");
4045 return NOTOK;
4046 }
4047
4048
4049 static int store_external (ct)
4050 register CT ct;
4051 {
4052 int result = NOTOK;
4053 register struct exbody *e = (struct exbody *) ct -> c_ctparams;
4054 register CT p = e -> eb_content;
4055
4056 if (!type_ok (p, 1))
4057 return OK;
4058
4059 p -> c_partno = ct -> c_partno;
4060 if (p -> c_ctstorefnx)
4061 result = (*p -> c_ctstorefnx) (p, NULLCP);
4062 p -> c_partno = NULL;
4063
4064 return result;
4065 }
4066
4067
4068 static int free_external (ct)
4069 register CT ct;
4070 {
4071 register struct exbody *e = (struct exbody *) ct -> c_ctparams;
4072
4073 if (!e)
4074 return;
4075
4076 free_content (e -> eb_content);
4077 if (e -> eb_body)
4078 free (e -> eb_body);
4079
4080 free ((char *) e);
4081 ct -> c_ctparams = NULL;
4082 }
4083
4084
4085 static struct k2v SubMessage[] = {
4086 "rfc822", MESSAGE_RFC822,
4087 "partial", MESSAGE_PARTIAL,
4088 "external-body", MESSAGE_EXTERNAL,
4089
4090 NULL, MESSAGE_UNKNOWN /* this one must be last! */
4091 };
4092
4093 static int InitMessage (ct)
4094 register CT ct;
4095 {
4096 register struct k2v *kv;
4097 register CI ci = &ct -> c_ctinfo;
4098
4099 if (ct -> c_encoding != CE_7BIT) {
4100 admonish (NULLCP,
4101 "\"%s/%s\" type in message %s should be encoded in 7bit",
4102 ci -> ci_type, ci -> ci_subtype, ct -> c_file);
4103 return NOTOK;
4104 }
4105
4106 if (!*ci -> ci_subtype) /* XXX: attmail bogosity! */
4107 ci -> ci_subtype = add ("rfc822", ci -> ci_subtype);
4108 for (kv = SubMessage; kv -> kv_key; kv++)
4109 if (uleq (ci -> ci_subtype, kv -> kv_key))
4110 break;
4111
4112 switch (ct -> c_subtype = kv -> kv_value) {
4113 case MESSAGE_RFC822:
4114 ct -> c_showproc = add ("%pshow -file '%F'", NULLCP);
4115 break;
4116
4117 case MESSAGE_PARTIAL:
4118 {
4119 register char **ap,
4120 **ep;
4121 register struct partial *p;
4122
4123 ct -> c_ctshowfnx = NULL;
4124 ct -> c_ctstorefnx = NULL;
4125
4126 if ((p = (struct partial *) calloc (1, sizeof *p)) == NULL)
4127 adios (NULLCP, "out of memory");
4128 ct -> c_ctparams = (caddr_t) p;
4129 ct -> c_ctfreefnx = free_partial;
4130
4131 for (ap = ci -> ci_attrs, ep = ci -> ci_values;
4132 *ap;
4133 ap++, ep++) {
4134 if (uleq (*ap, "id")) {
4135 p -> pm_partid = add (*ep, NULLCP);
4136
4137 continue;
4138 }
4139
4140 if (uleq (*ap, "number")) {
4141 if (sscanf (*ep, "%d", &p -> pm_partno) != 1
4142 || p -> pm_partno < 1) {
4143 invalid_param: ;
4144 advise (NULLCP,
4145 "invalid %s parameter for \"%s/%s\" type in message %s's %s field",
4146 *ap, ci -> ci_type, ci -> ci_subtype,
4147 ct -> c_file, TYPE_FIELD);
4148 return NOTOK;
4149 }
4150
4151 continue;
4152 }
4153
4154 if (uleq (*ap, "total")) {
4155 if (sscanf (*ep, "%d", &p -> pm_maxno) != 1
4156 || p -> pm_maxno < 1)
4157 goto invalid_param;
4158
4159 continue;
4160 }
4161 }
4162
4163 if (!p -> pm_partid
4164 || !p -> pm_partno
4165 || (p -> pm_maxno && p -> pm_partno > p -> pm_maxno)) {
4166 advise (NULLCP,
4167 "invalid parameters for \"%s/%s\" type in message %s's %s field",
4168 ci -> ci_type, ci -> ci_subtype,
4169 ct -> c_file, TYPE_FIELD);
4170 return NOTOK;
4171 }
4172
4173 ct -> c_ctlistfnx = list_partial;
4174 ct -> c_ctstorefnx = store_partial;
4175 }
4176 break;
4177
4178 case MESSAGE_EXTERNAL:
4179 {
4180 int exresult;
4181 register struct exbody *e;
4182 CT p;
4183 FILE *fp;
4184
4185 ct -> c_ctshowfnx = NULL;
4186 ct -> c_ctstorefnx = NULL;
4187
4188 if ((e = (struct exbody *) calloc (1, sizeof *e)) == NULL)
4189 adios (NULLCP, "out of memory");
4190 ct -> c_ctparams = (caddr_t) e;
4191 ct -> c_ctfreefnx = free_external;
4192
4193 if (!ct -> c_fp
4194 && (ct -> c_fp = fopen (ct -> c_file, "r")) == NULL) {
4195 advise (ct -> c_file, "unable to open for reading");
4196 return NOTOK;
4197 }
4198
4199 (void) fseek (fp = ct -> c_fp, ct -> c_begin, 0);
4200
4201 if ((p = get_content (fp, ct -> c_file, 0)) == NULLCT) {
4202 (void) fclose (ct -> c_fp), ct -> c_fp = NULL;
4203 return NOTOK;
4204 }
4205
4206 e -> eb_parent = ct;
4207 e -> eb_content = p;
4208 p -> c_ctextern = (caddr_t) e;
4209 if ((exresult = params_external (ct, 0)) != NOTOK
4210 && p -> c_ceopenfnx == openMail) {
4211 int cc,
4212 size;
4213 char *bp;
4214
4215 if ((size = ct -> c_end - p -> c_begin) <= 0) {
4216 if (!e -> eb_subject)
4217 content_error (NULLCP, ct,
4218 "empty body for access-type=mail-server");
4219 goto no_body;
4220 }
4221
4222 if ((e -> eb_body = bp = malloc ((unsigned) size)) == NULL)
4223 adios (NULLCP, "out of memory");
4224 (void) fseek (p -> c_fp, p -> c_begin, 0);
4225 while (size > 0)
4226 switch (cc = fread (bp, sizeof *bp, size, p -> c_fp)) {
4227 case NOTOK:
4228 adios ("failed", "fread");
4229
4230 case OK:
4231 adios (NULLCP, "unexpected EOF from fread");
4232
4233 default:
4234 bp += cc, size -= cc;
4235 break;
4236 }
4237 *bp = 0;
4238 no_body: ;
4239 }
4240 p -> c_fp = NULL;
4241 p -> c_end = p -> c_begin;
4242
4243 (void) fclose (ct -> c_fp), ct -> c_fp = NULL;
4244
4245 ct -> c_ctlistfnx = list_external;
4246
4247 if (exresult == NOTOK)
4248 return NOTOK;
4249 if (e -> eb_flags == NOTOK)
4250 return OK;
4251
4252 if (e -> eb_name && autosw) {
4253 char *cp = e -> eb_name;
4254
4255 if (*cp != '/'
4256 && *cp != '.'
4257 && *cp != '|'
4258 && *cp != '!'
4259 && !index (cp, '%')) {
4260 if (!ct -> c_storeproc)
4261 ct -> c_storeproc = add (cp, NULLCP);
4262 if (!p -> c_storeproc)
4263 p -> c_storeproc = add (cp, NULLCP);
4264 }
4265 }
4266
4267 ct -> c_ctshowfnx = show_external;
4268 ct -> c_ctstorefnx = store_external;
4269 switch (p -> c_type) {
4270 case CT_MULTIPART:
4271 break;
4272
4273 case CT_MESSAGE:
4274 if (p -> c_subtype != MESSAGE_RFC822)
4275 break;
4276 /* else fall... */
4277 default:
4278 e -> eb_partno = ct -> c_partno;
4279 if (p -> c_ctinitfnx)
4280 (void) (*p -> c_ctinitfnx) (p);
4281 break;
4282 }
4283 }
4284 break;
4285
4286 default:
4287 break;
4288 }
4289
4290 return OK;
4291 }
4292
4293 /* \f APPLICATION */
4294
4295 #define APPLICATION_UNKNOWN 0x00
4296 #define APPLICATION_OCTETS 0x01
4297 #define APPLICATION_POSTSCRIPT 0x02
4298
4299
4300 static int list_application (ct, toplevel)
4301 register CT ct;
4302 int toplevel;
4303 {
4304 (void) list_content (ct, toplevel);
4305 if (verbosw) {
4306 register char **ap,
4307 **ep;
4308 register CI ci = &ct -> c_ctinfo;
4309
4310 for (ap = ci -> ci_attrs, ep = ci -> ci_values; *ap; ap++, ep++)
4311 printf ("\t %s=\"%s\"\n", *ap, *ep);
4312 }
4313
4314 return OK;
4315 }
4316
4317
4318 static struct k2v SubApplication[] = {
4319 "octet-stream", APPLICATION_OCTETS,
4320 "postscript", APPLICATION_POSTSCRIPT,
4321 NULL, APPLICATION_UNKNOWN /* this one must be last! */
4322 };
4323
4324 static int InitApplication (ct)
4325 register CT ct;
4326 {
4327 register char **ap,
4328 **ep;
4329 register struct k2v *kv;
4330 register CI ci = &ct -> c_ctinfo;
4331
4332 ct -> c_ctlistfnx = list_application;
4333
4334 for (kv = SubApplication; kv -> kv_key; kv++)
4335 if (uleq (ci -> ci_subtype, kv -> kv_key))
4336 break;
4337
4338 for (ap = ci -> ci_attrs, ep = ci -> ci_values; *ap; ap++, ep++)
4339 if (autosw && !ct -> c_storeproc && uleq (*ap, "name")) {
4340 register char *cp;
4341
4342 if (*(cp = *ep) != '/'
4343 && *cp != '.'
4344 && *cp != '|'
4345 && *cp != '!'
4346 && !index (cp, '%'))
4347 ct -> c_storeproc = add (cp, NULLCP);
4348 }
4349
4350 if ((ct -> c_subtype = kv -> kv_value) == APPLICATION_OCTETS) {
4351 int tarP,
4352 zP;
4353
4354 tarP = zP = 0;
4355 for (ap = ci -> ci_attrs, ep = ci -> ci_values; *ap; ap++, ep++) {
4356 if (uleq (*ap, "type")) {
4357 if (!uleq (*ep, "tar"))
4358 break;
4359
4360 tarP = 1;
4361 continue;
4362 }
4363
4364 if ((uleq (*ap, "conversions") || uleq (*ap, "x-conversions"))
4365 && (uleq (*ep, "compress") || uleq (*ep, "x-compress"))) {
4366 zP = 1;
4367 continue;
4368 }
4369 }
4370
4371 if (tarP) {
4372 ct -> c_showproc = add (zP ? "%euncompress | tar tvf -"
4373 : "%etar tvf -", NULLCP);
4374 if (!ct -> c_storeproc)
4375 if (autosw) {
4376 ct -> c_storeproc = add (zP ? "| uncompress | tar xvpf -"
4377 : "| tar xvpf -", NULLCP);
4378 ct -> c_umask = 0022;
4379 }
4380 else
4381 ct -> c_storeproc = add (zP ? "%m%P.tar.Z" : "%m%P.tar",
4382 NULLCP);
4383 }
4384 }
4385
4386 return OK;
4387 }
4388
4389 /* \f ENCODINGS */
4390
4391 #include "md5.c"
4392
4393
4394 struct cefile {
4395 char *ce_file;
4396 int ce_unlink;
4397
4398 FILE *ce_fp;
4399 };
4400
4401
4402 static int list_encoding (ct)
4403 register CT ct;
4404 {
4405 register struct cefile *ce = (struct cefile *) ct -> c_ceparams;
4406
4407 if (ce)
4408 fprintf (stderr, " decoded fp 0x%x file \"%s\"\n", ce -> ce_fp,
4409 ce -> ce_file ? ce -> ce_file : "");
4410
4411 return OK;
4412 }
4413
4414
4415 static int close_encoding (ct)
4416 register CT ct;
4417 {
4418 register struct cefile *ce = (struct cefile *) ct -> c_ceparams;
4419
4420 if (!ce)
4421 return;
4422
4423 if (ce -> ce_fp) {
4424 (void) fclose (ce -> ce_fp);
4425 ce -> ce_fp = NULL;
4426 }
4427 }
4428
4429
4430 static unsigned long size_encoding (ct)
4431 register CT ct;
4432 {
4433 int fd;
4434 unsigned long size;
4435 char *file;
4436 register struct cefile *ce = (struct cefile *) ct -> c_ceparams;
4437 struct stat st;
4438
4439 if (!ce) {
4440 estimate: ;
4441
4442 return (ct -> c_end - ct -> c_begin);
4443 }
4444
4445 if (ce -> ce_fp && fstat (fileno (ce -> ce_fp), &st) != NOTOK)
4446 return (long) st.st_size;
4447
4448 if (ce -> ce_file)
4449 return stat (ce -> ce_file, &st) != NOTOK ? (long) st.st_size : 0L;
4450
4451 if (ct -> c_encoding == CE_EXTERNAL)
4452 goto estimate;
4453
4454 file = NULL;
4455 if ((fd = (*ct -> c_ceopenfnx) (ct, &file)) == NOTOK)
4456 goto estimate;
4457
4458 size = fstat (fd, &st) != NOTOK ? (long) st.st_size : 0L;
4459
4460 (*ct -> c_ceclosefnx) (ct);
4461
4462 return size;
4463 }
4464
4465
4466 static int free_encoding (ct, toplevel)
4467 register CT ct;
4468 int toplevel;
4469 {
4470 register struct cefile *ce = (struct cefile *) ct -> c_ceparams;
4471
4472 if (!ce)
4473 return;
4474
4475 if (ce -> ce_fp) {
4476 (void) fclose (ce -> ce_fp);
4477 ce -> ce_fp = NULL;
4478 }
4479
4480 if (ce -> ce_file) {
4481 if (ce -> ce_unlink)
4482 (void) unlink (ce -> ce_file);
4483 free (ce -> ce_file);
4484 }
4485
4486 if (toplevel) {
4487 free ((char *) ce);
4488 ct -> c_ceparams = NULL;
4489 }
4490 else
4491 ct -> c_ceopenfnx = NULL;
4492 }
4493
4494
4495 static init_encoding (ct, openfnx)
4496 register CT ct;
4497 int (*openfnx) ();
4498 {
4499 register struct cefile *ce;
4500
4501 if ((ce = (struct cefile *) calloc (1, sizeof *ce)) == NULL)
4502 adios (NULLCP, "out of memory");
4503
4504 ct -> c_ceparams = (caddr_t) ce;
4505 ct -> c_ceopenfnx = openfnx;
4506 ct -> c_ceclosefnx = close_encoding;
4507 ct -> c_cesizefnx = size_encoding;
4508 ct -> c_celistfnx = list_encoding;
4509 ct -> c_cefreefnx = free_encoding;
4510
4511 return OK;
4512 }
4513
4514 /* \f BASE64 */
4515
4516 static unsigned char b642nib[0x80] = {
4517 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
4518 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
4519 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
4520 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
4521 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
4522 0xff, 0xff, 0xff, 0x3e, 0xff, 0xff, 0xff, 0x3f,
4523 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b,
4524 0x3c, 0x3d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
4525 0xff, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
4526 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
4527 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16,
4528 0x17, 0x18, 0x19, 0xff, 0xff, 0xff, 0xff, 0xff,
4529 0xff, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
4530 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
4531 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
4532 0x31, 0x32, 0x33, 0xff, 0xff, 0xff, 0xff, 0xff
4533 };
4534
4535
4536 static int openBase64 (ct, file)
4537 register CT ct;
4538 char **file;
4539 {
4540 int bitno,
4541 cc,
4542 digested,
4543 fd,
4544 len,
4545 skip;
4546 unsigned long bits;
4547 register char *cp,
4548 *ep;
4549 unsigned char value,
4550 *b = (unsigned char *) &bits,
4551 *b1 = &b[endian > 0 ? 1 : 2],
4552 *b2 = &b[endian > 0 ? 2 : 1],
4553 *b3 = &b[endian > 0 ? 3 : 0];
4554 char buffer[BUFSIZ];
4555 register struct cefile *ce = (struct cefile *) ct -> c_ceparams;
4556 MD5_CTX mdContext;
4557
4558 if (ce -> ce_fp)
4559 goto ready_to_go;
4560 if (ce -> ce_file) {
4561 if ((ce -> ce_fp = fopen (ce -> ce_file, "r")) == NULL) {
4562 content_error (ce -> ce_file, ct, "unable to fopen for reading");
4563 return NOTOK;
4564 }
4565
4566 *file = ce -> ce_file;
4567 return fileno (ce -> ce_fp);
4568 }
4569
4570 ce -> ce_unlink = *file == NULL;
4571 if ((ce -> ce_fp = fopen (ce -> ce_file =
4572 add (*file ? *file : m_scratch ("", tmp),
4573 NULLCP),
4574 "w+")) == NULL) {
4575 content_error (ce -> ce_file, ct,
4576 "unable to fopen for writing and reading");
4577 return NOTOK;
4578 }
4579
4580 if ((len = ct -> c_end - ct -> c_begin) < 0)
4581 adios (NULLCP, "internal error(1)");
4582
4583 if (!ct -> c_fp && (ct -> c_fp = fopen (ct -> c_file, "r")) == NULL) {
4584 content_error (ct -> c_file, ct, "unable to open for reading");
4585 return NOTOK;
4586 }
4587
4588 if (digested = ct -> c_digested)
4589 MD5Init (&mdContext);
4590
4591 (void) lseek (fd = fileno (ct -> c_fp), (off_t)ct -> c_begin, 0);
4592 bitno = 18, bits = 0L, skip = 0;
4593 while (len > 0)
4594 switch (cc = read (fd, buffer, sizeof buffer - 1)) {
4595 case NOTOK:
4596 content_error (ct -> c_file, ct, "error reading from");
4597 goto clean_up;
4598
4599 case OK:
4600 content_error (NULLCP, ct, "premature eof");
4601 goto clean_up;
4602
4603 default:
4604 if (cc > len)
4605 cc = len;
4606 len -= cc;
4607
4608 for (ep = (cp = buffer) + cc; cp < ep; cp++)
4609 switch (*cp) {
4610 default:
4611 if (isspace (*cp))
4612 break;
4613 if (skip
4614 || (*cp & 0x80)
4615 || (value = b642nib[*cp & 0x7f]) > 0x3f) {
4616 if (debugsw)
4617 fprintf (stderr,
4618 "*cp=0x%x pos=%ld skip=%d\n", *cp,
4619 (long) lseek (fd, (off_t)0, 1) - (ep - cp),
4620 skip);
4621 content_error (NULLCP, ct,
4622 "invalid BASE64 encoding -- continuing");
4623 continue;
4624 }
4625
4626 bits |= value << bitno;
4627 test_end: ;
4628 if ((bitno -= 6) < 0) {
4629 (void) putc ((char) *b1, ce -> ce_fp);
4630 if (digested)
4631 MD5Update (&mdContext, b1, 1);
4632 if (skip < 2) {
4633 (void) putc ((char) *b2, ce -> ce_fp);
4634 if (digested)
4635 MD5Update (&mdContext, b2, 1);
4636 if (skip < 1) {
4637 (void) putc ((char) *b3, ce -> ce_fp);
4638 if (digested)
4639 MD5Update (&mdContext, b3, 1);
4640 }
4641 }
4642
4643 if (ferror (ce -> ce_fp)) {
4644 content_error (ce -> ce_file, ct,
4645 "error writing to");
4646 goto clean_up;
4647 }
4648 bitno = 18, bits = 0L, skip = 0;
4649 }
4650 break;
4651
4652 case '=':
4653 if (++skip > 3)
4654 goto self_delimiting;
4655 goto test_end;
4656 }
4657 }
4658 if (bitno != 18) {
4659 if (debugsw)
4660 fprintf (stderr, "premature ending (bitno %d)\n", bitno);
4661
4662 content_error (NULLCP, ct, "invalid BASE64 encoding");
4663 goto clean_up;
4664 }
4665 self_delimiting: ;
4666 (void) fseek (ct -> c_fp, 0L, 0);
4667
4668 if (fflush (ce -> ce_fp)) {
4669 content_error (ce -> ce_file, ct, "error writing to");
4670 goto clean_up;
4671 }
4672
4673 if (digested) {
4674 unsigned char digest[16];
4675
4676 MD5Final (digest, &mdContext);
4677 if (bcmp ((char *) digest, (char *) ct -> c_digest,
4678 sizeof digest / sizeof digest[0]))
4679 content_error (NULLCP, ct,
4680 "content integrity suspect (digest mismatch) -- continuing");
4681 else
4682 if (debugsw)
4683 fprintf (stderr, "content integrity confirmed\n");
4684 }
4685
4686 ready_to_go: ;
4687 (void) fseek (ce -> ce_fp, 0L, 0);
4688 *file = ce -> ce_file;
4689 return fileno (ce -> ce_fp);
4690
4691 clean_up: ;
4692 free_encoding (ct, 0);
4693
4694 return NOTOK;
4695 }
4696
4697
4698 static int InitBase64 (ct)
4699 register CT ct;
4700 {
4701 return init_encoding (ct, openBase64);
4702 }
4703
4704
4705 static int set_endian ()
4706 {
4707 char *cp;
4708 union {
4709 long l;
4710 char c[sizeof (long)];
4711 } un;
4712
4713 un.l = 1;
4714 endian = un.c[0] ? -1 : 1;
4715 if (debugsw)
4716 fprintf (stderr, "%s endian architecture\n",
4717 endian > 0 ? "big" : "little");
4718
4719 mm_charset = getenv ("MM_CHARSET");
4720
4721 if ((cp = getenv ("MM_NOASK")) && strcmp (cp, "1") == 0) {
4722 nolist = 1, pausesw = 0;
4723 if (showsw)
4724 listsw = 0;
4725 }
4726 }
4727
4728 /* \f QUOTED */
4729
4730 static char hex2nib[0x80] = {
4731 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4732 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4733 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4734 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4735 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4736 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4737 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
4738 0x08, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4739 0x00, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x00,
4740 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4741 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4742 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4743 0x00, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x00,
4744 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4745 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4746 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
4747 };
4748
4749
4750 static int openQuoted (ct, file)
4751 register CT ct;
4752 char **file;
4753 {
4754 int cc,
4755 digested,
4756 len,
4757 quoted;
4758 register char *cp,
4759 *ep;
4760 char buffer[BUFSIZ];
4761 unsigned char mask;
4762 register struct cefile *ce = (struct cefile *) ct -> c_ceparams;
4763 MD5_CTX mdContext;
4764
4765 if (ce -> ce_fp)
4766 goto ready_to_go;
4767 if (ce -> ce_file) {
4768 if ((ce -> ce_fp = fopen (ce -> ce_file, "r")) == NULL) {
4769 content_error (ce -> ce_file, ct, "unable to fopen for reading");
4770 return NOTOK;
4771 }
4772
4773 *file = ce -> ce_file;
4774 return fileno (ce -> ce_fp);
4775 }
4776
4777 ce -> ce_unlink = *file == NULL;
4778 if ((ce -> ce_fp = fopen (ce -> ce_file =
4779 add (*file ? *file : m_scratch ("", tmp),
4780 NULLCP),
4781 "w+")) == NULL) {
4782 content_error (ce -> ce_file, ct,
4783 "unable to fopen for writing and reading");
4784 return NOTOK;
4785 }
4786
4787 if ((len = ct -> c_end - ct -> c_begin) < 0)
4788 adios (NULLCP, "internal error(2)");
4789
4790 if (!ct -> c_fp && (ct -> c_fp = fopen (ct -> c_file, "r")) == NULL) {
4791 content_error (ct -> c_file, ct, "unable to open for reading");
4792 return NOTOK;
4793 }
4794
4795 if (digested = ct -> c_digested)
4796 MD5Init (&mdContext);
4797
4798 (void) fseek (ct -> c_fp, ct -> c_begin, 0);
4799 quoted = 0;
4800 #ifdef lint
4801 mask = 0;
4802 #endif
4803 while (len > 0) {
4804 char *dp;
4805
4806 if (fgets (buffer, sizeof buffer - 1, ct -> c_fp) == NULL) {
4807 content_error (NULLCP, ct, "premature eof");
4808 goto clean_up;
4809 }
4810
4811 if ((cc = strlen (buffer)) > len)
4812 cc = len;
4813 len -= cc;
4814
4815 for (ep = (cp = buffer) + cc - 1; cp <= ep; ep--)
4816 if (!isspace (*ep))
4817 break;
4818 *++ep = '\n', ep++;
4819
4820 for (; cp < ep; cp++) {
4821 if (quoted) {
4822 if (quoted > 1) {
4823 if (!isxdigit (*cp)) {
4824 invalid_hex: ;
4825 dp = "expecting hexidecimal-digit";
4826 goto invalid_encoding;
4827 }
4828 mask <<= 4;
4829 mask |= hex2nib[*cp & 0x7f];
4830 (void) putc (mask, ce -> ce_fp);
4831 if (digested)
4832 MD5Update (&mdContext, &mask, 1);
4833 }
4834 else
4835 switch (*cp) {
4836 case ':':
4837 (void) putc (*cp, ce -> ce_fp);
4838 if (digested)
4839 MD5Update (&mdContext, (unsigned char *) ":",
4840 1);
4841 break;
4842
4843 default:
4844 if (!isxdigit (*cp))
4845 goto invalid_hex;
4846 mask = hex2nib[*cp & 0x7f];
4847 quoted = 2;
4848 continue;
4849 }
4850
4851 if (ferror (ce -> ce_fp)) {
4852 content_error (ce -> ce_file, ct, "error writing to");
4853 goto clean_up;
4854 }
4855 quoted = 0;
4856 continue;
4857 }
4858
4859 switch (*cp) {
4860 default:
4861 if (*cp < '!' || *cp > '~') {
4862 int i;
4863 dp = "expecting character in range [!..~]";
4864
4865 invalid_encoding: ;
4866 i = strlen (invo_name) + 2;
4867 content_error (NULLCP, ct,
4868 "invalid QUOTED-PRINTABLE encoding -- %s,\n%*.*sbut got char 0x%x",
4869 dp, i, i, "", *cp);
4870 goto clean_up;
4871 }
4872 /* and fall...*/
4873 case ' ':
4874 case '\t':
4875 case '\n':
4876 (void) putc (*cp, ce -> ce_fp);
4877 if (digested) {
4878 if (*cp == '\n')
4879 MD5Update (&mdContext, (unsigned char *) "\r\n",2);
4880 else
4881 MD5Update (&mdContext, (unsigned char *) cp, 1);
4882 }
4883 if (ferror (ce -> ce_fp)) {
4884 content_error (ce -> ce_file, ct, "error writing to");
4885 goto clean_up;
4886 }
4887 break;
4888
4889 case '=':
4890 if (*++cp != '\n') {
4891 quoted = 1;
4892 cp--;
4893 }
4894 break;
4895 }
4896 }
4897 }
4898 if (quoted) {
4899 content_error (NULLCP, ct,
4900 "invalid QUOTED-PRINTABLE encoding -- end-of-content while still quoting");
4901 goto clean_up;
4902 }
4903 (void) fseek (ct -> c_fp, 0L, 0);
4904
4905 if (fflush (ce -> ce_fp)) {
4906 content_error (ce -> ce_file, ct, "error writing to");
4907 goto clean_up;
4908 }
4909
4910 if (digested) {
4911 unsigned char digest[16];
4912
4913 MD5Final (digest, &mdContext);
4914 if (bcmp ((char *) digest, (char *) ct -> c_digest,
4915 sizeof digest / sizeof digest[0]))
4916 content_error (NULLCP, ct,
4917 "content integrity suspect (digest mismatch) -- continuing");
4918 else
4919 if (debugsw)
4920 fprintf (stderr, "content integrity confirmed\n");
4921 }
4922
4923 ready_to_go: ;
4924 (void) fseek (ce -> ce_fp, 0L, 0);
4925 *file = ce -> ce_file;
4926 return fileno (ce -> ce_fp);
4927
4928 clean_up: ;
4929 free_encoding (ct, 0);
4930
4931 return NOTOK;
4932 }
4933
4934
4935 static int InitQuoted (ct)
4936 register CT ct;
4937 {
4938 return init_encoding (ct, openQuoted);
4939 }
4940
4941 /* \f 7BIT */
4942
4943 static int open7Bit (ct, file)
4944 register CT ct;
4945 char **file;
4946 {
4947 int cc,
4948 fd,
4949 len;
4950 char buffer[BUFSIZ];
4951 register struct cefile *ce = (struct cefile *) ct -> c_ceparams;
4952
4953 if (ce -> ce_fp)
4954 goto ready_to_go;
4955 if (ce -> ce_file) {
4956 if ((ce -> ce_fp = fopen (ce -> ce_file, "r")) == NULL) {
4957 content_error (ce -> ce_file, ct, "unable to fopen for reading");
4958 return NOTOK;
4959 }
4960
4961 *file = ce -> ce_file;
4962 return fileno (ce -> ce_fp);
4963 }
4964
4965 ce -> ce_unlink = *file == NULL;
4966 if ((ce -> ce_fp = fopen (ce -> ce_file =
4967 add (*file ? *file : m_scratch ("", tmp),
4968 NULLCP),
4969 "w+")) == NULL) {
4970 content_error (ce -> ce_file, ct,
4971 "unable to fopen for writing and reading");
4972 return NOTOK;
4973 }
4974
4975 if (ct -> c_type == CT_MULTIPART) {
4976 register char **ap,
4977 **ep;
4978 register CI ci = &ct -> c_ctinfo;
4979
4980 len = 0;
4981
4982 fprintf (ce -> ce_fp, "%s: %s/%s", TYPE_FIELD, ci -> ci_type,
4983 ci -> ci_subtype);
4984 len += strlen (TYPE_FIELD) + 2 + strlen (ci -> ci_type)
4985 + 1 + strlen (ci -> ci_subtype);
4986 for (ap = ci -> ci_attrs, ep = ci -> ci_values; *ap; ap++, ep++) {
4987 (void) putc (';', ce -> ce_fp);
4988 len++;
4989
4990 (void) sprintf (buffer, "%s=\"%s\"", *ap, *ep);
4991
4992 if (len + 1 + (cc = strlen (buffer)) >= CPERLIN) {
4993 (void) fputs ("\n\t", ce -> ce_fp);
4994 len = 8;
4995 }
4996 else {
4997 (void) putc (' ', ce -> ce_fp);
4998 len++;
4999 }
5000 fprintf (ce -> ce_fp, "%s", buffer);
5001 len += cc;
5002 }
5003 if (ci -> ci_comment) {
5004 if (len + 1 + (cc = 2 + strlen (ci -> ci_comment)) >= CPERLIN) {
5005 (void) fputs ("\n\t", ce -> ce_fp);
5006 len = 8;
5007 }
5008 else {
5009 (void) putc (' ', ce -> ce_fp);
5010 len++;
5011 }
5012 fprintf (ce -> ce_fp, "(%s)", ci -> ci_comment);
5013 len += cc;
5014 }
5015 fprintf (ce -> ce_fp, "\n");
5016 if (ct -> c_id)
5017 fprintf (ce -> ce_fp, "%s:%s", ID_FIELD, ct -> c_id);
5018 if (ct -> c_descr)
5019 fprintf (ce -> ce_fp, "%s:%s", DESCR_FIELD, ct -> c_descr);
5020 fprintf (ce -> ce_fp, "\n");
5021 }
5022
5023 if ((len = ct -> c_end - ct -> c_begin) < 0)
5024 adios (NULLCP, "internal error(3)");
5025
5026 if (!ct -> c_fp && (ct -> c_fp = fopen (ct -> c_file, "r")) == NULL) {
5027 content_error (ct -> c_file, ct, "unable to open for reading");
5028 return NOTOK;
5029 }
5030
5031 (void) lseek (fd = fileno (ct -> c_fp), (off_t) ct -> c_begin, 0);
5032 while (len > 0)
5033 switch (cc = read (fd, buffer, sizeof buffer - 1)) {
5034 case NOTOK:
5035 content_error (ct -> c_file, ct, "error reading from");
5036 goto clean_up;
5037
5038 case OK:
5039 content_error (NULLCP, ct, "premature eof");
5040 goto clean_up;
5041
5042 default:
5043 if (cc > len)
5044 cc = len;
5045 len -= cc;
5046
5047 (void) fwrite (buffer, sizeof *buffer, cc, ce -> ce_fp);
5048 if (ferror (ce -> ce_fp)) {
5049 content_error (ce -> ce_file, ct, "error writing to");
5050 goto clean_up;
5051 }
5052 }
5053 (void) fseek (ct -> c_fp, 0L, 0);
5054
5055 if (fflush (ce -> ce_fp)) {
5056 content_error (ce -> ce_file, ct, "error writing to");
5057 goto clean_up;
5058 }
5059
5060 ready_to_go: ;
5061 (void) fseek (ce -> ce_fp, 0L, 0);
5062 *file = ce -> ce_file;
5063 return fileno (ce -> ce_fp);
5064
5065 clean_up: ;
5066 free_encoding (ct, 0);
5067
5068 return NOTOK;
5069 }
5070
5071
5072 static int Init7Bit (ct)
5073 register CT ct;
5074 {
5075 if (init_encoding (ct, open7Bit) == NOTOK)
5076 return NOTOK;
5077 ct -> c_cesizefnx = NULL;
5078
5079 return OK;
5080 }
5081
5082 /* \f External */
5083
5084 static int openExternal (ct, cb, ce, file, fd)
5085 register CT ct;
5086 CT cb;
5087 struct cefile *ce;
5088 char **file;
5089 int *fd;
5090 {
5091 char cachefile[BUFSIZ];
5092
5093 if (ce -> ce_fp) {
5094 (void) fseek (ce -> ce_fp, 0L, 0);
5095
5096 ready_already: ;
5097 *file = ce -> ce_file, *fd = fileno (ce -> ce_fp);
5098 return DONE;
5099 }
5100
5101 if (ce -> ce_file) {
5102 if ((ce -> ce_fp = fopen (ce -> ce_file, "r")) == NULL) {
5103 content_error (ce -> ce_file, ct, "unable to fopen for reading");
5104 return NOTOK;
5105 }
5106
5107 goto ready_already;
5108 }
5109
5110 if (find_cache (ct, rcachesw, (int *) 0, cb -> c_id, cachefile) != NOTOK) {
5111 if (ce -> ce_fp = fopen (cachefile, "r")) {
5112 ce -> ce_unlink = 0;
5113 ce -> ce_file = getcpy (cachefile);
5114 goto ready_already;
5115 }
5116 else
5117 admonish (cachefile, "unable to fopen for reading");
5118 }
5119
5120 return OK;
5121 }
5122
5123 /* \f File */
5124
5125 static int openFile (ct, file)
5126 register CT ct;
5127 char **file;
5128 {
5129 int fd,
5130 cachetype;
5131 char cachefile[BUFSIZ];
5132 register struct exbody *e = (struct exbody *) ct -> c_ctextern;
5133 register struct cefile *ce = (struct cefile *) ct -> c_ceparams;
5134
5135 switch (openExternal (e -> eb_parent, e -> eb_content, ce, file, &fd)) {
5136 case NOTOK:
5137 return NOTOK;
5138
5139 case OK:
5140 break;
5141
5142 case DONE:
5143 return fd;
5144 }
5145
5146 if (!e -> eb_name) {
5147 content_error (NULLCP, ct, "missing name parameter");
5148 return NOTOK;
5149 }
5150
5151 ce -> ce_unlink = 0;
5152 if ((ce -> ce_fp = fopen (ce -> ce_file = getcpy (e -> eb_name), "r"))
5153 == NULL) {
5154 content_error (ce -> ce_file, ct, "unable to fopen for reading");
5155 return NOTOK;
5156 }
5157
5158 if ((!e -> eb_permission || !uleq (e -> eb_permission, "read-write"))
5159 && find_cache (NULLCT, wcachesw, &cachetype,
5160 e -> eb_content -> c_id, cachefile) != NOTOK) {
5161 int mask;
5162 FILE *fp;
5163
5164 mask = umask (cachetype ? ~m_gmprot () : 0222);
5165 if (fp = fopen (cachefile, "w")) {
5166 int cc;
5167 char buffer[BUFSIZ];
5168 FILE *gp = ce -> ce_fp;
5169
5170 (void) fseek (gp, 0L, 0);
5171
5172 while ((cc = fread (buffer, sizeof *buffer, sizeof buffer, gp))
5173 > 0)
5174 (void) fwrite (buffer, sizeof *buffer, cc, fp);
5175 (void) fflush (fp);
5176
5177 if (ferror (gp)) {
5178 admonish (ce -> ce_file, "error reading");
5179 (void) unlink (cachefile);
5180 }
5181 else
5182 if (ferror (fp)) {
5183 admonish (cachefile, "error writing");
5184 (void) unlink (cachefile);
5185 }
5186 (void) fclose (fp);
5187 }
5188 (void) umask (mask);
5189 }
5190
5191 (void) fseek (ce -> ce_fp, 0L, 0);
5192 *file = ce -> ce_file;
5193 return fileno (ce -> ce_fp);
5194 }
5195
5196 /* \f FTP */
5197
5198 static int openFTP (ct, file)
5199 register CT ct;
5200 char **file;
5201 {
5202 int cachetype,
5203 caching,
5204 fd;
5205 char *bp,
5206 *ftp,
5207 *user,
5208 *pass,
5209 buffer[BUFSIZ],
5210 cachefile[BUFSIZ];
5211 register struct exbody *e = (struct exbody *) ct -> c_ctextern;
5212 register struct cefile *ce = (struct cefile *) ct -> c_ceparams;
5213 static char *username = NULL;
5214 static char *password = NULL;
5215
5216 (void) sprintf (buffer, "%s-access-ftp", invo_name);
5217 if ((ftp = m_find (buffer)) && !*ftp)
5218 ftp = NULLCP;
5219 #ifndef FTP
5220 if (!ftp)
5221 return NOTOK;
5222 #endif
5223 switch (openExternal (e -> eb_parent, e -> eb_content, ce, file, &fd)) {
5224 case NOTOK:
5225 return NOTOK;
5226
5227 case OK:
5228 break;
5229
5230 case DONE:
5231 return fd;
5232 }
5233
5234 if (!e -> eb_name || !e -> eb_site) {
5235 content_error (NULLCP, ct, "missing %s parameter",
5236 e -> eb_name ? "site": "name");
5237 return NOTOK;
5238 }
5239
5240 if (xpid) {
5241 if (xpid < 0)
5242 xpid = -xpid;
5243 (void) pidcheck (pidwait (xpid, NOTOK));
5244 xpid = 0;
5245 }
5246
5247 bp = buffer;
5248 (void) sprintf (bp, "Retrieve %s", e -> eb_name);
5249 bp += strlen (bp);
5250 if (e -> eb_partno) {
5251 (void) sprintf (bp, " (content %s)", e -> eb_partno);
5252 bp += strlen (bp);
5253 }
5254 (void) sprintf (bp, "\n using %sFTP from site %s",
5255 e -> eb_flags ? "anonymous " : "", e -> eb_site);
5256 bp += strlen (bp);
5257 if (e -> eb_size > 0) {
5258 (void) sprintf (bp, " (%lu octets)", e -> eb_size);
5259 bp += strlen (bp);
5260 }
5261 (void) sprintf (bp, "? ");
5262 if (!getanswer (buffer))
5263 return NOTOK;
5264
5265 if (e -> eb_flags) {
5266 user = "anonymous";
5267 (void) sprintf (pass = buffer, "%s@@%s", getusr (), LocalName ());
5268 }
5269 else {
5270 ruserpass (e -> eb_site, &username, &password);
5271 user = username, pass = password;
5272 }
5273
5274 ce -> ce_unlink = *file == NULL, caching = 0, cachefile[0] = 0;
5275 if ((!e -> eb_permission || !uleq (e -> eb_permission, "read-write"))
5276 && find_cache (NULLCT, wcachesw, &cachetype,
5277 e -> eb_content -> c_id, cachefile) != NOTOK) {
5278 if (*file == NULL) {
5279 ce -> ce_unlink = 0;
5280 caching = 1;
5281 }
5282 }
5283
5284 if ((ce -> ce_fp = fopen (ce -> ce_file =
5285 add (*file ? *file
5286 : caching ? cachefile
5287 : m_scratch ("", tmp),
5288 NULLCP),
5289 "w+")) == NULL) {
5290 content_error (ce -> ce_file, ct,
5291 "unable to fopen for writing and reading");
5292 return NOTOK;
5293 }
5294
5295 #ifdef FTP
5296 if (ftp)
5297 #endif
5298 {
5299 int child_id,
5300 i,
5301 vecp;
5302 char *vec[9];
5303
5304 vecp = 0;
5305 vec[vecp++] = r1bindex (ftp, '/');
5306 vec[vecp++] = e -> eb_site;
5307 vec[vecp++] = user;
5308 vec[vecp++] = pass;
5309 vec[vecp++] = e -> eb_dir;
5310 vec[vecp++] = e -> eb_name;
5311 vec[vecp++] = ce -> ce_file,
5312 vec[vecp++] = e -> eb_mode && uleq (e -> eb_mode, "ascii")
5313 ? "ascii" : "binary";
5314 vec[vecp] = NULL;
5315
5316 (void) fflush (stdout);
5317
5318 for (i = 0; (child_id = vfork ()) == NOTOK && i < 5; i++)
5319 sleep (5);
5320 switch (child_id) {
5321 case NOTOK:
5322 adios ("fork", "unable to");
5323 /* NOTREACHED */
5324
5325 case OK:
5326 (void) close (fileno (ce -> ce_fp));
5327 (void) execvp (ftp, vec);
5328 fprintf (stderr, "unable to exec ");
5329 perror (ftp);
5330 _exit (-1);
5331 /* NOTREACHED */
5332
5333 default:
5334 if (pidXwait (child_id, NULLCP)) {
5335 #ifdef FTP
5336 losing_ftp: ;
5337 #endif
5338 username = password = NULL;
5339 ce -> ce_unlink = 1;
5340 return NOTOK;
5341 }
5342 break;
5343 }
5344 }
5345 #ifdef FTP
5346 else
5347 if (ftp_get (e -> eb_site, user, pass, e -> eb_dir, e -> eb_name,
5348 ce -> ce_file,
5349 !e -> eb_mode || uleq (e -> eb_mode, "ascii"), 0)
5350 == NOTOK)
5351 goto losing_ftp;
5352 #endif
5353
5354 if (cachefile[0])
5355 if (caching)
5356 (void) chmod (cachefile, cachetype ? m_gmprot () : 0444);
5357 else {
5358 int mask;
5359 FILE *fp;
5360
5361 mask = umask (cachetype ? ~m_gmprot () : 0222);
5362 if (fp = fopen (cachefile, "w")) {
5363 int cc;
5364 FILE *gp = ce -> ce_fp;
5365
5366 (void) fseek (gp, 0L, 0);
5367
5368 while ((cc = fread (buffer, sizeof *buffer, sizeof buffer, gp))
5369 > 0)
5370 (void) fwrite (buffer, sizeof *buffer, cc, fp);
5371 (void) fflush (fp);
5372
5373 if (ferror (gp)) {
5374 admonish (ce -> ce_file, "error reading");
5375 (void) unlink (cachefile);
5376 }
5377 else
5378 if (ferror (fp)) {
5379 admonish (cachefile, "error writing");
5380 (void) unlink (cachefile);
5381 }
5382 (void) fclose (fp);
5383 }
5384 (void) umask (mask);
5385 }
5386
5387 (void) fseek (ce -> ce_fp, 0L, 0);
5388 *file = ce -> ce_file;
5389 return fileno (ce -> ce_fp);
5390 }
5391
5392 /* \f Mail */
5393
5394 static int openMail (ct, file)
5395 register CT ct;
5396 char **file;
5397 {
5398 int child_id,
5399 fd,
5400 i,
5401 vecp;
5402 char *bp,
5403 buffer[BUFSIZ],
5404 *vec[7];
5405 register struct exbody *e = (struct exbody *) ct -> c_ctextern;
5406 register struct cefile *ce = (struct cefile *) ct -> c_ceparams;
5407
5408 switch (openExternal (e -> eb_parent, e -> eb_content, ce, file, &fd)) {
5409 case NOTOK:
5410 return NOTOK;
5411
5412 case OK:
5413 break;
5414
5415 case DONE:
5416 return fd;
5417 }
5418
5419 if (!e -> eb_server) {
5420 content_error (NULLCP, ct, "missing server parameter");
5421 return NOTOK;
5422 }
5423
5424 if (xpid) {
5425 if (xpid < 0)
5426 xpid = -xpid;
5427 (void) pidcheck (pidwait (xpid, NOTOK));
5428 xpid = 0;
5429 }
5430
5431 bp = buffer;
5432 (void) sprintf (bp, "Retrieve content");
5433 bp += strlen (bp);
5434 if (e -> eb_partno) {
5435 (void) sprintf (bp, " %s", e -> eb_partno);
5436 bp += strlen (bp);
5437 }
5438 (void) sprintf (bp, " by asking %s\n\n%s\n? ",
5439 e -> eb_server,
5440 e -> eb_subject ? e -> eb_subject : e -> eb_body);
5441 if (!getanswer (buffer))
5442 return NOTOK;
5443
5444 vecp = 0;
5445 vec[vecp++] = r1bindex (mailproc, '/');
5446 vec[vecp++] = e -> eb_server;
5447 vec[vecp++] = "-subject";
5448 vec[vecp++] = e -> eb_subject ? e -> eb_subject : "mail-server request";
5449 vec[vecp++] = "-body";
5450 vec[vecp++] = e -> eb_body;
5451 vec[vecp] = NULL;
5452
5453 for (i = 0; (child_id = vfork ()) == NOTOK && i < 5; i++)
5454 sleep (5);
5455 switch (child_id) {
5456 case NOTOK:
5457 advise ("fork", "unable to");
5458 return NOTOK;
5459
5460 case OK:
5461 (void) execvp (mailproc, vec);
5462 fprintf (stderr, "unable to exec ");
5463 perror (mailproc);
5464 _exit (-1);
5465 /* NOTREACHED */
5466
5467 default:
5468 if (pidXwait (child_id, NULLCP) == OK)
5469 advise (NULLCP, "request sent");
5470 break;
5471 }
5472
5473 ce -> ce_unlink = *file == NULL;
5474 if ((ce -> ce_fp = fopen (ce -> ce_file =
5475 add (*file ? *file : m_scratch ("", tmp),
5476 NULLCP),
5477 "w+")) == NULL) {
5478 content_error (ce -> ce_file, ct,
5479 "unable to fopen for writing and reading");
5480 return NOTOK;
5481 }
5482 if (ct -> c_showproc)
5483 free (ct -> c_showproc);
5484 ct -> c_showproc = add ("true", NULLCP);
5485
5486 (void) fseek (ce -> ce_fp, 0L, 0);
5487 *file = ce -> ce_file;
5488 return fileno (ce -> ce_fp);
5489 }
5490
5491 /* \f CACHE */
5492
5493 static int find_cache (ct, policy, writing, id, buffer)
5494 CT ct;
5495 int policy,
5496 *writing;
5497 char *id,
5498 *buffer;
5499 {
5500 int status = NOTOK;
5501
5502 if (id == NULL)
5503 return NOTOK;
5504 id = trimcpy (id);
5505
5506 if (debugsw)
5507 fprintf (stderr, "find_cache %s(%d) %s %s\n",
5508 caches[policy].sw, policy, writing ? "writing" : "reading",
5509 id);
5510
5511 switch (policy) {
5512 case CACHE_NEVER:
5513 default:
5514 break;
5515
5516 case CACHE_ASK:
5517 case CACHE_PUBLIC:
5518 if (cache_private
5519 && !writing
5520 && find_cache_aux (writing ? 2 : 0, cache_private, id,
5521 buffer) == OK) {
5522 if (access (buffer, 04) != NOTOK) {
5523 got_private: ;
5524 if (writing)
5525 *writing = 1;
5526 got_it: ;
5527 status = OK;
5528 break;
5529 }
5530 }
5531 if (cache_public
5532 && find_cache_aux (writing ? 1 : 0, cache_public, id,
5533 buffer) == OK) {
5534 if (writing || access (buffer, 04) != NOTOK) {
5535 if (writing)
5536 *writing = 0;
5537 goto got_it;
5538 }
5539 }
5540 break;
5541
5542 case CACHE_PRIVATE:
5543 if (cache_private
5544 && find_cache_aux (writing ? 2 : 0, cache_private, id,
5545 buffer) == OK) {
5546 if (writing || access (buffer, 04) != NOTOK)
5547 goto got_private;
5548 }
5549 break;
5550
5551 }
5552
5553 if (status == OK && policy == CACHE_ASK) {
5554 char *bp,
5555 query[BUFSIZ];
5556
5557 if (xpid) {
5558 if (xpid < 0)
5559 xpid = -xpid;
5560 (void) pidcheck (pidwait (xpid, NOTOK));
5561 xpid = 0;
5562 }
5563
5564 bp = query;
5565 if (writing)
5566 (void) sprintf (bp, "Make cached, publically-accessible copy");
5567 else {
5568 struct stat st;
5569
5570 (void) sprintf (bp, "Use cached copy");
5571 bp += strlen (bp);
5572 if (ct -> c_partno) {
5573 (void) sprintf (bp, " of content %s", ct -> c_partno);
5574 bp += strlen (bp);
5575 }
5576 (void) stat (buffer, &st);
5577 (void) sprintf (bp, " (size %lu octets)",
5578 (unsigned long) st.st_size);
5579 }
5580 bp += strlen (bp);
5581 (void) sprintf (bp, "\n in file %s? ", buffer);
5582 if (!getanswer (query))
5583 status = NOTOK;
5584 }
5585 if (status == OK && writing) {
5586 if (*writing && index (buffer, '/'))
5587 (void) make_intermediates (buffer);
5588 (void) unlink (buffer);
5589 }
5590
5591 free (id);
5592 return status;
5593 }
5594
5595 /* \f */
5596
5597 static int find_cache_aux (writing, directory, id, buffer)
5598 int writing;
5599 char *directory,
5600 *id,
5601 *buffer;
5602 {
5603 int mask;
5604 #ifdef BSD42
5605 int usemap = index (id, '/') ? 1 : 0;
5606 #else
5607 int usemap = 1;
5608 #endif
5609 char mapfile[BUFSIZ],
5610 mapname[BUFSIZ];
5611 FILE *fp;
5612 static int partno,
5613 pid;
5614 static long clock = 0L;
5615
5616 if (debugsw)
5617 fprintf (stderr, "find_cache_aux %s usemap=%d\n", directory, usemap);
5618
5619 (void) sprintf (mapfile, "%s/cache.map", directory);
5620 if (find_cache_aux2 (mapfile, id, mapname) == OK)
5621 goto done_map;
5622
5623 if (!writing) {
5624 if (usemap)
5625 return NOTOK;
5626
5627 use_raw: ;
5628 (void) sprintf (buffer, "%s/%s", directory, id);
5629 return OK;
5630 }
5631
5632 if (!usemap && access (mapfile, 02) == NOTOK)
5633 goto use_raw;
5634
5635 if (clock != 0L) {
5636 long now;
5637
5638 (void) time (&now);
5639 if (now > clock)
5640 clock = 0L;
5641 }
5642 else
5643 pid = getpid ();
5644 if (clock == 0L) {
5645 (void) time (&clock);
5646 partno = 0;
5647 }
5648 else
5649 if (partno > 0xff)
5650 clock++, partno = 0;
5651
5652 (void) sprintf (mapname, "%08x%04x%02x", clock & 0xffffffff,
5653 pid & 0xffff, partno++ & 0xff);
5654 if (debugsw)
5655 fprintf (stderr, "creating mapping %s -> %s\n", mapname, id);
5656
5657 (void) make_intermediates (mapfile);
5658 mask = umask (writing == 2 ? 0077 : 0);
5659 if (!(fp = lkfopen (mapfile, "a")) && errno == ENOENT) {
5660 int fd = creat (mapfile, 0666);
5661
5662 if (fd != NOTOK) {
5663 (void) close (fd);
5664 fp = lkfopen (mapfile, "a");
5665 }
5666 }
5667 (void) umask (mask);
5668 if (!fp)
5669 return NOTOK;
5670 fprintf (fp, "%s: %s\n", mapname, id);
5671 (void) lkfclose (fp, mapfile);
5672
5673 done_map: ;
5674 if (*mapname == '/')
5675 (void) strcpy (buffer, mapname);
5676 else
5677 (void) sprintf (buffer, "%s/%s", directory, mapname);
5678 if (debugsw)
5679 fprintf (stderr, "use %s\n", buffer);
5680
5681 return OK;
5682 }
5683
5684 /* \f */
5685
5686 static int find_cache_aux2 (mapfile, id, mapname)
5687 char *mapfile,
5688 *id,
5689 *mapname;
5690 {
5691 int state;
5692 char buf[BUFSIZ],
5693 name[NAMESZ];
5694 FILE *fp;
5695
5696 if (!(fp = lkfopen (mapfile, "r")))
5697 return NOTOK;
5698
5699 for (state = FLD;;) {
5700 int result;
5701 register char *cp,
5702 *dp;
5703
5704 switch (state = m_getfld (state, name, buf, sizeof buf, fp)) {
5705 case FLD:
5706 case FLDPLUS:
5707 case FLDEOF:
5708 (void) strcpy (mapname, name);
5709 if (state != FLDPLUS)
5710 cp = buf;
5711 else {
5712 cp = add (buf, NULLCP);
5713 while (state == FLDPLUS) {
5714 state = m_getfld (state, name, buf, sizeof buf, fp);
5715 cp = add (buf, cp);
5716 }
5717 }
5718 dp = trimcpy (cp);
5719 if (cp != buf)
5720 free (cp);
5721 if (debugsw)
5722 fprintf (stderr, "compare %s to %s <- %s\n", id, dp,
5723 mapname);
5724 result = strcmp (id, dp);
5725 free (dp);
5726 if (result == 0) {
5727 (void) lkfclose (fp, mapfile);
5728 return OK;
5729 }
5730 if (state != FLDEOF)
5731 continue;
5732 /* else fall... */
5733
5734 case BODY:
5735 case BODYEOF:
5736 case FILEEOF:
5737 default:
5738 break;
5739 }
5740 break;
5741 }
5742
5743 (void) lkfclose (fp, mapfile);
5744 return NOTOK;
5745 }
5746
5747 /* \f */
5748
5749 static int cache_content (ct)
5750 register CT ct;
5751 {
5752 int cachetype;
5753 char *file,
5754 cachefile[BUFSIZ];
5755 register struct cefile *ce = (struct cefile *) ct -> c_ceparams;
5756
5757 if (!ct -> c_id) {
5758 advise (NULLCP, "no %s: field in %s", ID_FIELD, ct -> c_file);
5759 return;
5760 }
5761
5762 if (!ce) {
5763 advise (NULLCP, "unable to decode %s", ct -> c_file);
5764 return;
5765 }
5766
5767 if (ct -> c_ceopenfnx == openMail) {
5768 advise (NULLCP, "a radish may no know Greek, but I do...");
5769 return;
5770 }
5771
5772 if (find_cache (NULLCT, wcachesw != CACHE_NEVER ? wcachesw : CACHE_ASK,
5773 &cachetype, ct -> c_id, cachefile)
5774 == NOTOK) {
5775 advise (NULLCP, "unable to cache %s's contents", ct -> c_file);
5776 return;
5777 }
5778 if (wcachesw != CACHE_NEVER && wcachesw != CACHE_ASK) {
5779 (void) fflush (stdout);
5780 fprintf (stderr, "caching message %s as file %s\n", ct -> c_file,
5781 cachefile);
5782 }
5783
5784 if (ce -> ce_file) {
5785 int mask = umask (cachetype ? ~m_gmprot () : 0222);
5786 FILE *fp;
5787
5788 if (debugsw)
5789 fprintf (stderr, "caching by copying %s...\n", ce -> ce_file);
5790
5791 file = NULL;
5792 if ((*ct -> c_ceopenfnx) (ct, &file) == NOTOK)
5793 goto reset_umask;
5794
5795 if (fp = fopen (cachefile, "w")) {
5796 int cc;
5797 char buffer[BUFSIZ];
5798 FILE *gp = ce -> ce_fp;
5799
5800 (void) fseek (gp, 0L, 0);
5801
5802 while ((cc = fread (buffer, sizeof *buffer, sizeof buffer, gp))
5803 > 0)
5804 (void) fwrite (buffer, sizeof *buffer, cc, fp);
5805 (void) fflush (fp);
5806
5807 if (ferror (gp)) {
5808 admonish (ce -> ce_file, "error reading");
5809 (void) unlink (cachefile);
5810 }
5811 else
5812 if (ferror (fp)) {
5813 admonish (cachefile, "error writing");
5814 (void) unlink (cachefile);
5815 }
5816 (void) fclose (fp);
5817 }
5818 else
5819 content_error (cachefile, ct, "unable to fopen for writing");
5820 reset_umask: ;
5821 (void) umask (mask);
5822 }
5823 else {
5824 if (debugsw)
5825 fprintf (stderr, "in place caching...\n");
5826
5827 file = cachefile;
5828 if ((*ct -> c_ceopenfnx) (ct, &file) != NOTOK)
5829 (void) chmod (cachefile, cachetype ? m_gmprot () : 0444);
5830 }
5831 }
5832
5833 /* \f COMPOSITION */
5834
5835 static char prefix[] = "----- =_aaaaaaaaaa";
5836
5837 static char *free_file = NULL;
5838 static CT free_ct = NULL;
5839
5840
5841 static void build_comp (file)
5842 char *file;
5843 {
5844 int compnum,
5845 state;
5846 char *cp,
5847 buf[BUFSIZ],
5848 name[NAMESZ],
5849 tmpfil[BUFSIZ];
5850 struct multipart *m;
5851 register struct part **pp;
5852 CT ct;
5853 FILE *in,
5854 *out;
5855
5856 if ((in = fopen (file, "r")) == NULL)
5857 adios (file, "unable to open for reading");
5858
5859 (void) umask (~m_gmprot ());
5860
5861 (void) strcpy (tmpfil, m_scratch (file, invo_name));
5862 if ((out = fopen (tmpfil, "w")) == NULL)
5863 adios (tmpfil, "unable to open for writing");
5864 free_file = tmpfil;
5865
5866 for (compnum = 1, state = FLD;;) {
5867 switch (state = m_getfld (state, name, buf, sizeof buf, in)) {
5868 case FLD:
5869 case FLDPLUS:
5870 case FLDEOF:
5871 compnum++;
5872
5873 if (uleq (name, VRSN_FIELD))
5874 adios (NULLCP, "draft shouldn't contain %s: field",
5875 VRSN_FIELD);
5876
5877 if (uleq (name, TYPE_FIELD)) {
5878 while (state == FLDPLUS)
5879 state = m_getfld (state, name, buf, sizeof buf, in);
5880 goto finish_field;
5881 }
5882
5883 if (uleq (name, ENCODING_FIELD))
5884 adios (NULLCP, "draft shouldn't contain %s: field",
5885 ENCODING_FIELD);
5886
5887 fprintf (out, "%s:%s", name, buf);
5888 while (state == FLDPLUS) {
5889 state = m_getfld (state, name, buf, sizeof buf, in);
5890 (void) fputs (buf, out);
5891 }
5892 finish_field: ;
5893 if (state != FLDEOF)
5894 continue;
5895 /* else fall... */
5896
5897 case FILEEOF:
5898 adios (NULLCP, "draft has empty body -- no directives!");
5899 /* NOTREACHED */
5900
5901 case BODY:
5902 case BODYEOF:
5903 (void) fseek (in, (long) (-strlen (buf)), 1);
5904 break;
5905
5906 case LENERR:
5907 case FMTERR:
5908 adios (NULLCP, "message format error in component #%d",
5909 compnum);
5910
5911 default:
5912 adios (NULLCP, "getfld() returned %d", state);
5913 }
5914 break;
5915 }
5916
5917 if ((free_ct = ct = (CT) calloc (1, sizeof *ct)) == NULL)
5918 adios (NULLCP, "out of memory");
5919 if (get_ctinfo ("multipart/mixed", ct, 0) == NOTOK)
5920 done (1);
5921 ct -> c_type = CT_MULTIPART;
5922 ct -> c_subtype = MULTI_MIXED;
5923 ct -> c_ctlistfnx = list_multi;
5924 ct -> c_ctfreefnx = free_multi;
5925 ct -> c_file = add (file, NULLCP);
5926
5927 if ((m = (struct multipart *) calloc (1, sizeof *m)) == NULL)
5928 adios (NULLCP, "out of memory");
5929 ct -> c_ctparams = (caddr_t) m;
5930
5931 pp = &m -> mp_parts;
5932 while (fgetstr (buf, sizeof buf - 1, in)) {
5933 register struct part *part;
5934 CT p;
5935
5936 if (user_content (in, file, buf, &p) == DONE) {
5937 admonish (NULLCP, "ignoring spurious #end");
5938 continue;
5939 }
5940 if (!p)
5941 continue;
5942
5943 if ((part = (struct part *) calloc (1, sizeof *part)) == NULL)
5944 adios (NULLCP, "out of memory");
5945 *pp = part, pp = &part -> mp_next;
5946 part -> mp_part = p;
5947 }
5948
5949 (void) fclose (in);
5950
5951 if (!m -> mp_parts)
5952 adios (NULLCP, "no content directives found");
5953 if (!m -> mp_parts -> mp_next) {
5954 CT p = m -> mp_parts -> mp_part;
5955
5956 m -> mp_parts -> mp_part = NULL;
5957 free_content (ct);
5958 free_ct = ct = p;
5959 }
5960 else
5961 set_id (ct, 1);
5962
5963 if ((cp = index (prefix, 'a')) == NULL)
5964 adios (NULLCP, "internal error(4)");
5965
5966 while (compose_content (ct) == NOTOK)
5967 if (*cp < 'z')
5968 (*cp)++;
5969 else
5970 if (*++cp == 0)
5971 adios (NULLCP,
5972 "giving up trying to find a unique delimiter string");
5973 else
5974 (*cp)++;
5975
5976 fprintf (out, "%s: %s\n", VRSN_FIELD, VRSN_VALUE);
5977 (void) output_content (ct, out);
5978
5979 if (fflush (out))
5980 adios (tmpfil, "error writing to");
5981
5982 (void) fclose (out);
5983
5984 if (listsw && ct -> c_ctlistfnx) {
5985 char *savfile;
5986
5987 if (headsw)
5988 printf (LSTFMT1, "msg", "part", "type/subtype", "size",
5989 "description");
5990
5991 /* to get msgno */
5992 savfile = ct -> c_file, ct -> c_file = file;
5993 (*ct -> c_ctlistfnx) (ct, 1);
5994 ct -> c_file = savfile;
5995 }
5996
5997 free_content (ct);
5998 free_ct = NULL;
5999
6000 (void) sprintf (buf, "%s.orig", m_backup (file));
6001 if (rename (file, buf) == NOTOK)
6002 adios (buf, "unable to rename %s to", file);
6003 if (rename (tmpfil, file) == NOTOK) {
6004 advise (file, "unable to rename %s to", tmpfil);
6005 (void) rename (buf, file);
6006 done (1);
6007 }
6008 free_file = NULL;
6009
6010 done (0);
6011 }
6012
6013 /* \f */
6014
6015 static char *fgetstr (s, n, stream)
6016 char *s;
6017 int n;
6018 FILE *stream;
6019 {
6020 register char *cp,
6021 *ep;
6022
6023 for (ep = (cp = s) + n; cp < ep; ) {
6024 register int i;
6025
6026 if (!fgets (cp, n, stream))
6027 return (cp != s ? s : NULL);
6028 if (cp == s && *cp != '#')
6029 return s;
6030
6031 cp += (i = strlen (cp)) - 1;
6032 if (i <= 1 || *cp-- != '\n' || *cp != '\\')
6033 break;
6034 *cp = 0, n -= (i - 2);
6035 }
6036
6037 return s;
6038 }
6039
6040 /* \f */
6041
6042 static int user_content (in, file, buf, ctp)
6043 FILE *in;
6044 char *file,
6045 *buf;
6046 CT *ctp;
6047 {
6048 int extrnal,
6049 vrsn;
6050 register char *cp,
6051 **ap;
6052 char buffer[BUFSIZ];
6053 struct multipart *m;
6054 register struct part **pp;
6055 struct stat st;
6056 register struct str2init *s2i;
6057 register CI ci;
6058 register CT ct;
6059
6060 if (buf[0] == '\n' || strcmp (buf, "#\n") == 0) {
6061 *ctp = NULL;
6062 return OK;
6063 }
6064
6065 if ((ct = (CT) calloc (1, sizeof *ct)) == NULL)
6066 adios (NULLCP, "out of memory");
6067 *ctp = ct;
6068 ci = &ct -> c_ctinfo;
6069 ct -> c_ctlistfnx = list_content;
6070 set_id (ct, 0);
6071
6072 if (buf[0] != '#' || buf[1] == '#' || buf[1] == '<') {
6073 int headers,
6074 inlineD;
6075 long pos;
6076 char content[BUFSIZ];
6077 FILE *out;
6078
6079 ct -> c_file = add (m_tmpfil (invo_name), NULLCP);
6080 ct -> c_unlink = 1;
6081
6082 if ((out = fopen (ct -> c_file, "w")) == NULL)
6083 adios (ct -> c_file, "unable to open for writing");
6084
6085 if (buf[0] == '#' && buf[1] == '<') {
6086 (void) strcpy (content, buf + 2);
6087 inlineD = 1;
6088 goto rock_and_roll;
6089 }
6090 else
6091 inlineD = 0;
6092
6093 (void) strcpy (content, "text/plain");
6094 headers = 0;
6095 (void) strcpy (buffer, buf[0] != '#' ? buf : buf + 1);
6096 for (;;) {
6097 int i;
6098
6099 if (headers >= 0
6100 && uprf (buffer, DESCR_FIELD)
6101 && buffer[i = strlen (DESCR_FIELD)] == ':') {
6102 headers = 1;
6103
6104 again_descr: ;
6105 ct -> c_descr = add (buffer + i + 1, ct -> c_descr);
6106 if (!fgetstr (buffer, sizeof buffer - 1, in))
6107 adios (NULLCP,
6108 "end-of-file after %s: field in plaintext",
6109 DESCR_FIELD);
6110 switch (buffer[0]) {
6111 case ' ':
6112 case '\t':
6113 i = -1;
6114 goto again_descr;
6115
6116 case '#':
6117 adios (NULLCP,
6118 "#-directive after %s: field in plaintext",
6119 DESCR_FIELD);
6120 /* NOTREACHED */
6121
6122 default:
6123 break;
6124 }
6125 }
6126
6127 if (headers != 1 || buffer[0] != '\n')
6128 (void) fputs (buffer, out);
6129 rock_and_roll: ;
6130 headers = -1;
6131
6132 pos = ftell (in);
6133 if ((cp = fgetstr (buffer, sizeof buffer - 1, in)) == NULL)
6134 break;
6135 if (buffer[0] == '#') {
6136 register char *bp;
6137
6138 if (buffer[1] != '#')
6139 break;
6140 for (cp = (bp = buffer) + 1; *cp; cp++)
6141 *bp++ = *cp;
6142 *bp = '\0';
6143 }
6144 }
6145
6146 if (listsw)
6147 ct -> c_end = ftell (out);
6148 (void) fclose (out);
6149
6150 if (get_ctinfo (content, ct, inlineD) == NOTOK)
6151 done (1);
6152 for (s2i = str2cts; s2i -> si_key; s2i++)
6153 if (uleq (ci -> ci_type, s2i -> si_key))
6154 break;
6155 if (!s2i -> si_key && !uprf (ci -> ci_type, "X-"))
6156 s2i++;
6157 switch (ct -> c_type = s2i -> si_val) {
6158 case CT_MESSAGE:
6159 if (uleq (ci -> ci_subtype, "rfc822")) {
6160 ct -> c_encoding = CE_7BIT; /* XXX */
6161 goto call_init;
6162 }
6163 /* else fall... */
6164 case CT_MULTIPART:
6165 adios (NULLCP,
6166 "it makes sense to define a in-line %s content... NOT!",
6167 ct -> c_type == CT_MESSAGE ? "message" : "multipart");
6168 /* NOTREACHED */
6169
6170 default:
6171 call_init: ;
6172 if (ct -> c_ctinitfnx = s2i -> si_init)
6173 (void) (*ct -> c_ctinitfnx) (ct);
6174 break;
6175 }
6176
6177 if (cp)
6178 (void) fseek (in, pos, 0);
6179 return OK;
6180 }
6181
6182 extrnal = buf[1] == '@@';
6183 if (get_ctinfo (buf + (extrnal ? 2 : 1), ct, 1) == NOTOK)
6184 done (1);
6185
6186 for (s2i = str2cts; s2i -> si_key; s2i++)
6187 if (uleq (ci -> ci_type, s2i -> si_key))
6188 break;
6189 if (s2i -> si_key) { /* type/subtype [file] */
6190 if (!ci -> ci_subtype)
6191 adios (NULLCP, "missing subtype in \"#%s\"", ci -> ci_type);
6192
6193 switch (ct -> c_type = s2i -> si_val) {
6194 case CT_MULTIPART:
6195 adios (NULLCP, "use \"#begin ... #end\" instead of \"#%s/%s\"",
6196 ci -> ci_type, ci -> ci_subtype);
6197 /* NOTREACHED */
6198
6199 case CT_MESSAGE:
6200 if (uleq (ci -> ci_subtype, "partial"))
6201 adios (NULLCP, "sorry, \"#%s/%s\" isn't supported",
6202 ci -> ci_type, ci -> ci_subtype);
6203 if (uleq (ci -> ci_subtype, "external-body"))
6204 adios (NULLCP, "use \"#@@type/subtype ... [] ...\" instead of \"#%s/%s\"",
6205 ci -> ci_type, ci -> ci_subtype);
6206 use_forw: ;
6207 adios (NULLCP,
6208 "use \"#forw [+folder] [msgs]\" instead of \"#%s/%s\"",
6209 ci -> ci_type, ci -> ci_subtype);
6210 /* NOTREACHED */
6211
6212 default:
6213 if (ct -> c_ctinitfnx = s2i -> si_init)
6214 (void) (*ct -> c_ctinitfnx) (ct);
6215 break;
6216 }
6217
6218 if (extrnal) {
6219 register struct exbody *e;
6220 CT p;
6221
6222 if (!ci -> ci_magic)
6223 adios (NULLCP, "need external information for \"#@@%s/%s\"",
6224 ci -> ci_type, ci -> ci_subtype);
6225 p = ct;
6226
6227 (void) sprintf (buffer, "message/external-body; %s",
6228 ci -> ci_magic);
6229 free (ci -> ci_magic), ci -> ci_magic = NULL;
6230
6231 if ((ct = (CT) calloc (1, sizeof *ct)) == NULL)
6232 adios (NULLCP, "out of memory");
6233 *ctp = ct;
6234 ci = &ct -> c_ctinfo;
6235 ct -> c_ctlistfnx = list_content;
6236 if (get_ctinfo (buffer, ct, 0) == NOTOK)
6237 done (1);
6238 ct -> c_type = CT_MESSAGE;
6239 ct -> c_subtype = MESSAGE_EXTERNAL;
6240
6241 if ((e = (struct exbody *) calloc (1, sizeof *e)) == NULL)
6242 adios (NULLCP, "out of memory");
6243 ct -> c_ctparams = (caddr_t) e;
6244 ct -> c_ctfreefnx = free_external;
6245
6246 e -> eb_parent = ct;
6247 e -> eb_content = p;
6248 p -> c_ctextern = (caddr_t) e;
6249
6250 ct -> c_ctlistfnx = list_external;
6251
6252 if (params_external (ct, 1) == NOTOK)
6253 done (1);
6254
6255 return OK;
6256 }
6257
6258 if (ci -> ci_magic) {
6259 if (*ci -> ci_magic == '|' || *ci -> ci_magic == '!') {
6260 for (cp = ci -> ci_magic + 1; isspace (*cp); cp++)
6261 continue;
6262 if (!*cp)
6263 adios (NULLCP, "empty pipe command for #%s directive",
6264 ci -> ci_type);
6265 cp = add (cp, NULLCP);
6266 free (ci -> ci_magic);
6267 ci -> ci_magic = cp;
6268 }
6269 else {
6270 if (access (ct -> c_file = ci -> ci_magic, 04) == NOTOK)
6271 adios ("reading", "unable to access %s for", ct -> c_file);
6272 if (listsw && stat (ct -> c_file, &st) != NOTOK)
6273 ct -> c_end = (long) st.st_size;
6274 ci -> ci_magic = NULL;
6275 }
6276 return OK;
6277 }
6278
6279 (void) sprintf (buffer, "%s-compose-%s/%s", invo_name, ci -> ci_type,
6280 ci -> ci_subtype);
6281 if ((cp = m_find (buffer)) == NULL || *cp == 0) {
6282 (void) sprintf (buffer, "%s-compose-%s", invo_name, ci -> ci_type);
6283 if ((cp = m_find (buffer)) == NULL || *cp == 0) {
6284 content_error (NULLCP, ct,
6285 "don't know how to compose content");
6286 done (1);
6287 }
6288 }
6289 ci -> ci_magic = add (cp, NULLCP);
6290 return OK;
6291 }
6292
6293 if (extrnal)
6294 adios (NULLCP, "externally definition not allowed for \"#%s\"",
6295 ci -> ci_type);
6296
6297 if (uleq (ci -> ci_type, "forw")) { /* #forw [+folder] [msgs] */
6298 int msgnum;
6299 char *folder,
6300 *arguments[MAXARGS];
6301 struct msgs *mp;
6302
6303 if (ci -> ci_magic) {
6304 ap = brkstring (ci -> ci_magic, " ", "\n");
6305 ap = copyip (ap, arguments);
6306 }
6307 else
6308 arguments[0] = "cur", arguments[1] = NULL;
6309
6310 folder = NULL;
6311 for (ap = arguments; cp = *ap; ap++)
6312 if (*cp == '+' || *cp == '@@')
6313 if (folder)
6314 adios (NULLCP, "only one folder per #forw directive");
6315 else
6316 folder = path (cp + 1, *cp == '+' ? TFOLDER : TSUBCWF);
6317 if (!folder)
6318 folder = add (m_getfolder (), NULLCP);
6319
6320 if ((mp = m_gmsg (folder)) == NULL)
6321 adios (NULLCP, "unable to read folder %s", folder);
6322 for (ap = arguments; cp = *ap; ap++)
6323 if (*cp != '+' && *cp != '@@')
6324 if (!m_convert (mp, cp))
6325 done (1);
6326 free (folder);
6327
6328 free_ctinfo (ct);
6329 if (mp -> numsel > 1) {
6330 if (get_ctinfo ("multipart/digest", ct, 0) == NOTOK)
6331 done (1);
6332 ct -> c_type = CT_MULTIPART;
6333 ct -> c_subtype = MULTI_DIGEST;
6334 ct -> c_ctlistfnx = list_multi;
6335 ct -> c_ctfreefnx = free_multi;
6336
6337 if ((m = (struct multipart *) calloc (1, sizeof *m)) == NULL)
6338 adios (NULLCP, "out of memory");
6339 ct -> c_ctparams = (caddr_t) m;
6340
6341 pp = &m -> mp_parts;
6342 }
6343 else
6344 free_content (ct);
6345 for (msgnum = mp -> lowsel; msgnum <= mp -> hghsel; msgnum++)
6346 if (mp -> msgstats[msgnum] & SELECTED) {
6347 register struct part *part;
6348 register CT p;
6349
6350 if ((p = (CT) calloc (1, sizeof *p)) == NULL)
6351 adios (NULLCP, "out of memory");
6352 if (get_ctinfo ("message/rfc822", p, 0) == NOTOK)
6353 done (1);
6354 p -> c_type = CT_MESSAGE;
6355 p -> c_subtype = MESSAGE_RFC822;
6356 p -> c_ctlistfnx = list_content;
6357
6358 (void) sprintf (buffer, "%s/%d", mp -> foldpath, msgnum);
6359 p -> c_file = add (buffer, NULLCP);
6360 if (listsw && stat (p -> c_file, &st) != NOTOK)
6361 p -> c_end = (long) st.st_size;
6362
6363 if (mp -> numsel > 1) {
6364 if ((part = (struct part *) calloc (1, sizeof *part))
6365 == NULL)
6366 adios (NULLCP, "out of memory");
6367 *pp = part, pp = &part -> mp_next;
6368 part -> mp_part = p;
6369 }
6370 else
6371 *ctp = ct = p;
6372 }
6373
6374 m_fmsg (mp);
6375
6376 return OK;
6377 }
6378
6379 if (uleq (ci -> ci_type, "end")) {
6380 free_content (ct);
6381 *ctp = NULL;
6382 return DONE;
6383 }
6384
6385 if (!uleq (ci -> ci_type, "begin"))
6386 adios (NULLCP, "unknown directive \"#%s\"", ci -> ci_type);
6387
6388 /* #begin [ alternative | parallel ] */
6389 if (!ci -> ci_magic)
6390 cp = SubMultiPart[(vrsn = MULTI_MIXED) - 1].kv_key;
6391 else
6392 if (uleq (ci -> ci_magic, "alternative"))
6393 cp = SubMultiPart[(vrsn = MULTI_ALTERNATE) - 1].kv_key;
6394 else
6395 if (uleq (ci -> ci_magic, "parallel"))
6396 cp = SubMultiPart[(vrsn = MULTI_PARALLEL) - 1].kv_key;
6397 else
6398 if (uprf (ci -> ci_magic, "digest"))
6399 goto use_forw;
6400 else
6401 cp = ci -> ci_magic, vrsn = MULTI_UNKNOWN;
6402 free_ctinfo (ct);
6403 (void) sprintf (buffer, "multipart/%s", cp);
6404 if (get_ctinfo (buffer, ct, 0) == NOTOK)
6405 done (1);
6406 ct -> c_type = CT_MULTIPART;
6407 ct -> c_subtype = vrsn;
6408 ct -> c_ctlistfnx = list_multi;
6409 ct -> c_ctfreefnx = free_multi;
6410
6411 if ((m = (struct multipart *) calloc (1, sizeof *m)) == NULL)
6412 adios (NULLCP, "out of memory");
6413 ct -> c_ctparams = (caddr_t) m;
6414
6415 pp = &m -> mp_parts;
6416 while (fgetstr (buffer, sizeof buffer - 1, in)) {
6417 register struct part *part;
6418 CT p;
6419
6420 if (user_content (in, file, buffer, &p) == DONE) {
6421 if (!m -> mp_parts)
6422 adios (NULLCP, "empty \"#begin ... #end\" sequence");
6423 return OK;
6424 }
6425 if (!p)
6426 continue;
6427
6428 if ((part = (struct part *) calloc (1, sizeof *part)) == NULL)
6429 adios (NULLCP, "out of memory");
6430 *pp = part, pp = &part -> mp_next;
6431 part -> mp_part = p;
6432 }
6433 admonish (NULLCP, "premature end-of-file, missing #end");
6434 return OK;
6435 }
6436
6437 /* \f */
6438
6439 static void set_id (ct, top)
6440 CT ct;
6441 int top;
6442 {
6443 char msgid[BUFSIZ];
6444 static int partno;
6445 static long clock = 0L;
6446 static char *msgfmt;
6447
6448 if (clock == 0L) {
6449 (void) time (&clock);
6450 (void) sprintf (msgid, "<%d.%ld.%%d@@%s>\n", getpid (), clock,
6451 LocalName ());
6452 partno = 0;
6453 msgfmt = getcpy (msgid);
6454 }
6455 (void) sprintf (msgid, msgfmt, top ? 0 : ++partno);
6456 ct -> c_id = getcpy (msgid);
6457 }
6458
6459 /* \f */
6460
6461 static char ebcdicsafe[0x100] = {
6462 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
6463 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
6464 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
6465 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
6466 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01,
6467 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
6468 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
6469 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
6470 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
6471 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
6472 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
6473 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01,
6474 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
6475 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
6476 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
6477 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
6478 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
6479 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
6480 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
6481 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
6482 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
6483 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
6484 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
6485 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
6486 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
6487 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
6488 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
6489 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
6490 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
6491 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
6492 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
6493 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
6494 };
6495
6496 static int compose_content (ct)
6497 register CT ct;
6498 {
6499 register char *cp;
6500 char buffer[BUFSIZ];
6501 register CI ci = &ct -> c_ctinfo;
6502
6503 if (ct -> c_type == CT_MESSAGE && ct -> c_subtype == MESSAGE_EXTERNAL)
6504 return OK;
6505
6506 switch (ct -> c_type) {
6507 case CT_MULTIPART:
6508 {
6509 int partnum;
6510 register char *pp;
6511 char partnam[BUFSIZ];
6512 struct multipart *m = (struct multipart *) ct -> c_ctparams;
6513 register struct part *part;
6514
6515 if (ct -> c_partno) {
6516 (void) sprintf (partnam, "%s.", ct -> c_partno);
6517 pp = partnam + strlen (partnam);
6518 }
6519 else
6520 pp = partnam;
6521
6522 for (part = m -> mp_parts, partnum = 1;
6523 part;
6524 part = part -> mp_next, partnum++) {
6525 register CT p = part -> mp_part;
6526
6527 (void) sprintf (pp, "%d", partnum);
6528 p -> c_partno = add (partnam, NULLCP);
6529
6530 if (compose_content (p) == NOTOK)
6531 return NOTOK;
6532 }
6533
6534 if (rfc934sw && ct -> c_subtype == MULTI_DIGEST) {
6535 int is934 = 1;
6536
6537 for (part = m -> mp_parts; part; part = part -> mp_next) {
6538 register CT p = part -> mp_part;
6539
6540 if (p -> c_subtype != MESSAGE_RFC822) {
6541 is934 = 0;
6542 break;
6543 }
6544 }
6545
6546 ct -> c_rfc934 = is934;
6547 for (part = m -> mp_parts; part; part = part -> mp_next) {
6548 register CT p = part -> mp_part;
6549
6550 if (p -> c_rfc934 = is934)
6551 p -> c_end++;
6552 }
6553 }
6554
6555 if (listsw) {
6556 ct -> c_end = (partnum = strlen (prefix) + 2) + 2;
6557 if (ct -> c_rfc934)
6558 ct -> c_end += 1;
6559
6560 for (part = m -> mp_parts; part; part = part -> mp_next)
6561 ct -> c_end += part -> mp_part -> c_end + partnum;
6562 }
6563 }
6564 break;
6565
6566
6567 default:
6568 if (!ct -> c_file) {
6569 int child_id,
6570 i,
6571 xstdout;
6572 register char *bp,
6573 **ap;
6574 char *vec[4];
6575 FILE *out;
6576
6577 if (!(cp = ci -> ci_magic))
6578 adios (NULLCP, "internal error(5)");
6579
6580 ct -> c_file = add (m_tmpfil (invo_name), NULLCP);
6581 ct -> c_unlink = 1;
6582
6583 xstdout = 0;
6584 buffer[0] = '\0';
6585 for (bp = buffer; *cp; cp++)
6586 if (*cp == '%') {
6587 switch (*++cp) {
6588 case 'a': /* additional arguments */
6589 {
6590 register char **ep;
6591 char *s = "";
6592
6593 for (ap = ci -> ci_attrs, ep = ci -> ci_values;
6594 *ap;
6595 ap++, ep++) {
6596 (void) sprintf (bp, "%s%s=\"%s\"", s,
6597 *ap, *ep);
6598 bp += strlen (bp);
6599 s = " ";
6600 }
6601 }
6602 break;
6603
6604 case 'F': /* %f, and stdout is not-redirected */
6605 xstdout = 1;
6606 /* and fall... */
6607 case 'f': /* filename */
6608 (void) sprintf (bp, "%s", ct -> c_file);
6609 break;
6610
6611 case 's': /* subtype */
6612 (void) strcpy (bp, ci -> ci_subtype);
6613 break;
6614
6615 case '%':
6616 goto raw;
6617
6618 default:
6619 *bp++ = *--cp;
6620 *bp = '\0';
6621 continue;
6622 }
6623 bp += strlen (bp);
6624 }
6625 else {
6626 raw: ;
6627 *bp++ = *cp;
6628 *bp = '\0';
6629 }
6630
6631 printf ("composing content %s/%s from command\n\t%s\n",
6632 ci -> ci_type, ci -> ci_subtype, buffer);
6633 (void) fflush (stdout);
6634
6635 vec[0] = "/bin/sh";
6636 vec[1] = "-c";
6637 vec[2] = buffer;
6638 vec[3] = NULL;
6639
6640 if ((out = fopen (ct -> c_file, "w")) == NULL)
6641 adios (ct -> c_file, "unable to open for writing");
6642
6643 for (i = 0; (child_id = vfork ()) == NOTOK && i > 5; i++)
6644 sleep (5);
6645 switch (child_id) {
6646 case NOTOK:
6647 adios ("fork", "unable to fork");
6648 /* NOTREACHED */
6649
6650 case OK:
6651 if (!xstdout)
6652 (void) dup2 (fileno (out), 1);
6653 (void) close (fileno (out));
6654 (void) execvp ("/bin/sh", vec);
6655 fprintf (stderr, "unable to exec ");
6656 perror ("/bin/sh");
6657 _exit (-1);
6658 /* NOTREACHED */
6659
6660 default:
6661 (void) fclose (out);
6662 if (pidXwait (child_id, NULLCP))
6663 done (1);
6664 break;
6665 }
6666 }
6667 if (listsw && ct -> c_end == 0L) {
6668 struct stat st;
6669
6670 if (stat (ct -> c_file, &st) != NOTOK)
6671 ct -> c_end = (long) st.st_size;
6672 }
6673 if (ct -> c_type != CT_TEXT && ct -> c_type != CT_APPLICATION)
6674 break;
6675 /* else fall... */
6676
6677 case CT_MESSAGE:
6678 {
6679 int charset,
6680 len,
6681 linelen,
6682 result;
6683 FILE *in;
6684
6685 if ((in = fopen (ct -> c_file, "r")) == NULL)
6686 adios (ct -> c_file, "unable to open for reading");
6687
6688 len = strlen (prefix);
6689 result = OK;
6690 switch (ct -> c_type) {
6691 case CT_TEXT:
6692 charset = ct -> c_ctparams ? 0 : -1;
6693 linelen = ct -> c_subtype == TEXT_PLAIN ? 0 : -1;
6694 break;
6695
6696 case CT_APPLICATION:
6697 charset = linelen = ct -> c_encoding ? 0 : -1;
6698 break;
6699
6700 default:
6701 charset = linelen = 0;
6702 break;
6703 }
6704 while (fgets (buffer, sizeof buffer - 1, in)) {
6705 if (charset == -1) {
6706 for (cp = buffer; *cp; cp++) {
6707 if (!isascii (*cp)) {
6708 charset = CHARSET_UNKNOWN;
6709 break;
6710 }
6711 if (linelen == -1
6712 && ebcdicsw
6713 && !ebcdicsafe[*cp & 0xff])
6714 linelen = 1;
6715 }
6716 if ((linelen == -1) && (cp - buffer > CPERLIN + 1))
6717 linelen = 1;
6718 if (result == NOTOK)
6719 break;
6720 }
6721 else
6722 if ((linelen == -1) && (strlen (buffer) > CPERLIN + 1))
6723 linelen = 1;
6724 if (result == NOTOK)
6725 continue;
6726
6727 if (linelen == -1) {
6728 if ((cp = buffer + strlen (buffer) - 2) > buffer
6729 && isspace (*cp))
6730 linelen = 1;
6731 else
6732 if ((*(cp = buffer) == '.')
6733 || (strncmp (cp, "From ",
6734 sizeof "From " -1) == 0))
6735 linelen = 1;
6736 }
6737
6738 if (buffer[0] == '-' && buffer[1] == '-') {
6739 for (cp = buffer + strlen (buffer) - 1;
6740 cp >= buffer;
6741 cp--)
6742 if (!isspace (*cp))
6743 break;
6744 *++cp = '\0';
6745 if (strncmp (buffer + 2, prefix, len) == 0
6746 && isdigit (buffer[2 + len])) {
6747 result = NOTOK;
6748 if (charset != -1 && linelen != -1)
6749 break;
6750 }
6751 }
6752 }
6753 if (ct -> c_type == CT_APPLICATION && !ct -> c_encoding)
6754 ct -> c_encoding = linelen == -1
6755 && charset != CHARSET_UNKNOWN
6756 ? CE_7BIT
6757 : ct -> c_subtype
6758 != APPLICATION_POSTSCRIPT
6759 ? CE_BASE64 : CE_QUOTED;
6760 if (ct -> c_type == CT_TEXT && !ct -> c_ctparams) {
6761 register char **ap,
6762 **ep;
6763 register struct text *t;
6764
6765 if (charset == CHARSET_UNKNOWN && mm_charset)
6766 charset = -2;
6767 else
6768 if (charset == -1)
6769 charset = CHARSET_USASCII;
6770
6771 if ((t = (struct text *) calloc (1, sizeof *t)) == NULL)
6772 adios (NULLCP, "out of memory");
6773 ct -> c_ctparams = (caddr_t) t;
6774 for (ap = ci -> ci_attrs, ep = ci -> ci_values;
6775 *ap;
6776 ap++, ep++)
6777 continue;
6778 switch (t -> tx_charset = charset) {
6779 case CHARSET_USASCII:
6780 *ap = add ("charset=us-ascii", NULLCP);
6781 break;
6782
6783 case CHARSET_UNKNOWN:
6784 default:
6785 *ap = add ("charset=x-unknown", NULLCP);
6786 break;
6787
6788 case -2:
6789 *ap = concat ("charset=", mm_charset, NULLCP);
6790 break;
6791 }
6792 cp = index (*ap++, '=');
6793 *ap = NULL;
6794 *cp++ = '\0';
6795 *ep = cp;
6796 }
6797 if (ct -> c_type == CT_TEXT && ct -> c_subtype != TEXT_PLAIN)
6798 ct -> c_encoding = linelen == -1 ? CE_7BIT : CE_QUOTED;
6799
6800 (void) fclose (in);
6801
6802 return result;
6803 }
6804 }
6805
6806 return OK;
6807 }
6808
6809 /* \f */
6810
6811 static int output_content (ct, out)
6812 register CT ct;
6813 FILE *out;
6814 {
6815 int cc,
6816 mailbody,
6817 len;
6818 register char **ap,
6819 **ep;
6820 char buffer[BUFSIZ];
6821 register CI ci = &ct -> c_ctinfo;
6822
6823 if (ct -> c_type == CT_MULTIPART) {
6824 register char *cp;
6825 static int encl = 0;
6826
6827 ap = ci -> ci_attrs, ep = ci -> ci_values;
6828
6829 (void) sprintf (buffer, "boundary=%s%d", prefix, encl++);
6830 cp = index (*ap++ = add (buffer, NULLCP), '=');
6831 *ap = NULL;
6832 *cp++ = '\0';
6833 *ep = cp;
6834 }
6835 else
6836 if (ct -> c_type == CT_MESSAGE && ct -> c_rfc934)
6837 goto rfc934_mode;
6838
6839 len = 0;
6840 fprintf (out, "%s: %s/%s", TYPE_FIELD, ci -> ci_type, ci -> ci_subtype);
6841 len += strlen (TYPE_FIELD) + 2 + strlen (ci -> ci_type)
6842 + 1 + strlen (ci -> ci_subtype);
6843 mailbody = ct -> c_type == CT_MESSAGE
6844 && ct -> c_subtype == MESSAGE_EXTERNAL
6845 && ((struct exbody *) ct -> c_ctparams) -> eb_body;
6846 for (ap = ci -> ci_attrs, ep = ci -> ci_values; *ap; ap++, ep++) {
6847 if (mailbody && uleq (*ap, "body"))
6848 continue;
6849
6850 (void) putc (';', out);
6851 len++;
6852
6853 (void) sprintf (buffer, "%s=\"%s\"", *ap, *ep);
6854
6855 if (len + 1 + (cc = strlen (buffer)) >= CPERLIN) {
6856 (void) fputs ("\n\t", out);
6857 len = 8;
6858 }
6859 else {
6860 (void) putc (' ', out);
6861 len++;
6862 }
6863 fputs (buffer, out);
6864 len += cc;
6865 }
6866 if (ci -> ci_comment) {
6867 if (len + 1 + (cc = 2 + strlen (ci -> ci_comment)) >= CPERLIN) {
6868 (void) fputs ("\n\t", out);
6869 len = 8;
6870 }
6871 else {
6872 (void) putc (' ', out);
6873 len++;
6874 }
6875 fprintf (out, "(%s)", ci -> ci_comment);
6876 len += cc;
6877 }
6878 (void) putc ('\n', out);
6879 if (ct -> c_id)
6880 fprintf (out, "%s: %s", ID_FIELD, ct -> c_id);
6881 if (ct -> c_descr)
6882 fprintf (out, "%s: %s", DESCR_FIELD, ct -> c_descr);
6883
6884 rfc934_mode: ;
6885 if (ct -> c_ctextern)
6886 return OK;
6887 switch (ct -> c_type) {
6888 case CT_MULTIPART:
6889 {
6890 struct multipart *m = (struct multipart *) ct -> c_ctparams;
6891 register struct part *part;
6892
6893 if (ct -> c_rfc934)
6894 (void) putc ('\n', out);
6895
6896 for (part = m -> mp_parts; part; part = part -> mp_next) {
6897 register CT p = part -> mp_part;
6898
6899 fprintf (out, "\n--%s\n", ci -> ci_values[0]);
6900 (void) output_content (p, out);
6901 }
6902
6903 fprintf (out, "\n--%s--\n", ci -> ci_values[0]);
6904 }
6905 break;
6906
6907 case CT_TEXT:
6908 if (ct -> c_ctparams
6909 && ((struct text *) ct -> c_ctparams) -> tx_charset
6910 != CHARSET_USASCII) {
6911 quoted_printable: ;
6912 if (checksw)
6913 writeDigest (ct, out, 1);
6914 fprintf (out, "%s: %s\n\n", ENCODING_FIELD,
6915 "quoted-printable");
6916 (void) writeQuoted (ct, out);
6917 break;
6918 }
6919 if ((ct -> c_subtype != TEXT_PLAIN && ct -> c_encoding != CE_7BIT)
6920 || checksw)
6921 goto quoted_printable;
6922 /* else fall... */
6923
6924 case CT_MESSAGE:
6925 seven_bit: ;
6926 (void) putc ('\n', out);
6927 if (ct -> c_type == CT_MESSAGE
6928 && ct -> c_subtype == MESSAGE_EXTERNAL) {
6929 register struct exbody *e = (struct exbody *) ct -> c_ctparams;
6930
6931 (void) output_content (e -> eb_content, out);
6932 if (e -> eb_body) {
6933 register char *cp;
6934
6935 putc ('\n', out);
6936 for (cp = e -> eb_body; *cp; cp++) {
6937 CT ct2 = e -> eb_content;
6938 CI ci2 = &ct2 -> c_ctinfo;
6939
6940 if (*cp == '\\')
6941 switch (*++cp) {
6942 case 'I':
6943 if (ct2 -> c_id) {
6944 char *dp = trimcpy (ct2 -> c_id);
6945
6946 (void) fputs (dp, out);
6947 free (dp);
6948 }
6949 continue;
6950
6951 case 'N':
6952 for (ap = ci2 -> ci_attrs,
6953 ep = ci2 -> ci_values;
6954 *ap;
6955 ap++, ep++)
6956 if (uleq (*ap, "name")) {
6957 fprintf (out, "%s", *ep);
6958 break;
6959 }
6960 continue;
6961
6962 case 'T':
6963 fprintf (out, "%s/%s", ci2 -> ci_type,
6964 ci2 -> ci_subtype);
6965 for (ap = ci2 -> ci_attrs,
6966 ep = ci2 -> ci_values;
6967 *ap;
6968 ap++, ep++)
6969 fprintf (out, "; %s=\"%s\"", *ap, *ep);
6970 continue;
6971
6972 case 'n':
6973 (void) putc ('\n', out);
6974 continue;
6975
6976 case 't':
6977 (void) putc ('\t', out);
6978 continue;
6979
6980 case '\0':
6981 cp--;
6982 break;
6983
6984 case '\\':
6985 case '"':
6986 break;
6987
6988 default:
6989 (void) putc ('\\', out);
6990 break;
6991 }
6992
6993 (void) putc (*cp, out);
6994 }
6995 putc ('\n', out);
6996 }
6997 }
6998 else
6999 (void) write7Bit (ct, out);
7000 break;
7001
7002 case CT_APPLICATION:
7003 switch (ct -> c_encoding) {
7004 case CE_7BIT:
7005 goto seven_bit;
7006
7007 case CE_QUOTED:
7008 goto quoted_printable;
7009
7010 default:
7011 break;
7012 }
7013 /* else fall... */
7014
7015 default:
7016 if (checksw)
7017 writeDigest (ct, out, 0);
7018 fprintf (out, "%s: %s\n\n", ENCODING_FIELD, "base64");
7019 (void) writeBase64 (ct, out);
7020 break;
7021 }
7022
7023 return OK;
7024 }
7025
7026 /* \f */
7027
7028 static int write7Bit (ct, out)
7029 register CT ct;
7030 FILE *out;
7031 {
7032 char c,
7033 buffer[BUFSIZ];
7034 FILE *in;
7035
7036 if ((in = fopen (ct -> c_file, "r")) == NULL)
7037 adios (ct -> c_file, "unable to open for reading");
7038
7039 c = '\n';
7040 while (fgets (buffer, sizeof buffer - 1, in)) {
7041 c = buffer[strlen (buffer) - 1];
7042 (void) fputs (buffer, out);
7043 }
7044 if (c != '\n')
7045 (void) putc ('\n', out);
7046
7047 (void) fclose (in);
7048
7049 return OK;
7050 }
7051
7052 /* \f */
7053
7054 static int writeQuoted (ct, out)
7055 register CT ct;
7056 FILE *out;
7057 {
7058 register char *cp;
7059 char c,
7060 buffer[BUFSIZ];
7061 FILE *in;
7062
7063 if ((in = fopen (ct -> c_file, "r")) == NULL)
7064 adios (ct -> c_file, "unable to open for reading");
7065
7066 while (fgets (buffer, sizeof buffer - 1, in)) {
7067 register int n;
7068
7069 cp = buffer + strlen (buffer) - 1;
7070 if ((c = *cp) == '\n')
7071 *cp = '\0';
7072
7073 if ((*(cp = buffer) == '.')
7074 || (strncmp (cp, "From ", sizeof "From " - 1) == 0)) {
7075 (void) fprintf (out, "=%02X", *cp++ & 0xff);
7076 n = 3;
7077 }
7078 else
7079 n = 0;
7080 for (; *cp; cp++) {
7081 if (n > CPERLIN - 3) {
7082 (void) fputs ("=\n", out);
7083 n = 0;
7084 }
7085
7086 switch (*cp) {
7087 case ' ':
7088 case '\t':
7089 (void) putc (*cp, out);
7090 n++;
7091 break;
7092
7093 default:
7094 if (*cp < '!'
7095 || *cp > '~'
7096 || (ebcdicsw && !ebcdicsafe[*cp & 0xff]))
7097 goto three_print;
7098 (void) putc (*cp, out);
7099 n++;
7100 break;
7101
7102 case '=':
7103 three_print: ;
7104 (void) fprintf (out, "=%02X", *cp & 0xff);
7105 n += 3;
7106 break;
7107 }
7108 }
7109
7110 if (c == '\n') {
7111 if (cp > buffer && (*--cp == ' ' || *cp == '\t'))
7112 (void) fputs ("=\n", out);
7113
7114 (void) putc ('\n', out);
7115 }
7116 else
7117 (void) fputs ("=\n", out);
7118 }
7119
7120 (void) fclose (in);
7121
7122 return OK;
7123 }
7124
7125 /* \f */
7126
7127 static char nib2b64[0x40+1] =
7128 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
7129
7130
7131 static int writeBase64 (ct, out)
7132 register CT ct;
7133 FILE *out;
7134 {
7135 int result;
7136 FILE *in;
7137
7138 if ((in = fopen (ct -> c_file, "r")) == NULL)
7139 adios (ct -> c_file, "unable to open for reading");
7140
7141 result = writeBase64aux (in, out);
7142
7143 (void) fclose (in);
7144
7145 return result;
7146 }
7147
7148
7149 static int writeBase64aux (in, out)
7150 FILE *in,
7151 *out;
7152 {
7153 int cc,
7154 n;
7155 char inbuf[3];
7156
7157 n = BPERLIN;
7158 while ((cc = fread (inbuf, sizeof *inbuf, sizeof inbuf, in)) > 0) {
7159 unsigned long bits;
7160 register char *bp;
7161 char outbuf[4];
7162
7163 if (cc < sizeof inbuf) {
7164 inbuf[2] = 0;
7165 if (cc < sizeof inbuf - 1)
7166 inbuf[1] = 0;
7167 }
7168 bits = (inbuf[0] & 0xff) << 16;
7169 bits |= (inbuf[1] & 0xff) << 8;
7170 bits |= inbuf[2] & 0xff;
7171
7172 for (bp = outbuf + sizeof outbuf; bp > outbuf; bits >>= 6)
7173 *--bp = nib2b64[bits & 0x3f];
7174 if (cc < sizeof inbuf) {
7175 outbuf[3] = '=';
7176 if (cc < sizeof inbuf - 1)
7177 outbuf[2] = '=';
7178 }
7179
7180 (void) fwrite (outbuf, sizeof *outbuf, sizeof outbuf, out);
7181
7182 if (cc < sizeof inbuf) {
7183 (void) putc ('\n', out);
7184 return OK;
7185 }
7186
7187 if (--n <= 0) {
7188 n = BPERLIN;
7189 (void) putc ('\n', out);
7190 }
7191 }
7192 if (n != BPERLIN)
7193 (void) putc ('\n', out);
7194
7195 return OK;
7196 }
7197
7198 /* \f */
7199
7200 static int writeDigest (ct, out, asciiP)
7201 register CT ct;
7202 FILE *out;
7203 int asciiP;
7204 {
7205 int cc;
7206 char buffer[BUFSIZ];
7207 register unsigned char *dp;
7208 unsigned char digest[16];
7209 FILE *in;
7210 MD5_CTX mdContext;
7211
7212 if ((in = fopen (ct -> c_file, "r")) == NULL)
7213 adios (ct -> c_file, "unable to open for reading");
7214
7215 MD5Init (&mdContext);
7216 if (asciiP) {
7217 while (fgets (buffer, sizeof buffer - 1, in)) {
7218 register char *cp;
7219 char c;
7220
7221 cp = buffer + strlen (buffer) - 1;
7222 if ((c = *cp) == '\n')
7223 *cp = '\0';
7224
7225 MD5Update (&mdContext, (unsigned char *) buffer,
7226 (unsigned int) strlen (buffer));
7227
7228 if (c == '\n')
7229 MD5Update (&mdContext, (unsigned char *) "\r\n", 2);
7230 }
7231 }
7232 else
7233 while ((cc = fread (buffer, sizeof *buffer, sizeof buffer, in)) > 0)
7234 MD5Update (&mdContext, (unsigned char *) buffer,
7235 (unsigned int) cc);
7236 MD5Final (digest, &mdContext);
7237 if (debugsw) {
7238 unsigned char *ep;
7239
7240 fprintf (stderr, "MD5 digest=");
7241 for (ep = (dp = digest) + sizeof digest / sizeof digest[0];
7242 dp < ep;
7243 dp++)
7244 fprintf (stderr, "%02x", *dp & 0xff);
7245 fprintf (stderr, "\n");
7246 }
7247
7248 (void) fclose (in);
7249
7250 fprintf (out, "%s: ", MD5_FIELD);
7251 for (dp = digest, cc = sizeof digest / sizeof digest[0]; cc > 0; cc -= 3) {
7252 unsigned long bits;
7253 register char *bp;
7254 char outbuf[4];
7255
7256 bits = (*dp++ & 0xff) << 16;
7257 if (cc > 1) {
7258 bits |= (*dp++ & 0xff) << 8;
7259 if (cc > 2)
7260 bits |= *dp++ & 0xff;
7261 }
7262
7263 for (bp = outbuf + sizeof outbuf; bp > outbuf; bits >>= 6)
7264 *--bp = nib2b64[bits & 0x3f];
7265 if (cc < 3) {
7266 outbuf[3] = '=';
7267 if (cc < 2)
7268 outbuf[2] = '=';
7269 }
7270
7271 (void) fwrite (outbuf, sizeof *outbuf, sizeof outbuf, out);
7272 }
7273 fprintf (out, "\n");
7274 }
7275
7276 /* \f */
7277
7278 static int readDigest (ct, cp)
7279 register CT ct;
7280 register char *cp;
7281 {
7282 int bitno,
7283 skip;
7284 unsigned long bits;
7285 char *bp = cp;
7286 register unsigned char *dp;
7287 unsigned char value,
7288 *ep,
7289 *b = (unsigned char *) &bits,
7290 *b1 = &b[endian > 0 ? 1 : 2],
7291 *b2 = &b[endian > 0 ? 2 : 1],
7292 *b3 = &b[endian > 0 ? 3 : 0];
7293
7294 bitno = 18, bits = 0L, skip = 0;
7295 for (ep = (dp = ct -> c_digest)
7296 + sizeof ct -> c_digest / sizeof ct -> c_digest[0];
7297 *cp;
7298 cp++)
7299 switch (*cp) {
7300 default:
7301 if (skip
7302 || (*cp & 0x80)
7303 || (value = b642nib[*cp & 0x7f]) > 0x3f) {
7304 if (debugsw)
7305 fprintf (stderr, "invalid BASE64 encoding\n");
7306 return NOTOK;
7307 }
7308
7309 bits |= value << bitno;
7310 test_end: ;
7311 if ((bitno -= 6) < 0) {
7312 if (dp + (3 - skip) > ep)
7313 goto invalid_digest;
7314 *dp++ = *b1;
7315 if (skip < 2) {
7316 *dp++ = *b2;
7317 if (skip < 1)
7318 *dp++ = *b3;
7319 }
7320 bitno = 18, bits = 0L, skip = 0;
7321 }
7322 break;
7323
7324 case '=':
7325 if (++skip > 3)
7326 goto self_delimiting;
7327 goto test_end;
7328 }
7329 if (bitno != 18) {
7330 if (debugsw)
7331 fprintf (stderr, "premature ending (bitno %d)\n", bitno);
7332
7333 return NOTOK;
7334 }
7335 self_delimiting: ;
7336 if (dp != ep) {
7337 invalid_digest: ;
7338 if (debugsw) {
7339 while (*cp)
7340 cp++;
7341 fprintf (stderr, "invalid MD5 digest (got %d octets)\n",
7342 cp - bp);
7343 }
7344
7345 return NOTOK;
7346 }
7347
7348 if (debugsw) {
7349 fprintf (stderr, "MD5 digest=");
7350 for (dp = ct -> c_digest; dp < ep; dp++)
7351 fprintf (stderr, "%02x", *dp & 0xff);
7352 fprintf (stderr, "\n");
7353 }
7354
7355 return OK;
7356 }
7357
7358 /* \f VIAMAIL */
7359
7360 #include "../zotnet/tws.h"
7361
7362
7363 static int via_mail (mailsw, subjsw, parmsw, descsw, cmntsw, slowsw, fromsw)
7364 char *mailsw,
7365 *subjsw,
7366 *parmsw,
7367 *descsw,
7368 *cmntsw,
7369 *fromsw;
7370 int slowsw;
7371 {
7372 int nlines,
7373 nparts,
7374 status;
7375 long pos;
7376 long offset;
7377 char tmpfil[BUFSIZ];
7378 struct stat st;
7379 FILE *fp;
7380
7381 (void) umask (~m_gmprot ());
7382
7383 (void) strcpy (tmpfil, m_tmpfil (invo_name));
7384 if ((fp = fopen (tmpfil, "w+")) == NULL)
7385 adios (tmpfil, "unable to open for writing");
7386 (void) chmod (tmpfil, 0600);
7387
7388 if (!index (mailsw, '@@'))
7389 mailsw = concat (mailsw, "@@", LocalName (), NULLCP);
7390 fprintf (fp, "To: %s\n", mailsw);
7391 nlines = 1;
7392 if (subjsw)
7393 fprintf (fp, "Subject: %s\n", subjsw), nlines++;
7394 if (fromsw) {
7395 if (!index (fromsw, '@@'))
7396 fromsw = concat (fromsw, "@@", LocalName (), NULLCP);
7397 fprintf (fp, "From: %s\n", fromsw), nlines++;
7398 }
7399 fprintf (fp, "%s: %s\n", VRSN_FIELD, VRSN_VALUE), nlines++;
7400 offset = ftell (fp);
7401 fprintf (fp, "%s: application/octet-stream", TYPE_FIELD);
7402 if (parmsw)
7403 fprintf (fp, "; %s", parmsw);
7404 if (cmntsw)
7405 fprintf (fp, "\n\t(%s)", cmntsw), nlines++;
7406 if (descsw)
7407 fprintf (fp, "\n%s: %s", DESCR_FIELD, descsw), nlines++;
7408 fprintf (fp, "\n%s: %s\n\n", ENCODING_FIELD, "base64"), nlines += 2;
7409 if (fflush (fp))
7410 adios (tmpfil, "error writing to");
7411
7412 pos = ftell (fp);
7413 (void) writeBase64aux (stdin, fp);
7414 if (fflush (fp))
7415 adios (tmpfil, "error writing to");
7416
7417 if (fstat (fileno (fp), &st) == NOTOK)
7418 adios ("failed", "fstat of %s", tmpfil);
7419 nlines += (((long) st.st_size - pos) + CPERLIN) / (CPERLIN + 1);
7420 nparts = (nlines + (LPERMSG - 1)) / LPERMSG;
7421
7422 if (nparts <= 1)
7423 status = via_post (tmpfil, 0);
7424 else {
7425 int partno;
7426 long clock;
7427 char buffer[BUFSIZ],
7428 msgid[BUFSIZ];
7429
7430 if (verbosw) {
7431 printf ("sending binary image as %d partial messages\n", nparts);
7432 (void) fflush (stdout);
7433 }
7434
7435 (void) time (&clock);
7436 (void) sprintf (msgid, "<%d.%ld@@%s>", getpid (), clock, LocalName ());
7437
7438 (void) fseek (fp, offset, 0);
7439 for (partno = 1; partno <= nparts; partno++) {
7440 int lineno;
7441 char tmpdrf[BUFSIZ];
7442 FILE *out;
7443
7444 (void) strcpy (tmpdrf, m_tmpfil (invo_name));
7445 if ((out = fopen (tmpdrf, "w")) == NULL)
7446 adios (tmpdrf, "unable to open for writing");
7447 (void) chmod (tmpdrf, 0600);
7448
7449 fprintf (out, "To: %s\n", mailsw);
7450 if (subjsw)
7451 fprintf (out, "Subject: %s\n", subjsw);
7452 fprintf (out, "%s: %s\n", VRSN_FIELD, VRSN_VALUE);
7453 fprintf (out,
7454 "%s: message/partial; id=\"%s\";\n\tnumber=%d; total=%d\n",
7455 TYPE_FIELD, msgid, partno, nparts);
7456 fprintf (out, "%s: part %d of %d\n\n", DESCR_FIELD, partno,
7457 nparts);
7458
7459 if (partno == 1)
7460 fprintf (out, "Message-ID: %s\n", msgid);
7461
7462 for (lineno = LPERMSG; lineno > 0; lineno--) {
7463 if (!fgets (buffer, sizeof buffer, fp)) {
7464 if (partno == nparts)
7465 break;
7466 adios (NULLCP, "premature eof");
7467 }
7468
7469 (void) fputs (buffer, out);
7470 }
7471 offset = ftell (fp);
7472
7473 if (fflush (out))
7474 adios (tmpdrf, "error writing to");
7475
7476 (void) fclose (out);
7477
7478 status = via_post (tmpdrf, slowsw == 0);
7479 (void) unlink (tmpdrf);
7480 if (status)
7481 break;
7482
7483 if (slowsw > 0 && partno < nparts) {
7484 if (verbosw) {
7485 printf ("pausing %d seconds before sending part %d...\n",
7486 slowsw, partno + 1);
7487 (void) fflush (stdout);
7488 }
7489
7490 sleep ((unsigned) slowsw);
7491 }
7492 }
7493 }
7494
7495 (void) fclose (fp);
7496 (void) unlink (tmpfil);
7497
7498 done (status ? 1 : 0);
7499 }
7500
7501 /* \f */
7502
7503 static int via_post (file, queued)
7504 char *file;
7505 int queued;
7506 {
7507 int child_id,
7508 i;
7509
7510 for (i = 0; (child_id = fork ()) == NOTOK && i < 5; i++)
7511 sleep (5);
7512 switch (child_id) {
7513 case NOTOK:
7514 adios ("fork", "unable to");
7515 /* NOTREACHED */
7516
7517 case OK:
7518 (void) execlp (postproc, r1bindex (postproc, '/'), file,
7519 queued ? "-queued" : NULLCP, NULLCP);
7520 fprintf (stderr, "unable to exec ");
7521 perror (postproc);
7522 _exit (-1);
7523 /* NOTREACHED */
7524
7525 default:
7526 return pidXwait (child_id, postproc);
7527 }
7528 }
7529
7530 /* \f */
7531
7532 void done (status)
7533 int status;
7534 {
7535 register CT *ctp;
7536
7537 if (ctp = cts)
7538 for (; *ctp; ctp++)
7539 free_content (*ctp);
7540 if (free_ct)
7541 free_content (free_ct);
7542 if (free_file)
7543 (void) unlink (free_file);
7544
7545 exit (status);
7546 }
7547
7548
7549 static int pidcheck (status)
7550 int status;
7551 {
7552 if ((status & 0xff00) == 0xff00 || (status & 0x007f) != SIGQUIT)
7553 return status;
7554
7555 (void) unlink ("core");
7556
7557 (void) fflush (stdout);
7558
7559 (void) fflush (stderr);
7560
7561 done (1);
7562 /* NOTREACHED */
7563 }
7564 @
7565
7566
7567 2.41
7568 log
7569 @pgp fixes from mtr
7570 @
7571 text
7572 @d3 1
7573 a3 1
7574 static char ident[] = "@@(#)$Id: mhn.c,v 2.40 1995/12/06 21:03:37 jromine Exp jromine $";
7575 d1019 1
7576 a1019 1
7577 int si_value;
7578 d1162 1
7579 a1162 1
7580 ct -> c_type = s2i -> si_value;
7581 d1201 1
7582 a1201 1
7583 ct -> c_encoding = s2i -> si_value;
7584 d3674 1
7585 a3674 1
7586 e -> eb_flags = s2i -> si_value;
7587 d5889 1
7588 a5889 1
7589 switch (ct -> c_type = s2i -> si_value) {
7590 d5925 1
7591 a5925 1
7592 switch (ct -> c_type = s2i -> si_value) {
7593 @
7594
7595
7596 2.40
7597 log
7598 @mhn bugfix
7599 @
7600 text
7601 @d3 1
7602 a3 1
7603 static char ident[] = "@@(#)$Id: mhn.c,v 2.39 1995/12/06 21:02:05 jromine Exp jromine $";
7604 d1093 1
7605 d1098 1
7606 d1100 1
7607 d1102 2
7608 @
7609
7610
7611 2.39
7612 log
7613 @enhancements for quoted-printable from mtr
7614 @
7615 text
7616 @d3 1
7617 a3 1
7618 static char ident[] = "@@(#)$Id: mhn.c,v 2.38 1995/12/06 20:55:31 jromine Exp jromine $";
7619 d3383 3
7620 a3385 1
7621 if (ct -> c_subtype == MULTI_ALTERNATE && m -> mp_parts -> mp_next) {
7622 @
7623
7624
7625 2.38
7626 log
7627 @fix from mtr
7628 @
7629 text
7630 @d3 1
7631 a3 1
7632 static char ident[] = "@@(#)$Id: mhn.c,v 2.37 1995/12/06 19:20:22 jromine Exp jromine $";
7633 d6452 10
7634 a6461 4
7635 if (linelen == -1
7636 && (cp = buffer + strlen (buffer) - 2) > buffer
7637 && isspace (*cp))
7638 linelen = 1;
7639 d6798 2
7640 a6799 1
7641 if (strncmp (cp = buffer, "From ", sizeof "From " - 1) == 0) {
7642 @
7643
7644
7645 2.37
7646 log
7647 @fixes from mtr
7648 @
7649 text
7650 @d3 1
7651 a3 1
7652 static char ident[] = "@@(#)$Id: mhn.c,v 2.36 1994/04/21 19:23:38 jromine Exp jromine $";
7653 a6618 4
7654 if (p -> c_type == CT_MESSAGE
7655 && p -> c_subtype != MESSAGE_EXTERNAL
7656 && !p -> c_rfc934)
7657 fprintf (out, "%s: %s\n", VRSN_FIELD, VRSN_VALUE);
7658 @
7659
7660
7661 2.36
7662 log
7663 @mhn fixes from MTR
7664 @
7665 text
7666 @d3 1
7667 a3 1
7668 static char ident[] = "@@(#)$Id: mhn.c,v 2.35 1993/10/26 22:17:44 jromine Exp jromine $";
7669 d1291 1
7670 d2130 1
7671 a2130 1
7672 if (intr != OK) {
7673 d5074 1
7674 a5074 1
7675 e -> eb_mode && uleq (e -> eb_mode, "ascii"), 0)
7676 @
7677
7678
7679 2.35
7680 log
7681 @change to re-sync with mtr's version
7682 @
7683 text
7684 @d3 1
7685 a3 1
7686 static char ident[] = "@@(#)$Id: mhn.c,v 2.34 1993/10/26 20:15:00 jromine Exp jromine $";
7687 d2608 1
7688 d2611 1
7689 d2613 1
7690 a2613 1
7691 free (*ap);
7692 d2616 1
7693 d2619 1
7694 d2631 1
7695 d2635 1
7696 d2639 1
7697 d2645 1
7698 d2649 1
7699 d2652 1
7700 d2655 1
7701 d2659 1
7702 d2662 1
7703 d2666 1
7704 d2669 1
7705 d2675 1
7706 d2679 1
7707 d2683 1
7708 d2745 1
7709 a2745 1
7710 if (autosw && !ct -> c_storeproc && uleq (*ap, "x-name")) {
7711 d2844 1
7712 a2844 1
7713 if (autosw && !ct -> c_storeproc && uleq (*ap, "x-name")) {
7714 d4063 1
7715 a4063 1
7716 if (autosw && !ct -> c_storeproc && uleq (*ap, "x-name")) {
7717 d4445 5
7718 a4449 2
7719 if ((cp = getenv ("MM_NOASK")) && strcmp (cp, "1") == 0)
7720 nolist = 1, listsw = pausesw = 0;
7721 d6397 1
7722 a6397 3
7723 if (ct -> c_type != CT_TEXT
7724 && !(ct -> c_type == CT_APPLICATION
7725 && ct -> c_subtype == APPLICATION_POSTSCRIPT))
7726 d6474 4
7727 a6477 1
7728 ? CE_7BIT : CE_QUOTED;
7729 d6725 2
7730 a6726 2
7731 if (ct -> c_subtype == APPLICATION_POSTSCRIPT) {
7732 if (ct -> c_encoding == CE_7BIT)
7733 d6728 6
7734 a6733 1
7735 goto quoted_printable;
7736 @
7737
7738
7739 2.34
7740 log
7741 @fixes from mtr -- content-id?
7742 @
7743 text
7744 @d3 1
7745 a3 1
7746 static char ident[] = "@@(#)$Id: mhn.c,v 2.33 1993/10/26 20:11:27 jromine Exp jromine $";
7747 d12 1
7748 d2564 1
7749 a2564 1
7750 for (cp = file; cp = index (cp, '/'); cp++) {
7751 d3598 2
7752 a3603 3
7753
7754 unsigned long
7755 eb_size;
7756 d3922 3
7757 a3924 2
7758 content_error (NULLCP, ct,
7759 "empty body for access-type=mail-server");
7760 d4682 1
7761 a4682 1
7762
7763 d5223 1
7764 a5223 1
7765 && find_cache_aux (writing, cache_private, id,
7766 d5235 1
7767 a5235 1
7768 && find_cache_aux (writing, cache_public, id,
7769 d5247 1
7770 a5247 1
7771 && find_cache_aux (writing, cache_private, id,
7772 d5301 1
7773 a5301 1
7774 int *writing;
7775 d5306 1
7776 d5315 3
7777 d5338 16
7778 a5353 2
7779 (void) sprintf (mapname, "%s/%s", directory, invo_name);
7780 (void) strcpy (mapname, r1bindex (m_scratch (mapname, invo_name), '/'));
7781 d5355 2
7782 d5360 12
7783 a5371 1
7784 if (!(fp = fopen (mapfile, "a")))
7785 d5374 1
7786 a5374 1
7787 (void) fclose (fp);
7788 d5399 1
7789 a5399 1
7790 if (!(fp = fopen (mapfile, "r")))
7791 d5430 1
7792 a5430 1
7793 (void) fclose (fp);
7794 d5446 1
7795 a5446 1
7796 (void) fclose (fp);
7797 d5862 5
7798 d5874 1
7799 d6032 7
7800 a6038 6
7801 if (get_ctinfo ("multipart/digest", ct, 0) == NOTOK)
7802 done (1);
7803 ct -> c_type = CT_MULTIPART;
7804 ct -> c_subtype = MULTI_DIGEST;
7805 ct -> c_ctlistfnx = list_multi;
7806 ct -> c_ctfreefnx = free_multi;
7807 d6040 3
7808 a6042 3
7809 if ((m = (struct multipart *) calloc (1, sizeof *m)) == NULL)
7810 adios (NULLCP, "out of memory");
7811 ct -> c_ctparams = (caddr_t) m;
7812 d6044 4
7813 a6047 1
7814 pp = &m -> mp_parts;
7815 d6066 9
7816 a6074 4
7817 if ((part = (struct part *) calloc (1, sizeof *part)) == NULL)
7818 adios (NULLCP, "out of memory");
7819 *pp = part, pp = &part -> mp_next;
7820 part -> mp_part = p;
7821 d6637 3
7822 d6642 30
7823 @
7824
7825
7826 2.33
7827 log
7828 @minor fixup in DESCR/ID_FIELD
7829 @
7830 text
7831 @d3 1
7832 a3 1
7833 static char ident[] = "@@(#)$Id: mhn.c,v 2.32 1993/10/26 15:56:01 jromine Exp jromine $";
7834 d1518 20
7835 a6044 1
7836
7837 d6512 1
7838 a6512 1
7839 fprintf (out, "%s", buffer);
7840 d6527 1
7841 a6527 1
7842 fprintf (out, "\n");
7843 d6543 1
7844 a6543 1
7845 fprintf (out, "\n");
7846 d6572 2
7847 a6573 1
7848 if (ct -> c_subtype != TEXT_PLAIN && ct -> c_encoding != CE_7BIT)
7849 a6574 2
7850 if (checksw)
7851 goto quoted_printable;
7852 d6579 1
7853 a6579 1
7854 fprintf (out, "\n");
7855 d6585 32
7856 a6616 2
7857 if (e -> eb_body)
7858 fprintf (out, "\n%s\n", e -> eb_body);
7859 @
7860
7861
7862 2.32
7863 log
7864 @formatting fixup (part 2)
7865 @
7866 text
7867 @d3 1
7868 a3 1
7869 static char ident[] = "@@(#)$Id: mhn.c,v 2.28 1993/10/25 19:58:19 jromine Exp jromine $";
7870 d4699 1
7871 a4699 1
7872 fprintf (ce -> ce_fp, "%s: %s", ID_FIELD, ct -> c_id);
7873 d4701 2
7874 a4702 1
7875 fprintf (ce -> ce_fp, "%s: %s", DESCR_FIELD, ct -> c_descr);
7876 @
7877
7878
7879 2.31
7880 log
7881 @fixup formatting
7882 @
7883 text
7884 @d4867 1
7885 a4867 3
7886 (void) fclose (fp);
7887 }
7888 (void) umask (mask);
7889 d4869 2
7890 @
7891
7892
7893 2.30
7894 log
7895 @cache changes (part 2)
7896 @
7897 text
7898 @d4793 1
7899 a4793 1
7900 ce -> ce_unlink = 0;
7901 d4795 2
7902 a4796 2
7903 goto ready_already;
7904 }
7905 d4799 1
7906 a4799 1
7907 }
7908 d4842 2
7909 a4843 2
7910 int mask;
7911 FILE *fp;
7912 d4846 2
7913 a4847 2
7914 if (fp = fopen (cachefile, "w")) {
7915 int cc;
7916 d4851 1
7917 a4851 1
7918 (void) fseek (gp, 0L, 0);
7919 d4855 2
7920 a4856 2
7921 (void) fwrite (buffer, sizeof *buffer, cc, fp);
7922 (void) fflush (fp);
7923 d4858 4
7924 a4861 4
7925 if (ferror (gp)) {
7926 admonish (ce -> ce_file, "error reading");
7927 (void) unlink (cachefile);
7928 }
7929 d4959 3
7930 a4961 4
7931 if (*file == NULL) {
7932 ce -> ce_unlink = 0;
7933 caching = 1;
7934 }
7935 d4963 1
7936 d5059 4
7937 a5062 4
7938 if (ferror (fp)) {
7939 admonish (cachefile, "error writing");
7940 (void) unlink (cachefile);
7941 }
7942 @
7943
7944
7945 2.29
7946 log
7947 @add -nocache, -rcache, -wcache
7948 @
7949 text
7950 @d147 7
7951 a153 3
7952 #define CACHE_ALWAYS 0
7953 "always", 0,
7954 #define CACHE_ASK 1
7955 a154 2
7956 #define CACHE_NEVER 2
7957 "never", 0,
7958 d160 1
7959 a160 1
7960 static int cachesw = CACHE_ASK;
7961 d173 1
7962 d182 1
7963 d190 2
7964 a191 1
7965 static char *cache;
7966 d318 1
7967 d330 1
7968 d352 2
7969 a353 1
7970 msgnum;
7971 d413 12
7972 d427 1
7973 a427 1
7974 switch (cachesw = smatch (cp, caches)) {
7975 d639 6
7976 a644 1
7977 cache = cachesw != CACHE_NEVER ? m_find (buf) : NULLCP;
7978 d658 1
7979 d781 1
7980 a781 1
7981 if (!listsw && !showsw && !storesw)
7982 d817 2
7983 d831 2
7984 d838 13
7985 d862 2
7986 d896 2
7987 d949 2
7988 d2057 1
7989 a2057 1
7990 list_content (ct, -1);
7991 a3977 1
7992
7993 a4656 3
7994 if ((len = ct -> c_end - ct -> c_begin) < 0)
7995 adios (NULLCP, "internal error(3)");
7996
7997 a4657 1
7998 int len = 0;
7999 d4662 2
8000 d4704 3
8001 d4772 1
8002 a4772 1
8003 char *id;
8004 d4791 2
8005 a4792 33
8006 if (xpid) {
8007 if (xpid < 0)
8008 xpid = -xpid;
8009 (void) pidcheck (pidwait (xpid, NOTOK));
8010 xpid = 0;
8011 }
8012
8013 if (cache && (id = cb -> c_id)) {
8014 char buffer[BUFSIZ];
8015
8016 (void) sprintf (buffer, "%s/%s", cache, id = trimcpy (id));
8017 free (id);
8018
8019 id = getcpy (buffer);
8020 if (ce -> ce_fp = fopen (id, "r")) {
8021 char *bp;
8022 struct stat st;
8023
8024 if (cachesw == CACHE_ALWAYS)
8025 goto do_cache;
8026
8027 (void) fstat (fileno (ce -> ce_fp), &st);
8028 (void) sprintf (bp = buffer,
8029 "Use cached copy %s of size %lu octets",
8030 id, (unsigned long) st.st_size);
8031 bp += strlen (bp);
8032 if (ct -> c_partno) {
8033 (void) sprintf (bp, " (content %s)", ct -> c_partno);
8034 bp += strlen (bp);
8035 }
8036 (void) sprintf (bp, "? ");
8037 if (getanswer (buffer)) {
8038 do_cache: ;
8039 d4794 1
8040 a4794 1
8041 ce -> ce_file = id;
8042 d4797 2
8043 a4798 2
8044
8045 (void) fclose (ce -> ce_fp), ce -> ce_fp = NULL;
8046 a4799 2
8047 free (id);
8048 }
8049 d4810 3
8050 a4812 2
8051 int fd;
8052 char *id;
8053 d4839 3
8054 a4841 9
8055 if (cache
8056 && (id = e -> eb_content -> c_id)
8057 && (!e -> eb_permission
8058 || !uleq (e -> eb_permission, "read-write"))) {
8059 char buffer[BUFSIZ];
8060
8061 (void) sprintf (buffer, "Make cached, publically-accessible copy of %s? ",
8062 e -> eb_name);
8063 if (cachesw == CACHE_ALWAYS || getanswer (buffer)) {
8064 a4842 1
8065 char cachefile[BUFSIZ];
8066 d4845 1
8067 a4845 4
8068 (void) sprintf (cachefile, "%s/%s", cache, id = trimcpy (id));
8069 free (id);
8070
8071 mask = umask (0022);
8072 d4848 2
8073 a4849 1
8074 register FILE *gp = ce -> ce_fp;
8075 d4853 2
8076 a4854 2
8077 while ((cc = fread (buffer, sizeof *buffer, sizeof buffer,
8078 gp)) > 0)
8079 d4862 1
8080 a4862 1
8081
8082 a4870 1
8083 }
8084 d4883 2
8085 a4884 1
8086 int caching,
8087 d4886 2
8088 a4887 2
8089 char *ftp,
8090 *id,
8091 d4921 22
8092 a4942 7
8093 (void) sprintf (buffer,
8094 e -> eb_size > 0
8095 ? "Retrieve %s (content %s)\n using %sFTP from site %s (%lu octets)? "
8096 : "Retrieve %s (content %s)\n using %sFTP from site %s? ",
8097 e -> eb_name, e -> eb_partno,
8098 e -> eb_flags ? "anonymous " : "",
8099 e -> eb_site, e -> eb_size);
8100 d4956 3
8101 a4958 9
8102 if (cache
8103 && (id = e -> eb_content -> c_id)
8104 && (!e -> eb_permission
8105 || !uleq (e -> eb_permission, "read-write"))) {
8106 (void) sprintf (buffer, "Make cached, publically-accessible copy? ");
8107 if (cachesw == CACHE_ALWAYS || getanswer (buffer)) {
8108 (void) sprintf (cachefile, "%s/%s", cache, id = trimcpy (id));
8109 free (id);
8110
8111 a4963 1
8112 }
8113 a4975 1
8114
8115 d5037 1
8116 a5037 1
8117 (void) chmod (cachefile, 0644);
8118 d5040 1
8119 a5040 1
8120 register FILE *fp;
8121 d5042 1
8122 a5042 1
8123 mask = umask (0022);
8124 d5044 2
8125 a5045 1
8126 register FILE *gp = ce -> ce_fp;
8127 d5049 3
8128 a5051 2
8129 while (fgets (buffer, sizeof buffer - 1, gp))
8130 (void) fputs (buffer, fp);
8131 d5058 1
8132 a5058 1
8133
8134 a5081 1
8135 result,
8136 a5083 1
8137 *id,
8138 d5105 6
8139 a5110 6
8140 bp = concat ("Retrieve content ", e -> eb_partno, " by asking mailbox ",
8141 e -> eb_server, "\n\n",
8142 e -> eb_subject ? e -> eb_subject: e -> eb_body, "\n? ",
8143 NULLCP);
8144 result = getanswer (bp);
8145 free (bp);
8146 d5112 11
8147 a5122 1
8148 if (!result)
8149 d5129 1
8150 a5129 15
8151 if (e -> eb_subject)
8152 vec[vecp++] = "mail-server request";
8153 else
8154 if (cache
8155 && (id = e -> eb_content -> c_id)
8156 && (!e -> eb_permission
8157 || !uleq (e -> eb_permission, "read-write"))) {
8158 (void) sprintf (buffer, "cache content as %s/%s", cache,
8159 id = trimcpy (id));
8160 free (id);
8161
8162 vec[vecp++] = buffer;
8163 }
8164 else
8165 vec[vecp++] = "mail-server request";
8166 d5170 311
8167 @
8168
8169
8170 2.28
8171 log
8172 @fixes from mtr (20-sep-93)
8173 @
8174 text
8175 @d3 1
8176 a3 1
8177 static char ident[] = "@@(#)$Id: mhn.c,v 2.27 1993/10/25 19:32:05 jromine Exp jromine $";
8178 d30 3
8179 a32 1
8180 "cache policy", 0,
8181 d34 1
8182 a34 1
8183 #define CHECKSW 3
8184 d36 1
8185 a36 1
8186 #define NCHECKSW 4
8187 d39 1
8188 a39 1
8189 #define DEBUGSW 5
8190 d42 1
8191 a42 1
8192 #define EBCDICSW 6
8193 d44 1
8194 a44 1
8195 #define NEBCDICSW 7
8196 d47 1
8197 a47 1
8198 #define FILESW 8 /* interface from show */
8199 d50 1
8200 a50 1
8201 #define FORMSW 9
8202 d53 1
8203 a53 1
8204 #define HEADSW 10
8205 d55 1
8206 a55 1
8207 #define NHEADSW 11
8208 d58 1
8209 a58 1
8210 #define LISTSW 12
8211 d60 1
8212 a60 1
8213 #define NLISTSW 13
8214 d63 1
8215 a63 1
8216 #define PARTSW 14
8217 d66 1
8218 a66 1
8219 #define PAUSESW 15
8220 d68 1
8221 a68 1
8222 #define NPAUSESW 16
8223 d71 4
8224 a74 1
8225 #define SIZESW 17
8226 d76 1
8227 a76 1
8228 #define NSIZESW 18
8229 d79 1
8230 a79 1
8231 #define RFC934SW 19
8232 d81 1
8233 a81 1
8234 #define NRFC934SW 20
8235 d84 1
8236 a84 1
8237 #define SERIALSW 21
8238 d86 1
8239 a86 1
8240 #define NSERIALSW 22
8241 d89 1
8242 a89 1
8243 #define SHOWSW 23
8244 d91 1
8245 a91 1
8246 #define NSHOWSW 24
8247 d94 1
8248 a94 1
8249 #define STORESW 25
8250 d96 1
8251 a96 1
8252 #define NSTORESW 26
8253 d99 1
8254 a99 1
8255 #define TYPESW 27
8256 d102 1
8257 a102 1
8258 #define VERBSW 28
8259 d104 1
8260 a104 1
8261 #define NVERBSW 29
8262 d106 3
8263 d110 1
8264 a110 1
8265 #define HELPSW 30
8266 d113 1
8267 a113 1
8268 #define PROGSW 31
8269 d115 1
8270 a115 1
8271 #define NPROGSW 32
8272 d118 1
8273 a118 1
8274 #define LENSW 33
8275 d120 1
8276 a120 1
8277 #define WIDSW 34
8278 d123 1
8279 a123 1
8280 #define VIAMSW 35
8281 d125 1
8282 a125 1
8283 #define VIASSW 36
8284 d127 1
8285 a127 1
8286 #define VIAPSW 37
8287 d129 1
8288 a129 1
8289 #define VIADSW 38
8290 d131 1
8291 a131 1
8292 #define VIACSW 39
8293 d133 1
8294 a133 1
8295 #define VIAZSW 40
8296 d135 1
8297 a135 1
8298 #define VIAFSW 41
8299 @
8300
8301
8302 2.27
8303 log
8304 @fixes from mtr: add MHN_SILENT, changes something in printing
8305 multi-part messages
8306 @
8307 text
8308 @d3 1
8309 a3 1
8310 static char ident[] = "@@(#)$Id: mhn.c,v 2.26 1993/09/09 22:38:43 jromine Exp jromine $";
8311 a818 4
8312 int child_id,
8313 i,
8314 vecp;
8315 char *vec[8];
8316 d846 5
8317 a850 14
8318 vecp = 0;
8319 vec[vecp++] = r1bindex (mhlproc, '/');
8320 vec[vecp++] = "-form";
8321 vec[vecp++] = formsw;
8322 vec[vecp++] = "-nobody";
8323 vec[vecp++] = ct -> c_file;
8324 if (nomore)
8325 vec[vecp++] = "-nomoreproc";
8326 else
8327 if (progsw) {
8328 vec[vecp++] = "-moreproc";
8329 vec[vecp++] = progsw;
8330 }
8331 vec[vecp] = NULL;
8332 d852 14
8333 a865 8
8334 (void) fflush (stdout);
8335
8336 for (i = 0; (child_id = vfork ()) == NOTOK && i < 5; i++)
8337 sleep (5);
8338 switch (child_id) {
8339 case NOTOK:
8340 adios ("fork", "unable to");
8341 /* NOTREACHED */
8342 d867 1
8343 a867 6
8344 case OK:
8345 (void) execvp (mhlproc, vec);
8346 fprintf (stderr, "unable to exec ");
8347 perror (mhlproc);
8348 _exit (-1);
8349 /* NOTREACHED */
8350 d869 18
8351 a886 3
8352 default:
8353 xpid = -child_id;
8354 break;
8355 d888 2
8356 d4336 1
8357 d4350 1
8358 a4350 1
8359 if (getenv ("MHN_SILENT"))
8360 @
8361
8362
8363 2.26
8364 log
8365 @fixes from mtr
8366 @
8367 text
8368 @d3 1
8369 a3 1
8370 static char ident[] = "@@(#)$Id: mhn.c,v 2.25 1993/09/01 21:46:58 jromine Exp jromine $";
8371 d157 1
8372 d1916 1
8373 a1916 1
8374 xlist = 1;
8375 d1994 4
8376 a1997 1
8377 (*ct -> c_ctlistfnx) (ct, -1);
8378 d3040 1
8379 a3040 1
8380 xlist = 1;
8381 d4343 3
8382 d4597 46
8383 @
8384
8385
8386 2.25
8387 log
8388 @fix from mrose for quoted-printable 8-bit chars
8389 @
8390 text
8391 @d3 1
8392 a3 1
8393 static char ident[] = "@@(#)$Id: mhn.c,v 2.24 1993/09/01 20:50:03 jromine Exp jromine $";
8394 d302 4
8395 a305 4
8396 static CT get_content ();
8397 static int list_content (), show_content (), store_content ();
8398 static int user_content(), compose_content(), output_content();
8399 static void free_content (), flush_errors ();
8400 d313 1
8401 a313 1
8402 static int init_encoding(), type_ok(), copy_some_headers(), set_endian();
8403 d315 1
8404 a315 1
8405 static int write7Bit(), writeQuoted(), writeBase64(), writeBase64aux();
8406 d317 1
8407 a317 1
8408 static int via_mail(), via_post(), pidcheck();
8409 d760 1
8410 a760 1
8411 if (type_ok (ct)
8412 d777 1
8413 a777 1
8414 if (type_ok (ct) && ct -> c_ctlistfnx) {
8415 d789 1
8416 a789 1
8417 if (type_ok (ct) && ct -> c_ctstorefnx) {
8418 d805 1
8419 a805 1
8420 if (type_ok (ct) && ct -> c_ctlistfnx) {
8421 d829 1
8422 a829 1
8423 if (!type_ok (ct))
8424 d1805 1
8425 a1805 1
8426 static int show_content_aux ();
8427 d1807 1
8428 d1842 1
8429 a1842 3
8430 int child_id,
8431 fd,
8432 i,
8433 d1849 1
8434 a1849 3
8435 *vec[4],
8436 buffer[BUFSIZ],
8437 exec[BUFSIZ + sizeof "exec "];
8438 d1890 9
8439 d1943 1
8440 d1945 3
8441 d1949 20
8442 d2087 2
8443 a2088 1
8444 (void) (*ct -> c_ceclosefnx) (ct);
8445 d2249 8
8446 a2256 17
8447 /*
8448 if (debugsw) {
8449 */
8450 (void) fflush (stdout);
8451
8452 fprintf (stderr, "storing message %s", ct -> c_file);
8453 if (ct -> c_partno)
8454 fprintf (stderr, " part %s", ct -> c_partno);
8455 fprintf (stderr, " as file %s\n",
8456 strncmp (ct -> c_storage, cwd, cwdlen)
8457 || ct -> c_storage[cwdlen] != '/'
8458 ? ct -> c_storage
8459 : ct -> c_storage + cwdlen + 1);
8460 /*
8461 }
8462 */
8463
8464 d2585 1
8465 a2585 1
8466 static int part_ok (ct)
8467 d2587 1
8468 d2591 2
8469 a2592 1
8470 if (ct -> c_type == CT_MULTIPART || npart == 0)
8471 d2604 1
8472 a2604 1
8473 static int type_ok (ct)
8474 d2606 1
8475 d2612 2
8476 a2613 1
8477 if (ct -> c_type == CT_MULTIPART || ntype == 0)
8478 d2786 1
8479 a2786 1
8480 if (part_ok (p) && type_ok (p) && p -> c_ctlistfnx)
8481 d2834 1
8482 a2834 1
8483 result = OK;
8484 d2838 5
8485 a2842 4
8486 if (part_ok (p)
8487 && type_ok (p)
8488 && p -> c_ctshowfnx) {
8489 switch ((*p -> c_ctshowfnx) (p, nowserial, nowalternate)) {
8490 d2856 1
8491 a2856 1
8492 if (alternate)
8493 d2858 3
8494 d2928 142
8495 d3084 2
8496 a3085 2
8497 if (part_ok (p)
8498 && type_ok (p)
8499 d3185 2
8500 a3186 1
8501 ct -> c_ctshowfnx = show_multi;
8502 d3658 1
8503 a3658 1
8504 if (!type_ok (p))
8505 d3676 1
8506 a3676 1
8507 if (!type_ok (p))
8508 d5221 2
8509 d5331 1
8510 d5461 1
8511 a5473 1
8512 char msgid[BUFSIZ];
8513 a5475 3
8514 static int partno;
8515 static long clock = 0L;
8516 static char *msgfmt;
8517 a5509 11
8518 if (clock == 0L) {
8519 (void) time (&clock);
8520 (void) sprintf (msgid, "<%d.%ld.%%d@@%s>\n", getpid (), clock,
8521 LocalName ());
8522 partno = 0;
8523 msgfmt = getcpy (msgid);
8524 }
8525
8526 (void) sprintf (msgid, msgfmt, ++partno);
8527 p -> c_id = getcpy (msgid);
8528
8529 d5635 14
8530 a5648 3
8531 vrsn = !ci -> ci_magic ? MULTI_MIXED
8532 : uprf (ci -> ci_magic, "alt") ? MULTI_ALTERNATE
8533 : MULTI_PARALLEL;
8534 d5650 1
8535 a5650 1
8536 (void) sprintf (buffer, "multipart/%s", SubMultiPart[vrsn - 1].kv_key);
8537 d5682 22
8538 @
8539
8540
8541 2.24
8542 log
8543 @document -file
8544 @
8545 text
8546 @d3 1
8547 a3 1
8548 static char ident[] = "@@(#)$Id: mhn.c,v 2.23 1993/08/25 17:26:22 jromine Exp jromine $";
8549 d6075 3
8550 a6077 1
8551 if (ebcdicsw && !ebcdicsafe[*cp & 0xff])
8552 @
8553
8554
8555 2.23
8556 log
8557 @off_t fixes for BSD44
8558 @
8559 text
8560 @d3 1
8561 a3 1
8562 static char ident[] = "@@(#)$Id: mhn.c,v 2.22 1993/08/20 15:52:01 jromine Exp jromine $";
8563 d45 4
8564 a48 1
8565 #define FORMSW 8
8566 d51 1
8567 a51 1
8568 #define HEADSW 9
8569 d53 1
8570 a53 1
8571 #define NHEADSW 10
8572 d56 1
8573 a56 1
8574 #define LISTSW 11
8575 d58 1
8576 a58 1
8577 #define NLISTSW 12
8578 d61 1
8579 a61 1
8580 #define PARTSW 13
8581 d64 1
8582 a64 1
8583 #define PAUSESW 14
8584 d66 1
8585 a66 1
8586 #define NPAUSESW 15
8587 d69 1
8588 a69 1
8589 #define SIZESW 16
8590 d71 1
8591 a71 1
8592 #define NSIZESW 17
8593 d74 1
8594 a74 1
8595 #define RFC934SW 18
8596 d76 1
8597 a76 1
8598 #define NRFC934SW 19
8599 d79 1
8600 a79 1
8601 #define SERIALSW 20
8602 d81 1
8603 a81 1
8604 #define NSERIALSW 21
8605 d84 1
8606 a84 1
8607 #define SHOWSW 22
8608 d86 1
8609 a86 1
8610 #define NSHOWSW 23
8611 d89 1
8612 a89 1
8613 #define STORESW 24
8614 d91 1
8615 a91 1
8616 #define NSTORESW 25
8617 d94 1
8618 a94 1
8619 #define TYPESW 26
8620 d97 1
8621 a97 1
8622 #define VERBSW 27
8623 d99 1
8624 a99 1
8625 #define NVERBSW 28
8626 d102 1
8627 a102 1
8628 #define HELPSW 29
8629 d105 1
8630 a105 1
8631 #define PROGSW 30
8632 d107 1
8633 a107 1
8634 #define NPROGSW 31
8635 d110 1
8636 a110 1
8637 #define LENSW 32
8638 d112 1
8639 a112 1
8640 #define WIDSW 33
8641 a113 3
8642
8643 #define FILESW 34 /* interface from show */
8644 "file file", -4,
8645 @
8646
8647
8648 2.22
8649 log
8650 @fixes from mtr:
8651 added "-cache policy" switch
8652 added "-[no]pause" switch
8653 remove application/oda content-type (change in MIME standard)
8654 add subject=/size= for external-parts (change in MIME standard)
8655 @
8656 text
8657 @d3 1
8658 a3 1
8659 static char ident[] = "@@(#)$Id: mhn.c,v 2.21 1992/12/15 00:20:22 jromine Exp jromine $";
8660 d186 1
8661 d189 1
8662 d3893 1
8663 a3893 1
8664 return st.st_size;
8665 d3896 1
8666 a3896 1
8667 return stat (ce -> ce_file, &st) != NOTOK ? st.st_size : 0L;
8668 d3905 1
8669 a3905 1
8670 size = fstat (fd, &st) != NOTOK ? st.st_size : 0L;
8671 d4038 1
8672 a4038 1
8673 (void) lseek (fd = fileno (ct -> c_fp), ct -> c_begin, 0);
8674 d4066 1
8675 a4066 1
8676 lseek (fd, 0L, 1) - (ep - cp),
8677 d4423 1
8678 a4423 1
8679 (void) lseek (fd = fileno (ct -> c_fp), ct -> c_begin, 0);
8680 d5366 1
8681 a5366 1
8682 ct -> c_end = st.st_size;
8683 d5450 1
8684 a5450 1
8685 p -> c_end = st.st_size;
8686 d5723 1
8687 a5723 1
8688 ct -> c_end = st.st_size;
8689 d6398 1
8690 a6398 1
8691 nlines += ((st.st_size - pos) + CPERLIN) / (CPERLIN + 1);
8692 @
8693
8694
8695 2.21
8696 log
8697 @endif sugar
8698 @
8699 text
8700 @d3 1
8701 a3 1
8702 static char ident[] = "@@(#)$Id: mhn.c,v 2.20 1992/12/14 17:10:25 jromine Exp jromine $";
8703 d24 1
8704 a24 1
8705 #define AUTOSW 0
8706 d26 1
8707 a26 1
8708 #define NAUTOSW 1
8709 d29 9
8710 a37 1
8711 #define DEBUGSW 2
8712 d40 1
8713 a40 1
8714 #define EBCDICSW 3
8715 d42 1
8716 a42 1
8717 #define NEBCDICSW 4
8718 d45 1
8719 a45 1
8720 #define FORMSW 5
8721 d48 1
8722 a48 1
8723 #define HEADSW 6
8724 d50 1
8725 a50 1
8726 #define NHEADSW 7
8727 d53 1
8728 a53 1
8729 #define LISTSW 8
8730 d55 1
8731 a55 1
8732 #define NLISTSW 9
8733 d58 1
8734 a58 1
8735 #define PARTSW 10
8736 d61 6
8737 a66 1
8738 #define SIZESW 11
8739 d68 1
8740 a68 1
8741 #define NSIZESW 12
8742 d71 1
8743 a71 1
8744 #define RFC934SW 13
8745 d73 1
8746 a73 1
8747 #define NRFC934SW 14
8748 d76 1
8749 a76 1
8750 #define SERIALSW 15
8751 d78 1
8752 a78 1
8753 #define NSERIALSW 16
8754 d81 1
8755 a81 1
8756 #define SHOWSW 17
8757 d83 1
8758 a83 1
8759 #define NSHOWSW 18
8760 d86 1
8761 a86 1
8762 #define STORESW 19
8763 d88 1
8764 a88 1
8765 #define NSTORESW 20
8766 d91 1
8767 a91 1
8768 #define TYPESW 21
8769 d94 1
8770 a94 1
8771 #define VERBSW 22
8772 d96 1
8773 a96 1
8774 #define NVERBSW 23
8775 d99 1
8776 a99 1
8777 #define HELPSW 24
8778 d102 1
8779 a102 1
8780 #define PROGSW 25
8781 d104 1
8782 a104 1
8783 #define NPROGSW 26
8784 d107 1
8785 a107 1
8786 #define LENSW 27
8787 d109 1
8788 a109 1
8789 #define WIDSW 28
8790 d112 1
8791 a112 1
8792 #define FILESW 29 /* interface from show */
8793 d115 1
8794 a115 1
8795 #define VIAMSW 30
8796 d117 1
8797 a117 1
8798 #define VIASSW 31
8799 d119 1
8800 a119 1
8801 #define VIAPSW 32
8802 d121 1
8803 a121 1
8804 #define VIADSW 33
8805 d123 1
8806 a123 1
8807 #define VIACSW 34
8808 d125 1
8809 a125 1
8810 #define VIAZSW 35
8811 d127 1
8812 a127 1
8813 #define VIAFSW 36
8814 d138 11
8815 d150 2
8816 d160 1
8817 d249 1
8818 a249 1
8819 char *c_storeproc; /* default, if not in profile */
8820 d283 2
8821 d312 1
8822 d314 1
8823 d393 21
8824 d457 7
8825 d589 1
8826 a589 1
8827 if (f2 || f3 || f4 || f5 || f6)
8828 d608 1
8829 a608 1
8830 cache = m_find (buf);
8831 d879 1
8832 a879 1
8833 xpid = child_id;
8834 d958 2
8835 a959 1
8836 static int InitApplication (), InitMessage (), InitMultiPart (), InitText ();
8837 d964 2
8838 a965 2
8839 "audio", CT_AUDIO, NULL,
8840 "image", CT_IMAGE, NULL,
8841 d969 1
8842 a969 1
8843 "video", CT_VIDEO, NULL,
8844 d1015 4
8845 a1018 1
8846 register char *cp;
8847 a1026 2
8848 char *dp = trimcpy (cp);
8849
8850 d1029 1
8851 a1029 1
8852 ct -> c_file, VRSN_FIELD, dp);
8853 a1035 1
8854 #ifdef whocares
8855 d1038 12
8856 d1052 6
8857 a1057 6
8858 c = *dp, *dp = NULL;
8859 if (!uleq (cp, VRSN_VALUE)) {
8860 if (!isspace (c))
8861 *dp = c;
8862 advise (NULLCP,
8863 "message %s has unsupported value for %s: field (%s)",
8864 a1058 4
8865 goto out;
8866 }
8867 *dp = c;
8868 #endif
8869 d1154 53
8870 d1301 1
8871 a1301 1
8872 if (*cp == '(' && get_comment (ct, &cp) == NOTOK)
8873 d1323 1
8874 a1323 1
8875 if (*cp == '(' && get_comment (ct, &cp) == NOTOK)
8876 d1336 1
8877 a1336 1
8878 if (*cp == '(' && get_comment (ct, &cp) == NOTOK)
8879 d1360 1
8880 a1360 1
8881 if (*cp == '(' && get_comment (ct, &cp) == NOTOK)
8882 d1379 1
8883 a1379 1
8884 if (*cp == '(' && get_comment (ct, &cp) == NOTOK)
8885 d1449 1
8886 a1449 1
8887 if (*cp == '(' && get_comment (ct, &cp) == NOTOK)
8888 d1489 1
8889 a1489 1
8890 static int get_comment (ct, ap)
8891 d1492 1
8892 d1511 1
8893 a1511 1
8894 ct -> c_file, TYPE_FIELD);
8895 d1538 7
8896 a1544 3
8897 if (dp = ci -> ci_comment) {
8898 ci -> ci_comment = concat (dp, " ", buffer, NULLCP);
8899 free (dp);
8900 a1545 2
8901 else
8902 ci -> ci_comment = add (buffer, NULLCP);
8903 d1628 1
8904 a1628 1
8905 fprintf (stderr, " %s:%s", VRSN_FIELD, ct -> c_vrsn);
8906 d1903 1
8907 a1903 1
8908 xpause = 1;
8909 d1950 3
8910 a1952 1
8911 if (xtty && xpid) {
8912 d2233 4
8913 d2367 1
8914 d2412 3
8915 a2414 1
8916 if (uprf (name, XXX_FIELD_PRF) || uleq (name, "Message-ID")) {
8917 d2447 40
8918 d2603 23
8919 d2688 1
8920 a2688 1
8921 if (uleq (*ap, "charset")) {
8922 a2708 2
8923
8924 break;
8925 d2710 3
8926 d2714 8
8927 d3338 1
8928 d3421 4
8929 d3458 2
8930 d3742 1
8931 a3742 2
8932 #define APPLICATION_ODA 0x02
8933 #define APPLICATION_POSTSCRIPT 0x03
8934 a3764 1
8935 "oda", APPLICATION_ODA,
8936 d3783 3
8937 a3785 4
8938 if (autosw && !ct -> c_storeproc)
8939 for (ap = ci -> ci_attrs, ep = ci -> ci_values; *ap; ap++, ep++)
8940 if (uleq (*ap, "name")) {
8941 register char *cp;
8942 d3787 7
8943 a3793 8
8944 if (*(cp = *ep) != '/'
8945 && *cp != '.'
8946 && *cp != '|'
8947 && *cp != '!'
8948 && !index (cp, '%'))
8949 ct -> c_storeproc = add (cp, NULLCP);
8950 break;
8951 }
8952 d3809 1
8953 a3809 1
8954 if (uleq (*ap, "conversions")
8955 d3836 3
8956 d3987 1
8957 d4001 1
8958 d4033 3
8959 d4075 2
8960 d4079 3
8961 a4081 1
8962 if (skip < 1)
8963 d4083 3
8964 d4118 13
8965 d4193 1
8966 d4201 1
8967 d4233 3
8968 d4269 2
8969 d4276 3
8970 d4315 6
8971 d4348 13
8972 d4474 1
8973 a4474 1
8974 static int openExternal (ct, ce, file, fd)
8975 d4476 1
8976 d4501 2
8977 d4507 1
8978 a4507 1
8979 if (cache && (id = ct -> c_id)) {
8980 d4515 1
8981 d4518 3
8982 d4522 9
8983 a4530 4
8984 (void) sprintf (buffer,
8985 "Use cached copy %s of size %lu octets (content %s)? ",
8986 id, (unsigned long) st.st_size,
8987 ct -> c_partno);
8988 d4532 1
8989 d4557 1
8990 a4557 1
8991 switch (openExternal (e -> eb_parent, ce, file, &fd)) {
8992 d4581 1
8993 a4581 1
8994 && (id = e -> eb_parent -> c_id)
8995 d4588 1
8996 a4588 1
8997 if (getanswer (buffer)) {
8998 d4598 1
8999 d4603 3
9000 a4605 2
9001 while (fgets (buffer, sizeof buffer - 1, gp))
9002 (void) fputs (buffer, fp);
9003 d4654 1
9004 a4654 1
9005 switch (openExternal (e -> eb_parent, ce, file, &fd)) {
9006 d4692 1
9007 a4692 1
9008 && (id = e -> eb_parent -> c_id)
9009 d4696 1
9010 a4696 1
9011 if (getanswer (buffer)) {
9012 d4832 1
9013 a4832 1
9014 switch (openExternal (e -> eb_parent, ce, file, &fd)) {
9015 d4849 3
9016 a4851 1
9017 e -> eb_server, "\n\n", e -> eb_body, "\n? ", NULLCP);
9018 d4862 10
9019 a4871 7
9020 if (cache
9021 && (id = e -> eb_parent -> c_id)
9022 && (!e -> eb_permission
9023 || !uleq (e -> eb_permission, "read-write"))) {
9024 (void) sprintf (buffer, "cache content as %s/%s", cache,
9025 id = trimcpy (id));
9026 free (id);
9027 d4873 4
9028 a4876 4
9029 vec[vecp++] = buffer;
9030 }
9031 else
9032 vec[vecp++] = "mail-server request";
9033 d5344 1
9034 a5344 1
9035 ct -> c_id = getcpy (msgid);
9036 d5511 35
9037 d5745 1
9038 a5745 1
9039 linelen = 0;
9040 d5758 1
9041 a5758 1
9042 for (cp = buffer; *cp; cp++)
9043 d5763 5
9044 d5779 5
9045 d5840 2
9046 d5955 1
9047 a5955 2
9048 if (ct -> c_subtype != TEXT_PLAIN
9049 || (ct -> c_ctparams
9050 d5957 1
9051 a5957 1
9052 != CHARSET_USASCII)) {
9053 d5959 2
9054 d5966 4
9055 d5996 2
9056 d6072 2
9057 a6073 3
9058 case '@@':
9059 case '`':
9060 if (ebcdicsw)
9061 a6074 1
9062 one_print: ;
9063 a6078 12
9064 default:
9065 if (('!' <= *cp && *cp <= '$')
9066 || ('[' <= *cp && *cp <= '^')
9067 || ('{' <= *cp && *cp <= '~')) {
9068 if (ebcdicsw)
9069 goto three_print;
9070 goto one_print;
9071 }
9072
9073 if ('%' <= *cp && *cp <= 'z')
9074 goto one_print;
9075 /* else fall... */
9076 d6104 1
9077 a6104 1
9078 static char nib2b64[0x40f] =
9079 d6175 160
9080 d6353 1
9081 d6377 1
9082 d6400 1
9083 a6400 1
9084 status = via_post (tmpfil);
9085 d6406 1
9086 a6406 1
9087
9088 d6415 1
9089 a6415 5
9090 (void) fseek (fp, 0L, 0);
9091 if (!fgets (buffer, sizeof buffer, fp)
9092 || !fgets (buffer, sizeof buffer, fp)
9093 || (subjsw && !fgets (buffer, sizeof buffer, fp)))
9094 adios (NULLCP, "premature eof");
9095 d6448 1
9096 d6455 6
9097 a6460 1
9098 if (slowsw > 0 && 1 < partno && partno < nparts) {
9099 d6463 1
9100 a6463 1
9101 slowsw, partno);
9102 a6468 5
9103
9104 status = via_post (tmpdrf);
9105 (void) unlink (tmpdrf);
9106 if (status)
9107 break;
9108 d6480 1
9109 a6480 1
9110 static int via_post (file)
9111 d6482 1
9112 d6495 2
9113 a6496 1
9114 (void) execlp (postproc, r1bindex (postproc, '/'), file, NULLCP);
9115 @
9116
9117
9118 2.20
9119 log
9120 @WAITINT ifdefs
9121 @
9122 text
9123 @d3 2
9124 a4 2
9125 static char ident[] = "@@(#)$Id: mhn.c,v 2.19 1992/12/10 22:27:15 jromine Exp jromine $";
9126 #endif lint
9127 @
9128
9129
9130 2.19
9131 log
9132 @fix from mtr
9133 @
9134 text
9135 @d3 1
9136 a3 1
9137 static char ident[] = "@@(#)$Id: mhn.c,v 2.18 1992/12/09 19:23:22 jromine Exp jromine $";
9138 d761 3
9139 a763 1
9140 #ifndef BSD42
9141 a764 2
9142 #else
9143 union wait status;
9144 d834 3
9145 a836 1
9146 #ifndef BSD42
9147 a837 2
9148 #else
9149 (void) pidcheck (status.w_status);
9150 d2641 3
9151 a2643 1
9152 #ifndef BSD42
9153 a2644 2
9154 #else
9155 union wait status;
9156 d2659 3
9157 a2661 1
9158 #ifndef BSD42
9159 a2662 2
9160 #else
9161 (void) pidcheck (status.w_status);
9162 @
9163
9164
9165 2.18
9166 log
9167 @fix from mtr
9168 @
9169 text
9170 @d3 1
9171 a3 1
9172 static char ident[] = "@@(#)$Id: mhn.c,v 2.17 1992/12/03 21:58:18 jromine Exp jromine $";
9173 d1086 1
9174 d1091 1
9175 @
9176
9177
9178 2.17
9179 log
9180 @ignore return value of vsprintf()
9181 @
9182 text
9183 @d3 1
9184 a3 1
9185 static char ident[] = "@@(#)$Id: mhn.c,v 2.16 1992/12/02 18:50:39 jromine Exp jromine $";
9186 d4481 1
9187 @
9188
9189
9190 2.16
9191 log
9192 @#ifdef bug
9193 @
9194 text
9195 @d3 1
9196 a3 1
9197 static char ident[] = "@@(#)$Id: mhn.c,v 2.15 1992/11/24 18:21:54 jromine Exp jromine $";
9198 d1599 2
9199 a1600 1
9200 bp += vsprintf (bp, fmt, arglist);
9201 @
9202
9203
9204 2.15
9205 log
9206 @add/fixup decl
9207 @
9208 text
9209 @d3 1
9210 a3 1
9211 static char ident[] = "@@(#)$Id: mhn.c,v 2.14 1992/11/24 17:18:52 jromine Exp jromine $";
9212 d1581 1
9213 a1581 1
9214 register CI ci = &ct -> c_ctinfo;
9215 d1604 1
9216 @
9217
9218
9219 2.14
9220 log
9221 @fix from mtr
9222 @
9223 text
9224 @d3 1
9225 a3 1
9226 static char ident[] = "@@(#)$Id: mhn.c,v 2.13 1992/11/24 17:18:04 jromine Exp jromine $";
9227 d273 1
9228 d282 4
9229 d3136 3
9230 a3138 3
9231 extern int openFile ();
9232 extern int openFTP ();
9233 extern int openMail ();
9234 @
9235
9236
9237 2.13
9238 log
9239 @messed up ifdefs for VSPRINTF & __STDC__
9240 @
9241 text
9242 @d3 1
9243 a3 1
9244 static char ident[] = "@@(#)$Id: mhn.c,v 2.12 1992/11/23 19:07:08 jromine Exp jromine $";
9245 d916 1
9246 a916 1
9247 "8bit", CE_8BIT, NULL,
9248 @
9249
9250
9251 2.12
9252 log
9253 @fix from mtr
9254 @
9255 text
9256 @d3 1
9257 a3 1
9258 static char ident[] = "@@(#)$Id: mhn.c,v 2.11 1992/11/23 19:05:18 jromine Exp jromine $";
9259 d275 1
9260 a275 1
9261 #ifdef __STDC__
9262 d1545 1
9263 a1548 1
9264 #ifdef VSPRINTF
9265 d1551 2
9266 a1552 1
9267 #else
9268 a1563 1
9269 #endif
9270 @
9271
9272
9273 2.11
9274 log
9275 @fix from mtr
9276 @
9277 text
9278 @d3 1
9279 a3 1
9280 static char ident[] = "@@(#)$Id: mhn.c,v 2.10 1992/11/23 19:04:27 jromine Exp jromine $";
9281 d2861 2
9282 a2864 3
9283 if (p -> c_end < p -> c_begin) {
9284 p -> c_begin = p -> c_end;
9285 }
9286 @
9287
9288
9289 2.10
9290 log
9291 @fix '-moreproc' -- from mtr
9292 @
9293 text
9294 @d3 1
9295 a3 1
9296 static char ident[] = "@@(#)$Id: mhn.c,v 2.9 1992/11/11 17:57:04 jromine Exp jromine $";
9297 d4300 2
9298 a4301 1
9299 (void) sprintf (buffer, "Make cached, publically-accessible copy? ");
9300 @
9301
9302
9303 2.9
9304 log
9305 @minor fix from mtr
9306 @
9307 text
9308 @d3 1
9309 a3 1
9310 static char ident[] = "@@(#)$Id: mhn.c,v 2.8 1992/11/09 17:46:01 jromine Exp jromine $";
9311 d2477 2
9312 a2478 1
9313 moreproc && *moreproc ? moreproc : "more");
9314 @
9315
9316
9317 2.8
9318 log
9319 @fixup varargs include
9320 @
9321 text
9322 @d3 1
9323 a3 1
9324 static char ident[] = "@@(#)$Id: mhn.c,v 2.7 1992/11/09 17:45:19 jromine Exp jromine $";
9325 d550 1
9326 a550 1
9327 : m_maildir (invo_name);
9328 @
9329
9330
9331 2.7
9332 log
9333 @charset changes via MTR
9334 @
9335 text
9336 @d3 1
9337 a3 1
9338 static char ident[] = "@@(#)$Id: mhn.c,v 2.6 1992/11/06 03:24:40 jromine Exp jromine $";
9339 d1538 1
9340 d1540 3
9341 @
9342
9343
9344 2.6
9345 log
9346 @AUX fixups - varargs
9347 @
9348 text
9349 @d3 1
9350 a3 1
9351 static char ident[] = "@@(#)$Id: mhn.c,v 2.5 1992/11/04 00:47:59 jromine Exp jromine $";
9352 d3272 1
9353 d3281 1
9354 a3281 1
9355 (*p -> c_ctstorefnx) (p, NULLCP);
9356 d3284 1
9357 a3284 1
9358 return OK;
9359 d5463 5
9360 a5467 2
9361 if (charset == -1)
9362 charset = CHARSET_USASCII;
9363 d5476 15
9364 a5490 6
9365 cp = index (*ap++ =
9366 add ((t -> tx_charset = charset)
9367 == CHARSET_USASCII
9368 ? "charset=us-ascii"
9369 : "charset=x-unknown", NULLCP),
9370 '=');
9371 @
9372
9373
9374 2.5
9375 log
9376 @LOCALE
9377 TYPESIG
9378 isupper with isalpha
9379 @
9380 text
9381 @d3 1
9382 a3 1
9383 static char ident[] = "@@(#)$Id: mhn.c,v 2.4 1992/11/02 17:01:08 jromine Exp jromine $";
9384 d275 1
9385 a275 1
9386 #if defined(VSPRINTF) && !defined(hpux)
9387 d1541 1
9388 a1541 1
9389 #if defined(VSPRINTF) && !defined(hpux)
9390 d1544 4
9391 d1560 1
9392 d1565 4
9393 d1582 1
9394 d1584 6
9395 @
9396
9397
9398 2.4
9399 log
9400 @fixes from mtr
9401 @
9402 text
9403 @d3 1
9404 a3 1
9405 static char ident[] = "@@(#)$Id: mhn.c,v 2.3 1992/10/26 16:58:47 jromine Exp jromine $";
9406 d17 3
9407 d285 1
9408 a285 1
9409 static int pipeser ();
9410 d319 3
9411 d866 1
9412 a866 1
9413 static int pipeser (i)
9414 d1189 1
9415 a1189 1
9416 if (isupper (*dp))
9417 d1225 1
9418 a1225 1
9419 if (isupper (*dp))
9420 d1262 1
9421 a1262 1
9422 if (isupper (*dp))
9423 d1636 1
9424 a1636 1
9425 static int intrser (i)
9426 @
9427
9428
9429 2.3
9430 log
9431 @add single quotes areound %f
9432 @
9433 text
9434 @d3 1
9435 a3 1
9436 static char ident[] = "@@(#)$Id: mhn.c,v 2.2 1992/10/20 20:30:08 jromine Exp jromine $";
9437 d272 1
9438 a272 1
9439 #ifdef VSPRINTF
9440 d1535 1
9441 a1535 1
9442 #ifdef VSPRINTF
9443 d2661 1
9444 d2665 1
9445 d2669 6
9446 a2674 2
9447 if (part_ok (p) && type_ok (p) && p -> c_ctstorefnx)
9448 (void) (*p -> c_ctstorefnx) (p, NULLCP);
9449 d2677 1
9450 a2677 1
9451 return OK;
9452 a3105 1
9453 #ifdef FTP
9454 a3106 1
9455 #endif
9456 d3112 4
9457 a3115 6
9458 "local-file", 0, openFile,
9459 "afs", 1, openFile,
9460 #ifdef FTP
9461 "ftp", 0, openFTP,
9462 "anon-ftp", 1, openFTP,
9463 #endif
9464 d3412 6
9465 a3417 1
9466 size = ct -> c_end - p -> c_begin;
9467 d3434 1
9468 a4312 1
9469 #ifdef FTP
9470 d4319 2
9471 a4320 1
9472 char *id,
9473 d4330 7
9474 d4401 49
9475 a4449 6
9476 if (ftp_get (e -> eb_site, user, pass, e -> eb_dir, e -> eb_name,
9477 ce -> ce_file,
9478 e -> eb_mode && uleq (e -> eb_mode, "ascii"), 0)
9479 == NOTOK) {
9480 username = password = NULL;
9481 return NOTOK;
9482 d4451 8
9483 a4494 1
9484 #endif
9485 d4954 6
9486 @
9487
9488
9489 2.2
9490 log
9491 @MIME upgrade 10
9492 @
9493 text
9494 @d3 1
9495 a3 1
9496 static char ident[] = "@@(#)$Id: mhn.c,v 2.1 1992/10/20 16:26:29 jromine Exp jromine $";
9497 d2450 1
9498 a2450 1
9499 (void) sprintf (buffer, "%%p%s %%F",
9500 d3309 1
9501 a3309 1
9502 ct -> c_showproc = add ("%pshow -file %F", NULLCP);
9503 @
9504
9505
9506 2.1
9507 log
9508 @null fixes
9509 @
9510 text
9511 @d3 1
9512 a3 1
9513 static char ident[] = "@@(#)$Id: mhn.c,v 1.5 1992/02/18 17:36:22 jromine Exp $";
9514 d148 1
9515 d461 1
9516 a461 1
9517 if (!(cp = *argp++) || *cp == '-')
9518 d463 1
9519 a463 1
9520 file = path (cp, TFILE);
9521 d540 1
9522 a540 1
9523 cwd = getcpy (pwd ());
9524 d563 2
9525 d572 2
9526 a573 2
9527 if ((fp = fopen (file, "r")) == NULL)
9528 adios (file, "unable to read");
9529 d575 25
9530 d601 3
9531 d1262 2
9532 a1263 2
9533 "invalid parameter in message %s's %s: field\n%*.*s(%s)\n%*.*sstarting at %s",
9534 ct -> c_file, TYPE_FIELD, i, i, "", cp, i, i, "", dp);
9535 d2063 5
9536 a2067 1
9537 fprintf (stderr, " as file %s\n", ct -> c_storage);
9538 d3410 1
9539 a3413 1
9540 size = ct -> c_end - p -> c_begin;
9541 d4481 1
9542 a4481 1
9543 (void) sprintf (buffer, "mail-server request (cache as %s/%s)", cache,
9544 @
9545
9546
9547 2.0
9548 log
9549 @new version from /mtr - MIME/update9
9550 @
9551 text
9552 @d1217 1
9553 a1217 1
9554 if (*cp == NULL) {
9555 d2158 1
9556 a2158 1
9557 buffer[0] = NULL;
9558 d2169 1
9559 a2169 1
9560 buffer[0] = NULL;
9561 d3391 1
9562 a3391 1
9563 *bp = NULL;
9564 d4323 1
9565 a4323 1
9566 ce -> ce_unlink = *file == NULL, caching = 0, cachefile[0] = NULL;
9567 d4695 1
9568 a4695 1
9569 *cp = NULL, n -= (i - 2);
9570 @
9571
9572
9573 1.7
9574 log
9575 @NULL->0, AIX
9576 @
9577 text
9578 @d3 1
9579 a3 1
9580 static char ident[] = "@@(#)$Id: mhn.c,v 1.6 1992/03/03 17:13:54 jromine Exp jromine $";
9581 d9 1
9582 d111 2
9583 d141 3
9584 d147 1
9585 d151 1
9586 d217 1
9587 d280 1
9588 d282 1
9589 d301 1
9590 d491 4
9591 d509 2
9592 d514 1
9593 a514 1
9594 via_mail (f1, f2, f3, f4, f5, f6);
9595 d530 1
9596 a530 1
9597 if (fp = fopen (cp = libpath ("mhn_profile"), "r")) {
9598 d536 3
9599 d541 3
9600 a543 1
9601 dir = getcpy ((cp = m_find (buf)) ? cp : cwd);
9602 d653 1
9603 d656 12
9604 d675 1
9605 a683 10
9606 if (storesw || showsw)
9607 for (ctp = cts; ct = *ctp; ctp++)
9608 if (type_ok (ct) && (ct -> c_ctstorefnx || ct -> c_ctshowfnx)) {
9609 struct stat st;
9610
9611 if (!ct -> c_umask)
9612 ct -> c_umask = ~(stat (ct -> c_file, &st) != NOTOK
9613 ? (st.st_mode & 0777) : m_gmprot ());
9614 }
9615
9616 d703 1
9617 d718 1
9618 a718 1
9619 char *vec[7];
9620 d729 2
9621 a745 1
9622 (void) umask (ct -> c_umask);
9623 d750 1
9624 d761 2
9625 d791 6
9626 a796 1
9627 while (wait (&status) != NOTOK)
9628 d798 1
9629 a828 2
9630 /* ARGSUSED */
9631
9632 d832 9
9633 d913 1
9634 a913 3
9635 register char *cp,
9636 *dp;
9637 char c;
9638 a914 6
9639 if (ct -> c_vrsn) {
9640 advise (NULLCP, "message %s has multiple %s: fields",
9641 ct -> c_file, VRSN_FIELD);
9642 goto out;
9643 }
9644
9645 d921 11
9646 a956 6
9647 if (ct -> c_ctline) {
9648 advise (NULLCP, "message %s has multiple %s: fields",
9649 ct -> c_file, TYPE_FIELD);
9650 goto out;
9651 }
9652
9653 d963 11
9654 a991 6
9655 if (ct -> c_celine) {
9656 advise (NULLCP, "message %s has multiple %s: fields",
9657 ct -> c_file, ENCODING_FIELD);
9658 goto out;
9659 }
9660
9661 d998 10
9662 d1117 1
9663 d1146 2
9664 a1147 3
9665 advise (NULLCP, "invalid %s: field in message %s (empty type)",
9666 TYPE_FIELD,
9667 ct -> c_file);
9668 d1162 2
9669 a1163 10
9670 if (magic)
9671 goto magic_skip;
9672
9673 #ifdef notdef
9674 advise (NULLCP,
9675 "invalid %s: field in message %s (missing subtype for \"%s\")",
9676 TYPE_FIELD, ct -> c_file, ci -> ci_type);
9677 return NOTOK;
9678 #else
9679 ci -> ci_subtype = add ("", NULLCP);
9680 a1164 1
9681 #endif
9682 d1200 2
9683 a1201 1
9684 char *vp;
9685 d1217 7
9686 d1227 2
9687 d1231 2
9688 a1232 2
9689 "invalid parameter in message %s's %s: field (%s)",
9690 ct -> c_file, TYPE_FIELD, cp);
9691 d1236 5
9692 a1240 4
9693 vp = (*ap = add (cp, NULLCP)) + (dp - cp);
9694 *vp++ = '\0';
9695 ci -> ci_values[ap - ci -> ci_attrs] = vp;
9696 dp++;
9697 d1247 2
9698 a1248 2
9699 "invalid quoted-string in message %s's %s: field (parameter %s)",
9700 ct -> c_file, TYPE_FIELD, *ap);
9701 a1264 1
9702
9703 d1275 2
9704 a1276 2
9705 "invalid parameter in message %s's %s: field (parameter %s)",
9706 ct -> c_file, TYPE_FIELD, *ap);
9707 d1294 1
9708 a1294 2
9709 advise (NULLCP, "invalid description in message %s's %s: field",
9710 ct -> c_file, TYPE_FIELD);
9711 d1315 2
9712 a1316 2
9713 "extraneous information in message %s's %s: field (%s)",
9714 ct -> c_file, TYPE_FIELD, cp);
9715 d1474 4
9716 d1523 1
9717 d1556 3
9718 a1558 1
9719 (void) sprintf (bp, " (content %s/%s", ci -> ci_type, ci -> ci_subtype);
9720 d1594 19
9721 d1626 1
9722 a1626 1
9723 if ((cp = m_find (buffer)) == NULL) {
9724 d1628 1
9725 a1628 1
9726 if ((cp = m_find (buffer)) == NULL
9727 d1653 1
9728 d1659 2
9729 a1660 1
9730 buffer[BUFSIZ];
9731 d1673 2
9732 d1676 1
9733 a1676 1
9734 xlist = xstdin = xtty = 0;
9735 d1712 3
9736 d1739 6
9737 d1747 1
9738 a1747 1
9739 if (debugsw) {
9740 d1749 2
9741 a1750 1
9742 fprintf (stderr, "%s msg %s", cracked ? "store" : "show",
9743 d1754 4
9744 a1757 1
9745 fprintf (stderr, " using command %s\n", buffer);
9746 a1759 2
9747 (void) fflush (stdout);
9748
9749 d1761 1
9750 a1761 1
9751 (void) pidwait (xpid, NOTOK);
9752 d1765 2
9753 a1766 2
9754 if (xlist && ct -> c_ctlistfnx)
9755 (*ct -> c_ctlistfnx) (ct, -1);
9756 d1768 59
9757 d1829 1
9758 a1829 1
9759 vec[2] = buffer;
9760 d1832 2
9761 d1861 1
9762 a1861 1
9763 (void) pidXwait (child_id, NULLCP);
9764 d1889 7
9765 a1895 7
9766 (void) sprintf (buffer, "%s-store-%s/%s", invo_name, ci -> ci_type,
9767 ci -> ci_subtype);
9768 if ((cp = m_find (buffer)) == NULL) {
9769 (void) sprintf (buffer, "%s-store-%s", invo_name, ci -> ci_type);
9770 if ((cp = m_find (buffer)) == NULL
9771 && (cp = ct -> c_storeproc) == NULL)
9772 cp = ct -> c_type == CT_MESSAGE ? "+" : "%m%P.%s";
9773 d1897 1
9774 d1953 3
9775 a1955 2
9776 (void) sprintf (bp = buffer, "%s/", dir[1] ? dir : "");
9777 bp += strlen (bp);
9778 d2020 1
9779 a2020 1
9780 return show_content_aux (ct, 1, 0, buffer + 1, dir);
9781 d2024 1
9782 d2026 1
9783 d2033 1
9784 d2035 1
9785 d2047 2
9786 a2048 1
9787 file = appending ? NULLCP : ct -> c_storage;
9788 d2056 15
9789 a2070 5
9790 if ((fp = fopen (ct -> c_storage, appending ? "a" : "w")) == NULL) {
9791 advise (ct -> c_storage, "unable to fopen for %s",
9792 appending ? "appending" : "writing");
9793 (void) (*ct -> c_ceclosefnx) (ct);
9794 return NOTOK;
9795 d2072 7
9796 d2117 13
9797 a2129 4
9798 if ((fp = fopen (ct -> c_storage, appending ? "a" : "w")) == NULL) {
9799 advise (ct -> c_storage, "unable to fopen for %s",
9800 appending ? "appending" : "writing");
9801 return NOTOK;
9802 d2131 6
9803 d2138 1
9804 a2138 1
9805 if (append && !*append)
9806 d2140 4
9807 d2152 24
9808 d2217 1
9809 a2217 1
9810 fprintf (out, "%s: %s", name, buf);
9811 d2287 2
9812 d2364 1
9813 a2365 1
9814
9815 d2395 1
9816 d2409 2
9817 d2415 1
9818 a2415 1
9819 (void) sprintf (buffer, "%s %%F",
9820 d2422 8
9821 d2432 2
9822 a2433 8
9823 register struct text *t;
9824
9825 if ((t = (struct text *) calloc (1, sizeof *t)) == NULL)
9826 adios (NULLCP, "out of memory");
9827 ct -> c_ctparams = (caddr_t) t;
9828 ct -> c_ctfreefnx = free_text;
9829
9830 t -> tx_charset = kv -> kv_value;
9831 d2436 7
9832 d2509 1
9833 d2521 2
9834 a2522 1
9835 nowserial = 1;
9836 d2587 7
9837 a2593 1
9838 while (kids > 0 && (pid = wait (&status)) != NOTOK)
9839 d2605 1
9840 d2704 1
9841 a2704 1
9842 ci -> ci_type, ci -> ci_subtype);
9843 d3042 1
9844 d3044 1
9845 a3044 1
9846 int eb_didone;
9847 d3050 2
9848 d3055 6
9849 d3064 1
9850 d3068 1
9851 d3073 2
9852 d3079 1
9853 d3085 1
9854 a3085 1
9855 static int params_external (ct)
9856 d3087 1
9857 d3119 4
9858 d3135 12
9859 d3149 1
9860 a3149 1
9861 if (!e -> eb_access || !e -> eb_name || !e -> eb_site) {
9862 d3168 2
9863 a3169 1
9864 printf ("\t retrieve %s ", e -> eb_name);
9865 d3171 6
9866 a3176 3
9867 printf ("in directory %s ", e -> eb_dir);
9868 printf ("\n\t\t from %s\n\t\tusing %s", e -> eb_site,
9869 e -> eb_access);
9870 d3179 2
9871 a3201 14
9872 if (!e -> eb_didone) {
9873 char *file;
9874
9875 e -> eb_didone = 1;
9876
9877 file = NULL;
9878 if ((*p -> c_ceopenfnx) (p, &file) == NOTOK)
9879 return NOTOK;
9880 (void) (*p -> c_ceclosefnx) (p);
9881
9882 if (p -> c_ctinitfnx && (*p -> c_ctinitfnx) (p) == NOTOK)
9883 return NOTOK;
9884 }
9885
9886 a3218 15
9887 if (!e -> eb_didone) {
9888 char *file;
9889
9890 e -> eb_didone = 1;
9891
9892 file = NULL; /* would be great to have this filled in, but it's
9893 a chicken-and-egg situation... */
9894 if ((*p -> c_ceopenfnx) (p, &file) == NOTOK)
9895 return NOTOK;
9896 (void) (*p -> c_ceclosefnx) (p);
9897
9898 if (p -> c_ctinitfnx && (*p -> c_ctinitfnx) (p) == NOTOK)
9899 return NOTOK;
9900 }
9901
9902 d3237 2
9903 d3262 1
9904 a3262 1
9905 ci -> ci_type, ci -> ci_subtype);
9906 d3266 2
9907 d3274 1
9908 a3274 1
9909 ct -> c_showproc = add ("show -file %F", NULLCP);
9910 d3340 1
9911 a3364 2
9912 p -> c_fp = NULL;
9913 p -> c_end = p -> c_begin;
9914 d3366 1
9915 d3369 14
9916 d3384 12
9917 d3400 1
9918 a3400 1
9919 if (params_external (ct) == NOTOK)
9920 d3405 15
9921 d3431 1
9922 a3431 1
9923 e -> eb_didone = 1;
9924 d3483 2
9925 d3493 15
9926 a3510 2
9927 register char **ap,
9928 **ep;
9929 d3522 2
9930 a3523 1
9931 if (uleq (*ap, "conversions") && uleq (*ep, "compress")) {
9932 a3526 8
9933
9934 if (autosw && !ct -> c_storeproc && uleq (*ap, "file")) {
9935 register char *cp;
9936
9937 if (*(cp = *ep) != '/' && *cp != '+' && *cp != '@@')
9938 ct -> c_storeproc = add (cp, NULLCP);
9939 break;
9940 }
9941 a3700 1
9942 unsigned char *b = (unsigned char *) &bits;
9943 d3703 5
9944 a3707 1
9945 unsigned char value;
9946 d3725 1
9947 a3725 3
9948 add (*file ? *file
9949 : m_scratch ("",
9950 m_maildir (invo_name)),
9951 d3763 2
9952 a3764 1
9953 if ((*cp & 0x80)
9954 d3767 4
9955 a3770 2
9956 fprintf (stderr, "*cp=0x%x pos=%ld\n", *cp,
9957 lseek (fd, 0L, 1) - (ep - cp));
9958 d3772 1
9959 a3772 3
9960 "invalid BASE64 encoding (char 0x%x at position %ld) -- continuing",
9961 *cp,
9962 lseek (fd, 0L, 1) - (ep - cp));
9963 d3779 1
9964 a3779 2
9965 #if defined(i386) || defined(vax)
9966 (void) putc (b[2], ce -> ce_fp);
9967 d3781 1
9968 a3781 1
9969 (void) putc (b[1], ce -> ce_fp);
9970 d3783 1
9971 a3783 1
9972 (void) putc (b[0], ce -> ce_fp);
9973 d3785 5
9974 a3789 6
9975 #else
9976 (void) putc (b[1], ce -> ce_fp);
9977 if (skip < 2) {
9978 (void) putc (b[2], ce -> ce_fp);
9979 if (skip < 1)
9980 (void) putc (b[3], ce -> ce_fp);
9981 a3790 2
9982 #endif
9983
9984 d3796 2
9985 a3797 1
9986 skip++;
9987 a3798 14
9988
9989 #ifdef notanymore
9990 case ',':
9991 if (bitno != 18) {
9992 if (debugsw)
9993 fprintf (stderr,
9994 "unaligned ',' (bitno %d)\n",
9995 bitno);
9996
9997 goto invalid_encoding;
9998 }
9999 (void) putc ('\n', ce -> ce_fp);
10000 break;
10001 #endif
10002 a3803 3
10003 #ifdef notanymore
10004 invalid_encoding: ;
10005 #endif
10006 d3808 1
10007 d3834 17
10008 d3900 1
10009 a3900 3
10010 add (*file ? *file
10011 : m_scratch ("",
10012 m_maildir (invo_name)),
10013 d3964 4
10014 d3990 4
10015 d4061 1
10016 a4061 3
10017 add (*file ? *file
10018 : m_scratch ("",
10019 m_maildir (invo_name)),
10020 d4094 4
10021 d4128 140
10022 d4275 7
10023 a4281 2
10024 char *user,
10025 *pass;
10026 d4285 1
10027 a4285 1
10028 static char *password = NULL;
10029 d4287 2
10030 a4288 5
10031 if (ce -> ce_fp)
10032 goto ready_to_go;
10033 if (ce -> ce_file) {
10034 if ((ce -> ce_fp = fopen (ce -> ce_file, "r")) == NULL) {
10035 content_error (ce -> ce_file, ct, "unable to fopen for reading");
10036 a4289 1
10037 }
10038 d4291 5
10039 a4295 2
10040 *file = ce -> ce_file;
10041 return fileno (ce -> ce_fp);
10042 d4298 20
10043 a4317 2
10044 if (e -> eb_flags)
10045 user = "anonymous", pass = "guest";
10046 a4318 5
10047 if (xpid) {
10048 (void) pidwait (xpid, NOTOK);
10049 xpid = 0;
10050 }
10051
10052 d4323 17
10053 a4339 1
10054 ce -> ce_unlink = *file == NULL;
10055 d4342 2
10056 a4343 2
10057 : m_scratch ("",
10058 m_maildir (invo_name)),
10059 a4350 3
10060 if (verbosw)
10061 printf ("Retrieving %s using %sFTP from site %s\n",
10062 e -> eb_name, e -> eb_flags ? "Anonymous " : "", e -> eb_site);
10063 d4359 31
10064 a4389 1
10065 ready_to_go: ;
10066 d4396 100
10067 d4523 1
10068 d4550 1
10069 a4550 1
10070 fprintf (out, "%s: %s", name, buf);
10071 d4595 1
10072 a4595 1
10073 while (fgets (buf, sizeof buf - 1, in)) {
10074 d4631 1
10075 a4631 1
10076 if (*++cp == '\n')
10077 d4676 27
10078 d4732 5
10079 a4736 2
10080 if (buf[0] != '#' || buf[1] == '#') {
10081 int headers;
10082 d4745 9
10083 d4766 1
10084 a4766 1
10085 if (!fgets (buffer, sizeof buffer - 1, in))
10086 d4789 1
10087 d4792 2
10088 a4793 1
10089 if ((cp = fgets (buffer, sizeof buffer - 1, in)) == NULL)
10090 d4810 1
10091 a4810 1
10092 if (get_ctinfo ("text/plain", ct, 0) == NOTOK)
10093 d4812 19
10094 a4830 3
10095 ct -> c_type = CT_TEXT;
10096 ct -> c_ctinitfnx = InitText;
10097 (void) (*ct -> c_ctinitfnx) (ct);
10098 d4832 1
10099 a4832 1
10100 (void) fseek (in, (long) (-strlen (cp)), 1);
10101 d4866 1
10102 d4869 3
10103 d4897 1
10104 d4903 1
10105 a4903 1
10106 if (params_external (ct) == NOTOK)
10107 d4906 11
10108 d4943 1
10109 a4943 1
10110 if ((cp = m_find (buffer)) == NULL) {
10111 d4945 1
10112 a4945 1
10113 if ((cp = m_find (buffer)) == NULL) {
10114 d5059 1
10115 a5059 1
10116 while (fgets (buffer, sizeof buffer - 1, in)) {
10117 a5081 20
10118 static char asciiP[0x80] = {
10119 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
10120 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
10121 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
10122 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
10123 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
10124 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
10125 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
10126 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
10127 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
10128 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
10129 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
10130 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
10131 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
10132 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
10133 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
10134 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00
10135 };
10136
10137
10138 d5144 1
10139 a5144 1
10140 ct -> c_end += 1 /* notdef 2 */;
10141 d5248 1
10142 a5248 1
10143 if (pidXwait (child_id, NULLCP) & 0377)
10144 d5259 3
10145 a5261 1
10146 if (ct -> c_type != CT_TEXT)
10147 d5269 1
10148 d5278 14
10149 a5291 1
10150 charset = ct -> c_type != CT_TEXT || ct -> c_ctparams ? 0 : -1;
10151 d5295 6
10152 a5300 4
10153 if (!isascii (*cp) || !asciiP[*cp & 0x7f]) {
10154 charset = CHARSET_UNKNOWN;
10155 break;
10156 }
10157 d5304 3
10158 d5320 1
10159 a5320 1
10160 if (charset != -1)
10161 d5325 4
10162 d5348 1
10163 a5348 1
10164 : "charset=iso8859-1", NULLCP),
10165 d5371 1
10166 a5388 4
10167
10168 if (!ci -> ci_comment && ct -> c_rfc934)
10169 ci -> ci_comment = add ("RFC 934 compatible encapsulation",
10170 NULLCP);
10171 d5398 3
10172 d5402 3
10173 d5480 1
10174 d5487 2
10175 d5495 3
10176 a5497 1
10177 if (ct -> c_subtype == APPLICATION_POSTSCRIPT)
10178 d5499 1
10179 d5558 7
10180 a5564 2
10181 n = 0;
10182 for (cp = buffer; *cp; cp++) {
10183 a5575 1
10184
10185 a5577 3
10186 case '[':
10187 case ']':
10188 case '^':
10189 d5588 1
10190 d5659 5
10191 a5667 4
10192 #if defined(i386) || defined(vax)
10193 for (bp = outbuf; bp < outbuf + sizeof outbuf; bits >>= 6)
10194 *bp++ = nib2b64[bits & 0x3f];
10195 #else
10196 a5669 1
10197 #endif
10198 d5699 1
10199 a5699 1
10200 static int via_mail (mailsw, subjsw, parmsw, descsw, cmntsw, slowsw)
10201 d5704 2
10202 a5705 1
10203 *cmntsw;
10204 d5726 1
10205 d5728 7
10206 a5734 2
10207 fprintf (fp, "Subject: %s\n", subjsw);
10208 fprintf (fp, "%s: %s\n", VRSN_FIELD, VRSN_VALUE);
10209 d5739 1
10210 a5739 1
10211 fprintf (fp, "\n\t(%s)", cmntsw);
10212 d5741 2
10213 a5742 3
10214 fprintf (fp, "\n%s: %s", DESCR_FIELD, descsw);
10215 fprintf (fp, "\n%s: %s\n\n", ENCODING_FIELD, "base64");
10216 nlines = 4 + (subjsw ? 1 : 0) + (descsw ? 1 : 0) + (cmntsw ? 1 : 0);
10217 d5797 3
10218 d5881 17
10219 @
10220
10221
10222 1.6
10223 log
10224 @fixes from mtr
10225 @
10226 text
10227 @d3 1
10228 a3 1
10229 static char ident[] = "@@(#)$Id: mhn.c,v 1.5 1992/02/18 17:36:22 jromine Exp jromine $";
10230 d111 1
10231 a111 1
10232 NULL, NULL
10233 d166 1
10234 d182 2
10235 a183 1
10236 int get_ctinfo ();
10237 d258 3
10238 a260 3
10239 CT get_content ();
10240 int list_content (), show_content (), store_content ();
10241 void free_content (), content_error (), flush_errors ();
10242 d262 6
10243 d812 1
10244 a812 1
10245 int InitApplication (), InitMessage (), InitMultiPart (), InitText ();
10246 d829 1
10247 a829 1
10248 int InitBase64 (), InitQuoted (), Init7Bit ();
10249 d956 1
10250 a956 1
10251 c = *dp, *dp = NULL;
10252 d1074 1
10253 a1074 1
10254 *++dp = NULL;
10255 d1083 1
10256 a1083 1
10257 c = *dp, *dp = NULL;
10258 d1128 1
10259 a1128 1
10260 c = *dp, *dp = NULL;
10261 d1179 1
10262 a1179 1
10263 *vp++ = NULL;
10264 d1185 1
10265 a1185 1
10266 case NULL:
10267 d1194 1
10268 a1194 1
10269 if ((c = *cp++) == NULL)
10270 d1203 1
10271 a1203 1
10272 *dp = NULL;
10273 d1213 1
10274 a1213 1
10275 *dp = NULL;
10276 d1242 1
10277 a1242 1
10278 c = *dp, *dp = NULL;
10279 d1285 1
10280 a1285 1
10281 case NULL:
10282 d1293 1
10283 a1293 1
10284 if ((c = *cp++) == NULL)
10285 d1313 1
10286 a1313 1
10287 *bp = NULL;
10288 d1370 1
10289 a1370 1
10290 case NULL:
10291 d1439 7
10292 a1446 1
10293
10294 d1457 1
10295 d1459 3
10296 d1473 4
10297 d1479 1
10298 d1509 1
10299 a1509 1
10300 *bp = NULL;
10301 d1530 2
10302 d1594 1
10303 a1594 1
10304 buffer[0] = NULL;
10305 d1639 1
10306 a1639 1
10307 *bp = NULL;
10308 d1647 1
10309 a1647 1
10310 *bp = NULL;
10311 d1789 1
10312 a1789 1
10313 buffer[0] = NULL;
10314 d1803 1
10315 a1803 1
10316 *bp = NULL;
10317 d1848 1
10318 a1848 1
10319 *bp = NULL;
10320 d1856 1
10321 a1856 1
10322 *bp = NULL;
10323 d1948 1
10324 a1948 1
10325 buffer[diff] = NULL;
10326 d2494 1
10327 a2494 1
10328 *++dp = NULL;
10329 d3544 6
10330 a3549 6
10331 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
10332 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
10333 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
10334 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
10335 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
10336 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
10337 d3551 9
10338 a3559 9
10339 0x08, 0x09, NULL, NULL, NULL, NULL, NULL, NULL,
10340 NULL, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, NULL,
10341 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
10342 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
10343 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
10344 NULL, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, NULL,
10345 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
10346 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
10347 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
10348 d3886 1
10349 a3886 1
10350 static int build_comp (file)
10351 d4142 1
10352 a4142 1
10353 *bp = NULL;
10354 d4498 1
10355 a4498 1
10356 buffer[0] = NULL;
10357 d4534 1
10358 a4534 1
10359 *bp = NULL;
10360 d4542 1
10361 a4542 1
10362 *bp = NULL;
10363 d4623 1
10364 a4623 1
10365 *++cp = NULL;
10366 d4654 1
10367 a4654 1
10368 *cp++ = NULL;
10369 d4689 1
10370 a4689 1
10371 *cp++ = NULL;
10372 d4850 1
10373 a4850 1
10374 *cp = NULL;
10375 @
10376
10377
10378 1.5
10379 log
10380 @fix from mrose
10381 @
10382 text
10383 @d3 1
10384 a3 1
10385 static char ident[] = "@@(#)$Id: mhn.c,v 1.4 1992/02/14 16:22:17 jromine Exp jromine $";
10386 d1960 1
10387 a1960 1
10388 if (uprf (name, XXX_FIELD_PRF)) {
10389 @
10390
10391
10392 1.4
10393 log
10394 @fixes from /mtr
10395 @
10396 text
10397 @d3 1
10398 a3 1
10399 static char ident[] = "@@(#)$Id: mhn.c,v 1.3 1992/02/07 16:07:46 jromine Exp jromine $";
10400 a2426 6
10401 if (ct -> c_celine && ct -> c_encoding != CE_7BIT) {
10402 admonish (NULLCP, "%s: field should not be present for \"%s/%s\" type in message %s's %s: field",
10403 ENCODING_FIELD, ci -> ci_type, ci -> ci_subtype, ct -> c_file,
10404 TYPE_FIELD);
10405 return NOTOK;
10406 }
10407 a2974 6
10408 if (ct -> c_celine && ct -> c_encoding != CE_7BIT) {
10409 admonish (NULLCP, "%s: field should not be present for \"%s/%s\" type in message %s's %s: field",
10410 ENCODING_FIELD, ci -> ci_type, ci -> ci_subtype, ct -> c_file,
10411 TYPE_FIELD);
10412 return NOTOK;
10413 }
10414 @
10415
10416
10417 1.3
10418 log
10419 @patch from mrose
10420 @
10421 text
10422 @d3 1
10423 a3 1
10424 static char ident[] = "@@(#)$Id: mhn.c,v 1.2 1992/02/07 03:44:12 jromine Exp jromine $";
10425 d2427 1
10426 a2427 1
10427 if (ct -> c_celine) {
10428 d2981 1
10429 a2981 1
10430 if (ct -> c_celine) {
10431 d3612 1
10432 a3612 1
10433 for (ep = (cp = buffer) + cc - 2; cp <= ep; ep--)
10434 @
10435
10436
10437 1.2
10438 log
10439 @fix from mrose
10440 @
10441 text
10442 @d3 1
10443 a3 1
10444 static char ident[] = "@@(#)$Id: mhn.c,v 1.1 1992/01/31 16:28:15 jromine Exp jromine $";
10445 d2159 2
10446 a2160 1
10447 (void) sprintf (buffer, "%s %%F", moreproc);
10448 @
10449
10450
10451 1.1
10452 log
10453 @Initial revision
10454 @
10455 text
10456 @d3 1
10457 a3 1
10458 static char ident[] = "@@(#)$Id$";
10459 d1100 1
10460 d1105 4
10461 @
Fork of https://git.savannah.nongnu.org/cgit/nmh.git