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