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