]> diplodocus.org Git - nmh/blob - uip/mhparse.c
2be9760359526cd446863c4bc0eb3cee9dc33cbf
[nmh] / uip / mhparse.c
1
2 /*
3 * mhparse.c -- routines to parse the contents of MIME messages
4 *
5 * This code is Copyright (c) 2002, by the authors of nmh. See the
6 * COPYRIGHT file in the root directory of the nmh distribution for
7 * complete copyright information.
8 */
9
10 #include <h/mh.h>
11 #include <fcntl.h>
12 #include <h/md5.h>
13 #include <h/mts.h>
14 #include <h/tws.h>
15 #include <h/mime.h>
16 #include <h/mhparse.h>
17 #include <h/utils.h>
18 #ifdef HAVE_ICONV
19 # include <iconv.h>
20 #endif /* HAVE_ICONV */
21
22
23 extern int debugsw;
24
25 /* cache policies */
26 extern int rcachesw; /* mhcachesbr.c */
27 extern int wcachesw; /* mhcachesbr.c */
28
29 int checksw = 0; /* check Content-MD5 field */
30
31 /*
32 * These are for mhfixmsg to:
33 * 1) Instruct parser not to detect invalid Content-Transfer-Encoding
34 * in a multipart.
35 * 2) Suppress the warning about bogus multipart content, and report it.
36 * 3) Suppress the warning about extraneous trailing ';' in header parameter
37 * lists.
38 */
39 int skip_mp_cte_check;
40 int suppress_bogus_mp_content_warning;
41 int bogus_mp_content;
42 int suppress_extraneous_trailing_semicolon_warning;
43
44 /*
45 * By default, suppress warning about multiple MIME-Version header fields.
46 */
47 int suppress_multiple_mime_version_warning = 1;
48
49 /* list of preferred type/subtype pairs, for -prefer */
50 char *preferred_types[NPREFS],
51 *preferred_subtypes[NPREFS];
52 int npreferred;
53
54
55 /*
56 * Structures for TEXT messages
57 */
58 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 /* Charset[] removed -- yozo. Mon Oct 8 01:03:41 JST 2012 */
66
67 /*
68 * Structures for MULTIPART messages
69 */
70 struct k2v SubMultiPart[] = {
71 { "mixed", MULTI_MIXED },
72 { "alternative", MULTI_ALTERNATE },
73 { "digest", MULTI_DIGEST },
74 { "parallel", MULTI_PARALLEL },
75 { "related", MULTI_RELATED },
76 { NULL, MULTI_UNKNOWN } /* this one must be last! */
77 };
78
79 /*
80 * Structures for MESSAGE messages
81 */
82 struct k2v SubMessage[] = {
83 { "rfc822", MESSAGE_RFC822 },
84 { "partial", MESSAGE_PARTIAL },
85 { "external-body", MESSAGE_EXTERNAL },
86 { NULL, MESSAGE_UNKNOWN } /* this one must be last! */
87 };
88
89 /*
90 * Structure for APPLICATION messages
91 */
92 struct k2v SubApplication[] = {
93 { "octet-stream", APPLICATION_OCTETS },
94 { "postscript", APPLICATION_POSTSCRIPT },
95 { NULL, APPLICATION_UNKNOWN } /* this one must be last! */
96 };
97
98 /*
99 * Mapping of names of CTE types in mhbuild directives
100 */
101 static struct k2v EncodingType[] = {
102 { "8bit", CE_8BIT },
103 { "qp", CE_QUOTED },
104 { "q-p", CE_QUOTED },
105 { "quoted-printable", CE_QUOTED },
106 { "b64", CE_BASE64 },
107 { "base64", CE_BASE64 },
108 { NULL, 0 },
109 };
110
111
112 /* mhcachesbr.c */
113 int find_cache (CT, int, int *, char *, char *, int);
114
115 /* mhmisc.c */
116 int part_ok (CT);
117 int type_ok (CT, int);
118 void content_error (char *, CT, char *, ...);
119
120 /* mhfree.c */
121 void free_encoding (CT, int);
122
123 /*
124 * static prototypes
125 */
126 static CT get_content (FILE *, char *, int);
127 static int get_comment (const char *, const char *, char **, char **);
128
129 static int InitGeneric (CT);
130 static int InitText (CT);
131 static int InitMultiPart (CT);
132 static void reverse_parts (CT);
133 static void prefer_parts(CT ct);
134 static int InitMessage (CT);
135 static int InitApplication (CT);
136 static int init_encoding (CT, OpenCEFunc);
137 static unsigned long size_encoding (CT);
138 static int InitBase64 (CT);
139 static int openBase64 (CT, char **);
140 static int InitQuoted (CT);
141 static int openQuoted (CT, char **);
142 static int Init7Bit (CT);
143 static int openExternal (CT, CT, CE, char **, int *);
144 static int InitFile (CT);
145 static int openFile (CT, char **);
146 static int InitFTP (CT);
147 static int openFTP (CT, char **);
148 static int InitMail (CT);
149 static int openMail (CT, char **);
150 static int readDigest (CT, char *);
151 static int get_leftover_mp_content (CT, int);
152 static int InitURL (CT);
153 static int openURL (CT, char **);
154 static int parse_header_attrs (const char *, const char *, char **, PM *,
155 PM *, char **);
156 static size_t param_len(PM, int, size_t, int *, int *, size_t *);
157 static size_t normal_param(PM, char *, size_t, size_t, size_t);
158 static int get_dispo (char *, CT, int);
159
160 struct str2init str2cts[] = {
161 { "application", CT_APPLICATION, InitApplication },
162 { "audio", CT_AUDIO, InitGeneric },
163 { "image", CT_IMAGE, InitGeneric },
164 { "message", CT_MESSAGE, InitMessage },
165 { "multipart", CT_MULTIPART, InitMultiPart },
166 { "text", CT_TEXT, InitText },
167 { "video", CT_VIDEO, InitGeneric },
168 { NULL, CT_EXTENSION, NULL }, /* these two must be last! */
169 { NULL, CT_UNKNOWN, NULL },
170 };
171
172 struct str2init str2ces[] = {
173 { "base64", CE_BASE64, InitBase64 },
174 { "quoted-printable", CE_QUOTED, InitQuoted },
175 { "8bit", CE_8BIT, Init7Bit },
176 { "7bit", CE_7BIT, Init7Bit },
177 { "binary", CE_BINARY, Init7Bit },
178 { NULL, CE_EXTENSION, NULL }, /* these two must be last! */
179 { NULL, CE_UNKNOWN, NULL },
180 };
181
182 /*
183 * NOTE WELL: si_key MUST NOT have value of NOTOK
184 *
185 * si_key is 1 if access method is anonymous.
186 */
187 struct str2init str2methods[] = {
188 { "afs", 1, InitFile },
189 { "anon-ftp", 1, InitFTP },
190 { "ftp", 0, InitFTP },
191 { "local-file", 0, InitFile },
192 { "mail-server", 0, InitMail },
193 { "url", 0, InitURL },
194 { NULL, 0, NULL }
195 };
196
197
198 /*
199 * Main entry point for parsing a MIME message or file.
200 * It returns the Content structure for the top level
201 * entity in the file.
202 */
203
204 CT
205 parse_mime (char *file)
206 {
207 int is_stdin;
208 char buffer[BUFSIZ];
209 FILE *fp;
210 CT ct;
211 size_t n;
212 struct stat statbuf;
213
214 bogus_mp_content = 0;
215
216 /*
217 * Check if file is actually standard input
218 */
219 if ((is_stdin = !(strcmp (file, "-")))) {
220 char *tfile = m_mktemp2(NULL, invo_name, NULL, &fp);
221 if (tfile == NULL) {
222 advise("mhparse", "unable to create temporary file in %s",
223 get_temp_dir());
224 return NULL;
225 }
226 file = mh_xstrdup(tfile);
227
228 while ((n = fread(buffer, 1, sizeof(buffer), stdin)) > 0) {
229 if (fwrite(buffer, 1, n, fp) != n) {
230 (void) m_unlink (file);
231 advise (file, "error copying to temporary file");
232 return NULL;
233 }
234 }
235 fflush (fp);
236
237 if (ferror (stdin)) {
238 (void) m_unlink (file);
239 advise ("stdin", "error reading");
240 return NULL;
241 }
242 if (ferror (fp)) {
243 (void) m_unlink (file);
244 advise (file, "error writing");
245 return NULL;
246 }
247 fseek (fp, 0L, SEEK_SET);
248 } else if (lstat (file, &statbuf) == NOTOK) {
249 advise (file, "unable to lstat");
250 return NULL;
251 } else if (S_ISDIR(statbuf.st_mode)) {
252 /* Don't try to parse a directory. */
253 inform("%s is a directory", file);
254 return NULL;
255 } else if ((fp = fopen (file, "r")) == NULL) {
256 advise (file, "unable to read");
257 return NULL;
258 }
259
260 if (!(ct = get_content (fp, file, 1))) {
261 if (is_stdin)
262 (void) m_unlink (file);
263 inform("unable to decode %s", file);
264 return NULL;
265 }
266
267 if (is_stdin)
268 ct->c_unlink = 1; /* temp file to remove */
269
270 ct->c_fp = NULL;
271
272 if (ct->c_end == 0L) {
273 fseek (fp, 0L, SEEK_END);
274 ct->c_end = ftell (fp);
275 }
276
277 if (ct->c_ctinitfnx && (*ct->c_ctinitfnx) (ct) == NOTOK) {
278 fclose (fp);
279 free_content (ct);
280 return NULL;
281 }
282
283 fclose (fp);
284 return ct;
285 }
286
287
288 /*
289 * Main routine for reading/parsing the headers
290 * of a message content.
291 *
292 * toplevel = 1 # we are at the top level of the message
293 * toplevel = 0 # we are inside message type or multipart type
294 * # other than multipart/digest
295 * toplevel = -1 # we are inside multipart/digest
296 * NB: on failure we will fclose(in)!
297 */
298
299 static CT
300 get_content (FILE *in, char *file, int toplevel)
301 {
302 int compnum, state;
303 char buf[BUFSIZ], name[NAMESZ];
304 char *np, *vp;
305 CT ct;
306 HF hp;
307 m_getfld_state_t gstate = 0;
308
309 /* allocate the content structure */
310 NEW0(ct);
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 m_getfld_track_filepos (&gstate, in);
320 for (compnum = 1;;) {
321 int bufsz = sizeof buf;
322 switch (state = m_getfld (&gstate, name, buf, &bufsz, in)) {
323 case FLD:
324 case FLDPLUS:
325 compnum++;
326
327 /* get copies of the buffers */
328 np = mh_xstrdup(name);
329 vp = mh_xstrdup(buf);
330
331 /* if necessary, get rest of field */
332 while (state == FLDPLUS) {
333 bufsz = sizeof buf;
334 state = m_getfld (&gstate, name, buf, &bufsz, in);
335 vp = add (buf, vp); /* add to previous value */
336 }
337
338 /* Now add the header data to the list */
339 add_header (ct, np, vp);
340
341 /* continue, to see if this isn't the last header field */
342 ct->c_begin = ftell (in) + 1;
343 continue;
344
345 case BODY:
346 if (name[0] == ':') {
347 /* Special case: no blank line between header and body. The
348 file position indicator is on the newline at the end of the
349 line, but it needs to be one prior to the beginning of the
350 line. So subtract the length of the line, bufsz, plus 1. */
351 ct->c_begin = ftell (in) - (bufsz + 1);
352 } else {
353 ct->c_begin = ftell (in) - (bufsz - 1);
354 }
355 break;
356
357 case FILEEOF:
358 ct->c_begin = ftell (in);
359 break;
360
361 case LENERR:
362 case FMTERR:
363 adios (NULL, "message format error in component #%d", compnum);
364
365 default:
366 adios (NULL, "getfld() returned %d", state);
367 }
368
369 /* break out of the loop */
370 break;
371 }
372 m_getfld_state_destroy (&gstate);
373
374 /*
375 * Read the content headers. We will parse the
376 * MIME related header fields into their various
377 * structures and set internal flags related to
378 * content type/subtype, etc.
379 */
380
381 hp = ct->c_first_hf; /* start at first header field */
382 while (hp) {
383 /* Get MIME-Version field */
384 if (!strcasecmp (hp->name, VRSN_FIELD)) {
385 int ucmp;
386 char c, *cp, *dp;
387 char *vrsn;
388
389 vrsn = add (hp->value, NULL);
390
391 /* Now, cleanup this field */
392 cp = vrsn;
393
394 while (isspace ((unsigned char) *cp))
395 cp++;
396 for (dp = strchr(cp, '\n'); dp; dp = strchr(dp, '\n'))
397 *dp++ = ' ';
398 for (dp = cp + strlen (cp) - 1; dp >= cp; dp--)
399 if (!isspace ((unsigned char) *dp))
400 break;
401 *++dp = '\0';
402 if (debugsw)
403 fprintf (stderr, "%s: %s\n", VRSN_FIELD, cp);
404
405 if (*cp == '(' &&
406 get_comment (ct->c_file, VRSN_FIELD, &cp, NULL) == NOTOK)
407 goto out;
408
409 for (dp = cp; istoken (*dp); dp++)
410 continue;
411 c = *dp;
412 *dp = '\0';
413 ucmp = !strcasecmp (cp, VRSN_VALUE);
414 *dp = c;
415 if (!ucmp) {
416 admonish (NULL, "message %s has unknown value for %s: field (%s)",
417 ct->c_file, VRSN_FIELD, cp);
418 }
419 if (!ct->c_vrsn) {
420 ct->c_vrsn = vrsn;
421 } else {
422 if (! suppress_multiple_mime_version_warning)
423 inform("message %s has multiple %s: fields",
424 ct->c_file, VRSN_FIELD);
425 free(vrsn);
426 }
427 }
428 else if (!strcasecmp (hp->name, TYPE_FIELD)) {
429 /* Get Content-Type field */
430 struct str2init *s2i;
431 CI ci = &ct->c_ctinfo;
432
433 /* Check if we've already seen a Content-Type header */
434 if (ct->c_ctline) {
435 inform("message %s has multiple %s: fields",
436 ct->c_file, TYPE_FIELD);
437 goto next_header;
438 }
439
440 /* Parse the Content-Type field */
441 if (get_ctinfo (hp->value, ct, 0) == NOTOK)
442 goto out;
443
444 /*
445 * Set the Init function and the internal
446 * flag for this content type.
447 */
448 for (s2i = str2cts; s2i->si_key; s2i++)
449 if (!strcasecmp (ci->ci_type, s2i->si_key))
450 break;
451 if (!s2i->si_key && !uprf (ci->ci_type, "X-"))
452 s2i++;
453 ct->c_type = s2i->si_val;
454 ct->c_ctinitfnx = s2i->si_init;
455 }
456 else if (!strcasecmp (hp->name, ENCODING_FIELD)) {
457 /* Get Content-Transfer-Encoding field */
458 char c, *cp, *dp;
459 struct str2init *s2i;
460
461 /*
462 * Check if we've already seen the
463 * Content-Transfer-Encoding field
464 */
465 if (ct->c_celine) {
466 inform("message %s has multiple %s: fields",
467 ct->c_file, ENCODING_FIELD);
468 goto next_header;
469 }
470
471 /* get copy of this field */
472 ct->c_celine = cp = add (hp->value, NULL);
473
474 while (isspace ((unsigned char) *cp))
475 cp++;
476 for (dp = cp; istoken (*dp); dp++)
477 continue;
478 c = *dp;
479 *dp = '\0';
480
481 /*
482 * Find the internal flag and Init function
483 * for this transfer encoding.
484 */
485 for (s2i = str2ces; s2i->si_key; s2i++)
486 if (!strcasecmp (cp, s2i->si_key))
487 break;
488 if (!s2i->si_key && !uprf (cp, "X-"))
489 s2i++;
490 *dp = c;
491 ct->c_encoding = s2i->si_val;
492
493 /* Call the Init function for this encoding */
494 if (s2i->si_init && (*s2i->si_init) (ct) == NOTOK)
495 goto out;
496 }
497 else if (!strcasecmp (hp->name, MD5_FIELD)) {
498 /* Get Content-MD5 field */
499 char *cp, *dp, *ep;
500
501 if (!checksw)
502 goto next_header;
503
504 if (ct->c_digested) {
505 inform("message %s has multiple %s: fields",
506 ct->c_file, MD5_FIELD);
507 goto next_header;
508 }
509
510 ep = cp = add (hp->value, NULL); /* get a copy */
511
512 while (isspace ((unsigned char) *cp))
513 cp++;
514 for (dp = strchr(cp, '\n'); dp; dp = strchr(dp, '\n'))
515 *dp++ = ' ';
516 for (dp = cp + strlen (cp) - 1; dp >= cp; dp--)
517 if (!isspace ((unsigned char) *dp))
518 break;
519 *++dp = '\0';
520 if (debugsw)
521 fprintf (stderr, "%s: %s\n", MD5_FIELD, cp);
522
523 if (*cp == '(' &&
524 get_comment (ct->c_file, MD5_FIELD, &cp, NULL) == NOTOK) {
525 free (ep);
526 goto out;
527 }
528
529 for (dp = cp; *dp && !isspace ((unsigned char) *dp); dp++)
530 continue;
531 *dp = '\0';
532
533 readDigest (ct, cp);
534 free (ep);
535 ct->c_digested++;
536 }
537 else if (!strcasecmp (hp->name, ID_FIELD)) {
538 /* Get Content-ID field */
539 ct->c_id = add (hp->value, ct->c_id);
540 }
541 else if (!strcasecmp (hp->name, DESCR_FIELD)) {
542 /* Get Content-Description field */
543 ct->c_descr = add (hp->value, ct->c_descr);
544 }
545 else if (!strcasecmp (hp->name, DISPO_FIELD)) {
546 /* Get Content-Disposition field */
547 if (get_dispo(hp->value, ct, 0) == NOTOK)
548 goto out;
549 }
550
551 next_header:
552 hp = hp->next; /* next header field */
553 }
554
555 /*
556 * Check if we saw a Content-Type field.
557 * If not, then assign a default value for
558 * it, and the Init function.
559 */
560 if (!ct->c_ctline) {
561 /*
562 * If we are inside a multipart/digest message,
563 * so default type is message/rfc822
564 */
565 if (toplevel < 0) {
566 if (get_ctinfo ("message/rfc822", ct, 0) == NOTOK)
567 goto out;
568 ct->c_type = CT_MESSAGE;
569 ct->c_ctinitfnx = InitMessage;
570 } else {
571 /*
572 * Else default type is text/plain
573 */
574 if (get_ctinfo ("text/plain", ct, 0) == NOTOK)
575 goto out;
576 ct->c_type = CT_TEXT;
577 ct->c_ctinitfnx = InitText;
578 }
579 }
580
581 /* Use default Transfer-Encoding, if necessary */
582 if (!ct->c_celine) {
583 ct->c_encoding = CE_7BIT;
584 Init7Bit (ct);
585 }
586
587 return ct;
588
589 out:
590 free_content (ct);
591 return NULL;
592 }
593
594
595 /*
596 * small routine to add header field to list
597 */
598
599 int
600 add_header (CT ct, char *name, char *value)
601 {
602 HF hp;
603
604 /* allocate header field structure */
605 NEW(hp);
606
607 /* link data into header structure */
608 hp->name = name;
609 hp->value = value;
610 hp->next = NULL;
611
612 /* link header structure into the list */
613 if (ct->c_first_hf == NULL) {
614 ct->c_first_hf = hp; /* this is the first */
615 ct->c_last_hf = hp;
616 } else {
617 ct->c_last_hf->next = hp; /* add it to the end */
618 ct->c_last_hf = hp;
619 }
620
621 return 0;
622 }
623
624
625 /*
626 * Parse Content-Type line and (if `magic' is non-zero) mhbuild composition
627 * directives. Fills in the information of the CTinfo structure.
628 */
629 int
630 get_ctinfo (char *cp, CT ct, int magic)
631 {
632 char *dp;
633 char c;
634 CI ci;
635 int status;
636
637 ci = &ct->c_ctinfo;
638
639 /* store copy of Content-Type line */
640 cp = ct->c_ctline = add (cp, NULL);
641
642 while (isspace ((unsigned char) *cp)) /* trim leading spaces */
643 cp++;
644
645 /* change newlines to spaces */
646 for (dp = strchr(cp, '\n'); dp; dp = strchr(dp, '\n'))
647 *dp++ = ' ';
648
649 /* trim trailing spaces */
650 for (dp = cp + strlen (cp) - 1; dp >= cp; dp--)
651 if (!isspace ((unsigned char) *dp))
652 break;
653 *++dp = '\0';
654
655 if (debugsw)
656 fprintf (stderr, "%s: %s\n", TYPE_FIELD, cp);
657
658 if (*cp == '(' && get_comment (ct->c_file, TYPE_FIELD, &cp,
659 &ci->ci_comment) == NOTOK)
660 return NOTOK;
661
662 for (dp = cp; istoken (*dp); dp++)
663 continue;
664 c = *dp, *dp = '\0';
665 ci->ci_type = mh_xstrdup(cp); /* store content type */
666 *dp = c, cp = dp;
667
668 if (!*ci->ci_type) {
669 inform("invalid %s: field in message %s (empty type)",
670 TYPE_FIELD, ct->c_file);
671 return NOTOK;
672 }
673 to_lower(ci->ci_type);
674
675 while (isspace ((unsigned char) *cp))
676 cp++;
677
678 if (*cp == '(' && get_comment (ct->c_file, TYPE_FIELD, &cp,
679 &ci->ci_comment) == NOTOK)
680 return NOTOK;
681
682 if (*cp != '/') {
683 if (!magic)
684 ci->ci_subtype = mh_xstrdup("");
685 goto magic_skip;
686 }
687
688 cp++;
689 while (isspace ((unsigned char) *cp))
690 cp++;
691
692 if (*cp == '(' && get_comment (ct->c_file, TYPE_FIELD, &cp,
693 &ci->ci_comment) == NOTOK)
694 return NOTOK;
695
696 for (dp = cp; istoken (*dp); dp++)
697 continue;
698 c = *dp, *dp = '\0';
699 ci->ci_subtype = mh_xstrdup(cp); /* store the content subtype */
700 *dp = c, cp = dp;
701
702 if (!*ci->ci_subtype) {
703 inform("invalid %s: field in message %s (empty subtype for \"%s\")",
704 TYPE_FIELD, ct->c_file, ci->ci_type);
705 return NOTOK;
706 }
707 to_lower(ci->ci_subtype);
708
709 magic_skip:
710 while (isspace ((unsigned char) *cp))
711 cp++;
712
713 if (*cp == '(' && get_comment (ct->c_file, TYPE_FIELD, &cp,
714 &ci->ci_comment) == NOTOK)
715 return NOTOK;
716
717 if ((status = parse_header_attrs (ct->c_file, TYPE_FIELD, &cp,
718 &ci->ci_first_pm, &ci->ci_last_pm,
719 &ci->ci_comment)) != OK) {
720 return status == NOTOK ? NOTOK : OK;
721 }
722
723 /*
724 * Get any <Content-Id> given in buffer
725 */
726 if (magic && *cp == '<') {
727 mh_xfree(ct->c_id);
728 ct->c_id = NULL;
729 if (!(dp = strchr(ct->c_id = ++cp, '>'))) {
730 inform("invalid ID in message %s", ct->c_file);
731 return NOTOK;
732 }
733 c = *dp;
734 *dp = '\0';
735 if (*ct->c_id)
736 ct->c_id = concat ("<", ct->c_id, ">\n", NULL);
737 else
738 ct->c_id = NULL;
739 *dp++ = c;
740 cp = dp;
741
742 while (isspace ((unsigned char) *cp))
743 cp++;
744 }
745
746 /*
747 * Get any [Content-Description] given in buffer.
748 */
749 if (magic && *cp == '[') {
750 ct->c_descr = ++cp;
751 for (dp = cp + strlen (cp) - 1; dp >= cp; dp--)
752 if (*dp == ']')
753 break;
754 if (dp < cp) {
755 inform("invalid description in message %s", ct->c_file);
756 ct->c_descr = NULL;
757 return NOTOK;
758 }
759
760 c = *dp;
761 *dp = '\0';
762 if (*ct->c_descr)
763 ct->c_descr = concat (ct->c_descr, "\n", NULL);
764 else
765 ct->c_descr = NULL;
766 *dp++ = c;
767 cp = dp;
768
769 while (isspace ((unsigned char) *cp))
770 cp++;
771 }
772
773 /*
774 * Get any {Content-Disposition} given in buffer.
775 */
776 if (magic && *cp == '{') {
777 ++cp;
778 for (dp = cp + strlen (cp) - 1; dp >= cp; dp--)
779 if (*dp == '}')
780 break;
781 if (dp < cp) {
782 inform("invalid disposition in message %s", ct->c_file);
783 ct->c_dispo = NULL;
784 return NOTOK;
785 }
786
787 c = *dp;
788 *dp = '\0';
789
790 if (get_dispo(cp, ct, 1) != OK)
791 return NOTOK;
792
793 *dp++ = c;
794 cp = dp;
795
796 while (isspace ((unsigned char) *cp))
797 cp++;
798 }
799
800 /*
801 * Get any extension directives (right now just the content transfer
802 * encoding, but maybe others) that we care about.
803 */
804
805 if (magic && *cp == '*') {
806 /*
807 * See if it's a CTE we match on
808 */
809 struct k2v *kv;
810
811 dp = ++cp;
812 while (*cp != '\0' && ! isspace((unsigned char) *cp))
813 cp++;
814
815 if (dp == cp) {
816 inform("invalid null transfer encoding specification");
817 return NOTOK;
818 }
819
820 if (*cp != '\0')
821 *cp++ = '\0';
822
823 ct->c_reqencoding = CE_UNKNOWN;
824
825 for (kv = EncodingType; kv->kv_key; kv++) {
826 if (strcasecmp(kv->kv_key, dp) == 0) {
827 ct->c_reqencoding = kv->kv_value;
828 break;
829 }
830 }
831
832 if (ct->c_reqencoding == CE_UNKNOWN) {
833 inform("invalid CTE specification: \"%s\"", dp);
834 return NOTOK;
835 }
836
837 while (isspace ((unsigned char) *cp))
838 cp++;
839 }
840
841 /*
842 * Check if anything is left over
843 */
844 if (*cp) {
845 if (magic) {
846 ci->ci_magic = mh_xstrdup(cp);
847
848 /* If there is a Content-Disposition header and it doesn't
849 have a *filename=, extract it from the magic contents.
850 The r1bindex call skips any leading directory
851 components. */
852 if (ct->c_dispo_type &&
853 !get_param(ct->c_dispo_first, "filename", '_', 1)) {
854 add_param(&ct->c_dispo_first, &ct->c_dispo_last, "filename",
855 r1bindex(ci->ci_magic, '/'), 0);
856 }
857 }
858 else
859 inform("extraneous information in message %s's %s: field\n%*s(%s)",
860 ct->c_file, TYPE_FIELD, strlen(invo_name) + 2, "", cp);
861 }
862
863 return OK;
864 }
865
866
867 /*
868 * Parse out a Content-Disposition header. A lot of this is cribbed from
869 * get_ctinfo().
870 */
871 static int
872 get_dispo (char *cp, CT ct, int buildflag)
873 {
874 char *dp, *dispoheader;
875 char c;
876 int status;
877
878 /*
879 * Save the whole copy of the Content-Disposition header, unless we're
880 * processing a mhbuild directive. A NULL c_dispo will be a flag to
881 * mhbuild that the disposition header needs to be generated at that
882 * time.
883 */
884
885 dispoheader = cp = add(cp, NULL);
886
887 while (isspace ((unsigned char) *cp)) /* trim leading spaces */
888 cp++;
889
890 /* change newlines to spaces */
891 for (dp = strchr(cp, '\n'); dp; dp = strchr(dp, '\n'))
892 *dp++ = ' ';
893
894 /* trim trailing spaces */
895 for (dp = cp + strlen (cp) - 1; dp >= cp; dp--)
896 if (!isspace ((unsigned char) *dp))
897 break;
898 *++dp = '\0';
899
900 if (debugsw)
901 fprintf (stderr, "%s: %s\n", DISPO_FIELD, cp);
902
903 if (*cp == '(' && get_comment (ct->c_file, DISPO_FIELD, &cp, NULL) ==
904 NOTOK) {
905 free(dispoheader);
906 return NOTOK;
907 }
908
909 for (dp = cp; istoken (*dp); dp++)
910 continue;
911 c = *dp, *dp = '\0';
912 ct->c_dispo_type = mh_xstrdup(cp); /* store disposition type */
913 *dp = c, cp = dp;
914
915 if (*cp == '(' && get_comment (ct->c_file, DISPO_FIELD, &cp, NULL) == NOTOK)
916 return NOTOK;
917
918 if ((status = parse_header_attrs (ct->c_file, DISPO_FIELD, &cp,
919 &ct->c_dispo_first, &ct->c_dispo_last,
920 NULL)) != OK) {
921 if (status == NOTOK) {
922 free(dispoheader);
923 return NOTOK;
924 }
925 } else if (*cp) {
926 inform("extraneous information in message %s's %s: field\n%*s(%s)",
927 ct->c_file, DISPO_FIELD, strlen(invo_name) + 2, "", cp);
928 }
929
930 if (buildflag)
931 free(dispoheader);
932 else
933 ct->c_dispo = dispoheader;
934
935 return OK;
936 }
937
938
939 static int
940 get_comment (const char *filename, const char *fieldname, char **ap,
941 char **commentp)
942 {
943 int i;
944 char *bp, *cp;
945 char c, buffer[BUFSIZ], *dp;
946
947 cp = *ap;
948 bp = buffer;
949 cp++;
950
951 for (i = 0;;) {
952 switch (c = *cp++) {
953 case '\0':
954 invalid:
955 inform("invalid comment in message %s's %s: field",
956 filename, fieldname);
957 return NOTOK;
958
959 case '\\':
960 *bp++ = c;
961 if ((c = *cp++) == '\0')
962 goto invalid;
963 *bp++ = c;
964 continue;
965
966 case '(':
967 i++;
968 /* FALLTHRU */
969 default:
970 *bp++ = c;
971 continue;
972
973 case ')':
974 if (--i < 0)
975 break;
976 *bp++ = c;
977 continue;
978 }
979 break;
980 }
981 *bp = '\0';
982
983 if (commentp) {
984 if ((dp = *commentp)) {
985 *commentp = concat (dp, " ", buffer, NULL);
986 free (dp);
987 } else {
988 *commentp = mh_xstrdup(buffer);
989 }
990 }
991
992 while (isspace ((unsigned char) *cp))
993 cp++;
994
995 *ap = cp;
996 return OK;
997 }
998
999
1000 /*
1001 * CONTENTS
1002 *
1003 * Handles content types audio, image, and video.
1004 * There's not much to do right here.
1005 */
1006
1007 static int
1008 InitGeneric (CT ct)
1009 {
1010 NMH_UNUSED (ct);
1011
1012 return OK; /* not much to do here */
1013 }
1014
1015
1016 /*
1017 * TEXT
1018 */
1019
1020 static int
1021 InitText (CT ct)
1022 {
1023 char buffer[BUFSIZ];
1024 char *chset = NULL;
1025 char *cp;
1026 PM pm;
1027 struct text *t;
1028 CI ci = &ct->c_ctinfo;
1029
1030 /* check for missing subtype */
1031 if (!*ci->ci_subtype)
1032 ci->ci_subtype = add ("plain", ci->ci_subtype);
1033
1034 /* match subtype */
1035 ct->c_subtype = ct_str_subtype (CT_TEXT, ci->ci_subtype);
1036
1037 /* allocate text character set structure */
1038 NEW0(t);
1039 ct->c_ctparams = (void *) t;
1040
1041 /* scan for charset parameter */
1042 for (pm = ci->ci_first_pm; pm; pm = pm->pm_next)
1043 if (!strcasecmp (pm->pm_name, "charset"))
1044 break;
1045
1046 /* check if content specified a character set */
1047 if (pm) {
1048 chset = pm->pm_value;
1049 t->tx_charset = CHARSET_SPECIFIED;
1050 } else {
1051 t->tx_charset = CHARSET_UNSPECIFIED;
1052 }
1053
1054 /*
1055 * If we can not handle character set natively,
1056 * then check profile for string to modify the
1057 * terminal or display method.
1058 *
1059 * termproc is for mhshow, though mhlist -debug prints it, too.
1060 */
1061 if (chset != NULL && !check_charset (chset, strlen (chset))) {
1062 snprintf (buffer, sizeof(buffer), "%s-charset-%s", invo_name, chset);
1063 if ((cp = context_find (buffer)))
1064 ct->c_termproc = mh_xstrdup(cp);
1065 }
1066
1067 return OK;
1068 }
1069
1070
1071 /*
1072 * MULTIPART
1073 */
1074
1075 static int
1076 InitMultiPart (CT ct)
1077 {
1078 int inout;
1079 long last, pos;
1080 char *cp, *dp;
1081 PM pm;
1082 char *bp;
1083 char *bufp = NULL;
1084 size_t buflen;
1085 ssize_t gotlen;
1086 struct multipart *m;
1087 struct part *part, **next;
1088 CI ci = &ct->c_ctinfo;
1089 CT p;
1090 FILE *fp;
1091
1092 /*
1093 * The encoding for multipart messages must be either
1094 * 7bit, 8bit, or binary (per RFC2045).
1095 */
1096 if (! skip_mp_cte_check && ct->c_encoding != CE_7BIT &&
1097 ct->c_encoding != CE_8BIT && ct->c_encoding != CE_BINARY) {
1098 /* Copy the Content-Transfer-Encoding header field body so we can
1099 remove any trailing whitespace and leading blanks from it. */
1100 char *cte = mh_xstrdup(ct->c_celine ? ct->c_celine : "(null)");
1101
1102 bp = cte + strlen (cte) - 1;
1103 while (bp >= cte && isspace ((unsigned char) *bp)) *bp-- = '\0';
1104 for (bp = cte; *bp && isblank ((unsigned char) *bp); ++bp) continue;
1105
1106 admonish (NULL,
1107 "\"%s/%s\" type in message %s must be encoded in\n"
1108 "7bit, 8bit, or binary, per RFC 2045 (6.4). "
1109 "mhfixmsg -fixcte can fix it, or\n"
1110 "manually edit the file and change the \"%s\"\n"
1111 "Content-Transfer-Encoding to one of those. For now",
1112 ci->ci_type, ci->ci_subtype, ct->c_file, bp);
1113 free (cte);
1114
1115 return NOTOK;
1116 }
1117
1118 /* match subtype */
1119 ct->c_subtype = ct_str_subtype (CT_MULTIPART, ci->ci_subtype);
1120
1121 /*
1122 * Check for "boundary" parameter, which is
1123 * required for multipart messages.
1124 */
1125 bp = 0;
1126 for (pm = ci->ci_first_pm; pm; pm = pm->pm_next) {
1127 if (!strcasecmp (pm->pm_name, "boundary")) {
1128 bp = pm->pm_value;
1129 break;
1130 }
1131 }
1132
1133 /* complain if boundary parameter is missing */
1134 if (!pm) {
1135 inform("a \"boundary\" parameter is mandatory for \"%s/%s\" type in message %s's %s: field",
1136 ci->ci_type, ci->ci_subtype, ct->c_file, TYPE_FIELD);
1137 return NOTOK;
1138 }
1139
1140 /* allocate primary structure for multipart info */
1141 NEW0(m);
1142 ct->c_ctparams = (void *) m;
1143
1144 /* check if boundary parameter contains only whitespace characters */
1145 for (cp = bp; isspace ((unsigned char) *cp); cp++)
1146 continue;
1147 if (!*cp) {
1148 inform("invalid \"boundary\" parameter for \"%s/%s\" type in message %s's %s: field",
1149 ci->ci_type, ci->ci_subtype, ct->c_file, TYPE_FIELD);
1150 return NOTOK;
1151 }
1152
1153 /* remove trailing whitespace from boundary parameter */
1154 for (cp = bp, dp = cp + strlen (cp) - 1; dp > cp; dp--)
1155 if (!isspace ((unsigned char) *dp))
1156 break;
1157 *++dp = '\0';
1158
1159 /* record boundary separators */
1160 m->mp_start = concat (bp, "\n", NULL);
1161 m->mp_stop = concat (bp, "--\n", NULL);
1162
1163 if (!ct->c_fp && (ct->c_fp = fopen (ct->c_file, "r")) == NULL) {
1164 advise (ct->c_file, "unable to open for reading");
1165 return NOTOK;
1166 }
1167
1168 fseek (fp = ct->c_fp, pos = ct->c_begin, SEEK_SET);
1169 last = ct->c_end;
1170 next = &m->mp_parts;
1171 part = NULL;
1172 inout = 1;
1173
1174 while ((gotlen = getline(&bufp, &buflen, fp)) != -1) {
1175 if (pos > last)
1176 break;
1177
1178 pos += gotlen;
1179 if (bufp[0] != '-' || bufp[1] != '-')
1180 continue;
1181 if (inout) {
1182 if (strcmp (bufp + 2, m->mp_start))
1183 continue;
1184 next_part:
1185 NEW0(part);
1186 *next = part;
1187 next = &part->mp_next;
1188
1189 if (!(p = get_content (fp, ct->c_file,
1190 ct->c_subtype == MULTI_DIGEST ? -1 : 0))) {
1191 free(bufp);
1192 ct->c_fp = NULL;
1193 return NOTOK;
1194 }
1195 p->c_fp = NULL;
1196 part->mp_part = p;
1197 pos = p->c_begin;
1198 fseek (fp, pos, SEEK_SET);
1199 inout = 0;
1200 } else {
1201 if (strcmp (bufp + 2, m->mp_start) == 0) {
1202 inout = 1;
1203 end_part:
1204 p = part->mp_part;
1205 p->c_end = ftell(fp) - (gotlen + 1);
1206 if (p->c_end < p->c_begin)
1207 p->c_begin = p->c_end;
1208 if (inout)
1209 goto next_part;
1210 goto last_part;
1211 }
1212 if (strcmp (bufp + 2, m->mp_stop) == 0)
1213 goto end_part;
1214 }
1215 }
1216
1217 if (! suppress_bogus_mp_content_warning) {
1218 inform("bogus multipart content in message %s", ct->c_file);
1219 }
1220 bogus_mp_content = 1;
1221
1222 if (!inout && part) {
1223 p = part->mp_part;
1224 p->c_end = ct->c_end;
1225
1226 if (p->c_begin >= p->c_end) {
1227 for (next = &m->mp_parts; *next != part;
1228 next = &((*next)->mp_next))
1229 continue;
1230 *next = NULL;
1231 free_content (p);
1232 free(part);
1233 }
1234 }
1235
1236 last_part:
1237 /* reverse the order of the parts for multipart/alternative */
1238 if (ct->c_subtype == MULTI_ALTERNATE) {
1239 reverse_parts (ct);
1240 prefer_parts (ct);
1241 }
1242
1243 /*
1244 * label all subparts with part number, and
1245 * then initialize the content of the subpart.
1246 */
1247 {
1248 int partnum;
1249 char *pp;
1250 char partnam[BUFSIZ];
1251
1252 if (ct->c_partno) {
1253 snprintf (partnam, sizeof(partnam), "%s.", ct->c_partno);
1254 pp = partnam + strlen (partnam);
1255 } else {
1256 pp = partnam;
1257 }
1258
1259 for (part = m->mp_parts, partnum = 1; part;
1260 part = part->mp_next, partnum++) {
1261 p = part->mp_part;
1262
1263 sprintf (pp, "%d", partnum);
1264 p->c_partno = mh_xstrdup(partnam);
1265
1266 /* initialize the content of the subparts */
1267 if (p->c_ctinitfnx && (*p->c_ctinitfnx) (p) == NOTOK) {
1268 free(bufp);
1269 fclose (ct->c_fp);
1270 ct->c_fp = NULL;
1271 return NOTOK;
1272 }
1273 }
1274 }
1275
1276 get_leftover_mp_content (ct, 1);
1277 get_leftover_mp_content (ct, 0);
1278
1279 free(bufp);
1280 fclose (ct->c_fp);
1281 ct->c_fp = NULL;
1282 return OK;
1283 }
1284
1285
1286 /*
1287 * reverse the order of the parts of a multipart/alternative,
1288 * presumably to put the "most favored" alternative first, for
1289 * ease of choosing/displaying it later on. from a mail message on
1290 * nmh-workers, from kenh:
1291 * "Stock" MH 6.8.5 did not have a reverse_parts() function, but I
1292 * see code in mhn that did the same thing... Acccording to the RCS
1293 * logs, that code was around from the initial checkin of mhn.c by
1294 * John Romine in 1992, which is as far back as we have."
1295 */
1296 static void
1297 reverse_parts (CT ct)
1298 {
1299 struct multipart *m = (struct multipart *) ct->c_ctparams;
1300 struct part *part;
1301 struct part *next;
1302
1303 /* Reverse the order of its parts by walking the mp_parts list
1304 and pushing each node to the front. */
1305 for (part = m->mp_parts, m->mp_parts = NULL; part; part = next) {
1306 next = part->mp_next;
1307 part->mp_next = m->mp_parts;
1308 m->mp_parts = part;
1309 }
1310 }
1311
1312 static void
1313 move_preferred_part (CT ct, char *type, char *subtype)
1314 {
1315 struct multipart *m = (struct multipart *) ct->c_ctparams;
1316 struct part *part, *prev, *head, *nhead, *ntail;
1317 struct part h, n;
1318 CI ci;
1319
1320 /* move the matching part(s) to the head of the list: walk the
1321 * list of parts, move matching parts to a new list (maintaining
1322 * their order), and finally, concatenate the old list onto the
1323 * new.
1324 */
1325
1326 head = &h;
1327 nhead = &n;
1328
1329 head->mp_next = m->mp_parts;
1330 nhead->mp_next = NULL;
1331 ntail = nhead;
1332
1333 prev = head;
1334 part = head->mp_next;
1335 while (part != NULL) {
1336 ci = &part->mp_part->c_ctinfo;
1337 if (!strcasecmp(ci->ci_type, type) &&
1338 (!subtype || !strcasecmp(ci->ci_subtype, subtype))) {
1339 prev->mp_next = part->mp_next;
1340 part->mp_next = NULL;
1341 ntail->mp_next = part;
1342 ntail = part;
1343 part = prev->mp_next;
1344 } else {
1345 prev = part;
1346 part = prev->mp_next;
1347 }
1348 }
1349 ntail->mp_next = head->mp_next;
1350 m->mp_parts = nhead->mp_next;
1351
1352 }
1353
1354 /*
1355 * move parts that match the user's preferences (-prefer) to the head
1356 * of the line. process preferences in reverse so first one given
1357 * ends up first in line
1358 */
1359 static void
1360 prefer_parts(CT ct)
1361 {
1362 int i;
1363 for (i = npreferred-1; i >= 0; i--)
1364 move_preferred_part(ct, preferred_types[i], preferred_subtypes[i]);
1365 }
1366
1367
1368
1369 /* parse_mime() arranges alternates in reverse (priority) order. This
1370 function can be used to reverse them back. This will put, for
1371 example, a text/plain part before a text/html part in a
1372 multipart/alternative part, for example, where it belongs. */
1373 void
1374 reverse_alternative_parts (CT ct) {
1375 if (ct->c_type == CT_MULTIPART) {
1376 struct multipart *m = (struct multipart *) ct->c_ctparams;
1377 struct part *part;
1378
1379 if (ct->c_subtype == MULTI_ALTERNATE) {
1380 reverse_parts (ct);
1381 }
1382
1383 /* And call recursively on each part of a multipart. */
1384 for (part = m->mp_parts; part; part = part->mp_next) {
1385 reverse_alternative_parts (part->mp_part);
1386 }
1387 }
1388 }
1389
1390
1391 /*
1392 * MESSAGE
1393 */
1394
1395 static int
1396 InitMessage (CT ct)
1397 {
1398 CI ci = &ct->c_ctinfo;
1399
1400 if ((ct->c_encoding != CE_7BIT) && (ct->c_encoding != CE_8BIT)) {
1401 admonish (NULL,
1402 "\"%s/%s\" type in message %s should be encoded in 7bit or 8bit",
1403 ci->ci_type, ci->ci_subtype, ct->c_file);
1404 return NOTOK;
1405 }
1406
1407 /* check for missing subtype */
1408 if (!*ci->ci_subtype)
1409 ci->ci_subtype = add ("rfc822", ci->ci_subtype);
1410
1411 /* match subtype */
1412 ct->c_subtype = ct_str_subtype (CT_MESSAGE, ci->ci_subtype);
1413
1414 switch (ct->c_subtype) {
1415 case MESSAGE_RFC822:
1416 break;
1417
1418 case MESSAGE_PARTIAL:
1419 {
1420 PM pm;
1421 struct partial *p;
1422
1423 NEW0(p);
1424 ct->c_ctparams = (void *) p;
1425
1426 /* scan for parameters "id", "number", and "total" */
1427 for (pm = ci->ci_first_pm; pm; pm = pm->pm_next) {
1428 if (!strcasecmp (pm->pm_name, "id")) {
1429 p->pm_partid = add (pm->pm_value, NULL);
1430 continue;
1431 }
1432 if (!strcasecmp (pm->pm_name, "number")) {
1433 if (sscanf (pm->pm_value, "%d", &p->pm_partno) != 1
1434 || p->pm_partno < 1) {
1435 invalid_param:
1436 inform("invalid %s parameter for \"%s/%s\" type in message %s's %s field",
1437 pm->pm_name, ci->ci_type, ci->ci_subtype,
1438 ct->c_file, TYPE_FIELD);
1439 return NOTOK;
1440 }
1441 continue;
1442 }
1443 if (!strcasecmp (pm->pm_name, "total")) {
1444 if (sscanf (pm->pm_value, "%d", &p->pm_maxno) != 1
1445 || p->pm_maxno < 1)
1446 goto invalid_param;
1447 continue;
1448 }
1449 }
1450
1451 if (!p->pm_partid
1452 || !p->pm_partno
1453 || (p->pm_maxno && p->pm_partno > p->pm_maxno)) {
1454 inform("invalid parameters for \"%s/%s\" type in message %s's %s field",
1455 ci->ci_type, ci->ci_subtype, ct->c_file, TYPE_FIELD);
1456 return NOTOK;
1457 }
1458 }
1459 break;
1460
1461 case MESSAGE_EXTERNAL:
1462 {
1463 int exresult;
1464 struct exbody *e;
1465 CT p;
1466 FILE *fp;
1467
1468 NEW0(e);
1469 ct->c_ctparams = (void *) e;
1470
1471 if (!ct->c_fp
1472 && (ct->c_fp = fopen (ct->c_file, "r")) == NULL) {
1473 advise (ct->c_file, "unable to open for reading");
1474 return NOTOK;
1475 }
1476
1477 fseek (fp = ct->c_fp, ct->c_begin, SEEK_SET);
1478
1479 if (!(p = get_content (fp, ct->c_file, 0))) {
1480 ct->c_fp = NULL;
1481 return NOTOK;
1482 }
1483
1484 e->eb_parent = ct;
1485 e->eb_content = p;
1486 p->c_ctexbody = e;
1487 p->c_ceopenfnx = NULL;
1488 if ((exresult = params_external (ct, 0)) != NOTOK
1489 && p->c_ceopenfnx == openMail) {
1490 int cc, size;
1491 char *bp;
1492
1493 if ((size = ct->c_end - p->c_begin) <= 0) {
1494 if (!e->eb_subject)
1495 content_error (NULL, ct,
1496 "empty body for access-type=mail-server");
1497 goto no_body;
1498 }
1499
1500 e->eb_body = bp = mh_xmalloc ((unsigned) size);
1501 fseek (p->c_fp, p->c_begin, SEEK_SET);
1502 while (size > 0)
1503 switch (cc = fread (bp, sizeof(*bp), size, p->c_fp)) {
1504 case NOTOK:
1505 adios ("failed", "fread");
1506
1507 case OK:
1508 adios (NULL, "unexpected EOF from fread");
1509
1510 default:
1511 bp += cc, size -= cc;
1512 break;
1513 }
1514 *bp = 0;
1515 }
1516 no_body:
1517 p->c_fp = NULL;
1518 p->c_end = p->c_begin;
1519
1520 fclose (ct->c_fp);
1521 ct->c_fp = NULL;
1522
1523 if (exresult == NOTOK)
1524 return NOTOK;
1525 if (e->eb_flags == NOTOK)
1526 return OK;
1527
1528 switch (p->c_type) {
1529 case CT_MULTIPART:
1530 break;
1531
1532 case CT_MESSAGE:
1533 if (p->c_subtype != MESSAGE_RFC822)
1534 break;
1535 /* FALLTHRU */
1536 default:
1537 e->eb_partno = ct->c_partno;
1538 if (p->c_ctinitfnx)
1539 (*p->c_ctinitfnx) (p);
1540 break;
1541 }
1542 }
1543 break;
1544
1545 default:
1546 break;
1547 }
1548
1549 return OK;
1550 }
1551
1552
1553 int
1554 params_external (CT ct, int composing)
1555 {
1556 PM pm;
1557 struct exbody *e = (struct exbody *) ct->c_ctparams;
1558 CI ci = &ct->c_ctinfo;
1559
1560 ct->c_ceopenfnx = NULL;
1561 for (pm = ci->ci_first_pm; pm; pm = pm->pm_next) {
1562 if (!strcasecmp (pm->pm_name, "access-type")) {
1563 struct str2init *s2i;
1564 CT p = e->eb_content;
1565
1566 for (s2i = str2methods; s2i->si_key; s2i++)
1567 if (!strcasecmp (pm->pm_value, s2i->si_key))
1568 break;
1569 if (!s2i->si_key) {
1570 e->eb_access = pm->pm_value;
1571 e->eb_flags = NOTOK;
1572 p->c_encoding = CE_EXTERNAL;
1573 continue;
1574 }
1575 e->eb_access = s2i->si_key;
1576 e->eb_flags = s2i->si_val;
1577 p->c_encoding = CE_EXTERNAL;
1578
1579 /* Call the Init function for this external type */
1580 if ((*s2i->si_init)(p) == NOTOK)
1581 return NOTOK;
1582 continue;
1583 }
1584 if (!strcasecmp (pm->pm_name, "name")) {
1585 e->eb_name = pm->pm_value;
1586 continue;
1587 }
1588 if (!strcasecmp (pm->pm_name, "permission")) {
1589 e->eb_permission = pm->pm_value;
1590 continue;
1591 }
1592 if (!strcasecmp (pm->pm_name, "site")) {
1593 e->eb_site = pm->pm_value;
1594 continue;
1595 }
1596 if (!strcasecmp (pm->pm_name, "directory")) {
1597 e->eb_dir = pm->pm_value;
1598 continue;
1599 }
1600 if (!strcasecmp (pm->pm_name, "mode")) {
1601 e->eb_mode = pm->pm_value;
1602 continue;
1603 }
1604 if (!strcasecmp (pm->pm_name, "size")) {
1605 sscanf (pm->pm_value, "%lu", &e->eb_size);
1606 continue;
1607 }
1608 if (!strcasecmp (pm->pm_name, "server")) {
1609 e->eb_server = pm->pm_value;
1610 continue;
1611 }
1612 if (!strcasecmp (pm->pm_name, "subject")) {
1613 e->eb_subject = pm->pm_value;
1614 continue;
1615 }
1616 if (!strcasecmp (pm->pm_name, "url")) {
1617 /*
1618 * According to RFC 2017, we have to remove all whitespace from
1619 * the URL
1620 */
1621
1622 char *u, *p = pm->pm_value;
1623 e->eb_url = u = mh_xmalloc(strlen(pm->pm_value) + 1);
1624
1625 for (; *p != '\0'; p++) {
1626 if (! isspace((unsigned char) *p))
1627 *u++ = *p;
1628 }
1629
1630 *u = '\0';
1631 continue;
1632 }
1633 if (composing && !strcasecmp (pm->pm_name, "body")) {
1634 e->eb_body = getcpy (pm->pm_value);
1635 continue;
1636 }
1637 }
1638
1639 if (!e->eb_access) {
1640 inform("invalid parameters for \"%s/%s\" type in message %s's %s field",
1641 ci->ci_type, ci->ci_subtype, ct->c_file, TYPE_FIELD);
1642 return NOTOK;
1643 }
1644
1645 return OK;
1646 }
1647
1648
1649 /*
1650 * APPLICATION
1651 */
1652
1653 static int
1654 InitApplication (CT ct)
1655 {
1656 CI ci = &ct->c_ctinfo;
1657
1658 /* match subtype */
1659 ct->c_subtype = ct_str_subtype (CT_APPLICATION, ci->ci_subtype);
1660
1661 return OK;
1662 }
1663
1664
1665 /*
1666 * TRANSFER ENCODINGS
1667 */
1668
1669 static int
1670 init_encoding (CT ct, OpenCEFunc openfnx)
1671 {
1672 ct->c_ceopenfnx = openfnx;
1673 ct->c_ceclosefnx = close_encoding;
1674 ct->c_cesizefnx = size_encoding;
1675
1676 return OK;
1677 }
1678
1679
1680 void
1681 close_encoding (CT ct)
1682 {
1683 CE ce = &ct->c_cefile;
1684
1685 if (ce->ce_fp) {
1686 fclose (ce->ce_fp);
1687 ce->ce_fp = NULL;
1688 }
1689 }
1690
1691
1692 static unsigned long
1693 size_encoding (CT ct)
1694 {
1695 int fd;
1696 unsigned long size;
1697 char *file;
1698 CE ce = &ct->c_cefile;
1699 struct stat st;
1700
1701 if (ce->ce_fp && fstat (fileno (ce->ce_fp), &st) != NOTOK)
1702 return (long) st.st_size;
1703
1704 if (ce->ce_file) {
1705 if (stat (ce->ce_file, &st) != NOTOK)
1706 return (long) st.st_size;
1707 return 0L;
1708 }
1709
1710 if (ct->c_encoding == CE_EXTERNAL)
1711 return (ct->c_end - ct->c_begin);
1712
1713 file = NULL;
1714 if ((fd = (*ct->c_ceopenfnx) (ct, &file)) == NOTOK)
1715 return (ct->c_end - ct->c_begin);
1716
1717 if (fstat (fd, &st) != NOTOK)
1718 size = (long) st.st_size;
1719 else
1720 size = 0L;
1721
1722 (*ct->c_ceclosefnx) (ct);
1723 return size;
1724 }
1725
1726
1727 /*
1728 * BASE64
1729 */
1730
1731 static int
1732 InitBase64 (CT ct)
1733 {
1734 return init_encoding (ct, openBase64);
1735 }
1736
1737
1738 static int
1739 openBase64 (CT ct, char **file)
1740 {
1741 ssize_t cc, len;
1742 int fd, own_ct_fp = 0;
1743 char *cp, *buffer = NULL;
1744 /* sbeck -- handle suffixes */
1745 CI ci;
1746 CE ce = &ct->c_cefile;
1747 unsigned char *decoded;
1748 size_t decoded_len;
1749 unsigned char digest[16];
1750
1751 if (ce->ce_fp) {
1752 fseek (ce->ce_fp, 0L, SEEK_SET);
1753 goto ready_to_go;
1754 }
1755
1756 if (ce->ce_file) {
1757 if ((ce->ce_fp = fopen (ce->ce_file, "r")) == NULL) {
1758 content_error (ce->ce_file, ct, "unable to fopen for reading");
1759 return NOTOK;
1760 }
1761 goto ready_to_go;
1762 }
1763
1764 if (*file == NULL) {
1765 ce->ce_unlink = 1;
1766 } else {
1767 ce->ce_file = mh_xstrdup(*file);
1768 ce->ce_unlink = 0;
1769 }
1770
1771 /* sbeck@cise.ufl.edu -- handle suffixes */
1772 ci = &ct->c_ctinfo;
1773 if ((cp = context_find_by_type ("suffix", ci->ci_type, ci->ci_subtype))) {
1774 if (ce->ce_unlink) {
1775 /* Create temporary file with filename extension. */
1776 if ((ce->ce_file = m_mktemps(invo_name, cp, NULL, NULL)) == NULL) {
1777 adios(NULL, "unable to create temporary file in %s",
1778 get_temp_dir());
1779 }
1780 } else {
1781 ce->ce_file = add (cp, ce->ce_file);
1782 }
1783 } else if (*file == NULL) {
1784 char *tempfile;
1785 if ((tempfile = m_mktemp2(NULL, invo_name, NULL, NULL)) == NULL) {
1786 adios(NULL, "unable to create temporary file in %s",
1787 get_temp_dir());
1788 }
1789 ce->ce_file = mh_xstrdup(tempfile);
1790 }
1791
1792 if ((ce->ce_fp = fopen (ce->ce_file, "w+")) == NULL) {
1793 content_error (ce->ce_file, ct, "unable to fopen for reading/writing");
1794 return NOTOK;
1795 }
1796
1797 if ((len = ct->c_end - ct->c_begin) < 0)
1798 adios (NULL, "internal error(1)");
1799
1800 buffer = mh_xmalloc (len + 1);
1801
1802 if (! ct->c_fp) {
1803 if ((ct->c_fp = fopen (ct->c_file, "r")) == NULL) {
1804 content_error (ct->c_file, ct, "unable to open for reading");
1805 return NOTOK;
1806 }
1807 own_ct_fp = 1;
1808 }
1809
1810 lseek (fd = fileno (ct->c_fp), (off_t) ct->c_begin, SEEK_SET);
1811 cp = buffer;
1812 while (len > 0) {
1813 switch (cc = read (fd, cp, len)) {
1814 case NOTOK:
1815 content_error (ct->c_file, ct, "error reading from");
1816 goto clean_up;
1817
1818 case OK:
1819 content_error (NULL, ct, "premature eof");
1820 goto clean_up;
1821
1822 default:
1823 if (cc > len)
1824 cc = len;
1825 len -= cc;
1826 cp += cc;
1827 }
1828 }
1829
1830 /* decodeBase64() requires null-terminated input. */
1831 *cp = '\0';
1832
1833 if (decodeBase64 (buffer, &decoded, &decoded_len, ct->c_type == CT_TEXT,
1834 ct->c_digested ? digest : NULL) == OK) {
1835 size_t i;
1836 unsigned char *decoded_p = decoded;
1837 for (i = 0; i < decoded_len; ++i) {
1838 putc (*decoded_p++, ce->ce_fp);
1839 }
1840 free(decoded);
1841 if (ferror (ce->ce_fp)) {
1842 content_error (ce->ce_file, ct, "error writing to");
1843 goto clean_up;
1844 }
1845
1846 if (ct->c_digested) {
1847 if (memcmp(digest, ct->c_digest,
1848 sizeof(digest) / sizeof(digest[0]))) {
1849 content_error (NULL, ct,
1850 "content integrity suspect (digest mismatch) -- continuing");
1851 } else {
1852 if (debugsw) {
1853 fprintf (stderr, "content integrity confirmed\n");
1854 }
1855 }
1856 }
1857 } else {
1858 goto clean_up;
1859 }
1860
1861 fseek (ct->c_fp, 0L, SEEK_SET);
1862
1863 if (fflush (ce->ce_fp)) {
1864 content_error (ce->ce_file, ct, "error writing to");
1865 goto clean_up;
1866 }
1867
1868 fseek (ce->ce_fp, 0L, SEEK_SET);
1869
1870 ready_to_go:
1871 *file = ce->ce_file;
1872 if (own_ct_fp) {
1873 fclose (ct->c_fp);
1874 ct->c_fp = NULL;
1875 }
1876 free (buffer);
1877 return fileno (ce->ce_fp);
1878
1879 clean_up:
1880 if (own_ct_fp) {
1881 fclose (ct->c_fp);
1882 ct->c_fp = NULL;
1883 }
1884 free_encoding (ct, 0);
1885 free (buffer);
1886 return NOTOK;
1887 }
1888
1889
1890 /*
1891 * QUOTED PRINTABLE
1892 */
1893
1894 static char hex2nib[0x80] = {
1895 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1896 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1897 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1898 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1899 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1900 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1901 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1902 0x08, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1903 0x00, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x00,
1904 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1905 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1906 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1907 0x00, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x00,
1908 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1909 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1910 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
1911 };
1912
1913
1914 static int
1915 InitQuoted (CT ct)
1916 {
1917 return init_encoding (ct, openQuoted);
1918 }
1919
1920
1921 static int
1922 openQuoted (CT ct, char **file)
1923 {
1924 int cc, digested, len, quoted, own_ct_fp = 0;
1925 char *cp, *ep;
1926 char *bufp = NULL;
1927 size_t buflen;
1928 ssize_t gotlen;
1929 unsigned char mask;
1930 CE ce = &ct->c_cefile;
1931 /* sbeck -- handle suffixes */
1932 CI ci;
1933 MD5_CTX mdContext;
1934
1935 if (ce->ce_fp) {
1936 fseek (ce->ce_fp, 0L, SEEK_SET);
1937 goto ready_to_go;
1938 }
1939
1940 if (ce->ce_file) {
1941 if ((ce->ce_fp = fopen (ce->ce_file, "r")) == NULL) {
1942 content_error (ce->ce_file, ct, "unable to fopen for reading");
1943 return NOTOK;
1944 }
1945 goto ready_to_go;
1946 }
1947
1948 if (*file == NULL) {
1949 ce->ce_unlink = 1;
1950 } else {
1951 ce->ce_file = mh_xstrdup(*file);
1952 ce->ce_unlink = 0;
1953 }
1954
1955 /* sbeck@cise.ufl.edu -- handle suffixes */
1956 ci = &ct->c_ctinfo;
1957 if ((cp = context_find_by_type ("suffix", ci->ci_type, ci->ci_subtype))) {
1958 if (ce->ce_unlink) {
1959 /* Create temporary file with filename extension. */
1960 if ((ce->ce_file = m_mktemps(invo_name, cp, NULL, NULL)) == NULL) {
1961 adios(NULL, "unable to create temporary file in %s",
1962 get_temp_dir());
1963 }
1964 } else {
1965 ce->ce_file = add (cp, ce->ce_file);
1966 }
1967 } else if (*file == NULL) {
1968 char *tempfile;
1969 if ((tempfile = m_mktemp2(NULL, invo_name, NULL, NULL)) == NULL) {
1970 adios(NULL, "unable to create temporary file in %s",
1971 get_temp_dir());
1972 }
1973 ce->ce_file = mh_xstrdup(tempfile);
1974 }
1975
1976 if ((ce->ce_fp = fopen (ce->ce_file, "w+")) == NULL) {
1977 content_error (ce->ce_file, ct, "unable to fopen for reading/writing");
1978 return NOTOK;
1979 }
1980
1981 if ((len = ct->c_end - ct->c_begin) < 0)
1982 adios (NULL, "internal error(2)");
1983
1984 if (! ct->c_fp) {
1985 if ((ct->c_fp = fopen (ct->c_file, "r")) == NULL) {
1986 content_error (ct->c_file, ct, "unable to open for reading");
1987 return NOTOK;
1988 }
1989 own_ct_fp = 1;
1990 }
1991
1992 if ((digested = ct->c_digested))
1993 MD5Init (&mdContext);
1994
1995 quoted = 0;
1996 #ifdef lint
1997 mask = 0;
1998 #endif
1999
2000 fseek (ct->c_fp, ct->c_begin, SEEK_SET);
2001 while (len > 0) {
2002 if ((gotlen = getline(&bufp, &buflen, ct->c_fp)) == -1) {
2003 content_error (NULL, ct, "premature eof");
2004 goto clean_up;
2005 }
2006
2007 if ((cc = gotlen) > len)
2008 cc = len;
2009 len -= cc;
2010
2011 for (ep = (cp = bufp) + cc - 1; cp <= ep; ep--)
2012 if (!isspace ((unsigned char) *ep))
2013 break;
2014 *++ep = '\n', ep++;
2015
2016 for (; cp < ep; cp++) {
2017 if (quoted > 0) {
2018 /* in an escape sequence */
2019 if (quoted == 1) {
2020 /* at byte 1 of an escape sequence */
2021 mask = hex2nib[((unsigned char) *cp) & 0x7f];
2022 /* next is byte 2 */
2023 quoted = 2;
2024 } else {
2025 /* at byte 2 of an escape sequence */
2026 mask <<= 4;
2027 mask |= hex2nib[((unsigned char) *cp) & 0x7f];
2028 putc (mask, ce->ce_fp);
2029 if (digested)
2030 MD5Update (&mdContext, &mask, 1);
2031 if (ferror (ce->ce_fp)) {
2032 content_error (ce->ce_file, ct, "error writing to");
2033 goto clean_up;
2034 }
2035 /* finished escape sequence; next may be literal or a new
2036 * escape sequence */
2037 quoted = 0;
2038 }
2039 /* on to next byte */
2040 continue;
2041 }
2042
2043 /* not in an escape sequence */
2044 if (*cp == '=') {
2045 /* starting an escape sequence, or invalid '='? */
2046 if (cp + 1 < ep && cp[1] == '\n') {
2047 /* "=\n" soft line break, eat the \n */
2048 cp++;
2049 continue;
2050 }
2051 if (cp + 1 >= ep || cp + 2 >= ep) {
2052 /* We don't have 2 bytes left, so this is an invalid
2053 * escape sequence; just show the raw bytes (below). */
2054 } else if (isxdigit ((unsigned char) cp[1]) &&
2055 isxdigit ((unsigned char) cp[2])) {
2056 /* Next 2 bytes are hex digits, making this a valid escape
2057 * sequence; let's decode it (above). */
2058 quoted = 1;
2059 continue;
2060 } else {
2061 /* One or both of the next 2 is out of range, making this
2062 * an invalid escape sequence; just show the raw bytes
2063 * (below). */
2064 }
2065 }
2066
2067 /* Just show the raw byte. */
2068 putc (*cp, ce->ce_fp);
2069 if (digested) {
2070 if (*cp == '\n') {
2071 MD5Update (&mdContext, (unsigned char *) "\r\n",2);
2072 } else {
2073 MD5Update (&mdContext, (unsigned char *) cp, 1);
2074 }
2075 }
2076 if (ferror (ce->ce_fp)) {
2077 content_error (ce->ce_file, ct, "error writing to");
2078 goto clean_up;
2079 }
2080 }
2081 }
2082 if (quoted) {
2083 content_error (NULL, ct,
2084 "invalid QUOTED-PRINTABLE encoding -- end-of-content while still quoting");
2085 goto clean_up;
2086 }
2087
2088 fseek (ct->c_fp, 0L, SEEK_SET);
2089
2090 if (fflush (ce->ce_fp)) {
2091 content_error (ce->ce_file, ct, "error writing to");
2092 goto clean_up;
2093 }
2094
2095 if (digested) {
2096 unsigned char digest[16];
2097
2098 MD5Final (digest, &mdContext);
2099 if (memcmp((char *) digest, (char *) ct->c_digest,
2100 sizeof(digest) / sizeof(digest[0])))
2101 content_error (NULL, ct,
2102 "content integrity suspect (digest mismatch) -- continuing");
2103 else
2104 if (debugsw)
2105 fprintf (stderr, "content integrity confirmed\n");
2106 }
2107
2108 fseek (ce->ce_fp, 0L, SEEK_SET);
2109
2110 ready_to_go:
2111 *file = ce->ce_file;
2112 if (own_ct_fp) {
2113 fclose (ct->c_fp);
2114 ct->c_fp = NULL;
2115 }
2116 free (bufp);
2117 return fileno (ce->ce_fp);
2118
2119 clean_up:
2120 free_encoding (ct, 0);
2121 if (own_ct_fp) {
2122 fclose (ct->c_fp);
2123 ct->c_fp = NULL;
2124 }
2125 free (bufp);
2126 return NOTOK;
2127 }
2128
2129
2130 /*
2131 * 7BIT
2132 */
2133
2134 static int
2135 Init7Bit (CT ct)
2136 {
2137 if (init_encoding (ct, open7Bit) == NOTOK)
2138 return NOTOK;
2139
2140 ct->c_cesizefnx = NULL; /* no need to decode for real size */
2141 return OK;
2142 }
2143
2144
2145 int
2146 open7Bit (CT ct, char **file)
2147 {
2148 int cc, fd, len, own_ct_fp = 0;
2149 char buffer[BUFSIZ];
2150 /* sbeck -- handle suffixes */
2151 char *cp;
2152 CI ci;
2153 CE ce = &ct->c_cefile;
2154
2155 if (ce->ce_fp) {
2156 fseek (ce->ce_fp, 0L, SEEK_SET);
2157 goto ready_to_go;
2158 }
2159
2160 if (ce->ce_file) {
2161 if ((ce->ce_fp = fopen (ce->ce_file, "r")) == NULL) {
2162 content_error (ce->ce_file, ct, "unable to fopen for reading");
2163 return NOTOK;
2164 }
2165 goto ready_to_go;
2166 }
2167
2168 if (*file == NULL) {
2169 ce->ce_unlink = 1;
2170 } else {
2171 ce->ce_file = mh_xstrdup(*file);
2172 ce->ce_unlink = 0;
2173 }
2174
2175 /* sbeck@cise.ufl.edu -- handle suffixes */
2176 ci = &ct->c_ctinfo;
2177 if ((cp = context_find_by_type ("suffix", ci->ci_type, ci->ci_subtype))) {
2178 if (ce->ce_unlink) {
2179 /* Create temporary file with filename extension. */
2180 if ((ce->ce_file = m_mktemps(invo_name, cp, NULL, NULL)) == NULL) {
2181 adios(NULL, "unable to create temporary file in %s",
2182 get_temp_dir());
2183 }
2184 } else {
2185 ce->ce_file = add (cp, ce->ce_file);
2186 }
2187 } else if (*file == NULL) {
2188 char *tempfile;
2189 if ((tempfile = m_mktemp2(NULL, invo_name, NULL, NULL)) == NULL) {
2190 adios(NULL, "unable to create temporary file in %s",
2191 get_temp_dir());
2192 }
2193 ce->ce_file = mh_xstrdup(tempfile);
2194 }
2195
2196 if ((ce->ce_fp = fopen (ce->ce_file, "w+")) == NULL) {
2197 content_error (ce->ce_file, ct, "unable to fopen for reading/writing");
2198 return NOTOK;
2199 }
2200
2201 if (ct->c_type == CT_MULTIPART) {
2202 CI ci = &ct->c_ctinfo;
2203 char *buffer;
2204
2205 len = 0;
2206 fprintf (ce->ce_fp, "%s: %s/%s", TYPE_FIELD, ci->ci_type, ci->ci_subtype);
2207 len += strlen (TYPE_FIELD) + 2 + strlen (ci->ci_type)
2208 + 1 + strlen (ci->ci_subtype);
2209 buffer = output_params(len, ci->ci_first_pm, &len, 0);
2210
2211 if (buffer) {
2212 fputs (buffer, ce->ce_fp);
2213 free(buffer);
2214 }
2215
2216 if (ci->ci_comment) {
2217 if (len + 1 + (cc = 2 + strlen (ci->ci_comment)) >= CPERLIN) {
2218 fputs ("\n\t", ce->ce_fp);
2219 len = 8;
2220 }
2221 else {
2222 putc (' ', ce->ce_fp);
2223 len++;
2224 }
2225 fprintf (ce->ce_fp, "(%s)", ci->ci_comment);
2226 len += cc;
2227 }
2228 fprintf (ce->ce_fp, "\n");
2229 if (ct->c_id)
2230 fprintf (ce->ce_fp, "%s:%s", ID_FIELD, ct->c_id);
2231 if (ct->c_descr)
2232 fprintf (ce->ce_fp, "%s:%s", DESCR_FIELD, ct->c_descr);
2233 if (ct->c_dispo)
2234 fprintf (ce->ce_fp, "%s:%s", DISPO_FIELD, ct->c_dispo);
2235 fprintf (ce->ce_fp, "\n");
2236 }
2237
2238 if ((len = ct->c_end - ct->c_begin) < 0)
2239 adios (NULL, "internal error(3)");
2240
2241 if (! ct->c_fp) {
2242 if ((ct->c_fp = fopen (ct->c_file, "r")) == NULL) {
2243 content_error (ct->c_file, ct, "unable to open for reading");
2244 return NOTOK;
2245 }
2246 own_ct_fp = 1;
2247 }
2248
2249 lseek (fd = fileno (ct->c_fp), (off_t) ct->c_begin, SEEK_SET);
2250 while (len > 0)
2251 switch (cc = read (fd, buffer, sizeof(buffer) - 1)) {
2252 case NOTOK:
2253 content_error (ct->c_file, ct, "error reading from");
2254 goto clean_up;
2255
2256 case OK:
2257 content_error (NULL, ct, "premature eof");
2258 goto clean_up;
2259
2260 default:
2261 if (cc > len)
2262 cc = len;
2263 len -= cc;
2264
2265 if ((int) fwrite (buffer, sizeof(*buffer), cc, ce->ce_fp) < cc) {
2266 advise ("open7Bit", "fwrite");
2267 }
2268 if (ferror (ce->ce_fp)) {
2269 content_error (ce->ce_file, ct, "error writing to");
2270 goto clean_up;
2271 }
2272 }
2273
2274 fseek (ct->c_fp, 0L, SEEK_SET);
2275
2276 if (fflush (ce->ce_fp)) {
2277 content_error (ce->ce_file, ct, "error writing to");
2278 goto clean_up;
2279 }
2280
2281 fseek (ce->ce_fp, 0L, SEEK_SET);
2282
2283 ready_to_go:
2284 *file = ce->ce_file;
2285 if (own_ct_fp) {
2286 fclose (ct->c_fp);
2287 ct->c_fp = NULL;
2288 }
2289 return fileno (ce->ce_fp);
2290
2291 clean_up:
2292 free_encoding (ct, 0);
2293 if (own_ct_fp) {
2294 fclose (ct->c_fp);
2295 ct->c_fp = NULL;
2296 }
2297 return NOTOK;
2298 }
2299
2300
2301 /*
2302 * External
2303 */
2304
2305 static int
2306 openExternal (CT ct, CT cb, CE ce, char **file, int *fd)
2307 {
2308 char cachefile[BUFSIZ];
2309
2310 if (ce->ce_fp) {
2311 fseek (ce->ce_fp, 0L, SEEK_SET);
2312 goto ready_already;
2313 }
2314
2315 if (ce->ce_file) {
2316 if ((ce->ce_fp = fopen (ce->ce_file, "r")) == NULL) {
2317 content_error (ce->ce_file, ct, "unable to fopen for reading");
2318 return NOTOK;
2319 }
2320 goto ready_already;
2321 }
2322
2323 if (find_cache (ct, rcachesw, (int *) 0, cb->c_id,
2324 cachefile, sizeof(cachefile)) != NOTOK) {
2325 if ((ce->ce_fp = fopen (cachefile, "r"))) {
2326 ce->ce_file = mh_xstrdup(cachefile);
2327 ce->ce_unlink = 0;
2328 goto ready_already;
2329 }
2330 admonish (cachefile, "unable to fopen for reading");
2331 }
2332
2333 *fd = fileno (ce->ce_fp);
2334 return OK;
2335
2336 ready_already:
2337 *file = ce->ce_file;
2338 *fd = fileno (ce->ce_fp);
2339 return DONE;
2340 }
2341
2342 /*
2343 * File
2344 */
2345
2346 static int
2347 InitFile (CT ct)
2348 {
2349 return init_encoding (ct, openFile);
2350 }
2351
2352
2353 static int
2354 openFile (CT ct, char **file)
2355 {
2356 int fd, cachetype;
2357 char cachefile[BUFSIZ];
2358 struct exbody *e = ct->c_ctexbody;
2359 CE ce = &ct->c_cefile;
2360
2361 switch (openExternal (e->eb_parent, e->eb_content, ce, file, &fd)) {
2362 case NOTOK:
2363 return NOTOK;
2364
2365 case OK:
2366 break;
2367
2368 case DONE:
2369 return fd;
2370 }
2371
2372 if (!e->eb_name) {
2373 content_error (NULL, ct, "missing name parameter");
2374 return NOTOK;
2375 }
2376
2377 ce->ce_file = mh_xstrdup(e->eb_name);
2378 ce->ce_unlink = 0;
2379
2380 if ((ce->ce_fp = fopen (ce->ce_file, "r")) == NULL) {
2381 content_error (ce->ce_file, ct, "unable to fopen for reading");
2382 return NOTOK;
2383 }
2384
2385 if ((!e->eb_permission || strcasecmp (e->eb_permission, "read-write"))
2386 && find_cache (NULL, wcachesw, &cachetype, e->eb_content->c_id,
2387 cachefile, sizeof(cachefile)) != NOTOK) {
2388 int mask;
2389 FILE *fp;
2390
2391 mask = umask (cachetype ? ~m_gmprot () : 0222);
2392 if ((fp = fopen (cachefile, "w"))) {
2393 int cc;
2394 char buffer[BUFSIZ];
2395 FILE *gp = ce->ce_fp;
2396
2397 fseek (gp, 0L, SEEK_SET);
2398
2399 while ((cc = fread (buffer, sizeof(*buffer), sizeof(buffer), gp))
2400 > 0)
2401 if ((int) fwrite (buffer, sizeof(*buffer), cc, fp) < cc) {
2402 advise ("openFile", "fwrite");
2403 }
2404 fflush (fp);
2405
2406 if (ferror (gp)) {
2407 admonish (ce->ce_file, "error reading");
2408 (void) m_unlink (cachefile);
2409 }
2410 else
2411 if (ferror (fp)) {
2412 admonish (cachefile, "error writing");
2413 (void) m_unlink (cachefile);
2414 }
2415 fclose (fp);
2416 }
2417 umask (mask);
2418 }
2419
2420 fseek (ce->ce_fp, 0L, SEEK_SET);
2421 *file = ce->ce_file;
2422 return fileno (ce->ce_fp);
2423 }
2424
2425 /*
2426 * FTP
2427 */
2428
2429 static int
2430 InitFTP (CT ct)
2431 {
2432 return init_encoding (ct, openFTP);
2433 }
2434
2435
2436 static int
2437 openFTP (CT ct, char **file)
2438 {
2439 int cachetype, caching, fd;
2440 int len, buflen;
2441 char *bp, *ftp, *user, *pass;
2442 char buffer[BUFSIZ], cachefile[BUFSIZ];
2443 struct exbody *e;
2444 CE ce = &ct->c_cefile;
2445 static char *username = NULL;
2446 static char *password = NULL;
2447
2448 e = ct->c_ctexbody;
2449
2450 if ((ftp = context_find (nmhaccessftp)) && !*ftp)
2451 ftp = NULL;
2452
2453 if (!ftp)
2454 return NOTOK;
2455
2456 switch (openExternal (e->eb_parent, e->eb_content, ce, file, &fd)) {
2457 case NOTOK:
2458 return NOTOK;
2459
2460 case OK:
2461 break;
2462
2463 case DONE:
2464 return fd;
2465 }
2466
2467 if (!e->eb_name || !e->eb_site) {
2468 content_error (NULL, ct, "missing %s parameter",
2469 e->eb_name ? "site": "name");
2470 return NOTOK;
2471 }
2472
2473 /* Get the buffer ready to go */
2474 bp = buffer;
2475 buflen = sizeof(buffer);
2476
2477 /*
2478 * Construct the query message for user
2479 */
2480 snprintf (bp, buflen, "Retrieve %s", e->eb_name);
2481 len = strlen (bp);
2482 bp += len;
2483 buflen -= len;
2484
2485 if (e->eb_partno) {
2486 snprintf (bp, buflen, " (content %s)", e->eb_partno);
2487 len = strlen (bp);
2488 bp += len;
2489 buflen -= len;
2490 }
2491
2492 snprintf (bp, buflen, "\n using %sFTP from site %s",
2493 e->eb_flags ? "anonymous " : "", e->eb_site);
2494 len = strlen (bp);
2495 bp += len;
2496 buflen -= len;
2497
2498 if (e->eb_size > 0) {
2499 snprintf (bp, buflen, " (%lu octets)", e->eb_size);
2500 len = strlen (bp);
2501 bp += len;
2502 buflen -= len;
2503 }
2504 snprintf (bp, buflen, "? ");
2505
2506 /*
2507 * Now, check the answer
2508 */
2509 if (!read_yes_or_no_if_tty (buffer))
2510 return NOTOK;
2511
2512 if (e->eb_flags) {
2513 user = "anonymous";
2514 snprintf (buffer, sizeof(buffer), "%s@%s", getusername (),
2515 LocalName (1));
2516 pass = buffer;
2517 } else {
2518 ruserpass (e->eb_site, &username, &password, 0);
2519 user = username;
2520 pass = password;
2521 }
2522
2523 ce->ce_unlink = (*file == NULL);
2524 caching = 0;
2525 cachefile[0] = '\0';
2526 if ((!e->eb_permission || strcasecmp (e->eb_permission, "read-write"))
2527 && find_cache (NULL, wcachesw, &cachetype, e->eb_content->c_id,
2528 cachefile, sizeof(cachefile)) != NOTOK) {
2529 if (*file == NULL) {
2530 ce->ce_unlink = 0;
2531 caching = 1;
2532 }
2533 }
2534
2535 if (*file)
2536 ce->ce_file = mh_xstrdup(*file);
2537 else if (caching)
2538 ce->ce_file = mh_xstrdup(cachefile);
2539 else {
2540 char *tempfile;
2541 if ((tempfile = m_mktemp2(NULL, invo_name, NULL, NULL)) == NULL) {
2542 adios(NULL, "unable to create temporary file in %s",
2543 get_temp_dir());
2544 }
2545 ce->ce_file = mh_xstrdup(tempfile);
2546 }
2547
2548 if ((ce->ce_fp = fopen (ce->ce_file, "w+")) == NULL) {
2549 content_error (ce->ce_file, ct, "unable to fopen for reading/writing");
2550 return NOTOK;
2551 }
2552
2553 {
2554 int child_id, i, vecp;
2555 char *vec[9];
2556
2557 vecp = 0;
2558 vec[vecp++] = r1bindex (ftp, '/');
2559 vec[vecp++] = e->eb_site;
2560 vec[vecp++] = user;
2561 vec[vecp++] = pass;
2562 vec[vecp++] = e->eb_dir;
2563 vec[vecp++] = e->eb_name;
2564 vec[vecp++] = ce->ce_file,
2565 vec[vecp++] = e->eb_mode && !strcasecmp (e->eb_mode, "ascii")
2566 ? "ascii" : "binary";
2567 vec[vecp] = NULL;
2568
2569 fflush (stdout);
2570
2571 for (i = 0; (child_id = fork()) == NOTOK && i < 5; i++)
2572 sleep (5);
2573 switch (child_id) {
2574 case NOTOK:
2575 adios ("fork", "unable to");
2576 /* NOTREACHED */
2577
2578 case OK:
2579 close (fileno (ce->ce_fp));
2580 execvp (ftp, vec);
2581 fprintf (stderr, "unable to exec ");
2582 perror (ftp);
2583 _exit (-1);
2584 /* NOTREACHED */
2585
2586 default:
2587 if (pidXwait (child_id, NULL)) {
2588 username = password = NULL;
2589 ce->ce_unlink = 1;
2590 return NOTOK;
2591 }
2592 break;
2593 }
2594 }
2595
2596 if (cachefile[0]) {
2597 if (caching)
2598 chmod (cachefile, cachetype ? m_gmprot () : 0444);
2599 else {
2600 int mask;
2601 FILE *fp;
2602
2603 mask = umask (cachetype ? ~m_gmprot () : 0222);
2604 if ((fp = fopen (cachefile, "w"))) {
2605 int cc;
2606 FILE *gp = ce->ce_fp;
2607
2608 fseek (gp, 0L, SEEK_SET);
2609
2610 while ((cc= fread (buffer, sizeof(*buffer), sizeof(buffer), gp))
2611 > 0)
2612 if ((int) fwrite (buffer, sizeof(*buffer), cc, fp) < cc) {
2613 advise ("openFTP", "fwrite");
2614 }
2615 fflush (fp);
2616
2617 if (ferror (gp)) {
2618 admonish (ce->ce_file, "error reading");
2619 (void) m_unlink (cachefile);
2620 }
2621 else
2622 if (ferror (fp)) {
2623 admonish (cachefile, "error writing");
2624 (void) m_unlink (cachefile);
2625 }
2626 fclose (fp);
2627 }
2628 umask (mask);
2629 }
2630 }
2631
2632 fseek (ce->ce_fp, 0L, SEEK_SET);
2633 *file = ce->ce_file;
2634 return fileno (ce->ce_fp);
2635 }
2636
2637
2638 /*
2639 * Mail
2640 */
2641
2642 static int
2643 InitMail (CT ct)
2644 {
2645 return init_encoding (ct, openMail);
2646 }
2647
2648
2649 static int
2650 openMail (CT ct, char **file)
2651 {
2652 int child_id, fd, i, vecp;
2653 int len, buflen;
2654 char *bp, buffer[BUFSIZ], *vec[7];
2655 struct exbody *e = ct->c_ctexbody;
2656 CE ce = &ct->c_cefile;
2657
2658 switch (openExternal (e->eb_parent, e->eb_content, ce, file, &fd)) {
2659 case NOTOK:
2660 return NOTOK;
2661
2662 case OK:
2663 break;
2664
2665 case DONE:
2666 return fd;
2667 }
2668
2669 if (!e->eb_server) {
2670 content_error (NULL, ct, "missing server parameter");
2671 return NOTOK;
2672 }
2673
2674 /* Get buffer ready to go */
2675 bp = buffer;
2676 buflen = sizeof(buffer);
2677
2678 /* Now, construct query message */
2679 snprintf (bp, buflen, "Retrieve content");
2680 len = strlen (bp);
2681 bp += len;
2682 buflen -= len;
2683
2684 if (e->eb_partno) {
2685 snprintf (bp, buflen, " %s", e->eb_partno);
2686 len = strlen (bp);
2687 bp += len;
2688 buflen -= len;
2689 }
2690
2691 snprintf (bp, buflen, " by asking %s\n\n%s\n? ",
2692 e->eb_server,
2693 e->eb_subject ? e->eb_subject : e->eb_body);
2694
2695 /* Now, check answer */
2696 if (!read_yes_or_no_if_tty (buffer))
2697 return NOTOK;
2698
2699 vecp = 0;
2700 vec[vecp++] = r1bindex (mailproc, '/');
2701 vec[vecp++] = e->eb_server;
2702 vec[vecp++] = "-subject";
2703 vec[vecp++] = e->eb_subject ? e->eb_subject : "mail-server request";
2704 vec[vecp++] = "-body";
2705 vec[vecp++] = e->eb_body;
2706 vec[vecp] = NULL;
2707
2708 for (i = 0; (child_id = fork()) == NOTOK && i < 5; i++)
2709 sleep (5);
2710 switch (child_id) {
2711 case NOTOK:
2712 advise ("fork", "unable to");
2713 return NOTOK;
2714
2715 case OK:
2716 execvp (mailproc, vec);
2717 fprintf (stderr, "unable to exec ");
2718 perror (mailproc);
2719 _exit (-1);
2720 /* NOTREACHED */
2721
2722 default:
2723 if (pidXwait (child_id, NULL) == OK)
2724 inform("request sent");
2725 break;
2726 }
2727
2728 if (*file == NULL) {
2729 char *tempfile;
2730 if ((tempfile = m_mktemp2(NULL, invo_name, NULL, NULL)) == NULL) {
2731 adios(NULL, "unable to create temporary file in %s",
2732 get_temp_dir());
2733 }
2734 ce->ce_file = mh_xstrdup(tempfile);
2735 ce->ce_unlink = 1;
2736 } else {
2737 ce->ce_file = mh_xstrdup(*file);
2738 ce->ce_unlink = 0;
2739 }
2740
2741 if ((ce->ce_fp = fopen (ce->ce_file, "w+")) == NULL) {
2742 content_error (ce->ce_file, ct, "unable to fopen for reading/writing");
2743 return NOTOK;
2744 }
2745
2746 /* showproc is for mhshow and mhstore, though mhlist -debug
2747 * prints it, too. */
2748 mh_xfree(ct->c_showproc);
2749 ct->c_showproc = mh_xstrdup("true");
2750
2751 fseek (ce->ce_fp, 0L, SEEK_SET);
2752 *file = ce->ce_file;
2753 return fileno (ce->ce_fp);
2754 }
2755
2756
2757 /*
2758 * URL
2759 */
2760
2761 static int
2762 InitURL (CT ct)
2763 {
2764 return init_encoding (ct, openURL);
2765 }
2766
2767
2768 static int
2769 openURL (CT ct, char **file)
2770 {
2771 struct exbody *e = ct->c_ctexbody;
2772 CE ce = &ct->c_cefile;
2773 char *urlprog, *program;
2774 char buffer[BUFSIZ], cachefile[BUFSIZ];
2775 int fd, caching, cachetype;
2776 struct msgs_array args = { 0, 0, NULL};
2777 pid_t child_id;
2778
2779 if ((urlprog = context_find(nmhaccessurl)) && *urlprog == '\0')
2780 urlprog = NULL;
2781
2782 if (! urlprog) {
2783 content_error(NULL, ct, "No entry for nmh-access-url in profile");
2784 return NOTOK;
2785 }
2786
2787 switch (openExternal(e->eb_parent, e->eb_content, ce, file, &fd)) {
2788 case NOTOK:
2789 return NOTOK;
2790
2791 case OK:
2792 break;
2793
2794 case DONE:
2795 return fd;
2796 }
2797
2798 if (!e->eb_url) {
2799 content_error(NULL, ct, "missing url parameter");
2800 return NOTOK;
2801 }
2802
2803 ce->ce_unlink = (*file == NULL);
2804 caching = 0;
2805 cachefile[0] = '\0';
2806
2807 if (find_cache(NULL, wcachesw, &cachetype, e->eb_content->c_id,
2808 cachefile, sizeof(cachefile)) != NOTOK) {
2809 if (*file == NULL) {
2810 ce->ce_unlink = 0;
2811 caching = 1;
2812 }
2813 }
2814
2815 if (*file)
2816 ce->ce_file = mh_xstrdup(*file);
2817 else if (caching)
2818 ce->ce_file = mh_xstrdup(cachefile);
2819 else {
2820 char *tempfile;
2821 if ((tempfile = m_mktemp2(NULL, invo_name, NULL, NULL)) == NULL) {
2822 adios(NULL, "unable to create temporary file in %s",
2823 get_temp_dir());
2824 }
2825 ce->ce_file = mh_xstrdup(tempfile);
2826 }
2827
2828 if ((ce->ce_fp = fopen(ce->ce_file, "w+")) == NULL) {
2829 content_error(ce->ce_file, ct, "unable to fopen for read/writing");
2830 return NOTOK;
2831 }
2832
2833 switch (child_id = fork()) {
2834 case NOTOK:
2835 adios ("fork", "unable to");
2836 /* NOTREACHED */
2837
2838 case OK:
2839 argsplit_msgarg(&args, urlprog, &program);
2840 app_msgarg(&args, e->eb_url);
2841 app_msgarg(&args, NULL);
2842 dup2(fileno(ce->ce_fp), 1);
2843 close(fileno(ce->ce_fp));
2844 execvp(program, args.msgs);
2845 fprintf(stderr, "Unable to exec ");
2846 perror(program);
2847 _exit(-1);
2848 /* NOTREACHED */
2849
2850 default:
2851 if (pidXwait(child_id, NULL)) {
2852 ce->ce_unlink = 1;
2853 return NOTOK;
2854 }
2855 }
2856
2857 if (cachefile[0]) {
2858 if (caching)
2859 chmod(cachefile, cachetype ? m_gmprot() : 0444);
2860 else {
2861 int mask;
2862 FILE *fp;
2863
2864 mask = umask (cachetype ? ~m_gmprot() : 0222);
2865 if ((fp = fopen(cachefile, "w"))) {
2866 int cc;
2867 FILE *gp = ce->ce_fp;
2868
2869 fseeko(gp, 0, SEEK_SET);
2870
2871 while ((cc = fread(buffer, sizeof(*buffer),
2872 sizeof(buffer), gp)) > 0)
2873 if ((int) fwrite(buffer, sizeof(*buffer), cc, fp) < cc) {
2874 advise ("openURL", "fwrite");
2875 }
2876
2877 fflush(fp);
2878
2879 if (ferror(gp)) {
2880 admonish(ce->ce_file, "error reading");
2881 (void) m_unlink (cachefile);
2882 }
2883 }
2884 umask(mask);
2885 }
2886 }
2887
2888 fseeko(ce->ce_fp, 0, SEEK_SET);
2889 *file = ce->ce_file;
2890 return fd;
2891 }
2892
2893
2894 /*
2895 * Stores MD5 digest (in cp, from Content-MD5 header) in ct->c_digest. It
2896 * has to be base64 decoded.
2897 */
2898 static int
2899 readDigest (CT ct, char *cp)
2900 {
2901 unsigned char *digest;
2902
2903 size_t len;
2904 if (decodeBase64 (cp, &digest, &len, 0, NULL) == OK) {
2905 const size_t maxlen = sizeof ct->c_digest / sizeof ct->c_digest[0];
2906
2907 if (strlen ((char *) digest) <= maxlen) {
2908 memcpy (ct->c_digest, digest, maxlen);
2909
2910 if (debugsw) {
2911 size_t i;
2912
2913 fprintf (stderr, "MD5 digest=");
2914 for (i = 0; i < maxlen; ++i) {
2915 fprintf (stderr, "%02x", ct->c_digest[i] & 0xff);
2916 }
2917 fprintf (stderr, "\n");
2918 }
2919
2920 return OK;
2921 }
2922 if (debugsw) {
2923 fprintf (stderr, "invalid MD5 digest (got %d octets)\n",
2924 (int) strlen ((char *) digest));
2925 }
2926
2927 return NOTOK;
2928 }
2929
2930 return NOTOK;
2931 }
2932
2933
2934 /* Multipart parts might have content before the first subpart and/or
2935 after the last subpart that hasn't been stored anywhere else, so do
2936 that. */
2937 int
2938 get_leftover_mp_content (CT ct, int before /* or after */)
2939 {
2940 struct multipart *m = (struct multipart *) ct->c_ctparams;
2941 char *boundary;
2942 int found_boundary = 0;
2943 int max = BUFSIZ;
2944 char *bufp = NULL;
2945 size_t buflen;
2946 ssize_t gotlen;
2947 int read = 0;
2948 char *content = NULL;
2949
2950 if (! m) return NOTOK;
2951
2952 if (before) {
2953 if (! m->mp_parts || ! m->mp_parts->mp_part) return NOTOK;
2954
2955 /* Isolate the beginning of this part to the beginning of the
2956 first subpart and save any content between them. */
2957 fseeko (ct->c_fp, ct->c_begin, SEEK_SET);
2958 max = m->mp_parts->mp_part->c_begin - ct->c_begin;
2959 boundary = concat ("--", m->mp_start, NULL);
2960 } else {
2961 struct part *last_subpart = NULL;
2962 struct part *subpart;
2963
2964 /* Go to the last subpart to get its end position. */
2965 for (subpart = m->mp_parts; subpart; subpart = subpart->mp_next) {
2966 last_subpart = subpart;
2967 }
2968
2969 if (last_subpart == NULL) return NOTOK;
2970
2971 /* Isolate the end of the last subpart to the end of this part
2972 and save any content between them. */
2973 fseeko (ct->c_fp, last_subpart->mp_part->c_end, SEEK_SET);
2974 max = ct->c_end - last_subpart->mp_part->c_end;
2975 boundary = concat ("--", m->mp_stop, NULL);
2976 }
2977
2978 /* Back up by 1 to pick up the newline. */
2979 while ((gotlen = getline(&bufp, &buflen, ct->c_fp)) != -1) {
2980 read += gotlen;
2981 /* Don't look beyond beginning of first subpart (before) or
2982 next part (after). */
2983 if (read > max) bufp[read-max] = '\0';
2984
2985 if (before) {
2986 if (! strcmp (bufp, boundary)) {
2987 found_boundary = 1;
2988 }
2989 } else {
2990 if (! found_boundary && ! strcmp (bufp, boundary)) {
2991 found_boundary = 1;
2992 continue;
2993 }
2994 }
2995
2996 if ((before && ! found_boundary) || (! before && found_boundary)) {
2997 if (content) {
2998 char *old_content = content;
2999 content = concat (content, bufp, NULL);
3000 free (old_content);
3001 } else {
3002 content = before
3003 ? concat ("\n", bufp, NULL)
3004 : concat (bufp, NULL);
3005 }
3006 }
3007
3008 if (before) {
3009 if (found_boundary || read > max) break;
3010 } else {
3011 if (read > max) break;
3012 }
3013 }
3014
3015 /* Skip the newline if that's all there is. */
3016 if (content) {
3017 char *cp;
3018
3019 /* Remove trailing newline, except at EOF. */
3020 if ((before || ! feof (ct->c_fp)) &&
3021 (cp = content + strlen (content)) > content &&
3022 *--cp == '\n') {
3023 *cp = '\0';
3024 }
3025
3026 if (strlen (content) > 1) {
3027 if (before) {
3028 m->mp_content_before = content;
3029 } else {
3030 m->mp_content_after = content;
3031 }
3032 } else {
3033 free (content);
3034 }
3035 }
3036
3037 free (boundary);
3038 free (bufp);
3039
3040 return OK;
3041 }
3042
3043
3044 char *
3045 ct_type_str (int type) {
3046 switch (type) {
3047 case CT_APPLICATION:
3048 return "application";
3049 case CT_AUDIO:
3050 return "audio";
3051 case CT_IMAGE:
3052 return "image";
3053 case CT_MESSAGE:
3054 return "message";
3055 case CT_MULTIPART:
3056 return "multipart";
3057 case CT_TEXT:
3058 return "text";
3059 case CT_VIDEO:
3060 return "video";
3061 case CT_EXTENSION:
3062 return "extension";
3063 default:
3064 return "unknown_type";
3065 }
3066 }
3067
3068
3069 char *
3070 ct_subtype_str (int type, int subtype) {
3071 switch (type) {
3072 case CT_APPLICATION:
3073 switch (subtype) {
3074 case APPLICATION_OCTETS:
3075 return "octets";
3076 case APPLICATION_POSTSCRIPT:
3077 return "postscript";
3078 default:
3079 return "unknown_app_subtype";
3080 }
3081 case CT_MESSAGE:
3082 switch (subtype) {
3083 case MESSAGE_RFC822:
3084 return "rfc822";
3085 case MESSAGE_PARTIAL:
3086 return "partial";
3087 case MESSAGE_EXTERNAL:
3088 return "external";
3089 default:
3090 return "unknown_msg_subtype";
3091 }
3092 case CT_MULTIPART:
3093 switch (subtype) {
3094 case MULTI_MIXED:
3095 return "mixed";
3096 case MULTI_ALTERNATE:
3097 return "alternative";
3098 case MULTI_DIGEST:
3099 return "digest";
3100 case MULTI_PARALLEL:
3101 return "parallel";
3102 case MULTI_RELATED:
3103 return "related";
3104 default:
3105 return "unknown_multipart_subtype";
3106 }
3107 case CT_TEXT:
3108 switch (subtype) {
3109 case TEXT_PLAIN:
3110 return "plain";
3111 case TEXT_RICHTEXT:
3112 return "richtext";
3113 case TEXT_ENRICHED:
3114 return "enriched";
3115 default:
3116 return "unknown_text_subtype";
3117 }
3118 default:
3119 return "unknown_type";
3120 }
3121 }
3122
3123
3124 int
3125 ct_str_type (const char *type) {
3126 struct str2init *s2i;
3127
3128 for (s2i = str2cts; s2i->si_key; ++s2i) {
3129 if (! strcasecmp (type, s2i->si_key)) {
3130 break;
3131 }
3132 }
3133 if (! s2i->si_key && ! uprf (type, "X-")) {
3134 ++s2i;
3135 }
3136
3137 return s2i->si_val;
3138 }
3139
3140
3141 int
3142 ct_str_subtype (int type, const char *subtype) {
3143 struct k2v *kv;
3144
3145 switch (type) {
3146 case CT_APPLICATION:
3147 for (kv = SubApplication; kv->kv_key; ++kv) {
3148 if (! strcasecmp (subtype, kv->kv_key)) {
3149 break;
3150 }
3151 }
3152 return kv->kv_value;
3153 case CT_MESSAGE:
3154 for (kv = SubMessage; kv->kv_key; ++kv) {
3155 if (! strcasecmp (subtype, kv->kv_key)) {
3156 break;
3157 }
3158 }
3159 return kv->kv_value;
3160 case CT_MULTIPART:
3161 for (kv = SubMultiPart; kv->kv_key; ++kv) {
3162 if (! strcasecmp (subtype, kv->kv_key)) {
3163 break;
3164 }
3165 }
3166 return kv->kv_value;
3167 case CT_TEXT:
3168 for (kv = SubText; kv->kv_key; ++kv) {
3169 if (! strcasecmp (subtype, kv->kv_key)) {
3170 break;
3171 }
3172 }
3173 return kv->kv_value;
3174 default:
3175 return 0;
3176 }
3177 }
3178
3179
3180 /* Find the content type and InitFunc for the CT. */
3181 const struct str2init *
3182 get_ct_init (int type) {
3183 const struct str2init *sp;
3184
3185 for (sp = str2cts; sp->si_key; ++sp) {
3186 if (type == sp->si_val) {
3187 return sp;
3188 }
3189 }
3190
3191 return NULL;
3192 }
3193
3194 const char *
3195 ce_str (int encoding) {
3196 switch (encoding) {
3197 case CE_BASE64:
3198 return "base64";
3199 case CE_QUOTED:
3200 return "quoted-printable";
3201 case CE_8BIT:
3202 return "8bit";
3203 case CE_7BIT:
3204 return "7bit";
3205 case CE_BINARY:
3206 return "binary";
3207 case CE_EXTENSION:
3208 return "extension";
3209 case CE_EXTERNAL:
3210 return "external";
3211 default:
3212 return "unknown";
3213 }
3214 }
3215
3216 /* Find the content type and InitFunc for the content encoding method. */
3217 const struct str2init *
3218 get_ce_method (const char *method) {
3219 struct str2init *sp;
3220
3221 for (sp = str2ces; sp->si_key; ++sp) {
3222 if (! strcasecmp (method, sp->si_key)) {
3223 return sp;
3224 }
3225 }
3226
3227 return NULL;
3228 }
3229
3230 /*
3231 * Parse a series of MIME attributes (or parameters) given a header as
3232 * input.
3233 *
3234 * Arguments include:
3235 *
3236 * filename - Name of input file (for error messages)
3237 * fieldname - Name of field being processed
3238 * headerp - Pointer to pointer of the beginning of the MIME attributes.
3239 * Updated to point to end of attributes when finished.
3240 * param_head - Pointer to head of parameter list
3241 * param_tail - Pointer to tail of parameter list
3242 * commentp - Pointer to header comment pointer (may be NULL)
3243 *
3244 * Returns OK if parsing was successful, NOTOK if parsing failed, and
3245 * DONE to indicate a benign error (minor parsing error, but the program
3246 * should continue).
3247 */
3248
3249 static int
3250 parse_header_attrs (const char *filename, const char *fieldname,
3251 char **header_attrp, PM *param_head, PM *param_tail,
3252 char **commentp)
3253 {
3254 char *cp = *header_attrp;
3255 PM pm;
3256 struct sectlist {
3257 char *value;
3258 int index;
3259 int len;
3260 struct sectlist *next;
3261 } *sp, *sp2;
3262 struct parmlist {
3263 char *name;
3264 char *charset;
3265 char *lang;
3266 struct sectlist *sechead;
3267 struct parmlist *next;
3268 } *pp, *pp2, *phead = NULL;
3269
3270 while (*cp == ';') {
3271 char *dp, *vp, *up, *nameptr, *valptr, *charset = NULL, *lang = NULL;
3272 int encoded = 0, partial = 0, len = 0, index = 0;
3273
3274 cp++;
3275 while (isspace ((unsigned char) *cp))
3276 cp++;
3277
3278 if (*cp == '(' &&
3279 get_comment (filename, fieldname, &cp, commentp) == NOTOK) {
3280 return NOTOK;
3281 }
3282
3283 if (*cp == 0) {
3284 if (! suppress_extraneous_trailing_semicolon_warning) {
3285 inform("extraneous trailing ';' in message %s's %s: "
3286 "parameter list", filename, fieldname);
3287 }
3288 return DONE;
3289 }
3290
3291 /* down case the attribute name */
3292 for (dp = cp; istoken ((unsigned char) *dp); dp++)
3293 *dp = tolower ((unsigned char) *dp);
3294
3295 for (up = dp; isspace ((unsigned char) *dp);)
3296 dp++;
3297 if (dp == cp || *dp != '=') {
3298 inform("invalid parameter in message %s's %s: "
3299 "field\n%*sparameter %s (error detected at offset %d)",
3300 filename, fieldname, strlen(invo_name) + 2, "",cp, dp - cp);
3301 return NOTOK;
3302 }
3303
3304 /*
3305 * To handle RFC 2231, we have to deal with the following extensions:
3306 *
3307 * name*=encoded-value
3308 * name*<N>=part-N-of-a-parameter-value
3309 * name*<N>*=encoded-part-N-of-a-parameter-value
3310 *
3311 * So the rule is:
3312 * If there's a * right before the equal sign, it's encoded.
3313 * If there's a * and one or more digits, then it's section N.
3314 *
3315 * Remember we can have one or the other, or both. cp points to
3316 * beginning of name, up points past the last character in the
3317 * parameter name.
3318 */
3319
3320 for (vp = cp; vp < up; vp++) {
3321 if (*vp == '*' && vp < up - 1) {
3322 partial = 1;
3323 continue;
3324 } else if (*vp == '*' && vp == up - 1) {
3325 encoded = 1;
3326 } else if (partial) {
3327 if (isdigit((unsigned char) *vp))
3328 index = *vp - '0' + index * 10;
3329 else {
3330 inform("invalid parameter index in message %s's "
3331 "%s: field\n%*s(parameter %s)", filename,
3332 fieldname, strlen(invo_name) + 2, "", cp);
3333 return NOTOK;
3334 }
3335 } else {
3336 len++;
3337 }
3338 }
3339
3340 /*
3341 * Break out the parameter name and value sections and allocate
3342 * memory for each.
3343 */
3344
3345 nameptr = mh_xmalloc(len + 1);
3346 strncpy(nameptr, cp, len);
3347 nameptr[len] = '\0';
3348
3349 for (dp++; isspace ((unsigned char) *dp);)
3350 dp++;
3351
3352 if (encoded) {
3353 /*
3354 * Single quotes delimit the character set and language tag.
3355 * They are required on the first section (or a complete
3356 * parameter).
3357 */
3358 if (index == 0) {
3359 vp = dp;
3360 while (*vp != '\'' && !isspace((unsigned char) *vp) &&
3361 *vp != '\0')
3362 vp++;
3363 if (*vp == '\'') {
3364 if (vp != dp) {
3365 len = vp - dp;
3366 charset = mh_xmalloc(len + 1);
3367 strncpy(charset, dp, len);
3368 charset[len] = '\0';
3369 } else {
3370 charset = NULL;
3371 }
3372 vp++;
3373 } else {
3374 inform("missing charset in message %s's %s: "
3375 "field\n%*s(parameter %s)", filename, fieldname,
3376 strlen(invo_name) + 2, "", nameptr);
3377 free(nameptr);
3378 return NOTOK;
3379 }
3380 dp = vp;
3381
3382 while (*vp != '\'' && !isspace((unsigned char) *vp) &&
3383 *vp != '\0')
3384 vp++;
3385
3386 if (*vp == '\'') {
3387 if (vp != dp) {
3388 len = vp - dp;
3389 lang = mh_xmalloc(len + 1);
3390 strncpy(lang, dp, len);
3391 lang[len] = '\0';
3392 } else {
3393 lang = NULL;
3394 }
3395 vp++;
3396 } else {
3397 inform("missing language tag in message %s's %s: "
3398 "field\n%*s(parameter %s)", filename, fieldname,
3399 strlen(invo_name) + 2, "", nameptr);
3400 free(nameptr);
3401 mh_xfree(charset);
3402 return NOTOK;
3403 }
3404
3405 dp = vp;
3406 }
3407
3408 /*
3409 * At this point vp should be pointing at the beginning
3410 * of the encoded value/section. Continue until we reach
3411 * the end or get whitespace. But first, calculate the
3412 * length so we can allocate the correct buffer size.
3413 */
3414
3415 for (vp = dp, len = 0; istoken(*vp); vp++) {
3416 if (*vp == '%') {
3417 if (*(vp + 1) == '\0' ||
3418 !isxdigit((unsigned char) *(vp + 1)) ||
3419 *(vp + 2) == '\0' ||
3420 !isxdigit((unsigned char) *(vp + 2))) {
3421 inform("invalid encoded sequence in message "
3422 "%s's %s: field\n%*s(parameter %s)",
3423 filename, fieldname, strlen(invo_name) + 2,
3424 "", nameptr);
3425 free(nameptr);
3426 mh_xfree(charset);
3427 mh_xfree(lang);
3428 return NOTOK;
3429 }
3430 vp += 2;
3431 }
3432 len++;
3433 }
3434
3435 up = valptr = mh_xmalloc(len + 1);
3436
3437 for (vp = dp; istoken(*vp); vp++) {
3438 if (*vp == '%') {
3439 *up++ = decode_qp(*(vp + 1), *(vp + 2));
3440 vp += 2;
3441 } else {
3442 *up++ = *vp;
3443 }
3444 }
3445
3446 *up = '\0';
3447 cp = vp;
3448 } else {
3449 /*
3450 * A "normal" string. If it's got a leading quote, then we
3451 * strip the quotes out. Otherwise go until we reach the end
3452 * or get whitespace. Note we scan it twice; once to get the
3453 * length, then the second time copies it into the destination
3454 * buffer.
3455 */
3456
3457 len = 0;
3458
3459 if (*dp == '"') {
3460 for (cp = dp + 1;;) {
3461 switch (*cp++) {
3462 case '\0':
3463 bad_quote:
3464 inform("invalid quoted-string in message %s's %s: "
3465 "field\n%*s(parameter %s)", filename,
3466 fieldname, strlen(invo_name) + 2, "", nameptr);
3467 free(nameptr);
3468 mh_xfree(charset);
3469 mh_xfree(lang);
3470 return NOTOK;
3471 case '"':
3472 break;
3473
3474 case '\\':
3475 if (*++cp == '\0')
3476 goto bad_quote;
3477 /* FALLTHRU */
3478 default:
3479 len++;
3480 continue;
3481 }
3482 break;
3483 }
3484
3485 } else {
3486 for (cp = dp; istoken (*cp); cp++) {
3487 len++;
3488 }
3489 }
3490
3491 valptr = mh_xmalloc(len + 1);
3492
3493 if (*dp == '"') {
3494 int i;
3495 for (cp = dp + 1, vp = valptr, i = 0; i < len; i++) {
3496 if (*cp == '\\') {
3497 cp++;
3498 }
3499 *vp++ = *cp++;
3500 }
3501 cp++;
3502 } else {
3503 strncpy(valptr, cp = dp, len);
3504 cp += len;
3505 }
3506
3507 valptr[len] = '\0';
3508 }
3509
3510 /*
3511 * If 'partial' is set, we don't allocate a parameter now. We
3512 * put it on the parameter linked list to be reassembled later.
3513 *
3514 * "phead" points to a list of all parameters we need to reassemble.
3515 * Each parameter has a list of sections. We insert the sections in
3516 * order.
3517 */
3518
3519 if (partial) {
3520 for (pp = phead; pp != NULL; pp = pp->next) {
3521 if (strcasecmp(nameptr, pp->name) == 0) {
3522 free (nameptr);
3523 nameptr = pp->name;
3524 break;
3525 }
3526 }
3527
3528 if (pp == NULL) {
3529 NEW0(pp);
3530 pp->name = nameptr;
3531 pp->next = phead;
3532 phead = pp;
3533 }
3534
3535 /*
3536 * Insert this into the section linked list
3537 */
3538
3539 NEW0(sp);
3540 sp->value = valptr;
3541 sp->index = index;
3542 sp->len = len;
3543
3544 if (pp->sechead == NULL || pp->sechead->index > index) {
3545 sp->next = pp->sechead;
3546 pp->sechead = sp;
3547 } else {
3548 for (sp2 = pp->sechead; sp2 != NULL; sp2 = sp2->next) {
3549 if (sp2->index == sp->index) {
3550 inform("duplicate index (%d) in message "
3551 "%s's %s: field\n%*s(parameter %s)", sp->index,
3552 filename, fieldname, strlen(invo_name) + 2, "",
3553 nameptr);
3554 return NOTOK;
3555 }
3556 if (sp2->index < sp->index &&
3557 (sp2->next == NULL || sp2->next->index > sp->index)) {
3558 sp->next = sp2->next;
3559 sp2->next = sp;
3560 break;
3561 }
3562 }
3563
3564 if (sp2 == NULL) {
3565 inform("Internal error: cannot insert partial "
3566 "param in message %s's %s: field\n%*s(parameter %s)",
3567 filename, fieldname, strlen(invo_name) + 2, "",
3568 nameptr);
3569 return NOTOK;
3570 }
3571 }
3572
3573 /*
3574 * Save our charset and lang tags.
3575 */
3576
3577 if (index == 0 && encoded) {
3578 mh_xfree(pp->charset);
3579 pp->charset = charset;
3580 mh_xfree(pp->lang);
3581 pp->lang = lang;
3582 }
3583 } else {
3584 pm = add_param(param_head, param_tail, nameptr, valptr, 1);
3585 pm->pm_charset = charset;
3586 pm->pm_lang = lang;
3587 }
3588
3589 while (isspace ((unsigned char) *cp))
3590 cp++;
3591
3592 if (*cp == '(' &&
3593 get_comment (filename, fieldname, &cp, commentp) == NOTOK) {
3594 return NOTOK;
3595 }
3596 }
3597
3598 /*
3599 * Now that we're done, reassemble all of the partial parameters.
3600 */
3601
3602 for (pp = phead; pp != NULL; ) {
3603 char *p, *q;
3604 size_t tlen = 0;
3605 int pindex = 0;
3606 for (sp = pp->sechead; sp != NULL; sp = sp->next) {
3607 if (sp->index != pindex++) {
3608 inform("missing section %d for parameter in "
3609 "message %s's %s: field\n%*s(parameter %s)", pindex - 1,
3610 filename, fieldname, strlen(invo_name) + 2, "",
3611 pp->name);
3612 return NOTOK;
3613 }
3614 tlen += sp->len;
3615 }
3616
3617 p = q = mh_xmalloc(tlen + 1);
3618 for (sp = pp->sechead; sp != NULL; ) {
3619 memcpy(q, sp->value, sp->len);
3620 q += sp->len;
3621 free(sp->value);
3622 sp2 = sp->next;
3623 free(sp);
3624 sp = sp2;
3625 }
3626
3627 p[tlen] = '\0';
3628
3629 pm = add_param(param_head, param_tail, pp->name, p, 1);
3630 pm->pm_charset = pp->charset;
3631 pm->pm_lang = pp->lang;
3632 pp2 = pp->next;
3633 free(pp);
3634 pp = pp2;
3635 }
3636
3637 *header_attrp = cp;
3638 return OK;
3639 }
3640
3641 /*
3642 * Return the charset for a particular content type.
3643 */
3644
3645 char *
3646 content_charset (CT ct) {
3647 char *ret_charset = NULL;
3648
3649 ret_charset = get_param(ct->c_ctinfo.ci_first_pm, "charset", '?', 0);
3650
3651 return ret_charset ? ret_charset : mh_xstrdup("US-ASCII");
3652 }
3653
3654
3655 /*
3656 * Create a string based on a list of output parameters. Assume that this
3657 * parameter string will be appended to an existing header, so start out
3658 * with the separator (;). Perform RFC 2231 encoding when necessary.
3659 */
3660
3661 char *
3662 output_params(size_t initialwidth, PM params, int *offsetout, int external)
3663 {
3664 char *paramout = NULL;
3665 char line[CPERLIN * 2], *q;
3666 int curlen, index, cont, encode, i;
3667 size_t valoff, numchars;
3668
3669 while (params != NULL) {
3670 encode = 0;
3671 index = 0;
3672 valoff = 0;
3673 q = line;
3674
3675 if (external && strcasecmp(params->pm_name, "body") == 0)
3676 continue;
3677
3678 if (strlen(params->pm_name) > CPERLIN) {
3679 inform("Parameter name \"%s\" is too long", params->pm_name);
3680 mh_xfree(paramout);
3681 return NULL;
3682 }
3683
3684 curlen = param_len(params, index, valoff, &encode, &cont, &numchars);
3685
3686 /*
3687 * Loop until we get a parameter that fits within a line. We
3688 * assume new lines start with a tab, so check our overflow based
3689 * on that.
3690 */
3691
3692 while (cont) {
3693 *q++ = ';';
3694 *q++ = '\n';
3695 *q++ = '\t';
3696
3697 /*
3698 * At this point we're definitely continuing the line, so
3699 * be sure to include the parameter name and section index.
3700 */
3701
3702 q += snprintf(q, sizeof(line) - (q - line), "%s*%d",
3703 params->pm_name, index);
3704
3705 /*
3706 * Both of these functions do a NUL termination
3707 */
3708
3709 if (encode)
3710 i = encode_param(params, q, sizeof(line) - (q - line),
3711 numchars, valoff, index);
3712 else
3713 i = normal_param(params, q, sizeof(line) - (q - line),
3714 numchars, valoff);
3715
3716 if (i == 0) {
3717 mh_xfree(paramout);
3718 return NULL;
3719 }
3720
3721 valoff += numchars;
3722 index++;
3723 curlen = param_len(params, index, valoff, &encode, &cont,
3724 &numchars);
3725 q = line;
3726
3727 /*
3728 * "line" starts with a ;\n\t, so that doesn't count against
3729 * the length. But add 8 since it starts with a tab; that's
3730 * how we end up with 5.
3731 */
3732
3733 initialwidth = strlen(line) + 5;
3734
3735 /*
3736 * At this point the line should be built, so add it to our
3737 * current output buffer.
3738 */
3739
3740 paramout = add(line, paramout);
3741 }
3742
3743 /*
3744 * If this won't fit on the line, start a new one. Save room in
3745 * case we need a semicolon on the end
3746 */
3747
3748 if (initialwidth + curlen > CPERLIN - 1) {
3749 *q++ = ';';
3750 *q++ = '\n';
3751 *q++ = '\t';
3752 initialwidth = 8;
3753 } else {
3754 *q++ = ';';
3755 *q++ = ' ';
3756 initialwidth += 2;
3757 }
3758
3759 /*
3760 * At this point, we're either finishing a contined parameter, or
3761 * we're working on a new one.
3762 */
3763
3764 if (index > 0) {
3765 q += snprintf(q, sizeof(line) - (q - line), "%s*%d",
3766 params->pm_name, index);
3767 } else {
3768 strncpy(q, params->pm_name, sizeof(line) - (q - line));
3769 q += strlen(q);
3770 }
3771
3772 if (encode)
3773 i = encode_param(params, q, sizeof(line) - (q - line),
3774 strlen(params->pm_value + valoff), valoff, index);
3775 else
3776 i = normal_param(params, q, sizeof(line) - (q - line),
3777 strlen(params->pm_value + valoff), valoff);
3778
3779 if (i == 0) {
3780 mh_xfree(paramout);
3781 return NULL;
3782 }
3783
3784 paramout = add(line, paramout);
3785 initialwidth += strlen(line);
3786
3787 params = params->pm_next;
3788 }
3789
3790 if (offsetout)
3791 *offsetout = initialwidth;
3792
3793 return paramout;
3794 }
3795
3796 /*
3797 * Calculate the size of a parameter.
3798 *
3799 * Arguments include
3800 *
3801 * pm - The parameter being output
3802 * index - If continuing the parameter, the index of the section
3803 * we're on.
3804 * valueoff - The current offset into the parameter value that we're
3805 * working on (previous sections have consumed valueoff bytes).
3806 * encode - Set if we should perform encoding on this parameter section
3807 * (given that we're consuming bytesfit bytes).
3808 * cont - Set if the remaining data in value will not fit on a single
3809 * line and will need to be continued.
3810 * bytesfit - The number of bytes that we can consume from the parameter
3811 * value and still fit on a completely new line. The
3812 * calculation assumes the new line starts with a tab,
3813 * includes the parameter name and any encoding, and fits
3814 * within CPERLIN bytes. Will always be at least 1.
3815 */
3816
3817 static size_t
3818 param_len(PM pm, int index, size_t valueoff, int *encode, int *cont,
3819 size_t *bytesfit)
3820 {
3821 char *start = pm->pm_value + valueoff, *p, indexchar[32];
3822 size_t len = 0, fit = 0;
3823 int fitlimit = 0, eightbit, maxfit;
3824
3825 *encode = 0;
3826
3827 /*
3828 * Add up the length. First, start with the parameter name.
3829 */
3830
3831 len = strlen(pm->pm_name);
3832
3833 /*
3834 * Scan the parameter value and see if we need to do encoding for this
3835 * section.
3836 */
3837
3838 eightbit = contains8bit(start, NULL);
3839
3840 /*
3841 * Determine if we need to encode this section. Encoding is necessary if:
3842 *
3843 * - There are any 8-bit characters at all and we're on the first
3844 * section.
3845 * - There are 8-bit characters within N bytes of our section start.
3846 * N is calculated based on the number of bytes it would take to
3847 * reach CPERLIN. Specifically:
3848 * 8 (starting tab) +
3849 * strlen(param name) +
3850 * 4 ('* for section marker, '=', opening/closing '"')
3851 * strlen (index)
3852 * is the number of bytes used by everything that isn't part of the
3853 * value. So that gets subtracted from CPERLIN.
3854 */
3855
3856 snprintf(indexchar, sizeof(indexchar), "%d", index);
3857 maxfit = CPERLIN - (12 + len + strlen(indexchar));
3858 if ((eightbit && index == 0) || contains8bit(start, start + maxfit)) {
3859 *encode = 1;
3860 }
3861
3862 len++; /* Add in equal sign */
3863
3864 if (*encode) {
3865 /*
3866 * We're using maxfit as a marker for how many characters we can
3867 * fit into the line. Bump it by two because we're not using quotes
3868 * when encoding.
3869 */
3870
3871 maxfit += 2;
3872
3873 /*
3874 * If we don't have a charset or language tag in this parameter,
3875 * add them now.
3876 */
3877
3878 if (! pm->pm_charset) {
3879 pm->pm_charset = mh_xstrdup(write_charset_8bit());
3880 if (strcasecmp(pm->pm_charset, "US-ASCII") == 0)
3881 adios(NULL, "8-bit characters in parameter \"%s\", but "
3882 "local character set is US-ASCII", pm->pm_name);
3883 }
3884 if (! pm->pm_lang)
3885 pm->pm_lang = mh_xstrdup(""); /* Default to a blank lang tag */
3886
3887 len++; /* For the encoding marker */
3888 maxfit--;
3889 if (index == 0) {
3890 int enclen = strlen(pm->pm_charset) + strlen(pm->pm_lang) + 2;
3891 len += enclen;
3892 maxfit-= enclen;
3893 } else {
3894 /*
3895 * We know we definitely need to include an index. maxfit already
3896 * includes the section marker.
3897 */
3898 len += strlen(indexchar);
3899 }
3900 for (p = start; *p != '\0'; p++) {
3901 if (isparamencode(*p)) {
3902 len += 3;
3903 maxfit -= 3;
3904 } else {
3905 len++;
3906 maxfit--;
3907 }
3908 /*
3909 * Just so there's no confusion: maxfit is counting OUTPUT
3910 * characters (post-encoding). fit is counting INPUT characters.
3911 */
3912 if (! fitlimit && maxfit >= 0)
3913 fit++;
3914 else if (! fitlimit)
3915 fitlimit++;
3916 }
3917 } else {
3918 /*
3919 * Calculate the string length, but add room for quoting \
3920 * and " if necessary. Also account for quotes at beginning
3921 * and end.
3922 */
3923 for (p = start; *p != '\0'; p++) {
3924 switch (*p) {
3925 case '"':
3926 case '\\':
3927 len++;
3928 maxfit--;
3929 /* FALLTHRU */
3930 default:
3931 len++;
3932 maxfit--;
3933 }
3934 if (! fitlimit && maxfit >= 0)
3935 fit++;
3936 else if (! fitlimit)
3937 fitlimit++;
3938 }
3939
3940 len += 2;
3941 }
3942
3943 if (fit < 1)
3944 fit = 1;
3945
3946 *cont = fitlimit;
3947 *bytesfit = fit;
3948
3949 return len;
3950 }
3951
3952 /*
3953 * Output an encoded parameter string.
3954 */
3955
3956 size_t
3957 encode_param(PM pm, char *output, size_t len, size_t valuelen,
3958 size_t valueoff, int index)
3959 {
3960 size_t outlen = 0, n;
3961 char *endptr = output + len, *p;
3962
3963 /*
3964 * First, output the marker for an encoded string.
3965 */
3966
3967 *output++ = '*';
3968 *output++ = '=';
3969 outlen += 2;
3970
3971 /*
3972 * If the index is 0, output the character set and language tag.
3973 * If theses were NULL, they should have already been filled in
3974 * by param_len().
3975 */
3976
3977 if (index == 0) {
3978 n = snprintf(output, len - outlen, "%s'%s'", pm->pm_charset,
3979 pm->pm_lang);
3980 output += n;
3981 outlen += n;
3982 if (output > endptr) {
3983 inform("Internal error: parameter buffer overflow");
3984 return 0;
3985 }
3986 }
3987
3988 /*
3989 * Copy over the value, encoding if necessary
3990 */
3991
3992 p = pm->pm_value + valueoff;
3993 while (valuelen-- > 0) {
3994 if (isparamencode(*p)) {
3995 n = snprintf(output, len - outlen, "%%%02X", (unsigned char) *p++);
3996 output += n;
3997 outlen += n;
3998 } else {
3999 *output++ = *p++;
4000 outlen++;
4001 }
4002 if (output > endptr) {
4003 inform("Internal error: parameter buffer overflow");
4004 return 0;
4005 }
4006 }
4007
4008 *output = '\0';
4009
4010 return outlen;
4011 }
4012
4013 /*
4014 * Output a "normal" parameter, without encoding. Be sure to escape
4015 * quotes and backslashes if necessary.
4016 */
4017
4018 static size_t
4019 normal_param(PM pm, char *output, size_t len, size_t valuelen,
4020 size_t valueoff)
4021 {
4022 size_t outlen = 0;
4023 char *endptr = output + len, *p;
4024
4025 *output++ = '=';
4026 *output++ = '"';
4027 outlen += 2;
4028
4029 p = pm->pm_value + valueoff;
4030
4031 while (valuelen-- > 0) {
4032 switch (*p) {
4033 case '\\':
4034 case '"':
4035 *output++ = '\\';
4036 outlen++;
4037 /* FALLTHRU */
4038 default:
4039 *output++ = *p++;
4040 outlen++;
4041 }
4042 if (output > endptr) {
4043 inform("Internal error: parameter buffer overflow");
4044 return 0;
4045 }
4046 }
4047
4048 if (output - 2 > endptr) {
4049 inform("Internal error: parameter buffer overflow");
4050 return 0;
4051 }
4052
4053 *output++ = '"';
4054 *output++ = '\0';
4055
4056 return outlen + 1;
4057 }
4058
4059 /*
4060 * Add a parameter to the parameter linked list
4061 */
4062
4063 PM
4064 add_param(PM *first, PM *last, char *name, char *value, int nocopy)
4065 {
4066 PM pm;
4067
4068 NEW0(pm);
4069 pm->pm_name = nocopy ? name : getcpy(name);
4070 pm->pm_value = nocopy ? value : getcpy(value);
4071
4072 if (*first) {
4073 (*last)->pm_next = pm;
4074 *last = pm;
4075 } else {
4076 *first = pm;
4077 *last = pm;
4078 }
4079
4080 return pm;
4081 }
4082
4083 /*
4084 * Either replace a current parameter with a new value, or add the parameter
4085 * to the parameter linked list.
4086 */
4087
4088 PM
4089 replace_param(PM *first, PM *last, char *name, char *value, int nocopy)
4090 {
4091 PM pm;
4092
4093 for (pm = *first; pm != NULL; pm = pm->pm_next) {
4094 if (strcasecmp(name, pm->pm_name) == 0) {
4095 /*
4096 * If nocopy is set, it's assumed that we own both name
4097 * and value. We don't need name, so we discard it now.
4098 */
4099 if (nocopy)
4100 free(name);
4101 free(pm->pm_value);
4102 pm->pm_value = nocopy ? value : getcpy(value);
4103 return pm;
4104 }
4105 }
4106
4107 return add_param(first, last, name, value, nocopy);
4108 }
4109
4110 /*
4111 * Retrieve a parameter value from a parameter linked list. If the parameter
4112 * value needs converted to the local character set, do that now.
4113 */
4114
4115 char *
4116 get_param(PM first, const char *name, char replace, int fetchonly)
4117 {
4118 while (first != NULL) {
4119 if (strcasecmp(name, first->pm_name) == 0) {
4120 if (fetchonly)
4121 return first->pm_value;
4122 return getcpy(get_param_value(first, replace));
4123 }
4124 first = first->pm_next;
4125 }
4126
4127 return NULL;
4128 }
4129
4130 /*
4131 * Return a parameter value, converting to the local character set if
4132 * necessary
4133 */
4134
4135 char *get_param_value(PM pm, char replace)
4136 {
4137 static char buffer[4096]; /* I hope no parameters are larger */
4138 size_t bufsize = sizeof(buffer);
4139 #ifdef HAVE_ICONV
4140 size_t inbytes;
4141 int utf8;
4142 iconv_t cd;
4143 ICONV_CONST char *p;
4144 #else /* HAVE_ICONV */
4145 char *p;
4146 #endif /* HAVE_ICONV */
4147
4148 char *q;
4149
4150 /*
4151 * If we don't have a character set indicated, it's assumed to be
4152 * US-ASCII. If it matches our character set, we don't need to convert
4153 * anything.
4154 */
4155
4156 if (!pm->pm_charset || check_charset(pm->pm_charset,
4157 strlen(pm->pm_charset))) {
4158 return pm->pm_value;
4159 }
4160
4161 /*
4162 * In this case, we need to convert. If we have iconv support, use
4163 * that. Otherwise, go through and simply replace every non-ASCII
4164 * character with the substitution character.
4165 */
4166
4167 #ifdef HAVE_ICONV
4168 q = buffer;
4169 bufsize = sizeof(buffer);
4170 utf8 = strcasecmp(pm->pm_charset, "UTF-8") == 0;
4171
4172 cd = iconv_open(get_charset(), pm->pm_charset);
4173 if (cd == (iconv_t) -1) {
4174 goto noiconv;
4175 }
4176
4177 inbytes = strlen(pm->pm_value);
4178 p = pm->pm_value;
4179
4180 while (inbytes) {
4181 if (iconv(cd, &p, &inbytes, &q, &bufsize) == (size_t)-1) {
4182 if (errno != EILSEQ) {
4183 iconv_close(cd);
4184 goto noiconv;
4185 }
4186 /*
4187 * Reset shift state, substitute our character,
4188 * try to restart conversion.
4189 */
4190
4191 iconv(cd, NULL, NULL, &q, &bufsize);
4192
4193 if (bufsize == 0) {
4194 iconv_close(cd);
4195 goto noiconv;
4196 }
4197 *q++ = replace;
4198 bufsize--;
4199 if (bufsize == 0) {
4200 iconv_close(cd);
4201 goto noiconv;
4202 }
4203 if (utf8) {
4204 for (++p, --inbytes;
4205 inbytes > 0 && (((unsigned char) *p) & 0xc0) == 0x80;
4206 ++p, --inbytes)
4207 continue;
4208 } else {
4209 p++;
4210 inbytes--;
4211 }
4212 }
4213 }
4214
4215 iconv_close(cd);
4216
4217 if (bufsize == 0)
4218 q--;
4219 *q = '\0';
4220
4221 return buffer;
4222
4223 noiconv:
4224 #endif /* HAVE_ICONV */
4225
4226 /*
4227 * Take everything non-ASCII and substitute the replacement character
4228 */
4229
4230 q = buffer;
4231 bufsize = sizeof(buffer);
4232 for (p = pm->pm_value; *p != '\0' && bufsize > 1; p++, q++, bufsize--) {
4233 if (isascii((unsigned char) *p) && isprint((unsigned char) *p))
4234 *q = *p;
4235 else
4236 *q = replace;
4237 }
4238
4239 *q = '\0';
4240
4241 return buffer;
4242 }