?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Drop `customhdr' again (keep *customhdr*): `~^' is better!
[s-mailx.git] / sendout.c
blobf63ec996b8b9cd7876cec1e178ba2a2c4a1b3a9c
1 /*@ S-nail - a mail user agent derived from Berkeley Mail.
2 *@ Message sending lifecycle, header composing, etc.
3 *
4 * Copyright (c) 2000-2004 Gunnar Ritter, Freiburg i. Br., Germany.
5 * Copyright (c) 2012 - 2016 Steffen (Daode) Nurpmeso <steffen@sdaoden.eu>.
6 */
7 /*
8 * Copyright (c) 1980, 1993
9 * The Regents of the University of California. All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 * 3. Neither the name of the University nor the names of its contributors
20 * may be used to endorse or promote products derived from this software
21 * without specific prior written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * SUCH DAMAGE.
34 */
35 #undef n_FILE
36 #define n_FILE sendout
37
38 #ifndef HAVE_AMALGAMATION
39 # include "nail.h"
40 #endif
41
42 #undef SEND_LINESIZE
43 #define SEND_LINESIZE \
44 ((1024 / B64_ENCODE_INPUT_PER_LINE) * B64_ENCODE_INPUT_PER_LINE)
45
46 enum fmt_flags {
47 FMT_DOMIME = 1<<0,
48 FMT_COMMA = GCOMMA,
49 FMT_FILES = GFILES,
50 _FMT_GMASK = FMT_COMMA | FMT_FILES
51 };
52 n_CTA(!(_FMT_GMASK & FMT_DOMIME),
53 "Code-required condition not satisfied but actual bit carrier value");
54
55 static char const *__sendout_ident; /* TODO temporary hack; rewrite puthead() */
56 static char * _sendout_boundary;
57 static si8_t _sendout_error;
58
59 /* */
60 static enum okay _putname(char const *line, enum gfield w,
61 enum sendaction action, size_t *gotcha,
62 char const *prefix, FILE *fo, struct name **xp,
63 enum gfield addflags);
64
65 /* Place Content-Type:, Content-Transfer-Encoding:, Content-Disposition:
66 * headers, respectively */
67 static int _put_ct(FILE *fo, char const *contenttype,
68 char const *charset);
69 SINLINE int _put_cte(FILE *fo, enum conversion conv);
70 static int _put_cd(FILE *fo, char const *cd, char const *filename);
71
72 /* Put all entries of the given header list */
73 static bool_t _sendout_header_list(FILE *fo, struct n_header_field *hfp,
74 bool_t nodisp);
75
76 /* Write an attachment to the file buffer, converting to MIME */
77 static int _attach_file(struct attachment *ap, FILE *fo);
78 static int __attach_file(struct attachment *ap, FILE *fo);
79
80 /* There are non-local receivers, collect credentials etc. */
81 static bool_t _sendbundle_setup_creds(struct sendbundle *sbpm,
82 bool_t signing_caps);
83
84 /* Attach a message to the file buffer */
85 static int attach_message(struct attachment *ap, FILE *fo);
86
87 /* Generate the body of a MIME multipart message */
88 static int make_multipart(struct header *hp, int convert, FILE *fi,
89 FILE *fo, char const *contenttype, char const *charset);
90
91 /* Prepend a header in front of the collected stuff and return the new file */
92 static FILE * infix(struct header *hp, FILE *fi);
93
94 /* Check whether Disposition-Notification-To: is desired */
95 static bool_t _check_dispo_notif(struct name *mdn, struct header *hp,
96 FILE *fo);
97
98 /* Send mail to a bunch of user names. The interface is through mail() */
99 static int sendmail_internal(void *v, int recipient_record);
100
101 /* Deal with file and pipe addressees */
102 static struct name * _outof(struct name *names, FILE *fo, bool_t *senderror);
103
104 /* Record outgoing mail if instructed to do so; in *record* unless to is set */
105 static bool_t mightrecord(FILE *fp, struct name *to, bool_t resend);
106
107 static bool_t a_sendout__savemail(char const *name, FILE *fp, bool_t resend);
108
109 /* */
110 static bool_t _transfer(struct sendbundle *sbp);
111
112 static bool_t __mta_start(struct sendbundle *sbp);
113 static char const ** __mta_prepare_args(struct name *to, struct header *hp);
114 static void __mta_debug(struct sendbundle *sbp, char const *mta,
115 char const **args);
116
117 /* Create a Message-ID: header field. Use either host name or from address */
118 static char * _message_id(struct header *hp);
119
120 /* Format the given header line to not exceed 72 characters */
121 static int fmt(char const *str, struct name *np, FILE *fo,
122 enum fmt_flags ff);
123
124 /* Rewrite a message for resending, adding the Resent-Headers */
125 static int infix_resend(FILE *fi, FILE *fo, struct message *mp,
126 struct name *to, int add_resent);
127
128 static enum okay
129 _putname(char const *line, enum gfield w, enum sendaction action,
130 size_t *gotcha, char const *prefix, FILE *fo, struct name **xp,
131 enum gfield addflags)
132 {
133 struct name *np;
134 enum okay rv = STOP;
135 NYD_ENTER;
136
137 np = lextract(line, GEXTRA | GFULL | addflags);
138 if (xp != NULL)
139 *xp = np;
140 if (np == NULL)
141 ;
142 else if (fmt(prefix, np, fo, ((w & GCOMMA) |
143 ((action != SEND_TODISP) ? FMT_DOMIME : 0))))
144 rv = OKAY;
145 else if (gotcha != NULL)
146 ++(*gotcha);
147 NYD_LEAVE;
148 return rv;
149 }
150
151 static int
152 _put_ct(FILE *fo, char const *contenttype, char const *charset)
153 {
154 int rv, i;
155 NYD2_ENTER;
156
157 if ((rv = fprintf(fo, "Content-Type: %s", contenttype)) < 0)
158 goto jerr;
159
160 if (charset == NULL)
161 goto jend;
162
163 if (putc(';', fo) == EOF)
164 goto jerr;
165 ++rv;
166
167 if (strlen(contenttype) + sizeof("Content-Type: ;")-1 > 50) {
168 if (putc('\n', fo) == EOF)
169 goto jerr;
170 ++rv;
171 }
172
173 /* C99 */{
174 size_t l = strlen(charset);
175 char *lcs = salloc(l +1);
176
177 for(l = 0; *charset != '\0'; ++l, ++charset)
178 lcs[l] = lowerconv(*charset);
179 lcs[l] = '\0';
180 charset = lcs;
181 }
182 if ((i = fprintf(fo, " charset=%s", charset)) < 0)
183 goto jerr;
184 rv += i;
185
186 jend:
187 if (putc('\n', fo) == EOF)
188 goto jerr;
189 ++rv;
190 jleave:
191 NYD2_LEAVE;
192 return rv;
193 jerr:
194 rv = -1;
195 goto jleave;
196 }
197
198 SINLINE int
199 _put_cte(FILE *fo, enum conversion conv)
200 {
201 int rv;
202 NYD2_ENTER;
203
204 /* RFC 2045, 6.1.:
205 * This is the default value -- that is,
206 * "Content-Transfer-Encoding: 7BIT" is assumed if the
207 * Content-Transfer-Encoding header field is not present.
208 */
209 rv = (conv == CONV_7BIT) ? 0
210 : fprintf(fo, "Content-Transfer-Encoding: %s\n",
211 mime_enc_from_conversion(conv));
212 NYD2_LEAVE;
213 return rv;
214 }
215
216 static int
217 _put_cd(FILE *fo, char const *cd, char const *filename)
218 {
219 struct str f;
220 si8_t mpc;
221 int rv;
222 NYD2_ENTER;
223
224 f.s = NULL;
225
226 /* xxx Ugly with the trailing space in case of wrap! */
227 if ((rv = fprintf(fo, "Content-Disposition: %s; ", cd)) < 0)
228 goto jerr;
229
230 if (!(mpc = mime_param_create(&f, "filename", filename)))
231 goto jerr;
232 /* Always fold if result contains newlines */
233 if (mpc < 0 || f.l + rv > MIME_LINELEN) { /* FIXME MIME_LINELEN_MAX */
234 if (putc('\n', fo) == EOF || putc(' ', fo) == EOF)
235 goto jerr;
236 rv += 2;
237 }
238 if (fputs(f.s, fo) == EOF || putc('\n', fo) == EOF)
239 goto jerr;
240 rv += (int)++f.l;
241
242 jleave:
243 NYD2_LEAVE;
244 return rv;
245 jerr:
246 rv = -1;
247 goto jleave;
248
249 }
250
251 static bool_t
252 _sendout_header_list(FILE *fo, struct n_header_field *hfp, bool_t nodisp){
253 bool_t rv;
254 NYD2_ENTER;
255
256 for(rv = TRU1; hfp != NULL; hfp = hfp->hf_next)
257 if(fwrite(hfp->hf_dat, sizeof(char), hfp->hf_nl, fo) != hfp->hf_nl ||
258 putc(':', fo) == EOF || putc(' ', fo) == EOF ||
259 xmime_write(hfp->hf_dat + hfp->hf_nl +1, hfp->hf_bl, fo,
260 (!nodisp ? CONV_NONE : CONV_TOHDR),
261 (!nodisp ? TD_ISPR | TD_ICONV : TD_ICONV)) < 0 ||
262 putc('\n', fo) == EOF){
263 rv = FAL0;
264 break;
265 }
266 NYD_LEAVE;
267 return rv;
268 }
269
270 static int
271 _attach_file(struct attachment *ap, FILE *fo)
272 {
273 /* TODO of course, the MIME classification needs to performed once
274 * TODO only, not for each and every charset anew ... ;-// */
275 char *charset_iter_orig[2];
276 long offs;
277 int err = 0;
278 NYD_ENTER;
279
280 /* Is this already in target charset? Simply copy over */
281 if (ap->a_conv == AC_TMPFILE) {
282 err = __attach_file(ap, fo);
283 Fclose(ap->a_tmpf);
284 DBG( ap->a_tmpf = NULL; )
285 goto jleave;
286 }
287
288 /* If we don't apply charset conversion at all (fixed input=ouput charset)
289 * we also simply copy over, since it's the users desire */
290 if (ap->a_conv == AC_FIX_INCS) {
291 ap->a_charset = ap->a_input_charset;
292 err = __attach_file(ap, fo);
293 goto jleave;
294 }
295
296 /* Otherwise we need to iterate over all possible output charsets */
297 if ((offs = ftell(fo)) == -1) {
298 err = EIO;
299 goto jleave;
300 }
301 charset_iter_recurse(charset_iter_orig);
302 for (charset_iter_reset(NULL);; charset_iter_next()) {
303 if (!charset_iter_is_valid()) {
304 err = EILSEQ;
305 break;
306 }
307 err = __attach_file(ap, fo);
308 if (err == 0 || (err != EILSEQ && err != EINVAL))
309 break;
310 clearerr(fo);
311 if (fseek(fo, offs, SEEK_SET) == -1) {
312 err = EIO;
313 break;
314 }
315 if (ap->a_conv != AC_DEFAULT) {
316 err = EILSEQ;
317 break;
318 }
319 ap->a_charset = NULL;
320 }
321 charset_iter_restore(charset_iter_orig);
322 jleave:
323 NYD_LEAVE;
324 return err;
325 }
326
327 static int
328 __attach_file(struct attachment *ap, FILE *fo) /* XXX linelength */
329 {
330 int err = 0, do_iconv;
331 FILE *fi;
332 char const *charset;
333 enum conversion convert;
334 char *buf;
335 size_t bufsize, lncnt, inlen;
336 NYD_ENTER;
337
338 /* Either charset-converted temporary file, or plain path */
339 if (ap->a_conv == AC_TMPFILE) {
340 fi = ap->a_tmpf;
341 assert(ftell(fi) == 0);
342 } else if ((fi = Fopen(ap->a_name, "r")) == NULL) {
343 err = errno;
344 n_err(_("%s: %s\n"), n_shexp_quote_cp(ap->a_name, FAL0), strerror(err));
345 goto jleave;
346 }
347
348 /* MIME part header for attachment */
349 { char const *bn = ap->a_name, *ct;
350
351 if ((ct = strrchr(bn, '/')) != NULL)
352 bn = ++ct;
353 ct = ap->a_content_type;
354 charset = ap->a_charset;
355 convert = mime_type_classify_file(fi, (char const**)&ct,
356 &charset, &do_iconv);
357 if (charset == NULL || ap->a_conv == AC_FIX_INCS ||
358 ap->a_conv == AC_TMPFILE)
359 do_iconv = 0;
360
361 if (fprintf(fo, "\n--%s\n", _sendout_boundary) < 0 ||
362 _put_ct(fo, ct, charset) < 0 || _put_cte(fo, convert) < 0 ||
363 _put_cd(fo, ap->a_content_disposition, bn) < 0)
364 goto jerr_header;
365
366 if ((bn = ap->a_content_id) != NULL &&
367 fprintf(fo, "Content-ID: %s\n", bn) == -1)
368 goto jerr_header;
369
370 if ((bn = ap->a_content_description) != NULL &&
371 fprintf(fo, "Content-Description: %s\n", bn) == -1) /* TODO MIME! */
372 goto jerr_header;
373
374 if (putc('\n', fo) == EOF) {
375 jerr_header:
376 err = errno;
377 goto jerr_fclose;
378 }
379 }
380
381 #ifdef HAVE_ICONV
382 if (iconvd != (iconv_t)-1)
383 n_iconv_close(iconvd);
384 if (do_iconv) {
385 char const *tcs = charset_get_lc();
386 if (asccasecmp(charset, tcs) &&
387 (iconvd = n_iconv_open(charset, tcs)) == (iconv_t)-1 &&
388 (err = errno) != 0) {
389 if (err == EINVAL)
390 n_err(_("Cannot convert from %s to %s\n"), tcs, charset);
391 else
392 n_err(_("iconv_open: %s\n"), strerror(err));
393 goto jerr_fclose;
394 }
395 }
396 #endif
397
398 bufsize = SEND_LINESIZE;
399 buf = smalloc(bufsize);
400 if (convert == CONV_TOQP
401 #ifdef HAVE_ICONV
402 || iconvd != (iconv_t)-1
403 #endif
404 )
405 lncnt = fsize(fi);
406 for (;;) {
407 if (convert == CONV_TOQP
408 #ifdef HAVE_ICONV
409 || iconvd != (iconv_t)-1
410 #endif
411 ) {
412 if (fgetline(&buf, &bufsize, &lncnt, &inlen, fi, 0) == NULL)
413 break;
414 } else if ((inlen = fread(buf, sizeof *buf, bufsize, fi)) == 0)
415 break;
416 if (xmime_write(buf, inlen, fo, convert, TD_ICONV) < 0) {
417 err = errno;
418 goto jerr;
419 }
420 }
421 if (ferror(fi))
422 err = EDOM;
423 jerr:
424 free(buf);
425 jerr_fclose:
426 if (ap->a_conv != AC_TMPFILE)
427 Fclose(fi);
428 jleave:
429 NYD_LEAVE;
430 return err;
431 }
432
433 static bool_t
434 _sendbundle_setup_creds(struct sendbundle *sbp, bool_t signing_caps)
435 {
436 bool_t v15, rv = FAL0;
437 char *shost, *from;
438 #ifdef HAVE_SMTP
439 char const *smtp;
440 #endif
441 NYD_ENTER;
442
443 v15 = ok_blook(v15_compat);
444 shost = (v15 ? ok_vlook(smtp_hostname) : NULL);
445 from = ((signing_caps || !v15 || shost == NULL)
446 ? skin(myorigin(sbp->sb_hp)) : NULL);
447
448 if (signing_caps) {
449 if (from == NULL) {
450 #ifdef HAVE_SSL
451 n_err(_("No *from* address for signing specified\n"));
452 goto jleave;
453 #endif
454 } else
455 sbp->sb_signer.l = strlen(sbp->sb_signer.s = from);
456 }
457
458 #ifdef HAVE_SMTP
459 if ((smtp = ok_vlook(smtp)) == NULL) { /* TODO v15 url_creat(,ok_vlook(mta)*/
460 char const *proto;
461
462 /* *smtp* OBSOLETE message in mta_start() */
463 if ((smtp = ok_vlook(mta)) == NULL ||
464 (proto = n_servbyname(smtp, NULL)) == NULL || *proto == '\0') {
465 rv = TRU1;
466 goto jleave;
467 }
468 }
469
470 if (!url_parse(&sbp->sb_url, CPROTO_SMTP, smtp))
471 goto jleave;
472
473 if (v15) {
474 if (shost == NULL) {
475 if (from == NULL)
476 goto jenofrom;
477 sbp->sb_url.url_u_h.l = strlen(sbp->sb_url.url_u_h.s = from);
478 } else
479 __sendout_ident = sbp->sb_url.url_u_h.s;
480 if (!ccred_lookup(&sbp->sb_ccred, &sbp->sb_url))
481 goto jleave;
482 } else {
483 if (sbp->sb_url.url_had_user || sbp->sb_url.url_pass.s != NULL) {
484 n_err(_("New-style URL used without *v15-compat* being set\n"));
485 goto jleave;
486 }
487 /* TODO part of the entire myorigin() disaster, get rid of this! */
488 if (from == NULL) {
489 jenofrom:
490 n_err(_("Your configuration requires a *from* address, "
491 "but none was given\n"));
492 goto jleave;
493 }
494 if (!ccred_lookup_old(&sbp->sb_ccred, CPROTO_SMTP, from))
495 goto jleave;
496 sbp->sb_url.url_u_h.l = strlen(sbp->sb_url.url_u_h.s = from);
497 }
498
499 rv = TRU1;
500 #endif /* HAVE_SMTP */
501 #if defined HAVE_SSL || defined HAVE_SMTP
502 jleave:
503 #endif
504 NYD_LEAVE;
505 return rv;
506 }
507
508 static int
509 attach_message(struct attachment *ap, FILE *fo)
510 {
511 struct message *mp;
512 char const *ccp;
513 int rv;
514 NYD_ENTER;
515
516 fprintf(fo, "\n--%s\nContent-Type: message/rfc822\n"
517 "Content-Disposition: inline\n", _sendout_boundary);
518 if ((ccp = ap->a_content_description) != NULL)
519 fprintf(fo, "Content-Description: %s\n", ccp);/* TODO MIME! */
520 putc('\n', fo);
521
522 mp = message + ap->a_msgno - 1;
523 touch(mp);
524 rv = (sendmp(mp, fo, 0, NULL, SEND_RFC822, NULL) < 0) ? -1 : 0;
525 NYD_LEAVE;
526 return rv;
527 }
528
529 static int
530 make_multipart(struct header *hp, int convert, FILE *fi, FILE *fo,
531 char const *contenttype, char const *charset)
532 {
533 struct attachment *att;
534 int rv = -1;
535 NYD_ENTER;
536
537 fputs("This is a multi-part message in MIME format.\n", fo);
538 if (fsize(fi) != 0) {
539 char *buf;
540 size_t sz, bufsize, cnt;
541
542 if (fprintf(fo, "\n--%s\n", _sendout_boundary) < 0 ||
543 _put_ct(fo, contenttype, charset) < 0 ||
544 _put_cte(fo, convert) < 0 ||
545 fprintf(fo, "Content-Disposition: inline\n\n") < 0)
546 goto jleave;
547
548 buf = smalloc(bufsize = SEND_LINESIZE);
549 if (convert == CONV_TOQP
550 #ifdef HAVE_ICONV
551 || iconvd != (iconv_t)-1
552 #endif
553 ) {
554 fflush(fi);
555 cnt = fsize(fi);
556 }
557 for (;;) {
558 if (convert == CONV_TOQP
559 #ifdef HAVE_ICONV
560 || iconvd != (iconv_t)-1
561 #endif
562 ) {
563 if (fgetline(&buf, &bufsize, &cnt, &sz, fi, 0) == NULL)
564 break;
565 } else if ((sz = fread(buf, sizeof *buf, bufsize, fi)) == 0)
566 break;
567
568 if (xmime_write(buf, sz, fo, convert, TD_ICONV) < 0) {
569 free(buf);
570 goto jleave;
571 }
572 }
573 free(buf);
574
575 if (ferror(fi))
576 goto jleave;
577 }
578
579 for (att = hp->h_attach; att != NULL; att = att->a_flink) {
580 if (att->a_msgno) {
581 if (attach_message(att, fo) != 0)
582 goto jleave;
583 } else if (_attach_file(att, fo) != 0)
584 goto jleave;
585 }
586
587 /* the final boundary with two attached dashes */
588 fprintf(fo, "\n--%s--\n", _sendout_boundary);
589 rv = 0;
590 jleave:
591 NYD_LEAVE;
592 return rv;
593 }
594
595 static FILE *
596 infix(struct header *hp, FILE *fi) /* TODO check */
597 {
598 FILE *nfo, *nfi = NULL;
599 char *tempMail;
600 char const *contenttype, *charset = NULL;
601 enum conversion convert;
602 int do_iconv = 0, err;
603 #ifdef HAVE_ICONV
604 char const *tcs, *convhdr = NULL;
605 #endif
606 NYD_ENTER;
607
608 if ((nfo = Ftmp(&tempMail, "infix", OF_WRONLY | OF_HOLDSIGS | OF_REGISTER))
609 == NULL) {
610 n_perr(_("temporary mail file"), 0);
611 goto jleave;
612 }
613 if ((nfi = Fopen(tempMail, "r")) == NULL) {
614 n_perr(tempMail, 0);
615 Fclose(nfo);
616 }
617 Ftmp_release(&tempMail);
618 if (nfi == NULL)
619 goto jleave;
620
621 pstate &= ~PS_HEADER_NEEDED_MIME; /* TODO a hack should be carrier tracked */
622
623 contenttype = "text/plain"; /* XXX mail body - always text/plain, want XX? */
624 if((options & OPT_Mm_FLAG) && option_Mm_arg != NULL)
625 contenttype = option_Mm_arg;
626 convert = mime_type_classify_file(fi, &contenttype, &charset, &do_iconv);
627
628 #ifdef HAVE_ICONV
629 tcs = charset_get_lc();
630 if ((convhdr = need_hdrconv(hp))) {
631 if (iconvd != (iconv_t)-1) /* XXX */
632 n_iconv_close(iconvd);
633 if (asccasecmp(convhdr, tcs) != 0 &&
634 (iconvd = n_iconv_open(convhdr, tcs)) == (iconv_t)-1 &&
635 (err = errno) != 0)
636 goto jiconv_err;
637 }
638 #endif
639 if (puthead(FAL0, hp, nfo,
640 (GTO | GSUBJECT | GCC | GBCC | GNL | GCOMMA | GUA | GMIME | GMSGID |
641 GIDENT | GREF | GDATE), SEND_MBOX, convert, contenttype, charset))
642 goto jerr;
643 #ifdef HAVE_ICONV
644 if (iconvd != (iconv_t)-1)
645 n_iconv_close(iconvd);
646 #endif
647
648 #ifdef HAVE_ICONV
649 if (do_iconv && charset != NULL) { /*TODO charset->mime_type_classify_file*/
650 if (asccasecmp(charset, tcs) != 0 &&
651 (iconvd = n_iconv_open(charset, tcs)) == (iconv_t)-1 &&
652 (err = errno) != 0) {
653 jiconv_err:
654 if (err == EINVAL)
655 n_err(_("Cannot convert from %s to %s\n"), tcs, charset);
656 else
657 n_perr("iconv_open", 0);
658 goto jerr;
659 }
660 }
661 #endif
662
663 if (hp->h_attach != NULL) {
664 if (make_multipart(hp, convert, fi, nfo, contenttype, charset) != 0)
665 goto jerr;
666 } else {
667 size_t sz, bufsize, cnt;
668 char *buf;
669
670 if (convert == CONV_TOQP
671 #ifdef HAVE_ICONV
672 || iconvd != (iconv_t)-1
673 #endif
674 ) {
675 fflush(fi);
676 cnt = fsize(fi);
677 }
678 buf = smalloc(bufsize = SEND_LINESIZE);
679 for (err = 0;;) {
680 if (convert == CONV_TOQP
681 #ifdef HAVE_ICONV
682 || iconvd != (iconv_t)-1
683 #endif
684 ) {
685 if (fgetline(&buf, &bufsize, &cnt, &sz, fi, 0) == NULL)
686 break;
687 } else if ((sz = fread(buf, sizeof *buf, bufsize, fi)) == 0)
688 break;
689 if (xmime_write(buf, sz, nfo, convert, TD_ICONV) < 0) {
690 err = 1;
691 break;
692 }
693 }
694 free(buf);
695
696 if (err || ferror(fi)) {
697 jerr:
698 Fclose(nfo);
699 Fclose(nfi);
700 #ifdef HAVE_ICONV
701 if (iconvd != (iconv_t)-1)
702 n_iconv_close(iconvd);
703 #endif
704 nfi = NULL;
705 goto jleave;
706 }
707 }
708
709 #ifdef HAVE_ICONV
710 if (iconvd != (iconv_t)-1)
711 n_iconv_close(iconvd);
712 #endif
713
714 fflush(nfo);
715 if ((err = ferror(nfo)))
716 n_perr(_("temporary mail file"), 0);
717 Fclose(nfo);
718 if (!err) {
719 fflush_rewind(nfi);
720 Fclose(fi);
721 } else {
722 Fclose(nfi);
723 nfi = NULL;
724 }
725 jleave:
726 NYD_LEAVE;
727 return nfi;
728 }
729
730 static bool_t
731 _check_dispo_notif(struct name *mdn, struct header *hp, FILE *fo)
732 {
733 char const *from;
734 bool_t rv = TRU1;
735 NYD_ENTER;
736
737 /* TODO smtp_disposition_notification (RFC 3798): relation to return-path
738 * TODO not yet checked */
739 if (!ok_blook(disposition_notification_send))
740 goto jleave;
741
742 if (mdn != NULL && mdn != (struct name*)0x1)
743 from = mdn->n_name;
744 else if ((from = myorigin(hp)) == NULL) {
745 if (options & OPT_D_V)
746 n_err(_("*disposition-notification-send*: no *from* set\n"));
747 goto jleave;
748 }
749
750 if (fmt("Disposition-Notification-To:", nalloc(n_UNCONST(from), 0), fo, 0))
751 rv = FAL0;
752 jleave:
753 NYD_LEAVE;
754 return rv;
755 }
756
757 static int
758 sendmail_internal(void *v, int recipient_record)
759 {
760 struct header head;
761 char *str = v;
762 int rv;
763 NYD_ENTER;
764
765 memset(&head, 0, sizeof head);
766 head.h_to = lextract(str, GTO | GFULL);
767 rv = mail1(&head, 0, NULL, NULL, recipient_record, 0);
768 NYD_LEAVE;
769 return (rv == 0);
770 }
771
772 static struct name *
773 _outof(struct name *names, FILE *fo, bool_t *senderror)
774 {
775 ui32_t pipecnt, xcnt, i;
776 int *fda;
777 char const *sh;
778 struct name *np;
779 FILE *fin = NULL, *fout;
780 NYD_ENTER;
781
782 /* Look through all recipients and do a quick return if no file or pipe
783 * addressee is found */
784 fda = NULL; /* Silence cc */
785 for (pipecnt = xcnt = 0, np = names; np != NULL; np = np->n_flink) {
786 if (np->n_type & GDEL)
787 continue;
788 switch (np->n_flags & NAME_ADDRSPEC_ISFILEORPIPE) {
789 case NAME_ADDRSPEC_ISFILE:
790 ++xcnt;
791 break;
792 case NAME_ADDRSPEC_ISPIPE:
793 ++pipecnt;
794 break;
795 }
796 }
797 if (pipecnt == 0 && xcnt == 0)
798 goto jleave;
799
800 /* Otherwise create an array of file descriptors for each found pipe
801 * addressee to get around the dup(2)-shared-file-offset problem, i.e.,
802 * each pipe subprocess needs its very own file descriptor, and we need
803 * to deal with that.
804 * To make our life a bit easier let's just use the auto-reclaimed
805 * string storage */
806 if (pipecnt == 0 || (options & OPT_DEBUG)) {
807 pipecnt = 0;
808 fda = NULL;
809 sh = NULL;
810 } else {
811 fda = salloc(sizeof(int) * pipecnt);
812 for (i = 0; i < pipecnt; ++i)
813 fda[i] = -1;
814 sh = ok_vlook(SHELL);
815 }
816
817 for (np = names; np != NULL; np = np->n_flink) {
818 if (!(np->n_flags & NAME_ADDRSPEC_ISFILEORPIPE))
819 continue;
820
821 /* In days of old we removed the entry from the the list; now for sake of
822 * header expansion we leave it in and mark it as deleted */
823 np->n_type |= GDEL;
824
825 if(options & OPT_D_VV)
826 n_err(_(">>> Writing message via %s\n"),
827 n_shexp_quote_cp(np->n_name, FAL0));
828 if(options & OPT_DEBUG)
829 continue;
830
831 /* See if we have copied the complete message out yet. If not, do so */
832 if (image < 0) {
833 int c;
834 char *tempEdit;
835
836 if ((fout = Ftmp(&tempEdit, "outof",
837 OF_WRONLY | OF_HOLDSIGS | OF_REGISTER)) == NULL) {
838 n_perr(_("Creation of temporary image"), 0);
839 *senderror = TRU1;
840 goto jcant;
841 }
842 if ((image = open(tempEdit, O_RDWR | _O_CLOEXEC)) >= 0) {
843 _CLOEXEC_SET(image);
844 for (i = 0; i < pipecnt; ++i) {
845 int fd = open(tempEdit, O_RDONLY | _O_CLOEXEC);
846 if (fd < 0) {
847 close(image);
848 image = -1;
849 pipecnt = i;
850 break;
851 }
852 fda[i] = fd;
853 _CLOEXEC_SET(fd);
854 }
855 }
856 Ftmp_release(&tempEdit);
857
858 if (image < 0) {
859 n_perr(_("Creating descriptor duplicate of temporary image"), 0);
860 *senderror = TRU1;
861 Fclose(fout);
862 goto jcant;
863 }
864
865 fprintf(fout, "From %s %s", myname, time_current.tc_ctime);
866 c = EOF;
867 while (i = c, (c = getc(fo)) != EOF)
868 putc(c, fout);
869 rewind(fo);
870 if ((int)i != '\n')
871 putc('\n', fout);
872 putc('\n', fout);
873 fflush(fout);
874 if (ferror(fout)) {
875 n_perr(_("Finalizing write of temporary image"), 0);
876 Fclose(fout);
877 goto jcantfout;
878 }
879 Fclose(fout);
880
881 /* If we have to serve file addressees, open reader */
882 if (xcnt != 0 && (fin = Fdopen(image, "r", FAL0)) == NULL) {
883 n_perr(_("Failed to open a temporary image duplicate"), 0);
884 jcantfout:
885 *senderror = TRU1;
886 close(image);
887 image = -1;
888 goto jcant;
889 }
890
891 /* From now on use xcnt as a counter for pipecnt */
892 xcnt = 0;
893 }
894
895 /* Now either copy "image" to the desired file or give it as the standard
896 * input to the desired program as appropriate */
897 if (np->n_flags & NAME_ADDRSPEC_ISPIPE) {
898 int pid;
899 sigset_t nset;
900
901 sigemptyset(&nset);
902 sigaddset(&nset, SIGHUP);
903 sigaddset(&nset, SIGINT);
904 sigaddset(&nset, SIGQUIT);
905 pid = start_command(sh, &nset, fda[xcnt++], COMMAND_FD_NULL, "-c",
906 np->n_name + 1, NULL, NULL);
907 if (pid < 0) {
908 n_err(_("Piping message to %s failed\n"),
909 n_shexp_quote_cp(np->n_name, FAL0));
910 *senderror = TRU1;
911 goto jcant;
912 }
913 free_child(pid);
914 } else {
915 int c;
916 char const *fname, *fnameq;
917
918 if ((fname = fexpand(np->n_name, FEXP_LOCAL | FEXP_NOPROTO)) == NULL) {
919 *senderror = TRU1;
920 goto jcant;
921 }
922 fnameq = n_shexp_quote_cp(fname, FAL0);
923
924 if(fname[0] == '-' && fname[1] == '\0')
925 fout = stdout;
926 else if ((fout = Zopen(fname, "a")) == NULL) {
927 n_err(_("Writing message to %s failed: %s\n"),
928 fnameq, strerror(errno));
929 *senderror = TRU1;
930 goto jcant;
931 }
932 rewind(fin);
933 while ((c = getc(fin)) != EOF)
934 putc(c, fout);
935 if (ferror(fout)) {
936 n_err(_("Writing message to %s failed: %s\n"),
937 fnameq, _("write error"));
938 *senderror = TRU1;
939 }
940 if(fout != stdout)
941 Fclose(fout);
942 }
943
944 jcant:
945 if (image < 0)
946 goto jdelall;
947 }
948
949 jleave:
950 if (fin != NULL)
951 Fclose(fin);
952 for (i = 0; i < pipecnt; ++i)
953 close(fda[i]);
954 if (image >= 0) {
955 close(image);
956 image = -1;
957 }
958 NYD_LEAVE;
959 return names;
960
961 jdelall:
962 while (np != NULL) {
963 if (np->n_flags & NAME_ADDRSPEC_ISFILEORPIPE)
964 np->n_type |= GDEL;
965 np = np->n_flink;
966 }
967 goto jleave;
968 }
969
970 static bool_t
971 mightrecord(FILE *fp, struct name *to, bool_t resend)
972 {
973 char *cp, *cq;
974 char const *ep;
975 bool_t rv = TRU1;
976 NYD_ENTER;
977
978 if (options & OPT_DEBUG)
979 cp = NULL;
980 else if (to != NULL) {
981 cp = savestr(skinned_name(to));
982 for (cq = cp; *cq != '\0' && *cq != '@'; ++cq)
983 ;
984 *cq = '\0';
985 } else
986 cp = ok_vlook(record);
987
988 if (cp != NULL) {
989 if ((ep = expand(cp)) == NULL) {
990 ep = "NULL";
991 goto jbail;
992 }
993
994 if (*ep != '/' && *ep != '+' && ok_blook(outfolder) &&
995 which_protocol(ep) == PROTO_FILE) {
996 size_t i = strlen(cp);
997 cq = salloc(i + 1 +1);
998 cq[0] = '+';
999 memcpy(cq + 1, cp, i +1);
1000 cp = cq;
1001 if ((ep = fexpand(cp, FEXP_LOCAL | FEXP_NOPROTO)) == NULL) {
1002 ep = "NULL";
1003 goto jbail;
1004 }
1005 }
1006
1007 if (!a_sendout__savemail(ep, fp, resend)) {
1008 jbail:
1009 n_err(_("Failed to save message in %s - message not sent\n"),
1010 n_shexp_quote_cp(ep, FAL0));
1011 exit_status |= EXIT_ERR;
1012 savedeadletter(fp, 1);
1013 rv = FAL0;
1014 }
1015 }
1016 NYD_LEAVE;
1017 return rv;
1018 }
1019
1020 static bool_t
1021 a_sendout__savemail(char const *name, FILE *fp, bool_t resend){
1022 FILE *fo;
1023 size_t bufsize, buflen, cnt;
1024 bool_t rv, emptyline;
1025 char *buf;
1026 NYD_ENTER;
1027
1028 buf = smalloc(bufsize = LINESIZE);
1029 rv = emptyline = FAL0;
1030
1031 if((fo = Zopen(name, "a+")) == NULL){
1032 if((fo = Zopen(name, "wx")) == NULL){
1033 n_perr(name, 0);
1034 goto j_leave;
1035 }
1036 emptyline = TRU1;
1037 }
1038
1039 /* TODO RETURN check, but be aware of protocols: v15: Mailbox->lock()! */
1040 n_file_lock(fileno(fo), FLT_WRITE, 0,0, UIZ_MAX);
1041
1042 rv = TRU1;
1043
1044 if(!emptyline){
1045 if(fseek(fo, -2L, SEEK_END) == 0){ /* TODO Should be Mailbox::->append */
1046 switch(fread(buf, sizeof *buf, 2, fo)){
1047 case 2:
1048 if(buf[1] != '\n')
1049 emptyline = TRU1;
1050 break;
1051 case 1:
1052 if(buf[0] != '\n')
1053 emptyline = TRU1;
1054 break;
1055 default:
1056 if(ferror(fo)){
1057 n_perr(name, 0);
1058 rv = FAL0;
1059 goto jleave;
1060 }
1061 }
1062 if(emptyline){
1063 putc('\n', fo);
1064 fflush(fo);
1065 }
1066 }
1067 }
1068
1069 fflush_rewind(fp);
1070
1071 fprintf(fo, "From %s %s", myname, time_current.tc_ctime);
1072 for(emptyline = FAL0, buflen = 0, cnt = fsize(fp);
1073 fgetline(&buf, &bufsize, &cnt, &buflen, fp, 0) != NULL;){
1074 /* Only if we are resending it can happen that we have to quote From_
1075 * lines here; we don't generate messages which are ambiguous ourselves */
1076 if(resend){
1077 if(emptyline && is_head(buf, buflen, FAL0))
1078 putc('>', fo);
1079 }DBG(else assert(!is_head(buf, buflen, FAL0)); )
1080
1081 emptyline = (buflen > 0 && *buf == '\n');
1082 fwrite(buf, sizeof *buf, buflen, fo);
1083 }
1084 if(buflen > 0 && buf[buflen - 1] != '\n')
1085 putc('\n', fo);
1086 putc('\n', fo);
1087 fflush(fo);
1088 if(ferror(fo)){
1089 n_perr(name, 0);
1090 rv = FAL0;
1091 }
1092
1093 jleave:
1094 really_rewind(fp);
1095 if(Fclose(fo) != 0)
1096 rv = FAL0;
1097 j_leave:
1098 free(buf);
1099 NYD_LEAVE;
1100 return rv;
1101 }
1102
1103 static bool_t
1104 _transfer(struct sendbundle *sbp)
1105 {
1106 struct name *np;
1107 ui32_t cnt;
1108 bool_t rv = TRU1;
1109 NYD_ENTER;
1110
1111 for (cnt = 0, np = sbp->sb_to; np != NULL;) {
1112 char const k[] = "smime-encrypt-";
1113 size_t nl = strlen(np->n_name);
1114 char *cp, *vs = ac_alloc(sizeof(k)-1 + nl +1);
1115 memcpy(vs, k, sizeof(k) -1);
1116 memcpy(vs + sizeof(k) -1, np->n_name, nl +1);
1117
1118 if ((cp = vok_vlook(vs)) != NULL) {
1119 #ifdef HAVE_SSL
1120 FILE *ef;
1121
1122 if ((ef = smime_encrypt(sbp->sb_input, cp, np->n_name)) != NULL) {
1123 FILE *fisave = sbp->sb_input;
1124 struct name *nsave = sbp->sb_to;
1125
1126 sbp->sb_to = ndup(np, np->n_type & ~(GFULL | GSKIN));
1127 sbp->sb_input = ef;
1128 if (!__mta_start(sbp))
1129 rv = FAL0;
1130 sbp->sb_to = nsave;
1131 sbp->sb_input = fisave;
1132
1133 Fclose(ef);
1134 } else {
1135 #else
1136 n_err(_("No SSL support compiled in\n"));
1137 rv = FAL0;
1138 #endif
1139 n_err(_("Message not sent to: %s\n"), np->n_name);
1140 _sendout_error = TRU1;
1141 #ifdef HAVE_SSL
1142 }
1143 #endif
1144 rewind(sbp->sb_input);
1145
1146 if (np->n_flink != NULL)
1147 np->n_flink->n_blink = np->n_blink;
1148 if (np->n_blink != NULL)
1149 np->n_blink->n_flink = np->n_flink;
1150 if (np == sbp->sb_to)
1151 sbp->sb_to = np->n_flink;
1152 np = np->n_flink;
1153 } else {
1154 ++cnt;
1155 np = np->n_flink;
1156 }
1157 ac_free(vs);
1158 }
1159
1160 if (cnt > 0 && (ok_blook(smime_force_encryption) || !__mta_start(sbp)))
1161 rv = FAL0;
1162 NYD_LEAVE;
1163 return rv;
1164 }
1165
1166 static bool_t
1167 __mta_start(struct sendbundle *sbp)
1168 {
1169 pid_t pid;
1170 sigset_t nset;
1171 char const **args, *mta;
1172 bool_t rv;
1173 NYD_ENTER;
1174
1175 if((mta = ok_vlook(smtp)) != NULL){
1176 OBSOLETE(_("please don't use *smtp*, but assign an SMTP URL to *mta*"));
1177 /* For *smtp* the smtp:// protocol was optional; be simple: don't check
1178 * that *smtp* is misused with file:// or so */
1179 if(n_servbyname(mta, NULL) == NULL)
1180 mta = savecat("smtp://", mta);
1181 rv = TRU1;
1182 }else{
1183 char const *proto;
1184
1185 if((proto = ok_vlook(sendmail)) != NULL)
1186 OBSOLETE(_("please use *mta* instead of *sendmail*"));
1187 if((mta = ok_vlook(mta)) == NULL){ /* TODO v15: mta = ok_vlook(mta); */
1188 if(proto == NULL){
1189 mta = VAL_MTA;
1190 rv = FAL0;
1191 }else
1192 rv = TRU1;
1193 }
1194 /* TODO for now this is pretty hacky: in v15 we should simply create
1195 * TODO an URL object; i.e., be able to do so, and it does it right
1196 * TODO I.e.,: url_creat(&url, ok_vlook(mta)); */
1197 else if((proto = n_servbyname(mta, NULL)) != NULL){
1198 if(*proto == '\0'){
1199 mta += sizeof("file://") -1;
1200 rv = FAL0;
1201 }else
1202 rv = TRU1;
1203 }else
1204 rv = FAL0;
1205 }
1206
1207 if(!rv){
1208 char const *mta_base;
1209
1210 if((mta = fexpand(mta_base = mta, FEXP_LOCAL | FEXP_NOPROTO)) == NULL){
1211 n_err(_("*mta* variable expansion failure: %s\n"),
1212 n_shexp_quote_cp(mta_base, FAL0));
1213 goto jstop;
1214 }
1215
1216 args = __mta_prepare_args(sbp->sb_to, sbp->sb_hp);
1217 if (options & OPT_DEBUG) {
1218 __mta_debug(sbp, mta, args);
1219 rv = TRU1;
1220 goto jleave;
1221 }
1222 } else {
1223 n_UNINIT(args, NULL);
1224 #ifndef HAVE_SMTP
1225 n_err(_("No SMTP support compiled in\n"));
1226 goto jstop;
1227 #else
1228 if (options & OPT_DEBUG) {
1229 (void)smtp_mta(sbp);
1230 rv = TRU1;
1231 goto jleave;
1232 }
1233 #endif
1234 }
1235
1236 /* Fork, set up the temporary mail file as standard input for "mail", and
1237 * exec with the user list we generated far above */
1238 if ((pid = fork_child()) == -1) {
1239 n_perr("fork", 0);
1240 jstop:
1241 savedeadletter(sbp->sb_input, 0);
1242 _sendout_error = TRU1;
1243 goto jleave;
1244 }
1245 if (pid == 0) {
1246 sigemptyset(&nset);
1247 sigaddset(&nset, SIGHUP);
1248 sigaddset(&nset, SIGINT);
1249 sigaddset(&nset, SIGQUIT);
1250 sigaddset(&nset, SIGTSTP);
1251 sigaddset(&nset, SIGTTIN);
1252 sigaddset(&nset, SIGTTOU);
1253 freopen("/dev/null", "r", stdin);
1254 #ifdef HAVE_SMTP
1255 if (rv) {
1256 prepare_child(&nset, 0, 1);
1257 if (smtp_mta(sbp))
1258 _exit(EXIT_OK);
1259 } else
1260 #endif
1261 {
1262 char const *ecp;
1263 int e;
1264
1265 prepare_child(&nset, fileno(sbp->sb_input), -1);
1266 execv(mta, n_UNCONST(args));
1267 e = errno;
1268 ecp = (e != ENOENT) ? strerror(e)
1269 : _("executable not found (adjust *mta* variable)");
1270 n_err(_("Cannot start %s: %s\n"), n_shexp_quote_cp(mta, FAL0), ecp);
1271 }
1272 savedeadletter(sbp->sb_input, 1);
1273 n_err(_("... message not sent\n"));
1274 _exit(EXIT_ERR);
1275 }
1276
1277 if ((options & (OPT_DEBUG | OPT_VERB)) || ok_blook(sendwait)) {
1278 if (!(rv = wait_child(pid, NULL)))
1279 _sendout_error = TRU1;
1280 } else {
1281 free_child(pid);
1282 rv = TRU1;
1283 }
1284 jleave:
1285 NYD_LEAVE;
1286 return rv;
1287 }
1288
1289 static char const **
1290 __mta_prepare_args(struct name *to, struct header *hp)
1291 {
1292 size_t vas_cnt, i, j;
1293 char **vas;
1294 char const **args, *cp, *cp_v15compat;
1295 bool_t snda;
1296 NYD_ENTER;
1297
1298 if((cp_v15compat = ok_vlook(sendmail_arguments)) != NULL)
1299 OBSOLETE(_("please use *mta-arguments*, not *sendmail-arguments*"));
1300 if((cp = ok_vlook(mta_arguments)) == NULL)
1301 cp = cp_v15compat;
1302 if ((cp /* TODO v15: = ok_vlook(mta_arguments)*/) == NULL) {
1303 vas_cnt = 0;
1304 vas = NULL;
1305 } else {
1306 /* Don't assume anything on the content but do allocate exactly j slots;
1307 * like this getrawlist will never overflow (and return -1) */
1308 j = strlen(cp);
1309 vas = n_lofi_alloc(sizeof(*vas) * j);
1310 vas_cnt = (size_t)getrawlist(FAL0, vas, j, cp, j);
1311 }
1312
1313 i = 4 + smopts_cnt + vas_cnt + 4 + 1 + count(to) + 1;
1314 args = salloc(i * sizeof(char*));
1315
1316 if((cp_v15compat = ok_vlook(sendmail_progname)) != NULL)
1317 OBSOLETE(_("please use *mta-argv0*, not *sendmail-progname*"));
1318 if((cp = ok_vlook(mta_argv0)) == NULL)
1319 cp = cp_v15compat;
1320 if(cp == NULL)
1321 cp = VAL_MTA_ARGV0;
1322 args[0] = cp/* TODO v15: = ok_vlook(mta_argv0) */;
1323
1324 if ((snda = ok_blook(sendmail_no_default_arguments)))
1325 OBSOLETE(_("please use *mta-no-default-arguments*, "
1326 "not *sendmail-no-default-arguments*"));
1327 snda |= ok_blook(mta_no_default_arguments);
1328 if ((snda /* TODO v15: = ok_blook(mta_no_default_arguments)*/))
1329 i = 1;
1330 else {
1331 args[1] = "-i";
1332 i = 2;
1333 if (ok_blook(metoo))
1334 args[i++] = "-m";
1335 if (options & OPT_VERB)
1336 args[i++] = "-v";
1337 }
1338
1339 for (j = 0; j < smopts_cnt; ++j, ++i)
1340 args[i] = smopts[j];
1341
1342 for (j = 0; j < vas_cnt; ++j, ++i)
1343 args[i] = vas[j];
1344
1345 /* -r option? In conjunction with -t we act compatible to postfix(1) and
1346 * ignore it (it is -f / -F there) if the message specified From:/Sender:.
1347 * The interdependency with -t has been resolved in puthead() */
1348 if (!snda && (options & OPT_r_FLAG)) {
1349 struct name const *np;
1350
1351 if (hp != NULL && (np = hp->h_from) != NULL) {
1352 /* However, what wasn't resolved there was the case that the message
1353 * specified multiple From: addresses and a Sender: */
1354 if ((pstate & PS_t_FLAG) && hp->h_sender != NULL)
1355 np = hp->h_sender;
1356
1357 if (np->n_fullextra != NULL) {
1358 args[i++] = "-F";
1359 args[i++] = np->n_fullextra;
1360 }
1361 cp = np->n_name;
1362 } else {
1363 assert(option_r_arg == NULL);
1364 cp = skin(myorigin(NULL));
1365 }
1366
1367 if (cp != NULL) {
1368 args[i++] = "-f";
1369 args[i++] = cp;
1370 }
1371 }
1372
1373 /* Terminate option list to avoid false interpretation of system-wide
1374 * aliases that start with hyphen */
1375 if (!snda)
1376 args[i++] = "--";
1377
1378 /* Receivers follow */
1379 for (; to != NULL; to = to->n_flink)
1380 if (!(to->n_type & GDEL))
1381 args[i++] = to->n_name;
1382 args[i] = NULL;
1383
1384 if(vas != NULL)
1385 n_lofi_free(vas);
1386 NYD_LEAVE;
1387 return args;
1388 }
1389
1390 static void
1391 __mta_debug(struct sendbundle *sbp, char const *mta, char const **args)
1392 {
1393 size_t cnt, bufsize, llen;
1394 char *buf;
1395 NYD_ENTER;
1396
1397 n_err(_(">>> MTA: %s, arguments:"), n_shexp_quote_cp(mta, FAL0));
1398 for (; *args != NULL; ++args)
1399 n_err(" %s", n_shexp_quote_cp(*args, FAL0));
1400 n_err("\n");
1401
1402 fflush_rewind(sbp->sb_input);
1403
1404 cnt = fsize(sbp->sb_input);
1405 buf = NULL;
1406 bufsize = 0;
1407 while (fgetline(&buf, &bufsize, &cnt, &llen, sbp->sb_input, TRU1) != NULL) {
1408 buf[--llen] = '\0';
1409 n_err(">>> %s\n", buf);
1410 }
1411 if (buf != NULL)
1412 free(buf);
1413 NYD_LEAVE;
1414 }
1415
1416 static char *
1417 _message_id(struct header *hp)
1418 {
1419 char *rv = NULL, sep;
1420 char const *h;
1421 size_t rl, i;
1422 struct tm *tmp;
1423 NYD_ENTER;
1424
1425 if (hp != NULL && hp->h_message_id != NULL) {
1426 i = strlen(hp->h_message_id->n_name);
1427 rl = sizeof("Message-ID: <>") -1;
1428 rv = salloc(rl + i +1);
1429 memcpy(rv, "Message-ID: <", --rl);
1430 memcpy(rv + rl, hp->h_message_id->n_name, i);
1431 rl += i;
1432 rv[rl++] = '>';
1433 rv[rl] = '\0';
1434 goto jleave;
1435 }
1436
1437 if (ok_blook(message_id_disable))
1438 goto jleave;
1439
1440 sep = '%';
1441 rl = 9;
1442 if ((h = __sendout_ident) != NULL)
1443 goto jgen;
1444 if (ok_vlook(hostname) != NULL) {
1445 h = nodename(1);
1446 sep = '@';
1447 rl = 15;
1448 goto jgen;
1449 }
1450 if (hp != NULL && (h = skin(myorigin(hp))) != NULL && strchr(h, '@') != NULL)
1451 goto jgen;
1452 /* Up to MTA */
1453 goto jleave;
1454
1455 jgen:
1456 tmp = &time_current.tc_gm;
1457 i = sizeof("Message-ID: <%04d%02d%02d%02d%02d%02d.%s%c%s>") -1 +
1458 rl + strlen(h);
1459 rv = salloc(i +1);
1460 snprintf(rv, i, "Message-ID: <%04d%02d%02d%02d%02d%02d.%s%c%s>",
1461 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
1462 tmp->tm_hour, tmp->tm_min, tmp->tm_sec,
1463 getrandstring(rl), sep, h);
1464 rv[i] = '\0'; /* Because we don't test snprintf(3) return */
1465 jleave:
1466 NYD_LEAVE;
1467 return rv;
1468 }
1469
1470 static int
1471 fmt(char const *str, struct name *np, FILE *fo, enum fmt_flags ff)
1472 {
1473 enum {
1474 m_INIT = 1<<0,
1475 m_COMMA = 1<<1,
1476 m_NOPF = 1<<2,
1477 m_NONAME = 1<<3,
1478 m_CSEEN = 1<<4
1479 } m = (ff & GCOMMA) ? m_COMMA : 0;
1480 ssize_t col, len;
1481 int rv = 1;
1482 NYD_ENTER;
1483
1484 col = strlen(str);
1485 if (col) {
1486 fwrite(str, sizeof *str, col, fo);
1487 #undef _X
1488 #define _X(S) (col == sizeof(S) -1 && !asccasecmp(str, S))
1489 if (ff & GFILES) {
1490 ;
1491 } else if (_X("reply-to:") || _X("mail-followup-to:") ||
1492 _X("references:") || _X("disposition-notification-to:"))
1493 m |= m_NOPF | m_NONAME;
1494 else if (ok_blook(add_file_recipients)) {
1495 ;
1496 } else if (_X("to:") || _X("cc:") || _X("bcc:") || _X("resent-to:"))
1497 m |= m_NOPF;
1498 #undef _X
1499 }
1500
1501 for (; np != NULL; np = np->n_flink) {
1502 if (is_addr_invalid(np,
1503 EACM_NOLOG | (m & m_NONAME ? EACM_NONAME : EACM_NONE)))
1504 continue;
1505 /* File and pipe addresses only printed with set *add-file-recipients* */
1506 if ((m & m_NOPF) && is_fileorpipe_addr(np))
1507 continue;
1508
1509 if ((m & (m_INIT | m_COMMA)) == (m_INIT | m_COMMA)) {
1510 if (putc(',', fo) == EOF)
1511 goto jleave;
1512 m |= m_CSEEN;
1513 ++col;
1514 }
1515
1516 len = strlen(np->n_fullname);
1517 if (np->n_flags & GREF)
1518 len += 2;
1519 ++col; /* The separating space */
1520 if ((m & m_INIT) && /*col > 1 &&*/ UICMP(z, col + len, >, 72)) {
1521 if (fputs("\n ", fo) == EOF)
1522 goto jleave;
1523 col = 1;
1524 m &= ~m_CSEEN;
1525 } else
1526 putc(' ', fo);
1527 m = (m & ~m_CSEEN) | m_INIT;
1528
1529 {
1530 char *hb = np->n_fullname;
1531 /* GREF needs to be placed in angle brackets, but which are missing */
1532 if (np->n_type & GREF) {
1533 hb = ac_alloc(len + 2 +1);
1534 hb[0] = '<';
1535 hb[len + 1] = '>';
1536 hb[len + 2] = '\0';
1537 memcpy(hb + 1, np->n_fullname, len);
1538 len += 2;
1539 }
1540 len = xmime_write(hb, len, fo,
1541 ((ff & FMT_DOMIME) ? CONV_TOHDR_A : CONV_NONE), TD_ICONV);
1542 if (np->n_type & GREF)
1543 ac_free(hb);
1544 }
1545 if (len < 0)
1546 goto jleave;
1547 col += len;
1548 }
1549
1550 if (putc('\n', fo) != EOF)
1551 rv = 0;
1552 jleave:
1553 NYD_LEAVE;
1554 return rv;
1555 }
1556
1557 static int
1558 infix_resend(FILE *fi, FILE *fo, struct message *mp, struct name *to,
1559 int add_resent)
1560 {
1561 size_t cnt, c, bufsize = 0;
1562 char *buf = NULL;
1563 char const *cp;
1564 struct name *fromfield = NULL, *senderfield = NULL, *mdn;
1565 int rv = 1;
1566 NYD_ENTER;
1567
1568 cnt = mp->m_size;
1569
1570 /* Write the Resent-Fields */
1571 if (add_resent) {
1572 fputs("Resent-", fo);
1573 mkdate(fo, "Date");
1574 if ((cp = myaddrs(NULL)) != NULL) {
1575 if (_putname(cp, GCOMMA, SEND_MBOX, NULL, "Resent-From:", fo,
1576 &fromfield, 0))
1577 goto jleave;
1578 }
1579 /* TODO RFC 5322: Resent-Sender SHOULD NOT be used if it's EQ -From: */
1580 if ((cp = ok_vlook(sender)) != NULL) {
1581 if (_putname(cp, GCOMMA, SEND_MBOX, NULL, "Resent-Sender:", fo,
1582 &senderfield, 0))
1583 goto jleave;
1584 }
1585 if (fmt("Resent-To:", to, fo, FMT_COMMA))
1586 goto jleave;
1587 if (((cp = ok_vlook(stealthmua)) == NULL || !strcmp(cp, "noagent")) &&
1588 (cp = _message_id(NULL)) != NULL)
1589 fprintf(fo, "Resent-%s\n", cp);
1590 }
1591
1592 if ((mdn = n_UNCONST(check_from_and_sender(fromfield, senderfield))) == NULL)
1593 goto jleave;
1594 if (!_check_dispo_notif(mdn, NULL, fo))
1595 goto jleave;
1596
1597 /* Write the original headers */
1598 while (cnt > 0) {
1599 if (fgetline(&buf, &bufsize, &cnt, &c, fi, 0) == NULL)
1600 break;
1601 if (ascncasecmp("status:", buf, 7) &&
1602 ascncasecmp("disposition-notification-to:", buf, 28) &&
1603 !is_head(buf, c, FAL0))
1604 fwrite(buf, sizeof *buf, c, fo);
1605 if (cnt > 0 && *buf == '\n')
1606 break;
1607 }
1608
1609 /* Write the message body */
1610 while (cnt > 0) {
1611 if (fgetline(&buf, &bufsize, &cnt, &c, fi, 0) == NULL)
1612 break;
1613 if (cnt == 0 && *buf == '\n')
1614 break;
1615 fwrite(buf, sizeof *buf, c, fo);
1616 }
1617 if (buf != NULL)
1618 free(buf);
1619 if (ferror(fo)) {
1620 n_perr(_("temporary mail file"), 0);
1621 goto jleave;
1622 }
1623 rv = 0;
1624 jleave:
1625 NYD_LEAVE;
1626 return rv;
1627 }
1628
1629 FL int
1630 mail(struct name *to, struct name *cc, struct name *bcc, char *subject,
1631 struct attachment *attach, char *quotefile, int recipient_record)
1632 {
1633 struct header head;
1634 struct str in, out;
1635 NYD_ENTER;
1636
1637 memset(&head, 0, sizeof head);
1638
1639 /* The given subject may be in RFC1522 format. */
1640 if (subject != NULL) {
1641 in.s = subject;
1642 in.l = strlen(subject);
1643 mime_fromhdr(&in, &out, /* TODO ??? TD_ISPR |*/ TD_ICONV);
1644 head.h_subject = out.s;
1645 }
1646 head.h_to = to;
1647 head.h_cc = cc;
1648 head.h_bcc = bcc;
1649 head.h_attach = attach;
1650
1651 mail1(&head, 0, NULL, quotefile, recipient_record, 0);
1652
1653 if (subject != NULL)
1654 free(out.s);
1655 NYD_LEAVE;
1656 return 0;
1657 }
1658
1659 FL int
1660 c_sendmail(void *v)
1661 {
1662 int rv;
1663 NYD_ENTER;
1664
1665 rv = sendmail_internal(v, 0);
1666 NYD_LEAVE;
1667 return rv;
1668 }
1669
1670 FL int
1671 c_Sendmail(void *v)
1672 {
1673 int rv;
1674 NYD_ENTER;
1675
1676 rv = sendmail_internal(v, 1);
1677 NYD_LEAVE;
1678 return rv;
1679 }
1680
1681 FL enum okay
1682 mail1(struct header *hp, int printheaders, struct message *quote,
1683 char *quotefile, int recipient_record, int doprefix)
1684 {
1685 struct sendbundle sb;
1686 struct name *to;
1687 FILE *mtf, *nmtf;
1688 bool_t dosign;
1689 enum okay rv = STOP;
1690 NYD_ENTER;
1691
1692 _sendout_error = FAL0;
1693 __sendout_ident = NULL;
1694
1695 /* Update some globals we likely need first */
1696 time_current_update(&time_current, TRU1);
1697
1698 /* Collect user's mail from standard input. Get the result as mtf */
1699 mtf = collect(hp, printheaders, quote, quotefile, doprefix, &_sendout_error);
1700 if (mtf == NULL)
1701 goto j_leave;
1702
1703 dosign = TRUM1;
1704
1705 /* */
1706 if (options & OPT_INTERACTIVE) {
1707 if (ok_blook(asksign))
1708 dosign = getapproval(_("Sign this message"), TRU1);
1709 }
1710
1711 if (fsize(mtf) == 0) {
1712 if (options & OPT_E_FLAG)
1713 goto jleave;
1714 if (hp->h_subject == NULL)
1715 printf(_("No message, no subject; hope that's ok\n"));
1716 else if (ok_blook(bsdcompat) || ok_blook(bsdmsgs))
1717 printf(_("Null message body; hope that's ok\n"));
1718 }
1719
1720 if (dosign == TRUM1)
1721 dosign = ok_blook(smime_sign); /* TODO USER@HOST <-> *from* +++!!! */
1722 #ifndef HAVE_SSL
1723 if (dosign) {
1724 n_err(_("No SSL support compiled in\n"));
1725 goto jleave;
1726 }
1727 #endif
1728
1729 /* XXX Update time_current again; once collect() offers editing of more
1730 * XXX headers, including Date:, this must only happen if Date: is the
1731 * XXX same that it was before collect() (e.g., postponing etc.).
1732 * XXX But *do* update otherwise because the mail seems to be backdated
1733 * XXX if the user edited some time, which looks odd and it happened
1734 * XXX to me that i got mis-dated response mails due to that... */
1735 time_current_update(&time_current, TRU1);
1736
1737 /* TODO hrmpf; the MIME/send layer rewrite MUST address the init crap:
1738 * TODO setup the header ONCE; note this affects edit.c, collect.c ...,
1739 * TODO but: offer a hook that rebuilds/expands/checks/fixates all
1740 * TODO header fields ONCE, call that ONCE after user editing etc. has
1741 * TODO completed (one edit cycle) */
1742
1743 /* Take the user names from the combined to and cc lists and do all the
1744 * alias processing. The POSIX standard says:
1745 * The names shall be substituted when alias is used as a recipient
1746 * address specified by the user in an outgoing message (that is,
1747 * other recipients addressed indirectly through the reply command
1748 * shall not be substituted in this manner).
1749 * S-nail thus violates POSIX, as has been pointed out correctly by
1750 * Martin Neitzel, but logic and usability of POSIX standards is not seldom
1751 * disputable anyway. Go for user friendliness */
1752
1753 to = namelist_vaporise_head(hp,
1754 (EACM_NORMAL |
1755 (!(expandaddr_to_eaf() & EAF_NAME) ? EACM_NONAME : EACM_NONE)),
1756 TRU1, &_sendout_error);
1757 if (to == NULL) {
1758 n_err(_("No recipients specified\n"));
1759 goto jfail_dead;
1760 }
1761 if (_sendout_error < 0) {
1762 n_err(_("Some addressees were classified as \"hard error\"\n"));
1763 goto jfail_dead;
1764 }
1765
1766 /* */
1767 memset(&sb, 0, sizeof sb);
1768 sb.sb_hp = hp;
1769 sb.sb_to = to;
1770 sb.sb_input = mtf;
1771 if ((dosign || count_nonlocal(to) > 0) &&
1772 !_sendbundle_setup_creds(&sb, (dosign > 0)))
1773 /* TODO saving $DEAD and recovering etc is not yet well defined */
1774 goto jfail_dead;
1775
1776 /* 'Bit ugly kind of control flow until we find a charset that does it */
1777 for (charset_iter_reset(hp->h_charset);; charset_iter_next()) {
1778 int err;
1779
1780 if (!charset_iter_is_valid())
1781 ;
1782 else if ((nmtf = infix(hp, mtf)) != NULL)
1783 break;
1784 else if ((err = errno) == EILSEQ || err == EINVAL) {
1785 rewind(mtf);
1786 continue;
1787 }
1788
1789 n_perr(_("Failed to create encoded message"), 0);
1790 goto jfail_dead;
1791 }
1792 mtf = nmtf;
1793
1794 /* */
1795 #ifdef HAVE_SSL
1796 if (dosign) {
1797 if ((nmtf = smime_sign(mtf, sb.sb_signer.s)) == NULL)
1798 goto jfail_dead;
1799 Fclose(mtf);
1800 mtf = nmtf;
1801 }
1802 #endif
1803
1804 /* TODO truly - i still don't get what follows: (1) we deliver file
1805 * TODO and pipe addressees, (2) we mightrecord() and (3) we transfer
1806 * TODO even if (1) savedeadletter() etc. To me this doesn't make sense? */
1807
1808 /* Deliver pipe and file addressees */
1809 to = _outof(to, mtf, &_sendout_error);
1810 if (_sendout_error)
1811 savedeadletter(mtf, FAL0);
1812
1813 to = elide(to); /* XXX needed only to drop GDELs due to _outof()! */
1814
1815 { ui32_t cnt = count(to);
1816 if ((!recipient_record || cnt > 0) &&
1817 !mightrecord(mtf, (recipient_record ? to : NULL), FAL0))
1818 goto jleave;
1819 if (cnt > 0) {
1820 sb.sb_hp = hp;
1821 sb.sb_to = to;
1822 sb.sb_input = mtf;
1823 if (_transfer(&sb))
1824 rv = OKAY;
1825 } else if (!_sendout_error)
1826 rv = OKAY;
1827 }
1828 jleave:
1829 Fclose(mtf);
1830 j_leave:
1831 if (_sendout_error)
1832 exit_status |= EXIT_SEND_ERROR;
1833 NYD_LEAVE;
1834 return rv;
1835
1836 jfail_dead:
1837 _sendout_error = TRU1;
1838 savedeadletter(mtf, TRU1);
1839 n_err(_("... message not sent\n"));
1840 goto jleave;
1841 }
1842
1843 FL int
1844 mkdate(FILE *fo, char const *field)
1845 {
1846 struct tm tmpgm, *tmptr;
1847 int tzdiff, tzdiff_hour, tzdiff_min, rv;
1848 NYD_ENTER;
1849
1850 memcpy(&tmpgm, &time_current.tc_gm, sizeof tmpgm);
1851 tzdiff = time_current.tc_time - mktime(&tmpgm);
1852 tzdiff_hour = (int)(tzdiff / 60);
1853 tzdiff_min = tzdiff_hour % 60;
1854 tzdiff_hour /= 60;
1855 tmptr = &time_current.tc_local;
1856 if (tmptr->tm_isdst > 0)
1857 ++tzdiff_hour;
1858 rv = fprintf(fo, "%s: %s, %02d %s %04d %02d:%02d:%02d %+05d\n",
1859 field,
1860 weekday_names[tmptr->tm_wday],
1861 tmptr->tm_mday, month_names[tmptr->tm_mon],
1862 tmptr->tm_year + 1900, tmptr->tm_hour,
1863 tmptr->tm_min, tmptr->tm_sec,
1864 tzdiff_hour * 100 + tzdiff_min);
1865 NYD_LEAVE;
1866 return rv;
1867 }
1868
1869 FL int
1870 puthead(bool_t nosend_msg, struct header *hp, FILE *fo, enum gfield w,
1871 enum sendaction action, enum conversion convert, char const *contenttype,
1872 char const *charset)
1873 {
1874 #define FMT_CC_AND_BCC() \
1875 do {\
1876 if ((w & GCC) && (hp->h_cc != NULL || nosend_msg == TRUM1)) {\
1877 if (fmt("Cc:", hp->h_cc, fo, ff))\
1878 goto jleave;\
1879 ++gotcha;\
1880 }\
1881 if ((w & GBCC) && (hp->h_bcc != NULL || nosend_msg == TRUM1)) {\
1882 if (fmt("Bcc:", hp->h_bcc, fo, ff))\
1883 goto jleave;\
1884 ++gotcha;\
1885 }\
1886 } while (0)
1887
1888 char const *addr;
1889 size_t gotcha;
1890 struct name *np, *fromasender = NULL;
1891 int stealthmua, rv = 1;
1892 bool_t nodisp;
1893 enum fmt_flags ff;
1894 NYD_ENTER;
1895
1896 if ((addr = ok_vlook(stealthmua)) != NULL)
1897 stealthmua = !strcmp(addr, "noagent") ? -1 : 1;
1898 else
1899 stealthmua = 0;
1900 gotcha = 0;
1901 nodisp = (action != SEND_TODISP);
1902 ff = (w & (GCOMMA | GFILES)) | (nodisp ? FMT_DOMIME : 0);
1903
1904 if (w & GDATE)
1905 mkdate(fo, "Date"), ++gotcha;
1906 if (w & GIDENT) {
1907 if (hp->h_from == NULL || hp->h_sender == NULL)
1908 setup_from_and_sender(hp);
1909
1910 if (hp->h_from != NULL) {
1911 if (fmt("From:", hp->h_from, fo, ff))
1912 goto jleave;
1913 ++gotcha;
1914 }
1915
1916 if (hp->h_sender != NULL) {
1917 if (fmt("Sender:", hp->h_sender, fo, ff))
1918 goto jleave;
1919 ++gotcha;
1920 }
1921
1922 fromasender = n_UNCONST(check_from_and_sender(hp->h_from, hp->h_sender));
1923 if (fromasender == NULL)
1924 goto jleave;
1925 /* Note that fromasender is (NULL,) 0x1 or real sender here */
1926 }
1927
1928 #if 1
1929 if ((w & GTO) && (hp->h_to != NULL || nosend_msg == TRUM1)) {
1930 if (fmt("To:", hp->h_to, fo, ff))
1931 goto jleave;
1932 ++gotcha;
1933 }
1934 #else
1935 /* TODO Thought about undisclosed recipients:;, but would be such a fake
1936 * TODO given that we cannot handle group addresses. Ridiculous */
1937 if (w & GTO) {
1938 struct name *xto;
1939
1940 if ((xto = hp->h_to) != NULL) {
1941 char const ud[] = "To: Undisclosed recipients:;\n" /* TODO groups */;
1942
1943 if (count_nonlocal(xto) != 0 || ok_blook(add_file_recipients) ||
1944 (hp->h_cc != NULL && count_nonlocal(hp->h_cc) > 0))
1945 goto jto_fmt;
1946 if (fwrite(ud, 1, sizeof(ud) -1, fo) != sizeof(ud) -1)
1947 goto jleave;
1948 ++gotcha;
1949 } else if (nosend_msg == TRUM1) {
1950 jto_fmt:
1951 if (fmt("To:", hp->h_to, fo, ff))
1952 goto jleave;
1953 ++gotcha;
1954 }
1955 }
1956 #endif
1957
1958 if (!ok_blook(bsdcompat) && !ok_blook(bsdorder))
1959 FMT_CC_AND_BCC();
1960
1961 if ((w & GSUBJECT) && (hp->h_subject != NULL || nosend_msg == TRUM1)) {
1962 if (fwrite("Subject: ", sizeof(char), 9, fo) != 9)
1963 goto jleave;
1964 if (hp->h_subject != NULL) {
1965 char *sub = subject_re_trim(hp->h_subject);
1966 size_t sublen = strlen(sub);
1967
1968 /* Trimmed something, (re-)add Re: */
1969 if (sub != hp->h_subject) {
1970 if (fwrite("Re: ", 1, 4, fo) != 4) /* RFC mandates eng. "Re: " */
1971 goto jleave;
1972 if (sublen > 0 &&
1973 xmime_write(sub, sublen, fo,
1974 (!nodisp ? CONV_NONE : CONV_TOHDR),
1975 (!nodisp ? TD_ISPR | TD_ICONV : TD_ICONV)) < 0)
1976 goto jleave;
1977 }
1978 /* This may be, e.g., a Fwd: XXX yes, unfortunately we do like that */
1979 else if (*sub != '\0') {
1980 if (xmime_write(sub, sublen, fo, (!nodisp ? CONV_NONE : CONV_TOHDR),
1981 (!nodisp ? TD_ISPR | TD_ICONV : TD_ICONV)) < 0)
1982 goto jleave;
1983 }
1984 }
1985 ++gotcha;
1986 putc('\n', fo);
1987 }
1988
1989 if (ok_blook(bsdcompat) || ok_blook(bsdorder))
1990 FMT_CC_AND_BCC();
1991
1992 if ((w & GMSGID) && stealthmua <= 0 && (addr = _message_id(hp)) != NULL) {
1993 if (fputs(addr, fo) == EOF || putc('\n', fo) == EOF)
1994 goto jleave;
1995 ++gotcha;
1996 }
1997
1998 if ((np = hp->h_ref) != NULL && (w & GREF)) {
1999 if (fmt("References:", np, fo, 0))
2000 goto jleave;
2001 if (hp->h_in_reply_to == NULL && np->n_name != NULL) {
2002 while (np->n_flink != NULL)
2003 np = np->n_flink;
2004 if (!is_addr_invalid(np, /* TODO check that on parser side! */
2005 /*EACM_STRICT | TODO '/' valid!! */ EACM_NOLOG | EACM_NONAME)) {
2006 if (fprintf(fo,
2007 "In-Reply-To: <%s>\n", np->n_name /*TODO RFC5322 3.6.4*/) < 0)
2008 goto jleave;
2009 ++gotcha;
2010 } else {
2011 n_err(_("Invalid address in mail header: %s\n"), np->n_name);
2012 goto jleave;
2013 }
2014 }
2015 }
2016 if ((np = hp->h_in_reply_to) != NULL && (w & GREF)) {
2017 if (fprintf(fo,
2018 "In-Reply-To: <%s>\n", np->n_name /*TODO RFC 5322 3.6.4*/) < 0)
2019 goto jleave;
2020 ++gotcha;
2021 }
2022
2023 if (w & GIDENT) {
2024 /* Reply-To:. Be careful not to destroy a possible user input, duplicate
2025 * the list first.. TODO it is a terrible codebase.. */
2026 if ((np = hp->h_replyto) != NULL)
2027 np = namelist_dup(np, np->n_type);
2028 else if ((addr = ok_vlook(replyto)) != NULL)
2029 np = lextract(addr, GEXTRA | GFULL);
2030 if (np != NULL &&
2031 (np = elide(
2032 checkaddrs(usermap(np, TRU1), EACM_STRICT | EACM_NOLOG,
2033 NULL))) != NULL) {
2034 if (fmt("Reply-To:", np, fo, ff))
2035 goto jleave;
2036 ++gotcha;
2037 }
2038 }
2039
2040 if ((w & GIDENT) && !nosend_msg) {
2041 /* Mail-Followup-To: TODO factor out this huge block of code */
2042 /* Place ourselfs in there if any non-subscribed list is an addressee */
2043 if ((hp->h_flags & HF_LIST_REPLY) || hp->h_mft != NULL ||
2044 ok_blook(followup_to)) {
2045 enum {_ANYLIST=1<<(HF__NEXT_SHIFT+0), _HADMFT=1<<(HF__NEXT_SHIFT+1)};
2046
2047 ui32_t f = hp->h_flags | (hp->h_mft != NULL ? _HADMFT : 0);
2048 struct name *mft, *x;
2049
2050 /* But for that, we have to remove all incarnations of ourselfs first.
2051 * TODO It is total crap that we have delete_alternates(), is_myname()
2052 * TODO or whatever; these work only with variables, not with data
2053 * TODO that is _currently_ in some header fields!!! v15.0: complete
2054 * TODO rewrite, object based, lazy evaluated, on-the-fly marked.
2055 * TODO then this should be a really cheap thing in here... */
2056 np = elide(delete_alternates(cat(
2057 namelist_dup(hp->h_to, GEXTRA | GFULL),
2058 namelist_dup(hp->h_cc, GEXTRA | GFULL))));
2059 addr = hp->h_list_post;
2060
2061 for (mft = NULL; (x = np) != NULL;) {
2062 si8_t ml;
2063 np = np->n_flink;
2064
2065 if ((ml = is_mlist(x->n_name, FAL0)) == MLIST_OTHER &&
2066 addr != NULL && !asccasecmp(addr, x->n_name))
2067 ml = MLIST_KNOWN;
2068
2069 /* Any non-subscribed list? Add ourselves */
2070 switch (ml) {
2071 case MLIST_KNOWN:
2072 f |= HF_MFT_SENDER;
2073 /* FALLTHRU */
2074 case MLIST_SUBSCRIBED:
2075 f |= _ANYLIST;
2076 goto j_mft_add;
2077 case MLIST_OTHER:
2078 if (!(f & HF_LIST_REPLY)) {
2079 j_mft_add:
2080 if (!is_addr_invalid(x,
2081 EACM_STRICT | EACM_NOLOG | EACM_NONAME)) {
2082 x->n_flink = mft;
2083 mft = x;
2084 } /* XXX write some warning? if verbose?? */
2085 continue;
2086 }
2087 /* And if this is a reply that honoured a MFT: header then we'll
2088 * also add all members of the original MFT: that are still
2089 * addressed by us, regardless of all other circumstances */
2090 else if (f & _HADMFT) {
2091 struct name *ox;
2092 for (ox = hp->h_mft; ox != NULL; ox = ox->n_flink)
2093 if (!asccasecmp(ox->n_name, x->n_name))
2094 goto j_mft_add;
2095 }
2096 break;
2097 }
2098 }
2099
2100 if (f & (_ANYLIST | _HADMFT) && mft != NULL) {
2101 if (((f & HF_MFT_SENDER) ||
2102 ((f & (_ANYLIST | _HADMFT)) == _HADMFT)) &&
2103 (np = fromasender) != NULL && np != (struct name*)0x1) {
2104 np = ndup(np, (np->n_type & ~GMASK) | GEXTRA | GFULL);
2105 np->n_flink = mft;
2106 mft = np;
2107 }
2108
2109 if (fmt("Mail-Followup-To:", mft, fo, ff))
2110 goto jleave;
2111 ++gotcha;
2112 }
2113 }
2114
2115 if (!_check_dispo_notif(fromasender, hp, fo))
2116 goto jleave;
2117 }
2118
2119 if ((w & GUA) && stealthmua == 0) {
2120 if (fprintf(fo, "User-Agent: %s %s\n", uagent, ok_vlook(version)) < 0)
2121 goto jleave;
2122 ++gotcha;
2123 }
2124
2125 /* The user may have placed headers when editing */
2126 if(1){
2127 struct n_header_field *hfp;
2128
2129 if((hfp = hp->h_user_headers) != NULL){
2130 if(!_sendout_header_list(fo, hfp, nodisp))
2131 goto jleave;
2132 ++gotcha;
2133 }
2134 }
2135
2136 /* Custom headers, as via *customhdr* */
2137 if(!nosend_msg){
2138 struct n_header_field *hfp;
2139
2140 /* With iconv support we likely have a cached result */
2141 if((hfp = hp->h_custom_headers) == NULL)
2142 hp->h_custom_headers = hfp = n_customhdr_query();
2143 if(hfp != NULL){
2144 if(!_sendout_header_list(fo, hfp, nodisp))
2145 goto jleave;
2146 ++gotcha;
2147 }
2148 }
2149
2150 /* We don't need MIME unless.. we need MIME?! */
2151 if ((w & GMIME) && ((pstate & PS_HEADER_NEEDED_MIME) ||
2152 hp->h_attach != NULL ||
2153 ((options & OPT_Mm_FLAG) && option_Mm_arg != NULL) ||
2154 convert != CONV_7BIT || asccasecmp(charset, "US-ASCII"))) {
2155 ++gotcha;
2156 if (fputs("MIME-Version: 1.0\n", fo) == EOF)
2157 goto jleave;
2158 if (hp->h_attach != NULL) {
2159 _sendout_boundary = mime_param_boundary_create();/*TODO carrier*/
2160 if (fprintf(fo,
2161 "Content-Type: multipart/mixed;\n boundary=\"%s\"\n",
2162 _sendout_boundary) < 0)
2163 goto jleave;
2164 } else {
2165 if (_put_ct(fo, contenttype, charset) < 0 || _put_cte(fo, convert) < 0)
2166 goto jleave;
2167 }
2168 }
2169
2170 if (gotcha && (w & GNL))
2171 if (putc('\n', fo) == EOF)
2172 goto jleave;
2173 rv = 0;
2174 jleave:
2175 NYD_LEAVE;
2176 return rv;
2177 #undef FMT_CC_AND_BCC
2178 }
2179
2180 FL enum okay
2181 resend_msg(struct message *mp, struct name *to, int add_resent) /* TODO check */
2182 {
2183 struct sendbundle sb;
2184 FILE *ibuf, *nfo, *nfi;
2185 char *tempMail;
2186 enum okay rv = STOP;
2187 NYD_ENTER;
2188
2189 _sendout_error = FAL0;
2190 __sendout_ident = NULL;
2191
2192 /* Update some globals we likely need first */
2193 time_current_update(&time_current, TRU1);
2194
2195 if ((to = checkaddrs(to,
2196 (EACM_NORMAL |
2197 (!(expandaddr_to_eaf() & EAF_NAME) ? EACM_NONAME : EACM_NONE)),
2198 &_sendout_error)) == NULL)
2199 goto jleave;
2200 /* For the _sendout_error<0 case we want to wait until we can write DEAD! */
2201 if (_sendout_error < 0)
2202 n_err(_("Some addressees were classified as \"hard error\"\n"));
2203
2204 if ((nfo = Ftmp(&tempMail, "resend", OF_WRONLY | OF_HOLDSIGS | OF_REGISTER))
2205 == NULL) {
2206 _sendout_error = TRU1;
2207 n_perr(_("temporary mail file"), 0);
2208 goto jleave;
2209 }
2210 if ((nfi = Fopen(tempMail, "r")) == NULL)
2211 n_perr(tempMail, 0);
2212 Ftmp_release(&tempMail);
2213 if (nfi == NULL)
2214 goto jerr_o;
2215
2216 if ((ibuf = setinput(&mb, mp, NEED_BODY)) == NULL)
2217 goto jerr_io;
2218
2219 memset(&sb, 0, sizeof sb);
2220 sb.sb_to = to;
2221 sb.sb_input = nfi;
2222 if (count_nonlocal(to) > 0 && !_sendbundle_setup_creds(&sb, FAL0))
2223 /* ..wait until we can write DEAD */
2224 _sendout_error = -1;
2225
2226 if (infix_resend(ibuf, nfo, mp, to, add_resent) != 0) {
2227 jfail_dead:
2228 savedeadletter(nfi, TRU1);
2229 n_err(_("... message not sent\n"));
2230 jerr_io:
2231 Fclose(nfi);
2232 jerr_o:
2233 Fclose(nfo);
2234 _sendout_error = TRU1;
2235 goto jleave;
2236 }
2237
2238 if (_sendout_error < 0)
2239 goto jfail_dead;
2240
2241 Fclose(nfo);
2242 rewind(nfi);
2243
2244 to = _outof(to, nfi, &_sendout_error);
2245
2246 if (_sendout_error)
2247 savedeadletter(nfi, FAL0);
2248
2249 if (count(to = elide(to)) != 0) {
2250 if (!ok_blook(record_resent) || mightrecord(nfi, NULL, TRU1)) {
2251 sb.sb_to = to;
2252 /*sb.sb_input = nfi;*/
2253 if (_transfer(&sb))
2254 rv = OKAY;
2255 }
2256 } else if (!_sendout_error)
2257 rv = OKAY;
2258
2259 Fclose(nfi);
2260 jleave:
2261 if (_sendout_error)
2262 exit_status |= EXIT_SEND_ERROR;
2263 NYD_LEAVE;
2264 return rv;
2265 }
2266
2267 FL void
2268 savedeadletter(FILE *fp, bool_t fflush_rewind_first){
2269 struct n_string line;
2270 int c;
2271 enum {a_NONE, a_INIT = 1<<0, a_BODY = 1<<1, a_NL = 1<<2} flags;
2272 ul_i bytes, lines;
2273 FILE *dbuf;
2274 char const *cp, *cpq;
2275 NYD_ENTER;
2276
2277 if(!ok_blook(save))
2278 goto jleave;
2279
2280 if(fflush_rewind_first){
2281 fflush(fp);
2282 rewind(fp);
2283 }
2284 if(fsize(fp) == 0)
2285 goto jleave;
2286
2287 cp = n_getdeadletter();
2288 cpq = n_shexp_quote_cp(cp, FAL0);
2289
2290 if(options & OPT_DEBUG){
2291 n_err(_(">>> Would (try to) write $DEAD %s\n"), cpq);
2292 goto jleave;
2293 }
2294
2295 if((dbuf = Fopen(cp, "w")) == NULL){
2296 n_perr(_("Cannot save to $DEAD"), 0);
2297 goto jleave;
2298 }
2299 n_file_lock(fileno(dbuf), FLT_WRITE, 0,0, UIZ_MAX); /* XXX Natomic */
2300
2301 printf("%s ", cpq);
2302 fflush(stdout);
2303
2304 /* TODO savedeadletter() non-conforming: should check whether we have any
2305 * TODO headers, if not we need to place "something", anything will do.
2306 * TODO MIME is completely missing, we use MBOXO quoting!! Yuck.
2307 * TODO I/O error handling missing. Yuck! */
2308 n_string_reserve(n_string_creat_auto(&line), 2 * SEND_LINESIZE);
2309 bytes = (ul_i)fprintf(dbuf, "From %s %s", myname, time_current.tc_ctime);
2310 lines = 1;
2311 for(flags = a_NONE, c = '\0'; c != EOF; bytes += line.s_len, ++lines){
2312 n_string_trunc(&line, 0);
2313 while((c = getc(fp)) != EOF && c != '\n')
2314 n_string_push_c(&line, c);
2315
2316 /* TODO It may be that we have only some plain text. It may be that we
2317 * TODO have a complete MIME encoded message. We don't know, and we
2318 * TODO have no usable mechanism to dig it!! tWe need v15! */
2319 if(!(flags & a_INIT)){
2320 size_t i;
2321
2322 /* Throw away leading empty lines! */
2323 if(line.s_len == 0)
2324 continue;
2325 for(i = 0; i < line.s_len; ++i){
2326 if(fieldnamechar(line.s_dat[i]))
2327 continue;
2328 if(line.s_dat[i] == ':'){
2329 flags |= a_INIT;
2330 break;
2331 }else{
2332 /* We have no headers, this is already a body line! */
2333 flags |= a_INIT | a_BODY;
2334 break;
2335 }
2336 }
2337 /* Well, i had to check whether the RFC allows this. Assume we've
2338 * passed the headers, too, then! */
2339 if(i == line.s_len)
2340 flags |= a_INIT | a_BODY;
2341 }
2342 if(flags & a_BODY){
2343 if(line.s_len >= 5 && !memcmp(line.s_dat, "From ", 5))
2344 n_string_unshift_c(&line, '>');
2345 }
2346 if(line.s_len == 0)
2347 flags |= a_BODY | a_NL;
2348 else
2349 flags &= ~a_NL;
2350
2351 n_string_push_c(&line, '\n');
2352 fwrite(line.s_dat, sizeof *line.s_dat, line.s_len, dbuf);
2353 }
2354 if(!(flags & a_NL)){
2355 putc('\n', dbuf);
2356 ++bytes;
2357 ++lines;
2358 }
2359 n_string_gut(&line);
2360
2361 Fclose(dbuf);
2362 printf("%lu/%lu\n", lines, bytes);
2363 fflush(stdout);
2364
2365 rewind(fp);
2366 jleave:
2367 NYD_LEAVE;
2368 }
2369
2370 #undef SEND_LINESIZE
2371
2372 /* s-it-mode */
A mail processing system intended to provide the functionality of the POSIX mailx(1) command