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