?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Dump to a "-" file recipient even with *debug* enabled!
[s-mailx.git] / sendout.c
blobb0064c5dd6365a852b2b59463bfb04ca28f02091
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 /* We _do_ write to STDOUT, anyway! */
829 if((options & OPT_DEBUG) && ((np->n_flags & NAME_ADDRSPEC_ISPIPE) ||
830 np->n_name[0] != '-' || np->n_name[1] != '\0'))
831 continue;
832
833 /* See if we have copied the complete message out yet. If not, do so */
834 if (image < 0) {
835 int c;
836 char *tempEdit;
837
838 if ((fout = Ftmp(&tempEdit, "outof",
839 OF_WRONLY | OF_HOLDSIGS | OF_REGISTER)) == NULL) {
840 n_perr(_("Creation of temporary image"), 0);
841 *senderror = TRU1;
842 goto jcant;
843 }
844 if ((image = open(tempEdit, O_RDWR | _O_CLOEXEC)) >= 0) {
845 _CLOEXEC_SET(image);
846 for (i = 0; i < pipecnt; ++i) {
847 int fd = open(tempEdit, O_RDONLY | _O_CLOEXEC);
848 if (fd < 0) {
849 close(image);
850 image = -1;
851 pipecnt = i;
852 break;
853 }
854 fda[i] = fd;
855 _CLOEXEC_SET(fd);
856 }
857 }
858 Ftmp_release(&tempEdit);
859
860 if (image < 0) {
861 n_perr(_("Creating descriptor duplicate of temporary image"), 0);
862 *senderror = TRU1;
863 Fclose(fout);
864 goto jcant;
865 }
866
867 fprintf(fout, "From %s %s", myname, time_current.tc_ctime);
868 c = EOF;
869 while (i = c, (c = getc(fo)) != EOF)
870 putc(c, fout);
871 rewind(fo);
872 if ((int)i != '\n')
873 putc('\n', fout);
874 putc('\n', fout);
875 fflush(fout);
876 if (ferror(fout)) {
877 n_perr(_("Finalizing write of temporary image"), 0);
878 Fclose(fout);
879 goto jcantfout;
880 }
881 Fclose(fout);
882
883 /* If we have to serve file addressees, open reader */
884 if (xcnt != 0 && (fin = Fdopen(image, "r", FAL0)) == NULL) {
885 n_perr(_("Failed to open a temporary image duplicate"), 0);
886 jcantfout:
887 *senderror = TRU1;
888 close(image);
889 image = -1;
890 goto jcant;
891 }
892
893 /* From now on use xcnt as a counter for pipecnt */
894 xcnt = 0;
895 }
896
897 /* Now either copy "image" to the desired file or give it as the standard
898 * input to the desired program as appropriate */
899 if (np->n_flags & NAME_ADDRSPEC_ISPIPE) {
900 int pid;
901 sigset_t nset;
902
903 sigemptyset(&nset);
904 sigaddset(&nset, SIGHUP);
905 sigaddset(&nset, SIGINT);
906 sigaddset(&nset, SIGQUIT);
907 pid = start_command(sh, &nset, fda[xcnt++], COMMAND_FD_NULL, "-c",
908 np->n_name + 1, NULL, NULL);
909 if (pid < 0) {
910 n_err(_("Piping message to %s failed\n"),
911 n_shexp_quote_cp(np->n_name, FAL0));
912 *senderror = TRU1;
913 goto jcant;
914 }
915 free_child(pid);
916 } else {
917 int c;
918 char const *fname, *fnameq;
919
920 if ((fname = fexpand(np->n_name, FEXP_LOCAL | FEXP_NOPROTO)) == NULL) {
921 *senderror = TRU1;
922 goto jcant;
923 }
924 fnameq = n_shexp_quote_cp(fname, FAL0);
925
926 if(fname[0] == '-' && fname[1] == '\0')
927 fout = stdout;
928 else if ((fout = Zopen(fname, "a")) == NULL) {
929 n_err(_("Writing message to %s failed: %s\n"),
930 fnameq, strerror(errno));
931 *senderror = TRU1;
932 goto jcant;
933 }
934 rewind(fin);
935 while ((c = getc(fin)) != EOF)
936 putc(c, fout);
937 if (ferror(fout)) {
938 n_err(_("Writing message to %s failed: %s\n"),
939 fnameq, _("write error"));
940 *senderror = TRU1;
941 }
942 if(fout != stdout)
943 Fclose(fout);
944 }
945
946 jcant:
947 if (image < 0)
948 goto jdelall;
949 }
950
951 jleave:
952 if (fin != NULL)
953 Fclose(fin);
954 for (i = 0; i < pipecnt; ++i)
955 close(fda[i]);
956 if (image >= 0) {
957 close(image);
958 image = -1;
959 }
960 NYD_LEAVE;
961 return names;
962
963 jdelall:
964 while (np != NULL) {
965 if (np->n_flags & NAME_ADDRSPEC_ISFILEORPIPE)
966 np->n_type |= GDEL;
967 np = np->n_flink;
968 }
969 goto jleave;
970 }
971
972 static bool_t
973 mightrecord(FILE *fp, struct name *to, bool_t resend)
974 {
975 char *cp, *cq;
976 char const *ep;
977 bool_t rv = TRU1;
978 NYD_ENTER;
979
980 if (options & OPT_DEBUG)
981 cp = NULL;
982 else if (to != NULL) {
983 cp = savestr(skinned_name(to));
984 for (cq = cp; *cq != '\0' && *cq != '@'; ++cq)
985 ;
986 *cq = '\0';
987 } else
988 cp = ok_vlook(record);
989
990 if (cp != NULL) {
991 if ((ep = expand(cp)) == NULL) {
992 ep = "NULL";
993 goto jbail;
994 }
995
996 if (*ep != '/' && *ep != '+' && ok_blook(outfolder) &&
997 which_protocol(ep) == PROTO_FILE) {
998 size_t i = strlen(cp);
999 cq = salloc(i + 1 +1);
1000 cq[0] = '+';
1001 memcpy(cq + 1, cp, i +1);
1002 cp = cq;
1003 if ((ep = fexpand(cp, FEXP_LOCAL | FEXP_NOPROTO)) == NULL) {
1004 ep = "NULL";
1005 goto jbail;
1006 }
1007 }
1008
1009 if (!a_sendout__savemail(ep, fp, resend)) {
1010 jbail:
1011 n_err(_("Failed to save message in %s - message not sent\n"),
1012 n_shexp_quote_cp(ep, FAL0));
1013 exit_status |= EXIT_ERR;
1014 savedeadletter(fp, 1);
1015 rv = FAL0;
1016 }
1017 }
1018 NYD_LEAVE;
1019 return rv;
1020 }
1021
1022 static bool_t
1023 a_sendout__savemail(char const *name, FILE *fp, bool_t resend){
1024 FILE *fo;
1025 size_t bufsize, buflen, cnt;
1026 bool_t rv, emptyline;
1027 char *buf;
1028 NYD_ENTER;
1029
1030 buf = smalloc(bufsize = LINESIZE);
1031 rv = emptyline = FAL0;
1032
1033 if((fo = Zopen(name, "a+")) == NULL){
1034 if((fo = Zopen(name, "wx")) == NULL){
1035 n_perr(name, 0);
1036 goto j_leave;
1037 }
1038 emptyline = TRU1;
1039 }
1040
1041 /* TODO RETURN check, but be aware of protocols: v15: Mailbox->lock()! */
1042 n_file_lock(fileno(fo), FLT_WRITE, 0,0, UIZ_MAX);
1043
1044 rv = TRU1;
1045
1046 if(!emptyline){
1047 if(fseek(fo, -2L, SEEK_END) == 0){ /* TODO Should be Mailbox::->append */
1048 switch(fread(buf, sizeof *buf, 2, fo)){
1049 case 2:
1050 if(buf[1] != '\n')
1051 emptyline = TRU1;
1052 break;
1053 case 1:
1054 if(buf[0] != '\n')
1055 emptyline = TRU1;
1056 break;
1057 default:
1058 if(ferror(fo)){
1059 n_perr(name, 0);
1060 rv = FAL0;
1061 goto jleave;
1062 }
1063 }
1064 if(emptyline){
1065 putc('\n', fo);
1066 fflush(fo);
1067 }
1068 }
1069 }
1070
1071 fflush_rewind(fp);
1072
1073 fprintf(fo, "From %s %s", myname, time_current.tc_ctime);
1074 for(emptyline = FAL0, buflen = 0, cnt = fsize(fp);
1075 fgetline(&buf, &bufsize, &cnt, &buflen, fp, 0) != NULL;){
1076 /* Only if we are resending it can happen that we have to quote From_
1077 * lines here; we don't generate messages which are ambiguous ourselves */
1078 if(resend){
1079 if(emptyline && is_head(buf, buflen, FAL0))
1080 putc('>', fo);
1081 }DBG(else assert(!is_head(buf, buflen, FAL0)); )
1082
1083 emptyline = (buflen > 0 && *buf == '\n');
1084 fwrite(buf, sizeof *buf, buflen, fo);
1085 }
1086 if(buflen > 0 && buf[buflen - 1] != '\n')
1087 putc('\n', fo);
1088 putc('\n', fo);
1089 fflush(fo);
1090 if(ferror(fo)){
1091 n_perr(name, 0);
1092 rv = FAL0;
1093 }
1094
1095 jleave:
1096 really_rewind(fp);
1097 if(Fclose(fo) != 0)
1098 rv = FAL0;
1099 j_leave:
1100 free(buf);
1101 NYD_LEAVE;
1102 return rv;
1103 }
1104
1105 static bool_t
1106 _transfer(struct sendbundle *sbp)
1107 {
1108 struct name *np;
1109 ui32_t cnt;
1110 bool_t rv = TRU1;
1111 NYD_ENTER;
1112
1113 for (cnt = 0, np = sbp->sb_to; np != NULL;) {
1114 char const k[] = "smime-encrypt-";
1115 size_t nl = strlen(np->n_name);
1116 char *cp, *vs = ac_alloc(sizeof(k)-1 + nl +1);
1117 memcpy(vs, k, sizeof(k) -1);
1118 memcpy(vs + sizeof(k) -1, np->n_name, nl +1);
1119
1120 if ((cp = vok_vlook(vs)) != NULL) {
1121 #ifdef HAVE_SSL
1122 FILE *ef;
1123
1124 if ((ef = smime_encrypt(sbp->sb_input, cp, np->n_name)) != NULL) {
1125 FILE *fisave = sbp->sb_input;
1126 struct name *nsave = sbp->sb_to;
1127
1128 sbp->sb_to = ndup(np, np->n_type & ~(GFULL | GSKIN));
1129 sbp->sb_input = ef;
1130 if (!__mta_start(sbp))
1131 rv = FAL0;
1132 sbp->sb_to = nsave;
1133 sbp->sb_input = fisave;
1134
1135 Fclose(ef);
1136 } else {
1137 #else
1138 n_err(_("No SSL support compiled in\n"));
1139 rv = FAL0;
1140 #endif
1141 n_err(_("Message not sent to: %s\n"), np->n_name);
1142 _sendout_error = TRU1;
1143 #ifdef HAVE_SSL
1144 }
1145 #endif
1146 rewind(sbp->sb_input);
1147
1148 if (np->n_flink != NULL)
1149 np->n_flink->n_blink = np->n_blink;
1150 if (np->n_blink != NULL)
1151 np->n_blink->n_flink = np->n_flink;
1152 if (np == sbp->sb_to)
1153 sbp->sb_to = np->n_flink;
1154 np = np->n_flink;
1155 } else {
1156 ++cnt;
1157 np = np->n_flink;
1158 }
1159 ac_free(vs);
1160 }
1161
1162 if (cnt > 0 && (ok_blook(smime_force_encryption) || !__mta_start(sbp)))
1163 rv = FAL0;
1164 NYD_LEAVE;
1165 return rv;
1166 }
1167
1168 static bool_t
1169 __mta_start(struct sendbundle *sbp)
1170 {
1171 pid_t pid;
1172 sigset_t nset;
1173 char const **args, *mta;
1174 bool_t rv;
1175 NYD_ENTER;
1176
1177 if((mta = ok_vlook(smtp)) != NULL){
1178 OBSOLETE(_("please don't use *smtp*, but assign an SMTP URL to *mta*"));
1179 /* For *smtp* the smtp:// protocol was optional; be simple: don't check
1180 * that *smtp* is misused with file:// or so */
1181 if(n_servbyname(mta, NULL) == NULL)
1182 mta = savecat("smtp://", mta);
1183 rv = TRU1;
1184 }else{
1185 char const *proto;
1186
1187 if((proto = ok_vlook(sendmail)) != NULL)
1188 OBSOLETE(_("please use *mta* instead of *sendmail*"));
1189 if((mta = ok_vlook(mta)) == NULL){ /* TODO v15: mta = ok_vlook(mta); */
1190 if(proto == NULL){
1191 mta = VAL_MTA;
1192 rv = FAL0;
1193 }else
1194 rv = TRU1;
1195 }
1196 /* TODO for now this is pretty hacky: in v15 we should simply create
1197 * TODO an URL object; i.e., be able to do so, and it does it right
1198 * TODO I.e.,: url_creat(&url, ok_vlook(mta)); */
1199 else if((proto = n_servbyname(mta, NULL)) != NULL){
1200 if(*proto == '\0'){
1201 mta += sizeof("file://") -1;
1202 rv = FAL0;
1203 }else
1204 rv = TRU1;
1205 }else
1206 rv = FAL0;
1207 }
1208
1209 if(!rv){
1210 char const *mta_base;
1211
1212 if((mta = fexpand(mta_base = mta, FEXP_LOCAL | FEXP_NOPROTO)) == NULL){
1213 n_err(_("*mta* variable expansion failure: %s\n"),
1214 n_shexp_quote_cp(mta_base, FAL0));
1215 goto jstop;
1216 }
1217
1218 args = __mta_prepare_args(sbp->sb_to, sbp->sb_hp);
1219 if (options & OPT_DEBUG) {
1220 __mta_debug(sbp, mta, args);
1221 rv = TRU1;
1222 goto jleave;
1223 }
1224 } else {
1225 n_UNINIT(args, NULL);
1226 #ifndef HAVE_SMTP
1227 n_err(_("No SMTP support compiled in\n"));
1228 goto jstop;
1229 #else
1230 if (options & OPT_DEBUG) {
1231 (void)smtp_mta(sbp);
1232 rv = TRU1;
1233 goto jleave;
1234 }
1235 #endif
1236 }
1237
1238 /* Fork, set up the temporary mail file as standard input for "mail", and
1239 * exec with the user list we generated far above */
1240 if ((pid = fork_child()) == -1) {
1241 n_perr("fork", 0);
1242 jstop:
1243 savedeadletter(sbp->sb_input, 0);
1244 _sendout_error = TRU1;
1245 goto jleave;
1246 }
1247 if (pid == 0) {
1248 sigemptyset(&nset);
1249 sigaddset(&nset, SIGHUP);
1250 sigaddset(&nset, SIGINT);
1251 sigaddset(&nset, SIGQUIT);
1252 sigaddset(&nset, SIGTSTP);
1253 sigaddset(&nset, SIGTTIN);
1254 sigaddset(&nset, SIGTTOU);
1255 freopen("/dev/null", "r", stdin);
1256 #ifdef HAVE_SMTP
1257 if (rv) {
1258 prepare_child(&nset, 0, 1);
1259 if (smtp_mta(sbp))
1260 _exit(EXIT_OK);
1261 } else
1262 #endif
1263 {
1264 char const *ecp;
1265 int e;
1266
1267 prepare_child(&nset, fileno(sbp->sb_input), -1);
1268 execv(mta, n_UNCONST(args));
1269 e = errno;
1270 ecp = (e != ENOENT) ? strerror(e)
1271 : _("executable not found (adjust *mta* variable)");
1272 n_err(_("Cannot start %s: %s\n"), n_shexp_quote_cp(mta, FAL0), ecp);
1273 }
1274 savedeadletter(sbp->sb_input, 1);
1275 n_err(_("... message not sent\n"));
1276 _exit(EXIT_ERR);
1277 }
1278
1279 if ((options & (OPT_DEBUG | OPT_VERB)) || ok_blook(sendwait)) {
1280 if (!(rv = wait_child(pid, NULL)))
1281 _sendout_error = TRU1;
1282 } else {
1283 free_child(pid);
1284 rv = TRU1;
1285 }
1286 jleave:
1287 NYD_LEAVE;
1288 return rv;
1289 }
1290
1291 static char const **
1292 __mta_prepare_args(struct name *to, struct header *hp)
1293 {
1294 size_t vas_cnt, i, j;
1295 char **vas;
1296 char const **args, *cp, *cp_v15compat;
1297 bool_t snda;
1298 NYD_ENTER;
1299
1300 if((cp_v15compat = ok_vlook(sendmail_arguments)) != NULL)
1301 OBSOLETE(_("please use *mta-arguments*, not *sendmail-arguments*"));
1302 if((cp = ok_vlook(mta_arguments)) == NULL)
1303 cp = cp_v15compat;
1304 if ((cp /* TODO v15: = ok_vlook(mta_arguments)*/) == NULL) {
1305 vas_cnt = 0;
1306 vas = NULL;
1307 } else {
1308 /* Don't assume anything on the content but do allocate exactly j slots;
1309 * like this getrawlist will never overflow (and return -1) */
1310 j = strlen(cp);
1311 vas = n_lofi_alloc(sizeof(*vas) * j);
1312 vas_cnt = (size_t)getrawlist(FAL0, vas, j, cp, j);
1313 }
1314
1315 i = 4 + smopts_cnt + vas_cnt + 4 + 1 + count(to) + 1;
1316 args = salloc(i * sizeof(char*));
1317
1318 if((cp_v15compat = ok_vlook(sendmail_progname)) != NULL)
1319 OBSOLETE(_("please use *mta-argv0*, not *sendmail-progname*"));
1320 if((cp = ok_vlook(mta_argv0)) == NULL)
1321 cp = cp_v15compat;
1322 if(cp == NULL)
1323 cp = VAL_MTA_ARGV0;
1324 args[0] = cp/* TODO v15: = ok_vlook(mta_argv0) */;
1325
1326 if ((snda = ok_blook(sendmail_no_default_arguments)))
1327 OBSOLETE(_("please use *mta-no-default-arguments*, "
1328 "not *sendmail-no-default-arguments*"));
1329 snda |= ok_blook(mta_no_default_arguments);
1330 if ((snda /* TODO v15: = ok_blook(mta_no_default_arguments)*/))
1331 i = 1;
1332 else {
1333 args[1] = "-i";
1334 i = 2;
1335 if (ok_blook(metoo))
1336 args[i++] = "-m";
1337 if (options & OPT_VERB)
1338 args[i++] = "-v";
1339 }
1340
1341 for (j = 0; j < smopts_cnt; ++j, ++i)
1342 args[i] = smopts[j];
1343
1344 for (j = 0; j < vas_cnt; ++j, ++i)
1345 args[i] = vas[j];
1346
1347 /* -r option? In conjunction with -t we act compatible to postfix(1) and
1348 * ignore it (it is -f / -F there) if the message specified From:/Sender:.
1349 * The interdependency with -t has been resolved in puthead() */
1350 if (!snda && ((options & OPT_r_FLAG) || ok_blook(r_option_implicit))) {
1351 struct name const *np;
1352
1353 if (hp != NULL && (np = hp->h_from) != NULL) {
1354 /* However, what wasn't resolved there was the case that the message
1355 * specified multiple From: addresses and a Sender: */
1356 if ((pstate & PS_t_FLAG) && hp->h_sender != NULL)
1357 np = hp->h_sender;
1358
1359 if (np->n_fullextra != NULL) {
1360 args[i++] = "-F";
1361 args[i++] = np->n_fullextra;
1362 }
1363 cp = np->n_name;
1364 } else {
1365 assert(option_r_arg == NULL);
1366 cp = skin(myorigin(NULL));
1367 }
1368
1369 if (cp != NULL) {
1370 args[i++] = "-f";
1371 args[i++] = cp;
1372 }
1373 }
1374
1375 /* Terminate option list to avoid false interpretation of system-wide
1376 * aliases that start with hyphen */
1377 if (!snda)
1378 args[i++] = "--";
1379
1380 /* Receivers follow */
1381 for (; to != NULL; to = to->n_flink)
1382 if (!(to->n_type & GDEL))
1383 args[i++] = to->n_name;
1384 args[i] = NULL;
1385
1386 if(vas != NULL)
1387 n_lofi_free(vas);
1388 NYD_LEAVE;
1389 return args;
1390 }
1391
1392 static void
1393 __mta_debug(struct sendbundle *sbp, char const *mta, char const **args)
1394 {
1395 size_t cnt, bufsize, llen;
1396 char *buf;
1397 NYD_ENTER;
1398
1399 n_err(_(">>> MTA: %s, arguments:"), n_shexp_quote_cp(mta, FAL0));
1400 for (; *args != NULL; ++args)
1401 n_err(" %s", n_shexp_quote_cp(*args, FAL0));
1402 n_err("\n");
1403
1404 fflush_rewind(sbp->sb_input);
1405
1406 cnt = fsize(sbp->sb_input);
1407 buf = NULL;
1408 bufsize = 0;
1409 while (fgetline(&buf, &bufsize, &cnt, &llen, sbp->sb_input, TRU1) != NULL) {
1410 buf[--llen] = '\0';
1411 n_err(">>> %s\n", buf);
1412 }
1413 if (buf != NULL)
1414 free(buf);
1415 NYD_LEAVE;
1416 }
1417
1418 static char *
1419 _message_id(struct header *hp)
1420 {
1421 char *rv = NULL, sep;
1422 char const *h;
1423 size_t rl, i;
1424 struct tm *tmp;
1425 NYD_ENTER;
1426
1427 if (hp != NULL && hp->h_message_id != NULL) {
1428 i = strlen(hp->h_message_id->n_name);
1429 rl = sizeof("Message-ID: <>") -1;
1430 rv = salloc(rl + i +1);
1431 memcpy(rv, "Message-ID: <", --rl);
1432 memcpy(rv + rl, hp->h_message_id->n_name, i);
1433 rl += i;
1434 rv[rl++] = '>';
1435 rv[rl] = '\0';
1436 goto jleave;
1437 }
1438
1439 if (ok_blook(message_id_disable))
1440 goto jleave;
1441
1442 sep = '%';
1443 rl = 9;
1444 if ((h = __sendout_ident) != NULL)
1445 goto jgen;
1446 if (ok_vlook(hostname) != NULL) {
1447 h = nodename(1);
1448 sep = '@';
1449 rl = 15;
1450 goto jgen;
1451 }
1452 if (hp != NULL && (h = skin(myorigin(hp))) != NULL && strchr(h, '@') != NULL)
1453 goto jgen;
1454 /* Up to MTA */
1455 goto jleave;
1456
1457 jgen:
1458 tmp = &time_current.tc_gm;
1459 i = sizeof("Message-ID: <%04d%02d%02d%02d%02d%02d.%s%c%s>") -1 +
1460 rl + strlen(h);
1461 rv = salloc(i +1);
1462 snprintf(rv, i, "Message-ID: <%04d%02d%02d%02d%02d%02d.%s%c%s>",
1463 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
1464 tmp->tm_hour, tmp->tm_min, tmp->tm_sec,
1465 getrandstring(rl), sep, h);
1466 rv[i] = '\0'; /* Because we don't test snprintf(3) return */
1467 jleave:
1468 NYD_LEAVE;
1469 return rv;
1470 }
1471
1472 static int
1473 fmt(char const *str, struct name *np, FILE *fo, enum fmt_flags ff)
1474 {
1475 enum {
1476 m_INIT = 1<<0,
1477 m_COMMA = 1<<1,
1478 m_NOPF = 1<<2,
1479 m_NONAME = 1<<3,
1480 m_CSEEN = 1<<4
1481 } m = (ff & GCOMMA) ? m_COMMA : 0;
1482 ssize_t col, len;
1483 int rv = 1;
1484 NYD_ENTER;
1485
1486 col = strlen(str);
1487 if (col) {
1488 fwrite(str, sizeof *str, col, fo);
1489 #undef _X
1490 #define _X(S) (col == sizeof(S) -1 && !asccasecmp(str, S))
1491 if (ff & GFILES) {
1492 ;
1493 } else if (_X("reply-to:") || _X("mail-followup-to:") ||
1494 _X("references:") || _X("disposition-notification-to:"))
1495 m |= m_NOPF | m_NONAME;
1496 else if (ok_blook(add_file_recipients)) {
1497 ;
1498 } else if (_X("to:") || _X("cc:") || _X("bcc:") || _X("resent-to:"))
1499 m |= m_NOPF;
1500 #undef _X
1501 }
1502
1503 for (; np != NULL; np = np->n_flink) {
1504 if (is_addr_invalid(np,
1505 EACM_NOLOG | (m & m_NONAME ? EACM_NONAME : EACM_NONE)))
1506 continue;
1507 /* File and pipe addresses only printed with set *add-file-recipients* */
1508 if ((m & m_NOPF) && is_fileorpipe_addr(np))
1509 continue;
1510
1511 if ((m & (m_INIT | m_COMMA)) == (m_INIT | m_COMMA)) {
1512 if (putc(',', fo) == EOF)
1513 goto jleave;
1514 m |= m_CSEEN;
1515 ++col;
1516 }
1517
1518 len = strlen(np->n_fullname);
1519 if (np->n_flags & GREF)
1520 len += 2;
1521 ++col; /* The separating space */
1522 if ((m & m_INIT) && /*col > 1 &&*/ UICMP(z, col + len, >, 72)) {
1523 if (fputs("\n ", fo) == EOF)
1524 goto jleave;
1525 col = 1;
1526 m &= ~m_CSEEN;
1527 } else
1528 putc(' ', fo);
1529 m = (m & ~m_CSEEN) | m_INIT;
1530
1531 {
1532 char *hb = np->n_fullname;
1533 /* GREF needs to be placed in angle brackets, but which are missing */
1534 if (np->n_type & GREF) {
1535 hb = ac_alloc(len + 2 +1);
1536 hb[0] = '<';
1537 hb[len + 1] = '>';
1538 hb[len + 2] = '\0';
1539 memcpy(hb + 1, np->n_fullname, len);
1540 len += 2;
1541 }
1542 len = xmime_write(hb, len, fo,
1543 ((ff & FMT_DOMIME) ? CONV_TOHDR_A : CONV_NONE), TD_ICONV);
1544 if (np->n_type & GREF)
1545 ac_free(hb);
1546 }
1547 if (len < 0)
1548 goto jleave;
1549 col += len;
1550 }
1551
1552 if (putc('\n', fo) != EOF)
1553 rv = 0;
1554 jleave:
1555 NYD_LEAVE;
1556 return rv;
1557 }
1558
1559 static int
1560 infix_resend(FILE *fi, FILE *fo, struct message *mp, struct name *to,
1561 int add_resent)
1562 {
1563 size_t cnt, c, bufsize = 0;
1564 char *buf = NULL;
1565 char const *cp;
1566 struct name *fromfield = NULL, *senderfield = NULL, *mdn;
1567 int rv = 1;
1568 NYD_ENTER;
1569
1570 cnt = mp->m_size;
1571
1572 /* Write the Resent-Fields */
1573 if (add_resent) {
1574 fputs("Resent-", fo);
1575 mkdate(fo, "Date");
1576 if ((cp = myaddrs(NULL)) != NULL) {
1577 if (_putname(cp, GCOMMA, SEND_MBOX, NULL, "Resent-From:", fo,
1578 &fromfield, 0))
1579 goto jleave;
1580 }
1581 /* TODO RFC 5322: Resent-Sender SHOULD NOT be used if it's EQ -From: */
1582 if ((cp = ok_vlook(sender)) != NULL) {
1583 if (_putname(cp, GCOMMA, SEND_MBOX, NULL, "Resent-Sender:", fo,
1584 &senderfield, 0))
1585 goto jleave;
1586 }
1587 if (fmt("Resent-To:", to, fo, FMT_COMMA))
1588 goto jleave;
1589 if (((cp = ok_vlook(stealthmua)) == NULL || !strcmp(cp, "noagent")) &&
1590 (cp = _message_id(NULL)) != NULL)
1591 fprintf(fo, "Resent-%s\n", cp);
1592 }
1593
1594 if ((mdn = n_UNCONST(check_from_and_sender(fromfield, senderfield))) == NULL)
1595 goto jleave;
1596 if (!_check_dispo_notif(mdn, NULL, fo))
1597 goto jleave;
1598
1599 /* Write the original headers */
1600 while (cnt > 0) {
1601 if (fgetline(&buf, &bufsize, &cnt, &c, fi, 0) == NULL)
1602 break;
1603 if (ascncasecmp("status:", buf, 7) &&
1604 ascncasecmp("disposition-notification-to:", buf, 28) &&
1605 !is_head(buf, c, FAL0))
1606 fwrite(buf, sizeof *buf, c, fo);
1607 if (cnt > 0 && *buf == '\n')
1608 break;
1609 }
1610
1611 /* Write the message body */
1612 while (cnt > 0) {
1613 if (fgetline(&buf, &bufsize, &cnt, &c, fi, 0) == NULL)
1614 break;
1615 if (cnt == 0 && *buf == '\n')
1616 break;
1617 fwrite(buf, sizeof *buf, c, fo);
1618 }
1619 if (buf != NULL)
1620 free(buf);
1621 if (ferror(fo)) {
1622 n_perr(_("temporary mail file"), 0);
1623 goto jleave;
1624 }
1625 rv = 0;
1626 jleave:
1627 NYD_LEAVE;
1628 return rv;
1629 }
1630
1631 FL int
1632 mail(struct name *to, struct name *cc, struct name *bcc, char *subject,
1633 struct attachment *attach, char *quotefile, int recipient_record)
1634 {
1635 struct header head;
1636 struct str in, out;
1637 NYD_ENTER;
1638
1639 memset(&head, 0, sizeof head);
1640
1641 /* The given subject may be in RFC1522 format. */
1642 if (subject != NULL) {
1643 in.s = subject;
1644 in.l = strlen(subject);
1645 mime_fromhdr(&in, &out, /* TODO ??? TD_ISPR |*/ TD_ICONV);
1646 head.h_subject = out.s;
1647 }
1648 head.h_to = to;
1649 head.h_cc = cc;
1650 head.h_bcc = bcc;
1651 head.h_attach = attach;
1652
1653 mail1(&head, 0, NULL, quotefile, recipient_record, 0);
1654
1655 if (subject != NULL)
1656 free(out.s);
1657 NYD_LEAVE;
1658 return 0;
1659 }
1660
1661 FL int
1662 c_sendmail(void *v)
1663 {
1664 int rv;
1665 NYD_ENTER;
1666
1667 rv = sendmail_internal(v, 0);
1668 NYD_LEAVE;
1669 return rv;
1670 }
1671
1672 FL int
1673 c_Sendmail(void *v)
1674 {
1675 int rv;
1676 NYD_ENTER;
1677
1678 rv = sendmail_internal(v, 1);
1679 NYD_LEAVE;
1680 return rv;
1681 }
1682
1683 FL enum okay
1684 mail1(struct header *hp, int printheaders, struct message *quote,
1685 char *quotefile, int recipient_record, int doprefix)
1686 {
1687 struct sendbundle sb;
1688 struct name *to;
1689 FILE *mtf, *nmtf;
1690 bool_t dosign;
1691 enum okay rv = STOP;
1692 NYD_ENTER;
1693
1694 _sendout_error = FAL0;
1695 __sendout_ident = NULL;
1696
1697 /* Update some globals we likely need first */
1698 time_current_update(&time_current, TRU1);
1699
1700 /* Collect user's mail from standard input. Get the result as mtf */
1701 mtf = collect(hp, printheaders, quote, quotefile, doprefix, &_sendout_error);
1702 if (mtf == NULL)
1703 goto j_leave;
1704
1705 dosign = TRUM1;
1706
1707 /* */
1708 if (options & OPT_INTERACTIVE) {
1709 if (ok_blook(asksign))
1710 dosign = getapproval(_("Sign this message"), TRU1);
1711 }
1712
1713 if (fsize(mtf) == 0) {
1714 if (options & OPT_E_FLAG)
1715 goto jleave;
1716 if (hp->h_subject == NULL)
1717 printf(_("No message, no subject; hope that's ok\n"));
1718 else if (ok_blook(bsdcompat) || ok_blook(bsdmsgs))
1719 printf(_("Null message body; hope that's ok\n"));
1720 }
1721
1722 if (dosign == TRUM1)
1723 dosign = ok_blook(smime_sign); /* TODO USER@HOST <-> *from* +++!!! */
1724 #ifndef HAVE_SSL
1725 if (dosign) {
1726 n_err(_("No SSL support compiled in\n"));
1727 goto jleave;
1728 }
1729 #endif
1730
1731 /* XXX Update time_current again; once collect() offers editing of more
1732 * XXX headers, including Date:, this must only happen if Date: is the
1733 * XXX same that it was before collect() (e.g., postponing etc.).
1734 * XXX But *do* update otherwise because the mail seems to be backdated
1735 * XXX if the user edited some time, which looks odd and it happened
1736 * XXX to me that i got mis-dated response mails due to that... */
1737 time_current_update(&time_current, TRU1);
1738
1739 /* TODO hrmpf; the MIME/send layer rewrite MUST address the init crap:
1740 * TODO setup the header ONCE; note this affects edit.c, collect.c ...,
1741 * TODO but: offer a hook that rebuilds/expands/checks/fixates all
1742 * TODO header fields ONCE, call that ONCE after user editing etc. has
1743 * TODO completed (one edit cycle) */
1744
1745 /* Take the user names from the combined to and cc lists and do all the
1746 * alias processing. The POSIX standard says:
1747 * The names shall be substituted when alias is used as a recipient
1748 * address specified by the user in an outgoing message (that is,
1749 * other recipients addressed indirectly through the reply command
1750 * shall not be substituted in this manner).
1751 * S-nail thus violates POSIX, as has been pointed out correctly by
1752 * Martin Neitzel, but logic and usability of POSIX standards is not seldom
1753 * disputable anyway. Go for user friendliness */
1754
1755 to = namelist_vaporise_head(hp,
1756 (EACM_NORMAL |
1757 (!(expandaddr_to_eaf() & EAF_NAME) ? EACM_NONAME : EACM_NONE)),
1758 TRU1, &_sendout_error);
1759 if (to == NULL) {
1760 n_err(_("No recipients specified\n"));
1761 goto jfail_dead;
1762 }
1763 if (_sendout_error < 0) {
1764 n_err(_("Some addressees were classified as \"hard error\"\n"));
1765 goto jfail_dead;
1766 }
1767
1768 /* */
1769 memset(&sb, 0, sizeof sb);
1770 sb.sb_hp = hp;
1771 sb.sb_to = to;
1772 sb.sb_input = mtf;
1773 if ((dosign || count_nonlocal(to) > 0) &&
1774 !_sendbundle_setup_creds(&sb, (dosign > 0)))
1775 /* TODO saving $DEAD and recovering etc is not yet well defined */
1776 goto jfail_dead;
1777
1778 /* 'Bit ugly kind of control flow until we find a charset that does it */
1779 for (charset_iter_reset(hp->h_charset);; charset_iter_next()) {
1780 int err;
1781
1782 if (!charset_iter_is_valid())
1783 ;
1784 else if ((nmtf = infix(hp, mtf)) != NULL)
1785 break;
1786 else if ((err = errno) == EILSEQ || err == EINVAL) {
1787 rewind(mtf);
1788 continue;
1789 }
1790
1791 n_perr(_("Failed to create encoded message"), 0);
1792 goto jfail_dead;
1793 }
1794 mtf = nmtf;
1795
1796 /* */
1797 #ifdef HAVE_SSL
1798 if (dosign) {
1799 if ((nmtf = smime_sign(mtf, sb.sb_signer.s)) == NULL)
1800 goto jfail_dead;
1801 Fclose(mtf);
1802 mtf = nmtf;
1803 }
1804 #endif
1805
1806 /* TODO truly - i still don't get what follows: (1) we deliver file
1807 * TODO and pipe addressees, (2) we mightrecord() and (3) we transfer
1808 * TODO even if (1) savedeadletter() etc. To me this doesn't make sense? */
1809
1810 /* Deliver pipe and file addressees */
1811 to = _outof(to, mtf, &_sendout_error);
1812 if (_sendout_error)
1813 savedeadletter(mtf, FAL0);
1814
1815 to = elide(to); /* XXX needed only to drop GDELs due to _outof()! */
1816
1817 { ui32_t cnt = count(to);
1818 if ((!recipient_record || cnt > 0) &&
1819 !mightrecord(mtf, (recipient_record ? to : NULL), FAL0))
1820 goto jleave;
1821 if (cnt > 0) {
1822 sb.sb_hp = hp;
1823 sb.sb_to = to;
1824 sb.sb_input = mtf;
1825 if (_transfer(&sb))
1826 rv = OKAY;
1827 } else if (!_sendout_error)
1828 rv = OKAY;
1829 }
1830 jleave:
1831 Fclose(mtf);
1832 j_leave:
1833 if (_sendout_error)
1834 exit_status |= EXIT_SEND_ERROR;
1835 NYD_LEAVE;
1836 return rv;
1837
1838 jfail_dead:
1839 _sendout_error = TRU1;
1840 savedeadletter(mtf, TRU1);
1841 n_err(_("... message not sent\n"));
1842 goto jleave;
1843 }
1844
1845 FL int
1846 mkdate(FILE *fo, char const *field)
1847 {
1848 struct tm tmpgm, *tmptr;
1849 int tzdiff, tzdiff_hour, tzdiff_min, rv;
1850 NYD_ENTER;
1851
1852 memcpy(&tmpgm, &time_current.tc_gm, sizeof tmpgm);
1853 tzdiff = time_current.tc_time - mktime(&tmpgm);
1854 tzdiff_hour = (int)(tzdiff / 60);
1855 tzdiff_min = tzdiff_hour % 60;
1856 tzdiff_hour /= 60;
1857 tmptr = &time_current.tc_local;
1858 if (tmptr->tm_isdst > 0)
1859 ++tzdiff_hour;
1860 rv = fprintf(fo, "%s: %s, %02d %s %04d %02d:%02d:%02d %+05d\n",
1861 field,
1862 weekday_names[tmptr->tm_wday],
1863 tmptr->tm_mday, month_names[tmptr->tm_mon],
1864 tmptr->tm_year + 1900, tmptr->tm_hour,
1865 tmptr->tm_min, tmptr->tm_sec,
1866 tzdiff_hour * 100 + tzdiff_min);
1867 NYD_LEAVE;
1868 return rv;
1869 }
1870
1871 FL int
1872 puthead(bool_t nosend_msg, struct header *hp, FILE *fo, enum gfield w,
1873 enum sendaction action, enum conversion convert, char const *contenttype,
1874 char const *charset)
1875 {
1876 #define FMT_CC_AND_BCC() \
1877 do {\
1878 if ((w & GCC) && (hp->h_cc != NULL || nosend_msg == TRUM1)) {\
1879 if (fmt("Cc:", hp->h_cc, fo, ff))\
1880 goto jleave;\
1881 ++gotcha;\
1882 }\
1883 if ((w & GBCC) && (hp->h_bcc != NULL || nosend_msg == TRUM1)) {\
1884 if (fmt("Bcc:", hp->h_bcc, fo, ff))\
1885 goto jleave;\
1886 ++gotcha;\
1887 }\
1888 } while (0)
1889
1890 char const *addr;
1891 size_t gotcha;
1892 struct name *np, *fromasender = NULL;
1893 int stealthmua, rv = 1;
1894 bool_t nodisp;
1895 enum fmt_flags ff;
1896 NYD_ENTER;
1897
1898 if ((addr = ok_vlook(stealthmua)) != NULL)
1899 stealthmua = !strcmp(addr, "noagent") ? -1 : 1;
1900 else
1901 stealthmua = 0;
1902 gotcha = 0;
1903 nodisp = (action != SEND_TODISP);
1904 ff = (w & (GCOMMA | GFILES)) | (nodisp ? FMT_DOMIME : 0);
1905
1906 if (w & GDATE)
1907 mkdate(fo, "Date"), ++gotcha;
1908 if (w & GIDENT) {
1909 if (hp->h_from == NULL || hp->h_sender == NULL)
1910 setup_from_and_sender(hp);
1911
1912 if (hp->h_from != NULL) {
1913 if (fmt("From:", hp->h_from, fo, ff))
1914 goto jleave;
1915 ++gotcha;
1916 }
1917
1918 if (hp->h_sender != NULL) {
1919 if (fmt("Sender:", hp->h_sender, fo, ff))
1920 goto jleave;
1921 ++gotcha;
1922 }
1923
1924 fromasender = n_UNCONST(check_from_and_sender(hp->h_from, hp->h_sender));
1925 if (fromasender == NULL)
1926 goto jleave;
1927 /* Note that fromasender is (NULL,) 0x1 or real sender here */
1928 }
1929
1930 #if 1
1931 if ((w & GTO) && (hp->h_to != NULL || nosend_msg == TRUM1)) {
1932 if (fmt("To:", hp->h_to, fo, ff))
1933 goto jleave;
1934 ++gotcha;
1935 }
1936 #else
1937 /* TODO Thought about undisclosed recipients:;, but would be such a fake
1938 * TODO given that we cannot handle group addresses. Ridiculous */
1939 if (w & GTO) {
1940 struct name *xto;
1941
1942 if ((xto = hp->h_to) != NULL) {
1943 char const ud[] = "To: Undisclosed recipients:;\n" /* TODO groups */;
1944
1945 if (count_nonlocal(xto) != 0 || ok_blook(add_file_recipients) ||
1946 (hp->h_cc != NULL && count_nonlocal(hp->h_cc) > 0))
1947 goto jto_fmt;
1948 if (fwrite(ud, 1, sizeof(ud) -1, fo) != sizeof(ud) -1)
1949 goto jleave;
1950 ++gotcha;
1951 } else if (nosend_msg == TRUM1) {
1952 jto_fmt:
1953 if (fmt("To:", hp->h_to, fo, ff))
1954 goto jleave;
1955 ++gotcha;
1956 }
1957 }
1958 #endif
1959
1960 if (!ok_blook(bsdcompat) && !ok_blook(bsdorder))
1961 FMT_CC_AND_BCC();
1962
1963 if ((w & GSUBJECT) && (hp->h_subject != NULL || nosend_msg == TRUM1)) {
1964 if (fwrite("Subject: ", sizeof(char), 9, fo) != 9)
1965 goto jleave;
1966 if (hp->h_subject != NULL) {
1967 char *sub = subject_re_trim(hp->h_subject);
1968 size_t sublen = strlen(sub);
1969
1970 /* Trimmed something, (re-)add Re: */
1971 if (sub != hp->h_subject) {
1972 if (fwrite("Re: ", 1, 4, fo) != 4) /* RFC mandates eng. "Re: " */
1973 goto jleave;
1974 if (sublen > 0 &&
1975 xmime_write(sub, sublen, fo,
1976 (!nodisp ? CONV_NONE : CONV_TOHDR),
1977 (!nodisp ? TD_ISPR | TD_ICONV : TD_ICONV)) < 0)
1978 goto jleave;
1979 }
1980 /* This may be, e.g., a Fwd: XXX yes, unfortunately we do like that */
1981 else if (*sub != '\0') {
1982 if (xmime_write(sub, sublen, fo, (!nodisp ? CONV_NONE : CONV_TOHDR),
1983 (!nodisp ? TD_ISPR | TD_ICONV : TD_ICONV)) < 0)
1984 goto jleave;
1985 }
1986 }
1987 ++gotcha;
1988 putc('\n', fo);
1989 }
1990
1991 if (ok_blook(bsdcompat) || ok_blook(bsdorder))
1992 FMT_CC_AND_BCC();
1993
1994 if ((w & GMSGID) && stealthmua <= 0 && (addr = _message_id(hp)) != NULL) {
1995 if (fputs(addr, fo) == EOF || putc('\n', fo) == EOF)
1996 goto jleave;
1997 ++gotcha;
1998 }
1999
2000 if ((np = hp->h_ref) != NULL && (w & GREF)) {
2001 if (fmt("References:", np, fo, 0))
2002 goto jleave;
2003 if (hp->h_in_reply_to == NULL && np->n_name != NULL) {
2004 while (np->n_flink != NULL)
2005 np = np->n_flink;
2006 if (!is_addr_invalid(np, /* TODO check that on parser side! */
2007 /*EACM_STRICT | TODO '/' valid!! */ EACM_NOLOG | EACM_NONAME)) {
2008 if (fprintf(fo,
2009 "In-Reply-To: <%s>\n", np->n_name /*TODO RFC5322 3.6.4*/) < 0)
2010 goto jleave;
2011 ++gotcha;
2012 } else {
2013 n_err(_("Invalid address in mail header: %s\n"), np->n_name);
2014 goto jleave;
2015 }
2016 }
2017 }
2018 if ((np = hp->h_in_reply_to) != NULL && (w & GREF)) {
2019 if (fprintf(fo,
2020 "In-Reply-To: <%s>\n", np->n_name /*TODO RFC 5322 3.6.4*/) < 0)
2021 goto jleave;
2022 ++gotcha;
2023 }
2024
2025 if (w & GIDENT) {
2026 /* Reply-To:. Be careful not to destroy a possible user input, duplicate
2027 * the list first.. TODO it is a terrible codebase.. */
2028 if ((np = hp->h_replyto) != NULL)
2029 np = namelist_dup(np, np->n_type);
2030 else if ((addr = ok_vlook(replyto)) != NULL)
2031 np = lextract(addr, GEXTRA | GFULL);
2032 if (np != NULL &&
2033 (np = elide(
2034 checkaddrs(usermap(np, TRU1), EACM_STRICT | EACM_NOLOG,
2035 NULL))) != NULL) {
2036 if (fmt("Reply-To:", np, fo, ff))
2037 goto jleave;
2038 ++gotcha;
2039 }
2040 }
2041
2042 if ((w & GIDENT) && !nosend_msg) {
2043 /* Mail-Followup-To: TODO factor out this huge block of code */
2044 /* Place ourselfs in there if any non-subscribed list is an addressee */
2045 if ((hp->h_flags & HF_LIST_REPLY) || hp->h_mft != NULL ||
2046 ok_blook(followup_to)) {
2047 enum {_ANYLIST=1<<(HF__NEXT_SHIFT+0), _HADMFT=1<<(HF__NEXT_SHIFT+1)};
2048
2049 ui32_t f = hp->h_flags | (hp->h_mft != NULL ? _HADMFT : 0);
2050 struct name *mft, *x;
2051
2052 /* But for that, we have to remove all incarnations of ourselfs first.
2053 * TODO It is total crap that we have delete_alternates(), is_myname()
2054 * TODO or whatever; these work only with variables, not with data
2055 * TODO that is _currently_ in some header fields!!! v15.0: complete
2056 * TODO rewrite, object based, lazy evaluated, on-the-fly marked.
2057 * TODO then this should be a really cheap thing in here... */
2058 np = elide(delete_alternates(cat(
2059 namelist_dup(hp->h_to, GEXTRA | GFULL),
2060 namelist_dup(hp->h_cc, GEXTRA | GFULL))));
2061 addr = hp->h_list_post;
2062
2063 for (mft = NULL; (x = np) != NULL;) {
2064 si8_t ml;
2065 np = np->n_flink;
2066
2067 if ((ml = is_mlist(x->n_name, FAL0)) == MLIST_OTHER &&
2068 addr != NULL && !asccasecmp(addr, x->n_name))
2069 ml = MLIST_KNOWN;
2070
2071 /* Any non-subscribed list? Add ourselves */
2072 switch (ml) {
2073 case MLIST_KNOWN:
2074 f |= HF_MFT_SENDER;
2075 /* FALLTHRU */
2076 case MLIST_SUBSCRIBED:
2077 f |= _ANYLIST;
2078 goto j_mft_add;
2079 case MLIST_OTHER:
2080 if (!(f & HF_LIST_REPLY)) {
2081 j_mft_add:
2082 if (!is_addr_invalid(x,
2083 EACM_STRICT | EACM_NOLOG | EACM_NONAME)) {
2084 x->n_flink = mft;
2085 mft = x;
2086 } /* XXX write some warning? if verbose?? */
2087 continue;
2088 }
2089 /* And if this is a reply that honoured a MFT: header then we'll
2090 * also add all members of the original MFT: that are still
2091 * addressed by us, regardless of all other circumstances */
2092 else if (f & _HADMFT) {
2093 struct name *ox;
2094 for (ox = hp->h_mft; ox != NULL; ox = ox->n_flink)
2095 if (!asccasecmp(ox->n_name, x->n_name))
2096 goto j_mft_add;
2097 }
2098 break;
2099 }
2100 }
2101
2102 if (f & (_ANYLIST | _HADMFT) && mft != NULL) {
2103 if (((f & HF_MFT_SENDER) ||
2104 ((f & (_ANYLIST | _HADMFT)) == _HADMFT)) &&
2105 (np = fromasender) != NULL && np != (struct name*)0x1) {
2106 np = ndup(np, (np->n_type & ~GMASK) | GEXTRA | GFULL);
2107 np->n_flink = mft;
2108 mft = np;
2109 }
2110
2111 if (fmt("Mail-Followup-To:", mft, fo, ff))
2112 goto jleave;
2113 ++gotcha;
2114 }
2115 }
2116
2117 if (!_check_dispo_notif(fromasender, hp, fo))
2118 goto jleave;
2119 }
2120
2121 if ((w & GUA) && stealthmua == 0) {
2122 if (fprintf(fo, "User-Agent: %s %s\n", uagent, ok_vlook(version)) < 0)
2123 goto jleave;
2124 ++gotcha;
2125 }
2126
2127 /* The user may have placed headers when editing */
2128 if(1){
2129 struct n_header_field *hfp;
2130
2131 if((hfp = hp->h_user_headers) != NULL){
2132 if(!_sendout_header_list(fo, hfp, nodisp))
2133 goto jleave;
2134 ++gotcha;
2135 }
2136 }
2137
2138 /* Custom headers, as via *customhdr* */
2139 if(!nosend_msg){
2140 struct n_header_field *hfp;
2141
2142 /* With iconv support we likely have a cached result */
2143 if((hfp = hp->h_custom_headers) == NULL)
2144 hp->h_custom_headers = hfp = n_customhdr_query();
2145 if(hfp != NULL){
2146 if(!_sendout_header_list(fo, hfp, nodisp))
2147 goto jleave;
2148 ++gotcha;
2149 }
2150 }
2151
2152 /* We don't need MIME unless.. we need MIME?! */
2153 if ((w & GMIME) && ((pstate & PS_HEADER_NEEDED_MIME) ||
2154 hp->h_attach != NULL ||
2155 ((options & OPT_Mm_FLAG) && option_Mm_arg != NULL) ||
2156 convert != CONV_7BIT || asccasecmp(charset, "US-ASCII"))) {
2157 ++gotcha;
2158 if (fputs("MIME-Version: 1.0\n", fo) == EOF)
2159 goto jleave;
2160 if (hp->h_attach != NULL) {
2161 _sendout_boundary = mime_param_boundary_create();/*TODO carrier*/
2162 if (fprintf(fo,
2163 "Content-Type: multipart/mixed;\n boundary=\"%s\"\n",
2164 _sendout_boundary) < 0)
2165 goto jleave;
2166 } else {
2167 if (_put_ct(fo, contenttype, charset) < 0 || _put_cte(fo, convert) < 0)
2168 goto jleave;
2169 }
2170 }
2171
2172 if (gotcha && (w & GNL))
2173 if (putc('\n', fo) == EOF)
2174 goto jleave;
2175 rv = 0;
2176 jleave:
2177 NYD_LEAVE;
2178 return rv;
2179 #undef FMT_CC_AND_BCC
2180 }
2181
2182 FL enum okay
2183 resend_msg(struct message *mp, struct name *to, int add_resent) /* TODO check */
2184 {
2185 struct sendbundle sb;
2186 FILE *ibuf, *nfo, *nfi;
2187 char *tempMail;
2188 enum okay rv = STOP;
2189 NYD_ENTER;
2190
2191 _sendout_error = FAL0;
2192 __sendout_ident = NULL;
2193
2194 /* Update some globals we likely need first */
2195 time_current_update(&time_current, TRU1);
2196
2197 if ((to = checkaddrs(to,
2198 (EACM_NORMAL |
2199 (!(expandaddr_to_eaf() & EAF_NAME) ? EACM_NONAME : EACM_NONE)),
2200 &_sendout_error)) == NULL)
2201 goto jleave;
2202 /* For the _sendout_error<0 case we want to wait until we can write DEAD! */
2203 if (_sendout_error < 0)
2204 n_err(_("Some addressees were classified as \"hard error\"\n"));
2205
2206 if ((nfo = Ftmp(&tempMail, "resend", OF_WRONLY | OF_HOLDSIGS | OF_REGISTER))
2207 == NULL) {
2208 _sendout_error = TRU1;
2209 n_perr(_("temporary mail file"), 0);
2210 goto jleave;
2211 }
2212 if ((nfi = Fopen(tempMail, "r")) == NULL)
2213 n_perr(tempMail, 0);
2214 Ftmp_release(&tempMail);
2215 if (nfi == NULL)
2216 goto jerr_o;
2217
2218 if ((ibuf = setinput(&mb, mp, NEED_BODY)) == NULL)
2219 goto jerr_io;
2220
2221 memset(&sb, 0, sizeof sb);
2222 sb.sb_to = to;
2223 sb.sb_input = nfi;
2224 if (count_nonlocal(to) > 0 && !_sendbundle_setup_creds(&sb, FAL0))
2225 /* ..wait until we can write DEAD */
2226 _sendout_error = -1;
2227
2228 if (infix_resend(ibuf, nfo, mp, to, add_resent) != 0) {
2229 jfail_dead:
2230 savedeadletter(nfi, TRU1);
2231 n_err(_("... message not sent\n"));
2232 jerr_io:
2233 Fclose(nfi);
2234 jerr_o:
2235 Fclose(nfo);
2236 _sendout_error = TRU1;
2237 goto jleave;
2238 }
2239
2240 if (_sendout_error < 0)
2241 goto jfail_dead;
2242
2243 Fclose(nfo);
2244 rewind(nfi);
2245
2246 to = _outof(to, nfi, &_sendout_error);
2247
2248 if (_sendout_error)
2249 savedeadletter(nfi, FAL0);
2250
2251 if (count(to = elide(to)) != 0) {
2252 if (!ok_blook(record_resent) || mightrecord(nfi, NULL, TRU1)) {
2253 sb.sb_to = to;
2254 /*sb.sb_input = nfi;*/
2255 if (_transfer(&sb))
2256 rv = OKAY;
2257 }
2258 } else if (!_sendout_error)
2259 rv = OKAY;
2260
2261 Fclose(nfi);
2262 jleave:
2263 if (_sendout_error)
2264 exit_status |= EXIT_SEND_ERROR;
2265 NYD_LEAVE;
2266 return rv;
2267 }
2268
2269 FL void
2270 savedeadletter(FILE *fp, bool_t fflush_rewind_first){
2271 struct n_string line;
2272 int c;
2273 enum {a_NONE, a_INIT = 1<<0, a_BODY = 1<<1, a_NL = 1<<2} flags;
2274 ul_i bytes, lines;
2275 FILE *dbuf;
2276 char const *cp, *cpq;
2277 NYD_ENTER;
2278
2279 if(!ok_blook(save))
2280 goto jleave;
2281
2282 if(fflush_rewind_first){
2283 fflush(fp);
2284 rewind(fp);
2285 }
2286 if(fsize(fp) == 0)
2287 goto jleave;
2288
2289 cp = n_getdeadletter();
2290 cpq = n_shexp_quote_cp(cp, FAL0);
2291
2292 if(options & OPT_DEBUG){
2293 n_err(_(">>> Would (try to) write $DEAD %s\n"), cpq);
2294 goto jleave;
2295 }
2296
2297 if((dbuf = Fopen(cp, "w")) == NULL){
2298 n_perr(_("Cannot save to $DEAD"), 0);
2299 goto jleave;
2300 }
2301 n_file_lock(fileno(dbuf), FLT_WRITE, 0,0, UIZ_MAX); /* XXX Natomic */
2302
2303 printf("%s ", cpq);
2304 fflush(stdout);
2305
2306 /* TODO savedeadletter() non-conforming: should check whether we have any
2307 * TODO headers, if not we need to place "something", anything will do.
2308 * TODO MIME is completely missing, we use MBOXO quoting!! Yuck.
2309 * TODO I/O error handling missing. Yuck! */
2310 n_string_reserve(n_string_creat_auto(&line), 2 * SEND_LINESIZE);
2311 bytes = (ul_i)fprintf(dbuf, "From %s %s", myname, time_current.tc_ctime);
2312 lines = 1;
2313 for(flags = a_NONE, c = '\0'; c != EOF; bytes += line.s_len, ++lines){
2314 n_string_trunc(&line, 0);
2315 while((c = getc(fp)) != EOF && c != '\n')
2316 n_string_push_c(&line, c);
2317
2318 /* TODO It may be that we have only some plain text. It may be that we
2319 * TODO have a complete MIME encoded message. We don't know, and we
2320 * TODO have no usable mechanism to dig it!! tWe need v15! */
2321 if(!(flags & a_INIT)){
2322 size_t i;
2323
2324 /* Throw away leading empty lines! */
2325 if(line.s_len == 0)
2326 continue;
2327 for(i = 0; i < line.s_len; ++i){
2328 if(fieldnamechar(line.s_dat[i]))
2329 continue;
2330 if(line.s_dat[i] == ':'){
2331 flags |= a_INIT;
2332 break;
2333 }else{
2334 /* We have no headers, this is already a body line! */
2335 flags |= a_INIT | a_BODY;
2336 break;
2337 }
2338 }
2339 /* Well, i had to check whether the RFC allows this. Assume we've
2340 * passed the headers, too, then! */
2341 if(i == line.s_len)
2342 flags |= a_INIT | a_BODY;
2343 }
2344 if(flags & a_BODY){
2345 if(line.s_len >= 5 && !memcmp(line.s_dat, "From ", 5))
2346 n_string_unshift_c(&line, '>');
2347 }
2348 if(line.s_len == 0)
2349 flags |= a_BODY | a_NL;
2350 else
2351 flags &= ~a_NL;
2352
2353 n_string_push_c(&line, '\n');
2354 fwrite(line.s_dat, sizeof *line.s_dat, line.s_len, dbuf);
2355 }
2356 if(!(flags & a_NL)){
2357 putc('\n', dbuf);
2358 ++bytes;
2359 ++lines;
2360 }
2361 n_string_gut(&line);
2362
2363 Fclose(dbuf);
2364 printf("%lu/%lu\n", lines, bytes);
2365 fflush(stdout);
2366
2367 rewind(fp);
2368 jleave:
2369 NYD_LEAVE;
2370 }
2371
2372 #undef SEND_LINESIZE
2373
2374 /* s-it-mode */
A mail processing system intended to provide the functionality of the POSIX mailx(1) command