]> diplodocus.org Git - nmh/blob - uip/mhbuildsbr.c
It looks like the first test fails on Solaris because it
[nmh] / uip / mhbuildsbr.c
1
2 /*
3 * mhbuildsbr.c -- routines to expand/translate MIME composition files
4 *
5 * This code is Copyright (c) 2002, by the authors of nmh. See the
6 * COPYRIGHT file in the root directory of the nmh distribution for
7 * complete copyright information.
8 */
9
10 /*
11 * This code was originally part of mhn.c. I split it into
12 * a separate program (mhbuild.c) and then later split it
13 * again (mhbuildsbr.c). But the code still has some of
14 * the mhn.c code in it. This program needs additional
15 * streamlining and removal of unneeded code.
16 */
17
18 #include <h/mh.h>
19 #include <fcntl.h>
20 #include <h/signals.h>
21 #include <h/md5.h>
22 #include <errno.h>
23 #include <signal.h>
24 #include <h/mts.h>
25 #include <h/tws.h>
26 #include <h/mime.h>
27 #include <h/mhparse.h>
28 #include <h/utils.h>
29
30 #ifdef HAVE_SYS_TIME_H
31 # include <sys/time.h>
32 #endif
33 #include <time.h>
34
35
36 extern int debugsw;
37 extern int verbosw;
38
39 extern int listsw;
40 extern int rfc934sw;
41 extern int contentidsw;
42
43 /* cache policies */
44 extern int rcachesw; /* mhcachesbr.c */
45 extern int wcachesw; /* mhcachesbr.c */
46
47 /*
48 * Directory to place tmp files. This must
49 * be set before these routines are called.
50 */
51 char *tmp;
52
53 pid_t xpid = 0;
54
55 static char prefix[] = "----- =_aaaaaaaaaa";
56
57
58 /* mhmisc.c */
59 void content_error (char *, CT, char *, ...);
60
61 /* mhcachesbr.c */
62 int find_cache (CT, int, int *, char *, char *, int);
63
64 /* mhfree.c */
65 void free_content (CT);
66 void free_ctinfo (CT);
67 void free_encoding (CT, int);
68
69 /*
70 * prototypes
71 */
72 CT build_mime (char *, int);
73
74 /*
75 * static prototypes
76 */
77 static int init_decoded_content (CT);
78 static char *fgetstr (char *, int, FILE *);
79 static int user_content (FILE *, char *, char *, CT *);
80 static void set_id (CT, int);
81 static int compose_content (CT);
82 static int scan_content (CT);
83 static int build_headers (CT);
84 static char *calculate_digest (CT, int);
85
86
87 static unsigned char directives_stack[32];
88 static unsigned int directives_index;
89
90 static int do_direct(void)
91 {
92 return directives_stack[directives_index];
93 }
94
95 static void directive_onoff(int onoff)
96 {
97 if (directives_index >= sizeof(directives_stack) - 1) {
98 fprintf(stderr, "mhbuild: #on/off overflow, continuing\n");
99 return;
100 }
101 directives_stack[++directives_index] = onoff;
102 }
103
104 static void directive_init(int onoff)
105 {
106 directives_index = 0;
107 directives_stack[0] = onoff;
108 }
109
110 static void directive_pop(void)
111 {
112 if (directives_index > 0)
113 directives_index--;
114 else
115 fprintf(stderr, "mhbuild: #pop underflow, continuing\n");
116 }
117
118 /*
119 * Main routine for translating composition file
120 * into valid MIME message. It translates the draft
121 * into a content structure (actually a tree of content
122 * structures). This message then can be manipulated
123 * in various ways, including being output via
124 * output_message().
125 */
126
127 CT
128 build_mime (char *infile, int directives)
129 {
130 int compnum, state;
131 char buf[BUFSIZ], name[NAMESZ];
132 char *cp, *np, *vp;
133 struct multipart *m;
134 struct part **pp;
135 CT ct;
136 FILE *in;
137 m_getfld_state_t gstate = 0;
138
139 directive_init(directives);
140
141 umask (~m_gmprot ());
142
143 /* open the composition draft */
144 if ((in = fopen (infile, "r")) == NULL)
145 adios (infile, "unable to open for reading");
146
147 /*
148 * Allocate space for primary (outside) content
149 */
150 if ((ct = (CT) calloc (1, sizeof(*ct))) == NULL)
151 adios (NULL, "out of memory");
152
153 /*
154 * Allocate structure for handling decoded content
155 * for this part. We don't really need this, but
156 * allocate it to remain consistent.
157 */
158 init_decoded_content (ct);
159
160 /*
161 * Parse some of the header fields in the composition
162 * draft into the linked list of header fields for
163 * the new MIME message.
164 */
165 m_getfld_track_filepos (&gstate, in);
166 for (compnum = 1;;) {
167 int bufsz = sizeof buf;
168 switch (state = m_getfld (&gstate, name, buf, &bufsz, in)) {
169 case FLD:
170 case FLDPLUS:
171 compnum++;
172
173 /* abort if draft has Mime-Version header field */
174 if (!mh_strcasecmp (name, VRSN_FIELD))
175 adios (NULL, "draft shouldn't contain %s: field", VRSN_FIELD);
176
177 /* abort if draft has Content-Transfer-Encoding header field */
178 if (!mh_strcasecmp (name, ENCODING_FIELD))
179 adios (NULL, "draft shouldn't contain %s: field", ENCODING_FIELD);
180
181 /* ignore any Content-Type fields in the header */
182 if (!mh_strcasecmp (name, TYPE_FIELD)) {
183 while (state == FLDPLUS) {
184 bufsz = sizeof buf;
185 state = m_getfld (&gstate, name, buf, &bufsz, in);
186 }
187 goto finish_field;
188 }
189
190 /* get copies of the buffers */
191 np = add (name, NULL);
192 vp = add (buf, NULL);
193
194 /* if necessary, get rest of field */
195 while (state == FLDPLUS) {
196 bufsz = sizeof buf;
197 state = m_getfld (&gstate, name, buf, &bufsz, in);
198 vp = add (buf, vp); /* add to previous value */
199 }
200
201 /* Now add the header data to the list */
202 add_header (ct, np, vp);
203
204 finish_field:
205 /* if this wasn't the last header field, then continue */
206 continue;
207
208 case FILEEOF:
209 adios (NULL, "draft has empty body -- no directives!");
210 /* NOTREACHED */
211
212 case BODY:
213 fseek (in, (long) (-strlen (buf)), SEEK_CUR);
214 break;
215
216 case LENERR:
217 case FMTERR:
218 adios (NULL, "message format error in component #%d", compnum);
219
220 default:
221 adios (NULL, "getfld() returned %d", state);
222 }
223 break;
224 }
225 m_getfld_state_destroy (&gstate);
226
227 /*
228 * Now add the MIME-Version header field
229 * to the list of header fields.
230 */
231 np = add (VRSN_FIELD, NULL);
232 vp = concat (" ", VRSN_VALUE, "\n", NULL);
233 add_header (ct, np, vp);
234
235 /*
236 * We initally assume we will find multiple contents in the
237 * draft. So create a multipart/mixed content to hold everything.
238 * We can remove this later, if it is not needed.
239 */
240 if (get_ctinfo ("multipart/mixed", ct, 0) == NOTOK)
241 done (1);
242 ct->c_type = CT_MULTIPART;
243 ct->c_subtype = MULTI_MIXED;
244 ct->c_file = add (infile, NULL);
245
246 if ((m = (struct multipart *) calloc (1, sizeof(*m))) == NULL)
247 adios (NULL, "out of memory");
248 ct->c_ctparams = (void *) m;
249 pp = &m->mp_parts;
250
251 /*
252 * read and parse the composition file
253 * and the directives it contains.
254 */
255 while (fgetstr (buf, sizeof(buf) - 1, in)) {
256 struct part *part;
257 CT p;
258
259 if (user_content (in, infile, buf, &p) == DONE) {
260 admonish (NULL, "ignoring spurious #end");
261 continue;
262 }
263 if (!p)
264 continue;
265
266 if ((part = (struct part *) calloc (1, sizeof(*part))) == NULL)
267 adios (NULL, "out of memory");
268 *pp = part;
269 pp = &part->mp_next;
270 part->mp_part = p;
271 }
272
273 /*
274 * close the composition draft since
275 * it's not needed any longer.
276 */
277 fclose (in);
278
279 /* check if any contents were found */
280 if (!m->mp_parts)
281 adios (NULL, "no content directives found");
282
283 /*
284 * If only one content was found, then remove and
285 * free the outer multipart content.
286 */
287 if (!m->mp_parts->mp_next) {
288 CT p;
289
290 p = m->mp_parts->mp_part;
291 m->mp_parts->mp_part = NULL;
292
293 /* move header fields */
294 p->c_first_hf = ct->c_first_hf;
295 p->c_last_hf = ct->c_last_hf;
296 ct->c_first_hf = NULL;
297 ct->c_last_hf = NULL;
298
299 free_content (ct);
300 ct = p;
301 } else {
302 set_id (ct, 1);
303 }
304
305 /*
306 * Fill out, or expand directives. Parse and execute
307 * commands specified by profile composition strings.
308 */
309 compose_content (ct);
310
311 if ((cp = strchr(prefix, 'a')) == NULL)
312 adios (NULL, "internal error(4)");
313
314 /*
315 * Scan the contents. Choose a transfer encoding, and
316 * check if prefix for multipart boundary clashes with
317 * any of the contents.
318 */
319 while (scan_content (ct) == NOTOK) {
320 if (*cp < 'z') {
321 (*cp)++;
322 } else {
323 if (*++cp == 0)
324 adios (NULL, "giving up trying to find a unique delimiter string");
325 else
326 (*cp)++;
327 }
328 }
329
330 /* Build the rest of the header field structures */
331 build_headers (ct);
332
333 return ct;
334 }
335
336
337 /*
338 * Set up structures for placing unencoded
339 * content when building parts.
340 */
341
342 static int
343 init_decoded_content (CT ct)
344 {
345 CE ce;
346
347 if ((ce = (CE) calloc (1, sizeof(*ce))) == NULL)
348 adios (NULL, "out of memory");
349
350 ct->c_cefile = ce;
351 ct->c_ceopenfnx = open7Bit; /* since unencoded */
352 ct->c_ceclosefnx = close_encoding;
353 ct->c_cesizefnx = NULL; /* since unencoded */
354
355 return OK;
356 }
357
358
359 static char *
360 fgetstr (char *s, int n, FILE *stream)
361 {
362 char *cp, *ep;
363 int o_n = n;
364
365 while(1) {
366 for (ep = (cp = s) + o_n; cp < ep; ) {
367 int i;
368
369 if (!fgets (cp, n, stream))
370 return (cp != s ? s : NULL);
371
372 if (cp == s && *cp != '#')
373 return s;
374
375 cp += (i = strlen (cp)) - 1;
376 if (i <= 1 || *cp-- != '\n' || *cp != '\\')
377 break;
378 *cp = '\0';
379 n -= (i - 2);
380 }
381
382 if (strcmp(s, "#on\n") == 0) {
383 directive_onoff(1);
384 } else if (strcmp(s, "#off\n") == 0) {
385 directive_onoff(0);
386 } else if (strcmp(s, "#pop\n") == 0) {
387 directive_pop();
388 } else {
389 break;
390 }
391 }
392
393 return s;
394 }
395
396
397 /*
398 * Parse the composition draft for text and directives.
399 * Do initial setup of Content structure.
400 */
401
402 static int
403 user_content (FILE *in, char *file, char *buf, CT *ctp)
404 {
405 int extrnal, vrsn;
406 unsigned char *cp;
407 char **ap;
408 char buffer[BUFSIZ];
409 struct multipart *m;
410 struct part **pp;
411 struct stat st;
412 struct str2init *s2i;
413 CI ci;
414 CT ct;
415 CE ce;
416
417 if (buf[0] == '\n' || (do_direct() && strcmp (buf, "#\n") == 0)) {
418 *ctp = NULL;
419 return OK;
420 }
421
422 /* allocate basic Content structure */
423 if ((ct = (CT) calloc (1, sizeof(*ct))) == NULL)
424 adios (NULL, "out of memory");
425 *ctp = ct;
426
427 /* allocate basic structure for handling decoded content */
428 init_decoded_content (ct);
429 ce = ct->c_cefile;
430
431 ci = &ct->c_ctinfo;
432 set_id (ct, 0);
433
434 /*
435 * Handle inline text. Check if line
436 * is one of the following forms:
437 *
438 * 1) doesn't begin with '#' (implicit directive)
439 * 2) begins with "##" (implicit directive)
440 * 3) begins with "#<"
441 */
442 if (!do_direct() || buf[0] != '#' || buf[1] == '#' || buf[1] == '<') {
443 int headers;
444 int inlineD;
445 long pos;
446 char content[BUFSIZ];
447 FILE *out;
448 char *cp;
449
450 cp = m_mktemp2(NULL, invo_name, NULL, &out);
451 if (cp == NULL) adios("mhbuildsbr", "unable to create temporary file");
452
453 /* use a temp file to collect the plain text lines */
454 ce->ce_file = add (cp, NULL);
455 ce->ce_unlink = 1;
456
457 if (do_direct() && (buf[0] == '#' && buf[1] == '<')) {
458 strncpy (content, buf + 2, sizeof(content));
459 inlineD = 1;
460 goto rock_and_roll;
461 } else {
462 inlineD = 0;
463 }
464
465 /* the directive is implicit */
466 strncpy (content, "text/plain", sizeof(content));
467 headers = 0;
468 strncpy (buffer, (!do_direct() || buf[0] != '#') ? buf : buf + 1, sizeof(buffer));
469 for (;;) {
470 int i;
471
472 if (headers >= 0 && do_direct() && uprf (buffer, DESCR_FIELD)
473 && buffer[i = strlen (DESCR_FIELD)] == ':') {
474 headers = 1;
475
476 again_descr:
477 ct->c_descr = add (buffer + i + 1, ct->c_descr);
478 if (!fgetstr (buffer, sizeof(buffer) - 1, in))
479 adios (NULL, "end-of-file after %s: field in plaintext", DESCR_FIELD);
480 switch (buffer[0]) {
481 case ' ':
482 case '\t':
483 i = -1;
484 goto again_descr;
485
486 case '#':
487 adios (NULL, "#-directive after %s: field in plaintext", DESCR_FIELD);
488 /* NOTREACHED */
489
490 default:
491 break;
492 }
493 }
494
495 if (headers >= 0 && do_direct() && uprf (buffer, DISPO_FIELD)
496 && buffer[i = strlen (DISPO_FIELD)] == ':') {
497 headers = 1;
498
499 again_dispo:
500 ct->c_dispo = add (buffer + i + 1, ct->c_dispo);
501 if (!fgetstr (buffer, sizeof(buffer) - 1, in))
502 adios (NULL, "end-of-file after %s: field in plaintext", DISPO_FIELD);
503 switch (buffer[0]) {
504 case ' ':
505 case '\t':
506 i = -1;
507 goto again_dispo;
508
509 case '#':
510 adios (NULL, "#-directive after %s: field in plaintext", DISPO_FIELD);
511 /* NOTREACHED */
512
513 default:
514 break;
515 }
516 }
517
518 if (headers != 1 || buffer[0] != '\n')
519 fputs (buffer, out);
520
521 rock_and_roll:
522 headers = -1;
523 pos = ftell (in);
524 if ((cp = fgetstr (buffer, sizeof(buffer) - 1, in)) == NULL)
525 break;
526 if (do_direct() && buffer[0] == '#') {
527 char *bp;
528
529 if (buffer[1] != '#')
530 break;
531 for (cp = (bp = buffer) + 1; *cp; cp++)
532 *bp++ = *cp;
533 *bp = '\0';
534 }
535 }
536
537 if (listsw)
538 ct->c_end = ftell (out);
539 fclose (out);
540
541 /* parse content type */
542 if (get_ctinfo (content, ct, inlineD) == NOTOK)
543 done (1);
544
545 for (s2i = str2cts; s2i->si_key; s2i++)
546 if (!mh_strcasecmp (ci->ci_type, s2i->si_key))
547 break;
548 if (!s2i->si_key && !uprf (ci->ci_type, "X-"))
549 s2i++;
550
551 /*
552 * check type specified (possibly implicitly)
553 */
554 switch (ct->c_type = s2i->si_val) {
555 case CT_MESSAGE:
556 if (!mh_strcasecmp (ci->ci_subtype, "rfc822")) {
557 ct->c_encoding = CE_7BIT;
558 goto call_init;
559 }
560 /* else fall... */
561 case CT_MULTIPART:
562 adios (NULL, "it doesn't make sense to define an in-line %s content",
563 ct->c_type == CT_MESSAGE ? "message" : "multipart");
564 /* NOTREACHED */
565
566 default:
567 call_init:
568 if ((ct->c_ctinitfnx = s2i->si_init))
569 (*ct->c_ctinitfnx) (ct);
570 break;
571 }
572
573 if (cp)
574 fseek (in, pos, SEEK_SET);
575 return OK;
576 }
577
578 /*
579 * If we've reached this point, the next line
580 * must be some type of explicit directive.
581 */
582
583 /* check if directive is external-type */
584 extrnal = (buf[1] == '@');
585
586 /* parse directive */
587 if (get_ctinfo (buf + (extrnal ? 2 : 1), ct, 1) == NOTOK)
588 done (1);
589
590 /* check directive against the list of MIME types */
591 for (s2i = str2cts; s2i->si_key; s2i++)
592 if (!mh_strcasecmp (ci->ci_type, s2i->si_key))
593 break;
594
595 /*
596 * Check if the directive specified a valid type.
597 * This will happen if it was one of the following forms:
598 *
599 * #type/subtype (or)
600 * #@type/subtype
601 */
602 if (s2i->si_key) {
603 if (!ci->ci_subtype)
604 adios (NULL, "missing subtype in \"#%s\"", ci->ci_type);
605
606 switch (ct->c_type = s2i->si_val) {
607 case CT_MULTIPART:
608 adios (NULL, "use \"#begin ... #end\" instead of \"#%s/%s\"",
609 ci->ci_type, ci->ci_subtype);
610 /* NOTREACHED */
611
612 case CT_MESSAGE:
613 if (!mh_strcasecmp (ci->ci_subtype, "partial"))
614 adios (NULL, "sorry, \"#%s/%s\" isn't supported",
615 ci->ci_type, ci->ci_subtype);
616 if (!mh_strcasecmp (ci->ci_subtype, "external-body"))
617 adios (NULL, "use \"#@type/subtype ... [] ...\" instead of \"#%s/%s\"",
618 ci->ci_type, ci->ci_subtype);
619 use_forw:
620 adios (NULL,
621 "use \"#forw [+folder] [msgs]\" instead of \"#%s/%s\"",
622 ci->ci_type, ci->ci_subtype);
623 /* NOTREACHED */
624
625 default:
626 if ((ct->c_ctinitfnx = s2i->si_init))
627 (*ct->c_ctinitfnx) (ct);
628 break;
629 }
630
631 /*
632 * #@type/subtype (external types directive)
633 */
634 if (extrnal) {
635 struct exbody *e;
636 CT p;
637
638 if (!ci->ci_magic)
639 adios (NULL, "need external information for \"#@%s/%s\"",
640 ci->ci_type, ci->ci_subtype);
641 p = ct;
642
643 snprintf (buffer, sizeof(buffer), "message/external-body; %s", ci->ci_magic);
644 free (ci->ci_magic);
645 ci->ci_magic = NULL;
646
647 /*
648 * Since we are using the current Content structure to
649 * hold information about the type of the external
650 * reference, we need to create another Content structure
651 * for the message/external-body to wrap it in.
652 */
653 if ((ct = (CT) calloc (1, sizeof(*ct))) == NULL)
654 adios (NULL, "out of memory");
655 *ctp = ct;
656 ci = &ct->c_ctinfo;
657 if (get_ctinfo (buffer, ct, 0) == NOTOK)
658 done (1);
659 ct->c_type = CT_MESSAGE;
660 ct->c_subtype = MESSAGE_EXTERNAL;
661
662 if ((e = (struct exbody *) calloc (1, sizeof(*e))) == NULL)
663 adios (NULL, "out of memory");
664 ct->c_ctparams = (void *) e;
665
666 e->eb_parent = ct;
667 e->eb_content = p;
668 p->c_ctexbody = e;
669
670 if (params_external (ct, 1) == NOTOK)
671 done (1);
672
673 return OK;
674 }
675
676 /* Handle [file] argument */
677 if (ci->ci_magic) {
678 /* check if specifies command to execute */
679 if (*ci->ci_magic == '|' || *ci->ci_magic == '!') {
680 for (cp = ci->ci_magic + 1; isspace (*cp); cp++)
681 continue;
682 if (!*cp)
683 adios (NULL, "empty pipe command for #%s directive", ci->ci_type);
684 cp = add (cp, NULL);
685 free (ci->ci_magic);
686 ci->ci_magic = cp;
687 } else {
688 /* record filename of decoded contents */
689 ce->ce_file = ci->ci_magic;
690 if (access (ce->ce_file, R_OK) == NOTOK)
691 adios ("reading", "unable to access %s for", ce->ce_file);
692 if (listsw && stat (ce->ce_file, &st) != NOTOK)
693 ct->c_end = (long) st.st_size;
694 ci->ci_magic = NULL;
695 }
696 return OK;
697 }
698
699 /*
700 * No [file] argument, so check profile for
701 * method to compose content.
702 */
703 snprintf (buffer, sizeof(buffer), "%s-compose-%s/%s",
704 invo_name, ci->ci_type, ci->ci_subtype);
705 if ((cp = context_find (buffer)) == NULL || *cp == '\0') {
706 snprintf (buffer, sizeof(buffer), "%s-compose-%s", invo_name, ci->ci_type);
707 if ((cp = context_find (buffer)) == NULL || *cp == '\0') {
708 content_error (NULL, ct, "don't know how to compose content");
709 done (1);
710 }
711 }
712 ci->ci_magic = add (cp, NULL);
713 return OK;
714 }
715
716 if (extrnal)
717 adios (NULL, "external definition not allowed for \"#%s\"", ci->ci_type);
718
719 /*
720 * Message directive
721 * #forw [+folder] [msgs]
722 */
723 if (!mh_strcasecmp (ci->ci_type, "forw")) {
724 int msgnum;
725 char *folder, *arguments[MAXARGS];
726 struct msgs *mp;
727
728 if (ci->ci_magic) {
729 ap = brkstring (ci->ci_magic, " ", "\n");
730 copyip (ap, arguments, MAXARGS);
731 } else {
732 arguments[0] = "cur";
733 arguments[1] = NULL;
734 }
735 folder = NULL;
736
737 /* search the arguments for a folder name */
738 for (ap = arguments; *ap; ap++) {
739 cp = *ap;
740 if (*cp == '+' || *cp == '@') {
741 if (folder)
742 adios (NULL, "only one folder per #forw directive");
743 else
744 folder = pluspath (cp);
745 }
746 }
747
748 /* else, use the current folder */
749 if (!folder)
750 folder = add (getfolder (1), NULL);
751
752 if (!(mp = folder_read (folder)))
753 adios (NULL, "unable to read folder %s", folder);
754 for (ap = arguments; *ap; ap++) {
755 cp = *ap;
756 if (*cp != '+' && *cp != '@')
757 if (!m_convert (mp, cp))
758 done (1);
759 }
760 free (folder);
761 free_ctinfo (ct);
762
763 /*
764 * If there is more than one message to include, make this
765 * a content of type "multipart/digest" and insert each message
766 * as a subpart. If there is only one message, then make this
767 * a content of type "message/rfc822".
768 */
769 if (mp->numsel > 1) {
770 /* we are forwarding multiple messages */
771 if (get_ctinfo ("multipart/digest", ct, 0) == NOTOK)
772 done (1);
773 ct->c_type = CT_MULTIPART;
774 ct->c_subtype = MULTI_DIGEST;
775
776 if ((m = (struct multipart *) calloc (1, sizeof(*m))) == NULL)
777 adios (NULL, "out of memory");
778 ct->c_ctparams = (void *) m;
779 pp = &m->mp_parts;
780
781 for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++) {
782 if (is_selected(mp, msgnum)) {
783 struct part *part;
784 CT p;
785 CE pe;
786
787 if ((p = (CT) calloc (1, sizeof(*p))) == NULL)
788 adios (NULL, "out of memory");
789 init_decoded_content (p);
790 pe = p->c_cefile;
791 if (get_ctinfo ("message/rfc822", p, 0) == NOTOK)
792 done (1);
793 p->c_type = CT_MESSAGE;
794 p->c_subtype = MESSAGE_RFC822;
795
796 snprintf (buffer, sizeof(buffer), "%s/%d", mp->foldpath, msgnum);
797 pe->ce_file = add (buffer, NULL);
798 if (listsw && stat (pe->ce_file, &st) != NOTOK)
799 p->c_end = (long) st.st_size;
800
801 if ((part = (struct part *) calloc (1, sizeof(*part))) == NULL)
802 adios (NULL, "out of memory");
803 *pp = part;
804 pp = &part->mp_next;
805 part->mp_part = p;
806 }
807 }
808 } else {
809 /* we are forwarding one message */
810 if (get_ctinfo ("message/rfc822", ct, 0) == NOTOK)
811 done (1);
812 ct->c_type = CT_MESSAGE;
813 ct->c_subtype = MESSAGE_RFC822;
814
815 msgnum = mp->lowsel;
816 snprintf (buffer, sizeof(buffer), "%s/%d", mp->foldpath, msgnum);
817 ce->ce_file = add (buffer, NULL);
818 if (listsw && stat (ce->ce_file, &st) != NOTOK)
819 ct->c_end = (long) st.st_size;
820 }
821
822 folder_free (mp); /* free folder/message structure */
823 return OK;
824 }
825
826 /*
827 * #end
828 */
829 if (!mh_strcasecmp (ci->ci_type, "end")) {
830 free_content (ct);
831 *ctp = NULL;
832 return DONE;
833 }
834
835 /*
836 * #begin [ alternative | parallel ]
837 */
838 if (!mh_strcasecmp (ci->ci_type, "begin")) {
839 if (!ci->ci_magic) {
840 vrsn = MULTI_MIXED;
841 cp = SubMultiPart[vrsn - 1].kv_key;
842 } else if (!mh_strcasecmp (ci->ci_magic, "alternative")) {
843 vrsn = MULTI_ALTERNATE;
844 cp = SubMultiPart[vrsn - 1].kv_key;
845 } else if (!mh_strcasecmp (ci->ci_magic, "parallel")) {
846 vrsn = MULTI_PARALLEL;
847 cp = SubMultiPart[vrsn - 1].kv_key;
848 } else if (uprf (ci->ci_magic, "digest")) {
849 goto use_forw;
850 } else {
851 vrsn = MULTI_UNKNOWN;
852 cp = ci->ci_magic;
853 }
854
855 free_ctinfo (ct);
856 snprintf (buffer, sizeof(buffer), "multipart/%s", cp);
857 if (get_ctinfo (buffer, ct, 0) == NOTOK)
858 done (1);
859 ct->c_type = CT_MULTIPART;
860 ct->c_subtype = vrsn;
861
862 if ((m = (struct multipart *) calloc (1, sizeof(*m))) == NULL)
863 adios (NULL, "out of memory");
864 ct->c_ctparams = (void *) m;
865
866 pp = &m->mp_parts;
867 while (fgetstr (buffer, sizeof(buffer) - 1, in)) {
868 struct part *part;
869 CT p;
870
871 if (user_content (in, file, buffer, &p) == DONE) {
872 if (!m->mp_parts)
873 adios (NULL, "empty \"#begin ... #end\" sequence");
874 return OK;
875 }
876 if (!p)
877 continue;
878
879 if ((part = (struct part *) calloc (1, sizeof(*part))) == NULL)
880 adios (NULL, "out of memory");
881 *pp = part;
882 pp = &part->mp_next;
883 part->mp_part = p;
884 }
885 admonish (NULL, "premature end-of-file, missing #end");
886 return OK;
887 }
888
889 /*
890 * Unknown directive
891 */
892 adios (NULL, "unknown directive \"#%s\"", ci->ci_type);
893 return NOTOK; /* NOT REACHED */
894 }
895
896
897 static void
898 set_id (CT ct, int top)
899 {
900 char contentid[BUFSIZ];
901 static int partno;
902 static time_t clock = 0;
903 static char *msgfmt;
904
905 if (clock == 0) {
906 time (&clock);
907 snprintf (contentid, sizeof(contentid), "%s\n", message_id (clock, 1));
908 partno = 0;
909 msgfmt = getcpy(contentid);
910 }
911 snprintf (contentid, sizeof(contentid), msgfmt, top ? 0 : ++partno);
912 ct->c_id = getcpy (contentid);
913 }
914
915
916 /*
917 * Fill out, or expand the various contents in the composition
918 * draft. Read-in any necessary files. Parse and execute any
919 * commands specified by profile composition strings.
920 */
921
922 static int
923 compose_content (CT ct)
924 {
925 CE ce = ct->c_cefile;
926
927 switch (ct->c_type) {
928 case CT_MULTIPART:
929 {
930 int partnum;
931 char *pp;
932 char partnam[BUFSIZ];
933 struct multipart *m = (struct multipart *) ct->c_ctparams;
934 struct part *part;
935
936 if (ct->c_partno) {
937 snprintf (partnam, sizeof(partnam), "%s.", ct->c_partno);
938 pp = partnam + strlen (partnam);
939 } else {
940 pp = partnam;
941 }
942
943 /* first, we call compose_content on all the subparts */
944 for (part = m->mp_parts, partnum = 1; part; part = part->mp_next, partnum++) {
945 CT p = part->mp_part;
946
947 sprintf (pp, "%d", partnum);
948 p->c_partno = add (partnam, NULL);
949 if (compose_content (p) == NOTOK)
950 return NOTOK;
951 }
952
953 /*
954 * If the -rfc934mode switch is given, then check all
955 * the subparts of a multipart/digest. If they are all
956 * message/rfc822, then mark this content and all
957 * subparts with the rfc934 compatibility mode flag.
958 */
959 if (rfc934sw && ct->c_subtype == MULTI_DIGEST) {
960 int is934 = 1;
961
962 for (part = m->mp_parts; part; part = part->mp_next) {
963 CT p = part->mp_part;
964
965 if (p->c_subtype != MESSAGE_RFC822) {
966 is934 = 0;
967 break;
968 }
969 }
970 ct->c_rfc934 = is934;
971 for (part = m->mp_parts; part; part = part->mp_next) {
972 CT p = part->mp_part;
973
974 if ((p->c_rfc934 = is934))
975 p->c_end++;
976 }
977 }
978
979 if (listsw) {
980 ct->c_end = (partnum = strlen (prefix) + 2) + 2;
981 if (ct->c_rfc934)
982 ct->c_end += 1;
983
984 for (part = m->mp_parts; part; part = part->mp_next)
985 ct->c_end += part->mp_part->c_end + partnum;
986 }
987 }
988 break;
989
990 case CT_MESSAGE:
991 /* Nothing to do for type message */
992 break;
993
994 /*
995 * Discrete types (text/application/audio/image/video)
996 */
997 default:
998 if (!ce->ce_file) {
999 pid_t child_id;
1000 int i, xstdout, len, buflen;
1001 char *bp, **ap, *cp;
1002 char *vec[4], buffer[BUFSIZ];
1003 FILE *out;
1004 CI ci = &ct->c_ctinfo;
1005 char *tfile = NULL;
1006
1007 if (!(cp = ci->ci_magic))
1008 adios (NULL, "internal error(5)");
1009
1010 tfile = m_mktemp2(NULL, invo_name, NULL, NULL);
1011 if (tfile == NULL) {
1012 adios("mhbuildsbr", "unable to create temporary file");
1013 }
1014 ce->ce_file = add (tfile, NULL);
1015 ce->ce_unlink = 1;
1016
1017 xstdout = 0;
1018
1019 /* Get buffer ready to go */
1020 bp = buffer;
1021 bp[0] = '\0';
1022 buflen = sizeof(buffer);
1023
1024 /*
1025 * Parse composition string into buffer
1026 */
1027 for ( ; *cp; cp++) {
1028 if (*cp == '%') {
1029 switch (*++cp) {
1030 case 'a':
1031 {
1032 /* insert parameters from directive */
1033 char **ep;
1034 char *s = "";
1035
1036 for (ap = ci->ci_attrs, ep = ci->ci_values; *ap; ap++, ep++) {
1037 snprintf (bp, buflen, "%s%s=\"%s\"", s, *ap, *ep);
1038 len = strlen (bp);
1039 bp += len;
1040 buflen -= len;
1041 s = " ";
1042 }
1043 }
1044 break;
1045
1046 case 'F':
1047 /* %f, and stdout is not-redirected */
1048 xstdout = 1;
1049 /* and fall... */
1050
1051 case 'f':
1052 /*
1053 * insert temporary filename where
1054 * content should be written
1055 */
1056 snprintf (bp, buflen, "%s", ce->ce_file);
1057 break;
1058
1059 case 's':
1060 /* insert content subtype */
1061 strncpy (bp, ci->ci_subtype, buflen);
1062 break;
1063
1064 case '%':
1065 /* insert character % */
1066 goto raw;
1067
1068 default:
1069 *bp++ = *--cp;
1070 *bp = '\0';
1071 buflen--;
1072 continue;
1073 }
1074 len = strlen (bp);
1075 bp += len;
1076 buflen -= len;
1077 } else {
1078 raw:
1079 *bp++ = *cp;
1080 *bp = '\0';
1081 buflen--;
1082 }
1083 }
1084
1085 if (verbosw)
1086 printf ("composing content %s/%s from command\n\t%s\n",
1087 ci->ci_type, ci->ci_subtype, buffer);
1088
1089 fflush (stdout); /* not sure if need for -noverbose */
1090
1091 vec[0] = "/bin/sh";
1092 vec[1] = "-c";
1093 vec[2] = buffer;
1094 vec[3] = NULL;
1095
1096 if ((out = fopen (ce->ce_file, "w")) == NULL)
1097 adios (ce->ce_file, "unable to open for writing");
1098
1099 for (i = 0; (child_id = fork()) == NOTOK && i > 5; i++)
1100 sleep (5);
1101 switch (child_id) {
1102 case NOTOK:
1103 adios ("fork", "unable to fork");
1104 /* NOTREACHED */
1105
1106 case OK:
1107 if (!xstdout)
1108 dup2 (fileno (out), 1);
1109 close (fileno (out));
1110 execvp ("/bin/sh", vec);
1111 fprintf (stderr, "unable to exec ");
1112 perror ("/bin/sh");
1113 _exit (-1);
1114 /* NOTREACHED */
1115
1116 default:
1117 fclose (out);
1118 if (pidXwait(child_id, NULL))
1119 done (1);
1120 break;
1121 }
1122 }
1123
1124 /* Check size of file */
1125 if (listsw && ct->c_end == 0L) {
1126 struct stat st;
1127
1128 if (stat (ce->ce_file, &st) != NOTOK)
1129 ct->c_end = (long) st.st_size;
1130 }
1131 break;
1132 }
1133
1134 return OK;
1135 }
1136
1137
1138 /*
1139 * Scan the content.
1140 *
1141 * 1) choose a transfer encoding.
1142 * 2) check for clashes with multipart boundary string.
1143 * 3) for text content, figure out which character set is being used.
1144 *
1145 * If there is a clash with one of the contents and the multipart boundary,
1146 * this function will exit with NOTOK. This will cause the scanning process
1147 * to be repeated with a different multipart boundary. It is possible
1148 * (although highly unlikely) that this scan will be repeated multiple times.
1149 */
1150
1151 static int
1152 scan_content (CT ct)
1153 {
1154 int len;
1155 int check8bit = 0, contains8bit = 0; /* check if contains 8bit data */
1156 int checklinelen = 0, linelen = 0; /* check for long lines */
1157 int checkboundary = 0, boundaryclash = 0; /* check if clashes with multipart boundary */
1158 int checklinespace = 0, linespace = 0; /* check if any line ends with space */
1159 unsigned char *cp = NULL, buffer[BUFSIZ];
1160 struct text *t = NULL;
1161 FILE *in = NULL;
1162 CE ce = ct->c_cefile;
1163
1164 /*
1165 * handle multipart by scanning all subparts
1166 * and then checking their encoding.
1167 */
1168 if (ct->c_type == CT_MULTIPART) {
1169 struct multipart *m = (struct multipart *) ct->c_ctparams;
1170 struct part *part;
1171
1172 /* initially mark the domain of enclosing multipart as 7bit */
1173 ct->c_encoding = CE_7BIT;
1174
1175 for (part = m->mp_parts; part; part = part->mp_next) {
1176 CT p = part->mp_part;
1177
1178 if (scan_content (p) == NOTOK) /* choose encoding for subpart */
1179 return NOTOK;
1180
1181 /* if necessary, enlarge encoding for enclosing multipart */
1182 if (p->c_encoding == CE_BINARY)
1183 ct->c_encoding = CE_BINARY;
1184 if (p->c_encoding == CE_8BIT && ct->c_encoding != CE_BINARY)
1185 ct->c_encoding = CE_8BIT;
1186 }
1187
1188 return OK;
1189 }
1190
1191 /*
1192 * Decide what to check while scanning this content.
1193 */
1194 switch (ct->c_type) {
1195 case CT_TEXT:
1196 check8bit = 1;
1197 checkboundary = 1;
1198 if (ct->c_subtype == TEXT_PLAIN) {
1199 checklinelen = 0;
1200 checklinespace = 0;
1201 } else {
1202 checklinelen = 1;
1203 checklinespace = 1;
1204 }
1205 break;
1206
1207 case CT_APPLICATION:
1208 check8bit = 1;
1209 checklinelen = 1;
1210 checklinespace = 1;
1211 checkboundary = 1;
1212 break;
1213
1214 case CT_MESSAGE:
1215 check8bit = 0;
1216 checklinelen = 0;
1217 checklinespace = 0;
1218
1219 /* don't check anything for message/external */
1220 if (ct->c_subtype == MESSAGE_EXTERNAL)
1221 checkboundary = 0;
1222 else
1223 checkboundary = 1;
1224 break;
1225
1226 case CT_AUDIO:
1227 case CT_IMAGE:
1228 case CT_VIDEO:
1229 /*
1230 * Don't check anything for these types,
1231 * since we are forcing use of base64.
1232 */
1233 check8bit = 0;
1234 checklinelen = 0;
1235 checklinespace = 0;
1236 checkboundary = 0;
1237 break;
1238 }
1239
1240 /*
1241 * Scan the unencoded content
1242 */
1243 if (check8bit || checklinelen || checklinespace || checkboundary) {
1244 if ((in = fopen (ce->ce_file, "r")) == NULL)
1245 adios (ce->ce_file, "unable to open for reading");
1246 len = strlen (prefix);
1247
1248 while (fgets (buffer, sizeof(buffer) - 1, in)) {
1249 /*
1250 * Check for 8bit data.
1251 */
1252 if (check8bit) {
1253 for (cp = buffer; *cp; cp++) {
1254 if (!isascii (*cp)) {
1255 contains8bit = 1;
1256 check8bit = 0; /* no need to keep checking */
1257 }
1258 }
1259 }
1260
1261 /*
1262 * Check line length.
1263 */
1264 if (checklinelen && (strlen (buffer) > CPERLIN + 1)) {
1265 linelen = 1;
1266 checklinelen = 0; /* no need to keep checking */
1267 }
1268
1269 /*
1270 * Check if line ends with a space.
1271 */
1272 if (checklinespace && (cp = buffer + strlen (buffer) - 2) > buffer && isspace (*cp)) {
1273 linespace = 1;
1274 checklinespace = 0; /* no need to keep checking */
1275 }
1276
1277 /*
1278 * Check if content contains a line that clashes
1279 * with our standard boundary for multipart messages.
1280 */
1281 if (checkboundary && buffer[0] == '-' && buffer[1] == '-') {
1282 for (cp = buffer + strlen (buffer) - 1; cp >= buffer; cp--)
1283 if (!isspace (*cp))
1284 break;
1285 *++cp = '\0';
1286 if (!strncmp(buffer + 2, prefix, len) && isdigit(buffer[2 + len])) {
1287 boundaryclash = 1;
1288 checkboundary = 0; /* no need to keep checking */
1289 }
1290 }
1291 }
1292 fclose (in);
1293 }
1294
1295 /*
1296 * Decide which transfer encoding to use.
1297 */
1298 switch (ct->c_type) {
1299 case CT_TEXT:
1300 /*
1301 * If the text content didn't specify a character
1302 * set, we need to figure out which one was used.
1303 */
1304 t = (struct text *) ct->c_ctparams;
1305 if (t->tx_charset == CHARSET_UNSPECIFIED) {
1306 CI ci = &ct->c_ctinfo;
1307 char **ap, **ep;
1308
1309 for (ap = ci->ci_attrs, ep = ci->ci_values; *ap; ap++, ep++)
1310 continue;
1311
1312 if (contains8bit) {
1313 *ap = concat ("charset=", write_charset_8bit(), NULL);
1314 } else {
1315 *ap = add ("charset=us-ascii", NULL);
1316 }
1317 t->tx_charset = CHARSET_SPECIFIED;
1318
1319 cp = strchr(*ap++, '=');
1320 *ap = NULL;
1321 *cp++ = '\0';
1322 *ep = cp;
1323 }
1324
1325 if (contains8bit || linelen || linespace || checksw)
1326 ct->c_encoding = CE_QUOTED;
1327 else
1328 ct->c_encoding = CE_7BIT;
1329 break;
1330
1331 case CT_APPLICATION:
1332 /* For application type, use base64, except when postscript */
1333 if (contains8bit || linelen || linespace || checksw)
1334 ct->c_encoding = (ct->c_subtype == APPLICATION_POSTSCRIPT)
1335 ? CE_QUOTED : CE_BASE64;
1336 else
1337 ct->c_encoding = CE_7BIT;
1338 break;
1339
1340 case CT_MESSAGE:
1341 ct->c_encoding = CE_7BIT;
1342 break;
1343
1344 case CT_AUDIO:
1345 case CT_IMAGE:
1346 case CT_VIDEO:
1347 /* For audio, image, and video contents, just use base64 */
1348 ct->c_encoding = CE_BASE64;
1349 break;
1350 }
1351
1352 return (boundaryclash ? NOTOK : OK);
1353 }
1354
1355
1356 /*
1357 * Scan the content structures, and build header
1358 * fields that will need to be output into the
1359 * message.
1360 */
1361
1362 static int
1363 build_headers (CT ct)
1364 {
1365 int cc, mailbody, len;
1366 char **ap, **ep;
1367 char *np, *vp, buffer[BUFSIZ];
1368 CI ci = &ct->c_ctinfo;
1369
1370 /*
1371 * If message is type multipart, then add the multipart
1372 * boundary to the list of attribute/value pairs.
1373 */
1374 if (ct->c_type == CT_MULTIPART) {
1375 char *cp;
1376 static int level = 0; /* store nesting level */
1377
1378 ap = ci->ci_attrs;
1379 ep = ci->ci_values;
1380 snprintf (buffer, sizeof(buffer), "boundary=%s%d", prefix, level++);
1381 cp = strchr(*ap++ = add (buffer, NULL), '=');
1382 *ap = NULL;
1383 *cp++ = '\0';
1384 *ep = cp;
1385 }
1386
1387 /*
1388 * Skip the output of Content-Type, parameters, content
1389 * description and disposition, and Content-ID if the
1390 * content is of type "message" and the rfc934 compatibility
1391 * flag is set (which means we are inside multipart/digest
1392 * and the switch -rfc934mode was given).
1393 */
1394 if (ct->c_type == CT_MESSAGE && ct->c_rfc934)
1395 goto skip_headers;
1396
1397 /*
1398 * output the content type and subtype
1399 */
1400 np = add (TYPE_FIELD, NULL);
1401 vp = concat (" ", ci->ci_type, "/", ci->ci_subtype, NULL);
1402
1403 /* keep track of length of line */
1404 len = strlen (TYPE_FIELD) + strlen (ci->ci_type)
1405 + strlen (ci->ci_subtype) + 3;
1406
1407 mailbody = ct->c_type == CT_MESSAGE
1408 && ct->c_subtype == MESSAGE_EXTERNAL
1409 && ((struct exbody *) ct->c_ctparams)->eb_body;
1410
1411 /*
1412 * Append the attribute/value pairs to
1413 * the end of the Content-Type line.
1414 */
1415 for (ap = ci->ci_attrs, ep = ci->ci_values; *ap; ap++, ep++) {
1416 if (mailbody && !mh_strcasecmp (*ap, "body"))
1417 continue;
1418
1419 vp = add (";", vp);
1420 len++;
1421
1422 snprintf (buffer, sizeof(buffer), "%s=\"%s\"", *ap, *ep);
1423 if (len + 1 + (cc = strlen (buffer)) >= CPERLIN) {
1424 vp = add ("\n\t", vp);
1425 len = 8;
1426 } else {
1427 vp = add (" ", vp);
1428 len++;
1429 }
1430 vp = add (buffer, vp);
1431 len += cc;
1432 }
1433
1434 /*
1435 * Append any RFC-822 comment to the end of
1436 * the Content-Type line.
1437 */
1438 if (ci->ci_comment) {
1439 snprintf (buffer, sizeof(buffer), "(%s)", ci->ci_comment);
1440 if (len + 1 + (cc = 2 + strlen (ci->ci_comment)) >= CPERLIN) {
1441 vp = add ("\n\t", vp);
1442 len = 8;
1443 } else {
1444 vp = add (" ", vp);
1445 len++;
1446 }
1447 vp = add (buffer, vp);
1448 len += cc;
1449 }
1450 vp = add ("\n", vp);
1451 add_header (ct, np, vp);
1452
1453 /*
1454 * output the Content-ID, unless disabled by -nocontentid
1455 */
1456 if (contentidsw && ct->c_id) {
1457 np = add (ID_FIELD, NULL);
1458 vp = concat (" ", ct->c_id, NULL);
1459 add_header (ct, np, vp);
1460 }
1461
1462 /*
1463 * output the Content-Description
1464 */
1465 if (ct->c_descr) {
1466 np = add (DESCR_FIELD, NULL);
1467 vp = concat (" ", ct->c_descr, NULL);
1468 add_header (ct, np, vp);
1469 }
1470
1471 /*
1472 * output the Content-Disposition
1473 */
1474 if (ct->c_dispo) {
1475 np = add (DISPO_FIELD, NULL);
1476 vp = concat (" ", ct->c_dispo, NULL);
1477 add_header (ct, np, vp);
1478 }
1479
1480 skip_headers:
1481 /*
1482 * If this is the internal content structure for a
1483 * "message/external", then we are done with the
1484 * headers (since it has no body).
1485 */
1486 if (ct->c_ctexbody)
1487 return OK;
1488
1489 /*
1490 * output the Content-MD5
1491 */
1492 if (checksw) {
1493 np = add (MD5_FIELD, NULL);
1494 vp = calculate_digest (ct, (ct->c_encoding == CE_QUOTED) ? 1 : 0);
1495 add_header (ct, np, vp);
1496 }
1497
1498 /*
1499 * output the Content-Transfer-Encoding
1500 */
1501 switch (ct->c_encoding) {
1502 case CE_7BIT:
1503 /* Nothing to output */
1504 break;
1505
1506 case CE_8BIT:
1507 if (ct->c_type == CT_MESSAGE)
1508 adios (NULL, "internal error, invalid encoding");
1509
1510 np = add (ENCODING_FIELD, NULL);
1511 vp = concat (" ", "8bit", "\n", NULL);
1512 add_header (ct, np, vp);
1513 break;
1514
1515 case CE_QUOTED:
1516 if (ct->c_type == CT_MESSAGE || ct->c_type == CT_MULTIPART)
1517 adios (NULL, "internal error, invalid encoding");
1518
1519 np = add (ENCODING_FIELD, NULL);
1520 vp = concat (" ", "quoted-printable", "\n", NULL);
1521 add_header (ct, np, vp);
1522 break;
1523
1524 case CE_BASE64:
1525 if (ct->c_type == CT_MESSAGE || ct->c_type == CT_MULTIPART)
1526 adios (NULL, "internal error, invalid encoding");
1527
1528 np = add (ENCODING_FIELD, NULL);
1529 vp = concat (" ", "base64", "\n", NULL);
1530 add_header (ct, np, vp);
1531 break;
1532
1533 case CE_BINARY:
1534 if (ct->c_type == CT_MESSAGE)
1535 adios (NULL, "internal error, invalid encoding");
1536
1537 np = add (ENCODING_FIELD, NULL);
1538 vp = concat (" ", "binary", "\n", NULL);
1539 add_header (ct, np, vp);
1540 break;
1541
1542 default:
1543 adios (NULL, "unknown transfer encoding in content");
1544 break;
1545 }
1546
1547 /*
1548 * Additional content specific header processing
1549 */
1550 switch (ct->c_type) {
1551 case CT_MULTIPART:
1552 {
1553 struct multipart *m;
1554 struct part *part;
1555
1556 m = (struct multipart *) ct->c_ctparams;
1557 for (part = m->mp_parts; part; part = part->mp_next) {
1558 CT p;
1559
1560 p = part->mp_part;
1561 build_headers (p);
1562 }
1563 }
1564 break;
1565
1566 case CT_MESSAGE:
1567 if (ct->c_subtype == MESSAGE_EXTERNAL) {
1568 struct exbody *e;
1569
1570 e = (struct exbody *) ct->c_ctparams;
1571 build_headers (e->eb_content);
1572 }
1573 break;
1574
1575 default:
1576 /* Nothing to do */
1577 break;
1578 }
1579
1580 return OK;
1581 }
1582
1583
1584 static char nib2b64[0x40+1] =
1585 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
1586
1587 static char *
1588 calculate_digest (CT ct, int asciiP)
1589 {
1590 int cc;
1591 char buffer[BUFSIZ], *vp, *op;
1592 unsigned char *dp;
1593 unsigned char digest[16];
1594 unsigned char outbuf[25];
1595 MD5_CTX mdContext;
1596 CE ce = ct->c_cefile;
1597 char *infilename = ce->ce_file ? ce->ce_file : ct->c_file;
1598 FILE *in;
1599
1600 /* open content */
1601 if ((in = fopen (infilename, "r")) == NULL)
1602 adios (infilename, "unable to open for reading");
1603
1604 /* Initialize md5 context */
1605 MD5Init (&mdContext);
1606
1607 /* calculate md5 message digest */
1608 if (asciiP) {
1609 while (fgets (buffer, sizeof(buffer) - 1, in)) {
1610 char c, *cp;
1611
1612 cp = buffer + strlen (buffer) - 1;
1613 if ((c = *cp) == '\n')
1614 *cp = '\0';
1615
1616 MD5Update (&mdContext, (unsigned char *) buffer,
1617 (unsigned int) strlen (buffer));
1618
1619 if (c == '\n')
1620 MD5Update (&mdContext, (unsigned char *) "\r\n", 2);
1621 }
1622 } else {
1623 while ((cc = fread (buffer, sizeof(*buffer), sizeof(buffer), in)) > 0)
1624 MD5Update (&mdContext, (unsigned char *) buffer, (unsigned int) cc);
1625 }
1626
1627 /* md5 finalization. Write digest and zero md5 context */
1628 MD5Final (digest, &mdContext);
1629
1630 /* close content */
1631 fclose (in);
1632
1633 /* print debugging info */
1634 if (debugsw) {
1635 unsigned char *ep;
1636
1637 fprintf (stderr, "MD5 digest=");
1638 for (ep = (dp = digest) + sizeof(digest) / sizeof(digest[0]);
1639 dp < ep; dp++)
1640 fprintf (stderr, "%02x", *dp & 0xff);
1641 fprintf (stderr, "\n");
1642 }
1643
1644 /* encode the digest using base64 */
1645 for (dp = digest, op = outbuf, cc = sizeof(digest) / sizeof(digest[0]);
1646 cc > 0; cc -= 3, op += 4) {
1647 unsigned long bits;
1648 char *bp;
1649
1650 bits = (*dp++ & 0xff) << 16;
1651 if (cc > 1) {
1652 bits |= (*dp++ & 0xff) << 8;
1653 if (cc > 2)
1654 bits |= *dp++ & 0xff;
1655 }
1656
1657 for (bp = op + 4; bp > op; bits >>= 6)
1658 *--bp = nib2b64[bits & 0x3f];
1659 if (cc < 3) {
1660 *(op + 3) = '=';
1661 if (cc < 2)
1662 *(op + 2) = '=';
1663 }
1664 }
1665
1666 /* null terminate string */
1667 outbuf[24] = '\0';
1668
1669 /* now make copy and return string */
1670 vp = concat (" ", outbuf, "\n", NULL);
1671 return vp;
1672 }