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