]> diplodocus.org Git - nmh/blob - uip/mhparse.c
projects / nmh / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Fix stupid accidental dependence on a bash quirk in previous
[nmh] / uip / mhparse.c
1
2 /*
3 * mhparse.c -- routines to parse the contents of MIME messages
4 *
5 * $Id$
6 *
7 * This code is Copyright (c) 2002, by the authors of nmh. See the
8 * COPYRIGHT file in the root directory of the nmh distribution for
9 * complete copyright information.
10 */
11
12 #include <h/mh.h>
13 #include <fcntl.h>
14 #include <h/signals.h>
15 #include <h/md5.h>
16 #include <errno.h>
17 #include <setjmp.h>
18 #include <signal.h>
19 #include <h/mts.h>
20 #include <h/tws.h>
21 #include <h/mime.h>
22 #include <h/mhparse.h>
23
24 #ifdef HAVE_SYS_WAIT_H
25 # include <sys/wait.h>
26 #endif
27
28
29 extern int debugsw;
30
31 extern int endian; /* mhmisc.c */
32
33 extern pid_t xpid; /* mhshowsbr.c */
34
35 /* cache policies */
36 extern int rcachesw; /* mhcachesbr.c */
37 extern int wcachesw; /* mhcachesbr.c */
38
39 int checksw = 0; /* check Content-MD5 field */
40
41 /*
42 * Directory to place temp files. This must
43 * be set before these routines are called.
44 */
45 char *tmp;
46
47 /*
48 * Structure for mapping types to their internal flags
49 */
50 struct k2v {
51 char *kv_key;
52 int kv_value;
53 };
54
55 /*
56 * Structures for TEXT messages
57 */
58 static struct k2v SubText[] = {
59 { "plain", TEXT_PLAIN },
60 { "richtext", TEXT_RICHTEXT }, /* defined in RFC-1341 */
61 { "enriched", TEXT_ENRICHED }, /* defined in RFC-1896 */
62 { NULL, TEXT_UNKNOWN } /* this one must be last! */
63 };
64
65 static struct k2v Charset[] = {
66 { "us-ascii", CHARSET_USASCII },
67 { "iso-8859-1", CHARSET_LATIN },
68 { NULL, CHARSET_UNKNOWN } /* this one must be last! */
69 };
70
71 /*
72 * Structures for MULTIPART messages
73 */
74 static struct k2v SubMultiPart[] = {
75 { "mixed", MULTI_MIXED },
76 { "alternative", MULTI_ALTERNATE },
77 { "digest", MULTI_DIGEST },
78 { "parallel", MULTI_PARALLEL },
79 { NULL, MULTI_UNKNOWN } /* this one must be last! */
80 };
81
82 /*
83 * Structures for MESSAGE messages
84 */
85 static struct k2v SubMessage[] = {
86 { "rfc822", MESSAGE_RFC822 },
87 { "partial", MESSAGE_PARTIAL },
88 { "external-body", MESSAGE_EXTERNAL },
89 { NULL, MESSAGE_UNKNOWN } /* this one must be last! */
90 };
91
92 /*
93 * Structure for APPLICATION messages
94 */
95 static struct k2v SubApplication[] = {
96 { "octet-stream", APPLICATION_OCTETS },
97 { "postscript", APPLICATION_POSTSCRIPT },
98 { NULL, APPLICATION_UNKNOWN } /* this one must be last! */
99 };
100
101
102 /* ftpsbr.c */
103 int ftp_get (char *, char *, char *, char *, char *, char *, int, int);
104
105 /* mhcachesbr.c */
106 int find_cache (CT, int, int *, char *, char *, int);
107
108 /* mhmisc.c */
109 int part_ok (CT, int);
110 int type_ok (CT, int);
111 int make_intermediates (char *);
112 void content_error (char *, CT, char *, ...);
113
114 /* mhfree.c */
115 void free_content (CT);
116 void free_encoding (CT, int);
117
118 /*
119 * prototypes
120 */
121 int pidcheck (int);
122 CT parse_mime (char *);
123
124 /*
125 * static prototypes
126 */
127 static CT get_content (FILE *, char *, int);
128 static int add_header (CT, char *, char *);
129 static int get_ctinfo (char *, CT);
130 static int get_comment (CT, char **, int);
131 static int InitGeneric (CT);
132 static int InitText (CT);
133 static int InitMultiPart (CT);
134 static void reverse_parts (CT);
135 static int InitMessage (CT);
136 static int params_external (CT, int);
137 static int InitApplication (CT);
138 static int init_encoding (CT, OpenCEFunc);
139 static void close_encoding (CT);
140 static unsigned long size_encoding (CT);
141 static int InitBase64 (CT);
142 static int openBase64 (CT, char **);
143 static int InitQuoted (CT);
144 static int openQuoted (CT, char **);
145 static int Init7Bit (CT);
146 static int open7Bit (CT, char **);
147 static int openExternal (CT, CT, CE, char **, int *);
148 static int InitFile (CT);
149 static int openFile (CT, char **);
150 static int InitFTP (CT);
151 static int openFTP (CT, char **);
152 static int InitMail (CT);
153 static int openMail (CT, char **);
154 static int readDigest (CT, char *);
155
156 /*
157 * Structures for mapping (content) types to
158 * the functions to handle them.
159 */
160 struct str2init {
161 char *si_key;
162 int si_val;
163 InitFunc si_init;
164 };
165
166 static struct str2init str2cts[] = {
167 { "application", CT_APPLICATION, InitApplication },
168 { "audio", CT_AUDIO, InitGeneric },
169 { "image", CT_IMAGE, InitGeneric },
170 { "message", CT_MESSAGE, InitMessage },
171 { "multipart", CT_MULTIPART, InitMultiPart },
172 { "text", CT_TEXT, InitText },
173 { "video", CT_VIDEO, InitGeneric },
174 { NULL, CT_EXTENSION, NULL }, /* these two must be last! */
175 { NULL, CT_UNKNOWN, NULL },
176 };
177
178 static struct str2init str2ces[] = {
179 { "base64", CE_BASE64, InitBase64 },
180 { "quoted-printable", CE_QUOTED, InitQuoted },
181 { "8bit", CE_8BIT, Init7Bit },
182 { "7bit", CE_7BIT, Init7Bit },
183 { "binary", CE_BINARY, Init7Bit },
184 { NULL, CE_EXTENSION, NULL }, /* these two must be last! */
185 { NULL, CE_UNKNOWN, NULL },
186 };
187
188 /*
189 * NOTE WELL: si_key MUST NOT have value of NOTOK
190 *
191 * si_key is 1 if access method is anonymous.
192 */
193 static struct str2init str2methods[] = {
194 { "afs", 1, InitFile },
195 { "anon-ftp", 1, InitFTP },
196 { "ftp", 0, InitFTP },
197 { "local-file", 0, InitFile },
198 { "mail-server", 0, InitMail },
199 { NULL, 0, NULL }
200 };
201
202
203 int
204 pidcheck (int status)
205 {
206 if ((status & 0xff00) == 0xff00 || (status & 0x007f) != SIGQUIT)
207 return status;
208
209 fflush (stdout);
210 fflush (stderr);
211 return done (1);
212 }
213
214
215 /*
216 * Main entry point for parsing a MIME message or file.
217 * It returns the Content structure for the top level
218 * entity in the file.
219 */
220
221 CT
222 parse_mime (char *file)
223 {
224 int is_stdin;
225 char buffer[BUFSIZ];
226 FILE *fp;
227 CT ct;
228
229 /*
230 * Check if file is actually standard input
231 */
232 if ((is_stdin = !(strcmp (file, "-")))) {
233 file = add (m_tmpfil (invo_name), NULL);
234 if ((fp = fopen (file, "w+")) == NULL) {
235 advise (file, "unable to fopen for writing and reading");
236 return NULL;
237 }
238 chmod (file, 0600);
239 while (fgets (buffer, sizeof(buffer), stdin))
240 fputs (buffer, fp);
241 fflush (fp);
242
243 if (ferror (stdin)) {
244 unlink (file);
245 advise ("stdin", "error reading");
246 return NULL;
247 }
248 if (ferror (fp)) {
249 unlink (file);
250 advise (file, "error writing");
251 return NULL;
252 }
253 fseek (fp, 0L, SEEK_SET);
254 } else if ((fp = fopen (file, "r")) == NULL) {
255 advise (file, "unable to read");
256 return NULL;
257 }
258
259 if (!(ct = get_content (fp, file, 1))) {
260 if (is_stdin)
261 unlink (file);
262 advise (NULL, "unable to decode %s", file);
263 return NULL;
264 }
265
266 if (is_stdin)
267 ct->c_unlink = 1; /* temp file to remove */
268
269 ct->c_fp = NULL;
270
271 if (ct->c_end == 0L) {
272 fseek (fp, 0L, SEEK_END);
273 ct->c_end = ftell (fp);
274 }
275
276 if (ct->c_ctinitfnx && (*ct->c_ctinitfnx) (ct) == NOTOK) {
277 fclose (fp);
278 free_content (ct);
279 return NULL;
280 }
281
282 fclose (fp);
283 return ct;
284 }
285
286
287 /*
288 * Main routine for reading/parsing the headers
289 * of a message content.
290 *
291 * toplevel = 1 # we are at the top level of the message
292 * toplevel = 0 # we are inside message type or multipart type
293 * # other than multipart/digest
294 * toplevel = -1 # we are inside multipart/digest
295 * NB: on failure we will fclose(in)!
296 */
297
298 static CT
299 get_content (FILE *in, char *file, int toplevel)
300 {
301 int compnum, state;
302 char buf[BUFSIZ], name[NAMESZ];
303 char *np, *vp;
304 CT ct;
305 HF hp;
306
307 /* allocate the content structure */
308 if (!(ct = (CT) calloc (1, sizeof(*ct))))
309 adios (NULL, "out of memory");
310
311 ct->c_fp = in;
312 ct->c_file = add (file, NULL);
313 ct->c_begin = ftell (ct->c_fp) + 1;
314
315 /*
316 * Parse the header fields for this
317 * content into a linked list.
318 */
319 for (compnum = 1, state = FLD;;) {
320 switch (state = m_getfld (state, name, buf, sizeof(buf), in)) {
321 case FLD:
322 case FLDPLUS:
323 case FLDEOF:
324 compnum++;
325
326 /* get copies of the buffers */
327 np = add (name, NULL);
328 vp = add (buf, NULL);
329
330 /* if necessary, get rest of field */
331 while (state == FLDPLUS) {
332 state = m_getfld (state, name, buf, sizeof(buf), in);
333 vp = add (buf, vp); /* add to previous value */
334 }
335
336 /* Now add the header data to the list */
337 add_header (ct, np, vp);
338
339 /* continue, if this isn't the last header field */
340 if (state != FLDEOF) {
341 ct->c_begin = ftell (in) + 1;
342 continue;
343 }
344 /* else fall... */
345
346 case BODY:
347 case BODYEOF:
348 ct->c_begin = ftell (in) - strlen (buf);
349 break;
350
351 case FILEEOF:
352 ct->c_begin = ftell (in);
353 break;
354
355 case LENERR:
356 case FMTERR:
357 adios (NULL, "message format error in component #%d", compnum);
358
359 default:
360 adios (NULL, "getfld() returned %d", state);
361 }
362
363 /* break out of the loop */
364 break;
365 }
366
367 /*
368 * Read the content headers. We will parse the
369 * MIME related header fields into their various
370 * structures and set internal flags related to
371 * content type/subtype, etc.
372 */
373
374 hp = ct->c_first_hf; /* start at first header field */
375 while (hp) {
376 /* Get MIME-Version field */
377 if (!strcasecmp (hp->name, VRSN_FIELD)) {
378 int ucmp;
379 char c, *cp, *dp;
380
381 if (ct->c_vrsn) {
382 advise (NULL, "message %s has multiple %s: fields",
383 ct->c_file, VRSN_FIELD);
384 goto next_header;
385 }
386 ct->c_vrsn = add (hp->value, NULL);
387
388 /* Now, cleanup this field */
389 cp = ct->c_vrsn;
390
391 while (isspace (*cp))
392 cp++;
393 for (dp = strchr(cp, '\n'); dp; dp = strchr(dp, '\n'))
394 *dp++ = ' ';
395 for (dp = cp + strlen (cp) - 1; dp >= cp; dp--)
396 if (!isspace (*dp))
397 break;
398 *++dp = '\0';
399 if (debugsw)
400 fprintf (stderr, "%s: %s\n", VRSN_FIELD, cp);
401
402 if (*cp == '(' && get_comment (ct, &cp, 0) == NOTOK)
403 goto out;
404
405 for (dp = cp; istoken (*dp); dp++)
406 continue;
407 c = *dp;
408 *dp = '\0';
409 ucmp = !strcasecmp (cp, VRSN_VALUE);
410 *dp = c;
411 if (!ucmp) {
412 admonish (NULL, "message %s has unknown value for %s: field (%s)",
413 ct->c_file, VRSN_FIELD, cp);
414 }
415 }
416 else if (!strcasecmp (hp->name, TYPE_FIELD)) {
417 /* Get Content-Type field */
418 struct str2init *s2i;
419 CI ci = &ct->c_ctinfo;
420
421 /* Check if we've already seen a Content-Type header */
422 if (ct->c_ctline) {
423 advise (NULL, "message %s has multiple %s: fields",
424 ct->c_file, TYPE_FIELD);
425 goto next_header;
426 }
427
428 /* Parse the Content-Type field */
429 if (get_ctinfo (hp->value, ct) == NOTOK)
430 goto out;
431
432 /*
433 * Set the Init function and the internal
434 * flag for this content type.
435 */
436 for (s2i = str2cts; s2i->si_key; s2i++)
437 if (!strcasecmp (ci->ci_type, s2i->si_key))
438 break;
439 if (!s2i->si_key && !uprf (ci->ci_type, "X-"))
440 s2i++;
441 ct->c_type = s2i->si_val;
442 ct->c_ctinitfnx = s2i->si_init;
443 }
444 else if (!strcasecmp (hp->name, ENCODING_FIELD)) {
445 /* Get Content-Transfer-Encoding field */
446 char c, *cp, *dp;
447 struct str2init *s2i;
448
449 /*
450 * Check if we've already seen the
451 * Content-Transfer-Encoding field
452 */
453 if (ct->c_celine) {
454 advise (NULL, "message %s has multiple %s: fields",
455 ct->c_file, ENCODING_FIELD);
456 goto next_header;
457 }
458
459 /* get copy of this field */
460 ct->c_celine = cp = add (hp->value, NULL);
461
462 while (isspace (*cp))
463 cp++;
464 for (dp = cp; istoken (*dp); dp++)
465 continue;
466 c = *dp;
467 *dp = '\0';
468
469 /*
470 * Find the internal flag and Init function
471 * for this transfer encoding.
472 */
473 for (s2i = str2ces; s2i->si_key; s2i++)
474 if (!strcasecmp (cp, s2i->si_key))
475 break;
476 if (!s2i->si_key && !uprf (cp, "X-"))
477 s2i++;
478 *dp = c;
479 ct->c_encoding = s2i->si_val;
480
481 /* Call the Init function for this encoding */
482 if (s2i->si_init && (*s2i->si_init) (ct) == NOTOK)
483 goto out;
484 }
485 else if (!strcasecmp (hp->name, MD5_FIELD)) {
486 /* Get Content-MD5 field */
487 char *cp, *dp, *ep;
488
489 if (!checksw)
490 goto next_header;
491
492 if (ct->c_digested) {
493 advise (NULL, "message %s has multiple %s: fields",
494 ct->c_file, MD5_FIELD);
495 goto next_header;
496 }
497
498 ep = cp = add (hp->value, NULL); /* get a copy */
499
500 while (isspace (*cp))
501 cp++;
502 for (dp = strchr(cp, '\n'); dp; dp = strchr(dp, '\n'))
503 *dp++ = ' ';
504 for (dp = cp + strlen (cp) - 1; dp >= cp; dp--)
505 if (!isspace (*dp))
506 break;
507 *++dp = '\0';
508 if (debugsw)
509 fprintf (stderr, "%s: %s\n", MD5_FIELD, cp);
510
511 if (*cp == '(' && get_comment (ct, &cp, 0) == NOTOK) {
512 free (ep);
513 goto out;
514 }
515
516 for (dp = cp; *dp && !isspace (*dp); dp++)
517 continue;
518 *dp = '\0';
519
520 readDigest (ct, cp);
521 free (ep);
522 ct->c_digested++;
523 }
524 else if (!strcasecmp (hp->name, ID_FIELD)) {
525 /* Get Content-ID field */
526 ct->c_id = add (hp->value, ct->c_id);
527 }
528 else if (!strcasecmp (hp->name, DESCR_FIELD)) {
529 /* Get Content-Description field */
530 ct->c_descr = add (hp->value, ct->c_descr);
531 }
532
533 next_header:
534 hp = hp->next; /* next header field */
535 }
536
537 /*
538 * Check if we saw a Content-Type field.
539 * If not, then assign a default value for
540 * it, and the Init function.
541 */
542 if (!ct->c_ctline) {
543 /*
544 * If we are inside a multipart/digest message,
545 * so default type is message/rfc822
546 */
547 if (toplevel < 0) {
548 if (get_ctinfo ("message/rfc822", ct) == NOTOK)
549 goto out;
550 ct->c_type = CT_MESSAGE;
551 ct->c_ctinitfnx = InitMessage;
552 } else {
553 /*
554 * Else default type is text/plain
555 */
556 if (get_ctinfo ("text/plain", ct) == NOTOK)
557 goto out;
558 ct->c_type = CT_TEXT;
559 ct->c_ctinitfnx = InitText;
560 }
561 }
562
563 /* Use default Transfer-Encoding, if necessary */
564 if (!ct->c_celine) {
565 ct->c_encoding = CE_7BIT;
566 Init7Bit (ct);
567 }
568
569 return ct;
570
571 out:
572 free_content (ct);
573 return NULL;
574 }
575
576
577 /*
578 * small routine to add header field to list
579 */
580
581 static int
582 add_header (CT ct, char *name, char *value)
583 {
584 HF hp;
585
586 /* allocate header field structure */
587 if (!(hp = malloc (sizeof(*hp))))
588 adios (NULL, "out of memory");
589
590 /* link data into header structure */
591 hp->name = name;
592 hp->value = value;
593 hp->next = NULL;
594
595 /* link header structure into the list */
596 if (ct->c_first_hf == NULL) {
597 ct->c_first_hf = hp; /* this is the first */
598 ct->c_last_hf = hp;
599 } else {
600 ct->c_last_hf->next = hp; /* add it to the end */
601 ct->c_last_hf = hp;
602 }
603
604 return 0;
605 }
606
607
608 /*
609 * Parse Content-Type line and fill in the
610 * information of the CTinfo structure.
611 */
612
613 static int
614 get_ctinfo (char *cp, CT ct)
615 {
616 int i;
617 char *dp, **ap, **ep;
618 char c;
619 CI ci;
620
621 ci = &ct->c_ctinfo;
622 i = strlen (invo_name) + 2;
623
624 /* store copy of Content-Type line */
625 cp = ct->c_ctline = add (cp, NULL);
626
627 while (isspace (*cp)) /* trim leading spaces */
628 cp++;
629
630 /* change newlines to spaces */
631 for (dp = strchr(cp, '\n'); dp; dp = strchr(dp, '\n'))
632 *dp++ = ' ';
633
634 /* trim trailing spaces */
635 for (dp = cp + strlen (cp) - 1; dp >= cp; dp--)
636 if (!isspace (*dp))
637 break;
638 *++dp = '\0';
639
640 if (debugsw)
641 fprintf (stderr, "%s: %s\n", TYPE_FIELD, cp);
642
643 if (*cp == '(' && get_comment (ct, &cp, 1) == NOTOK)
644 return NOTOK;
645
646 for (dp = cp; istoken (*dp); dp++)
647 continue;
648 c = *dp, *dp = '\0';
649 ci->ci_type = add (cp, NULL); /* store content type */
650 *dp = c, cp = dp;
651
652 if (!*ci->ci_type) {
653 advise (NULL, "invalid %s: field in message %s (empty type)",
654 TYPE_FIELD, ct->c_file);
655 return NOTOK;
656 }
657
658 /* down case the content type string */
659 for (dp = ci->ci_type; *dp; dp++)
660 if (isalpha(*dp) && isupper (*dp))
661 *dp = tolower (*dp);
662
663 while (isspace (*cp))
664 cp++;
665
666 if (*cp == '(' && get_comment (ct, &cp, 1) == NOTOK)
667 return NOTOK;
668
669 if (*cp != '/') {
670 ci->ci_subtype = add ("", NULL);
671 goto magic_skip;
672 }
673
674 cp++;
675 while (isspace (*cp))
676 cp++;
677
678 if (*cp == '(' && get_comment (ct, &cp, 1) == NOTOK)
679 return NOTOK;
680
681 for (dp = cp; istoken (*dp); dp++)
682 continue;
683 c = *dp, *dp = '\0';
684 ci->ci_subtype = add (cp, NULL); /* store the content subtype */
685 *dp = c, cp = dp;
686
687 if (!*ci->ci_subtype) {
688 advise (NULL,
689 "invalid %s: field in message %s (empty subtype for \"%s\")",
690 TYPE_FIELD, ct->c_file, ci->ci_type);
691 return NOTOK;
692 }
693
694 /* down case the content subtype string */
695 for (dp = ci->ci_subtype; *dp; dp++)
696 if (isalpha(*dp) && isupper (*dp))
697 *dp = tolower (*dp);
698
699 magic_skip:
700 while (isspace (*cp))
701 cp++;
702
703 if (*cp == '(' && get_comment (ct, &cp, 1) == NOTOK)
704 return NOTOK;
705
706 /*
707 * Parse attribute/value pairs given with Content-Type
708 */
709 ep = (ap = ci->ci_attrs) + NPARMS;
710 while (*cp == ';') {
711 char *vp, *up;
712
713 if (ap >= ep) {
714 advise (NULL,
715 "too many parameters in message %s's %s: field (%d max)",
716 ct->c_file, TYPE_FIELD, NPARMS);
717 return NOTOK;
718 }
719
720 cp++;
721 while (isspace (*cp))
722 cp++;
723
724 if (*cp == '(' && get_comment (ct, &cp, 1) == NOTOK)
725 return NOTOK;
726
727 if (*cp == 0) {
728 advise (NULL,
729 "extraneous trailing ';' in message %s's %s: parameter list",
730 ct->c_file, TYPE_FIELD);
731 return OK;
732 }
733
734 /* down case the attribute name */
735 for (dp = cp; istoken (*dp); dp++)
736 if (isalpha(*dp) && isupper (*dp))
737 *dp = tolower (*dp);
738
739 for (up = dp; isspace (*dp);)
740 dp++;
741 if (dp == cp || *dp != '=') {
742 advise (NULL,
743 "invalid parameter in message %s's %s: field\n%*.*sparameter %s (error detected at offset %d)",
744 ct->c_file, TYPE_FIELD, i, i, "", cp, dp - cp);
745 return NOTOK;
746 }
747
748 vp = (*ap = add (cp, NULL)) + (up - cp);
749 *vp = '\0';
750 for (dp++; isspace (*dp);)
751 dp++;
752
753 /* now add the attribute value */
754 ci->ci_values[ap - ci->ci_attrs] = vp = *ap + (dp - cp);
755
756 if (*dp == '"') {
757 for (cp = ++dp, dp = vp;;) {
758 switch (c = *cp++) {
759 case '\0':
760 bad_quote:
761 advise (NULL,
762 "invalid quoted-string in message %s's %s: field\n%*.*s(parameter %s)",
763 ct->c_file, TYPE_FIELD, i, i, "", *ap);
764 return NOTOK;
765
766 case '\\':
767 *dp++ = c;
768 if ((c = *cp++) == '\0')
769 goto bad_quote;
770 /* else fall... */
771
772 default:
773 *dp++ = c;
774 continue;
775
776 case '"':
777 *dp = '\0';
778 break;
779 }
780 break;
781 }
782 } else {
783 for (cp = dp, dp = vp; istoken (*cp); cp++, dp++)
784 continue;
785 *dp = '\0';
786 }
787 if (!*vp) {
788 advise (NULL,
789 "invalid parameter in message %s's %s: field\n%*.*s(parameter %s)",
790 ct->c_file, TYPE_FIELD, i, i, "", *ap);
791 return NOTOK;
792 }
793 ap++;
794
795 while (isspace (*cp))
796 cp++;
797
798 if (*cp == '(' && get_comment (ct, &cp, 1) == NOTOK)
799 return NOTOK;
800 }
801
802 /*
803 * Check if anything is left over
804 */
805 if (*cp) {
806 advise (NULL, "extraneous information in message %s's %s: field\n%*.*s(%s)",
807 ct->c_file, TYPE_FIELD, i, i, "", cp);
808 }
809
810 return OK;
811 }
812
813
814 static int
815 get_comment (CT ct, char **ap, int istype)
816 {
817 int i;
818 char *bp, *cp;
819 char c, buffer[BUFSIZ], *dp;
820 CI ci;
821
822 ci = &ct->c_ctinfo;
823 cp = *ap;
824 bp = buffer;
825 cp++;
826
827 for (i = 0;;) {
828 switch (c = *cp++) {
829 case '\0':
830 invalid:
831 advise (NULL, "invalid comment in message %s's %s: field",
832 ct->c_file, istype ? TYPE_FIELD : VRSN_FIELD);
833 return NOTOK;
834
835 case '\\':
836 *bp++ = c;
837 if ((c = *cp++) == '\0')
838 goto invalid;
839 *bp++ = c;
840 continue;
841
842 case '(':
843 i++;
844 /* and fall... */
845 default:
846 *bp++ = c;
847 continue;
848
849 case ')':
850 if (--i < 0)
851 break;
852 *bp++ = c;
853 continue;
854 }
855 break;
856 }
857 *bp = '\0';
858
859 if (istype) {
860 if ((dp = ci->ci_comment)) {
861 ci->ci_comment = concat (dp, " ", buffer, NULL);
862 free (dp);
863 } else {
864 ci->ci_comment = add (buffer, NULL);
865 }
866 }
867
868 while (isspace (*cp))
869 cp++;
870
871 *ap = cp;
872 return OK;
873 }
874
875
876 /*
877 * CONTENTS
878 *
879 * Handles content types audio, image, and video.
880 * There's not much to do right here.
881 */
882
883 static int
884 InitGeneric (CT ct)
885 {
886 return OK; /* not much to do here */
887 }
888
889
890 /*
891 * TEXT
892 */
893
894 static int
895 InitText (CT ct)
896 {
897 char buffer[BUFSIZ];
898 char *chset;
899 char **ap, **ep, *cp;
900 struct k2v *kv;
901 struct text *t;
902 CI ci = &ct->c_ctinfo;
903
904 /* check for missing subtype */
905 if (!*ci->ci_subtype)
906 ci->ci_subtype = add ("plain", ci->ci_subtype);
907
908 /* match subtype */
909 for (kv = SubText; kv->kv_key; kv++)
910 if (!strcasecmp (ci->ci_subtype, kv->kv_key))
911 break;
912 ct->c_subtype = kv->kv_value;
913
914 /* allocate text structure */
915 if ((t = (struct text *) calloc (1, sizeof(*t))) == NULL)
916 adios (NULL, "out of memory");
917 ct->c_ctparams = (void *) t;
918
919 /* scan for charset parameter */
920 for (ap = ci->ci_attrs, ep = ci->ci_values; *ap; ap++, ep++)
921 if (!strcasecmp (*ap, "charset"))
922 break;
923
924 if (*ap)
925 chset = *ep;
926 else
927 chset = "US-ASCII"; /* default for text */
928
929 /* match character set, or set to unknown */
930 for (kv = Charset; kv->kv_key; kv++)
931 if (!strcasecmp (chset, kv->kv_key))
932 break;
933 t->tx_charset = kv->kv_value;
934
935 /*
936 * If we can not handle character set natively,
937 * then check profile for string to modify the
938 * terminal or display method.
939 */
940 if (!check_charset (chset, strlen (chset))) {
941 snprintf (buffer, sizeof(buffer), "%s-charset-%s", invo_name, chset);
942 if ((cp = context_find (buffer)))
943 ct->c_termproc = getcpy (cp);
944 }
945
946 return OK;
947 }
948
949
950 /*
951 * MULTIPART
952 */
953
954 static int
955 InitMultiPart (CT ct)
956 {
957 int inout;
958 long last, pos;
959 char *cp, *dp, **ap, **ep;
960 char *bp, buffer[BUFSIZ];
961 struct multipart *m;
962 struct k2v *kv;
963 struct part *part, **next;
964 CI ci = &ct->c_ctinfo;
965 CT p;
966 FILE *fp;
967
968 /*
969 * The encoding for multipart messages must be either
970 * 7bit, 8bit, or binary (per RFC2045).
971 */
972 if (ct->c_encoding != CE_7BIT && ct->c_encoding != CE_8BIT
973 && ct->c_encoding != CE_BINARY) {
974 admonish (NULL,
975 "\"%s/%s\" type in message %s must be encoded in 7bit, 8bit, or binary",
976 ci->ci_type, ci->ci_subtype, ct->c_file);
977 return NOTOK;
978 }
979
980 /* match subtype */
981 for (kv = SubMultiPart; kv->kv_key; kv++)
982 if (!strcasecmp (ci->ci_subtype, kv->kv_key))
983 break;
984 ct->c_subtype = kv->kv_value;
985
986 /*
987 * Check for "boundary" parameter, which is
988 * required for multipart messages.
989 */
990 bp = 0;
991 for (ap = ci->ci_attrs, ep = ci->ci_values; *ap; ap++, ep++) {
992 if (!strcasecmp (*ap, "boundary")) {
993 bp = *ep;
994 break;
995 }
996 }
997
998 /* complain if boundary parameter is missing */
999 if (!*ap) {
1000 advise (NULL,
1001 "a \"boundary\" parameter is mandatory for \"%s/%s\" type in message %s's %s: field",
1002 ci->ci_type, ci->ci_subtype, ct->c_file, TYPE_FIELD);
1003 return NOTOK;
1004 }
1005
1006 /* allocate primary structure for multipart info */
1007 if ((m = (struct multipart *) calloc (1, sizeof(*m))) == NULL)
1008 adios (NULL, "out of memory");
1009 ct->c_ctparams = (void *) m;
1010
1011 /* check if boundary parameter contains only whitespace characters */
1012 for (cp = bp; isspace (*cp); cp++)
1013 continue;
1014 if (!*cp) {
1015 advise (NULL, "invalid \"boundary\" parameter for \"%s/%s\" type in message %s's %s: field",
1016 ci->ci_type, ci->ci_subtype, ct->c_file, TYPE_FIELD);
1017 return NOTOK;
1018 }
1019
1020 /* remove trailing whitespace from boundary parameter */
1021 for (cp = bp, dp = cp + strlen (cp) - 1; dp > cp; dp--)
1022 if (!isspace (*dp))
1023 break;
1024 *++dp = '\0';
1025
1026 /* record boundary separators */
1027 m->mp_start = concat (bp, "\n", NULL);
1028 m->mp_stop = concat (bp, "--\n", NULL);
1029
1030 if (!ct->c_fp && (ct->c_fp = fopen (ct->c_file, "r")) == NULL) {
1031 advise (ct->c_file, "unable to open for reading");
1032 return NOTOK;
1033 }
1034
1035 fseek (fp = ct->c_fp, pos = ct->c_begin, SEEK_SET);
1036 last = ct->c_end;
1037 next = &m->mp_parts;
1038 part = NULL;
1039 inout = 1;
1040
1041 while (fgets (buffer, sizeof(buffer) - 1, fp)) {
1042 if (pos > last)
1043 break;
1044
1045 pos += strlen (buffer);
1046 if (buffer[0] != '-' || buffer[1] != '-')
1047 continue;
1048 if (inout) {
1049 if (strcmp (buffer + 2, m->mp_start))
1050 continue;
1051 next_part:
1052 if ((part = (struct part *) calloc (1, sizeof(*part))) == NULL)
1053 adios (NULL, "out of memory");
1054 *next = part;
1055 next = &part->mp_next;
1056
1057 if (!(p = get_content (fp, ct->c_file,
1058 ct->c_subtype == MULTI_DIGEST ? -1 : 0))) {
1059 ct->c_fp = NULL;
1060 return NOTOK;
1061 }
1062 p->c_fp = NULL;
1063 part->mp_part = p;
1064 pos = p->c_begin;
1065 fseek (fp, pos, SEEK_SET);
1066 inout = 0;
1067 } else {
1068 if (strcmp (buffer + 2, m->mp_start) == 0) {
1069 inout = 1;
1070 end_part:
1071 p = part->mp_part;
1072 p->c_end = ftell(fp) - (strlen(buffer) + 1);
1073 if (p->c_end < p->c_begin)
1074 p->c_begin = p->c_end;
1075 if (inout)
1076 goto next_part;
1077 goto last_part;
1078 } else {
1079 if (strcmp (buffer + 2, m->mp_stop) == 0)
1080 goto end_part;
1081 }
1082 }
1083 }
1084
1085 advise (NULL, "bogus multipart content in message %s", ct->c_file);
1086 if (!inout && part) {
1087 p = part->mp_part;
1088 p->c_end = ct->c_end;
1089
1090 if (p->c_begin >= p->c_end) {
1091 for (next = &m->mp_parts; *next != part;
1092 next = &((*next)->mp_next))
1093 continue;
1094 *next = NULL;
1095 free_content (p);
1096 free ((char *) part);
1097 }
1098 }
1099
1100 last_part:
1101 /* reverse the order of the parts for multipart/alternative */
1102 if (ct->c_subtype == MULTI_ALTERNATE)
1103 reverse_parts (ct);
1104
1105 /*
1106 * label all subparts with part number, and
1107 * then initialize the content of the subpart.
1108 */
1109 {
1110 int partnum;
1111 char *pp;
1112 char partnam[BUFSIZ];
1113
1114 if (ct->c_partno) {
1115 snprintf (partnam, sizeof(partnum), "%s.", ct->c_partno);
1116 pp = partnam + strlen (partnam);
1117 } else {
1118 pp = partnam;
1119 }
1120
1121 for (part = m->mp_parts, partnum = 1; part;
1122 part = part->mp_next, partnum++) {
1123 p = part->mp_part;
1124
1125 sprintf (pp, "%d", partnum);
1126 p->c_partno = add (partnam, NULL);
1127
1128 /* initialize the content of the subparts */
1129 if (p->c_ctinitfnx && (*p->c_ctinitfnx) (p) == NOTOK) {
1130 fclose (ct->c_fp);
1131 ct->c_fp = NULL;
1132 return NOTOK;
1133 }
1134 }
1135 }
1136
1137 fclose (ct->c_fp);
1138 ct->c_fp = NULL;
1139 return OK;
1140 }
1141
1142
1143 /*
1144 * reverse the order of the parts of a multipart
1145 */
1146
1147 static void
1148 reverse_parts (CT ct)
1149 {
1150 int i;
1151 struct multipart *m;
1152 struct part **base, **bmp, **next, *part;
1153
1154 m = (struct multipart *) ct->c_ctparams;
1155
1156 /* if only one part, just return */
1157 if (!m->mp_parts || !m->mp_parts->mp_next)
1158 return;
1159
1160 /* count number of parts */
1161 i = 0;
1162 for (part = m->mp_parts; part; part = part->mp_next)
1163 i++;
1164
1165 /* allocate array of pointers to the parts */
1166 if (!(base = (struct part **) calloc ((size_t) (i + 1), sizeof(*base))))
1167 adios (NULL, "out of memory");
1168 bmp = base;
1169
1170 /* point at all the parts */
1171 for (part = m->mp_parts; part; part = part->mp_next)
1172 *bmp++ = part;
1173 *bmp = NULL;
1174
1175 /* reverse the order of the parts */
1176 next = &m->mp_parts;
1177 for (bmp--; bmp >= base; bmp--) {
1178 part = *bmp;
1179 *next = part;
1180 next = &part->mp_next;
1181 }
1182 *next = NULL;
1183
1184 /* free array of pointers */
1185 free ((char *) base);
1186 }
1187
1188
1189 /*
1190 * MESSAGE
1191 */
1192
1193 static int
1194 InitMessage (CT ct)
1195 {
1196 struct k2v *kv;
1197 CI ci = &ct->c_ctinfo;
1198
1199 if ((ct->c_encoding != CE_7BIT) && (ct->c_encoding != CE_8BIT)) {
1200 admonish (NULL,
1201 "\"%s/%s\" type in message %s should be encoded in 7bit or 8bit",
1202 ci->ci_type, ci->ci_subtype, ct->c_file);
1203 return NOTOK;
1204 }
1205
1206 /* check for missing subtype */
1207 if (!*ci->ci_subtype)
1208 ci->ci_subtype = add ("rfc822", ci->ci_subtype);
1209
1210 /* match subtype */
1211 for (kv = SubMessage; kv->kv_key; kv++)
1212 if (!strcasecmp (ci->ci_subtype, kv->kv_key))
1213 break;
1214 ct->c_subtype = kv->kv_value;
1215
1216 switch (ct->c_subtype) {
1217 case MESSAGE_RFC822:
1218 break;
1219
1220 case MESSAGE_PARTIAL:
1221 {
1222 char **ap, **ep;
1223 struct partial *p;
1224
1225 if ((p = (struct partial *) calloc (1, sizeof(*p))) == NULL)
1226 adios (NULL, "out of memory");
1227 ct->c_ctparams = (void *) p;
1228
1229 /* scan for parameters "id", "number", and "total" */
1230 for (ap = ci->ci_attrs, ep = ci->ci_values; *ap; ap++, ep++) {
1231 if (!strcasecmp (*ap, "id")) {
1232 p->pm_partid = add (*ep, NULL);
1233 continue;
1234 }
1235 if (!strcasecmp (*ap, "number")) {
1236 if (sscanf (*ep, "%d", &p->pm_partno) != 1
1237 || p->pm_partno < 1) {
1238 invalid_param:
1239 advise (NULL,
1240 "invalid %s parameter for \"%s/%s\" type in message %s's %s field",
1241 *ap, ci->ci_type, ci->ci_subtype,
1242 ct->c_file, TYPE_FIELD);
1243 return NOTOK;
1244 }
1245 continue;
1246 }
1247 if (!strcasecmp (*ap, "total")) {
1248 if (sscanf (*ep, "%d", &p->pm_maxno) != 1
1249 || p->pm_maxno < 1)
1250 goto invalid_param;
1251 continue;
1252 }
1253 }
1254
1255 if (!p->pm_partid
1256 || !p->pm_partno
1257 || (p->pm_maxno && p->pm_partno > p->pm_maxno)) {
1258 advise (NULL,
1259 "invalid parameters for \"%s/%s\" type in message %s's %s field",
1260 ci->ci_type, ci->ci_subtype,
1261 ct->c_file, TYPE_FIELD);
1262 return NOTOK;
1263 }
1264 }
1265 break;
1266
1267 case MESSAGE_EXTERNAL:
1268 {
1269 int exresult;
1270 struct exbody *e;
1271 CT p;
1272 FILE *fp;
1273
1274 if ((e = (struct exbody *) calloc (1, sizeof(*e))) == NULL)
1275 adios (NULL, "out of memory");
1276 ct->c_ctparams = (void *) e;
1277
1278 if (!ct->c_fp
1279 && (ct->c_fp = fopen (ct->c_file, "r")) == NULL) {
1280 advise (ct->c_file, "unable to open for reading");
1281 return NOTOK;
1282 }
1283
1284 fseek (fp = ct->c_fp, ct->c_begin, SEEK_SET);
1285
1286 if (!(p = get_content (fp, ct->c_file, 0))) {
1287 ct->c_fp = NULL;
1288 return NOTOK;
1289 }
1290
1291 e->eb_parent = ct;
1292 e->eb_content = p;
1293 p->c_ctexbody = e;
1294 if ((exresult = params_external (ct, 0)) != NOTOK
1295 && p->c_ceopenfnx == openMail) {
1296 int cc, size;
1297 char *bp;
1298
1299 if ((size = ct->c_end - p->c_begin) <= 0) {
1300 if (!e->eb_subject)
1301 content_error (NULL, ct,
1302 "empty body for access-type=mail-server");
1303 goto no_body;
1304 }
1305
1306 if ((e->eb_body = bp = malloc ((unsigned) size)) == NULL)
1307 adios (NULL, "out of memory");
1308 fseek (p->c_fp, p->c_begin, SEEK_SET);
1309 while (size > 0)
1310 switch (cc = fread (bp, sizeof(*bp), size, p->c_fp)) {
1311 case NOTOK:
1312 adios ("failed", "fread");
1313
1314 case OK:
1315 adios (NULL, "unexpected EOF from fread");
1316
1317 default:
1318 bp += cc, size -= cc;
1319 break;
1320 }
1321 *bp = 0;
1322 }
1323 no_body:
1324 p->c_fp = NULL;
1325 p->c_end = p->c_begin;
1326
1327 fclose (ct->c_fp);
1328 ct->c_fp = NULL;
1329
1330 if (exresult == NOTOK)
1331 return NOTOK;
1332 if (e->eb_flags == NOTOK)
1333 return OK;
1334
1335 switch (p->c_type) {
1336 case CT_MULTIPART:
1337 break;
1338
1339 case CT_MESSAGE:
1340 if (p->c_subtype != MESSAGE_RFC822)
1341 break;
1342 /* else fall... */
1343 default:
1344 e->eb_partno = ct->c_partno;
1345 if (p->c_ctinitfnx)
1346 (*p->c_ctinitfnx) (p);
1347 break;
1348 }
1349 }
1350 break;
1351
1352 default:
1353 break;
1354 }
1355
1356 return OK;
1357 }
1358
1359
1360 static int
1361 params_external (CT ct, int composing)
1362 {
1363 char **ap, **ep;
1364 struct exbody *e = (struct exbody *) ct->c_ctparams;
1365 CI ci = &ct->c_ctinfo;
1366
1367 for (ap = ci->ci_attrs, ep = ci->ci_values; *ap; ap++, ep++) {
1368 if (!strcasecmp (*ap, "access-type")) {
1369 struct str2init *s2i;
1370 CT p = e->eb_content;
1371
1372 for (s2i = str2methods; s2i->si_key; s2i++)
1373 if (!strcasecmp (*ep, s2i->si_key))
1374 break;
1375 if (!s2i->si_key) {
1376 e->eb_access = *ep;
1377 e->eb_flags = NOTOK;
1378 p->c_encoding = CE_EXTERNAL;
1379 continue;
1380 }
1381 e->eb_access = s2i->si_key;
1382 e->eb_flags = s2i->si_val;
1383 p->c_encoding = CE_EXTERNAL;
1384
1385 /* Call the Init function for this external type */
1386 if ((*s2i->si_init)(p) == NOTOK)
1387 return NOTOK;
1388 continue;
1389 }
1390 if (!strcasecmp (*ap, "name")) {
1391 e->eb_name = *ep;
1392 continue;
1393 }
1394 if (!strcasecmp (*ap, "permission")) {
1395 e->eb_permission = *ep;
1396 continue;
1397 }
1398 if (!strcasecmp (*ap, "site")) {
1399 e->eb_site = *ep;
1400 continue;
1401 }
1402 if (!strcasecmp (*ap, "directory")) {
1403 e->eb_dir = *ep;
1404 continue;
1405 }
1406 if (!strcasecmp (*ap, "mode")) {
1407 e->eb_mode = *ep;
1408 continue;
1409 }
1410 if (!strcasecmp (*ap, "size")) {
1411 sscanf (*ep, "%lu", &e->eb_size);
1412 continue;
1413 }
1414 if (!strcasecmp (*ap, "server")) {
1415 e->eb_server = *ep;
1416 continue;
1417 }
1418 if (!strcasecmp (*ap, "subject")) {
1419 e->eb_subject = *ep;
1420 continue;
1421 }
1422 if (composing && !strcasecmp (*ap, "body")) {
1423 e->eb_body = getcpy (*ep);
1424 continue;
1425 }
1426 }
1427
1428 if (!e->eb_access) {
1429 advise (NULL,
1430 "invalid parameters for \"%s/%s\" type in message %s's %s field",
1431 ci->ci_type, ci->ci_subtype, ct->c_file, TYPE_FIELD);
1432 return NOTOK;
1433 }
1434
1435 return OK;
1436 }
1437
1438
1439 /*
1440 * APPLICATION
1441 */
1442
1443 static int
1444 InitApplication (CT ct)
1445 {
1446 struct k2v *kv;
1447 CI ci = &ct->c_ctinfo;
1448
1449 /* match subtype */
1450 for (kv = SubApplication; kv->kv_key; kv++)
1451 if (!strcasecmp (ci->ci_subtype, kv->kv_key))
1452 break;
1453 ct->c_subtype = kv->kv_value;
1454
1455 return OK;
1456 }
1457
1458
1459 /*
1460 * TRANSFER ENCODINGS
1461 */
1462
1463 static int
1464 init_encoding (CT ct, OpenCEFunc openfnx)
1465 {
1466 CE ce;
1467
1468 if ((ce = (CE) calloc (1, sizeof(*ce))) == NULL)
1469 adios (NULL, "out of memory");
1470
1471 ct->c_cefile = ce;
1472 ct->c_ceopenfnx = openfnx;
1473 ct->c_ceclosefnx = close_encoding;
1474 ct->c_cesizefnx = size_encoding;
1475
1476 return OK;
1477 }
1478
1479
1480 static void
1481 close_encoding (CT ct)
1482 {
1483 CE ce;
1484
1485 if (!(ce = ct->c_cefile))
1486 return;
1487
1488 if (ce->ce_fp) {
1489 fclose (ce->ce_fp);
1490 ce->ce_fp = NULL;
1491 }
1492 }
1493
1494
1495 static unsigned long
1496 size_encoding (CT ct)
1497 {
1498 int fd;
1499 unsigned long size;
1500 char *file;
1501 CE ce;
1502 struct stat st;
1503
1504 if (!(ce = ct->c_cefile))
1505 return (ct->c_end - ct->c_begin);
1506
1507 if (ce->ce_fp && fstat (fileno (ce->ce_fp), &st) != NOTOK)
1508 return (long) st.st_size;
1509
1510 if (ce->ce_file) {
1511 if (stat (ce->ce_file, &st) != NOTOK)
1512 return (long) st.st_size;
1513 else
1514 return 0L;
1515 }
1516
1517 if (ct->c_encoding == CE_EXTERNAL)
1518 return (ct->c_end - ct->c_begin);
1519
1520 file = NULL;
1521 if ((fd = (*ct->c_ceopenfnx) (ct, &file)) == NOTOK)
1522 return (ct->c_end - ct->c_begin);
1523
1524 if (fstat (fd, &st) != NOTOK)
1525 size = (long) st.st_size;
1526 else
1527 size = 0L;
1528
1529 (*ct->c_ceclosefnx) (ct);
1530 return size;
1531 }
1532
1533
1534 /*
1535 * BASE64
1536 */
1537
1538 static unsigned char b642nib[0x80] = {
1539 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1540 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1541 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1542 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1543 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1544 0xff, 0xff, 0xff, 0x3e, 0xff, 0xff, 0xff, 0x3f,
1545 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b,
1546 0x3c, 0x3d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1547 0xff, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
1548 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
1549 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16,
1550 0x17, 0x18, 0x19, 0xff, 0xff, 0xff, 0xff, 0xff,
1551 0xff, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
1552 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
1553 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
1554 0x31, 0x32, 0x33, 0xff, 0xff, 0xff, 0xff, 0xff
1555 };
1556
1557
1558 static int
1559 InitBase64 (CT ct)
1560 {
1561 return init_encoding (ct, openBase64);
1562 }
1563
1564
1565 static int
1566 openBase64 (CT ct, char **file)
1567 {
1568 int bitno, cc, digested;
1569 int fd, len, skip;
1570 unsigned long bits;
1571 unsigned char value, *b, *b1, *b2, *b3;
1572 char *cp, *ep, buffer[BUFSIZ];
1573 /* sbeck -- handle prefixes */
1574 CI ci;
1575 CE ce;
1576 MD5_CTX mdContext;
1577
1578 b = (unsigned char *) &bits;
1579 b1 = &b[endian > 0 ? 1 : 2];
1580 b2 = &b[endian > 0 ? 2 : 1];
1581 b3 = &b[endian > 0 ? 3 : 0];
1582
1583 ce = ct->c_cefile;
1584 if (ce->ce_fp) {
1585 fseek (ce->ce_fp, 0L, SEEK_SET);
1586 goto ready_to_go;
1587 }
1588
1589 if (ce->ce_file) {
1590 if ((ce->ce_fp = fopen (ce->ce_file, "r")) == NULL) {
1591 content_error (ce->ce_file, ct, "unable to fopen for reading");
1592 return NOTOK;
1593 }
1594 goto ready_to_go;
1595 }
1596
1597 if (*file == NULL) {
1598 ce->ce_file = add (m_scratch ("", tmp), NULL);
1599 ce->ce_unlink = 1;
1600 } else {
1601 ce->ce_file = add (*file, NULL);
1602 ce->ce_unlink = 0;
1603 }
1604
1605 /* sbeck@cise.ufl.edu -- handle suffixes */
1606 ci = &ct->c_ctinfo;
1607 snprintf (buffer, sizeof(buffer), "%s-suffix-%s/%s",
1608 invo_name, ci->ci_type, ci->ci_subtype);
1609 cp = context_find (buffer);
1610 if (cp == NULL || *cp == '\0') {
1611 snprintf (buffer, sizeof(buffer), "%s-suffix-%s", invo_name,
1612 ci->ci_type);
1613 cp = context_find (buffer);
1614 }
1615 if (cp != NULL && *cp != '\0')
1616 ce->ce_file = add (cp, ce->ce_file);
1617
1618 if ((ce->ce_fp = fopen (ce->ce_file, "w+")) == NULL) {
1619 content_error (ce->ce_file, ct, "unable to fopen for reading/writing");
1620 return NOTOK;
1621 }
1622
1623 if ((len = ct->c_end - ct->c_begin) < 0)
1624 adios (NULL, "internal error(1)");
1625
1626 if (!ct->c_fp && (ct->c_fp = fopen (ct->c_file, "r")) == NULL) {
1627 content_error (ct->c_file, ct, "unable to open for reading");
1628 return NOTOK;
1629 }
1630
1631 if ((digested = ct->c_digested))
1632 MD5Init (&mdContext);
1633
1634 bitno = 18;
1635 bits = 0L;
1636 skip = 0;
1637
1638 lseek (fd = fileno (ct->c_fp), (off_t) ct->c_begin, SEEK_SET);
1639 while (len > 0) {
1640 switch (cc = read (fd, buffer, sizeof(buffer) - 1)) {
1641 case NOTOK:
1642 content_error (ct->c_file, ct, "error reading from");
1643 goto clean_up;
1644
1645 case OK:
1646 content_error (NULL, ct, "premature eof");
1647 goto clean_up;
1648
1649 default:
1650 if (cc > len)
1651 cc = len;
1652 len -= cc;
1653
1654 for (ep = (cp = buffer) + cc; cp < ep; cp++) {
1655 switch (*cp) {
1656 default:
1657 if (isspace (*cp))
1658 break;
1659 if (skip || (*cp & 0x80)
1660 || (value = b642nib[*cp & 0x7f]) > 0x3f) {
1661 if (debugsw) {
1662 fprintf (stderr, "*cp=0x%x pos=%ld skip=%d\n",
1663 *cp,
1664 (long) (lseek (fd, (off_t) 0, SEEK_CUR) - (ep - cp)),
1665 skip);
1666 }
1667 content_error (NULL, ct,
1668 "invalid BASE64 encoding -- continuing");
1669 continue;
1670 }
1671
1672 bits |= value << bitno;
1673 test_end:
1674 if ((bitno -= 6) < 0) {
1675 putc ((char) *b1, ce->ce_fp);
1676 if (digested)
1677 MD5Update (&mdContext, b1, 1);
1678 if (skip < 2) {
1679 putc ((char) *b2, ce->ce_fp);
1680 if (digested)
1681 MD5Update (&mdContext, b2, 1);
1682 if (skip < 1) {
1683 putc ((char) *b3, ce->ce_fp);
1684 if (digested)
1685 MD5Update (&mdContext, b3, 1);
1686 }
1687 }
1688
1689 if (ferror (ce->ce_fp)) {
1690 content_error (ce->ce_file, ct,
1691 "error writing to");
1692 goto clean_up;
1693 }
1694 bitno = 18, bits = 0L, skip = 0;
1695 }
1696 break;
1697
1698 case '=':
1699 if (++skip > 3)
1700 goto self_delimiting;
1701 goto test_end;
1702 }
1703 }
1704 }
1705 }
1706
1707 if (bitno != 18) {
1708 if (debugsw)
1709 fprintf (stderr, "premature ending (bitno %d)\n", bitno);
1710
1711 content_error (NULL, ct, "invalid BASE64 encoding");
1712 goto clean_up;
1713 }
1714
1715 self_delimiting:
1716 fseek (ct->c_fp, 0L, SEEK_SET);
1717
1718 if (fflush (ce->ce_fp)) {
1719 content_error (ce->ce_file, ct, "error writing to");
1720 goto clean_up;
1721 }
1722
1723 if (digested) {
1724 unsigned char digest[16];
1725
1726 MD5Final (digest, &mdContext);
1727 if (memcmp((char *) digest, (char *) ct->c_digest,
1728 sizeof(digest) / sizeof(digest[0])))
1729 content_error (NULL, ct,
1730 "content integrity suspect (digest mismatch) -- continuing");
1731 else
1732 if (debugsw)
1733 fprintf (stderr, "content integrity confirmed\n");
1734 }
1735
1736 fseek (ce->ce_fp, 0L, SEEK_SET);
1737
1738 ready_to_go:
1739 *file = ce->ce_file;
1740 return fileno (ce->ce_fp);
1741
1742 clean_up:
1743 free_encoding (ct, 0);
1744 return NOTOK;
1745 }
1746
1747
1748 /*
1749 * QUOTED PRINTABLE
1750 */
1751
1752 static char hex2nib[0x80] = {
1753 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1754 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1755 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1756 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1757 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1758 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1759 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1760 0x08, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1761 0x00, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x00,
1762 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1763 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1764 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1765 0x00, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x00,
1766 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1767 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1768 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
1769 };
1770
1771
1772 static int
1773 InitQuoted (CT ct)
1774 {
1775 return init_encoding (ct, openQuoted);
1776 }
1777
1778
1779 static int
1780 openQuoted (CT ct, char **file)
1781 {
1782 int cc, digested, len, quoted;
1783 char *cp, *ep;
1784 char buffer[BUFSIZ];
1785 unsigned char mask;
1786 CE ce;
1787 /* sbeck -- handle prefixes */
1788 CI ci;
1789 MD5_CTX mdContext;
1790
1791 ce = ct->c_cefile;
1792 if (ce->ce_fp) {
1793 fseek (ce->ce_fp, 0L, SEEK_SET);
1794 goto ready_to_go;
1795 }
1796
1797 if (ce->ce_file) {
1798 if ((ce->ce_fp = fopen (ce->ce_file, "r")) == NULL) {
1799 content_error (ce->ce_file, ct, "unable to fopen for reading");
1800 return NOTOK;
1801 }
1802 goto ready_to_go;
1803 }
1804
1805 if (*file == NULL) {
1806 ce->ce_file = add (m_scratch ("", tmp), NULL);
1807 ce->ce_unlink = 1;
1808 } else {
1809 ce->ce_file = add (*file, NULL);
1810 ce->ce_unlink = 0;
1811 }
1812
1813 /* sbeck@cise.ufl.edu -- handle suffixes */
1814 ci = &ct->c_ctinfo;
1815 snprintf (buffer, sizeof(buffer), "%s-suffix-%s/%s",
1816 invo_name, ci->ci_type, ci->ci_subtype);
1817 cp = context_find (buffer);
1818 if (cp == NULL || *cp == '\0') {
1819 snprintf (buffer, sizeof(buffer), "%s-suffix-%s", invo_name,
1820 ci->ci_type);
1821 cp = context_find (buffer);
1822 }
1823 if (cp != NULL && *cp != '\0')
1824 ce->ce_file = add (cp, ce->ce_file);
1825
1826 if ((ce->ce_fp = fopen (ce->ce_file, "w+")) == NULL) {
1827 content_error (ce->ce_file, ct, "unable to fopen for reading/writing");
1828 return NOTOK;
1829 }
1830
1831 if ((ce->ce_fp = fopen (ce->ce_file, "w+")) == NULL) {
1832 content_error (ce->ce_file, ct, "unable to fopen for reading/writing");
1833 return NOTOK;
1834 }
1835
1836 if ((len = ct->c_end - ct->c_begin) < 0)
1837 adios (NULL, "internal error(2)");
1838
1839 if (!ct->c_fp && (ct->c_fp = fopen (ct->c_file, "r")) == NULL) {
1840 content_error (ct->c_file, ct, "unable to open for reading");
1841 return NOTOK;
1842 }
1843
1844 if ((digested = ct->c_digested))
1845 MD5Init (&mdContext);
1846
1847 quoted = 0;
1848 #ifdef lint
1849 mask = 0;
1850 #endif
1851
1852 fseek (ct->c_fp, ct->c_begin, SEEK_SET);
1853 while (len > 0) {
1854 char *dp;
1855
1856 if (fgets (buffer, sizeof(buffer) - 1, ct->c_fp) == NULL) {
1857 content_error (NULL, ct, "premature eof");
1858 goto clean_up;
1859 }
1860
1861 if ((cc = strlen (buffer)) > len)
1862 cc = len;
1863 len -= cc;
1864
1865 for (ep = (cp = buffer) + cc - 1; cp <= ep; ep--)
1866 if (!isspace (*ep))
1867 break;
1868 *++ep = '\n', ep++;
1869
1870 for (; cp < ep; cp++) {
1871 if (quoted) {
1872 if (quoted > 1) {
1873 if (!isxdigit (*cp)) {
1874 invalid_hex:
1875 dp = "expecting hexidecimal-digit";
1876 goto invalid_encoding;
1877 }
1878 mask <<= 4;
1879 mask |= hex2nib[*cp & 0x7f];
1880 putc (mask, ce->ce_fp);
1881 if (digested)
1882 MD5Update (&mdContext, &mask, 1);
1883 } else {
1884 switch (*cp) {
1885 case ':':
1886 putc (*cp, ce->ce_fp);
1887 if (digested)
1888 MD5Update (&mdContext, (unsigned char *) ":", 1);
1889 break;
1890
1891 default:
1892 if (!isxdigit (*cp))
1893 goto invalid_hex;
1894 mask = hex2nib[*cp & 0x7f];
1895 quoted = 2;
1896 continue;
1897 }
1898 }
1899
1900 if (ferror (ce->ce_fp)) {
1901 content_error (ce->ce_file, ct, "error writing to");
1902 goto clean_up;
1903 }
1904 quoted = 0;
1905 continue;
1906 }
1907
1908 switch (*cp) {
1909 default:
1910 if (*cp < '!' || *cp > '~') {
1911 int i;
1912 dp = "expecting character in range [!..~]";
1913
1914 invalid_encoding:
1915 i = strlen (invo_name) + 2;
1916 content_error (NULL, ct,
1917 "invalid QUOTED-PRINTABLE encoding -- %s,\n%*.*sbut got char 0x%x",
1918 dp, i, i, "", *cp);
1919 goto clean_up;
1920 }
1921 /* and fall...*/
1922 case ' ':
1923 case '\t':
1924 case '\n':
1925 putc (*cp, ce->ce_fp);
1926 if (digested) {
1927 if (*cp == '\n')
1928 MD5Update (&mdContext, (unsigned char *) "\r\n",2);
1929 else
1930 MD5Update (&mdContext, (unsigned char *) cp, 1);
1931 }
1932 if (ferror (ce->ce_fp)) {
1933 content_error (ce->ce_file, ct, "error writing to");
1934 goto clean_up;
1935 }
1936 break;
1937
1938 case '=':
1939 if (*++cp != '\n') {
1940 quoted = 1;
1941 cp--;
1942 }
1943 break;
1944 }
1945 }
1946 }
1947 if (quoted) {
1948 content_error (NULL, ct,
1949 "invalid QUOTED-PRINTABLE encoding -- end-of-content while still quoting");
1950 goto clean_up;
1951 }
1952
1953 fseek (ct->c_fp, 0L, SEEK_SET);
1954
1955 if (fflush (ce->ce_fp)) {
1956 content_error (ce->ce_file, ct, "error writing to");
1957 goto clean_up;
1958 }
1959
1960 if (digested) {
1961 unsigned char digest[16];
1962
1963 MD5Final (digest, &mdContext);
1964 if (memcmp((char *) digest, (char *) ct->c_digest,
1965 sizeof(digest) / sizeof(digest[0])))
1966 content_error (NULL, ct,
1967 "content integrity suspect (digest mismatch) -- continuing");
1968 else
1969 if (debugsw)
1970 fprintf (stderr, "content integrity confirmed\n");
1971 }
1972
1973 fseek (ce->ce_fp, 0L, SEEK_SET);
1974
1975 ready_to_go:
1976 *file = ce->ce_file;
1977 return fileno (ce->ce_fp);
1978
1979 clean_up:
1980 free_encoding (ct, 0);
1981 return NOTOK;
1982 }
1983
1984
1985 /*
1986 * 7BIT
1987 */
1988
1989 static int
1990 Init7Bit (CT ct)
1991 {
1992 if (init_encoding (ct, open7Bit) == NOTOK)
1993 return NOTOK;
1994
1995 ct->c_cesizefnx = NULL; /* no need to decode for real size */
1996 return OK;
1997 }
1998
1999
2000 static int
2001 open7Bit (CT ct, char **file)
2002 {
2003 int cc, fd, len;
2004 char buffer[BUFSIZ];
2005 /* sbeck -- handle prefixes */
2006 char *cp;
2007 CI ci;
2008 CE ce;
2009
2010 ce = ct->c_cefile;
2011 if (ce->ce_fp) {
2012 fseek (ce->ce_fp, 0L, SEEK_SET);
2013 goto ready_to_go;
2014 }
2015
2016 if (ce->ce_file) {
2017 if ((ce->ce_fp = fopen (ce->ce_file, "r")) == NULL) {
2018 content_error (ce->ce_file, ct, "unable to fopen for reading");
2019 return NOTOK;
2020 }
2021 goto ready_to_go;
2022 }
2023
2024 if (*file == NULL) {
2025 ce->ce_file = add (m_scratch ("", tmp), NULL);
2026 ce->ce_unlink = 1;
2027 } else {
2028 ce->ce_file = add (*file, NULL);
2029 ce->ce_unlink = 0;
2030 }
2031
2032 /* sbeck@cise.ufl.edu -- handle suffixes */
2033 ci = &ct->c_ctinfo;
2034 snprintf (buffer, sizeof(buffer), "%s-suffix-%s/%s",
2035 invo_name, ci->ci_type, ci->ci_subtype);
2036 cp = context_find (buffer);
2037 if (cp == NULL || *cp == '\0') {
2038 snprintf (buffer, sizeof(buffer), "%s-suffix-%s", invo_name,
2039 ci->ci_type);
2040 cp = context_find (buffer);
2041 }
2042 if (cp != NULL && *cp != '\0')
2043 ce->ce_file = add (cp, ce->ce_file);
2044
2045 if ((ce->ce_fp = fopen (ce->ce_file, "w+")) == NULL) {
2046 content_error (ce->ce_file, ct, "unable to fopen for reading/writing");
2047 return NOTOK;
2048 }
2049
2050 if (ct->c_type == CT_MULTIPART) {
2051 char **ap, **ep;
2052 CI ci = &ct->c_ctinfo;
2053
2054 len = 0;
2055 fprintf (ce->ce_fp, "%s: %s/%s", TYPE_FIELD, ci->ci_type, ci->ci_subtype);
2056 len += strlen (TYPE_FIELD) + 2 + strlen (ci->ci_type)
2057 + 1 + strlen (ci->ci_subtype);
2058 for (ap = ci->ci_attrs, ep = ci->ci_values; *ap; ap++, ep++) {
2059 putc (';', ce->ce_fp);
2060 len++;
2061
2062 snprintf (buffer, sizeof(buffer), "%s=\"%s\"", *ap, *ep);
2063
2064 if (len + 1 + (cc = strlen (buffer)) >= CPERLIN) {
2065 fputs ("\n\t", ce->ce_fp);
2066 len = 8;
2067 } else {
2068 putc (' ', ce->ce_fp);
2069 len++;
2070 }
2071 fprintf (ce->ce_fp, "%s", buffer);
2072 len += cc;
2073 }
2074
2075 if (ci->ci_comment) {
2076 if (len + 1 + (cc = 2 + strlen (ci->ci_comment)) >= CPERLIN) {
2077 fputs ("\n\t", ce->ce_fp);
2078 len = 8;
2079 }
2080 else {
2081 putc (' ', ce->ce_fp);
2082 len++;
2083 }
2084 fprintf (ce->ce_fp, "(%s)", ci->ci_comment);
2085 len += cc;
2086 }
2087 fprintf (ce->ce_fp, "\n");
2088 if (ct->c_id)
2089 fprintf (ce->ce_fp, "%s:%s", ID_FIELD, ct->c_id);
2090 if (ct->c_descr)
2091 fprintf (ce->ce_fp, "%s:%s", DESCR_FIELD, ct->c_descr);
2092 fprintf (ce->ce_fp, "\n");
2093 }
2094
2095 if ((len = ct->c_end - ct->c_begin) < 0)
2096 adios (NULL, "internal error(3)");
2097
2098 if (!ct->c_fp && (ct->c_fp = fopen (ct->c_file, "r")) == NULL) {
2099 content_error (ct->c_file, ct, "unable to open for reading");
2100 return NOTOK;
2101 }
2102
2103 lseek (fd = fileno (ct->c_fp), (off_t) ct->c_begin, SEEK_SET);
2104 while (len > 0)
2105 switch (cc = read (fd, buffer, sizeof(buffer) - 1)) {
2106 case NOTOK:
2107 content_error (ct->c_file, ct, "error reading from");
2108 goto clean_up;
2109
2110 case OK:
2111 content_error (NULL, ct, "premature eof");
2112 goto clean_up;
2113
2114 default:
2115 if (cc > len)
2116 cc = len;
2117 len -= cc;
2118
2119 fwrite (buffer, sizeof(*buffer), cc, ce->ce_fp);
2120 if (ferror (ce->ce_fp)) {
2121 content_error (ce->ce_file, ct, "error writing to");
2122 goto clean_up;
2123 }
2124 }
2125
2126 fseek (ct->c_fp, 0L, SEEK_SET);
2127
2128 if (fflush (ce->ce_fp)) {
2129 content_error (ce->ce_file, ct, "error writing to");
2130 goto clean_up;
2131 }
2132
2133 fseek (ce->ce_fp, 0L, SEEK_SET);
2134
2135 ready_to_go:
2136 *file = ce->ce_file;
2137 return fileno (ce->ce_fp);
2138
2139 clean_up:
2140 free_encoding (ct, 0);
2141 return NOTOK;
2142 }
2143
2144
2145 /*
2146 * External
2147 */
2148
2149 static int
2150 openExternal (CT ct, CT cb, CE ce, char **file, int *fd)
2151 {
2152 char cachefile[BUFSIZ];
2153
2154 if (ce->ce_fp) {
2155 fseek (ce->ce_fp, 0L, SEEK_SET);
2156 goto ready_already;
2157 }
2158
2159 if (ce->ce_file) {
2160 if ((ce->ce_fp = fopen (ce->ce_file, "r")) == NULL) {
2161 content_error (ce->ce_file, ct, "unable to fopen for reading");
2162 return NOTOK;
2163 }
2164 goto ready_already;
2165 }
2166
2167 if (find_cache (ct, rcachesw, (int *) 0, cb->c_id,
2168 cachefile, sizeof(cachefile)) != NOTOK) {
2169 if ((ce->ce_fp = fopen (cachefile, "r"))) {
2170 ce->ce_file = getcpy (cachefile);
2171 ce->ce_unlink = 0;
2172 goto ready_already;
2173 } else {
2174 admonish (cachefile, "unable to fopen for reading");
2175 }
2176 }
2177
2178 return OK;
2179
2180 ready_already:
2181 *file = ce->ce_file;
2182 *fd = fileno (ce->ce_fp);
2183 return DONE;
2184 }
2185
2186 /*
2187 * File
2188 */
2189
2190 static int
2191 InitFile (CT ct)
2192 {
2193 return init_encoding (ct, openFile);
2194 }
2195
2196
2197 static int
2198 openFile (CT ct, char **file)
2199 {
2200 int fd, cachetype;
2201 char cachefile[BUFSIZ];
2202 struct exbody *e = ct->c_ctexbody;
2203 CE ce = ct->c_cefile;
2204
2205 switch (openExternal (e->eb_parent, e->eb_content, ce, file, &fd)) {
2206 case NOTOK:
2207 return NOTOK;
2208
2209 case OK:
2210 break;
2211
2212 case DONE:
2213 return fd;
2214 }
2215
2216 if (!e->eb_name) {
2217 content_error (NULL, ct, "missing name parameter");
2218 return NOTOK;
2219 }
2220
2221 ce->ce_file = getcpy (e->eb_name);
2222 ce->ce_unlink = 0;
2223
2224 if ((ce->ce_fp = fopen (ce->ce_file, "r")) == NULL) {
2225 content_error (ce->ce_file, ct, "unable to fopen for reading");
2226 return NOTOK;
2227 }
2228
2229 if ((!e->eb_permission || strcasecmp (e->eb_permission, "read-write"))
2230 && find_cache (NULL, wcachesw, &cachetype, e->eb_content->c_id,
2231 cachefile, sizeof(cachefile)) != NOTOK) {
2232 int mask;
2233 FILE *fp;
2234
2235 mask = umask (cachetype ? ~m_gmprot () : 0222);
2236 if ((fp = fopen (cachefile, "w"))) {
2237 int cc;
2238 char buffer[BUFSIZ];
2239 FILE *gp = ce->ce_fp;
2240
2241 fseek (gp, 0L, SEEK_SET);
2242
2243 while ((cc = fread (buffer, sizeof(*buffer), sizeof(buffer), gp))
2244 > 0)
2245 fwrite (buffer, sizeof(*buffer), cc, fp);
2246 fflush (fp);
2247
2248 if (ferror (gp)) {
2249 admonish (ce->ce_file, "error reading");
2250 unlink (cachefile);
2251 }
2252 else
2253 if (ferror (fp)) {
2254 admonish (cachefile, "error writing");
2255 unlink (cachefile);
2256 }
2257 fclose (fp);
2258 }
2259 umask (mask);
2260 }
2261
2262 fseek (ce->ce_fp, 0L, SEEK_SET);
2263 *file = ce->ce_file;
2264 return fileno (ce->ce_fp);
2265 }
2266
2267 /*
2268 * FTP
2269 */
2270
2271 static int
2272 InitFTP (CT ct)
2273 {
2274 return init_encoding (ct, openFTP);
2275 }
2276
2277
2278 static int
2279 openFTP (CT ct, char **file)
2280 {
2281 int cachetype, caching, fd;
2282 int len, buflen;
2283 char *bp, *ftp, *user, *pass;
2284 char buffer[BUFSIZ], cachefile[BUFSIZ];
2285 struct exbody *e;
2286 CE ce;
2287 static char *username = NULL;
2288 static char *password = NULL;
2289
2290 e = ct->c_ctexbody;
2291 ce = ct->c_cefile;
2292
2293 if ((ftp = context_find (nmhaccessftp)) && !*ftp)
2294 ftp = NULL;
2295
2296 #ifndef BUILTIN_FTP
2297 if (!ftp)
2298 return NOTOK;
2299 #endif
2300
2301 switch (openExternal (e->eb_parent, e->eb_content, ce, file, &fd)) {
2302 case NOTOK:
2303 return NOTOK;
2304
2305 case OK:
2306 break;
2307
2308 case DONE:
2309 return fd;
2310 }
2311
2312 if (!e->eb_name || !e->eb_site) {
2313 content_error (NULL, ct, "missing %s parameter",
2314 e->eb_name ? "site": "name");
2315 return NOTOK;
2316 }
2317
2318 if (xpid) {
2319 if (xpid < 0)
2320 xpid = -xpid;
2321 pidcheck (pidwait (xpid, NOTOK));
2322 xpid = 0;
2323 }
2324
2325 /* Get the buffer ready to go */
2326 bp = buffer;
2327 buflen = sizeof(buffer);
2328
2329 /*
2330 * Construct the query message for user
2331 */
2332 snprintf (bp, buflen, "Retrieve %s", e->eb_name);
2333 len = strlen (bp);
2334 bp += len;
2335 buflen -= len;
2336
2337 if (e->eb_partno) {
2338 snprintf (bp, buflen, " (content %s)", e->eb_partno);
2339 len = strlen (bp);
2340 bp += len;
2341 buflen -= len;
2342 }
2343
2344 snprintf (bp, buflen, "\n using %sFTP from site %s",
2345 e->eb_flags ? "anonymous " : "", e->eb_site);
2346 len = strlen (bp);
2347 bp += len;
2348 buflen -= len;
2349
2350 if (e->eb_size > 0) {
2351 snprintf (bp, buflen, " (%lu octets)", e->eb_size);
2352 len = strlen (bp);
2353 bp += len;
2354 buflen -= len;
2355 }
2356 snprintf (bp, buflen, "? ");
2357
2358 /*
2359 * Now, check the answer
2360 */
2361 if (!getanswer (buffer))
2362 return NOTOK;
2363
2364 if (e->eb_flags) {
2365 user = "anonymous";
2366 snprintf (buffer, sizeof(buffer), "%s@%s", getusername (), LocalName ());
2367 pass = buffer;
2368 } else {
2369 ruserpass (e->eb_site, &username, &password);
2370 user = username;
2371 pass = password;
2372 }
2373
2374 ce->ce_unlink = (*file == NULL);
2375 caching = 0;
2376 cachefile[0] = '\0';
2377 if ((!e->eb_permission || strcasecmp (e->eb_permission, "read-write"))
2378 && find_cache (NULL, wcachesw, &cachetype, e->eb_content->c_id,
2379 cachefile, sizeof(cachefile)) != NOTOK) {
2380 if (*file == NULL) {
2381 ce->ce_unlink = 0;
2382 caching = 1;
2383 }
2384 }
2385
2386 if (*file)
2387 ce->ce_file = add (*file, NULL);
2388 else if (caching)
2389 ce->ce_file = add (cachefile, NULL);
2390 else
2391 ce->ce_file = add (m_scratch ("", tmp), NULL);
2392
2393 if ((ce->ce_fp = fopen (ce->ce_file, "w+")) == NULL) {
2394 content_error (ce->ce_file, ct, "unable to fopen for reading/writing");
2395 return NOTOK;
2396 }
2397
2398 #ifdef BUILTIN_FTP
2399 if (ftp)
2400 #endif
2401 {
2402 int child_id, i, vecp;
2403 char *vec[9];
2404
2405 vecp = 0;
2406 vec[vecp++] = r1bindex (ftp, '/');
2407 vec[vecp++] = e->eb_site;
2408 vec[vecp++] = user;
2409 vec[vecp++] = pass;
2410 vec[vecp++] = e->eb_dir;
2411 vec[vecp++] = e->eb_name;
2412 vec[vecp++] = ce->ce_file,
2413 vec[vecp++] = e->eb_mode && !strcasecmp (e->eb_mode, "ascii")
2414 ? "ascii" : "binary";
2415 vec[vecp] = NULL;
2416
2417 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 adios ("fork", "unable to");
2424 /* NOTREACHED */
2425
2426 case OK:
2427 close (fileno (ce->ce_fp));
2428 execvp (ftp, vec);
2429 fprintf (stderr, "unable to exec ");
2430 perror (ftp);
2431 _exit (-1);
2432 /* NOTREACHED */
2433
2434 default:
2435 if (pidXwait (child_id, NULL)) {
2436 #ifdef BUILTIN_FTP
2437 losing_ftp:
2438 #endif
2439 username = password = NULL;
2440 ce->ce_unlink = 1;
2441 return NOTOK;
2442 }
2443 break;
2444 }
2445 }
2446 #ifdef BUILTIN_FTP
2447 else
2448 if (ftp_get (e->eb_site, user, pass, e->eb_dir, e->eb_name,
2449 ce->ce_file,
2450 e->eb_mode && !strcasecmp (e->eb_mode, "ascii"), 0)
2451 == NOTOK)
2452 goto losing_ftp;
2453 #endif
2454
2455 if (cachefile[0]) {
2456 if (caching)
2457 chmod (cachefile, cachetype ? m_gmprot () : 0444);
2458 else {
2459 int mask;
2460 FILE *fp;
2461
2462 mask = umask (cachetype ? ~m_gmprot () : 0222);
2463 if ((fp = fopen (cachefile, "w"))) {
2464 int cc;
2465 FILE *gp = ce->ce_fp;
2466
2467 fseek (gp, 0L, SEEK_SET);
2468
2469 while ((cc= fread (buffer, sizeof(*buffer), sizeof(buffer), gp))
2470 > 0)
2471 fwrite (buffer, sizeof(*buffer), cc, fp);
2472 fflush (fp);
2473
2474 if (ferror (gp)) {
2475 admonish (ce->ce_file, "error reading");
2476 unlink (cachefile);
2477 }
2478 else
2479 if (ferror (fp)) {
2480 admonish (cachefile, "error writing");
2481 unlink (cachefile);
2482 }
2483 fclose (fp);
2484 }
2485 umask (mask);
2486 }
2487 }
2488
2489 fseek (ce->ce_fp, 0L, SEEK_SET);
2490 *file = ce->ce_file;
2491 return fileno (ce->ce_fp);
2492 }
2493
2494
2495 /*
2496 * Mail
2497 */
2498
2499 static int
2500 InitMail (CT ct)
2501 {
2502 return init_encoding (ct, openMail);
2503 }
2504
2505
2506 static int
2507 openMail (CT ct, char **file)
2508 {
2509 int child_id, fd, i, vecp;
2510 int len, buflen;
2511 char *bp, buffer[BUFSIZ], *vec[7];
2512 struct exbody *e = ct->c_ctexbody;
2513 CE ce = ct->c_cefile;
2514
2515 switch (openExternal (e->eb_parent, e->eb_content, ce, file, &fd)) {
2516 case NOTOK:
2517 return NOTOK;
2518
2519 case OK:
2520 break;
2521
2522 case DONE:
2523 return fd;
2524 }
2525
2526 if (!e->eb_server) {
2527 content_error (NULL, ct, "missing server parameter");
2528 return NOTOK;
2529 }
2530
2531 if (xpid) {
2532 if (xpid < 0)
2533 xpid = -xpid;
2534 pidcheck (pidwait (xpid, NOTOK));
2535 xpid = 0;
2536 }
2537
2538 /* Get buffer ready to go */
2539 bp = buffer;
2540 buflen = sizeof(buffer);
2541
2542 /* Now, construct query message */
2543 snprintf (bp, buflen, "Retrieve content");
2544 len = strlen (bp);
2545 bp += len;
2546 buflen -= len;
2547
2548 if (e->eb_partno) {
2549 snprintf (bp, buflen, " %s", e->eb_partno);
2550 len = strlen (bp);
2551 bp += len;
2552 buflen -= len;
2553 }
2554
2555 snprintf (bp, buflen, " by asking %s\n\n%s\n? ",
2556 e->eb_server,
2557 e->eb_subject ? e->eb_subject : e->eb_body);
2558
2559 /* Now, check answer */
2560 if (!getanswer (buffer))
2561 return NOTOK;
2562
2563 vecp = 0;
2564 vec[vecp++] = r1bindex (mailproc, '/');
2565 vec[vecp++] = e->eb_server;
2566 vec[vecp++] = "-subject";
2567 vec[vecp++] = e->eb_subject ? e->eb_subject : "mail-server request";
2568 vec[vecp++] = "-body";
2569 vec[vecp++] = e->eb_body;
2570 vec[vecp] = NULL;
2571
2572 for (i = 0; (child_id = vfork ()) == NOTOK && i < 5; i++)
2573 sleep (5);
2574 switch (child_id) {
2575 case NOTOK:
2576 advise ("fork", "unable to");
2577 return NOTOK;
2578
2579 case OK:
2580 execvp (mailproc, vec);
2581 fprintf (stderr, "unable to exec ");
2582 perror (mailproc);
2583 _exit (-1);
2584 /* NOTREACHED */
2585
2586 default:
2587 if (pidXwait (child_id, NULL) == OK)
2588 advise (NULL, "request sent");
2589 break;
2590 }
2591
2592 if (*file == NULL) {
2593 ce->ce_file = add (m_scratch ("", tmp), NULL);
2594 ce->ce_unlink = 1;
2595 } else {
2596 ce->ce_file = add (*file, NULL);
2597 ce->ce_unlink = 0;
2598 }
2599
2600 if ((ce->ce_fp = fopen (ce->ce_file, "w+")) == NULL) {
2601 content_error (ce->ce_file, ct, "unable to fopen for reading/writing");
2602 return NOTOK;
2603 }
2604
2605 if (ct->c_showproc)
2606 free (ct->c_showproc);
2607 ct->c_showproc = add ("true", NULL);
2608
2609 fseek (ce->ce_fp, 0L, SEEK_SET);
2610 *file = ce->ce_file;
2611 return fileno (ce->ce_fp);
2612 }
2613
2614
2615 static int
2616 readDigest (CT ct, char *cp)
2617 {
2618 int bitno, skip;
2619 unsigned long bits;
2620 char *bp = cp;
2621 unsigned char *dp, value, *ep;
2622 unsigned char *b, *b1, *b2, *b3;
2623
2624 b = (unsigned char *) &bits,
2625 b1 = &b[endian > 0 ? 1 : 2],
2626 b2 = &b[endian > 0 ? 2 : 1],
2627 b3 = &b[endian > 0 ? 3 : 0];
2628 bitno = 18;
2629 bits = 0L;
2630 skip = 0;
2631
2632 for (ep = (dp = ct->c_digest)
2633 + sizeof(ct->c_digest) / sizeof(ct->c_digest[0]); *cp; cp++)
2634 switch (*cp) {
2635 default:
2636 if (skip
2637 || (*cp & 0x80)
2638 || (value = b642nib[*cp & 0x7f]) > 0x3f) {
2639 if (debugsw)
2640 fprintf (stderr, "invalid BASE64 encoding\n");
2641 return NOTOK;
2642 }
2643
2644 bits |= value << bitno;
2645 test_end:
2646 if ((bitno -= 6) < 0) {
2647 if (dp + (3 - skip) > ep)
2648 goto invalid_digest;
2649 *dp++ = *b1;
2650 if (skip < 2) {
2651 *dp++ = *b2;
2652 if (skip < 1)
2653 *dp++ = *b3;
2654 }
2655 bitno = 18;
2656 bits = 0L;
2657 skip = 0;
2658 }
2659 break;
2660
2661 case '=':
2662 if (++skip > 3)
2663 goto self_delimiting;
2664 goto test_end;
2665 }
2666 if (bitno != 18) {
2667 if (debugsw)
2668 fprintf (stderr, "premature ending (bitno %d)\n", bitno);
2669
2670 return NOTOK;
2671 }
2672 self_delimiting:
2673 if (dp != ep) {
2674 invalid_digest:
2675 if (debugsw) {
2676 while (*cp)
2677 cp++;
2678 fprintf (stderr, "invalid MD5 digest (got %d octets)\n",
2679 cp - bp);
2680 }
2681
2682 return NOTOK;
2683 }
2684
2685 if (debugsw) {
2686 fprintf (stderr, "MD5 digest=");
2687 for (dp = ct->c_digest; dp < ep; dp++)
2688 fprintf (stderr, "%02x", *dp & 0xff);
2689 fprintf (stderr, "\n");
2690 }
2691
2692 return OK;
2693 }
Fork of https://git.savannah.nongnu.org/cgit/nmh.git