Mercurial > notdcc

comparison dccifd/dccifd.c @ 0:c7f6b056b673

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
First import of vendor version
author Peter Gervai <grin@grin.hu>
date Tue, 10 Mar 2009 13:49:58 +0100
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:c7f6b056b673
1 /* Distributed Checksum Clearinghouse
2 *
3 * DCC interface daemon
4 *
5 * Copyright (c) 2008 by Rhyolite Software, LLC
6 *
7 * This agreement is not applicable to any entity which sells anti-spam
8 * solutions to others or provides an anti-spam solution as part of a
9 * security solution sold to other entities, or to a private network
10 * which employs the DCC or uses data provided by operation of the DCC
11 * but does not provide corresponding data to other users.
12 *
13 * Permission to use, copy, modify, and distribute this software without
14 * changes for any purpose with or without fee is hereby granted, provided
15 * that the above copyright notice and this permission notice appear in all
16 * copies and any distributed versions or copies are either unchanged
17 * or not called anything similar to "DCC" or "Distributed Checksum
18 * Clearinghouse".
19 *
20 * Parties not eligible to receive a license under this agreement can
21 * obtain a commercial license to use DCC by contacting Rhyolite Software
22 * at sales@rhyolite.com.
23 *
24 * A commercial license would be for Distributed Checksum and Reputation
25 * Clearinghouse software. That software includes additional features. This
26 * free license for Distributed ChecksumClearinghouse Software does not in any
27 * way grant permision to use Distributed Checksum and Reputation Clearinghouse
28 * software
29 *
30 * THE SOFTWARE IS PROVIDED "AS IS" AND RHYOLITE SOFTWARE, LLC DISCLAIMS ALL
31 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
32 * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL RHYOLITE SOFTWARE, LLC
33 * BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES
34 * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
35 * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
36 * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
37 * SOFTWARE.
38 *
39 * Rhyolite Software DCC 1.3.103-1.166 $Revision$
40 */
41
42 #include "dccif.h"
43 #include "dcc_paths.h"
44 #include "cmn_defs.h"
45 #include <signal.h>
46
47
48 static int stopping;
49
50 #define MAX_SMTP_LINE
51
52 u_char use_ipv6 = 0;
53
54 /* incoming proxy and bidirectional ASCII dccifd protocol connection */
55 static char *listen_addr;
56 static u_char listen_family;
57 static struct sockaddr_un listen_sun;
58
59 static const char *lhost_port;
60 static const char *rcidr;
61 static struct in6_addr raddr, rmask;
62 static SOCKET listen_soc = -1;
63
64 /* outgoing proxy connection */
65 static u_char proxy_out_family;
66 static struct sockaddr_un proxy_out_sun;
67 static char proxy_out_host[DCC_MAXDOMAINLEN];
68 static u_int16_t proxy_out_port;
69 static DCC_SOCKU proxy_out_su;
70
71 static const char *rundir = DCC_RUNDIR;
72 static DCC_PATH pidpath;
73 static const char *progpath = DCC_LIBEXECDIR"/dccifd";
74
75 static u_char background = 1;
76
77 static u_char proxy;
78
79 u_char cannot_discard = 0; /* can trim targets after DATA */
80 u_char cannot_reject = 1; /* ASCII protocol accepts all targets */
81
82
83 /* message state or context */
84 typedef struct { /* control an input buffer */
85 char *base;
86 char *in;
87 char *out;
88 char *next_line;
89 int size;
90 int line_len;
91 int *socp;
92 } IN_BC;
93 typedef struct { /* control an ouput buffer */
94 char *base;
95 char *in;
96 int len;
97 int size;
98 int *socp;
99 } OUT_BC;
100 typedef struct work {
101 int proxy_in_soc;
102 DCC_SOCKU proxy_in_su;
103 int proxy_out_soc;
104 char buf1[DCC_HDR_CK_MAX*8]; /* >=DCC_HDR_CK_MAX*2 & MAX_RCPTS */
105 char buf2[DCC_HDR_CK_MAX*8];
106 char buf3[1024];
107 char buf4[1024];
108 CMN_WORK cw;
109 enum {
110 SMTP_ST_START, /* expecting HELO */
111 SMTP_ST_HELO, /* seen HELO, expecting Mail_From */
112 SMTP_ST_TRANS, /* seen Mail_From */
113 SMTP_ST_RCPT, /* seen Rcpt_To */
114 SMTP_ST_ERROR /* no transaction until RSET or HELO */
115 } smtp_state;
116 /* from here down is zeroed when the structure is allocated */
117 #define WORK_ZERO fwd
118 struct work *fwd;
119 IN_BC msg_rd; /* incoming mail message */
120 OUT_BC msg_wt; /* outoing mail message */
121 IN_BC reply_in; /* incoming SMTP replies */
122 OUT_BC reply_out; /* outgoing SMTP replies */
123 int total_hdrs, cr_hdrs;
124 int parse_rcvd; /* which received: header to parse */
125 u_int dfgs;
126 # define DFG_WORK_LOCK 0x0001 /* hold the lock */
127 # define DFG_MISSING_BODY 0x0002 /* missing message body */
128 # define DFG_MTA_BODY 0x0004 /* MTA wants the body */
129 # define DFG_MTA_HEADER 0x0008 /* MTA wants the X-DCC header */
130 # define DFG_SEEN_HDR 0x0010 /* have at least 1 header */
131 # define DFG_PARSE_RCVD 0x0020 /* parse Received header */
132 # define DFG_XCLIENT_NAME 0x0040 /* client name via XCLIENT */
133 # define DFG_XCLIENT_ADDR 0x0080 /* client addresses via XCLIENT */
134 # define DFG_XCLIENT_HELO 0x0100 /* HELO value via XCLIENT */
135 # define DFG_RECYCLE (DFG_WORK_LOCK | DFG_MTA_BODY \
136 | DFG_XCLIENT_NAME | DFG_XCLIENT_ADDR \
137 | DFG_XCLIENT_HELO)
138 } WORK;
139
140 /* use a free list to avoid malloc() overhead */
141 static WORK *work_free;
142
143 /* each dccifd job involves
144 * a socket connected to the MTA or upstream proxy
145 * a socket connected to the downstream proxy if using SMTP
146 * a log file,
147 * and a socket to talk to the DCC server.
148 * The file descriptors for the whitelists are accounted for in EXTRA_FILES */
149 #define FILES_PER_JOB 4
150 int max_max_work = MAX_SELECT_WORK;
151
152
153 typedef struct user_domain {
154 struct user_domain *fwd;
155 const char *nm;
156 int len;
157 u_char wildcard;
158 } USER_DOMAIN;
159 static USER_DOMAIN *user_domains;
160 static char hostname[MAXHOSTNAMELEN+1] = "@";
161
162 /* max seconds to wait for MTA
163 * Longer than the longest timeout in RFC 2821 */
164 #define MAX_MTA_DELAY (10*60+5)
165
166
167 static void sigterm(int);
168 static u_char set_soc(DCC_EMSG, int, int, const char *);
169 static void bind_listen(void);
170 static void close_listen_soc(void);
171 static void unlink_listen_sun(void);
172 static void NRATTRIB *job_start(void *);
173 static void job_close(WORK *);
174 static void NRATTRIB job_exit(WORK *);
175 static void NRATTRIB proxy_msg_truncated(WORK *);
176 static void add_work(int);
177
178
179 static void
180 usage(const char* barg, const char *bvar)
181 {
182 const char str[] = {
183 "usage: [-VdbxANQ] [-G on | off | noIP | IPmask/xx] [-h homedir]"
184 " [-I user]\n"
185 " [-p /sock | host,port,rhost/bits]"
186 " [-o /sock | host,port]\n"
187 " [-D local-domain] [-r rejection-msg] [-m map] [-w whiteclnt]\n"
188 " [-U userdirs] [-a IGNORE | REJECT | DISCARD]\n"
189 " [-t type,[log-thold,][rej-thold]] [-g [not-]type]"
190 " [-S header]\n"
191 " [-l logdir] [-R rundir] [-T tmpdir] [-j maxjobs]\n"
192 " [-B dnsbl-option] [-L ltype,facility.level]\n"
193 };
194 static u_char complained;
195
196 if (!complained) {
197 if (barg)
198 dcc_error_msg("unrecognized \"%s%s\"\nusage: %s\n..."
199 " continuing",
200 barg, bvar, str);
201 else
202 dcc_error_msg("%s\n... continuing", str);
203 complained = 1;
204 }
205 }
206
207
208 int NRATTRIB
209 main(int argc, char **argv)
210 {
211 DCC_EMSG emsg;
212 #ifdef RLIMIT_NOFILE
213 struct rlimit nofile;
214 int old_rlim_cur;
215 #endif
216 long l;
217 u_char log_tgts_set = 0;
218 const char *homedir = 0;
219 const char *logdir = 0;
220 const char *tmpdir = 0;
221 WORK *wp;
222 pthread_t tid;
223 DCC_SOCKLEN_T namelen;
224 const char *cp;
225 USER_DOMAIN *udom, *udom2, **udomp;
226 char *p;
227 int error, i;
228
229 emsg[0] = '\0';
230 if (*argv[0] == '/')
231 progpath = argv[0];
232 dcc_syslog_init(1, argv[0], 0);
233 dcc_clear_tholds();
234
235 #ifdef RLIMIT_NOFILE
236 if (0 > getrlimit(RLIMIT_NOFILE, &nofile)) {
237 dcc_error_msg("getrlimit(RLIMIT_NOFILE): %s", ERROR_STR());
238 old_rlim_cur = 1000*1000;
239 } else {
240 old_rlim_cur = nofile.rlim_cur;
241 if (nofile.rlim_max < 1000*1000) {
242 i = nofile.rlim_max;
243 #ifndef USE_POLL
244 if (i > FD_SETSIZE)
245 i = FD_SETSIZE;
246 #endif
247 max_max_work = (i - EXTRA_FILES)/FILES_PER_JOB;
248 max_max_work_src = "RLIMIT_NOFILE limit";
249 }
250 }
251 #endif /* RLIMIT_NOFILE */
252 if (max_max_work <= 0) {
253 dcc_error_msg("too few open files allowed");
254 max_max_work = MIN_MAX_WORK;
255 }
256 max_work = max_max_work;
257
258 #define SLARGS "64VdbxANQW" /* fix start-dccifd if these change */
259 while (-1 != (i = getopt(argc, argv, SLARGS"G:h:I:p:o:D:r:m:w:U:"
260 "a:t:g:S:l:R:T:j:B:L:"))) {
261 switch (i) {
262 #ifndef NO_IPV6
263 case '6':
264 use_ipv6 = 1;
265 break;
266 #endif
267 case '4':
268 use_ipv6 = 0;
269 break;
270
271 case 'V':
272 fprintf(stderr, DCC_VERSION"\n");
273 exit(EX_OK);
274 break;
275
276 case 'd':
277 ++dcc_clnt_debug;
278 break;
279
280 case 'b':
281 background = 0;
282 break;
283
284 case 'x':
285 try_extra_hard = DCC_CLNT_FG_NO_FAIL;
286 break;
287
288 case 'A':
289 chghdr = ADDHDR;
290 break;
291
292 case 'N':
293 chghdr = NOHDR;
294 break;
295
296 case 'Q':
297 dcc_query_only = 1;
298 break;
299
300 case 'G':
301 if (!dcc_parse_client_grey(optarg))
302 usage("-G", optarg);
303 break;
304
305 case 'W': /* obsolete DCC off by default */
306 to_white_only = 1;
307 break;
308
309 case 'h':
310 homedir = optarg;
311 break;
312
313 case 'I':
314 dcc_daemon_su(optarg);
315 break;
316
317 case 'p':
318 listen_addr = optarg;
319 break;
320
321 case 'o':
322 proxy = 1;
323 cannot_reject = 0;
324 cannot_discard = 1;
325 p = strchr(optarg, ',');
326 if (!p) {
327 /* recognize single-ended (not-really-)-proxy */
328 if (!strcmp(optarg, _PATH_DEVNULL)) {
329 proxy_out_family = AF_UNSPEC;
330 break;
331 }
332 if (strlen(optarg)>=ISZ(proxy_out_sun.sun_path))
333 dcc_logbad(EX_USAGE, "invalid UNIX"
334 " domain socket: -o %s",
335 optarg);
336 strcpy(proxy_out_sun.sun_path, optarg);
337 #ifdef HAVE_SA_LEN
338 proxy_out_sun.sun_len = SUN_LEN(&proxy_out_sun);
339 #endif
340 proxy_out_sun.sun_family = AF_UNIX;
341 proxy_out_family = AF_UNIX;
342 } else {
343 cp = dcc_parse_nm_port(emsg, optarg,
344 DCC_GET_PORT_INVALID,
345 proxy_out_host,
346 sizeof(proxy_out_host),
347 &proxy_out_port, 0, 0,
348 0, 0);
349 if (!cp)
350 dcc_logbad(dcc_ex_code, "%s", emsg);
351 if (*cp != '\0')
352 dcc_logbad(EX_USAGE,
353 "invalid IP address: \"%s\"",
354 optarg);
355 proxy_out_family = AF_INET; /* includes IPv6 */
356 }
357 break;
358
359 case 'D':
360 /* save user domain names sorted by length
361 * so that we can apply the most restrictive */
362 i = strlen(optarg);
363 if (*optarg == '\0'
364 || ((optarg[0] == '@' || optarg[0] == '*')
365 && i < 2)
366 || strpbrk(optarg+1, "@*")) {
367 dcc_logbad(EX_USAGE,
368 "invalid local-domain \"%s\"",
369 optarg);
370 break;
371 }
372 udom2 = dcc_malloc(sizeof(*udom2));
373 memset(udom2, 0, sizeof(*udom2));
374 udom2->len = i;
375 udom2->nm = optarg;
376 if (optarg[0] == '*') {
377 udom2->wildcard = 1;
378 ++udom2->nm;
379 --udom2->len;
380 }
381 udomp = &user_domains;
382 for (;;) {
383 udom = *udomp;
384 /* insert longer names before shorter names
385 * insert wildcard before same, non-wildcard
386 * because i includes the '*' */
387 if (!udom || i > udom->len) {
388 udom2->fwd = udom;
389 *udomp = udom2;
390 break;
391 }
392 udomp = &udom->fwd;
393 }
394 break;
395
396 case 'r':
397 parse_reply_arg(optarg);
398 break;
399
400 case 'm':
401 mapfile_nm = optarg;
402 break;
403
404 case 'w':
405 main_white_nm = optarg;
406 break;
407
408 case 'U':
409 parse_userdirs(optarg);
410 break;
411
412 case 'a':
413 if (!strcasecmp(optarg, "IGNORE")) {
414 action = CMN_IGNORE;
415 } else if (!strcasecmp(optarg, "REJECT")) {
416 action = CMN_REJECT;
417 } else if (!strcasecmp(optarg, "DISCARD")) {
418 action = CMN_DISCARD;
419 } else {
420 dcc_error_msg("unrecognized -a action: %s",
421 optarg);
422 }
423 break;
424
425 case 't':
426 if (dcc_parse_tholds("-t ", optarg))
427 log_tgts_set = 1;
428 break;
429
430 case 'g': /* honor not-spam "counts" */
431 dcc_parse_honor(optarg);
432 break;
433
434 case 'S':
435 dcc_add_sub_hdr(0, optarg);
436 break;
437
438 case 'l': /* log rejected mail here */
439 logdir = optarg;
440 break;
441
442 case 'R':
443 rundir = optarg;
444 break;
445
446 case 'T':
447 tmpdir = optarg;
448 break;
449
450 case 'j': /* maximum simultaneous jobs */
451 l = strtoul(optarg, &p, 10);
452 if (*p != '\0' || l < MIN_MAX_WORK) {
453 dcc_error_msg("invalid queue length %s",
454 optarg);
455 } else if (l > max_max_work) {
456 dcc_error_msg("-j queue length %s"
457 " larger than %s; using %d",
458 optarg,
459 max_max_work_src, max_max_work);
460 max_work = max_max_work;
461 } else {
462 max_work = l;
463 }
464 break;
465
466 case 'B':
467 if (!dcc_parse_dnsbl(emsg, optarg, progpath, 0))
468 dcc_error_msg("%s", emsg);
469 break;
470
471 case 'L':
472 if (dcc_parse_log_opt(optarg))
473 helper_save_arg("-L", optarg);
474 break;
475
476 default:
477 usage(optopt2str(optopt), "");
478 }
479 }
480 argc -= optind;
481 argv += optind;
482 if (argc != 0)
483 usage(argv[0], "");
484
485 /* default -D setting to the local host name */
486 if (!user_domains) {
487 if (0 > gethostname(hostname+1, sizeof(hostname)-2)) {
488 dcc_error_msg("gethostname(): %s", ERROR_STR());
489 } else if ((i = strlen(hostname)) > 1) {
490 user_domains = dcc_malloc(sizeof(*user_domains));
491 memset(user_domains, 0, sizeof(*user_domains));
492 user_domains->len = i;
493 user_domains->nm = hostname;
494 }
495 }
496
497 dcc_cdhome(0, homedir, 0);
498 dcc_main_logdir_init(0, logdir);
499 tmp_path_init(tmpdir, logdir);
500
501 if (proxy_out_family == AF_INET) {
502 if (proxy_out_host[0] == '\0'
503 || !strcmp(proxy_out_host, "@")) {
504 /* null or "@" means incoming host */
505 ;
506 } else {
507 dcc_host_lock();
508 if (!dcc_get_host(proxy_out_host, use_ipv6, &error))
509 dcc_logbad(EX_NOHOST, "%s: %s",
510 proxy_out_host,
511 DCC_HSTRERROR(error));
512 proxy_out_su = dcc_hostaddrs[0];
513 *DCC_SU_PORTP(&proxy_out_su) = proxy_out_port;
514 dcc_host_unlock();
515 }
516 }
517
518 /* Open the incoming socket before our backgrounding fork() to
519 * minimize races and allow better error reporting. */
520 bind_listen();
521
522 if (dcc_main_logdir[0] == '\0') {
523 if (log_tgts_set)
524 dcc_error_msg("log thresholds set with -t"
525 " but no -l directory");
526 if (userdirs != '\0')
527 dcc_error_msg("no -l directory prevents per-user"
528 " logging with -U");
529 }
530
531 #ifdef RLIMIT_NOFILE
532 if (old_rlim_cur < (i = max_work*FILES_PER_JOB+EXTRA_FILES)) {
533 nofile.rlim_cur = i;
534 if (0 > setrlimit(RLIMIT_NOFILE, &nofile)) {
535 dcc_error_msg("setrlimit(RLIMIT_NOFILE,%d): %s",
536 i, ERROR_STR());
537 max_work = old_rlim_cur/FILES_PER_JOB - EXTRA_FILES;
538 if (max_work <= 0) {
539 dcc_error_msg("only %d open files allowed"
540 " by RLIMIT_NOFILE",
541 old_rlim_cur);
542 max_work = MIN_MAX_WORK;
543 }
544 }
545 }
546 #endif /* RLIMIT_NOFILE */
547
548 helper_init(max_work);
549
550 if (background) {
551 if (daemon(1, 0) < 0)
552 dcc_logbad(EX_OSERR, "daemon(): %s", ERROR_STR());
553
554 dcc_daemon_restart(rundir, 0);
555 dcc_pidfile(pidpath, rundir);
556 }
557
558 signal(SIGPIPE, SIG_IGN);
559 signal(SIGHUP, sigterm);
560 signal(SIGTERM, sigterm);
561 signal(SIGINT, sigterm);
562 #ifdef SIGXFSZ
563 signal(SIGXFSZ, SIG_IGN);
564 #endif
565
566 /* Be careful to start all threads only after the fork() in daemon(),
567 * because some POSIX threads packages (e.g. FreeBSD) get confused
568 * about threads in the parent. */
569
570 cmn_init();
571 add_work(init_work);
572
573 if (listen_family != AF_UNIX) {
574 dcc_trace_msg(DCC_VERSION" listening to %s from %s for %s",
575 lhost_port, rcidr,
576 proxy ? "SMTP commands" : "ASCII protocol");
577 } else {
578 dcc_trace_msg(DCC_VERSION" listening to %s for %s",
579 listen_addr,
580 proxy ? "SMTP commands" : "ASCII protocol");
581 }
582 if (dcc_clnt_debug)
583 dcc_trace_msg("init_work=%d max_work=%d max_max_work=%d (%s)",
584 total_work, max_work, max_max_work,
585 max_max_work_src);
586
587 while (!stopping) {
588 /* delay for 1 second instead of forever to notice
589 * when SIGTERM has said to stop */
590 i = dcc_select_poll(emsg, listen_soc, 1, DCC_US);
591 if (i < 0)
592 dcc_logbad(EX_OSERR, "%s", emsg);
593 if (i == 0)
594 continue;
595
596 /* A new connection is ready. Allocate a context
597 * block and create a thread */
598 lock_work();
599 wp = work_free;
600 if (!wp) {
601 if (total_work > max_work) {
602 /* pretend we weren't listening if we
603 * are out of context blocks */
604 unlock_work();
605 sleep(1);
606 continue;
607 }
608 if (dcc_clnt_debug > 1)
609 dcc_trace_msg("add %d work blocks to %d",
610 init_work, total_work);
611 add_work(init_work);
612 wp = work_free;
613 }
614 work_free = wp->fwd;
615 unlock_work();
616
617 /* clear most of context block for the new connection */
618 cmn_clear(&wp->cw, wp, 1);
619 wp->cw.helo[0] = '\0';
620 memset(&wp->WORK_ZERO, 0,
621 sizeof(*wp) - ((char*)&wp->WORK_ZERO - (char*)wp));
622
623 namelen = sizeof(wp->proxy_in_su);
624 wp->proxy_in_soc = accept(listen_soc,
625 &wp->proxy_in_su.sa, &namelen);
626 if (wp->proxy_in_soc < 0) {
627 dcc_error_msg("accept(): %s", ERROR_STR());
628 job_close(wp);
629 continue;
630 }
631 if (listen_family != AF_UNIX) {
632 struct in6_addr addr6, *ap;
633
634 if (wp->proxy_in_su.sa.sa_family == AF_INET6) {
635 ap = &wp->proxy_in_su.ipv6.sin6_addr;
636 } else {
637 ap = &addr6;
638 dcc_ipv4toipv6(ap,
639 wp->proxy_in_su.ipv4.sin_addr);
640 }
641 if (!DCC_IN_BLOCK(*ap, raddr, rmask)) {
642 char str[DCC_SU2STR_SIZE];
643 dcc_error_msg("unauthorized client address %s",
644 dcc_su2str(str, sizeof(str),
645 &wp->proxy_in_su));
646 job_close(wp);
647 continue;
648 }
649 }
650 if (!set_soc(emsg, wp->proxy_in_soc, listen_family, "MTA")) {
651 dcc_error_msg("%s", emsg);
652 job_close(wp);
653 continue;
654 }
655 i = pthread_create(&tid, 0, job_start, wp);
656 if (i) {
657 dcc_error_msg("pthread_create(): %s", ERROR_STR1(i));
658 job_close(wp);
659 continue;
660 }
661 i = pthread_detach(tid);
662 if (i != 0) {
663 if (i != ESRCH)
664 dcc_error_msg("pthread_detach(): %s", ERROR_STR1(i));
665 else if (dcc_clnt_debug)
666 dcc_trace_msg("pthread_detach(): %s", ERROR_STR1(i));
667 }
668 }
669
670 close_listen_soc();
671
672 totals_stop();
673
674 exit(stopping);
675 }
676
677
678
679 static void
680 unlink_listen_sun(void)
681 {
682 if (listen_family != AF_UNIX)
683 return;
684
685 /* there is an unavoidable race here */
686 if (0 > unlink(listen_sun.sun_path)
687 && errno != ENOENT)
688 dcc_error_msg("unlink(%s): %s",
689 listen_sun.sun_path, ERROR_STR());
690 }
691
692
693
694 static void
695 bind_unix_listen(void)
696 {
697 DCC_EMSG emsg;
698 struct stat sb;
699 int i;
700
701 #ifdef HP_UX_BAD_AF_UNIX
702 dcc_logbad(EX_CONFIG, "HP-UX AF_UNIX does not support shutdown()");
703 #endif
704
705 emsg[0] = '\0';
706 listen_family = AF_UNIX;
707
708 if (!listen_addr) {
709 /* use default UNIX domain socket */
710 snprintf(listen_sun.sun_path, sizeof(listen_sun.sun_path),
711 "%s/"DCC_DCCIF_UDS, dcc_homedir);
712 listen_addr = listen_sun.sun_path;
713 } else {
714 if (strlen(listen_addr) >= ISZ(listen_sun.sun_path))
715 dcc_logbad(EX_USAGE, "invalid UNIX domain socket: %s",
716 listen_addr);
717 strcpy(listen_sun.sun_path, listen_addr);
718 }
719 #ifdef HAVE_SA_LEN
720 listen_sun.sun_len = SUN_LEN(&listen_sun);
721 #endif
722 listen_sun.sun_family = AF_UNIX;
723
724 if (0 <= stat(listen_sun.sun_path, &sb)
725 && !(S_ISSOCK(sb.st_mode) || S_ISFIFO(sb.st_mode)))
726 dcc_logbad(EX_UNAVAILABLE, "non-socket present at %s",
727 listen_sun.sun_path);
728
729 /* Look for a daemon already using our socket. Do not give up
730 * immediately in case a previous instance is slowly stopping. */
731 i = 0;
732 for (;;) {
733 listen_soc = socket(AF_UNIX, SOCK_STREAM, 0);
734 if (listen_soc < 0)
735 dcc_logbad(EX_OSERR, "socket(AF_UNIX): %s",
736 ERROR_STR());
737 /* unlink it only if it looks like a dead socket */
738 if (0 > connect(listen_soc, (struct sockaddr *)&listen_sun,
739 sizeof(listen_sun))) {
740 if (errno == ECONNREFUSED || errno == ECONNRESET
741 || errno == EACCES) {
742 unlink_listen_sun();
743 } else if (dcc_clnt_debug > 2
744 && errno != ENOENT) {
745 dcc_trace_msg("connect(old server %s): %s",
746 listen_sun.sun_path, ERROR_STR());
747 }
748 close(listen_soc);
749 break;
750 }
751 /* connect() worked so the socket is alive */
752 if (++i > 5*10)
753 dcc_logbad(EX_UNAVAILABLE,
754 "something running with socket at %s",
755 listen_sun.sun_path);
756 close(listen_soc);
757 usleep(100*1000);
758 }
759
760 listen_soc = socket(AF_UNIX, SOCK_STREAM, 0);
761 if (listen_soc < 0)
762 dcc_logbad(EX_OSERR, "socket(AF_UNIX): %s", ERROR_STR());
763 if (0 > bind(listen_soc, (struct sockaddr *)&listen_sun,
764 sizeof(listen_sun)))
765 dcc_logbad(EX_IOERR, "bind(%s) %s",
766 listen_sun.sun_path, ERROR_STR());
767 if (0 > chmod(listen_sun.sun_path, 0666))
768 dcc_error_msg("chmod(%s, 0666): %s",
769 listen_sun.sun_path, ERROR_STR());
770 }
771
772
773
774 static void
775 bind_tcp_listen(void)
776 {
777 DCC_EMSG emsg;
778 char lhost[MAXHOSTNAMELEN];
779 u_int16_t lport;
780 DCC_SOCKU su;
781 char *duparg;
782 const char *cp;
783 int on, error;
784
785 emsg[0] = '\0';
786
787 duparg = strdup(listen_addr);
788 lhost_port = duparg;
789 duparg = strchr(duparg, ',');
790 if (!duparg)
791 dcc_logbad(EX_USAGE, "missing port number in \"%s\"",
792 listen_addr);
793
794 duparg = strchr(duparg+1, ',');
795 if (!duparg)
796 dcc_logbad(EX_USAGE, "missing rhost in \"%s\"",
797 listen_addr);
798 *duparg++ = '\0';
799
800 rcidr = duparg;
801 if (0 >= dcc_str2cidr(emsg, &raddr, &rmask, 0, rcidr, 0, 0))
802 dcc_logbad(EX_USAGE, "invalid rhost and mask \"%s\"",
803 rcidr);
804
805 cp = dcc_parse_nm_port(emsg, lhost_port, DCC_GET_PORT_INVALID,
806 lhost, sizeof(lhost), &lport, 0, 0, 0, 0);
807 if (!cp)
808 dcc_logbad(dcc_ex_code, "%s", emsg);
809 if (*cp != '\0')
810 dcc_logbad(EX_USAGE, "invalid IP address: \"%s\"",
811 lhost_port);
812
813 if (lhost[0] == '\0' || !strcmp(lhost, "@")) {
814 /* null or "@" means INADDR_ANY */
815 dcc_mk_su(&su, use_ipv6 ? AF_INET6: AF_INET, 0, lport);
816 } else {
817 dcc_host_lock();
818 if (!dcc_get_host(lhost, use_ipv6, &error))
819 dcc_logbad(EX_NOHOST, "%s: %s",
820 lhost, DCC_HSTRERROR(error));
821 su = dcc_hostaddrs[0];
822 *DCC_SU_PORTP(&su) = lport;
823 dcc_host_unlock();
824 }
825
826 listen_soc = socket(su.sa.sa_family, SOCK_STREAM, 0);
827 if (listen_soc < 0)
828 dcc_logbad(EX_OSERR, "socket(): %s", ERROR_STR());
829
830 on = 1;
831 if (0 > setsockopt(listen_soc, SOL_SOCKET, SO_REUSEADDR,
832 &on, sizeof(on)))
833 dcc_error_msg("setsockopt(listen %s, SO_REUSADDR): %s",
834 dcc_su2str_err(&su), ERROR_STR());
835
836 if (0 > bind(listen_soc, &su.sa, DCC_SU_LEN(&su)))
837 dcc_logbad(EX_UNAVAILABLE, "bind(%s) %s",
838 lhost_port, ERROR_STR());
839
840 listen_family = su.sa.sa_family;
841 }
842
843
844
845 static u_char
846 set_soc(DCC_EMSG emsg, int s, int family, const char *sname)
847 {
848 int on;
849
850 if (0 > fcntl(s, F_SETFD, FD_CLOEXEC)) {
851 dcc_pemsg(EX_IOERR, emsg,
852 "fcntl(%s, F_SETFD, FD_CLOEXEC): %s",
853 sname, ERROR_STR());
854 return 0;
855 }
856
857 if (family != AF_UNIX) {
858 on = 1;
859 if (0 > setsockopt(s, SOL_SOCKET, SO_KEEPALIVE,
860 &on, sizeof(on))) {
861 dcc_pemsg(EX_IOERR, emsg,
862 "setsockopt(%s, SO_KEEPALIVE): %s",
863 sname, ERROR_STR());
864 return 0;
865 }
866 }
867
868 /* use non-blocking sockets so that we can read entire lines
869 * without knowing how big they are or expecting the operating
870 * system to allow peeking at its buffers */
871 if (-1 == fcntl(s, F_SETFL,
872 fcntl(s, F_GETFL, 0) | O_NONBLOCK)) {
873 dcc_pemsg(EX_OSERR, emsg, "fcntl(%s, O_NONBLOCK): %s",
874 sname, ERROR_STR());
875 return 0;
876 }
877
878 return 1;
879 }
880
881
882
883 static void
884 bind_listen(void)
885 {
886 DCC_EMSG emsg;
887 char *p;
888
889 /* It is a TCP address if it has a port number and mask.
890 * Otherwise it is a UNIX domain socket.
891 */
892 if (listen_addr != 0
893 && (p = strchr(listen_addr, ',')) != 0
894 && strchr(p, ',')) {
895 bind_tcp_listen();
896 } else {
897 bind_unix_listen();
898 }
899
900 if (!set_soc(emsg, listen_soc, listen_family, "main socket"))
901 dcc_logbad(dcc_ex_code, "%s", emsg);
902 if (0 > listen(listen_soc, 10))
903 dcc_logbad(EX_IOERR, "listen(): %s", ERROR_STR());
904 }
905
906
907
908 static u_char /* 0=EOF, 1=read something */
909 soc_read(WORK *wp, IN_BC *bc)
910 {
911 int fspace, len, total, i;
912
913 if (bc->out >= bc->in)
914 bc->out = bc->in = bc->base;
915
916 fspace = &bc->base[bc->size] - bc->in;
917 if (fspace < bc->size/8) {
918 if (bc->out == bc->base) {
919 thr_error_msg(&wp->cw, "buffer overrun; in=%d",
920 (int)(bc->in - bc->base));
921 job_exit(wp);
922 }
923 len = bc->in - bc->out;
924 memmove(bc->base, bc->out, len);
925 bc->out = bc->base;
926 bc->in = bc->out+len;
927 fspace = bc->size - len;
928 }
929
930 if (wp->dfgs & DFG_WORK_LOCK)
931 unlock_work();
932
933 if (!bc->socp || *bc->socp < 0)
934 dcc_logbad(EX_SOFTWARE, "attempt to read closed socket");
935
936 for (;;) {
937 i = dcc_select_poll(wp->cw.emsg, *bc->socp, 1,
938 MAX_MTA_DELAY*DCC_US);
939 if (i > 0)
940 break;
941 if (i < 0) {
942 thr_error_msg(&wp->cw, "%s", wp->cw.emsg);
943 } else {
944 thr_error_msg(&wp->cw, "MTA read timeout");
945 }
946 job_exit(wp);
947 }
948 total = read(*bc->socp, bc->in, fspace);
949 if (total < 0) {
950 if (!proxy || dcc_clnt_debug)
951 thr_error_msg(&wp->cw, "read(sock): %s", ERROR_STR());
952 job_exit(wp);
953 }
954 bc->in += total;
955
956 if (wp->dfgs & DFG_WORK_LOCK)
957 lock_work();
958 return total != 0;
959 }
960
961
962
963 /* ensure there is another line in the buffer */
964 static u_char /* 0=eof or buffer overflow */
965 msg_read_line(WORK *wp, IN_BC *bc)
966 {
967 int i;
968 char *p;
969
970 for (;;) {
971 p = bc->out;
972 i = bc->in - p;
973 if (i != 0) {
974 /* look for <LF> for ASCII protocol
975 * or <CR><LF> for SMTP */
976 p = memchr(p, '\n', i);
977 if (p
978 && (!proxy
979 || (p > bc->out && *(p-1) == '\r'))) {
980 bc->next_line = p+1;
981 return 1;
982 }
983 }
984
985 if (!soc_read(wp, bc))
986 return 0;
987 }
988 }
989
990
991
992 static void
993 buf_write_flush(WORK *wp, OUT_BC *bc)
994 {
995 const char *buf;
996 int len, i;
997
998 len = bc->len;
999 if (!len)
1000 return;
1001 bc->len = 0;
1002
1003 if (!bc->socp || *bc->socp < 0)
1004 dcc_logbad(EX_SOFTWARE, "attempt to write closed socket");
1005
1006 buf = bc->base;
1007 do {
1008 i = dcc_select_poll(wp->cw.emsg, *bc->socp, 0,
1009 MAX_MTA_DELAY*DCC_US);
1010 if (i < 0) {
1011 thr_error_msg(&wp->cw, "%s", wp->cw.emsg);
1012 job_exit(wp);
1013 }
1014 if (i == 0) {
1015 thr_error_msg(&wp->cw, "MTA write timeout");
1016 job_exit(wp);
1017 }
1018 i = write(*bc->socp, buf, len);
1019 if (i < 0) {
1020 if (DCC_BLOCK_ERROR())
1021 continue;
1022 thr_error_msg(&wp->cw, "write(MTA socket,%d): %s",
1023 len, ERROR_STR());
1024 job_exit(wp);
1025 }
1026 if (i == 0) {
1027 thr_error_msg(&wp->cw, "write(MTA socket,%d)=%d",
1028 len, i);
1029 job_exit(wp);
1030 }
1031 buf += i;
1032 len -= i;
1033 } while (len > 0);
1034 }
1035
1036
1037
1038 static void
1039 buf_write(WORK *wp, OUT_BC *bc, const void *buf, u_int len)
1040 {
1041 u_int n;
1042
1043 for (;;) {
1044 n = bc->size - bc->len;
1045 if (n == 0)
1046 dcc_logbad(EX_SOFTWARE, "impossible buffer space");
1047 if (n > len)
1048 n = len;
1049 memcpy(&bc->base[bc->len], buf, n);
1050 if ((bc->len += n) >= bc->size)
1051 buf_write_flush(wp, bc);
1052 if ((len -= n) == 0)
1053 return;
1054 buf = (void *)((char *)buf + n);
1055 }
1056 }
1057
1058
1059
1060 static void
1061 tmp_write(WORK *wp, const void *buf, int len)
1062 {
1063 if (!cmn_write_tmp(&wp->cw, buf, len)) {
1064 thr_error_msg(&wp->cw, "%s", wp->cw.emsg);
1065 job_exit(wp);
1066 }
1067 }
1068
1069
1070
1071 static int
1072 tmp_read(WORK *wp, void *buf, int len)
1073 {
1074 int i;
1075
1076 if (wp->cw.tmp_fd < 0)
1077 return 0;
1078
1079 i = read(wp->cw.tmp_fd, buf, len);
1080 if (i < 0) {
1081 thr_error_msg(&wp->cw, "read(%s,%d): %s",
1082 wp->cw.tmp_nm, len, ERROR_STR());
1083 job_exit(wp);
1084 }
1085 return i;
1086 }
1087
1088
1089
1090 /* fill MTA read buffer from temporary file */
1091 static int
1092 tmp_read_msg_in(WORK *wp)
1093 {
1094 int i;
1095
1096 /* preserving what is already in it */
1097 i = wp->msg_rd.in - wp->msg_rd.out;
1098 if (i > 0)
1099 memmove(wp->msg_rd.base, wp->msg_rd.out, i);
1100 wp->msg_rd.out = wp->msg_rd.base;
1101 wp->msg_rd.in = wp->msg_rd.out+i;
1102
1103 wp->msg_rd.in += tmp_read(wp, wp->msg_rd.in, wp->msg_rd.size - i);
1104 return wp->msg_rd.in > wp->msg_rd.out;
1105 }
1106
1107
1108
1109 /* Create the contexts. */
1110 static void
1111 add_work(int i)
1112 {
1113 WORK *wp;
1114
1115 total_work += i;
1116
1117 wp = dcc_malloc(sizeof(*wp)*i);
1118 memset(wp, 0, sizeof(*wp)*i);
1119
1120 while (i-- != 0) {
1121 wp->proxy_in_soc = -1;
1122 wp->proxy_out_soc = -1;
1123 cmn_create(&wp->cw);
1124 wp->fwd = work_free;
1125 work_free = wp;
1126 ++wp;
1127 }
1128 }
1129
1130
1131
1132 void
1133 work_clean(void)
1134 {
1135 WORK *wp;
1136 int keep, delete;
1137
1138 lock_work();
1139 keep = 5;
1140 delete = init_work;
1141 for (wp = work_free; wp; wp = wp->fwd) {
1142 if (!wp->cw.dcc_ctxt)
1143 break;
1144 if (--keep > 0)
1145 continue;
1146 dcc_clnt_soc_close(wp->cw.dcc_ctxt);
1147 if (--delete <= 0)
1148 break;
1149 }
1150 unlock_work();
1151 }
1152
1153
1154
1155 static void
1156 job_close(WORK *wp)
1157 {
1158 if (wp->dfgs & DFG_WORK_LOCK) {
1159 wp->dfgs &= ~DFG_WORK_LOCK;
1160 unlock_work();
1161 }
1162
1163 wp->msg_rd.socp = 0;
1164 if (wp->msg_wt.socp) {
1165 buf_write_flush(wp, &wp->msg_wt);
1166 wp->msg_wt.socp = 0;
1167 }
1168 wp->reply_in.socp = 0;
1169 if (wp->reply_out.socp) {
1170 buf_write_flush(wp, &wp->reply_out);
1171 wp->reply_out.socp = 0;
1172 }
1173
1174 cmn_close_tmp(&wp->cw);
1175
1176 if (wp->proxy_in_soc >= 0) {
1177 if (0 > close(wp->proxy_in_soc)
1178 && (dcc_clnt_debug
1179 || (errno != ECONNRESET
1180 && errno != ENOTCONN)))
1181 thr_error_msg(&wp->cw, "close(proxy input socket): %s",
1182 ERROR_STR());
1183 wp->proxy_in_soc = -1;
1184 }
1185 if (wp->proxy_out_soc >= 0) {
1186 if (0 > close(wp->proxy_out_soc))
1187 thr_error_msg(&wp->cw, "close(proxy output socket): %s",
1188 ERROR_STR());
1189 wp->proxy_out_soc = -1;
1190 }
1191 log_stop(&wp->cw);
1192
1193 lock_work();
1194 free_rcpt_sts(&wp->cw, 0);
1195 wp->fwd = work_free;
1196 work_free = wp;
1197 unlock_work();
1198 }
1199
1200
1201
1202 static void NRATTRIB
1203 job_exit(WORK *wp)
1204 {
1205 job_close(wp);
1206 pthread_exit(0);
1207 /* mostly to suppress warning */
1208 dcc_logbad(EX_OSERR, "pthread_exit() returned");
1209 }
1210
1211
1212
1213 /* write headers or body data from the MTA read buffer to the MTA */
1214 static void
1215 mta_write(WORK *wp, char *end)
1216 {
1217 int len;
1218
1219 len = end - wp->msg_rd.out;
1220 if (len <= 0)
1221 return;
1222 buf_write(wp, &wp->msg_wt, wp->msg_rd.out, len);
1223 wp->msg_rd.out = end;
1224 }
1225
1226
1227
1228 /* copy headers from the temporary file to the MTA */
1229 static void
1230 hdrs_copy(WORK *wp)
1231 {
1232 enum {START_HDR, SKIP_HDR, COPY_HDR} cmode;
1233 const char *nl;
1234 char *bol, *eol;
1235 int i;
1236
1237 if (-1 == lseek(wp->cw.tmp_fd, 0, SEEK_SET)) {
1238 thr_error_msg(&wp->cw, "rewind %s: %s",
1239 wp->cw.tmp_nm, ERROR_STR());
1240 job_exit(wp);
1241 }
1242
1243 cmode = START_HDR;
1244 wp->msg_rd.in = wp->msg_rd.out = wp->msg_rd.base;
1245 for (;;) {
1246 /* fill wp->msg_rd while keeping anything already present */
1247 if (!tmp_read_msg_in(wp))
1248 return;
1249
1250 bol = wp->msg_rd.out;
1251 while ((i = wp->msg_rd.in - bol) > 0) {
1252 /* Find the end of the next line. */
1253 eol = memchr(bol, '\n', i);
1254 if (!eol) {
1255 /* Fill the buffer if we can't find '\n''
1256 * and the buffer has room */
1257 if (i < wp->msg_rd.size
1258 && wp->msg_rd.out != wp->msg_rd.base)
1259 break;
1260 /* pretend the header ended with the buffer
1261 * if there is no room */
1262 eol = wp->msg_rd.in-1;
1263 nl = 0;
1264 } else if (eol+1 >= wp->msg_rd.in) {
1265 /* get the character after '\n' */
1266 if (i < wp->msg_rd.size
1267 && wp->msg_rd.out != wp->msg_rd.base)
1268 break;
1269 /* pretend we could not find it if there
1270 * is no room in the buffer
1271 * or if we are at end of file.
1272 * This will also end the headers */
1273 nl = 0;
1274 } else {
1275 nl = eol+1;
1276 }
1277
1278 if (cmode == START_HDR) {
1279 /* We are at start of a header or the body.
1280 * Quit before line of "\n" or "\r\n" */
1281 if (eol == bol
1282 || (eol == bol+1 && *bol == '\r')) {
1283 /* write any preceding lines */
1284 mta_write(wp, bol);
1285 return;
1286 }
1287
1288 /* Look for our header
1289 * Assume the buffer is larger than the
1290 * largest possible X-DCC field name. */
1291 if (chghdr == SETHDR
1292 && is_xhdr(bol, eol-bol)) {
1293 /* skip it
1294 * and copy any preceding headers. */
1295 mta_write(wp, bol);
1296 cmode = SKIP_HDR;
1297 } else {
1298 cmode = COPY_HDR;
1299 }
1300 }
1301 if (cmode == SKIP_HDR)
1302 wp->msg_rd.out = eol+1;
1303
1304 /* Check the character after '\n' for
1305 * whitespace indicating continuation */
1306 if (nl && *nl != ' ' && *nl != '\t') {
1307 cmode = START_HDR;
1308 /* deal with SMTP transparency */
1309 if (proxy && *nl == '.')
1310 *eol-- = '.';
1311 }
1312
1313 bol = eol+1;
1314 }
1315
1316 mta_write(wp, bol);
1317 }
1318 }
1319
1320
1321
1322 static void
1323 add_hdr(void *wp0, const char *buf, u_int buf_len)
1324 {
1325 WORK *wp = wp0;
1326
1327 buf_write(wp, &wp->msg_wt, buf, buf_len);
1328 }
1329
1330
1331
1332 static void
1333 body_copy(WORK *wp)
1334 {
1335 u_char seen_crlf;
1336 char *p;
1337
1338 hdrs_copy(wp);
1339
1340 if (chghdr != NOHDR && wp->cw.header.buf[0] != '\0') {
1341 /* write X-DCC header
1342 * end with "\r\n" if at least
1343 * half of the header lines ended that way */
1344 xhdr_write(add_hdr, wp, wp->cw.header.buf,
1345 wp->cw.header.used,
1346 wp->cr_hdrs > wp->total_hdrs/2);
1347 }
1348
1349 /* copy body */
1350 seen_crlf = 2;
1351 do {
1352 p = wp->msg_rd.out;
1353 while (p < wp->msg_rd.in) {
1354 if (seen_crlf == 1) {
1355 seen_crlf = (*p++ == '\n') ? 2 : 0;
1356 continue;
1357 }
1358 if (seen_crlf == 2) {
1359 seen_crlf = 0;
1360 if (*p == '.' && proxy) {
1361 mta_write(wp, p);
1362 buf_write(wp, &wp->msg_wt, ".", 1);
1363 }
1364 }
1365
1366 if (!proxy)
1367 break;
1368 p = memchr(p, '\r', wp->msg_rd.in-p);
1369 if (!p)
1370 break;
1371 seen_crlf = 1;
1372 ++p;
1373 }
1374 mta_write(wp, wp->msg_rd.in);
1375 } while (tmp_read_msg_in(wp));
1376 }
1377
1378
1379
1380 static void
1381 close_listen_soc(void)
1382 {
1383 if (pidpath[0] != '\0') {
1384 unlink(pidpath);
1385 pidpath[0] = '\0';
1386 }
1387
1388 if (listen_soc >= 0) {
1389 unlink_listen_sun();
1390 if (0 > close(listen_soc))
1391 dcc_error_msg("close(main socket): %s",
1392 ERROR_STR());
1393 listen_soc = -1;
1394 }
1395 }
1396
1397
1398
1399 /* watch for fatal signals */
1400 static void
1401 sigterm(int sig)
1402 {
1403 stopping = 100 + sig;
1404 unlink_listen_sun();
1405 dcc_clnt_stop_resolve();
1406 signal(sig, SIG_DFL); /* quit on repeated signals */
1407 }
1408
1409
1410
1411 void
1412 user_reject_discard(UATTRIB CMN_WORK *cwp, UATTRIB RCPT_ST *rcpt_st)
1413 {
1414 /* dccifd has no way to tell the MTA to remove a recipient
1415 * after the Rcpt_To command */
1416 thr_error_msg(cwp, "cannot discard an individual target");
1417 }
1418
1419
1420
1421 static void
1422 get_helo(WORK *wp, const char *vp, int len)
1423 {
1424 if (len < DCC_HELO_MAX-1) {
1425 memcpy(wp->cw.helo, vp, len);
1426 wp->cw.helo[len] = '\0';
1427 } else {
1428 /* if the HELO value is too long, capture what we can
1429 * and indicate that we got only part of it */
1430 len = DCC_HELO_MAX-1;
1431 memcpy(wp->cw.helo, vp, len);
1432 strcpy(&wp->msg_rd.out[DCC_HELO_MAX-ISZ(DCC_HELO_CONT)],
1433 DCC_HELO_CONT);
1434 }
1435 }
1436
1437
1438
1439 /* Get the next header field
1440 * The line is copied to the temporary file and then null terminated
1441 * in the buffer */
1442 static u_char /* 1=have one, 0=end of headers */
1443 get_hdr(WORK *wp)
1444 {
1445 int tf_len; /* header bytes written to temp file */
1446 int hdr_len; /* total header length */
1447 int nlen; /* length of next chunk of header */
1448 char *np; /* next byte after field */
1449 char *p;
1450 u_char at_bol; /* 1=at start of a line of header */
1451
1452 tf_len = 0;
1453 hdr_len = 0;
1454 at_bol = 1;
1455 for (;;) {
1456 /* get another line of the header */
1457 np = wp->msg_rd.out + hdr_len;
1458 nlen = wp->msg_rd.in - np;
1459 if (nlen <= 1) {
1460 /* we do not have enough data */
1461 read_more:;
1462 if (hdr_len > DCC_HDR_CK_MAX) {
1463 /* we already have more than DCC_HDR_CK_MAX
1464 * bytes of the header.
1465 * Keep only DCC_HDR_CK_MAX bytes of it
1466 * in the buffer. We will eventually
1467 * return only the first DCC_HDR_CK_MAX
1468 * bytes and an arbitrary part of the tail
1469 * to our caller. */
1470 if (tf_len < hdr_len)
1471 tmp_write(wp, wp->msg_rd.out+tf_len,
1472 hdr_len - tf_len);
1473 /* discard all but the first DCC_HDR_CK_MAX
1474 * bytes of the header */
1475 hdr_len = DCC_HDR_CK_MAX;
1476 tf_len = DCC_HDR_CK_MAX;
1477 if (nlen != 0)
1478 wp->msg_rd.out[DCC_HDR_CK_MAX] = *np;
1479 wp->msg_rd.in = (wp->msg_rd.out + DCC_HDR_CK_MAX
1480 + nlen);
1481 }
1482 /* Get more data, possibly sliding what we already
1483 * have down in the buffer. That would move
1484 * wp->msg_rd.in to wp->msg_rd.base. */
1485 if (!soc_read(wp, &wp->msg_rd)) {
1486 /* EOF implies the message body including the
1487 * separating blank line is missing.
1488 * That is impossible for the ASCII dccifd
1489 * protocol because there should be at least
1490 * a Received header.
1491 * When running as a proxy, we should get
1492 * "\r\n.\r\n"
1493 * Fake newlines until we get out of here
1494 * so that we will log whatever we got */
1495 wp->dfgs |= DFG_MISSING_BODY;
1496 if (wp->cr_hdrs >= wp->total_hdrs/2)
1497 *wp->msg_rd.in++ = '\r';
1498 *wp->msg_rd.in++ = '\n';
1499 }
1500 continue;
1501 }
1502
1503 if (at_bol) {
1504 /* deal with SMTP transparency */
1505 if (*np == '.' && proxy) {
1506 if (nlen < 3)
1507 goto read_more;
1508 if (np[1] != '\r' || np[2] != '\n') {
1509 memmove(np, np+1, --nlen);
1510 } else if (hdr_len == 0) {
1511 /* ".\r\n" at the start of a line
1512 * ends the message. In this case
1513 * the message body including the
1514 * separating blank line is missing.
1515 * Stop short before the ".\r\n" */
1516 return 0;
1517 }
1518 }
1519
1520 /* stop before the next line if it is
1521 * not a continuation of the current header */
1522 if (hdr_len != 0
1523 && *np != ' '
1524 && *np != '\t') {
1525 if (tf_len < hdr_len)
1526 tmp_write(wp, wp->msg_rd.out+tf_len,
1527 hdr_len - tf_len);
1528 wp->msg_rd.out[hdr_len-1] = '\0';
1529 if (hdr_len > 1
1530 && wp->msg_rd.out[hdr_len-2] == '\r')
1531 ++wp->cr_hdrs;
1532 wp->msg_rd.next_line = &wp->msg_rd.out[hdr_len];
1533 return 1;
1534 }
1535 }
1536
1537 /* find the end of the next line */
1538 p = memchr(np, '\n', nlen);
1539 if (p) {
1540 hdr_len += ++p - np;
1541 /* quit at the end of headers */
1542 if (hdr_len == 1
1543 || (hdr_len == 2 && *wp->msg_rd.out == '\r'))
1544 return 0;
1545 at_bol = 1;
1546 } else {
1547 hdr_len += nlen;
1548 at_bol = 0;
1549 }
1550 }
1551 }
1552
1553
1554
1555 static void
1556 get_hdrs(WORK *wp)
1557 {
1558 const char *p, *rh;
1559
1560 for (;;) {
1561 /* stop at the separator between the body and headers */
1562 if (!get_hdr(wp))
1563 break;
1564 ++wp->total_hdrs;
1565
1566 #define GET_HDR_CK(h,t) { \
1567 if (!CLITCMP(wp->msg_rd.out, h)) { \
1568 dcc_get_cks(&wp->cw.cks, DCC_CK_##t, \
1569 &wp->msg_rd.out[LITZ(h)], 1); \
1570 wp->dfgs |= DFG_SEEN_HDR; \
1571 wp->msg_rd.out = wp->msg_rd.next_line; \
1572 continue;}}
1573 GET_HDR_CK(DCC_XHDR_TYPE_FROM":", FROM);
1574 GET_HDR_CK(DCC_XHDR_TYPE_MESSAGE_ID":", MESSAGE_ID);
1575 #undef GET_HDR_CK
1576
1577 /* notice UNIX From_ line */
1578 if (!(wp->dfgs & DFG_SEEN_HDR)
1579 && wp->cw.env_from[0] == '\0'
1580 && parse_unix_from(wp->msg_rd.out, wp->cw.env_from,
1581 sizeof(wp->cw.env_from))) {
1582 wp->dfgs |= DFG_SEEN_HDR;
1583 wp->msg_rd.out = wp->msg_rd.next_line;
1584 continue;
1585 }
1586
1587 if (wp->cw.env_from[0] == '\0'
1588 && parse_return_path(wp->msg_rd.out, wp->cw.env_from,
1589 sizeof(wp->cw.env_from))) {
1590 wp->dfgs |= DFG_SEEN_HDR;
1591 wp->msg_rd.out = wp->msg_rd.next_line;
1592 continue;
1593 }
1594
1595 if (!CLITCMP(wp->msg_rd.out, DCC_XHDR_TYPE_RECEIVED":")) {
1596 p = &wp->msg_rd.out[LITZ(DCC_XHDR_TYPE_RECEIVED":")];
1597
1598 /* compute checksum of the last Received: header */
1599 dcc_get_cks(&wp->cw.cks, DCC_CK_RECEIVED, p, 1);
1600
1601 wp->dfgs |= DFG_SEEN_HDR;
1602 wp->msg_rd.out = wp->msg_rd.next_line;
1603
1604 /* pick IP address out of first Received: header */
1605 if (!(wp->dfgs & DFG_PARSE_RCVD)
1606 || --wp->parse_rcvd >= 0)
1607 continue;
1608 rh = parse_received(p, &wp->cw.cks,
1609 (wp->cw.helo[0] == '\0')
1610 ? wp->cw.helo : 0,
1611 sizeof(wp->cw.helo),
1612 wp->cw.sender_str,
1613 sizeof(wp->cw.sender_str),
1614 wp->cw.sender_name,
1615 sizeof(wp->cw.sender_name));
1616 if (rh == 0) {
1617 /* to avoid being fooled by forged
1618 * headers, stop at a strange one */
1619 wp->dfgs &= ~DFG_PARSE_RCVD;
1620
1621 } else if (*rh != '\0') {
1622 thr_log_print(&wp->cw, 1,
1623 "skip %s Received: header\n", rh);
1624
1625 } else if (!check_mx_listing(&wp->cw)) {
1626 /* we know the client */
1627 wp->dfgs &= ~DFG_PARSE_RCVD;
1628 }
1629 continue;
1630 }
1631
1632 /* Notice MIME multipart boundary definitions */
1633 dcc_ck_mime_hdr(&wp->cw.cks, wp->msg_rd.out, 0);
1634
1635 if (dcc_ck_get_sub(&wp->cw.cks, wp->msg_rd.out, 0))
1636 wp->dfgs |= DFG_SEEN_HDR;
1637
1638 /* notice any sort of header */
1639 if (!(wp->dfgs & DFG_SEEN_HDR)) {
1640 for (p = wp->msg_rd.out; ; ++p) {
1641 if (*p == ':') {
1642 wp->dfgs |= DFG_SEEN_HDR;
1643 break;
1644 }
1645 if (*p <= ' ' || *p >= 0x7f)
1646 break;
1647 }
1648 }
1649
1650 wp->msg_rd.out = wp->msg_rd.next_line;
1651 }
1652
1653 /* Create a checksum for a null Message-ID header if there
1654 * was no Message-ID header. */
1655 if (wp->cw.cks.sums[DCC_CK_MESSAGE_ID].type != DCC_CK_MESSAGE_ID)
1656 dcc_get_cks(&wp->cw.cks, DCC_CK_MESSAGE_ID, "", 0);
1657 }
1658
1659
1660
1661 /* Assume for now that the sender is the SMTP client. Received: headers
1662 * might challenge that assumption */
1663 static void
1664 get_sender(WORK *wp)
1665 {
1666 strcpy(wp->cw.sender_name, wp->cw.clnt_name);
1667 strcpy(wp->cw.sender_str, wp->cw.clnt_str);
1668 if (wp->cw.sender_str[0] == '\0'
1669 || check_mx_listing(&wp->cw)) {
1670 /* try Received: header if client is unknown or MX server*/
1671 wp->dfgs |= DFG_PARSE_RCVD;
1672 }
1673 }
1674
1675
1676
1677 static u_char /* 0=temporary failure, 1=ok */
1678 get_body(WORK *wp)
1679 {
1680 char *p;
1681 char buf[1024];
1682 u_char bol;
1683 int buflen, i;
1684
1685 /* We must make a copy of the entire message in a temporary file
1686 * if the MTA wants a copy with the X-DCC header added
1687 * Copy the headers to a temporary file because the official
1688 * log file needs the SMTP client IP address and envelope information
1689 * before the header lines. The log file needs all of the header
1690 * lines including stray X-DCC lines, but those lines must be removed
1691 * from the output file. */
1692 if (!cmn_open_tmp(&wp->cw)) {
1693 if (wp->dfgs & DFG_MTA_BODY) {
1694 dcc_error_msg("fatal error: %s", wp->cw.emsg);
1695 return 0;
1696 }
1697 dcc_error_msg("%s", wp->cw.emsg);
1698 }
1699
1700 get_hdrs(wp);
1701
1702 /* log IP address and so forth that we may have collected from
1703 * the headers or Postfix XFORWARD or XCLIENT ESTMP extension */
1704 thr_log_envelope(&wp->cw, 0);
1705
1706 /* Check DNS blacklists for STMP client and envelope sender
1707 * unless DNSBL checks are turned off for all of the recipients */
1708 if (wp->cw.cks.dnsbl) {
1709 if (wp->cw.cks.sums[DCC_CK_IP].type == DCC_CK_IP)
1710 dcc_client_dnsbl(wp->cw.cks.dnsbl, &wp->cw.cks.ip_addr,
1711 wp->cw.sender_name);
1712 if (wp->cw.mail_host[0] != '\0')
1713 dcc_mail_host_dnsbl(wp->cw.cks.dnsbl, wp->cw.mail_host);
1714 }
1715
1716 /* copy headers from temporary file to log file */
1717 if (wp->cw.log_fd >= 0 && wp->cw.tmp_fd >= 0) {
1718 if (0 > lseek(wp->cw.tmp_fd, 0, SEEK_SET)) {
1719 thr_error_msg(&wp->cw, "rewind %s: %s",
1720 wp->cw.tmp_nm, ERROR_STR());
1721 job_exit(wp);
1722 }
1723 for (;;) {
1724 buflen = tmp_read(wp, buf, sizeof(buf));
1725 if (buflen <= 0)
1726 break;
1727 log_body_write(&wp->cw, buf, buflen);
1728 }
1729 }
1730
1731 if (wp->dfgs & DFG_MISSING_BODY)
1732 thr_error_msg(&wp->cw, "missing message body");
1733
1734 /* collect the body */
1735 bol = 1;
1736 for (;;) {
1737 buflen = wp->msg_rd.in - wp->msg_rd.out;
1738 if (buflen <= 0) {
1739 if (!soc_read(wp, &wp->msg_rd))
1740 break;
1741 buflen = wp->msg_rd.in - wp->msg_rd.out;
1742 }
1743
1744 /* deal with SMTP transparency and detect end of message */
1745 if (proxy) {
1746 if (bol) {
1747 /* We are at the beginning of a line.
1748 * There will always be at least 3 more bytes
1749 * in the message, ".\r\n" */
1750 if (buflen < 3) {
1751 if (!soc_read(wp, &wp->msg_rd))
1752 proxy_msg_truncated(wp);
1753 buflen = wp->msg_rd.in - wp->msg_rd.out;
1754 }
1755 /* Whether a '.' is the end of the data
1756 * or an escaped '.', we will discard it. */
1757 if (*wp->msg_rd.out == '.'
1758 && buflen >= 1) {
1759 ++wp->msg_rd.out;
1760 --buflen;
1761 /* if it is followed by "\r\n", then
1762 * we have the end of the message */
1763 if (buflen >= 2
1764 && wp->msg_rd.out[0] == '\r'
1765 && wp->msg_rd.out[1] == '\n') {
1766 wp->msg_rd.out += 2;
1767 break;
1768 }
1769 }
1770 /* we are still at the beginning of a line */
1771 }
1772
1773 /* check all of the lines in the buffer */
1774 p = wp->msg_rd.out;
1775 for (;;) {
1776 i = p - wp->msg_rd.out;
1777 p = memchr(p, '\r', buflen-i);
1778 if (!p) {
1779 /* We have checked all of the buffer.
1780 * It does not end near an end of line.
1781 * So log the block of body lines
1782 * and leave the part of a line
1783 * ending the buffer for later. */
1784 bol = 0;
1785 break;
1786 }
1787 /* We have found '\r'
1788 * Maybe it will be followed by '\n' */
1789 i = ++p - wp->msg_rd.out;
1790 if (i+2 >= buflen) {
1791 /* '\r' ends or almost ends buffer. */
1792 bol = 0;
1793 buflen = i-1;
1794 if (buflen > 0) {
1795 /* The buffer ends with "\rX"
1796 * and contains text before '\r'
1797 * Process up to the '\r' */
1798 break;
1799 }
1800 /* buffer starts with "\r" */
1801 if (!soc_read(wp, &wp->msg_rd))
1802 proxy_msg_truncated(wp);
1803 p = wp->msg_rd.out;
1804 buflen = wp->msg_rd.in - p;
1805
1806 } else if (*p == '\n') {
1807 /* We have "\r\n"
1808 * If "\r\n" is followed by '.',
1809 * then process up to the '.' */
1810 if (*++p == '.') {
1811 buflen = i+1;
1812 bol = 1;
1813 break;
1814 }
1815 }
1816 }
1817 }
1818
1819 /* Log the body block */
1820 log_body_write(&wp->cw, wp->msg_rd.out, buflen);
1821
1822 if (wp->dfgs & DFG_MTA_BODY)
1823 tmp_write(wp, wp->msg_rd.out, buflen);
1824
1825 dcc_ck_body(&wp->cw.cks, wp->msg_rd.out, buflen);
1826 wp->msg_rd.out += buflen;
1827 }
1828 dcc_cks_fin(&wp->cw.cks);
1829
1830 LOG_CAPTION(wp, DCC_LOG_MSG_SEP);
1831 thr_log_late(&wp->cw);
1832
1833 /* check the grey and white lists */
1834 cmn_ask_white(&wp->cw);
1835
1836 /* report spam to the DCC server in the case without a recipient
1837 * for the ASCII protocol,
1838 * which normally causes a query instead of a report. */
1839 if (!wp->cw.rcpt_st_first
1840 && ((wp->cw.ask_st & ASK_ST_MTA_ISSPAM)
1841 || (wp->cw.init_sws & FLTR_SW_TRAPS)
1842 || dcc_query_only
1843 || wp->cw.ask_st & ASK_ST_QUERY))
1844 ++wp->cw.tgts;
1845
1846 wp->cw.header.buf[0] = '\0';
1847 wp->cw.header.used = 0;
1848 if (wp->cw.tgts > wp->cw.white_tgts) {
1849 /* Report to the DCC and add our header if allowed.
1850 * After serious errors, act as if DCC server said not-spam
1851 * but remove our X-DCC header */
1852 i = cmn_ask_dcc(&wp->cw);
1853 if (!i && try_extra_hard)
1854 return 0;
1855
1856 } else {
1857 /* The message is whitelisted or the MTA told us there are 0
1858 * recipients, so we cannot ask the DCC server.
1859 * If it was whitelisted, add X-DCC header saying so. */
1860 if (wp->cw.tgts > 0)
1861 xhdr_whitelist(&wp->cw.header);
1862 /* Use the local target count to decide whether to log
1863 * the mail message */
1864 dcc_honor_log_cnts(&wp->cw.ask_st, &wp->cw.cks, wp->cw.tgts);
1865 }
1866
1867 totals.tgts += wp->cw.tgts;
1868
1869 return 1;
1870 }
1871
1872
1873
1874 /* ensure there is another line, trim its terminal "\r\n",
1875 * and add a terminal '\0'
1876 * This cannot be used with the proxy code because it often needs to
1877 * send the original buffer downstream. */
1878 static int /* # of bytes available */
1879 ascii_read_line(WORK *wp)
1880 {
1881 char *p;
1882
1883 if (!msg_read_line(wp, &wp->msg_rd)) {
1884 thr_error_msg(&wp->cw, "truncated request");
1885 job_exit(wp);
1886 }
1887
1888 p = wp->msg_rd.next_line-1;
1889 for (;;) {
1890 *p-- = '\0';
1891 if (p < wp->msg_rd.out)
1892 return 0;
1893 if (*p != '\r')
1894 return p+1 - wp->msg_rd.out;
1895 }
1896 }
1897
1898
1899
1900 /* Look for a string from the MTA
1901 * while ignoring case and skipping whitespace
1902 * The next line must already be in the buffer */
1903 static u_char /* 1=matched it */
1904 ascii_opt_str(WORK *wp, const char *st, int stlen)
1905 {
1906 /* skip initial white space */
1907 while (wp->msg_rd.out < wp->msg_rd.next_line
1908 && (*wp->msg_rd.out == '\t' || *wp->msg_rd.out == ' '))
1909 ++wp->msg_rd.out;
1910
1911 if (stlen <= wp->msg_rd.next_line - wp->msg_rd.out
1912 && !strncasecmp(wp->msg_rd.out, st, stlen)) {
1913 if (wp->msg_rd.out[stlen] == '\0') {
1914 wp->msg_rd.out += stlen;
1915 return 1;
1916 }
1917
1918 /* skip trailing whitespace */
1919 if (wp->msg_rd.out[stlen] == '\t'
1920 || wp->msg_rd.out[stlen] == ' ') {
1921 do {
1922 ++stlen;
1923 } while (wp->msg_rd.out[stlen] == '\t'
1924 || wp->msg_rd.out[stlen] == ' ');
1925 wp->msg_rd.out += stlen;
1926 return 1;
1927 }
1928 }
1929
1930 return 0;
1931 }
1932
1933
1934
1935 static u_char /* 0=bad recipient */
1936 check_addr(WORK *wp,
1937 const char **addrp, int *addr_lenp,
1938 const char **userp, int *user_lenp)
1939 {
1940 USER_DOMAIN *udom;
1941 const char *atchr, *addr, *cp;
1942 int addr_len, i;
1943
1944 addr = *addrp;
1945 addr_len = *addr_lenp;
1946 if (addr_len > RCTP_MAXNAME-1)
1947 addr_len = *addr_lenp = RCTP_MAXNAME-1;
1948 if (*addr == '<' && addr_len >= 2 && addr[addr_len-1] == '>') {
1949 ++addr;
1950 addr_len -= 2;
1951 if (addr_len == 0) {
1952 if (wp->dfgs & DFG_WORK_LOCK)
1953 unlock_work();
1954 thr_error_msg(&wp->cw, "null recipient address");
1955 if (wp->dfgs & DFG_WORK_LOCK)
1956 lock_work();
1957 return 0;
1958 }
1959 }
1960
1961 /* strip source route from recipient */
1962 while (addr_len != 0
1963 && (cp = memchr(addr, ',', addr_len)) != 0) {
1964 ++cp;
1965 addr_len -= cp-addr;
1966 addr = cp;
1967 *addr_lenp = addr_len;
1968 *addrp = addr;
1969 }
1970
1971 if (addr_len >= RCTP_MAXNAME) {
1972 if (wp->dfgs & DFG_WORK_LOCK)
1973 unlock_work();
1974 thr_error_msg(&wp->cw, "recipient \"%s\" is too long", addr);
1975 if (wp->dfgs & DFG_WORK_LOCK)
1976 lock_work();
1977 return 0;
1978 }
1979 if (addr_len <= 0) {
1980 if (wp->dfgs & DFG_WORK_LOCK)
1981 unlock_work();
1982 thr_error_msg(&wp->cw, "null recipient");
1983 if (wp->dfgs & DFG_WORK_LOCK)
1984 lock_work();
1985 return 0;
1986 }
1987
1988 if (*user_lenp) {
1989 if (*user_lenp > RCTP_MAXNAME-1)
1990 *user_lenp = RCTP_MAXNAME-1;
1991 } else {
1992 /* Use the list of local domain names to guess a user name
1993 * from the recipient address
1994 * Take the whole recipient name if it does not
1995 * include a domain name */
1996 atchr = memchr(addr, '@', addr_len);
1997 if (!atchr) {
1998 *userp = addr;
1999 *user_lenp = addr_len;
2000 return 1;
2001 }
2002
2003 for (udom = user_domains; udom; udom = udom->fwd) {
2004 i = addr_len - udom->len;
2005 if (i > 0 && !strncasecmp(addr+i, udom->nm,
2006 udom->len)) {
2007 if (*udom->nm == '@'
2008 || *udom->nm == '.') {
2009 ; /* got it */
2010 } else {
2011 /* match must start at '.' or '@'
2012 * if target did not start with
2013 * '.' or '@' then the name must
2014 * end with '.' or '@' */
2015 if (i-- < 2
2016 || (addr[i] != '.'
2017 && addr[i] != '@'))
2018 continue;
2019 }
2020 /* we have something like user or user@sub
2021 * from user@sub.domain.com */
2022 *userp = addr;
2023 if (!udom->wildcard) {
2024 *user_lenp = i;
2025 } else {
2026 *user_lenp = atchr - addr;
2027 }
2028 return 1;
2029 }
2030 }
2031 }
2032
2033 return 1;
2034 }
2035
2036
2037
2038 /* The mutex must be locked */
2039 static RCPT_ST *
2040 set_rcpt(WORK *wp,
2041 const char *rcpt, int rcpt_len,
2042 const char *user, int user_len)
2043 {
2044 RCPT_ST *rcpt_st;
2045
2046 rcpt_st = alloc_rcpt_st(&wp->cw, 0);
2047 if (!rcpt_st)
2048 return 0;
2049
2050 ++wp->cw.tgts;
2051 memcpy(rcpt_st->env_to, rcpt, rcpt_len);
2052 rcpt_st->env_to[rcpt_len] = '\0';
2053 if (user_len)
2054 memcpy(rcpt_st->user, user, user_len);
2055 rcpt_st->user[user_len] = '\0';
2056
2057 rcpt_st->dir[0] = '\0';
2058 if (user_len != 0
2059 && !get_user_dir(rcpt_st, user, user_len, 0, 0))
2060 thr_trace_msg(&wp->cw, "%s", wp->cw.emsg);
2061
2062 return rcpt_st;
2063 }
2064
2065
2066
2067 /* read lines of pairs if (env_To, username) values from the MTA */
2068 static void
2069 get_ascii_rcpts(WORK *wp)
2070 {
2071 const char *addr, *user, *user_end;
2072 char c;
2073 int addr_len, user_len;
2074 RCPT_ST *rcpt_st;
2075
2076 lock_work();
2077 wp->dfgs |= DFG_WORK_LOCK;
2078 for (;;) {
2079 ascii_read_line(wp);
2080
2081 /* stop after the empty line */
2082 addr = wp->msg_rd.out;
2083 if (*addr == '\0') {
2084 wp->msg_rd.out = wp->msg_rd.next_line;
2085 break;
2086 }
2087
2088 user_end = wp->msg_rd.next_line;
2089 while (user_end > addr
2090 && ((c = *(user_end-1)) == ' ' || c == '\t'))
2091 --user_end;
2092
2093 /* bytes up to '\r' are the env_To value
2094 * and bytes after are the local recipient */
2095 user = strchr(addr, '\r');
2096 if (!user) {
2097 addr_len = user_end - wp->msg_rd.out;
2098 user = user_end;
2099 } else {
2100 addr_len = user - addr;
2101 ++user;
2102 }
2103
2104 user_len = user_end - user;
2105 if (!check_addr(wp, &addr, &addr_len, &user, &user_len))
2106 job_exit(wp);
2107 rcpt_st = set_rcpt(wp, addr, addr_len, user, user_len);
2108 if (!rcpt_st)
2109 job_exit(wp);
2110
2111 /* Don't worry if this recipient is incompatible with preceding
2112 * recipients, because there is nothing we can do.
2113 * We cannot reject a recipient when the ASCII protocol is used,
2114 * but side effects of the check are required */
2115 cmn_compat_whitelist(&wp->cw, rcpt_st);
2116
2117 wp->msg_rd.out = wp->msg_rd.next_line;
2118 }
2119 unlock_work();
2120 wp->dfgs &= ~DFG_WORK_LOCK;
2121 }
2122
2123
2124
2125 /* We are finished with one SMTP message with the ASCII protocol
2126 * Send the result to the MTA and end this thread */
2127 static void NRATTRIB
2128 ascii_done(WORK *wp, DCCIF_RESULT_CHAR result_char)
2129 {
2130 const char *result_str;
2131 RCPT_ST *rcpt_st;
2132 char *p;
2133
2134 result_str = wp->cw.reply.log_result;
2135 if (!result_str)
2136 thr_error_msg(&wp->cw, "rejection reason undecided");
2137 else
2138 thr_log_print(&wp->cw, 0, DCC_XHDR_RESULT"%s\n", result_str);
2139
2140 /* tell MTA the overall result */
2141 p = wp->msg_rd.base;
2142 *p++ = result_char;
2143 *p++ = '\n';
2144
2145 /* output list of recipients */
2146 for (rcpt_st = wp->cw.rcpt_st_first; rcpt_st; rcpt_st = rcpt_st->fwd) {
2147 if (p >= &wp->msg_rd.base[wp->msg_rd.size-1]) {
2148 buf_write(wp, &wp->msg_wt,
2149 wp->msg_rd.base, wp->msg_rd.size-1);
2150 p = wp->msg_rd.base;
2151 }
2152 if (result_char == DCCIF_RESULT_GREY) {
2153 *p++ = DCCIF_RCPT_GREY;
2154 } else if (rcpt_st->fgs & RCPT_FG_ISSPAM) {
2155 *p++ = DCCIF_RCPT_REJECT;
2156 } else {
2157 *p++ = DCCIF_RCPT_ACCEPT;
2158 }
2159 }
2160 *p++ = '\n';
2161 buf_write(wp, &wp->msg_wt, wp->msg_rd.base, p-wp->msg_rd.base);
2162
2163 /* send the body from the temporary file to the MTA */
2164 if (wp->dfgs & DFG_MTA_BODY) {
2165 body_copy(wp);
2166
2167 } else if (wp->dfgs & DFG_MTA_HEADER) {
2168 /* MTA wants only the header, if we have it */
2169 if (wp->cw.header.used != 0)
2170 buf_write(wp, &wp->msg_wt, wp->cw.header.buf,
2171 wp->cw.header.used);
2172 buf_write(wp, &wp->msg_wt, "\n", 1);
2173 }
2174
2175 job_exit(wp);
2176 }
2177
2178
2179
2180 /* use the dccifd ASCII protocol to talk to an MTA */
2181 static void NRATTRIB
2182 ascii_job(WORK *wp)
2183 {
2184 # define AOPT(s) ascii_opt_str(wp, s, LITZ(s))
2185 char *p;
2186 int i;
2187
2188 log_start(&wp->cw);
2189
2190 wp->msg_rd.base = wp->buf1;
2191 wp->msg_rd.size = sizeof(wp->buf1);
2192 wp->msg_rd.socp = &wp->proxy_in_soc;
2193
2194 wp->msg_wt.base = wp->buf2;
2195 wp->msg_wt.size = sizeof(wp->buf2);
2196 wp->msg_wt.socp = &wp->proxy_in_soc;
2197
2198 /* get any options */
2199 ascii_read_line(wp);
2200 while (*wp->msg_rd.out != '\0') {
2201 if (AOPT(DCCIF_OPT_LOG)) {
2202 wp->cw.ask_st |= ASK_ST_LOGIT;
2203 continue;
2204 }
2205 if (AOPT(DCCIF_OPT_SPAM)) {
2206 wp->cw.ask_st |= ASK_ST_MTA_ISSPAM;
2207 continue;
2208 }
2209 if (AOPT(DCCIF_OPT_BODY)) {
2210 wp->dfgs |= DFG_MTA_BODY;
2211 continue;
2212 }
2213 if (AOPT(DCCIF_OPT_HEADER)) {
2214 wp->dfgs |= DFG_MTA_HEADER;
2215 continue;
2216 }
2217 if (AOPT(DCCIF_OPT_QUERY)) {
2218 wp->cw.ask_st |= ASK_ST_QUERY;
2219 continue;
2220 }
2221 if (AOPT(DCCIF_OPT_GREY_QUERY)) {
2222 wp->cw.ask_st |= ASK_ST_QUERY_GREY;
2223 continue;
2224 }
2225 if (AOPT(DCCIF_OPT_NO_REJECT)) {
2226 wp->cw.action = CMN_IGNORE;
2227 continue;
2228 }
2229 if (AOPT(DCCIF_OPT_RCVD_NXT)
2230 || AOPT(DCCIF_OPT_RCVD_NEXT)) {
2231 ++wp->parse_rcvd;
2232 continue;
2233 }
2234
2235 thr_error_msg(&wp->cw, "unrecognized option value: \"%s\"",
2236 wp->msg_rd.out);
2237 job_exit(wp);
2238 }
2239 if ((wp->cw.ask_st & ASK_ST_MTA_ISSPAM)
2240 && (wp->cw.ask_st & ASK_ST_QUERY)) {
2241 thr_error_msg(&wp->cw, DCCIF_OPT_SPAM" and "DCCIF_OPT_QUERY
2242 " are incompatible");
2243 wp->cw.ask_st &= ~ASK_ST_MTA_ISSPAM;
2244 }
2245 if ((wp->cw.ask_st & ASK_ST_MTA_ISSPAM)
2246 && (wp->cw.ask_st & ASK_ST_QUERY_GREY)) {
2247 thr_error_msg(&wp->cw, DCCIF_OPT_SPAM" and "DCCIF_OPT_GREY_QUERY
2248 " are incompatible");
2249 wp->cw.ask_st &= ~ASK_ST_MTA_ISSPAM;
2250 }
2251 if (dcc_query_only
2252 && (wp->cw.ask_st & ASK_ST_MTA_ISSPAM)) {
2253 thr_error_msg(&wp->cw, DCCIF_OPT_SPAM" and -Q"
2254 " are incompatible");
2255 wp->cw.ask_st &= ~ASK_ST_MTA_ISSPAM;
2256 }
2257 wp->msg_rd.out = wp->msg_rd.next_line;
2258
2259 /* open the connection to the nearest DCC server
2260 * and figure out our X-DCC header */
2261 if (!ck_dcc_ctxt(&wp->cw)) {
2262 /* failed to create context */
2263 make_reply(&wp->cw.reply, &dcc_fail_reply, &wp->cw, 0);
2264 ascii_done(wp, DCCIF_RESULT_TEMP);
2265 }
2266
2267 dcc_cks_init(&wp->cw.cks);
2268 dcc_dnsbl_init(&wp->cw.cks, wp->cw.dcc_ctxt, &wp->cw, wp->cw.id);
2269 wp->cw.cmn_fgs |= CMN_FG_LOG_EARLY;
2270
2271 /* get the SMTP client IP address and host name */
2272 i = ascii_read_line(wp);
2273 if (i == 0
2274 || !strcmp("0.0.0.0", wp->msg_rd.out)
2275 || !strcmp("0.0.0.0\r0.0.0.0", wp->msg_rd.out)) {
2276 /* it is absent or the SpamAssassin junk */
2277 wp->dfgs |= DFG_PARSE_RCVD; /* try a Received header */
2278 } else {
2279 /* the host name follows the IP address */
2280 p = strchr(wp->msg_rd.out, '\r');
2281 if (p) {
2282 *p++ = '\0';
2283 BUFCPY(wp->cw.clnt_name, p);
2284 }
2285 /* convert ASCCI representation of IP address to a
2286 * canonical form and to a checksum */
2287 if (!dcc_get_str_ip_ck(&wp->cw.cks, wp->msg_rd.out)) {
2288 thr_error_msg(&wp->cw, "unrecognized IP address \"%s\"",
2289 wp->msg_rd.out);
2290 } else {
2291 /* convert IPv6 address to a canonical string */
2292 wp->cw.clnt_addr = wp->cw.cks.ip_addr;
2293 dcc_ipv6tostr(wp->cw.clnt_str, sizeof(wp->cw.clnt_str),
2294 &wp->cw.clnt_addr);
2295 }
2296 }
2297 wp->msg_rd.out = wp->msg_rd.next_line;
2298
2299 /* get the HELO value */
2300 i = ascii_read_line(wp);
2301 get_helo(wp, wp->msg_rd.out, i);
2302 wp->msg_rd.out = wp->msg_rd.next_line;
2303
2304 /* get the envelope Mail_From value */
2305 i = ascii_read_line(wp);
2306 if (i > ISZ(wp->cw.env_from)-1)
2307 i = ISZ(wp->cw.env_from)-1;
2308 memcpy(wp->cw.env_from, wp->msg_rd.out, i);
2309 wp->cw.env_from[i] = '\0';
2310 wp->msg_rd.out = wp->msg_rd.next_line;
2311
2312 get_sender(wp);
2313
2314 /* get the list of recipients from the MTA */
2315 get_ascii_rcpts(wp);
2316
2317 if (!get_body(wp)) {
2318 /* something wrong while collecting the message body
2319 * such as contacting the DCC server */
2320 ascii_done(wp, DCCIF_RESULT_TEMP);
2321 }
2322
2323 /* get consensus of targets' wishes */
2324 users_process(&wp->cw);
2325 totals.tgts_rejected += wp->cw.reject_tgts;
2326 /* log the consensus & generate SMTP rejection message if needed */
2327 users_log_result(&wp->cw, 0);
2328
2329 if (wp->cw.ask_st & ASK_ST_GREY_EMBARGO) {
2330 totals.tgts_embargoed += wp->cw.tgts;
2331 ascii_done(wp, DCCIF_RESULT_GREY);
2332 }
2333
2334 if (wp->cw.reject_tgts != 0
2335 || (wp->cw.tgts == 0 && (wp->cw.ask_st & ASK_ST_CLNT_ISSPAM))) {
2336 if (wp->cw.action != CMN_IGNORE) {
2337 if (!wp->cw.reply.log_result)
2338 wp->cw.reply.log_result=DCC_XHDR_RESULT_REJECT;
2339 ascii_done(wp, DCCIF_RESULT_REJECT);
2340 } else {
2341 wp->cw.reply.log_result = DCC_XHDR_RESULT_I_A;
2342 ascii_done(wp, DCCIF_RESULT_OK);
2343 }
2344 }
2345
2346 wp->cw.reply.log_result = DCC_XHDR_RESULT_ACCEPT;
2347 ascii_done(wp, DCCIF_RESULT_OK);
2348
2349 # undef AOPT
2350 }
2351
2352
2353
2354 #define SMTP_REPLY_221 "221 dccifd closing connection"
2355 #define SMTP_REPLY_220 "220 dccifd proxy ready"
2356 #define SMTP_REPLY_250_DATA "250 dccifd mail ok"
2357 #define SMTP_REPLY_250_RSET "250 dccifd RSET ok"
2358 #define SMTP_REPLY_250_HELO "250 dccifd HELO ok"
2359 #define SMTP_REPLY_250_POSTFIX "250 dccifd Postfix extension ok"
2360 #define SMTP_REPLY_250_RCPT "250 dccifd Recipient ok"
2361 #define SMTP_REPLY_250_MAIL "250 dccifd Sender ok"
2362 #define SMTP_REPLY_350 "354 Enter mail to dccifd"
2363 #define SMTP_REPLY_452_WLIST "452 4.5.3 "DCC_XHDR_INCOMPAT_WLIST
2364 #define SMTP_REPLY_452_2MANY "452 4.5.3 "DCC_XHDR_TOO_MANY_RCPTS
2365 #define SMTP_REPLY_500 "500 5.0.0 dccifd command unrecognized"
2366 #define SMTP_REPLY_501_NO_ARG "501 5.5.4 dccifd command arg required"
2367 #define SMTP_REPLY_501_BAD_ARG "501 5.5.1 dccifd command unrecognized"
2368 #define SMTP_REPLY_501_RCPT "501 5.5.2 dccifd RCPT command syntax error"
2369 #define SMTP_REPLY_501_POSTFIX "501 5.5.2 dccifd Postfix extension syntax error"
2370 #define SMTP_REPLY_503_DATA "503 5.0.0 dccifd need RCPT"
2371 #define SMTP_REPLY_503 "503 5.0.0 bad dccifd command sequence"
2372
2373 #define SMTP_DEBUG_TRACE 3
2374
2375
2376 static void
2377 smtp_trace(WORK *wp, const char *type, const char *buf, int len)
2378 {
2379 if (dcc_clnt_debug < SMTP_DEBUG_TRACE)
2380 return;
2381
2382 log_start(&wp->cw);
2383 if (len > 0 && buf[len-1] == '\n')
2384 --len;
2385 if (len > 0 && buf[len-1] == '\r')
2386 --len;
2387 thr_trace_msg(&wp->cw, "%s %s: %.*s", wp->cw.id, type, len, buf);
2388 }
2389
2390
2391
2392 /* send an SMTP reply upstream to the SMTP client of our proxy */
2393 static void
2394 smtp_send_reply(WORK *wp, const char *reply, int len)
2395 {
2396 if (dcc_clnt_debug >= SMTP_DEBUG_TRACE)
2397 smtp_trace(wp, "SMTP response", reply, len);
2398 buf_write(wp, &wp->reply_out, reply, len);
2399 buf_write(wp, &wp->reply_out, "\r\n", 2);
2400 }
2401
2402 #define SMTP_REPLY(r) smtp_send_reply(wp,SMTP_REPLY_##r,LITZ(SMTP_REPLY_##r))
2403
2404 static void
2405 smtp_reply_error(WORK *wp, const char *reply, int len)
2406 {
2407 smtp_send_reply(wp, reply, len);
2408 wp->msg_rd.out = wp->msg_rd.next_line;
2409 wp->smtp_state = SMTP_ST_ERROR;
2410 if (dcc_clnt_debug)
2411 wp->cw.ask_st |= ASK_ST_LOGIT;
2412 /* depend on '\n' ending the SMTP message */
2413 thr_log_print(&wp->cw, 1, "%s", reply);
2414 }
2415
2416 #define SMTP_ERROR(r) smtp_reply_error(wp,SMTP_REPLY_##r,LITZ(SMTP_REPLY_##r))
2417
2418
2419
2420 /* look for an SMTP verb */
2421 typedef enum {
2422 SMTP_VERB_ERR, /* bad command */
2423 SMTP_VERB_UNREC, /* unrecognized command */
2424 SMTP_VERB_RSET,
2425 SMTP_VERB_HELO,
2426 SMTP_VERB_XCLIENT, /* Postfix extension */
2427 SMTP_VERB_XFORWARD, /* Postfix extension */
2428 SMTP_VERB_MAIL, /* Mail From */
2429 SMTP_VERB_RCPT, /* Rcpt To */
2430 SMTP_VERB_DATA,
2431 SMTP_VERB_QUIT
2432 } VERB_SMTP;
2433 typedef struct {
2434 const char *str;
2435 int str_len;
2436 const char *parm;
2437 int parm_len;
2438 VERB_SMTP verb;
2439 u_char arg_required;
2440 } PT;
2441 PT pt[] = {
2442 #define PT_M(s,p,v,r) {s,LITZ(s),p,LITZ(p),SMTP_VERB_##v,r}
2443 PT_M("HELO","", HELO, 1),
2444 PT_M("EHLO","", HELO, 1),
2445 PT_M("Mail","From:", MAIL, 1),
2446 PT_M("Rcpt","To:", RCPT, 1),
2447 PT_M("DATA","", DATA, 0),
2448 PT_M("XFORWARD","", XFORWARD, 1),
2449 PT_M("XCLIENT","", XCLIENT, 1),
2450 PT_M("RSET","", RSET, 0),
2451 PT_M("QUIT","", QUIT, 0),
2452 #undef PT_M
2453 };
2454
2455 #define RESP_DIGIT(c) ((c) >= '0' && (c) <= '9')
2456
2457 static VERB_SMTP
2458 get_smtp_verb(WORK *wp,
2459 const char **ppp, /* parameter after command */
2460 const char **pep) /* end of parameter */
2461 {
2462 PT *ptp;
2463 const char *lp, *pp;
2464 int i, len;
2465
2466 /* skip leading whitespace */
2467 wp->msg_rd.out += strspn(wp->msg_rd.out, " \t");
2468 lp = wp->msg_rd.out;
2469
2470 if (dcc_clnt_debug >= SMTP_DEBUG_TRACE)
2471 smtp_trace(wp, "SMTP command", lp, wp->msg_rd.next_line - lp);
2472
2473 for (ptp = pt; ptp < &pt[DIM(pt)]; ++ptp) {
2474 len = ptp->str_len;
2475 pp = lp+len;
2476 if (pp+2 > wp->msg_rd.next_line
2477 || strncasecmp(lp, ptp->str, len))
2478 continue;
2479
2480 if (pp+2 == wp->msg_rd.next_line) {
2481 /* SMTP command by itself on the line */
2482 *ppp = 0;
2483 *pep = 0;
2484 if (ptp->arg_required) {
2485 SMTP_REPLY(501_NO_ARG);
2486 return SMTP_VERB_ERR;
2487 }
2488 /* finished, having matched the command */
2489 return ptp->verb;
2490 }
2491
2492 /* all other commands require following text separated
2493 * from the command with whitespace, as in "Mail From:" */
2494 i = strspn(pp, " \t");
2495 if (i == 0)
2496 continue;
2497 pp += i;
2498
2499 /* skip the initial part of the parameter, such as "From:" */
2500 if (ptp->parm_len) {
2501 if (*pp == '\r') {
2502 SMTP_REPLY(501_NO_ARG);
2503 return SMTP_VERB_ERR;
2504 }
2505 if (strncasecmp(pp, ptp->parm, ptp->parm_len)) {
2506 SMTP_REPLY(501_BAD_ARG);
2507 return SMTP_VERB_ERR;
2508 }
2509 pp += ptp->parm_len;
2510 pp += strspn(pp, " \t");
2511 }
2512
2513 *ppp = pp;
2514 *pep = strpbrk(pp, " \t\r");
2515 return ptp->verb;
2516 }
2517
2518 *ppp = 0;
2519 return SMTP_VERB_UNREC;
2520 }
2521
2522
2523
2524 /* reset and restart the SMTP proxy state */
2525 static void
2526 proxy_rset(WORK *wp)
2527 {
2528 if (wp->smtp_state == SMTP_ST_START)
2529 return;
2530
2531 cmn_clear(&wp->cw, wp, 0);
2532 wp->dfgs &= DFG_RECYCLE;
2533 wp->smtp_state = SMTP_ST_START;
2534
2535 dcc_cks_init(&wp->cw.cks);
2536 dcc_dnsbl_init(&wp->cw.cks, wp->cw.dcc_ctxt, &wp->cw, wp->cw.id);
2537 wp->cw.cmn_fgs |= CMN_FG_LOG_EARLY;
2538
2539 /* Values from the Postfix XCLIENT ESMTP extension endure for the
2540 * entire session. Values from the XFORWARD extension or guesses from
2541 * a HELO command are cleared at the end of the SMTP transaction. */
2542 if (!(wp->dfgs & DFG_XCLIENT_NAME))
2543 wp->cw.clnt_name[0] = '\0';
2544 if (wp->dfgs & DFG_XCLIENT_ADDR) {
2545 dcc_get_ipv6_ck(&wp->cw.cks, &wp->cw.clnt_addr);
2546 } else {
2547 memset(&wp->cw.clnt_addr, 0, sizeof(wp->cw.clnt_addr));
2548 wp->cw.clnt_str[0] = '\0';
2549 }
2550 if (!(wp->dfgs & DFG_XCLIENT_HELO))
2551 wp->cw.helo[0] = '\0';
2552 }
2553
2554
2555
2556 /* deal with aborted SMTP sessions */
2557 static void
2558 proxy_abort(WORK *wp, const char *log_msg)
2559 {
2560 if (dcc_clnt_debug >= SMTP_DEBUG_TRACE)
2561 smtp_trace(wp, "reset", log_msg, strlen(log_msg));
2562
2563 if (wp->smtp_state != SMTP_ST_START
2564 && wp->smtp_state != SMTP_ST_HELO
2565 && wp->smtp_state != SMTP_ST_ERROR) {
2566
2567 wp->cw.ask_st |= ASK_ST_INVALID_MSG;
2568
2569 if (!(wp->cw.cmn_fgs & CMN_FG_ENV_LOGGED))
2570 thr_log_envelope(&wp->cw, 1);
2571 dcc_cks_fin(&wp->cw.cks);
2572 LOG_CAPTION(wp, "\n"DCC_LOG_MSG_SEP);
2573 thr_log_late(&wp->cw);
2574 cmn_ask_white(&wp->cw);
2575
2576 users_process(&wp->cw);
2577 users_log_result(&wp->cw, log_msg);
2578
2579 /* create log files for -d
2580 * and without any recipents but with "option log-all" */
2581 if (dcc_clnt_debug
2582 || (wp->cw.init_sws & FLTR_SW_LOG_ALL))
2583 wp->cw.ask_st |= ASK_ST_LOGIT;
2584
2585 if (wp->cw.ask_st & ASK_ST_LOGIT)
2586 thr_log_print(&wp->cw, 0,
2587 DCC_XHDR_RESULT"%s\n", log_msg);
2588 }
2589 proxy_rset(wp);
2590 }
2591
2592
2593
2594 /* quit a truncated message */
2595 static void NRATTRIB
2596 proxy_msg_truncated(WORK *wp)
2597 {
2598 if (!proxy) {
2599 thr_error_msg(&wp->cw, "truncated message");
2600 } else {
2601 proxy_abort(wp, "SMTP session aborted");
2602 }
2603 job_exit(wp);
2604 }
2605
2606
2607
2608 /* pass a line from the downstream proxy to our upstream */
2609 static void
2610 smtp_pass_line(WORK *wp)
2611 {
2612 int len;
2613
2614 len = wp->reply_in.next_line - wp->reply_in.out;
2615 if (dcc_clnt_debug >= SMTP_DEBUG_TRACE)
2616 smtp_trace(wp, "pass SMTP response", wp->reply_in.out, len);
2617
2618 buf_write(wp, &wp->reply_out, wp->reply_in.out,
2619 wp->reply_in.next_line - wp->reply_in.out);
2620
2621 wp->reply_in.out = wp->reply_in.next_line;
2622 }
2623
2624
2625
2626 static int /* -1 or 1st digit of response */
2627 smtp_get_resp(WORK *wp,
2628 u_char pass, /* 1=pass it upstream */
2629 char *logbuf, /* log response here */
2630 int logbuflen)
2631 {
2632 int len;
2633 char dig, cont;
2634
2635 for (;;) {
2636 if (!msg_read_line(wp, &wp->reply_in)) {
2637 if (pass)
2638 job_exit(wp);
2639 return -1;
2640 }
2641 len = wp->reply_in.next_line - wp->reply_in.out;
2642 if (len < 5) {
2643 thr_error_msg(&wp->cw, "short SMTP response"
2644 " \"%s\" from proxy server",
2645 wp->reply_in.out);
2646 return -1;
2647 }
2648 dig = wp->reply_in.out[0];
2649 cont = wp->reply_in.out[3];
2650 if ((dig < '1' || dig > '5')
2651 || !RESP_DIGIT(wp->reply_in.out[1])
2652 || !RESP_DIGIT(wp->reply_in.out[2])
2653 || (cont != ' ' && cont != '-')) {
2654 *wp->reply_in.next_line = '\0';
2655 thr_error_msg(&wp->cw, "unrecognized SMTP response"
2656 " \"%s\" from proxy",
2657 wp->reply_in.out);
2658 return -1;
2659 }
2660
2661 if (logbuflen != 0) {
2662 if (logbuflen > len)
2663 logbuflen = len;
2664 memcpy(logbuf, wp->reply_in.out, logbuflen);
2665 while (logbuflen > 0
2666 && (logbuf[logbuflen-1] == '\r'
2667 || logbuf[logbuflen-1] == '\n'))
2668 --logbuflen;
2669 logbuf[logbuflen] = '\0';
2670
2671 /* log only the first line */
2672 logbuflen = 0;
2673 }
2674
2675 if (pass) {
2676 /* pass the next line upstream */
2677 smtp_pass_line(wp);
2678 if (cont == ' ')
2679 return dig;
2680 } else {
2681 /* we don't like multi-line responses */
2682 if (cont == ' ')
2683 return dig;
2684
2685 *wp->reply_in.next_line = '\0';
2686 thr_error_msg(&wp->cw, "unacceptable multi-line"
2687 " SMTP response"
2688 " \"%s\" from proxy",
2689 wp->reply_in.out);
2690 return -1;
2691 }
2692 }
2693 }
2694
2695
2696
2697 /* pass an SMTP command from upstream or the SMTP client of our proxy
2698 * downstream to the SMTP server of our proxy.
2699 * Then relay the SMTP server's response upstream to the SMTP client */
2700 static u_char /* 0=server was unhappy */
2701 smtp_pass_cmd(WORK *wp,
2702 const char *reply, /* send this response upstream if */
2703 int reply_len, /* if downstream is happy */
2704 char *logbuf, /* logbuf response here */
2705 int logbuflen)
2706 {
2707 int len, result;
2708
2709 /* fake it if the SMTP server is /dev/null */
2710 if (proxy_out_family == AF_UNSPEC) {
2711 smtp_send_reply(wp, reply, reply_len);
2712 return 1;
2713 }
2714
2715 len = wp->msg_rd.next_line - wp->msg_rd.out;
2716 if (len != 0) {
2717 buf_write(wp, &wp->msg_wt, wp->msg_rd.out, len);
2718 buf_write_flush(wp, &wp->msg_wt);
2719 }
2720
2721 /* wait for & pass on response */
2722 result = smtp_get_resp(wp, 1, logbuf, logbuflen);
2723 if (result < 0)
2724 job_exit(wp);
2725 return (result == reply[0]);
2726 }
2727
2728 #define SMTP_PASS_CMD(r) smtp_pass_cmd(wp,SMTP_REPLY_##r,LITZ(SMTP_REPLY_##r), \
2729 0, 0)
2730
2731
2732
2733 /* parse Postfix XFORWARD and XCLIENT commands
2734 * see http://www.postfix.org/XCLIENT_README.html
2735 * and http://www.postfix.org/XFORWARD_README.html
2736 * Depend on the Postfix downstream to answer EHLO with XFORWRD */
2737 static void
2738 smtp_xpostfix(WORK *wp,
2739 VERB_SMTP verb, /* SMTP_VERB_XFORWARD or _XCLIENT */
2740 const char *parm)
2741 {
2742 const char *val, *end_parm;
2743 char addr[INET6_ADDRSTRLEN+1];
2744 int i;
2745
2746 wp->smtp_state = SMTP_ST_HELO;
2747
2748 for (; ; parm = end_parm + strspn(end_parm, " \t")) {
2749 if (*parm == '\r' || *parm == '\n') {
2750 SMTP_PASS_CMD(250_POSTFIX);
2751 break;
2752 }
2753
2754 /* find the value */
2755 val = strpbrk(parm, "= \t\r\n");
2756 if (*val++ != '=') {
2757 SMTP_REPLY(501_POSTFIX);
2758 break;
2759 }
2760
2761 end_parm = strpbrk(val, " \t\r\n");
2762
2763 if (!CLITCMP(parm, "NAME=")) {
2764 if (!CLITCMP(val, "[UNAVAILABLE]")
2765 || !CLITCMP(val, "[TEMPUNAVAIL]")) {
2766 wp->cw.clnt_name[0] = '\0';
2767 continue;
2768 }
2769 i = min(ISZ(wp->cw.clnt_name)-1, end_parm-val);
2770 memcpy(wp->cw.clnt_name, val, i);
2771 wp->cw.clnt_name[i] = '\0';
2772 if (verb == SMTP_VERB_XCLIENT)
2773 wp->dfgs |= DFG_XCLIENT_NAME;
2774 else
2775 wp->dfgs &= ~DFG_XCLIENT_NAME;
2776 continue;
2777 }
2778
2779 if (!CLITCMP(parm, "ADDR=")) {
2780 if (!CLITCMP(val, "[UNAVAILABLE]")
2781 || !CLITCMP(val, "[TEMPUNAVAIL]")) {
2782 wp->cw.clnt_str[0] = '\0';
2783 continue;
2784 }
2785 if (!CLITCMP(val, "IPV6"))
2786 val += LITZ("IPV6");
2787 i = min(ISZ(addr)-1, end_parm-val);
2788 memcpy(addr, val, i);
2789 addr[i] = '\0';
2790 /* try to convert ASCCI representation of IP address to
2791 * a canonical form and to a checksum */
2792 if (!dcc_get_str_ip_ck(&wp->cw.cks, addr)) {
2793 thr_error_msg(&wp->cw,
2794 "unrecognized IP address \"%s\"",
2795 addr);
2796 wp->cw.clnt_str[0] = '\0';
2797 continue;
2798 }
2799 wp->cw.clnt_addr = wp->cw.cks.ip_addr;
2800 dcc_ipv6tostr(wp->cw.clnt_str, sizeof(wp->cw.clnt_str),
2801 &wp->cw.clnt_addr);
2802 if (verb == SMTP_VERB_XCLIENT) {
2803 wp->dfgs |= DFG_XCLIENT_ADDR;
2804 } else {
2805 wp->dfgs &= ~DFG_XCLIENT_ADDR;
2806 }
2807 continue;
2808 }
2809
2810 if (!CLITCMP(parm, "HELO=")) {
2811 if (!CLITCMP(val, "[UNAVAILABLE]")
2812 || !CLITCMP(val, "[TEMPUNAVAIL]")) {
2813 wp->cw.helo[0] = '\0';
2814 } else {
2815 get_helo(wp, val, end_parm-val);
2816 }
2817 if (verb == SMTP_VERB_XCLIENT)
2818 wp->dfgs |= DFG_XCLIENT_HELO;
2819 else
2820 wp->dfgs &= ~DFG_XCLIENT_HELO;
2821 continue;
2822 }
2823 }
2824
2825 wp->msg_rd.out = wp->msg_rd.next_line;
2826 }
2827
2828
2829
2830 /* parse SMTP Rcpt_To command */
2831 static u_char /* 1=now seen >=1 good Rcpt command*/
2832 get_smtp_rcpt(WORK *wp,
2833 const char *path,
2834 const char *epath)
2835 {
2836 const char *user;
2837 int path_len, user_len;
2838 RCPT_ST *rcpt_st;
2839
2840 path_len = epath - path;
2841 user = "";
2842 user_len = 0;
2843 if (!check_addr(wp, &path, &path_len, &user, &user_len)) {
2844 SMTP_REPLY(501_RCPT);
2845 wp->msg_rd.out = wp->msg_rd.next_line;
2846 return 0;
2847 }
2848
2849 lock_work();
2850 wp->dfgs |= DFG_WORK_LOCK;
2851 rcpt_st = set_rcpt(wp, path, path_len, user, user_len);
2852 unlock_work();
2853 wp->dfgs &= ~DFG_WORK_LOCK;
2854 if (!rcpt_st) {
2855 SMTP_REPLY(452_2MANY);
2856 wp->msg_rd.out = wp->msg_rd.next_line;
2857 return 0;
2858 }
2859
2860 /* if this recipient is incompatible with preceding recipients
2861 * then reject it and remember to put something into the log */
2862 if (!cmn_compat_whitelist(&wp->cw, rcpt_st)) {
2863 --wp->cw.tgts;
2864 SMTP_REPLY(452_WLIST);
2865 wp->msg_rd.out = wp->msg_rd.next_line;
2866 BUFCPY(rcpt_st->rej_msg, SMTP_REPLY_452_WLIST);
2867 rcpt_st->rej_result = DCC_XHDR_INCOMPAT_WLIST;
2868 rcpt_st->fgs |= RCPT_FG_REJ_FILTER;
2869 return 0;
2870 }
2871
2872 /* Try to pass the command in the buffer downstream.
2873 * Forget this recipient if it is not good enough downstream.
2874 * Let the downstream proxy do its own logging.
2875 * That way we need save only one bit instead of an SMTP
2876 * rejection message for our eventual per-user log file. */
2877 if (!smtp_pass_cmd(wp, SMTP_REPLY_250_RCPT, LITZ(SMTP_REPLY_250_RCPT),
2878 rcpt_st->rej_msg, sizeof(rcpt_st->rej_msg))) {
2879 --wp->cw.tgts;
2880 wp->msg_rd.out = wp->msg_rd.next_line;
2881 rcpt_st->rej_result = rcpt_st->rej_msg;
2882 rcpt_st->rej_result += strspn(rcpt_st->rej_result,
2883 "0123456789. ");
2884 if (rcpt_st->rej_msg[0] != '4')
2885 ++wp->cw.mta_rej_tgts;
2886 wp->cw.ask_st |= ASK_ST_LOGIT;
2887 rcpt_st->fgs |= RCPT_FG_REJ_FILTER;
2888 return 0;
2889 }
2890
2891 /* there was no problem if the downstream was happy */
2892 rcpt_st->rej_msg[0] = '\0';
2893
2894 wp->msg_rd.out = wp->msg_rd.next_line;
2895 return 1;
2896 }
2897
2898
2899
2900 static void
2901 smtp_data_abort(WORK *wp)
2902 {
2903 /* After a rejection Postfix wants a before-queue proxy to
2904 * "abort the connnection" to the SMTP server downstream.
2905 * That might mean a simple TCP shutdown, but for testing with
2906 * sendmail, send an SMTP RSET command. */
2907 if (proxy_out_family != AF_UNSPEC) {
2908 buf_write(wp, &wp->msg_wt, "RSET\r\n", LITZ("RSET\r\n"));
2909 buf_write_flush(wp, &wp->msg_wt);
2910 /* sendmail will respond, but what about Postfix? */
2911 if (smtp_get_resp(wp, 0, 0, 0) >= 0
2912 && dcc_clnt_debug >= SMTP_DEBUG_TRACE) {
2913 smtp_trace(wp, "ignore response to RSET",
2914 wp->reply_in.out,
2915 wp->reply_in.next_line
2916 - wp->reply_in.out);
2917 wp->reply_in.out = wp->reply_in.next_line;
2918 }
2919 }
2920 }
2921
2922
2923
2924 /* We are rejecting the transaction with our generated reply */
2925 static void
2926 smtp_trans_reject(WORK *wp)
2927 {
2928 if (dcc_clnt_debug >= SMTP_DEBUG_TRACE)
2929 thr_trace_msg(&wp->cw, "%s SMTP response: %s %s %s",
2930 wp->cw.id,
2931 wp->cw.reply.rcode, wp->cw.reply.xcode,
2932 wp->cw.reply.str);
2933
2934 if (wp->proxy_in_soc >= 0) {
2935 buf_write(wp, &wp->reply_out,
2936 wp->cw.reply.rcode, strlen(wp->cw.reply.rcode));
2937 buf_write(wp, &wp->reply_out, " ", 1);
2938 buf_write(wp, &wp->reply_out,
2939 wp->cw.reply.xcode, strlen(wp->cw.reply.xcode));
2940 buf_write(wp, &wp->reply_out, " ", 1);
2941 buf_write(wp, &wp->reply_out,
2942 wp->cw.reply.str, strlen(wp->cw.reply.str));
2943 buf_write(wp, &wp->reply_out, "\r\n", 2);
2944 buf_write_flush(wp, &wp->reply_out);
2945 log_smtp_reply(&wp->cw);
2946 }
2947
2948 if (wp->proxy_out_soc >= 0)
2949 smtp_data_abort(wp);
2950 }
2951
2952
2953
2954 static void NRATTRIB
2955 smtp_temp_fail(WORK *wp)
2956 {
2957 make_reply(&wp->cw.reply, &dcc_fail_reply, &wp->cw, 0);
2958 smtp_trans_reject(wp);
2959 job_exit(wp);
2960 }
2961
2962
2963
2964 /* Send the mail message to the SMTP server for our proxy. */
2965 static const char *
2966 smtp_data_send(WORK *wp)
2967 {
2968 int class;
2969 int len;
2970 const char *result;
2971
2972 /* First send the DATA command. */
2973 buf_write(wp, &wp->msg_wt, "DATA\r\n", LITZ("DATA\r\n"));
2974 buf_write_flush(wp, &wp->msg_wt);
2975
2976 /* the server should respond with a 350 result */
2977 class = smtp_get_resp(wp, 0, 0, 0);
2978 if (class < 0)
2979 job_exit(wp);
2980
2981 if (class == '3') {
2982 wp->reply_in.out = wp->reply_in.next_line;
2983
2984 /* send the mail message to the SMTP server */
2985 body_copy(wp);
2986 buf_write(wp, &wp->msg_wt, ".\r\n", 3);
2987 buf_write_flush(wp, &wp->msg_wt);
2988
2989 /* see what it has to say */
2990 class = smtp_get_resp(wp, 0, 0, 0);
2991
2992 } else if (class != '4' && class != '5') {
2993 /* or quit if response to DATA was not 4yz or 5yz */
2994 thr_error_msg(&wp->cw, "unrecognized SMTP response"
2995 " \"%s\" from proxy to DATA command",
2996 wp->reply_in.out);
2997 job_exit(wp);
2998 }
2999
3000 if (class == '2') {
3001 result = DCC_XHDR_RESULT_ACCEPT;
3002 } else {
3003 len = wp->reply_in.next_line - wp->reply_in.out;
3004 while (len > 0 && (wp->reply_in.out[len-1] == '\r'
3005 || wp->reply_in.out[len-1] == '\n'))
3006 --len;
3007 if (len > ISZ(wp->cw.reply.str)-2)
3008 len = ISZ(wp->cw.reply.str)-2;
3009 memcpy(wp->cw.reply.str_buf, wp->reply_in.out, len);
3010 wp->cw.reply.str_buf[len++] = '\n';
3011 wp->cw.reply.str_buf[len] = '\0';
3012 wp->cw.reply.str = wp->cw.reply.str_buf;
3013 thr_log_print(&wp->cw, 0,
3014 "SMTP server "DCC_XHDR_REJ_DATA_MSG"%.*s",
3015 len, wp->cw.reply.str);
3016 if (dcc_clnt_debug)
3017 wp->cw.ask_st |= ASK_ST_LOGIT;
3018 result = "rejected by SMTP server";
3019 }
3020
3021 /* pass SMTP server's response to the SMTP client */
3022 smtp_pass_line(wp);
3023
3024 return result;
3025 }
3026
3027
3028
3029 static void
3030 smtp_data(WORK *wp)
3031 {
3032 const char *global_result, *user_result;
3033
3034 if (!wp->cw.num_rcpts) {
3035 /* never got SMTP DATA command */
3036 SMTP_ERROR(503_DATA);
3037 return;
3038 }
3039
3040 /* tell STMP client to send the mail message */
3041 wp->msg_rd.out = wp->msg_rd.next_line;
3042 SMTP_REPLY(350);
3043 buf_write_flush(wp, &wp->reply_out);
3044
3045 if (!get_body(wp)) {
3046 /* something went wrong while collecting the message body
3047 * such as contacting the DCC server */
3048 smtp_temp_fail(wp);
3049 return;
3050 }
3051
3052 /* get consensus of targets' wishes */
3053 users_process(&wp->cw);
3054
3055 if (wp->cw.ask_st & ASK_ST_GREY_EMBARGO) {
3056 totals.tgts_embargoed += wp->cw.tgts;
3057 smtp_trans_reject(wp);
3058 global_result = wp->cw.reply.log_result;
3059 user_result = global_result;
3060
3061 } else if (wp->cw.reject_tgts != 0) {
3062 switch (wp->cw.action) {
3063 case CMN_IGNORE:
3064 totals.tgts_ignored += wp->cw.reject_tgts;
3065 ++totals.msgs_spam;
3066 if (proxy_out_family == AF_UNSPEC) {
3067 SMTP_REPLY(250_DATA);
3068 global_result = DCC_XHDR_RESULT_I_A;
3069 } else {
3070 global_result = smtp_data_send(wp);
3071 }
3072 user_result = global_result;
3073 break;
3074
3075 case CMN_DISCARD:
3076 totals.tgts_discarded += wp->cw.reject_tgts;
3077 ++totals.msgs_spam;
3078 /* discard the message by aborting the downstream
3079 * SMTP session and telling the upstream 250-OK */
3080 if (proxy_out_family != AF_UNSPEC)
3081 smtp_data_abort(wp);
3082 SMTP_REPLY(250_DATA);
3083 global_result = DCC_XHDR_RESULT_DISCARD;
3084 user_result = global_result;
3085 break;
3086
3087 case CMN_REJECT:
3088 default:
3089 totals.tgts_rejected += wp->cw.reject_tgts;
3090 ++totals.msgs_spam;
3091 smtp_trans_reject(wp);
3092 global_result = wp->cw.reply.log_result;
3093 user_result = 0;
3094 break;
3095 }
3096
3097 } else if (proxy_out_family == AF_UNSPEC) {
3098 SMTP_REPLY(250_DATA);
3099 global_result = DCC_XHDR_RESULT_ACCEPT;
3100 user_result = 0;
3101
3102 } else {
3103 global_result = smtp_data_send(wp);
3104 user_result = 0;
3105 }
3106
3107 /* log the consensus & generate SMTP rejection message if needed */
3108 users_log_result(&wp->cw, user_result);
3109 thr_log_print(&wp->cw, 0, DCC_XHDR_RESULT"%s\n", global_result);
3110
3111 proxy_rset(wp);
3112 }
3113
3114
3115
3116 /* use a subset of SMTP to talk to an MTA */
3117 static void NRATTRIB
3118 proxy_job(WORK *wp)
3119 {
3120 char str[DCC_SU2STR_SIZE];
3121 DCC_SOCKU su;
3122 int out_soc;
3123 VERB_SMTP verb;
3124 const char *parmp, *eparmp;
3125 int i;
3126
3127 wp->msg_rd.base = wp->buf1;
3128 wp->msg_rd.size = sizeof(wp->buf1);
3129 wp->msg_rd.socp = &wp->proxy_in_soc;
3130
3131 wp->msg_wt.base = wp->buf2;
3132 wp->msg_wt.size = sizeof(wp->buf2);
3133 wp->msg_wt.socp = &wp->proxy_out_soc;
3134
3135 wp->reply_in.base = wp->buf3;
3136 wp->reply_in.size = sizeof(wp->buf3);
3137 wp->reply_in.socp = &wp->proxy_out_soc;
3138
3139 wp->reply_out.base = wp->buf4;
3140 wp->reply_out.size = sizeof(wp->buf4);
3141 wp->reply_out.socp = &wp->proxy_in_soc;
3142
3143 if (proxy_out_family == AF_UNSPEC) {
3144 /* single-ended */
3145 ;
3146
3147 } else if (proxy_out_family == AF_UNIX) {
3148 out_soc = socket(AF_UNIX, SOCK_STREAM, 0);
3149 if (out_soc < 0) {
3150 thr_error_msg(&wp->cw, "proxy_out socket(AF_UNIX): %s",
3151 ERROR_STR());
3152 smtp_temp_fail(wp);
3153 }
3154 if (0 > connect(out_soc,
3155 (struct sockaddr *)&proxy_out_sun,
3156 sizeof(listen_sun))) {
3157 thr_error_msg(&wp->cw,
3158 "proxy_out connect(AF_UNIX,%s): %s",
3159 proxy_out_sun.sun_path,
3160 ERROR_STR());
3161 close(out_soc);
3162 smtp_temp_fail(wp);
3163 }
3164 if (!set_soc(wp->cw.emsg, out_soc, AF_UNIX,
3165 "proxy output")) {
3166 thr_error_msg(&wp->cw, "%s", wp->cw.emsg);
3167 close(out_soc);
3168 smtp_temp_fail(wp);
3169 }
3170 wp->proxy_out_soc = out_soc;
3171 wp->dfgs |= DFG_MTA_BODY;
3172
3173 } else {
3174 if (proxy_out_su.sa.sa_family == AF_UNSPEC) {
3175 /* use SMTP client's IP address */
3176 if (wp->proxy_in_su.sa.sa_family == AF_INET)
3177 dcc_mk_su(&su, AF_INET,
3178 &wp->proxy_in_su.ipv4.sin_addr,
3179 proxy_out_port);
3180 else
3181 dcc_mk_su(&su, AF_INET6,
3182 &wp->proxy_in_su.ipv6.sin6_addr,
3183 proxy_out_port);
3184 } else {
3185 su = proxy_out_su;
3186 }
3187 out_soc = socket(su.sa.sa_family, SOCK_STREAM, 0);
3188 if (out_soc < 0) {
3189 thr_error_msg(&wp->cw, "proxy_out socket(%s): %s",
3190 dcc_su2str(str, sizeof(str), &su),
3191 ERROR_STR());
3192 close(out_soc);
3193 smtp_temp_fail(wp);
3194 }
3195 if (0 > connect(out_soc, &su.sa, DCC_SU_LEN(&su))) {
3196 thr_error_msg(&wp->cw,
3197 "proxy_out connect(%s): %s",
3198 dcc_su2str(str, sizeof(str), &su),
3199 ERROR_STR());
3200 close(out_soc);
3201 smtp_temp_fail(wp);
3202 }
3203 if (!set_soc(wp->cw.emsg, out_soc, su.sa.sa_family,
3204 "proxy output")) {
3205 thr_error_msg(&wp->cw, "%s", wp->cw.emsg);
3206 close(out_soc);
3207 smtp_temp_fail(wp);
3208 }
3209 wp->proxy_out_soc = out_soc;
3210 wp->dfgs |= DFG_MTA_BODY;
3211 }
3212
3213 /* open the connection to the nearest DCC server
3214 * and figure out our X-DCC header */
3215 if (!ck_dcc_ctxt(&wp->cw)) {
3216 /* failed to create context */
3217 smtp_temp_fail(wp);
3218 }
3219 dcc_cks_init(&wp->cw.cks);
3220 dcc_dnsbl_init(&wp->cw.cks, wp->cw.dcc_ctxt, &wp->cw, wp->cw.id);
3221 wp->cw.cmn_fgs |= CMN_FG_LOG_EARLY;
3222
3223 /* pass the banner upstream */
3224 wp->smtp_state = SMTP_ST_START;
3225 SMTP_PASS_CMD(220);
3226
3227 /* assume for now that the IP address is the SMTP client to our proxy */
3228 if (wp->proxy_in_su.sa.sa_family != AF_UNIX) {
3229 if (wp->proxy_in_su.sa.sa_family == AF_INET) {
3230 dcc_ipv4toipv6(&wp->cw.clnt_addr,
3231 wp->proxy_in_su.ipv4.sin_addr);
3232 } else {
3233 wp->cw.clnt_addr = (wp->proxy_in_su.ipv6.sin6_addr);
3234 }
3235 dcc_ipv6tostr(wp->cw.clnt_str, sizeof(wp->cw.clnt_str),
3236 &wp->cw.clnt_addr);
3237 }
3238
3239 for (;;) {
3240 buf_write_flush(wp, &wp->reply_out);
3241 if (!msg_read_line(wp, &wp->msg_rd)) {
3242 proxy_abort(wp, "SMTP session aborted");
3243 job_exit(wp);
3244 }
3245 verb = get_smtp_verb(wp, &parmp, &eparmp);
3246
3247 /* deal with common SMTP commands */
3248 switch (verb) {
3249 case SMTP_VERB_ERR:
3250 wp->msg_rd.out = wp->msg_rd.next_line;
3251 continue;
3252 case SMTP_VERB_UNREC:
3253 /* pass anything we don't recognize to the SMTP server
3254 * for our proxy.
3255 * If we don't have a server, reject it */
3256 SMTP_PASS_CMD(500);
3257 wp->msg_rd.out = wp->msg_rd.next_line;
3258 continue;
3259 case SMTP_VERB_QUIT:
3260 SMTP_PASS_CMD(221);
3261 proxy_abort(wp, "SMTP session aborted with QUIT");
3262 job_exit(wp);
3263 case SMTP_VERB_RSET:
3264 SMTP_PASS_CMD(250_RSET);
3265 proxy_abort(wp, "SMTP transaction aborted with RSET");
3266 wp->msg_rd.out = wp->msg_rd.next_line;
3267 continue;
3268 case SMTP_VERB_HELO:
3269 proxy_abort(wp, "SMTP transaction aborted with HELO");
3270 wp->smtp_state = SMTP_ST_HELO;
3271 /* save helo value in case there is no XPOSTFIX */
3272 if (SMTP_PASS_CMD(250_HELO)
3273 && wp->cw.helo[0] == '\0'
3274 && !(wp->dfgs & DFG_XCLIENT_HELO))
3275 get_helo(wp, parmp, eparmp - parmp);
3276 wp->msg_rd.out = wp->msg_rd.next_line;
3277 continue;
3278 case SMTP_VERB_XCLIENT:
3279 case SMTP_VERB_XFORWARD:
3280 case SMTP_VERB_MAIL:
3281 case SMTP_VERB_RCPT:
3282 case SMTP_VERB_DATA:
3283 break;
3284 }
3285
3286 switch (wp->smtp_state) {
3287 case SMTP_ST_START: /* expecting HELO or perhaps MAIL */
3288 case SMTP_ST_HELO: /* seen HELO */
3289 if (verb == SMTP_VERB_XCLIENT
3290 || verb == SMTP_VERB_XFORWARD) {
3291 smtp_xpostfix(wp, verb, parmp);
3292 continue;
3293 }
3294 if (verb == SMTP_VERB_MAIL) {
3295 /* This might be a second message for the
3296 * connection.
3297 * Get sender, start logging, etc. at
3298 * the Mail_From command. */
3299 if (SMTP_PASS_CMD(250_MAIL)) {
3300 log_start(&wp->cw);
3301 i = eparmp - parmp;
3302 if (i > ISZ(wp->cw.env_from)-1)
3303 i = ISZ(wp->cw.env_from)-1;
3304 memcpy(wp->cw.env_from, parmp, i);
3305 wp->cw.env_from[i] = '\0';
3306 wp->smtp_state = SMTP_ST_TRANS;
3307 }
3308 wp->msg_rd.out = wp->msg_rd.next_line;
3309 get_sender(wp);
3310 continue;
3311 }
3312 break;
3313
3314 case SMTP_ST_TRANS: /* seen Mail_From */
3315 if (verb == SMTP_VERB_RCPT) {
3316 if (get_smtp_rcpt(wp, parmp, eparmp))
3317 wp->smtp_state = SMTP_ST_RCPT;
3318 continue;
3319 }
3320 break;
3321
3322 case SMTP_ST_RCPT: /* seen Rctp_To */
3323 if (verb == SMTP_VERB_RCPT) {
3324 get_smtp_rcpt(wp, parmp, eparmp);
3325 continue;
3326 }
3327 if (verb == SMTP_VERB_DATA) {
3328 smtp_data(wp);
3329 continue;
3330 }
3331 break;
3332
3333 case SMTP_ST_ERROR: /* no transaction until RSET or HELO */
3334 break;
3335 }
3336
3337 /* reject anything out of sequence */
3338 SMTP_ERROR(503);
3339 }
3340 }
3341
3342
3343
3344 /* start a new connection to an MTA */
3345 static void * NRATTRIB
3346 job_start(void *wp0)
3347 {
3348 WORK *wp = wp0;
3349
3350 /* working threads do not deal with signals */
3351 clnt_sigs_off(0);
3352
3353 if (proxy)
3354 proxy_job(wp);
3355 else
3356 ascii_job(wp);
3357 }