1 /*
2 * Copyright (c) 1999-2009, 2012, 2013 Proofpoint, Inc. and its suppliers.
3 * All rights reserved.
4 *
5 * By using this file, you agree to the terms and conditions set
6 * forth in the LICENSE file which can be found at the top level of
7 * the sendmail distribution.
8 *
9 */
10
11 #include <sendmail.h>
12
13 SM_RCSID("@(#)$Id: milter.c,v 8.281 2013-11-22 20:51:56 ca Exp $")
14
15 #if MILTER
16 # include <sm/sendmail.h>
17 # include <libmilter/mfapi.h>
18 # include <libmilter/mfdef.h>
19
20 # include <errno.h>
21 # include <sm/time.h>
22 # include <sys/uio.h>
23
24 # if NETINET || NETINET6
25 # include <arpa/inet.h>
26 # if MILTER_NO_NAGLE
27 # include <netinet/tcp.h>
28 # endif
29 # endif /* NETINET || NETINET6 */
30
31 # include <sm/fdset.h>
32
33 static void milter_connect_timeout __P((int));
34 static void milter_error __P((struct milter *, ENVELOPE *));
35 static int milter_open __P((struct milter *, bool, ENVELOPE *));
36 static void milter_parse_timeouts __P((char *, struct milter *));
37 static char *milter_sysread __P((struct milter *, char *, ssize_t, time_t,
38 ENVELOPE *, const char *));
39 static char *milter_read __P((struct milter *, char *, ssize_t *, time_t,
40 ENVELOPE *, const char *));
41 static char *milter_write __P((struct milter *, int, char *, ssize_t,
42 time_t, ENVELOPE *, const char *));
43 static char *milter_send_command __P((struct milter *, int, void *,
44 ssize_t, ENVELOPE *, char *, const char *));
45 static char *milter_command __P((int, void *, ssize_t, int,
46 ENVELOPE *, char *, const char *, bool));
47 static char *milter_body __P((struct milter *, ENVELOPE *, char *));
48 static int milter_reopen_df __P((ENVELOPE *));
49 static int milter_reset_df __P((ENVELOPE *));
50 static void milter_quit_filter __P((struct milter *, ENVELOPE *));
51 static void milter_abort_filter __P((struct milter *, ENVELOPE *));
52 static void milter_send_macros __P((struct milter *, char **, int,
53 ENVELOPE *));
54 static int milter_negotiate __P((struct milter *, ENVELOPE *,
55 milters_T *));
56 static void milter_per_connection_check __P((ENVELOPE *));
57 static char *milter_headers __P((struct milter *, ENVELOPE *, char *));
58 static void milter_addheader __P((struct milter *, char *, ssize_t,
59 ENVELOPE *));
60 static void milter_insheader __P((struct milter *, char *, ssize_t,
61 ENVELOPE *));
62 static void milter_changeheader __P((struct milter *, char *, ssize_t,
63 ENVELOPE *));
64 static void milter_chgfrom __P((char *, ssize_t, ENVELOPE *, const char *));
65 static void milter_addrcpt __P((char *, ssize_t, ENVELOPE *, const char *));
66 static void milter_addrcpt_par __P((char *, ssize_t, ENVELOPE *, const char *));
67 static void milter_delrcpt __P((char *, ssize_t, ENVELOPE *, const char *));
68 static int milter_replbody __P((char *, ssize_t, bool, ENVELOPE *, const char *));
69 static int milter_set_macros __P((char *, char **, char *, int));
70
71
72 /* milter states */
73 # define SMFS_CLOSED 'C' /* closed for all further actions */
74 # define SMFS_OPEN 'O' /* connected to remote milter filter */
75 # define SMFS_INMSG 'M' /* currently servicing a message */
76 # define SMFS_DONE 'D' /* done with current message */
77 # define SMFS_CLOSABLE 'Q' /* done with current connection */
78 # define SMFS_ERROR 'E' /* error state */
79 # define SMFS_READY 'R' /* ready for action */
80 # define SMFS_SKIP 'S' /* skip body */
81
82 /*
83 ** MilterMacros contains the milter macros for each milter and each stage.
84 ** indices are (in order): stages, milter-index, macro
85 ** milter-index == 0: "global" macros (not for a specific milter).
86 */
87
88 static char *MilterMacros[SMFIM_LAST + 1][MAXFILTERS + 1][MAXFILTERMACROS + 1];
89 static size_t MilterMaxDataSize = MILTER_MAX_DATA_SIZE;
90
91 # define MILTER_CHECK_DONE_MSG() \
92 if (*state == SMFIR_REPLYCODE || \
93 *state == SMFIR_REJECT || \
94 *state == SMFIR_DISCARD || \
95 *state == SMFIR_TEMPFAIL) \
96 { \
97 /* Abort the filters to let them know we are done with msg */ \
98 milter_abort(e); \
99 }
100
101 /* set state in case of an error */
102 # define MILTER_SET_STATE \
103 if (bitnset(SMF_TEMPFAIL, m->mf_flags)) \
104 *state = SMFIR_TEMPFAIL; \
105 else if (bitnset(SMF_TEMPDROP, m->mf_flags)) \
106 *state = SMFIR_SHUTDOWN; \
107 else if (bitnset(SMF_REJECT, m->mf_flags)) \
108 *state = SMFIR_REJECT
109
110 /* flow through code maybe using continue; don't wrap in do {} while */
111 # define MILTER_CHECK_ERROR(initial, action) \
112 if (!initial && tTd(71, 100)) \
113 { \
114 if (e->e_quarmsg == NULL) \
115 { \
116 e->e_quarmsg = sm_rpool_strdup_x(e->e_rpool, \
117 "filter failure"); \
118 macdefine(&e->e_macro, A_PERM, macid("{quarantine}"), \
119 e->e_quarmsg); \
120 } \
121 } \
122 else if (tTd(71, 101)) \
123 { \
124 if (e->e_quarmsg == NULL) \
125 { \
126 e->e_quarmsg = sm_rpool_strdup_x(e->e_rpool, \
127 "filter failure"); \
128 macdefine(&e->e_macro, A_PERM, macid("{quarantine}"), \
129 e->e_quarmsg); \
130 } \
131 } \
132 else MILTER_SET_STATE; \
133 else \
134 action;
135
136 # define MILTER_CHECK_REPLYCODE(default) \
137 if (response == NULL || \
138 strlen(response) + 1 != (size_t) rlen || \
139 rlen < 3 || \
140 (response[0] != '4' && response[0] != '5') || \
141 !isascii(response[1]) || !isdigit(response[1]) || \
142 !isascii(response[2]) || !isdigit(response[2])) \
143 { \
144 if (response != NULL) \
145 sm_free(response); /* XXX */ \
146 response = newstr(default); \
147 } \
148 else \
149 { \
150 char *ptr = response; \
151 \
152 /* Check for unprotected %'s in the string */ \
153 while (*ptr != '\0') \
154 { \
155 if (*ptr == '%' && *++ptr != '%') \
156 { \
157 sm_free(response); /* XXX */ \
158 response = newstr(default); \
159 break; \
160 } \
161 ptr++; \
162 } \
163 }
164
165 # define MILTER_DF_ERROR(msg) \
166 { \
167 int save_errno = errno; \
168 \
169 if (tTd(64, 5)) \
170 { \
171 sm_dprintf(msg, dfname, sm_errstring(save_errno)); \
172 sm_dprintf("\n"); \
173 } \
174 if (MilterLogLevel > 0) \
175 sm_syslog(LOG_ERR, e->e_id, msg, dfname, sm_errstring(save_errno)); \
176 if (SuperSafe == SAFE_REALLY) \
177 { \
178 if (e->e_dfp != NULL) \
179 { \
180 (void) sm_io_close(e->e_dfp, SM_TIME_DEFAULT); \
181 e->e_dfp = NULL; \
182 } \
183 e->e_flags &= ~EF_HAS_DF; \
184 } \
185 errno = save_errno; \
186 }
187
188 /*
189 ** MILTER_TIMEOUT -- make sure socket is ready in time
190 **
191 ** Parameters:
192 ** routine -- routine name for debug/logging
193 ** secs -- number of seconds in timeout
194 ** write -- waiting to read or write?
195 ** started -- whether this is part of a previous sequence
196 **
197 ** Assumes 'm' is a milter structure for the current socket.
198 */
199
200 # define MILTER_TIMEOUT(routine, secs, write, started, function) \
201 { \
202 int ret; \
203 int save_errno; \
204 fd_set fds; \
205 struct timeval tv; \
206 \
207 if (!SM_FD_OK_SELECT(m->mf_sock)) \
208 { \
209 if (tTd(64, 5)) \
210 sm_dprintf("milter_%s(%s): socket %d is larger than FD_SETSIZE %d\n", \
211 (routine), m->mf_name, m->mf_sock, \
212 SM_FD_SETSIZE); \
213 if (MilterLogLevel > 0) \
214 sm_syslog(LOG_ERR, e->e_id, \
215 "Milter (%s): socket(%s) %d is larger than FD_SETSIZE %d", \
216 m->mf_name, (routine), m->mf_sock, \
217 SM_FD_SETSIZE); \
218 milter_error(m, e); \
219 return NULL; \
220 } \
221 \
222 do \
223 { \
224 FD_ZERO(&fds); \
225 SM_FD_SET(m->mf_sock, &fds); \
226 tv.tv_sec = (secs); \
227 tv.tv_usec = 0; \
228 ret = select(m->mf_sock + 1, \
229 (write) ? NULL : &fds, \
230 (write) ? &fds : NULL, \
231 NULL, &tv); \
232 } while (ret < 0 && errno == EINTR); \
233 \
234 switch (ret) \
235 { \
236 case 0: \
237 if (tTd(64, 5)) \
238 sm_dprintf("milter_%s(%s): timeout, where=%s\n", \
239 (routine), m->mf_name, (function)); \
240 if (MilterLogLevel > 0) \
241 sm_syslog(LOG_ERR, e->e_id, \
242 "Milter (%s): timeout %s data %s, where=%s", \
243 m->mf_name, \
244 started ? "during" : "before", \
245 (routine), (function)); \
246 milter_error(m, e); \
247 return NULL; \
248 \
249 case -1: \
250 save_errno = errno; \
251 if (tTd(64, 5)) \
252 sm_dprintf("milter_%s(%s): select: %s\n", (routine), \
253 m->mf_name, sm_errstring(save_errno)); \
254 if (MilterLogLevel > 0) \
255 { \
256 sm_syslog(LOG_ERR, e->e_id, \
257 "Milter (%s): select(%s): %s", \
258 m->mf_name, (routine), \
259 sm_errstring(save_errno)); \
260 } \
261 milter_error(m, e); \
262 return NULL; \
263 \
264 default: \
265 if (SM_FD_ISSET(m->mf_sock, &fds)) \
266 break; \
267 if (tTd(64, 5)) \
268 sm_dprintf("milter_%s(%s): socket not ready\n", \
269 (routine), m->mf_name); \
270 if (MilterLogLevel > 0) \
271 { \
272 sm_syslog(LOG_ERR, e->e_id, \
273 "Milter (%s): socket(%s) not ready", \
274 m->mf_name, (routine)); \
275 } \
276 milter_error(m, e); \
277 return NULL; \
278 } \
279 }
280
281 /*
282 ** Low level functions
283 */
284
285 /*
286 ** MILTER_READ -- read from a remote milter filter
287 **
288 ** Parameters:
289 ** m -- milter to read from.
290 ** cmd -- return param for command read.
291 ** rlen -- return length of response string.
292 ** to -- timeout in seconds.
293 ** e -- current envelope.
294 **
295 ** Returns:
296 ** response string (may be NULL)
297 */
298
299 static char *
milter_sysread(m,buf,sz,to,e,where)300 milter_sysread(m, buf, sz, to, e, where)
301 struct milter *m;
302 char *buf;
303 ssize_t sz;
304 time_t to;
305 ENVELOPE *e;
306 const char *where;
307 {
308 time_t readstart = 0;
309 ssize_t len, curl;
310 bool started = false;
311
312 curl = 0;
313
314 if (to > 0)
315 readstart = curtime();
316
317 for (;;)
318 {
319 if (to > 0)
320 {
321 time_t now;
322
323 now = curtime();
324 if (now - readstart >= to)
325 {
326 if (tTd(64, 5))
327 sm_dprintf("milter_sys_read (%s): timeout %s data read in %s",
328 m->mf_name,
329 started ? "during" : "before",
330 where);
331 if (MilterLogLevel > 0)
332 sm_syslog(LOG_ERR, e->e_id,
333 "Milter (%s): timeout %s data read in %s",
334 m->mf_name,
335 started ? "during" : "before",
336 where);
337 milter_error(m, e);
338 return NULL;
339 }
340 to -= now - readstart;
341 readstart = now;
342 MILTER_TIMEOUT("read", to, false, started, where);
343 }
344
345 len = read(m->mf_sock, buf + curl, sz - curl);
346
347 if (len < 0)
348 {
349 int save_errno = errno;
350
351 if (tTd(64, 5))
352 sm_dprintf("milter_sys_read(%s): read returned %ld: %s\n",
353 m->mf_name, (long) len,
354 sm_errstring(save_errno));
355 if (MilterLogLevel > 0)
356 sm_syslog(LOG_ERR, e->e_id,
357 "Milter (%s): read returned %ld: %s",
358 m->mf_name, (long) len,
359 sm_errstring(save_errno));
360 milter_error(m, e);
361 return NULL;
362 }
363
364 started = true;
365 curl += len;
366 if (len == 0 || curl >= sz)
367 break;
368
369 }
370
371 if (curl != sz)
372 {
373 if (tTd(64, 5))
374 sm_dprintf("milter_sys_read(%s): cmd read returned %ld, expecting %ld\n",
375 m->mf_name, (long) curl, (long) sz);
376 if (MilterLogLevel > 0)
377 sm_syslog(LOG_ERR, e->e_id,
378 "milter_sys_read(%s): cmd read returned %ld, expecting %ld",
379 m->mf_name, (long) curl, (long) sz);
380 milter_error(m, e);
381 return NULL;
382 }
383 return buf;
384 }
385
386 static char *
milter_read(m,cmd,rlen,to,e,where)387 milter_read(m, cmd, rlen, to, e, where)
388 struct milter *m;
389 char *cmd;
390 ssize_t *rlen;
391 time_t to;
392 ENVELOPE *e;
393 const char *where;
394 {
395 time_t readstart = 0;
396 ssize_t expl;
397 mi_int32 i;
398 # if MILTER_NO_NAGLE && defined(TCP_CORK)
399 int cork = 0;
400 # endif
401 char *buf;
402 char data[MILTER_LEN_BYTES + 1];
403
404 if (m->mf_sock < 0)
405 {
406 if (MilterLogLevel > 0)
407 sm_syslog(LOG_ERR, e->e_id,
408 "milter_read(%s): socket closed, where=%s",
409 m->mf_name, where);
410 milter_error(m, e);
411 return NULL;
412 }
413
414 *rlen = 0;
415 *cmd = '\0';
416
417 if (to > 0)
418 readstart = curtime();
419
420 # if MILTER_NO_NAGLE && defined(TCP_CORK)
421 setsockopt(m->mf_sock, IPPROTO_TCP, TCP_CORK, (char *)&cork,
422 sizeof(cork));
423 # endif
424
425 if (milter_sysread(m, data, sizeof(data), to, e, where) == NULL)
426 return NULL;
427
428 # if MILTER_NO_NAGLE && defined(TCP_CORK)
429 cork = 1;
430 setsockopt(m->mf_sock, IPPROTO_TCP, TCP_CORK, (char *)&cork,
431 sizeof(cork));
432 # endif
433
434 /* reset timeout */
435 if (to > 0)
436 {
437 time_t now;
438
439 now = curtime();
440 if (now - readstart >= to)
441 {
442 if (tTd(64, 5))
443 sm_dprintf("milter_read(%s): timeout before data read, where=%s\n",
444 m->mf_name, where);
445 if (MilterLogLevel > 0)
446 sm_syslog(LOG_ERR, e->e_id,
447 "Milter read(%s): timeout before data read, where=%s",
448 m->mf_name, where);
449 milter_error(m, e);
450 return NULL;
451 }
452 to -= now - readstart;
453 }
454
455 *cmd = data[MILTER_LEN_BYTES];
456 data[MILTER_LEN_BYTES] = '\0';
457 (void) memcpy(&i, data, MILTER_LEN_BYTES);
458 expl = ntohl(i) - 1;
459
460 if (tTd(64, 25))
461 sm_dprintf("milter_read(%s): expecting %ld bytes\n",
462 m->mf_name, (long) expl);
463
464 if (expl < 0)
465 {
466 if (tTd(64, 5))
467 sm_dprintf("milter_read(%s): read size %ld out of range, where=%s\n",
468 m->mf_name, (long) expl, where);
469 if (MilterLogLevel > 0)
470 sm_syslog(LOG_ERR, e->e_id,
471 "milter_read(%s): read size %ld out of range, where=%s",
472 m->mf_name, (long) expl, where);
473 milter_error(m, e);
474 return NULL;
475 }
476
477 if (expl == 0)
478 return NULL;
479
480 buf = (char *) xalloc(expl);
481
482 if (milter_sysread(m, buf, expl, to, e, where) == NULL)
483 {
484 sm_free(buf); /* XXX */
485 return NULL;
486 }
487
488 if (tTd(64, 50))
489 sm_dprintf("milter_read(%s): Returning %*s\n",
490 m->mf_name, (int) expl, buf);
491 *rlen = expl;
492 return buf;
493 }
494
495 /*
496 ** MILTER_WRITE -- write to a remote milter filter
497 **
498 ** Parameters:
499 ** m -- milter to read from.
500 ** cmd -- command to send.
501 ** buf -- optional command data.
502 ** len -- length of buf.
503 ** to -- timeout in seconds.
504 ** e -- current envelope.
505 **
506 ** Returns:
507 ** buf if successful, NULL otherwise
508 ** Not actually used anywhere but function prototype
509 ** must match milter_read()
510 */
511
512 static char *
milter_write(m,cmd,buf,len,to,e,where)513 milter_write(m, cmd, buf, len, to, e, where)
514 struct milter *m;
515 int cmd;
516 char *buf;
517 ssize_t len;
518 time_t to;
519 ENVELOPE *e;
520 const char *where;
521 {
522 ssize_t sl, i;
523 int num_vectors;
524 mi_int32 nl;
525 char command = (char) cmd;
526 char data[MILTER_LEN_BYTES + 1];
527 bool started = false;
528 struct iovec vector[2];
529
530 /*
531 ** At most two buffers will be written, though
532 ** only one may actually be used (see num_vectors).
533 ** The first is the size/command and the second is the command data.
534 */
535
536 if (len < 0 || len > MilterMaxDataSize)
537 {
538 if (tTd(64, 5))
539 {
540 sm_dprintf("milter_write(%s): length %ld out of range, cmd=%c\n",
541 m->mf_name, (long) len, command);
542 sm_dprintf("milter_write(%s): buf=%s\n",
543 m->mf_name, str2prt(buf));
544 }
545 if (MilterLogLevel > 0)
546 sm_syslog(LOG_ERR, e->e_id,
547 "milter_write(%s): length %ld out of range, cmd=%c",
548 m->mf_name, (long) len, command);
549 milter_error(m, e);
550 return NULL;
551 }
552 if (m->mf_sock < 0)
553 {
554 if (MilterLogLevel > 0)
555 sm_syslog(LOG_ERR, e->e_id,
556 "milter_write(%s): socket closed",
557 m->mf_name);
558 milter_error(m, e);
559 return NULL;
560 }
561
562 if (tTd(64, 20))
563 sm_dprintf("milter_write(%s): cmd %c, len %ld\n",
564 m->mf_name, command, (long) len);
565
566 nl = htonl(len + 1); /* add 1 for the command char */
567 (void) memcpy(data, (char *) &nl, MILTER_LEN_BYTES);
568 data[MILTER_LEN_BYTES] = command;
569 sl = MILTER_LEN_BYTES + 1;
570
571 /* set up the vector for the size / command */
572 vector[0].iov_base = (void *) data;
573 vector[0].iov_len = sl;
574
575 /*
576 ** Determine if there is command data. If so, there will be two
577 ** vectors. If not, there will be only one. The vectors are set
578 ** up here and 'num_vectors' and 'sl' are set appropriately.
579 */
580
581 /* NOTE: len<0 has already been checked for. Pedantic */
582 if (len <= 0 || buf == NULL)
583 {
584 /* There is no command data -- only a size / command data */
585 num_vectors = 1;
586 }
587 else
588 {
589 /*
590 ** There is both size / command and command data.
591 ** Set up the vector for the command data.
592 */
593
594 num_vectors = 2;
595 sl += len;
596 vector[1].iov_base = (void *) buf;
597 vector[1].iov_len = len;
598
599 if (tTd(64, 50))
600 sm_dprintf("milter_write(%s): Sending %*s\n",
601 m->mf_name, (int) len, buf);
602 }
603
604 if (to > 0)
605 MILTER_TIMEOUT("write", to, true, started, where);
606
607 /* write the vector(s) */
608 i = writev(m->mf_sock, vector, num_vectors);
609 if (i != sl)
610 {
611 int save_errno = errno;
612
613 if (tTd(64, 5))
614 sm_dprintf("milter_write(%s): write(%c) returned %ld, expected %ld: %s\n",
615 m->mf_name, command, (long) i, (long) sl,
616 sm_errstring(save_errno));
617 if (MilterLogLevel > 0)
618 sm_syslog(LOG_ERR, e->e_id,
619 "Milter (%s): write(%c) returned %ld, expected %ld: %s",
620 m->mf_name, command, (long) i, (long) sl,
621 sm_errstring(save_errno));
622 milter_error(m, e);
623 return NULL;
624 }
625 return buf;
626 }
627
628 /*
629 ** Utility functions
630 */
631
632 /*
633 ** MILTER_OPEN -- connect to remote milter filter
634 **
635 ** Parameters:
636 ** m -- milter to connect to.
637 ** parseonly -- parse but don't connect.
638 ** e -- current envelope.
639 **
640 ** Returns:
641 ** connected socket if successful && !parseonly,
642 ** 0 upon parse success if parseonly,
643 ** -1 otherwise.
644 */
645
646 static jmp_buf MilterConnectTimeout;
647
648 static int
milter_open(m,parseonly,e)649 milter_open(m, parseonly, e)
650 struct milter *m;
651 bool parseonly;
652 ENVELOPE *e;
653 {
654 int sock = 0;
655 SOCKADDR_LEN_T addrlen = 0;
656 int addrno = 0;
657 int save_errno;
658 char *p;
659 char *colon;
660 char *at;
661 struct hostent *hp = NULL;
662 SOCKADDR addr;
663
664 if (m->mf_conn == NULL || m->mf_conn[0] == '\0')
665 {
666 if (tTd(64, 5))
667 sm_dprintf("X%s: empty or missing socket information\n",
668 m->mf_name);
669 if (parseonly)
670 syserr("X%s: empty or missing socket information",
671 m->mf_name);
672 else if (MilterLogLevel > 0)
673 sm_syslog(LOG_ERR, e->e_id,
674 "Milter (%s): empty or missing socket information",
675 m->mf_name);
676 milter_error(m, e);
677 return -1;
678 }
679
680 /* protocol:filename or protocol:port@host */
681 memset(&addr, '\0', sizeof(addr));
682 p = m->mf_conn;
683 colon = strchr(p, ':');
684 if (colon != NULL)
685 {
686 *colon = '\0';
687
688 if (*p == '\0')
689 {
690 # if NETUNIX
691 /* default to AF_UNIX */
692 addr.sa.sa_family = AF_UNIX;
693 # else
694 # if NETINET
695 /* default to AF_INET */
696 addr.sa.sa_family = AF_INET;
697 # else /* NETINET */
698 # if NETINET6
699 /* default to AF_INET6 */
700 addr.sa.sa_family = AF_INET6;
701 # else /* NETINET6 */
702 /* no protocols available */
703 if (MilterLogLevel > 0)
704 sm_syslog(LOG_ERR, e->e_id,
705 "Milter (%s): no valid socket protocols available",
706 m->mf_name);
707 milter_error(m, e);
708 return -1;
709 # endif /* NETINET6 */
710 # endif /* NETINET */
711 # endif /* NETUNIX */
712 }
713 # if NETUNIX
714 else if (sm_strcasecmp(p, "unix") == 0 ||
715 sm_strcasecmp(p, "local") == 0)
716 addr.sa.sa_family = AF_UNIX;
717 # endif
718 # if NETINET
719 else if (sm_strcasecmp(p, "inet") == 0)
720 addr.sa.sa_family = AF_INET;
721 # endif
722 # if NETINET6
723 else if (sm_strcasecmp(p, "inet6") == 0)
724 addr.sa.sa_family = AF_INET6;
725 # endif
726 else
727 {
728 # ifdef EPROTONOSUPPORT
729 errno = EPROTONOSUPPORT;
730 # else
731 errno = EINVAL;
732 # endif
733 if (tTd(64, 5))
734 sm_dprintf("X%s: unknown socket type %s\n",
735 m->mf_name, p);
736 if (parseonly)
737 syserr("X%s: unknown socket type %s",
738 m->mf_name, p);
739 else if (MilterLogLevel > 0)
740 sm_syslog(LOG_ERR, e->e_id,
741 "Milter (%s): unknown socket type %s",
742 m->mf_name, p);
743 milter_error(m, e);
744 return -1;
745 }
746 *colon++ = ':';
747 }
748 else
749 {
750 /* default to AF_UNIX */
751 addr.sa.sa_family = AF_UNIX;
752 colon = p;
753 }
754
755 # if NETUNIX
756 if (addr.sa.sa_family == AF_UNIX)
757 {
758 long sff = SFF_SAFEDIRPATH|SFF_OPENASROOT|SFF_NOLINK|SFF_EXECOK;
759
760 at = colon;
761 if (strlen(colon) >= sizeof(addr.sunix.sun_path))
762 {
763 if (tTd(64, 5))
764 sm_dprintf("X%s: local socket name %s too long\n",
765 m->mf_name, colon);
766 errno = EINVAL;
767 if (parseonly)
768 syserr("X%s: local socket name %s too long",
769 m->mf_name, colon);
770 else if (MilterLogLevel > 0)
771 sm_syslog(LOG_ERR, e->e_id,
772 "Milter (%s): local socket name %s too long",
773 m->mf_name, colon);
774 milter_error(m, e);
775 return -1;
776 }
777 errno = safefile(colon, RunAsUid, RunAsGid, RunAsUserName, sff,
778 S_IRUSR|S_IWUSR, NULL);
779
780 /* if just parsing .cf file, socket doesn't need to exist */
781 if (parseonly && errno == ENOENT)
782 {
783 if (OpMode == MD_DAEMON ||
784 OpMode == MD_FGDAEMON)
785 (void) sm_io_fprintf(smioerr, SM_TIME_DEFAULT,
786 "WARNING: X%s: local socket name %s missing\n",
787 m->mf_name, colon);
788 }
789 else if (errno != 0)
790 {
791 /* if not safe, don't create */
792 save_errno = errno;
793 if (tTd(64, 5))
794 sm_dprintf("X%s: local socket name %s unsafe\n",
795 m->mf_name, colon);
796 errno = save_errno;
797 if (parseonly)
798 {
799 if (OpMode == MD_DAEMON ||
800 OpMode == MD_FGDAEMON ||
801 OpMode == MD_SMTP)
802 syserr("X%s: local socket name %s unsafe",
803 m->mf_name, colon);
804 }
805 else if (MilterLogLevel > 0)
806 sm_syslog(LOG_ERR, e->e_id,
807 "Milter (%s): local socket name %s unsafe",
808 m->mf_name, colon);
809 milter_error(m, e);
810 return -1;
811 }
812
813 (void) sm_strlcpy(addr.sunix.sun_path, colon,
814 sizeof(addr.sunix.sun_path));
815 addrlen = sizeof(struct sockaddr_un);
816 }
817 else
818 # endif /* NETUNIX */
819 # if NETINET || NETINET6
820 if (false
821 # if NETINET
822 || addr.sa.sa_family == AF_INET
823 # endif
824 # if NETINET6
825 || addr.sa.sa_family == AF_INET6
826 # endif
827 )
828 {
829 unsigned short port;
830
831 /* Parse port@host */
832 at = strchr(colon, '@');
833 if (at == NULL)
834 {
835 if (tTd(64, 5))
836 sm_dprintf("X%s: bad address %s (expected port@host)\n",
837 m->mf_name, colon);
838 if (parseonly)
839 syserr("X%s: bad address %s (expected port@host)",
840 m->mf_name, colon);
841 else if (MilterLogLevel > 0)
842 sm_syslog(LOG_ERR, e->e_id,
843 "Milter (%s): bad address %s (expected port@host)",
844 m->mf_name, colon);
845 milter_error(m, e);
846 return -1;
847 }
848 *at = '\0';
849 if (isascii(*colon) && isdigit(*colon))
850 port = htons((unsigned short) atoi(colon));
851 else
852 {
853 # ifdef NO_GETSERVBYNAME
854 if (tTd(64, 5))
855 sm_dprintf("X%s: invalid port number %s\n",
856 m->mf_name, colon);
857 if (parseonly)
858 syserr("X%s: invalid port number %s",
859 m->mf_name, colon);
860 else if (MilterLogLevel > 0)
861 sm_syslog(LOG_ERR, e->e_id,
862 "Milter (%s): invalid port number %s",
863 m->mf_name, colon);
864 milter_error(m, e);
865 return -1;
866 # else /* NO_GETSERVBYNAME */
867 struct servent *sp;
868
869 sp = getservbyname(colon, "tcp");
870 if (sp == NULL)
871 {
872 save_errno = errno;
873 if (tTd(64, 5))
874 sm_dprintf("X%s: unknown port name %s\n",
875 m->mf_name, colon);
876 errno = save_errno;
877 if (parseonly)
878 syserr("X%s: unknown port name %s",
879 m->mf_name, colon);
880 else if (MilterLogLevel > 0)
881 sm_syslog(LOG_ERR, e->e_id,
882 "Milter (%s): unknown port name %s",
883 m->mf_name, colon);
884 milter_error(m, e);
885 return -1;
886 }
887 port = sp->s_port;
888 # endif /* NO_GETSERVBYNAME */
889 }
890 *at++ = '@';
891 if (*at == '[')
892 {
893 char *end;
894
895 end = strchr(at, ']');
896 if (end != NULL)
897 {
898 bool found = false;
899 # if NETINET
900 unsigned long hid = INADDR_NONE;
901 # endif
902 # if NETINET6
903 struct sockaddr_in6 hid6;
904 # endif
905
906 *end = '\0';
907 # if NETINET
908 if (addr.sa.sa_family == AF_INET &&
909 (hid = inet_addr(&at[1])) != INADDR_NONE)
910 {
911 addr.sin.sin_addr.s_addr = hid;
912 addr.sin.sin_port = port;
913 found = true;
914 }
915 # endif /* NETINET */
916 # if NETINET6
917 (void) memset(&hid6, '\0', sizeof(hid6));
918 if (addr.sa.sa_family == AF_INET6 &&
919 anynet_pton(AF_INET6, &at[1],
920 &hid6.sin6_addr) == 1)
921 {
922 addr.sin6.sin6_addr = hid6.sin6_addr;
923 addr.sin6.sin6_port = port;
924 found = true;
925 }
926 # endif /* NETINET6 */
927 *end = ']';
928 if (!found)
929 {
930 if (tTd(64, 5))
931 sm_dprintf("X%s: Invalid numeric domain spec \"%s\"\n",
932 m->mf_name, at);
933 if (parseonly)
934 syserr("X%s: Invalid numeric domain spec \"%s\"",
935 m->mf_name, at);
936 else if (MilterLogLevel > 0)
937 sm_syslog(LOG_ERR, e->e_id,
938 "Milter (%s): Invalid numeric domain spec \"%s\"",
939 m->mf_name, at);
940 milter_error(m, e);
941 return -1;
942 }
943 }
944 else
945 {
946 if (tTd(64, 5))
947 sm_dprintf("X%s: Invalid numeric domain spec \"%s\"\n",
948 m->mf_name, at);
949 if (parseonly)
950 syserr("X%s: Invalid numeric domain spec \"%s\"",
951 m->mf_name, at);
952 else if (MilterLogLevel > 0)
953 sm_syslog(LOG_ERR, e->e_id,
954 "Milter (%s): Invalid numeric domain spec \"%s\"",
955 m->mf_name, at);
956 milter_error(m, e);
957 return -1;
958 }
959 }
960 else
961 {
962 hp = sm_gethostbyname(at, addr.sa.sa_family);
963 if (hp == NULL)
964 {
965 save_errno = errno;
966 if (tTd(64, 5))
967 sm_dprintf("X%s: Unknown host name %s\n",
968 m->mf_name, at);
969 errno = save_errno;
970 if (parseonly)
971 syserr("X%s: Unknown host name %s",
972 m->mf_name, at);
973 else if (MilterLogLevel > 0)
974 sm_syslog(LOG_ERR, e->e_id,
975 "Milter (%s): Unknown host name %s",
976 m->mf_name, at);
977 milter_error(m, e);
978 return -1;
979 }
980 addr.sa.sa_family = hp->h_addrtype;
981 switch (hp->h_addrtype)
982 {
983 # if NETINET
984 case AF_INET:
985 memmove(&addr.sin.sin_addr,
986 hp->h_addr, INADDRSZ);
987 addr.sin.sin_port = port;
988 addrlen = sizeof(struct sockaddr_in);
989 addrno = 1;
990 break;
991 # endif /* NETINET */
992
993 # if NETINET6
994 case AF_INET6:
995 memmove(&addr.sin6.sin6_addr,
996 hp->h_addr, IN6ADDRSZ);
997 addr.sin6.sin6_port = port;
998 addrlen = sizeof(struct sockaddr_in6);
999 addrno = 1;
1000 break;
1001 # endif /* NETINET6 */
1002
1003 default:
1004 if (tTd(64, 5))
1005 sm_dprintf("X%s: Unknown protocol for %s (%d)\n",
1006 m->mf_name, at,
1007 hp->h_addrtype);
1008 if (parseonly)
1009 syserr("X%s: Unknown protocol for %s (%d)",
1010 m->mf_name, at, hp->h_addrtype);
1011 else if (MilterLogLevel > 0)
1012 sm_syslog(LOG_ERR, e->e_id,
1013 "Milter (%s): Unknown protocol for %s (%d)",
1014 m->mf_name, at,
1015 hp->h_addrtype);
1016 milter_error(m, e);
1017 # if NETINET6
1018 freehostent(hp);
1019 # endif
1020 return -1;
1021 }
1022 }
1023 }
1024 else
1025 # endif /* NETINET || NETINET6 */
1026 {
1027 if (tTd(64, 5))
1028 sm_dprintf("X%s: unknown socket protocol\n",
1029 m->mf_name);
1030 if (parseonly)
1031 syserr("X%s: unknown socket protocol", m->mf_name);
1032 else if (MilterLogLevel > 0)
1033 sm_syslog(LOG_ERR, e->e_id,
1034 "Milter (%s): unknown socket protocol",
1035 m->mf_name);
1036 milter_error(m, e);
1037 return -1;
1038 }
1039
1040 /* just parsing through? */
1041 if (parseonly)
1042 {
1043 m->mf_state = SMFS_READY;
1044 # if NETINET6
1045 if (hp != NULL)
1046 freehostent(hp);
1047 # endif
1048 return 0;
1049 }
1050
1051 /* sanity check */
1052 if (m->mf_state != SMFS_READY &&
1053 m->mf_state != SMFS_CLOSED)
1054 {
1055 /* shouldn't happen */
1056 if (tTd(64, 1))
1057 sm_dprintf("Milter (%s): Trying to open filter in state %c\n",
1058 m->mf_name, (char) m->mf_state);
1059 milter_error(m, e);
1060 # if NETINET6
1061 if (hp != NULL)
1062 freehostent(hp);
1063 # endif
1064 return -1;
1065 }
1066
1067 /* nope, actually connecting */
1068 for (;;)
1069 {
1070 sock = socket(addr.sa.sa_family, SOCK_STREAM, 0);
1071 if (sock < 0)
1072 {
1073 save_errno = errno;
1074 if (tTd(64, 5))
1075 sm_dprintf("Milter (%s): error creating socket: %s\n",
1076 m->mf_name,
1077 sm_errstring(save_errno));
1078 if (MilterLogLevel > 0)
1079 sm_syslog(LOG_ERR, e->e_id,
1080 "Milter (%s): error creating socket: %s",
1081 m->mf_name, sm_errstring(save_errno));
1082 milter_error(m, e);
1083 # if NETINET6
1084 if (hp != NULL)
1085 freehostent(hp);
1086 # endif
1087 return -1;
1088 }
1089
1090 if (setjmp(MilterConnectTimeout) == 0)
1091 {
1092 SM_EVENT *ev = NULL;
1093 int i;
1094
1095 if (m->mf_timeout[SMFTO_CONNECT] > 0)
1096 ev = sm_setevent(m->mf_timeout[SMFTO_CONNECT],
1097 milter_connect_timeout, 0);
1098
1099 i = connect(sock, (struct sockaddr *) &addr, addrlen);
1100 save_errno = errno;
1101 if (ev != NULL)
1102 sm_clrevent(ev);
1103 errno = save_errno;
1104 if (i >= 0)
1105 break;
1106 }
1107
1108 /* couldn't connect.... try next address */
1109 save_errno = errno;
1110 p = CurHostName;
1111 CurHostName = at;
1112 if (tTd(64, 5))
1113 sm_dprintf("milter_open (%s): open %s failed: %s\n",
1114 m->mf_name, at, sm_errstring(save_errno));
1115 if (MilterLogLevel > 13)
1116 sm_syslog(LOG_INFO, e->e_id,
1117 "Milter (%s): open %s failed: %s",
1118 m->mf_name, at, sm_errstring(save_errno));
1119 CurHostName = p;
1120 (void) close(sock);
1121
1122 /* try next address */
1123 if (hp != NULL && hp->h_addr_list[addrno] != NULL)
1124 {
1125 switch (addr.sa.sa_family)
1126 {
1127 # if NETINET
1128 case AF_INET:
1129 memmove(&addr.sin.sin_addr,
1130 hp->h_addr_list[addrno++],
1131 INADDRSZ);
1132 break;
1133 # endif /* NETINET */
1134
1135 # if NETINET6
1136 case AF_INET6:
1137 memmove(&addr.sin6.sin6_addr,
1138 hp->h_addr_list[addrno++],
1139 IN6ADDRSZ);
1140 break;
1141 # endif /* NETINET6 */
1142
1143 default:
1144 if (tTd(64, 5))
1145 sm_dprintf("X%s: Unknown protocol for %s (%d)\n",
1146 m->mf_name, at,
1147 hp->h_addrtype);
1148 if (MilterLogLevel > 0)
1149 sm_syslog(LOG_ERR, e->e_id,
1150 "Milter (%s): Unknown protocol for %s (%d)",
1151 m->mf_name, at,
1152 hp->h_addrtype);
1153 milter_error(m, e);
1154 # if NETINET6
1155 freehostent(hp);
1156 # endif
1157 return -1;
1158 }
1159 continue;
1160 }
1161 p = CurHostName;
1162 CurHostName = at;
1163 if (tTd(64, 5))
1164 sm_dprintf("X%s: error connecting to filter: %s\n",
1165 m->mf_name, sm_errstring(save_errno));
1166 if (MilterLogLevel > 0)
1167 sm_syslog(LOG_ERR, e->e_id,
1168 "Milter (%s): error connecting to filter: %s",
1169 m->mf_name, sm_errstring(save_errno));
1170 CurHostName = p;
1171 milter_error(m, e);
1172 # if NETINET6
1173 if (hp != NULL)
1174 freehostent(hp);
1175 # endif
1176 return -1;
1177 }
1178 m->mf_state = SMFS_OPEN;
1179 # if NETINET6
1180 if (hp != NULL)
1181 {
1182 freehostent(hp);
1183 hp = NULL;
1184 }
1185 # endif /* NETINET6 */
1186 # if MILTER_NO_NAGLE && !defined(TCP_CORK)
1187 {
1188 int nodelay = 1;
1189
1190 setsockopt(m->mf_sock, IPPROTO_TCP, TCP_NODELAY,
1191 (char *)&nodelay, sizeof(nodelay));
1192 }
1193 # endif /* MILTER_NO_NAGLE && !defined(TCP_CORK) */
1194 return sock;
1195 }
1196
1197 static void
milter_connect_timeout(ignore)1198 milter_connect_timeout(ignore)
1199 int ignore;
1200 {
1201 /*
1202 ** NOTE: THIS CAN BE CALLED FROM A SIGNAL HANDLER. DO NOT ADD
1203 ** ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE
1204 ** DOING.
1205 */
1206
1207 errno = ETIMEDOUT;
1208 longjmp(MilterConnectTimeout, 1);
1209 }
1210
1211 /*
1212 ** MILTER_SETUP -- setup structure for a mail filter
1213 **
1214 ** Parameters:
1215 ** line -- the options line.
1216 **
1217 ** Returns:
1218 ** none
1219 */
1220
1221 void
milter_setup(line)1222 milter_setup(line)
1223 char *line;
1224 {
1225 char fcode;
1226 char *p;
1227 struct milter *m;
1228 STAB *s;
1229 static int idx = 0;
1230
1231 /* collect the filter name */
1232 for (p = line;
1233 *p != '\0' && *p != ',' && !(SM_ISSPACE(*p));
1234 p++)
1235 continue;
1236 if (*p != '\0')
1237 *p++ = '\0';
1238 if (line[0] == '\0')
1239 {
1240 syserr("name required for mail filter");
1241 return;
1242 }
1243 m = (struct milter *) xalloc(sizeof(*m));
1244 memset((char *) m, '\0', sizeof(*m));
1245 m->mf_name = newstr(line);
1246 m->mf_state = SMFS_READY;
1247 m->mf_sock = -1;
1248 m->mf_timeout[SMFTO_CONNECT] = (time_t) 300;
1249 m->mf_timeout[SMFTO_WRITE] = (time_t) 10;
1250 m->mf_timeout[SMFTO_READ] = (time_t) 10;
1251 m->mf_timeout[SMFTO_EOM] = (time_t) 300;
1252 #if _FFR_MILTER_CHECK
1253 m->mf_mta_prot_version = SMFI_PROT_VERSION;
1254 m->mf_mta_prot_flags = SMFI_CURR_PROT;
1255 m->mf_mta_actions = SMFI_CURR_ACTS;
1256 #endif /* _FFR_MILTER_CHECK */
1257
1258 /* now scan through and assign info from the fields */
1259 while (*p != '\0')
1260 {
1261 char *delimptr;
1262
1263 while (*p != '\0' &&
1264 (*p == ',' || (SM_ISSPACE(*p))))
1265 p++;
1266
1267 /* p now points to field code */
1268 fcode = *p;
1269 while (*p != '\0' && *p != '=' && *p != ',')
1270 p++;
1271 if (*p++ != '=')
1272 {
1273 syserr("X%s: `=' expected", m->mf_name);
1274 return;
1275 }
1276 while (SM_ISSPACE(*p))
1277 p++;
1278
1279 /* p now points to the field body */
1280 p = munchstring(p, &delimptr, ',');
1281
1282 /* install the field into the filter struct */
1283 switch (fcode)
1284 {
1285 case 'S': /* socket */
1286 if (p == NULL)
1287 m->mf_conn = NULL;
1288 else
1289 m->mf_conn = newstr(p);
1290 break;
1291
1292 case 'F': /* Milter flags configured on MTA */
1293 for (; *p != '\0'; p++)
1294 {
1295 if (!(SM_ISSPACE(*p)))
1296 setbitn(bitidx(*p), m->mf_flags);
1297 }
1298 break;
1299
1300 case 'T': /* timeouts */
1301 milter_parse_timeouts(p, m);
1302 break;
1303
1304 #if _FFR_MILTER_CHECK
1305 case 'a':
1306 m->mf_mta_actions = strtoul(p, NULL, 0);
1307 break;
1308 case 'f':
1309 m->mf_mta_prot_flags = strtoul(p, NULL, 0);
1310 break;
1311 case 'v':
1312 m->mf_mta_prot_version = strtoul(p, NULL, 0);
1313 break;
1314 #endif /* _FFR_MILTER_CHECK */
1315
1316 default:
1317 syserr("X%s: unknown filter equate %c=",
1318 m->mf_name, fcode);
1319 break;
1320 }
1321 p = delimptr;
1322 }
1323
1324 /* early check for errors */
1325 (void) milter_open(m, true, CurEnv);
1326
1327 /* enter the filter into the symbol table */
1328 s = stab(m->mf_name, ST_MILTER, ST_ENTER);
1329 if (s->s_milter != NULL)
1330 syserr("X%s: duplicate filter definition", m->mf_name);
1331 else
1332 {
1333 s->s_milter = m;
1334 m->mf_idx = ++idx;
1335 }
1336 }
1337
1338 /*
1339 ** MILTER_CONFIG -- parse option list into an array and check config
1340 **
1341 ** Called when reading configuration file.
1342 **
1343 ** Parameters:
1344 ** spec -- the filter list.
1345 ** list -- the array to fill in.
1346 ** max -- the maximum number of entries in list.
1347 **
1348 ** Returns:
1349 ** none
1350 */
1351
1352 void
milter_config(spec,list,max)1353 milter_config(spec, list, max)
1354 char *spec;
1355 struct milter **list;
1356 int max;
1357 {
1358 int numitems = 0;
1359 char *p;
1360
1361 /* leave one for the NULL signifying the end of the list */
1362 max--;
1363
1364 for (p = spec; p != NULL; )
1365 {
1366 STAB *s;
1367
1368 while (SM_ISSPACE(*p))
1369 p++;
1370 if (*p == '\0')
1371 break;
1372 spec = p;
1373
1374 if (numitems >= max)
1375 {
1376 syserr("Too many filters defined, %d max", max);
1377 if (max > 0)
1378 list[0] = NULL;
1379 return;
1380 }
1381 p = strpbrk(p, ";,");
1382 if (p != NULL)
1383 *p++ = '\0';
1384
1385 s = stab(spec, ST_MILTER, ST_FIND);
1386 if (s == NULL)
1387 {
1388 syserr("InputFilter %s not defined", spec);
1389 ExitStat = EX_CONFIG;
1390 return;
1391 }
1392 list[numitems++] = s->s_milter;
1393 }
1394 list[numitems] = NULL;
1395
1396 /* if not set, set to LogLevel */
1397 if (MilterLogLevel == -1)
1398 MilterLogLevel = LogLevel;
1399 }
1400
1401 /*
1402 ** MILTER_PARSE_TIMEOUTS -- parse timeout list
1403 **
1404 ** Called when reading configuration file.
1405 **
1406 ** Parameters:
1407 ** spec -- the timeout list.
1408 ** m -- milter to set.
1409 **
1410 ** Returns:
1411 ** none
1412 */
1413
1414 static void
milter_parse_timeouts(spec,m)1415 milter_parse_timeouts(spec, m)
1416 char *spec;
1417 struct milter *m;
1418 {
1419 char fcode;
1420 int tcode;
1421 char *p;
1422
1423 p = spec;
1424
1425 /* now scan through and assign info from the fields */
1426 while (*p != '\0')
1427 {
1428 char *delimptr;
1429
1430 while (*p != '\0' && (*p == ';' || (SM_ISSPACE(*p))))
1431 p++;
1432
1433 /* p now points to field code */
1434 fcode = *p;
1435 while (*p != '\0' && *p != ':')
1436 p++;
1437 if (*p++ != ':')
1438 {
1439 syserr("X%s, T=: `:' expected", m->mf_name);
1440 return;
1441 }
1442 while (SM_ISSPACE(*p))
1443 p++;
1444
1445 /* p now points to the field body */
1446 p = munchstring(p, &delimptr, ';');
1447 tcode = -1;
1448
1449 /* install the field into the filter struct */
1450 switch (fcode)
1451 {
1452 case 'C':
1453 tcode = SMFTO_CONNECT;
1454 break;
1455
1456 case 'S':
1457 tcode = SMFTO_WRITE;
1458 break;
1459
1460 case 'R':
1461 tcode = SMFTO_READ;
1462 break;
1463
1464 case 'E':
1465 tcode = SMFTO_EOM;
1466 break;
1467
1468 default:
1469 if (tTd(64, 5))
1470 sm_dprintf("X%s: %c unknown\n",
1471 m->mf_name, fcode);
1472 syserr("X%s: unknown filter timeout %c",
1473 m->mf_name, fcode);
1474 break;
1475 }
1476 if (tcode >= 0)
1477 {
1478 m->mf_timeout[tcode] = convtime(p, 's');
1479 if (tTd(64, 5))
1480 sm_dprintf("X%s: %c=%ld\n",
1481 m->mf_name, fcode,
1482 (u_long) m->mf_timeout[tcode]);
1483 }
1484 p = delimptr;
1485 }
1486 }
1487
1488 /*
1489 ** MILTER_SET_MACROS -- set milter macros
1490 **
1491 ** Parameters:
1492 ** name -- name of milter.
1493 ** macros -- where to store macros.
1494 ** val -- the value of the option.
1495 ** nummac -- current number of macros
1496 **
1497 ** Returns:
1498 ** new number of macros
1499 */
1500
1501 static int
milter_set_macros(name,macros,val,nummac)1502 milter_set_macros(name, macros, val, nummac)
1503 char *name;
1504 char **macros;
1505 char *val;
1506 int nummac;
1507 {
1508 char *p;
1509
1510 p = newstr(val);
1511 while (*p != '\0')
1512 {
1513 char *macro;
1514
1515 /* Skip leading commas, spaces */
1516 while (*p != '\0' && (*p == ',' || (SM_ISSPACE(*p))))
1517 p++;
1518
1519 if (*p == '\0')
1520 break;
1521
1522 /* Find end of macro */
1523 macro = p;
1524 while (*p != '\0' && *p != ',' &&
1525 isascii(*p) && !isspace(*p))
1526 p++;
1527 if (*p != '\0')
1528 *p++ = '\0';
1529
1530 if (nummac >= MAXFILTERMACROS)
1531 {
1532 syserr("milter_set_option: too many macros in Milter.%s (max %d)",
1533 name, MAXFILTERMACROS);
1534 macros[nummac] = NULL;
1535 return -1;
1536 }
1537 macros[nummac++] = macro;
1538 }
1539 macros[nummac] = NULL;
1540 return nummac;
1541 }
1542
1543 /*
1544 ** MILTER_SET_OPTION -- set an individual milter option
1545 **
1546 ** Parameters:
1547 ** name -- the name of the option.
1548 ** val -- the value of the option.
1549 ** sticky -- if set, don't let other setoptions override
1550 ** this value.
1551 **
1552 ** Returns:
1553 ** none.
1554 */
1555
1556 /* set if Milter sub-option is stuck */
1557 static BITMAP256 StickyMilterOpt;
1558
1559 static struct milteropt
1560 {
1561 char *mo_name; /* long name of milter option */
1562 unsigned char mo_code; /* code for option */
1563 } MilterOptTab[] =
1564 {
1565 { "macros.connect", SMFIM_CONNECT },
1566 { "macros.helo", SMFIM_HELO },
1567 { "macros.envfrom", SMFIM_ENVFROM },
1568 { "macros.envrcpt", SMFIM_ENVRCPT },
1569 { "macros.data", SMFIM_DATA },
1570 { "macros.eom", SMFIM_EOM },
1571 { "macros.eoh", SMFIM_EOH },
1572
1573 # define MO_LOGLEVEL 0x07
1574 { "loglevel", MO_LOGLEVEL },
1575 # if _FFR_MAXDATASIZE || _FFR_MDS_NEGOTIATE
1576 # define MO_MAXDATASIZE 0x08
1577 { "maxdatasize", MO_MAXDATASIZE },
1578 # endif
1579 { NULL, (unsigned char)-1 },
1580 };
1581
1582 void
milter_set_option(name,val,sticky)1583 milter_set_option(name, val, sticky)
1584 char *name;
1585 char *val;
1586 bool sticky;
1587 {
1588 int nummac, r;
1589 struct milteropt *mo;
1590 char **macros = NULL;
1591
1592 nummac = 0;
1593 if (tTd(37, 2) || tTd(64, 5))
1594 sm_dprintf("milter_set_option(%s = %s)", name, val);
1595
1596 if (name == NULL)
1597 {
1598 syserr("milter_set_option: invalid Milter option, must specify suboption");
1599 return;
1600 }
1601
1602 for (mo = MilterOptTab; mo->mo_name != NULL; mo++)
1603 {
1604 if (sm_strcasecmp(mo->mo_name, name) == 0)
1605 break;
1606 }
1607
1608 if (mo->mo_name == NULL)
1609 {
1610 syserr("milter_set_option: invalid Milter option %s", name);
1611 return;
1612 }
1613
1614 /*
1615 ** See if this option is preset for us.
1616 */
1617
1618 if (!sticky && bitnset(mo->mo_code, StickyMilterOpt))
1619 {
1620 if (tTd(37, 2) || tTd(64,5))
1621 sm_dprintf(" (ignored)\n");
1622 return;
1623 }
1624
1625 if (tTd(37, 2) || tTd(64,5))
1626 sm_dprintf("\n");
1627
1628 switch (mo->mo_code)
1629 {
1630 case MO_LOGLEVEL:
1631 MilterLogLevel = atoi(val);
1632 break;
1633
1634 # if _FFR_MAXDATASIZE || _FFR_MDS_NEGOTIATE
1635 case MO_MAXDATASIZE:
1636 # if _FFR_MDS_NEGOTIATE
1637 MilterMaxDataSize = (size_t)atol(val);
1638 if (MilterMaxDataSize != MILTER_MDS_64K &&
1639 MilterMaxDataSize != MILTER_MDS_256K &&
1640 MilterMaxDataSize != MILTER_MDS_1M)
1641 {
1642 sm_syslog(LOG_WARNING, NOQID,
1643 "WARNING: Milter.%s=%lu, allowed are only %d, %d, and %d",
1644 name, (unsigned long) MilterMaxDataSize,
1645 MILTER_MDS_64K, MILTER_MDS_256K,
1646 MILTER_MDS_1M);
1647 if (MilterMaxDataSize < MILTER_MDS_64K)
1648 MilterMaxDataSize = MILTER_MDS_64K;
1649 else if (MilterMaxDataSize < MILTER_MDS_256K)
1650 MilterMaxDataSize = MILTER_MDS_256K;
1651 else
1652 MilterMaxDataSize = MILTER_MDS_1M;
1653 }
1654 # endif /* _FFR_MDS_NEGOTIATE */
1655 break;
1656 # endif /* _FFR_MAXDATASIZE || _FFR_MDS_NEGOTIATE */
1657
1658 case SMFIM_CONNECT:
1659 case SMFIM_HELO:
1660 case SMFIM_ENVFROM:
1661 case SMFIM_ENVRCPT:
1662 case SMFIM_EOH:
1663 case SMFIM_EOM:
1664 case SMFIM_DATA:
1665 macros = MilterMacros[mo->mo_code][0];
1666
1667 r = milter_set_macros(name, macros, val, nummac);
1668 if (r >= 0)
1669 nummac = r;
1670 break;
1671
1672 default:
1673 syserr("milter_set_option: invalid Milter option %s", name);
1674 break;
1675 }
1676 if (sticky)
1677 setbitn(mo->mo_code, StickyMilterOpt);
1678 }
1679
1680 /*
1681 ** MILTER_REOPEN_DF -- open & truncate the data file (for replbody)
1682 **
1683 ** Parameters:
1684 ** e -- current envelope.
1685 **
1686 ** Returns:
1687 ** 0 if successful, -1 otherwise
1688 */
1689
1690 static int
milter_reopen_df(e)1691 milter_reopen_df(e)
1692 ENVELOPE *e;
1693 {
1694 char dfname[MAXPATHLEN];
1695
1696 (void) sm_strlcpy(dfname, queuename(e, DATAFL_LETTER), sizeof(dfname));
1697
1698 /*
1699 ** In SuperSafe == SAFE_REALLY mode, e->e_dfp is a read-only FP so
1700 ** close and reopen writable (later close and reopen
1701 ** read only again).
1702 **
1703 ** In SuperSafe != SAFE_REALLY mode, e->e_dfp still points at the
1704 ** buffered file I/O descriptor, still open for writing so there
1705 ** isn't any work to do here (except checking for consistency).
1706 */
1707
1708 if (SuperSafe == SAFE_REALLY)
1709 {
1710 /* close read-only data file */
1711 if (bitset(EF_HAS_DF, e->e_flags) && e->e_dfp != NULL)
1712 {
1713 (void) sm_io_close(e->e_dfp, SM_TIME_DEFAULT);
1714 e->e_flags &= ~EF_HAS_DF;
1715 }
1716
1717 /* open writable */
1718 if ((e->e_dfp = sm_io_open(SmFtStdio, SM_TIME_DEFAULT, dfname,
1719 SM_IO_RDWR_B, NULL)) == NULL)
1720 {
1721 MILTER_DF_ERROR("milter_reopen_df: sm_io_open %s: %s");
1722 return -1;
1723 }
1724 }
1725 else if (e->e_dfp == NULL)
1726 {
1727 /* shouldn't happen */
1728 errno = ENOENT;
1729 MILTER_DF_ERROR("milter_reopen_df: NULL e_dfp (%s: %s)");
1730 return -1;
1731 }
1732 return 0;
1733 }
1734
1735 /*
1736 ** MILTER_RESET_DF -- re-open read-only the data file (for replbody)
1737 **
1738 ** Parameters:
1739 ** e -- current envelope.
1740 **
1741 ** Returns:
1742 ** 0 if successful, -1 otherwise
1743 */
1744
1745 static int
milter_reset_df(e)1746 milter_reset_df(e)
1747 ENVELOPE *e;
1748 {
1749 int afd;
1750 char dfname[MAXPATHLEN];
1751
1752 (void) sm_strlcpy(dfname, queuename(e, DATAFL_LETTER), sizeof(dfname));
1753
1754 if (sm_io_flush(e->e_dfp, SM_TIME_DEFAULT) != 0 ||
1755 sm_io_error(e->e_dfp))
1756 {
1757 MILTER_DF_ERROR("milter_reset_df: error writing/flushing %s: %s");
1758 return -1;
1759 }
1760 else if (SuperSafe != SAFE_REALLY)
1761 {
1762 /* skip next few clauses */
1763 /* EMPTY */
1764 }
1765 else if ((afd = sm_io_getinfo(e->e_dfp, SM_IO_WHAT_FD, NULL)) >= 0
1766 && fsync(afd) < 0)
1767 {
1768 MILTER_DF_ERROR("milter_reset_df: error sync'ing %s: %s");
1769 return -1;
1770 }
1771 else if (sm_io_close(e->e_dfp, SM_TIME_DEFAULT) < 0)
1772 {
1773 MILTER_DF_ERROR("milter_reset_df: error closing %s: %s");
1774 return -1;
1775 }
1776 else if ((e->e_dfp = sm_io_open(SmFtStdio, SM_TIME_DEFAULT, dfname,
1777 SM_IO_RDONLY_B, NULL)) == NULL)
1778 {
1779 MILTER_DF_ERROR("milter_reset_df: error reopening %s: %s");
1780 return -1;
1781 }
1782 else
1783 e->e_flags |= EF_HAS_DF;
1784 return 0;
1785 }
1786
1787 /*
1788 ** MILTER_QUIT_FILTER -- close down a single filter
1789 **
1790 ** Parameters:
1791 ** m -- milter structure of filter to close down.
1792 ** e -- current envelope.
1793 **
1794 ** Returns:
1795 ** none
1796 */
1797
1798 static void
milter_quit_filter(m,e)1799 milter_quit_filter(m, e)
1800 struct milter *m;
1801 ENVELOPE *e;
1802 {
1803 if (tTd(64, 10))
1804 sm_dprintf("milter_quit_filter(%s)\n", m->mf_name);
1805 if (MilterLogLevel > 18)
1806 sm_syslog(LOG_INFO, e->e_id, "Milter (%s): quit filter",
1807 m->mf_name);
1808
1809 /* Never replace error state */
1810 if (m->mf_state == SMFS_ERROR)
1811 return;
1812
1813 if (m->mf_sock < 0 ||
1814 m->mf_state == SMFS_CLOSED ||
1815 m->mf_state == SMFS_READY)
1816 {
1817 m->mf_sock = -1;
1818 m->mf_state = SMFS_CLOSED;
1819 return;
1820 }
1821
1822 (void) milter_write(m, SMFIC_QUIT, (char *) NULL, 0,
1823 m->mf_timeout[SMFTO_WRITE], e, "quit_filter");
1824 if (m->mf_sock >= 0)
1825 {
1826 (void) close(m->mf_sock);
1827 m->mf_sock = -1;
1828 }
1829 if (m->mf_state != SMFS_ERROR)
1830 m->mf_state = SMFS_CLOSED;
1831 }
1832
1833 /*
1834 ** MILTER_ABORT_FILTER -- tell filter to abort current message
1835 **
1836 ** Parameters:
1837 ** m -- milter structure of filter to abort.
1838 ** e -- current envelope.
1839 **
1840 ** Returns:
1841 ** none
1842 */
1843
1844 static void
milter_abort_filter(m,e)1845 milter_abort_filter(m, e)
1846 struct milter *m;
1847 ENVELOPE *e;
1848 {
1849 if (tTd(64, 10))
1850 sm_dprintf("milter_abort_filter(%s)\n", m->mf_name);
1851 if (MilterLogLevel > 10)
1852 sm_syslog(LOG_INFO, e->e_id, "Milter (%s): abort filter",
1853 m->mf_name);
1854
1855 if (m->mf_sock < 0 ||
1856 m->mf_state != SMFS_INMSG)
1857 return;
1858
1859 (void) milter_write(m, SMFIC_ABORT, (char *) NULL, 0,
1860 m->mf_timeout[SMFTO_WRITE], e, "abort_filter");
1861 if (m->mf_state != SMFS_ERROR)
1862 m->mf_state = SMFS_DONE;
1863 }
1864
1865 /*
1866 ** MILTER_SEND_MACROS -- provide macros to the filters
1867 **
1868 ** Parameters:
1869 ** m -- milter to send macros to.
1870 ** macros -- macros to send for filter smfi_getsymval().
1871 ** cmd -- which command the macros are associated with.
1872 ** e -- current envelope (for macro access).
1873 **
1874 ** Returns:
1875 ** none
1876 */
1877
1878 static void
milter_send_macros(m,macros,cmd,e)1879 milter_send_macros(m, macros, cmd, e)
1880 struct milter *m;
1881 char **macros;
1882 int cmd;
1883 ENVELOPE *e;
1884 {
1885 int i;
1886 int mid;
1887 char command = (char) cmd;
1888 char *v;
1889 char *buf, *bp;
1890 char exp[MAXLINE];
1891 ssize_t s;
1892
1893 /* sanity check */
1894 if (macros == NULL || macros[0] == NULL)
1895 return;
1896
1897 /* put together data */
1898 s = 1; /* for the command character */
1899 for (i = 0; macros[i] != NULL; i++)
1900 {
1901 mid = macid(macros[i]);
1902 if (mid == 0)
1903 continue;
1904 v = macvalue(mid, e);
1905 if (v == NULL)
1906 continue;
1907 expand(v, exp, sizeof(exp), e);
1908 s += strlen(macros[i]) + 1 + strlen(exp) + 1;
1909 }
1910
1911 if (s < 0)
1912 return;
1913
1914 buf = (char *) xalloc(s);
1915 bp = buf;
1916 *bp++ = command;
1917 for (i = 0; macros[i] != NULL; i++)
1918 {
1919 mid = macid(macros[i]);
1920 if (mid == 0)
1921 continue;
1922 v = macvalue(mid, e);
1923 if (v == NULL)
1924 continue;
1925 expand(v, exp, sizeof(exp), e);
1926
1927 if (tTd(64, 10))
1928 sm_dprintf("milter_send_macros(%s, %c): %s=%s\n",
1929 m->mf_name, command, macros[i], exp);
1930
1931 (void) sm_strlcpy(bp, macros[i], s - (bp - buf));
1932 bp += strlen(bp) + 1;
1933 (void) sm_strlcpy(bp, exp, s - (bp - buf));
1934 bp += strlen(bp) + 1;
1935 }
1936 (void) milter_write(m, SMFIC_MACRO, buf, s,
1937 m->mf_timeout[SMFTO_WRITE], e, "send_macros");
1938 sm_free(buf);
1939 }
1940
1941 /*
1942 ** MILTER_SEND_COMMAND -- send a command and return the response for a filter
1943 **
1944 ** Parameters:
1945 ** m -- current milter filter
1946 ** cmd -- command to send.
1947 ** data -- optional command data.
1948 ** sz -- length of buf.
1949 ** e -- current envelope (for e->e_id).
1950 ** state -- return state word.
1951 **
1952 ** Returns:
1953 ** response string (may be NULL)
1954 */
1955
1956 static char *
milter_send_command(m,cmd,data,sz,e,state,where)1957 milter_send_command(m, cmd, data, sz, e, state, where)
1958 struct milter *m;
1959 int cmd;
1960 void *data;
1961 ssize_t sz;
1962 ENVELOPE *e;
1963 char *state;
1964 const char *where;
1965 {
1966 char rcmd;
1967 ssize_t rlen;
1968 unsigned long skipflag;
1969 unsigned long norespflag = 0;
1970 char command = (char) cmd;
1971 char *action;
1972 char *defresponse;
1973 char *response;
1974
1975 if (tTd(64, 10))
1976 sm_dprintf("milter_send_command(%s): cmd %c len %ld\n",
1977 m->mf_name, (char) command, (long) sz);
1978
1979 /* find skip flag and default failure */
1980 switch (command)
1981 {
1982 case SMFIC_CONNECT:
1983 skipflag = SMFIP_NOCONNECT;
1984 norespflag = SMFIP_NR_CONN;
1985 action = "connect";
1986 defresponse = "554 Command rejected";
1987 break;
1988
1989 case SMFIC_HELO:
1990 skipflag = SMFIP_NOHELO;
1991 norespflag = SMFIP_NR_HELO;
1992 action = "helo";
1993 defresponse = "550 Command rejected";
1994 break;
1995
1996 case SMFIC_MAIL:
1997 skipflag = SMFIP_NOMAIL;
1998 norespflag = SMFIP_NR_MAIL;
1999 action = "mail";
2000 defresponse = "550 5.7.1 Command rejected";
2001 break;
2002
2003 case SMFIC_RCPT:
2004 skipflag = SMFIP_NORCPT;
2005 norespflag = SMFIP_NR_RCPT;
2006 action = "rcpt";
2007 defresponse = "550 5.7.1 Command rejected";
2008 break;
2009
2010 case SMFIC_HEADER:
2011 skipflag = SMFIP_NOHDRS;
2012 norespflag = SMFIP_NR_HDR;
2013 action = "header";
2014 defresponse = "550 5.7.1 Command rejected";
2015 break;
2016
2017 case SMFIC_BODY:
2018 skipflag = SMFIP_NOBODY;
2019 norespflag = SMFIP_NR_BODY;
2020 action = "body";
2021 defresponse = "554 5.7.1 Command rejected";
2022 break;
2023
2024 case SMFIC_EOH:
2025 skipflag = SMFIP_NOEOH;
2026 norespflag = SMFIP_NR_EOH;
2027 action = "eoh";
2028 defresponse = "550 5.7.1 Command rejected";
2029 break;
2030
2031 case SMFIC_UNKNOWN:
2032 skipflag = SMFIP_NOUNKNOWN;
2033 norespflag = SMFIP_NR_UNKN;
2034 action = "unknown";
2035 defresponse = "550 5.7.1 Command rejected";
2036 break;
2037
2038 case SMFIC_DATA:
2039 skipflag = SMFIP_NODATA;
2040 norespflag = SMFIP_NR_DATA;
2041 action = "data";
2042 defresponse = "550 5.7.1 Command rejected";
2043 break;
2044
2045 case SMFIC_BODYEOB:
2046 case SMFIC_OPTNEG:
2047 case SMFIC_MACRO:
2048 case SMFIC_ABORT:
2049 case SMFIC_QUIT:
2050 /* NOTE: not handled by milter_send_command() */
2051 /* FALLTHROUGH */
2052
2053 default:
2054 skipflag = 0;
2055 action = "default";
2056 defresponse = "550 5.7.1 Command rejected";
2057 break;
2058 }
2059
2060 if (tTd(64, 10))
2061 sm_dprintf("milter_send_command(%s): skip=%lx, pflags=%x\n",
2062 m->mf_name, skipflag, m->mf_pflags);
2063
2064 /* check if filter wants this command */
2065 if (skipflag != 0 && bitset(skipflag, m->mf_pflags))
2066 return NULL;
2067
2068 /* send the command to the filter */
2069 (void) milter_write(m, command, data, sz,
2070 m->mf_timeout[SMFTO_WRITE], e, where);
2071 if (m->mf_state == SMFS_ERROR)
2072 {
2073 MILTER_CHECK_ERROR(false, return NULL);
2074 return NULL;
2075 }
2076
2077 /* check if filter sends response to this command */
2078 if (norespflag != 0 && bitset(norespflag, m->mf_pflags))
2079 return NULL;
2080
2081 /* get the response from the filter */
2082 response = milter_read(m, &rcmd, &rlen,
2083 m->mf_timeout[SMFTO_READ], e, where);
2084 if (m->mf_state == SMFS_ERROR)
2085 {
2086 MILTER_CHECK_ERROR(false, return NULL);
2087 return NULL;
2088 }
2089
2090 if (tTd(64, 10))
2091 sm_dprintf("milter_send_command(%s): returned %c\n",
2092 m->mf_name, (char) rcmd);
2093
2094 switch (rcmd)
2095 {
2096 case SMFIR_REPLYCODE:
2097 MILTER_CHECK_REPLYCODE(defresponse);
2098 if (MilterLogLevel > 10)
2099 sm_syslog(LOG_INFO, e->e_id,
2100 "milter=%s, action=%s, reject=%s",
2101 m->mf_name, action, response);
2102 *state = rcmd;
2103 break;
2104
2105 case SMFIR_REJECT:
2106 if (MilterLogLevel > 10)
2107 sm_syslog(LOG_INFO, e->e_id,
2108 "milter=%s, action=%s, reject",
2109 m->mf_name, action);
2110 *state = rcmd;
2111 break;
2112
2113 case SMFIR_DISCARD:
2114 if (MilterLogLevel > 10)
2115 sm_syslog(LOG_INFO, e->e_id,
2116 "milter=%s, action=%s, discard",
2117 m->mf_name, action);
2118 *state = rcmd;
2119 break;
2120
2121 case SMFIR_TEMPFAIL:
2122 if (MilterLogLevel > 10)
2123 sm_syslog(LOG_INFO, e->e_id,
2124 "milter=%s, action=%s, tempfail",
2125 m->mf_name, action);
2126 *state = rcmd;
2127 break;
2128
2129 case SMFIR_ACCEPT:
2130 /* this filter is done with message/connection */
2131 if (command == SMFIC_HELO ||
2132 command == SMFIC_CONNECT)
2133 m->mf_state = SMFS_CLOSABLE;
2134 else
2135 m->mf_state = SMFS_DONE;
2136 if (MilterLogLevel > 10)
2137 sm_syslog(LOG_INFO, e->e_id,
2138 "milter=%s, action=%s, accepted",
2139 m->mf_name, action);
2140 break;
2141
2142 case SMFIR_CONTINUE:
2143 /* if MAIL command is ok, filter is in message state */
2144 if (command == SMFIC_MAIL)
2145 m->mf_state = SMFS_INMSG;
2146 if (MilterLogLevel > 12)
2147 sm_syslog(LOG_INFO, e->e_id,
2148 "milter=%s, action=%s, continue",
2149 m->mf_name, action);
2150 break;
2151
2152 case SMFIR_SKIP:
2153 if (MilterLogLevel > 12)
2154 sm_syslog(LOG_INFO, e->e_id,
2155 "milter=%s, action=%s, skip",
2156 m->mf_name, action);
2157 m->mf_state = SMFS_SKIP;
2158 break;
2159
2160 default:
2161 /* Invalid response to command */
2162 if (MilterLogLevel > 0)
2163 sm_syslog(LOG_ERR, e->e_id,
2164 "milter_send_command(%s): action=%s returned bogus response %c",
2165 m->mf_name, action, rcmd);
2166 milter_error(m, e); /* NO ERROR CHECK? */
2167 break;
2168 }
2169
2170 if (*state != SMFIR_REPLYCODE && response != NULL)
2171 {
2172 sm_free(response); /* XXX */
2173 response = NULL;
2174 }
2175 return response;
2176 }
2177
2178 /*
2179 ** MILTER_COMMAND -- send a command and return the response for each filter
2180 **
2181 ** Parameters:
2182 ** cmd -- command to send.
2183 ** data -- optional command data.
2184 ** sz -- length of buf.
2185 ** stage -- index of macros to send for filter smfi_getsymval().
2186 ** e -- current envelope (for macro access).
2187 ** state -- return state word.
2188 ** where -- description of calling function (logging).
2189 ** cmd_error -- did the SMTP command cause an error?
2190 **
2191 ** Returns:
2192 ** response string (may be NULL)
2193 */
2194
2195 static char *
milter_command(cmd,data,sz,stage,e,state,where,cmd_error)2196 milter_command(cmd, data, sz, stage, e, state, where, cmd_error)
2197 int cmd;
2198 void *data;
2199 ssize_t sz;
2200 int stage;
2201 ENVELOPE *e;
2202 char *state;
2203 const char *where;
2204 bool cmd_error;
2205 {
2206 int i;
2207 char command = (char) cmd;
2208 char *response = NULL;
2209 time_t tn = 0;
2210
2211 if (tTd(64, 10))
2212 sm_dprintf("milter_command: cmd %c len %ld\n",
2213 command, (long) sz);
2214
2215 *state = SMFIR_CONTINUE;
2216 for (i = 0; InputFilters[i] != NULL; i++)
2217 {
2218 struct milter *m = InputFilters[i];
2219
2220 /* previous problem? */
2221 if (m->mf_state == SMFS_ERROR)
2222 {
2223 MILTER_CHECK_ERROR(false, continue);
2224 break;
2225 }
2226
2227 /* sanity check */
2228 if (m->mf_sock < 0 ||
2229 (m->mf_state != SMFS_OPEN && m->mf_state != SMFS_INMSG))
2230 continue;
2231
2232 if (stage >= SMFIM_FIRST && stage <= SMFIM_LAST)
2233 {
2234 int idx;
2235 char **macros;
2236
2237 if ((m->mf_lflags & MI_LFLAGS_SYM(stage)) != 0)
2238 idx = m->mf_idx;
2239 else
2240 idx = 0;
2241 SM_ASSERT(idx >= 0 && idx <= MAXFILTERS);
2242 macros = MilterMacros[stage][idx];
2243
2244 /* send macros (regardless of whether we send cmd) */
2245 if (macros != NULL && macros[0] != NULL)
2246 {
2247 milter_send_macros(m, macros, command, e);
2248 if (m->mf_state == SMFS_ERROR)
2249 {
2250 MILTER_CHECK_ERROR(false, continue);
2251 break;
2252 }
2253 }
2254 }
2255
2256 if (MilterLogLevel > 21)
2257 tn = curtime();
2258
2259 /*
2260 ** send the command if
2261 ** there is no error
2262 ** or it's RCPT and the client asked for it:
2263 ** !cmd_error ||
2264 ** where == "rcpt" && m->mf_pflags & SMFIP_RCPT_REJ != 0
2265 ** negate that condition and use continue
2266 */
2267
2268 if (cmd_error &&
2269 (strcmp(where, "rcpt") != 0 ||
2270 (m->mf_pflags & SMFIP_RCPT_REJ) == 0))
2271 continue;
2272
2273 response = milter_send_command(m, command, data, sz, e, state,
2274 where);
2275
2276 if (MilterLogLevel > 21)
2277 {
2278 /* log the time it took for the command per filter */
2279 sm_syslog(LOG_INFO, e->e_id,
2280 "Milter (%s): time command (%c), %d",
2281 m->mf_name, command, (int) (tn - curtime()));
2282 }
2283
2284 if (*state != SMFIR_CONTINUE)
2285 break;
2286 }
2287 return response;
2288 }
2289
2290 static int milter_getsymlist __P((struct milter *, char *, int, int));
2291
2292 static int
milter_getsymlist(m,buf,rlen,offset)2293 milter_getsymlist(m, buf, rlen, offset)
2294 struct milter *m;
2295 char *buf;
2296 int rlen;
2297 int offset;
2298 {
2299 int i, r, nummac;
2300 mi_int32 v;
2301
2302 SM_ASSERT(m != NULL);
2303 SM_ASSERT(buf != NULL);
2304
2305 while (offset + MILTER_LEN_BYTES < rlen)
2306 {
2307 size_t len;
2308 char **macros;
2309
2310 nummac = 0;
2311 (void) memcpy((char *) &v, buf + offset, MILTER_LEN_BYTES);
2312 i = ntohl(v);
2313 if (i < SMFIM_FIRST || i > SMFIM_LAST)
2314 return -1;
2315 offset += MILTER_LEN_BYTES;
2316 macros = NULL;
2317
2318 #define SM_M_MACRO_NAME(i) (((i) < SM_ARRAY_SIZE(MilterOptTab) && (i) >= 0) \
2319 ? MilterOptTab[i].mo_name : "?")
2320 switch (i)
2321 {
2322 case SMFIM_CONNECT:
2323 case SMFIM_HELO:
2324 case SMFIM_ENVFROM:
2325 case SMFIM_ENVRCPT:
2326 case SMFIM_EOH:
2327 case SMFIM_EOM:
2328 case SMFIM_DATA:
2329 SM_ASSERT(m->mf_idx > 0 && m->mf_idx < MAXFILTERS);
2330 macros = MilterMacros[i][m->mf_idx];
2331 m->mf_lflags |= MI_LFLAGS_SYM(i);
2332 len = strlen(buf + offset);
2333 r = milter_set_macros(m->mf_name, macros, buf + offset,
2334 nummac);
2335 if (r >= 0)
2336 nummac = r;
2337 if (tTd(64, 5))
2338 sm_dprintf("milter_getsymlist(%s, %s, \"%s\")=%d\n",
2339 m->mf_name, SM_M_MACRO_NAME(i),
2340 buf + offset, r);
2341 break;
2342
2343 default:
2344 return -1;
2345 }
2346 offset += len + 1;
2347 }
2348
2349 return 0;
2350 }
2351
2352 /*
2353 ** MILTER_NEGOTIATE -- get version and flags from filter
2354 **
2355 ** Parameters:
2356 ** m -- milter filter structure.
2357 ** e -- current envelope.
2358 ** milters -- milters structure.
2359 **
2360 ** Returns:
2361 ** 0 on success, -1 otherwise
2362 */
2363
2364 static int
milter_negotiate(m,e,milters)2365 milter_negotiate(m, e, milters)
2366 struct milter *m;
2367 ENVELOPE *e;
2368 milters_T *milters;
2369 {
2370 char rcmd;
2371 mi_int32 fvers, fflags, pflags;
2372 mi_int32 mta_prot_vers, mta_prot_flags, mta_actions;
2373 ssize_t rlen;
2374 char *response;
2375 char data[MILTER_OPTLEN];
2376
2377 /* sanity check */
2378 if (m->mf_sock < 0 || m->mf_state != SMFS_OPEN)
2379 {
2380 if (MilterLogLevel > 0)
2381 sm_syslog(LOG_ERR, e->e_id,
2382 "Milter (%s): negotiate, impossible state",
2383 m->mf_name);
2384 milter_error(m, e);
2385 return -1;
2386 }
2387
2388 #if _FFR_MILTER_CHECK
2389 mta_prot_vers = m->mf_mta_prot_version;
2390 mta_prot_flags = m->mf_mta_prot_flags;
2391 mta_actions = m->mf_mta_actions;
2392 #else /* _FFR_MILTER_CHECK */
2393 mta_prot_vers = SMFI_PROT_VERSION;
2394 mta_prot_flags = SMFI_CURR_PROT;
2395 mta_actions = SMFI_CURR_ACTS;
2396 #endif /* _FFR_MILTER_CHECK */
2397 #if _FFR_MDS_NEGOTIATE
2398 if (MilterMaxDataSize == MILTER_MDS_256K)
2399 mta_prot_flags |= SMFIP_MDS_256K;
2400 else if (MilterMaxDataSize == MILTER_MDS_1M)
2401 mta_prot_flags |= SMFIP_MDS_1M;
2402 #endif /* _FFR_MDS_NEGOTIATE */
2403
2404 fvers = htonl(mta_prot_vers);
2405 pflags = htonl(mta_prot_flags);
2406 fflags = htonl(mta_actions);
2407 (void) memcpy(data, (char *) &fvers, MILTER_LEN_BYTES);
2408 (void) memcpy(data + MILTER_LEN_BYTES,
2409 (char *) &fflags, MILTER_LEN_BYTES);
2410 (void) memcpy(data + (MILTER_LEN_BYTES * 2),
2411 (char *) &pflags, MILTER_LEN_BYTES);
2412 (void) milter_write(m, SMFIC_OPTNEG, data, sizeof(data),
2413 m->mf_timeout[SMFTO_WRITE], e, "negotiate");
2414
2415 if (m->mf_state == SMFS_ERROR)
2416 return -1;
2417
2418 if (tTd(64, 5))
2419 sm_dprintf("milter_negotiate(%s): send: version %lu, fflags 0x%lx, pflags 0x%lx\n",
2420 m->mf_name, (unsigned long) ntohl(fvers),
2421 (unsigned long) ntohl(fflags),
2422 (unsigned long) ntohl(pflags));
2423
2424 response = milter_read(m, &rcmd, &rlen, m->mf_timeout[SMFTO_READ], e,
2425 "negotiate");
2426 if (m->mf_state == SMFS_ERROR)
2427 return -1;
2428
2429 if (rcmd != SMFIC_OPTNEG)
2430 {
2431 if (tTd(64, 5))
2432 sm_dprintf("milter_negotiate(%s): returned %c instead of %c\n",
2433 m->mf_name, rcmd, SMFIC_OPTNEG);
2434 if (MilterLogLevel > 0)
2435 sm_syslog(LOG_ERR, e->e_id,
2436 "Milter (%s): negotiate: returned %c instead of %c",
2437 m->mf_name, rcmd, SMFIC_OPTNEG);
2438 SM_FREE(response);
2439 milter_error(m, e);
2440 return -1;
2441 }
2442
2443 /* Make sure we have enough bytes for the version */
2444 if (response == NULL || rlen < MILTER_LEN_BYTES)
2445 {
2446 if (tTd(64, 5))
2447 sm_dprintf("milter_negotiate(%s): did not return valid info\n",
2448 m->mf_name);
2449 if (MilterLogLevel > 0)
2450 sm_syslog(LOG_ERR, e->e_id,
2451 "Milter (%s): negotiate: did not return valid info",
2452 m->mf_name);
2453 SM_FREE(response);
2454 milter_error(m, e);
2455 return -1;
2456 }
2457
2458 /* extract information */
2459 (void) memcpy((char *) &fvers, response, MILTER_LEN_BYTES);
2460
2461 /* Now make sure we have enough for the feature bitmap */
2462 if (rlen < MILTER_OPTLEN)
2463 {
2464 if (tTd(64, 5))
2465 sm_dprintf("milter_negotiate(%s): did not return enough info\n",
2466 m->mf_name);
2467 if (MilterLogLevel > 0)
2468 sm_syslog(LOG_ERR, e->e_id,
2469 "Milter (%s): negotiate: did not return enough info",
2470 m->mf_name);
2471 SM_FREE(response);
2472 milter_error(m, e);
2473 return -1;
2474 }
2475
2476 (void) memcpy((char *) &fflags, response + MILTER_LEN_BYTES,
2477 MILTER_LEN_BYTES);
2478 (void) memcpy((char *) &pflags, response + (MILTER_LEN_BYTES * 2),
2479 MILTER_LEN_BYTES);
2480
2481 m->mf_fvers = ntohl(fvers);
2482 m->mf_fflags = ntohl(fflags);
2483 m->mf_pflags = ntohl(pflags);
2484
2485 /* check for version compatibility */
2486 if (m->mf_fvers == 1 ||
2487 m->mf_fvers > SMFI_VERSION)
2488 {
2489 if (tTd(64, 5))
2490 sm_dprintf("milter_negotiate(%s): version %d != MTA milter version %d\n",
2491 m->mf_name, m->mf_fvers, SMFI_VERSION);
2492 if (MilterLogLevel > 0)
2493 sm_syslog(LOG_ERR, e->e_id,
2494 "Milter (%s): negotiate: version %d != MTA milter version %d",
2495 m->mf_name, m->mf_fvers, SMFI_VERSION);
2496 milter_error(m, e);
2497 goto error;
2498 }
2499
2500 /* check for filter feature mismatch */
2501 if ((m->mf_fflags & mta_actions) != m->mf_fflags)
2502 {
2503 if (tTd(64, 5))
2504 sm_dprintf("milter_negotiate(%s): filter abilities 0x%x != MTA milter abilities 0x%lx\n",
2505 m->mf_name, m->mf_fflags,
2506 (unsigned long) mta_actions);
2507 if (MilterLogLevel > 0)
2508 sm_syslog(LOG_ERR, e->e_id,
2509 "Milter (%s): negotiate: filter abilities 0x%x != MTA milter abilities 0x%lx",
2510 m->mf_name, m->mf_fflags,
2511 (unsigned long) mta_actions);
2512 milter_error(m, e);
2513 goto error;
2514 }
2515
2516 #if _FFR_MDS_NEGOTIATE
2517 #define MDSWARNING(sz) \
2518 do \
2519 { \
2520 sm_syslog(LOG_WARNING, NOQID, \
2521 "WARNING: Milter.maxdatasize: configured=%lu, set by milter(%s)=%d", \
2522 (unsigned long) MilterMaxDataSize, m->mf_name, sz); \
2523 MilterMaxDataSize = sz; \
2524 } while (0)
2525
2526 /* use a table instead of sequence? */
2527 if (bitset(SMFIP_MDS_1M, m->mf_pflags))
2528 {
2529 if (MilterMaxDataSize != MILTER_MDS_1M)
2530 MDSWARNING(MILTER_MDS_1M);
2531 }
2532 else if (bitset(SMFIP_MDS_256K, m->mf_pflags))
2533 {
2534 if (MilterMaxDataSize != MILTER_MDS_256K)
2535 MDSWARNING(MILTER_MDS_256K);
2536 }
2537
2538 /*
2539 ** Note: it is not possible to distinguish between
2540 ** - milter requested 64K
2541 ** - milter did not request anything
2542 ** as there is no SMFIP_MDS_64K flag.
2543 */
2544
2545 else if (MilterMaxDataSize != MILTER_MDS_64K)
2546 MDSWARNING(MILTER_MDS_64K);
2547 m->mf_pflags &= ~SMFI_INTERNAL;
2548 #endif /* _FFR_MDS_NEGOTIATE */
2549
2550 /* check for protocol feature mismatch */
2551 if ((m->mf_pflags & mta_prot_flags) != m->mf_pflags)
2552 {
2553 if (tTd(64, 5))
2554 sm_dprintf("milter_negotiate(%s): protocol abilities 0x%x != MTA milter abilities 0x%lx\n",
2555 m->mf_name, m->mf_pflags,
2556 (unsigned long) mta_prot_flags);
2557 if (MilterLogLevel > 0)
2558 sm_syslog(LOG_ERR, e->e_id,
2559 "Milter (%s): negotiate: protocol abilities 0x%x != MTA milter abilities 0x%lx",
2560 m->mf_name, m->mf_pflags,
2561 (unsigned long) mta_prot_flags);
2562 milter_error(m, e);
2563 goto error;
2564 }
2565
2566 if (m->mf_fvers <= 2)
2567 m->mf_pflags |= SMFIP_NOUNKNOWN;
2568 if (m->mf_fvers <= 3)
2569 m->mf_pflags |= SMFIP_NODATA;
2570
2571 if (rlen > MILTER_OPTLEN)
2572 {
2573 milter_getsymlist(m, response, rlen, MILTER_OPTLEN);
2574 }
2575
2576 if (bitset(SMFIF_DELRCPT, m->mf_fflags))
2577 milters->mis_flags |= MIS_FL_DEL_RCPT;
2578 if (!bitset(SMFIP_NORCPT, m->mf_pflags) &&
2579 !bitset(SMFIP_NR_RCPT, m->mf_pflags))
2580 milters->mis_flags |= MIS_FL_REJ_RCPT;
2581
2582 if (tTd(64, 5))
2583 sm_dprintf("milter_negotiate(%s): received: version %u, fflags 0x%x, pflags 0x%x\n",
2584 m->mf_name, m->mf_fvers, m->mf_fflags, m->mf_pflags);
2585 SM_FREE(response);
2586 return 0;
2587
2588 error:
2589 SM_FREE(response);
2590 return -1;
2591 }
2592
2593 /*
2594 ** MILTER_PER_CONNECTION_CHECK -- checks on per-connection commands
2595 **
2596 ** Reduce code duplication by putting these checks in one place
2597 **
2598 ** Parameters:
2599 ** e -- current envelope.
2600 **
2601 ** Returns:
2602 ** none
2603 */
2604
2605 static void
milter_per_connection_check(e)2606 milter_per_connection_check(e)
2607 ENVELOPE *e;
2608 {
2609 int i;
2610
2611 /* see if we are done with any of the filters */
2612 for (i = 0; InputFilters[i] != NULL; i++)
2613 {
2614 struct milter *m = InputFilters[i];
2615
2616 if (m->mf_state == SMFS_CLOSABLE)
2617 milter_quit_filter(m, e);
2618 }
2619 }
2620
2621 /*
2622 ** MILTER_ERROR -- Put a milter filter into error state
2623 **
2624 ** Parameters:
2625 ** m -- the broken filter.
2626 ** e -- current envelope.
2627 **
2628 ** Returns:
2629 ** none
2630 */
2631
2632 static void
milter_error(m,e)2633 milter_error(m, e)
2634 struct milter *m;
2635 ENVELOPE *e;
2636 {
2637 /*
2638 ** We could send a quit here but we may have gotten here due to
2639 ** an I/O error so we don't want to try to make things worse.
2640 */
2641
2642 if (m->mf_sock >= 0)
2643 {
2644 (void) close(m->mf_sock);
2645 m->mf_sock = -1;
2646 }
2647 m->mf_state = SMFS_ERROR;
2648
2649 if (MilterLogLevel > 0)
2650 sm_syslog(LOG_INFO, e->e_id, "Milter (%s): to error state",
2651 m->mf_name);
2652 }
2653
2654 /*
2655 ** MILTER_HEADERS -- send headers to a single milter filter
2656 **
2657 ** Parameters:
2658 ** m -- current filter.
2659 ** e -- current envelope.
2660 ** state -- return state from response.
2661 **
2662 ** Returns:
2663 ** response string (may be NULL)
2664 */
2665
2666 static char *
milter_headers(m,e,state)2667 milter_headers(m, e, state)
2668 struct milter *m;
2669 ENVELOPE *e;
2670 char *state;
2671 {
2672 char *response = NULL;
2673 HDR *h;
2674
2675 if (MilterLogLevel > 17)
2676 sm_syslog(LOG_INFO, e->e_id, "Milter (%s): headers, send",
2677 m->mf_name);
2678
2679 for (h = e->e_header; h != NULL; h = h->h_link)
2680 {
2681 int len_n, len_v, len_t, len_f;
2682 char *buf, *hv;
2683
2684 /* don't send over deleted headers */
2685 if (h->h_value == NULL)
2686 {
2687 /* strip H_USER so not counted in milter_changeheader() */
2688 h->h_flags &= ~H_USER;
2689 continue;
2690 }
2691
2692 /* skip auto-generated */
2693 if (!bitset(H_USER, h->h_flags))
2694 continue;
2695
2696 if (tTd(64, 10))
2697 sm_dprintf("milter_headers: %s:%s\n",
2698 h->h_field, h->h_value);
2699 if (MilterLogLevel > 21)
2700 sm_syslog(LOG_INFO, e->e_id, "Milter (%s): header, %s",
2701 m->mf_name, h->h_field);
2702
2703 if (bitset(SMFIP_HDR_LEADSPC, m->mf_pflags)
2704 || *(h->h_value) != ' ')
2705 hv = h->h_value;
2706 else
2707 hv = h->h_value + 1;
2708 len_f = strlen(h->h_field) + 1;
2709 len_t = len_f + strlen(hv) + 1;
2710 if (len_t < 0)
2711 continue;
2712 buf = (char *) xalloc(len_t);
2713
2714 /*
2715 ** Note: currently the call to dequote_internal_chars()
2716 ** is not required as h_field is supposed to be 7-bit US-ASCII.
2717 */
2718
2719 len_n = dequote_internal_chars(h->h_field, buf, len_f);
2720 SM_ASSERT(len_n < len_f);
2721 len_v = dequote_internal_chars(hv, buf + len_n + 1,
2722 len_t - len_n - 1);
2723 SM_ASSERT(len_t >= len_n + 1 + len_v + 1);
2724 len_t = len_n + 1 + len_v + 1;
2725
2726 /* send it over */
2727 response = milter_send_command(m, SMFIC_HEADER, buf,
2728 len_t, e, state, "header");
2729 sm_free(buf);
2730 if (m->mf_state == SMFS_ERROR ||
2731 m->mf_state == SMFS_DONE ||
2732 *state != SMFIR_CONTINUE)
2733 break;
2734 }
2735 if (MilterLogLevel > 17)
2736 sm_syslog(LOG_INFO, e->e_id, "Milter (%s): headers, sent",
2737 m->mf_name);
2738 return response;
2739 }
2740
2741 /*
2742 ** MILTER_BODY -- send the body to a filter
2743 **
2744 ** Parameters:
2745 ** m -- current filter.
2746 ** e -- current envelope.
2747 ** state -- return state from response.
2748 **
2749 ** Returns:
2750 ** response string (may be NULL)
2751 */
2752
2753 static char *
milter_body(m,e,state)2754 milter_body(m, e, state)
2755 struct milter *m;
2756 ENVELOPE *e;
2757 char *state;
2758 {
2759 char bufchar = '\0';
2760 char prevchar = '\0';
2761 int c;
2762 char *response = NULL;
2763 char *bp;
2764 char buf[MILTER_CHUNK_SIZE];
2765
2766 if (tTd(64, 10))
2767 sm_dprintf("milter_body\n");
2768
2769 if (bfrewind(e->e_dfp) < 0)
2770 {
2771 ExitStat = EX_IOERR;
2772 *state = SMFIR_TEMPFAIL;
2773 syserr("milter_body: %s/%cf%s: rewind error",
2774 qid_printqueue(e->e_qgrp, e->e_qdir),
2775 DATAFL_LETTER, e->e_id);
2776 return NULL;
2777 }
2778
2779 if (MilterLogLevel > 17)
2780 sm_syslog(LOG_INFO, e->e_id, "Milter (%s): body, send",
2781 m->mf_name);
2782 bp = buf;
2783 while ((c = sm_io_getc(e->e_dfp, SM_TIME_DEFAULT)) != SM_IO_EOF)
2784 {
2785 /* Change LF to CRLF */
2786 if (c == '\n')
2787 {
2788 #if !_FFR_MILTER_CONVERT_ALL_LF_TO_CRLF
2789 /* Not a CRLF already? */
2790 if (prevchar != '\r')
2791 #endif
2792 {
2793 /* Room for CR now? */
2794 if (bp + 2 > &buf[sizeof(buf)])
2795 {
2796 /* No room, buffer LF */
2797 bufchar = c;
2798
2799 /* and send CR now */
2800 c = '\r';
2801 }
2802 else
2803 {
2804 /* Room to do it now */
2805 *bp++ = '\r';
2806 prevchar = '\r';
2807 }
2808 }
2809 }
2810 *bp++ = (char) c;
2811 prevchar = c;
2812 if (bp >= &buf[sizeof(buf)])
2813 {
2814 /* send chunk */
2815 response = milter_send_command(m, SMFIC_BODY, buf,
2816 bp - buf, e, state,
2817 "body chunk");
2818 bp = buf;
2819 if (bufchar != '\0')
2820 {
2821 *bp++ = bufchar;
2822 bufchar = '\0';
2823 prevchar = bufchar;
2824 }
2825 }
2826 if (m->mf_state == SMFS_ERROR ||
2827 m->mf_state == SMFS_DONE ||
2828 m->mf_state == SMFS_SKIP ||
2829 *state != SMFIR_CONTINUE)
2830 break;
2831 }
2832
2833 /* check for read errors */
2834 if (sm_io_error(e->e_dfp))
2835 {
2836 ExitStat = EX_IOERR;
2837 if (*state == SMFIR_CONTINUE ||
2838 *state == SMFIR_ACCEPT ||
2839 m->mf_state == SMFS_SKIP)
2840 {
2841 *state = SMFIR_TEMPFAIL;
2842 if (response != NULL)
2843 {
2844 sm_free(response); /* XXX */
2845 response = NULL;
2846 }
2847 }
2848 syserr("milter_body: %s/%cf%s: read error",
2849 qid_printqueue(e->e_qgrp, e->e_qdir),
2850 DATAFL_LETTER, e->e_id);
2851 return response;
2852 }
2853
2854 /* send last body chunk */
2855 if (bp > buf &&
2856 m->mf_state != SMFS_ERROR &&
2857 m->mf_state != SMFS_DONE &&
2858 m->mf_state != SMFS_SKIP &&
2859 *state == SMFIR_CONTINUE)
2860 {
2861 /* send chunk */
2862 response = milter_send_command(m, SMFIC_BODY, buf, bp - buf,
2863 e, state, "last body chunk");
2864 bp = buf;
2865 }
2866 if (MilterLogLevel > 17)
2867 sm_syslog(LOG_INFO, e->e_id, "Milter (%s): body, sent",
2868 m->mf_name);
2869 if (m->mf_state == SMFS_SKIP)
2870 {
2871 *state = SMFIR_CONTINUE;
2872 m->mf_state = SMFS_READY;
2873 }
2874
2875 return response;
2876 }
2877
2878 /*
2879 ** Actions
2880 */
2881
2882 /*
2883 ** ADDLEADINGSPACE -- Add a leading space to a string
2884 **
2885 ** Parameters:
2886 ** str -- string
2887 ** rp -- resource pool for allocations
2888 **
2889 ** Returns:
2890 ** pointer to new string
2891 */
2892
2893 static char *addleadingspace __P((char *, SM_RPOOL_T *));
2894
2895 static char *
addleadingspace(str,rp)2896 addleadingspace(str, rp)
2897 char *str;
2898 SM_RPOOL_T *rp;
2899 {
2900 size_t l;
2901 char *new;
2902
2903 SM_ASSERT(str != NULL);
2904 l = strlen(str);
2905 SM_ASSERT(l + 2 > l);
2906 new = sm_rpool_malloc_x(rp, l + 2);
2907 new[0] = ' ';
2908 new[1] = '\0';
2909 sm_strlcpy(new + 1, str, l + 1);
2910 return new;
2911 }
2912
2913 /*
2914 ** MILTER_ADDHEADER -- Add the supplied header to the message
2915 **
2916 ** Parameters:
2917 ** m -- current filter.
2918 ** response -- encoded form of header/value.
2919 ** rlen -- length of response.
2920 ** e -- current envelope.
2921 **
2922 ** Returns:
2923 ** none
2924 */
2925
2926 static void
milter_addheader(m,response,rlen,e)2927 milter_addheader(m, response, rlen, e)
2928 struct milter *m;
2929 char *response;
2930 ssize_t rlen;
2931 ENVELOPE *e;
2932 {
2933 int mh_v_len;
2934 char *val, *mh_value;
2935 HDR *h;
2936
2937 if (tTd(64, 10))
2938 sm_dprintf("milter_addheader: ");
2939
2940 /* sanity checks */
2941 if (response == NULL)
2942 {
2943 if (tTd(64, 10))
2944 sm_dprintf("NULL response\n");
2945 return;
2946 }
2947
2948 if (rlen < 2 || strlen(response) + 1 >= (size_t) rlen)
2949 {
2950 if (tTd(64, 10))
2951 sm_dprintf("didn't follow protocol (total len %d != rlen %d)\n",
2952 (int) strlen(response), (int) (rlen - 1));
2953 return;
2954 }
2955
2956 /* Find separating NUL */
2957 val = response + strlen(response) + 1;
2958
2959 /* another sanity check */
2960 if (strlen(response) + strlen(val) + 2 != (size_t) rlen)
2961 {
2962 if (tTd(64, 10))
2963 sm_dprintf("didn't follow protocol (part len)\n");
2964 return;
2965 }
2966
2967 if (*response == '\0')
2968 {
2969 if (tTd(64, 10))
2970 sm_dprintf("empty field name\n");
2971 return;
2972 }
2973
2974 for (h = e->e_header; h != NULL; h = h->h_link)
2975 {
2976 if (sm_strcasecmp(h->h_field, response) == 0 &&
2977 !bitset(H_USER, h->h_flags) &&
2978 !bitset(H_TRACE, h->h_flags))
2979 break;
2980 }
2981
2982 mh_v_len = 0;
2983 mh_value = quote_internal_chars(val, NULL, &mh_v_len);
2984
2985 /* add to e_msgsize */
2986 e->e_msgsize += strlen(response) + 2 + strlen(val);
2987
2988 if (h != NULL)
2989 {
2990 if (tTd(64, 10))
2991 sm_dprintf("Replace default header %s value with %s\n",
2992 h->h_field, mh_value);
2993 if (MilterLogLevel > 8)
2994 sm_syslog(LOG_INFO, e->e_id,
2995 "Milter (%s) change: default header %s value with %s",
2996 m->mf_name, h->h_field, mh_value);
2997 if (bitset(SMFIP_HDR_LEADSPC, m->mf_pflags))
2998 h->h_value = mh_value;
2999 else
3000 {
3001 h->h_value = addleadingspace(mh_value, e->e_rpool);
3002 SM_FREE(mh_value);
3003 }
3004 h->h_flags |= H_USER;
3005 }
3006 else
3007 {
3008 if (tTd(64, 10))
3009 sm_dprintf("Add %s: %s\n", response, mh_value);
3010 if (MilterLogLevel > 8)
3011 sm_syslog(LOG_INFO, e->e_id,
3012 "Milter (%s) add: header: %s: %s",
3013 m->mf_name, response, mh_value);
3014 addheader(newstr(response), mh_value, H_USER, e,
3015 !bitset(SMFIP_HDR_LEADSPC, m->mf_pflags));
3016 SM_FREE(mh_value);
3017 }
3018 }
3019
3020 /*
3021 ** MILTER_INSHEADER -- Insert the supplied header
3022 **
3023 ** Parameters:
3024 ** m -- current filter.
3025 ** response -- encoded form of header/value.
3026 ** rlen -- length of response.
3027 ** e -- current envelope.
3028 **
3029 ** Returns:
3030 ** none
3031 **
3032 ** Notes:
3033 ** Unlike milter_addheader(), this does not attempt to determine
3034 ** if the header already exists in the envelope, even a
3035 ** deleted version. It just blindly inserts.
3036 */
3037
3038 static void
milter_insheader(m,response,rlen,e)3039 milter_insheader(m, response, rlen, e)
3040 struct milter *m;
3041 char *response;
3042 ssize_t rlen;
3043 ENVELOPE *e;
3044 {
3045 mi_int32 idx, i;
3046 int mh_v_len;
3047 char *field, *val, *mh_value;
3048
3049 if (tTd(64, 10))
3050 sm_dprintf("milter_insheader: ");
3051
3052 /* sanity checks */
3053 if (response == NULL)
3054 {
3055 if (tTd(64, 10))
3056 sm_dprintf("NULL response\n");
3057 return;
3058 }
3059
3060 if (rlen < 2 || strlen(response) + 1 >= (size_t) rlen)
3061 {
3062 if (tTd(64, 10))
3063 sm_dprintf("didn't follow protocol (total len)\n");
3064 return;
3065 }
3066
3067 /* decode */
3068 (void) memcpy((char *) &i, response, MILTER_LEN_BYTES);
3069 idx = ntohl(i);
3070 field = response + MILTER_LEN_BYTES;
3071 val = field + strlen(field) + 1;
3072
3073 /* another sanity check */
3074 if (MILTER_LEN_BYTES + strlen(field) + 1 +
3075 strlen(val) + 1 != (size_t) rlen)
3076 {
3077 if (tTd(64, 10))
3078 sm_dprintf("didn't follow protocol (part len)\n");
3079 return;
3080 }
3081
3082 if (*field == '\0')
3083 {
3084 if (tTd(64, 10))
3085 sm_dprintf("empty field name\n");
3086 return;
3087 }
3088
3089 /* add to e_msgsize */
3090 e->e_msgsize += strlen(response) + 2 + strlen(val);
3091
3092 if (tTd(64, 10))
3093 sm_dprintf("Insert (%d) %s: %s\n", idx, field, val);
3094 if (MilterLogLevel > 8)
3095 sm_syslog(LOG_INFO, e->e_id,
3096 "Milter (%s) insert (%d): header: %s: %s",
3097 m->mf_name, idx, field, val);
3098 mh_v_len = 0;
3099 mh_value = quote_internal_chars(val, NULL, &mh_v_len);
3100 insheader(idx, newstr(field), mh_value, H_USER, e,
3101 !bitset(SMFIP_HDR_LEADSPC, m->mf_pflags));
3102 SM_FREE(mh_value);
3103 }
3104
3105 /*
3106 ** MILTER_CHANGEHEADER -- Change the supplied header in the message
3107 **
3108 ** Parameters:
3109 ** m -- current filter.
3110 ** response -- encoded form of header/index/value.
3111 ** rlen -- length of response.
3112 ** e -- current envelope.
3113 **
3114 ** Returns:
3115 ** none
3116 */
3117
3118 static void
milter_changeheader(m,response,rlen,e)3119 milter_changeheader(m, response, rlen, e)
3120 struct milter *m;
3121 char *response;
3122 ssize_t rlen;
3123 ENVELOPE *e;
3124 {
3125 mi_int32 i, index;
3126 int mh_v_len;
3127 char *field, *val, *mh_value;
3128 HDR *h, *sysheader;
3129
3130 if (tTd(64, 10))
3131 sm_dprintf("milter_changeheader: ");
3132
3133 /* sanity checks */
3134 if (response == NULL)
3135 {
3136 if (tTd(64, 10))
3137 sm_dprintf("NULL response\n");
3138 return;
3139 }
3140
3141 if (rlen < 2 || strlen(response) + 1 >= (size_t) rlen)
3142 {
3143 if (tTd(64, 10))
3144 sm_dprintf("didn't follow protocol (total len)\n");
3145 return;
3146 }
3147
3148 /* Find separating NUL */
3149 (void) memcpy((char *) &i, response, MILTER_LEN_BYTES);
3150 index = ntohl(i);
3151 field = response + MILTER_LEN_BYTES;
3152 val = field + strlen(field) + 1;
3153
3154 /* another sanity check */
3155 if (MILTER_LEN_BYTES + strlen(field) + 1 +
3156 strlen(val) + 1 != (size_t) rlen)
3157 {
3158 if (tTd(64, 10))
3159 sm_dprintf("didn't follow protocol (part len)\n");
3160 return;
3161 }
3162
3163 if (*field == '\0')
3164 {
3165 if (tTd(64, 10))
3166 sm_dprintf("empty field name\n");
3167 return;
3168 }
3169
3170 mh_v_len = 0;
3171 mh_value = quote_internal_chars(val, NULL, &mh_v_len);
3172
3173 sysheader = NULL;
3174 for (h = e->e_header; h != NULL; h = h->h_link)
3175 {
3176 if (sm_strcasecmp(h->h_field, field) == 0)
3177 {
3178 if (bitset(H_USER, h->h_flags) && --index <= 0)
3179 {
3180 sysheader = NULL;
3181 break;
3182 }
3183 else if (!bitset(H_USER, h->h_flags) &&
3184 !bitset(H_TRACE, h->h_flags))
3185 {
3186 /*
3187 ** RFC 2822:
3188 ** 27. No multiple occurrences of fields
3189 ** (except resent and received).*
3190 ** so make sure we replace any non-trace,
3191 ** non-user field.
3192 */
3193
3194 sysheader = h;
3195 }
3196 }
3197 }
3198
3199 /* if not found as user-provided header at index, use sysheader */
3200 if (h == NULL)
3201 h = sysheader;
3202
3203 if (h == NULL)
3204 {
3205 if (*val == '\0')
3206 {
3207 if (tTd(64, 10))
3208 sm_dprintf("Delete (noop) %s\n", field);
3209 if (MilterLogLevel > 8)
3210 sm_syslog(LOG_INFO, e->e_id,
3211 "Milter (%s) delete (noop): header: %s"
3212 , m->mf_name, field);
3213 }
3214 else
3215 {
3216 /* treat modify value with no existing header as add */
3217 if (tTd(64, 10))
3218 sm_dprintf("Add %s: %s\n", field, mh_value);
3219 if (MilterLogLevel > 8)
3220 sm_syslog(LOG_INFO, e->e_id,
3221 "Milter (%s) change (add): header: %s: %s"
3222 , m->mf_name, field, mh_value);
3223 addheader(newstr(field), mh_value, H_USER, e,
3224 !bitset(SMFIP_HDR_LEADSPC, m->mf_pflags));
3225 }
3226 SM_FREE(mh_value);
3227 return;
3228 }
3229
3230 if (tTd(64, 10))
3231 {
3232 if (*val == '\0')
3233 {
3234 sm_dprintf("Delete%s %s:%s\n",
3235 h == sysheader ? " (default header)" : "",
3236 field,
3237 h->h_value == NULL ? "<NULL>" : h->h_value);
3238 }
3239 else
3240 {
3241 sm_dprintf("Change%s %s: from %s to %s\n",
3242 h == sysheader ? " (default header)" : "",
3243 field,
3244 h->h_value == NULL ? "<NULL>" : h->h_value,
3245 mh_value);
3246 }
3247 }
3248
3249 if (MilterLogLevel > 8)
3250 {
3251 if (*val == '\0')
3252 {
3253 sm_syslog(LOG_INFO, e->e_id,
3254 "Milter (%s) delete: header%s %s:%s",
3255 m->mf_name,
3256 h == sysheader ? " (default header)" : "",
3257 field,
3258 h->h_value == NULL ? "<NULL>" : h->h_value);
3259 }
3260 else
3261 {
3262 sm_syslog(LOG_INFO, e->e_id,
3263 "Milter (%s) change: header%s %s: from %s to %s",
3264 m->mf_name,
3265 h == sysheader ? " (default header)" : "",
3266 field,
3267 h->h_value == NULL ? "<NULL>" : h->h_value,
3268 mh_value);
3269 }
3270 }
3271
3272 if (h != sysheader && h->h_value != NULL)
3273 {
3274 size_t l;
3275
3276 l = strlen(h->h_value);
3277 if (l > e->e_msgsize)
3278 e->e_msgsize = 0;
3279 else
3280 e->e_msgsize -= l;
3281 /* rpool, don't free: sm_free(h->h_value); XXX */
3282 }
3283
3284 if (*val == '\0')
3285 {
3286 /* Remove "Field: " from message size */
3287 if (h != sysheader)
3288 {
3289 size_t l;
3290
3291 l = strlen(h->h_field) + 2;
3292 if (l > e->e_msgsize)
3293 e->e_msgsize = 0;
3294 else
3295 e->e_msgsize -= l;
3296 }
3297 h->h_value = NULL;
3298 SM_FREE(mh_value);
3299 }
3300 else
3301 {
3302 if (bitset(SMFIP_HDR_LEADSPC, m->mf_pflags))
3303 h->h_value = mh_value;
3304 else
3305 {
3306 h->h_value = addleadingspace(mh_value, e->e_rpool);
3307 SM_FREE(mh_value);
3308 }
3309 h->h_flags |= H_USER;
3310 e->e_msgsize += strlen(h->h_value);
3311 }
3312 }
3313
3314 /*
3315 ** MILTER_SPLIT_RESPONSE -- Split response into fields.
3316 **
3317 ** Parameters:
3318 ** response -- encoded repsonse.
3319 ** rlen -- length of response.
3320 ** pargc -- number of arguments (ouput)
3321 **
3322 ** Returns:
3323 ** array of pointers to the individual strings
3324 */
3325
3326 static char **milter_split_response __P((char *, ssize_t, int *));
3327
3328 static char **
milter_split_response(response,rlen,pargc)3329 milter_split_response(response, rlen, pargc)
3330 char *response;
3331 ssize_t rlen;
3332 int *pargc;
3333 {
3334 char **s;
3335 size_t i;
3336 int elem, nelem;
3337
3338 SM_ASSERT(response != NULL);
3339 SM_ASSERT(pargc != NULL);
3340 *pargc = 0;
3341 if (rlen < 2 || strlen(response) >= (size_t) rlen)
3342 {
3343 if (tTd(64, 10))
3344 sm_dprintf("didn't follow protocol (total len %d != rlen %d)\n",
3345 (int) strlen(response), (int) (rlen - 1));
3346 return NULL;
3347 }
3348
3349 nelem = 0;
3350 for (i = 0; i < rlen; i++)
3351 {
3352 if (response[i] == '\0')
3353 ++nelem;
3354 }
3355 if (nelem == 0)
3356 return NULL;
3357
3358 /* last entry is only for the name */
3359 s = (char **)malloc((nelem + 1) * (sizeof(*s)));
3360 if (s == NULL)
3361 return NULL;
3362 s[0] = response;
3363 for (i = 0, elem = 0; i < rlen && elem < nelem; i++)
3364 {
3365 if (response[i] == '\0')
3366 {
3367 ++elem;
3368 if (i + 1 >= rlen)
3369 s[elem] = NULL;
3370 else
3371 s[elem] = &(response[i + 1]);
3372 }
3373 }
3374 *pargc = nelem;
3375
3376 if (tTd(64, 10))
3377 {
3378 for (elem = 0; elem < nelem; elem++)
3379 sm_dprintf("argv[%d]=\"%s\"\n", elem, s[elem]);
3380 }
3381
3382 /* overwrite last entry (already done above, just paranoia) */
3383 s[elem] = NULL;
3384 return s;
3385 }
3386
3387 /*
3388 ** MILTER_CHGFROM -- Change the envelope sender address
3389 **
3390 ** Parameters:
3391 ** response -- encoded form of recipient address.
3392 ** rlen -- length of response.
3393 ** e -- current envelope.
3394 ** mname -- name of milter.
3395 **
3396 ** Returns:
3397 ** none
3398 */
3399
3400 static void
milter_chgfrom(response,rlen,e,mname)3401 milter_chgfrom(response, rlen, e, mname)
3402 char *response;
3403 ssize_t rlen;
3404 ENVELOPE *e;
3405 const char *mname;
3406 {
3407 int olderrors, argc;
3408 char **argv;
3409
3410 if (tTd(64, 10))
3411 sm_dprintf("milter_chgfrom: ");
3412
3413 /* sanity checks */
3414 if (response == NULL)
3415 {
3416 if (tTd(64, 10))
3417 sm_dprintf("NULL response\n");
3418 return;
3419 }
3420
3421 if (*response == '\0' ||
3422 strlen(response) + 1 > (size_t) rlen)
3423 {
3424 if (tTd(64, 10))
3425 sm_dprintf("didn't follow protocol (total len %d != rlen %d)\n",
3426 (int) strlen(response), (int) (rlen - 1));
3427 return;
3428 }
3429
3430 if (tTd(64, 10))
3431 sm_dprintf("%s\n", response);
3432 if (MilterLogLevel > 8)
3433 sm_syslog(LOG_INFO, e->e_id, "Milter (%s) chgfrom: %s",
3434 mname, response);
3435 argv = milter_split_response(response, rlen, &argc);
3436 if (argc < 1 || argc > 2)
3437 {
3438 if (tTd(64, 10))
3439 sm_dprintf("didn't follow protocol argc=%d\n", argc);
3440 if (argv != NULL)
3441 free(argv);
3442 return;
3443 }
3444
3445 olderrors = Errors;
3446 setsender(argv[0], e, NULL, '\0', false);
3447 if (argc == 2)
3448 {
3449 reset_mail_esmtp_args(e);
3450
3451 /*
3452 ** need "features" here: how to get those? via e?
3453 ** "fake" it for now: allow everything.
3454 */
3455
3456 parse_esmtp_args(e, NULL, argv[0], argv[1], "MAIL", NULL,
3457 mail_esmtp_args);
3458 }
3459 Errors = olderrors;
3460 free(argv);
3461 return;
3462 }
3463
3464 /*
3465 ** MILTER_ADDRCPT_PAR -- Add the supplied recipient to the message
3466 **
3467 ** Parameters:
3468 ** response -- encoded form of recipient address.
3469 ** rlen -- length of response.
3470 ** e -- current envelope.
3471 ** mname -- name of milter.
3472 **
3473 ** Returns:
3474 ** none
3475 */
3476
3477 static void
milter_addrcpt_par(response,rlen,e,mname)3478 milter_addrcpt_par(response, rlen, e, mname)
3479 char *response;
3480 ssize_t rlen;
3481 ENVELOPE *e;
3482 const char *mname;
3483 {
3484 int olderrors, argc;
3485 char *delimptr;
3486 char **argv;
3487 ADDRESS *a;
3488
3489 if (tTd(64, 10))
3490 sm_dprintf("milter_addrcpt_par: ");
3491
3492 /* sanity checks */
3493 if (response == NULL)
3494 {
3495 if (tTd(64, 10))
3496 sm_dprintf("NULL response\n");
3497 return;
3498 }
3499
3500 if (tTd(64, 10))
3501 sm_dprintf("%s\n", response);
3502 if (MilterLogLevel > 8)
3503 sm_syslog(LOG_INFO, e->e_id, "Milter (%s) add: rcpt: %s",
3504 mname, response);
3505
3506 argv = milter_split_response(response, rlen, &argc);
3507 if (argc < 1 || argc > 2)
3508 {
3509 if (tTd(64, 10))
3510 sm_dprintf("didn't follow protocol argc=%d\n", argc);
3511 if (argv != NULL)
3512 free(argv);
3513 return;
3514 }
3515 olderrors = Errors;
3516
3517 /* how to set ESMTP arguments? */
3518 a = parseaddr(argv[0], NULLADDR, RF_COPYALL, ' ', &delimptr, e, true);
3519
3520 if (a != NULL && olderrors == Errors)
3521 {
3522 parse_esmtp_args(e, a, argv[0], argv[1], "RCPT", NULL,
3523 rcpt_esmtp_args);
3524 if (olderrors == Errors)
3525 a = recipient(a, &e->e_sendqueue, 0, e);
3526 else
3527 sm_dprintf("olderrors=%d, Errors=%d\n",
3528 olderrors, Errors);
3529 }
3530 else
3531 {
3532 sm_dprintf("a=%p, olderrors=%d, Errors=%d\n",
3533 (void *)a, olderrors, Errors);
3534 }
3535
3536 Errors = olderrors;
3537 free(argv);
3538 return;
3539 }
3540
3541 /*
3542 ** MILTER_ADDRCPT -- Add the supplied recipient to the message
3543 **
3544 ** Parameters:
3545 ** response -- encoded form of recipient address.
3546 ** rlen -- length of response.
3547 ** e -- current envelope.
3548 ** mname -- name of milter.
3549 **
3550 ** Returns:
3551 ** none
3552 */
3553
3554 static void
milter_addrcpt(response,rlen,e,mname)3555 milter_addrcpt(response, rlen, e, mname)
3556 char *response;
3557 ssize_t rlen;
3558 ENVELOPE *e;
3559 const char *mname;
3560 {
3561 int olderrors;
3562
3563 if (tTd(64, 10))
3564 sm_dprintf("milter_addrcpt: ");
3565
3566 /* sanity checks */
3567 if (response == NULL)
3568 {
3569 if (tTd(64, 10))
3570 sm_dprintf("NULL response\n");
3571 return;
3572 }
3573
3574 if (*response == '\0' ||
3575 strlen(response) + 1 != (size_t) rlen)
3576 {
3577 if (tTd(64, 10))
3578 sm_dprintf("didn't follow protocol (total len %d != rlen %d)\n",
3579 (int) strlen(response), (int) (rlen - 1));
3580 return;
3581 }
3582
3583 if (tTd(64, 10))
3584 sm_dprintf("%s\n", response);
3585 if (MilterLogLevel > 8)
3586 sm_syslog(LOG_INFO, e->e_id, "Milter (%s) add: rcpt: %s",
3587 mname, response);
3588 olderrors = Errors;
3589 (void) sendtolist(response, NULLADDR, &e->e_sendqueue, 0, e);
3590 Errors = olderrors;
3591 return;
3592 }
3593
3594 /*
3595 ** MILTER_DELRCPT -- Delete the supplied recipient from the message
3596 **
3597 ** Parameters:
3598 ** response -- encoded form of recipient address.
3599 ** rlen -- length of response.
3600 ** e -- current envelope.
3601 ** mname -- name of milter.
3602 **
3603 ** Returns:
3604 ** none
3605 */
3606
3607 static void
milter_delrcpt(response,rlen,e,mname)3608 milter_delrcpt(response, rlen, e, mname)
3609 char *response;
3610 ssize_t rlen;
3611 ENVELOPE *e;
3612 const char *mname;
3613 {
3614 int r;
3615
3616 if (tTd(64, 10))
3617 sm_dprintf("milter_delrcpt: ");
3618
3619 /* sanity checks */
3620 if (response == NULL)
3621 {
3622 if (tTd(64, 10))
3623 sm_dprintf("NULL response\n");
3624 return;
3625 }
3626
3627 if (*response == '\0' ||
3628 strlen(response) + 1 != (size_t) rlen)
3629 {
3630 if (tTd(64, 10))
3631 sm_dprintf("didn't follow protocol (total len %d != rlen %d)\n",
3632 (int) strlen(response), (int) (rlen - 1));
3633 return;
3634 }
3635
3636 if (tTd(64, 10))
3637 sm_dprintf("%s\n", response);
3638 r = removefromlist(response, &e->e_sendqueue, e);
3639 if (MilterLogLevel > 8)
3640 sm_syslog(LOG_INFO, e->e_id, "Milter (%s) delete: rcpt %s, naddrs=%d",
3641 mname, response, r);
3642 return;
3643 }
3644
3645 /*
3646 ** MILTER_REPLBODY -- Replace the current data file with new body
3647 **
3648 ** Parameters:
3649 ** response -- encoded form of new body.
3650 ** rlen -- length of response.
3651 ** newfilter -- if first time called by a new filter
3652 ** e -- current envelope.
3653 ** mname -- name of milter.
3654 **
3655 ** Returns:
3656 ** 0 upon success, -1 upon failure
3657 */
3658
3659 static int
milter_replbody(response,rlen,newfilter,e,mname)3660 milter_replbody(response, rlen, newfilter, e, mname)
3661 char *response;
3662 ssize_t rlen;
3663 bool newfilter;
3664 ENVELOPE *e;
3665 const char *mname;
3666 {
3667 static char prevchar;
3668 int i;
3669
3670 if (tTd(64, 10))
3671 sm_dprintf("milter_replbody\n");
3672
3673 /* If a new filter, reset previous character and truncate data file */
3674 if (newfilter)
3675 {
3676 off_t prevsize;
3677 char dfname[MAXPATHLEN];
3678
3679 (void) sm_strlcpy(dfname, queuename(e, DATAFL_LETTER),
3680 sizeof(dfname));
3681
3682 /* Reset prevchar */
3683 prevchar = '\0';
3684
3685 /* Get the current data file information */
3686 prevsize = sm_io_getinfo(e->e_dfp, SM_IO_WHAT_SIZE, NULL);
3687 if (prevsize < 0)
3688 prevsize = 0;
3689
3690 /* truncate current data file */
3691 if (sm_io_getinfo(e->e_dfp, SM_IO_WHAT_ISTYPE, BF_FILE_TYPE))
3692 {
3693 if (sm_io_setinfo(e->e_dfp, SM_BF_TRUNCATE, NULL) < 0)
3694 {
3695 MILTER_DF_ERROR("milter_replbody: sm_io truncate %s: %s");
3696 return -1;
3697 }
3698 }
3699 else
3700 {
3701 int err;
3702
3703 err = sm_io_error(e->e_dfp);
3704 (void) sm_io_flush(e->e_dfp, SM_TIME_DEFAULT);
3705
3706 /*
3707 ** Clear error if tried to fflush()
3708 ** a read-only file pointer and
3709 ** there wasn't a previous error.
3710 */
3711
3712 if (err == 0)
3713 sm_io_clearerr(e->e_dfp);
3714
3715 /* errno is set implicitly by fseek() before return */
3716 err = sm_io_seek(e->e_dfp, SM_TIME_DEFAULT,
3717 0, SEEK_SET);
3718 if (err < 0)
3719 {
3720 MILTER_DF_ERROR("milter_replbody: sm_io_seek %s: %s");
3721 return -1;
3722 }
3723 # if NOFTRUNCATE
3724 /* XXX: Not much we can do except rewind it */
3725 errno = EINVAL;
3726 MILTER_DF_ERROR("milter_replbody: ftruncate not available on this platform (%s:%s)");
3727 return -1;
3728 # else /* NOFTRUNCATE */
3729 err = ftruncate(sm_io_getinfo(e->e_dfp,
3730 SM_IO_WHAT_FD, NULL),
3731 0);
3732 if (err < 0)
3733 {
3734 MILTER_DF_ERROR("milter_replbody: sm_io ftruncate %s: %s");
3735 return -1;
3736 }
3737 # endif /* NOFTRUNCATE */
3738 }
3739
3740 if (prevsize > e->e_msgsize)
3741 e->e_msgsize = 0;
3742 else
3743 e->e_msgsize -= prevsize;
3744 }
3745
3746 if (newfilter && MilterLogLevel > 8)
3747 sm_syslog(LOG_INFO, e->e_id, "Milter (%s) message: body replaced",
3748 mname);
3749
3750 if (response == NULL)
3751 {
3752 /* Flush the buffered '\r' */
3753 if (prevchar == '\r')
3754 {
3755 (void) sm_io_putc(e->e_dfp, SM_TIME_DEFAULT, prevchar);
3756 e->e_msgsize++;
3757 }
3758 return 0;
3759 }
3760
3761 for (i = 0; i < rlen; i++)
3762 {
3763 /* Buffered char from last chunk */
3764 if (i == 0 && prevchar == '\r')
3765 {
3766 /* Not CRLF, output prevchar */
3767 if (response[i] != '\n')
3768 {
3769 (void) sm_io_putc(e->e_dfp, SM_TIME_DEFAULT,
3770 prevchar);
3771 e->e_msgsize++;
3772 }
3773 prevchar = '\0';
3774 }
3775
3776 /* Turn CRLF into LF */
3777 if (response[i] == '\r')
3778 {
3779 /* check if at end of chunk */
3780 if (i + 1 < rlen)
3781 {
3782 /* If LF, strip CR */
3783 if (response[i + 1] == '\n')
3784 i++;
3785 }
3786 else
3787 {
3788 /* check next chunk */
3789 prevchar = '\r';
3790 continue;
3791 }
3792 }
3793 (void) sm_io_putc(e->e_dfp, SM_TIME_DEFAULT, response[i]);
3794 e->e_msgsize++;
3795 }
3796 return 0;
3797 }
3798
3799 /*
3800 ** MTA callouts
3801 */
3802
3803 /*
3804 ** MILTER_INIT -- open and negotiate with all of the filters
3805 **
3806 ** Parameters:
3807 ** e -- current envelope.
3808 ** state -- return state from response.
3809 ** milters -- milters structure.
3810 **
3811 ** Returns:
3812 ** true iff at least one filter is active
3813 */
3814
3815 /* ARGSUSED */
3816 bool
milter_init(e,state,milters)3817 milter_init(e, state, milters)
3818 ENVELOPE *e;
3819 char *state;
3820 milters_T *milters;
3821 {
3822 int i;
3823
3824 if (tTd(64, 10))
3825 sm_dprintf("milter_init\n");
3826
3827 memset(milters, '\0', sizeof(*milters));
3828 *state = SMFIR_CONTINUE;
3829 if (InputFilters[0] == NULL)
3830 {
3831 if (MilterLogLevel > 10)
3832 sm_syslog(LOG_INFO, e->e_id,
3833 "Milter: no active filter");
3834 return false;
3835 }
3836
3837 for (i = 0; InputFilters[i] != NULL; i++)
3838 {
3839 struct milter *m = InputFilters[i];
3840
3841 m->mf_sock = milter_open(m, false, e);
3842 if (m->mf_state == SMFS_ERROR)
3843 {
3844 MILTER_CHECK_ERROR(true, continue);
3845 break;
3846 }
3847
3848 if (m->mf_sock < 0 ||
3849 milter_negotiate(m, e, milters) < 0 ||
3850 m->mf_state == SMFS_ERROR)
3851 {
3852 if (tTd(64, 5))
3853 sm_dprintf("milter_init(%s): failed to %s\n",
3854 m->mf_name,
3855 m->mf_sock < 0 ? "open" :
3856 "negotiate");
3857 if (MilterLogLevel > 0)
3858 sm_syslog(LOG_ERR, e->e_id,
3859 "Milter (%s): init failed to %s",
3860 m->mf_name,
3861 m->mf_sock < 0 ? "open" :
3862 "negotiate");
3863
3864 /* if negotiation failure, close socket */
3865 milter_error(m, e);
3866 MILTER_CHECK_ERROR(true, continue);
3867 continue;
3868 }
3869 if (MilterLogLevel > 9)
3870 sm_syslog(LOG_INFO, e->e_id,
3871 "Milter (%s): init success to %s",
3872 m->mf_name,
3873 m->mf_sock < 0 ? "open" : "negotiate");
3874 }
3875
3876 /*
3877 ** If something temp/perm failed with one of the filters,
3878 ** we won't be using any of them, so clear any existing
3879 ** connections.
3880 */
3881
3882 if (*state != SMFIR_CONTINUE)
3883 milter_quit(e);
3884
3885 return true;
3886 }
3887
3888 /*
3889 ** MILTER_CONNECT -- send connection info to milter filters
3890 **
3891 ** Parameters:
3892 ** hostname -- hostname of remote machine.
3893 ** addr -- address of remote machine.
3894 ** e -- current envelope.
3895 ** state -- return state from response.
3896 **
3897 ** Returns:
3898 ** response string (may be NULL)
3899 */
3900
3901 char *
milter_connect(hostname,addr,e,state)3902 milter_connect(hostname, addr, e, state)
3903 char *hostname;
3904 SOCKADDR addr;
3905 ENVELOPE *e;
3906 char *state;
3907 {
3908 char family;
3909 unsigned short port;
3910 char *buf, *bp;
3911 char *response;
3912 char *sockinfo = NULL;
3913 ssize_t s;
3914 # if NETINET6
3915 char buf6[INET6_ADDRSTRLEN];
3916 # endif
3917
3918 if (tTd(64, 10))
3919 sm_dprintf("milter_connect(%s)\n", hostname);
3920 if (MilterLogLevel > 9)
3921 sm_syslog(LOG_INFO, e->e_id, "Milter: connect to filters");
3922
3923 /* gather data */
3924 switch (addr.sa.sa_family)
3925 {
3926 # if NETUNIX
3927 case AF_UNIX:
3928 family = SMFIA_UNIX;
3929 port = htons(0);
3930 sockinfo = addr.sunix.sun_path;
3931 break;
3932 # endif /* NETUNIX */
3933
3934 # if NETINET
3935 case AF_INET:
3936 family = SMFIA_INET;
3937 port = addr.sin.sin_port;
3938 sockinfo = (char *) inet_ntoa(addr.sin.sin_addr);
3939 break;
3940 # endif /* NETINET */
3941
3942 # if NETINET6
3943 case AF_INET6:
3944 if (IN6_IS_ADDR_V4MAPPED(&addr.sin6.sin6_addr))
3945 family = SMFIA_INET;
3946 else
3947 family = SMFIA_INET6;
3948 port = addr.sin6.sin6_port;
3949 sockinfo = anynet_ntop(&addr.sin6.sin6_addr, buf6,
3950 sizeof(buf6));
3951 if (sockinfo == NULL)
3952 sockinfo = "";
3953 break;
3954 # endif /* NETINET6 */
3955
3956 default:
3957 family = SMFIA_UNKNOWN;
3958 break;
3959 }
3960
3961 s = strlen(hostname) + 1 + sizeof(family);
3962 if (family != SMFIA_UNKNOWN)
3963 s += sizeof(port) + strlen(sockinfo) + 1;
3964
3965 buf = (char *) xalloc(s);
3966 bp = buf;
3967
3968 /* put together data */
3969 (void) memcpy(bp, hostname, strlen(hostname));
3970 bp += strlen(hostname);
3971 *bp++ = '\0';
3972 (void) memcpy(bp, &family, sizeof(family));
3973 bp += sizeof(family);
3974 if (family != SMFIA_UNKNOWN)
3975 {
3976 (void) memcpy(bp, &port, sizeof(port));
3977 bp += sizeof(port);
3978
3979 /* include trailing '\0' */
3980 (void) memcpy(bp, sockinfo, strlen(sockinfo) + 1);
3981 }
3982
3983 response = milter_command(SMFIC_CONNECT, buf, s, SMFIM_CONNECT,
3984 e, state, "connect", false);
3985 sm_free(buf); /* XXX */
3986
3987 /*
3988 ** If this message connection is done for,
3989 ** close the filters.
3990 */
3991
3992 if (*state != SMFIR_CONTINUE)
3993 {
3994 if (MilterLogLevel > 9)
3995 sm_syslog(LOG_INFO, e->e_id, "Milter: connect, ending");
3996 milter_quit(e);
3997 }
3998 else
3999 milter_per_connection_check(e);
4000
4001 #if !_FFR_MILTER_CONNECT_REPLYCODE
4002 /*
4003 ** SMFIR_REPLYCODE can't work with connect due to
4004 ** the requirements of SMTP. Therefore, ignore the
4005 ** reply code text but keep the state it would reflect.
4006 */
4007
4008 if (*state == SMFIR_REPLYCODE)
4009 {
4010 if (response != NULL &&
4011 *response == '4')
4012 {
4013 if (strncmp(response, "421 ", 4) == 0)
4014 *state = SMFIR_SHUTDOWN;
4015 else
4016 *state = SMFIR_TEMPFAIL;
4017 }
4018 else
4019 *state = SMFIR_REJECT;
4020 if (response != NULL)
4021 {
4022 sm_free(response); /* XXX */
4023 response = NULL;
4024 }
4025 }
4026 #endif /* !_FFR_MILTER_CONNECT_REPLYCODE */
4027 return response;
4028 }
4029
4030 /*
4031 ** MILTER_HELO -- send SMTP HELO/EHLO command info to milter filters
4032 **
4033 ** Parameters:
4034 ** helo -- argument to SMTP HELO/EHLO command.
4035 ** e -- current envelope.
4036 ** state -- return state from response.
4037 **
4038 ** Returns:
4039 ** response string (may be NULL)
4040 */
4041
4042 char *
milter_helo(helo,e,state)4043 milter_helo(helo, e, state)
4044 char *helo;
4045 ENVELOPE *e;
4046 char *state;
4047 {
4048 int i;
4049 char *response;
4050
4051 if (tTd(64, 10))
4052 sm_dprintf("milter_helo(%s)\n", helo);
4053
4054 /* HELO/EHLO can come at any point */
4055 for (i = 0; InputFilters[i] != NULL; i++)
4056 {
4057 struct milter *m = InputFilters[i];
4058
4059 switch (m->mf_state)
4060 {
4061 case SMFS_INMSG:
4062 /* abort in message filters */
4063 milter_abort_filter(m, e);
4064 /* FALLTHROUGH */
4065
4066 case SMFS_DONE:
4067 /* reset done filters */
4068 m->mf_state = SMFS_OPEN;
4069 break;
4070 }
4071 }
4072
4073 response = milter_command(SMFIC_HELO, helo, strlen(helo) + 1,
4074 SMFIM_HELO, e, state, "helo", false);
4075 milter_per_connection_check(e);
4076 return response;
4077 }
4078
4079 /*
4080 ** MILTER_ENVFROM -- send SMTP MAIL command info to milter filters
4081 **
4082 ** Parameters:
4083 ** args -- SMTP MAIL command args (args[0] == sender).
4084 ** e -- current envelope.
4085 ** state -- return state from response.
4086 **
4087 ** Returns:
4088 ** response string (may be NULL)
4089 */
4090
4091 char *
milter_envfrom(args,e,state)4092 milter_envfrom(args, e, state)
4093 char **args;
4094 ENVELOPE *e;
4095 char *state;
4096 {
4097 int i;
4098 char *buf, *bp;
4099 char *response;
4100 ssize_t s;
4101
4102 if (tTd(64, 10))
4103 {
4104 sm_dprintf("milter_envfrom:");
4105 for (i = 0; args[i] != NULL; i++)
4106 sm_dprintf(" %s", args[i]);
4107 sm_dprintf("\n");
4108 }
4109
4110 /* sanity check */
4111 if (args[0] == NULL)
4112 {
4113 *state = SMFIR_REJECT;
4114 if (MilterLogLevel > 10)
4115 sm_syslog(LOG_INFO, e->e_id,
4116 "Milter: reject, no sender");
4117 return NULL;
4118 }
4119
4120 /* new message, so ... */
4121 for (i = 0; InputFilters[i] != NULL; i++)
4122 {
4123 struct milter *m = InputFilters[i];
4124
4125 switch (m->mf_state)
4126 {
4127 case SMFS_INMSG:
4128 /* abort in message filters */
4129 milter_abort_filter(m, e);
4130 /* FALLTHROUGH */
4131
4132 case SMFS_DONE:
4133 /* reset done filters */
4134 m->mf_state = SMFS_OPEN;
4135 break;
4136 }
4137 }
4138
4139 /* put together data */
4140 s = 0;
4141 for (i = 0; args[i] != NULL; i++)
4142 s += strlen(args[i]) + 1;
4143
4144 if (s < 0)
4145 {
4146 *state = SMFIR_TEMPFAIL;
4147 return NULL;
4148 }
4149
4150 buf = (char *) xalloc(s);
4151 bp = buf;
4152 for (i = 0; args[i] != NULL; i++)
4153 {
4154 (void) sm_strlcpy(bp, args[i], s - (bp - buf));
4155 bp += strlen(bp) + 1;
4156 }
4157
4158 if (MilterLogLevel > 14)
4159 sm_syslog(LOG_INFO, e->e_id, "Milter: sender: %s", buf);
4160
4161 /* send it over */
4162 response = milter_command(SMFIC_MAIL, buf, s, SMFIM_ENVFROM,
4163 e, state, "mail", false);
4164 sm_free(buf); /* XXX */
4165
4166 /*
4167 ** If filter rejects/discards a per message command,
4168 ** abort the other filters since we are done with the
4169 ** current message.
4170 */
4171
4172 MILTER_CHECK_DONE_MSG();
4173 if (MilterLogLevel > 10 && *state == SMFIR_REJECT)
4174 sm_syslog(LOG_INFO, e->e_id, "Milter: reject, sender");
4175 return response;
4176 }
4177
4178 /*
4179 ** MILTER_ENVRCPT -- send SMTP RCPT command info to milter filters
4180 **
4181 ** Parameters:
4182 ** args -- SMTP RCPT command args (args[0] == recipient).
4183 ** e -- current envelope.
4184 ** state -- return state from response.
4185 ** rcpt_error -- does RCPT have an error?
4186 **
4187 ** Returns:
4188 ** response string (may be NULL)
4189 */
4190
4191 char *
milter_envrcpt(args,e,state,rcpt_error)4192 milter_envrcpt(args, e, state, rcpt_error)
4193 char **args;
4194 ENVELOPE *e;
4195 char *state;
4196 bool rcpt_error;
4197 {
4198 int i;
4199 char *buf, *bp;
4200 char *response;
4201 ssize_t s;
4202
4203 if (tTd(64, 10))
4204 {
4205 sm_dprintf("milter_envrcpt:");
4206 for (i = 0; args[i] != NULL; i++)
4207 sm_dprintf(" %s", args[i]);
4208 sm_dprintf("\n");
4209 }
4210
4211 /* sanity check */
4212 if (args[0] == NULL)
4213 {
4214 *state = SMFIR_REJECT;
4215 if (MilterLogLevel > 10)
4216 sm_syslog(LOG_INFO, e->e_id, "Milter: reject, no rcpt");
4217 return NULL;
4218 }
4219
4220 /* put together data */
4221 s = 0;
4222 for (i = 0; args[i] != NULL; i++)
4223 s += strlen(args[i]) + 1;
4224
4225 if (s < 0)
4226 {
4227 *state = SMFIR_TEMPFAIL;
4228 return NULL;
4229 }
4230
4231 buf = (char *) xalloc(s);
4232 bp = buf;
4233 for (i = 0; args[i] != NULL; i++)
4234 {
4235 (void) sm_strlcpy(bp, args[i], s - (bp - buf));
4236 bp += strlen(bp) + 1;
4237 }
4238
4239 if (MilterLogLevel > 14)
4240 sm_syslog(LOG_INFO, e->e_id, "Milter: rcpts: %s", buf);
4241
4242 /* send it over */
4243 response = milter_command(SMFIC_RCPT, buf, s, SMFIM_ENVRCPT,
4244 e, state, "rcpt", rcpt_error);
4245 sm_free(buf); /* XXX */
4246 return response;
4247 }
4248
4249 /*
4250 ** MILTER_DATA_CMD -- send SMTP DATA command info to milter filters
4251 **
4252 ** Parameters:
4253 ** e -- current envelope.
4254 ** state -- return state from response.
4255 **
4256 ** Returns:
4257 ** response string (may be NULL)
4258 */
4259
4260 char *
milter_data_cmd(e,state)4261 milter_data_cmd(e, state)
4262 ENVELOPE *e;
4263 char *state;
4264 {
4265 if (tTd(64, 10))
4266 sm_dprintf("milter_data_cmd\n");
4267
4268 /* send it over */
4269 return milter_command(SMFIC_DATA, NULL, 0, SMFIM_DATA,
4270 e, state, "data", false);
4271 }
4272
4273 /*
4274 ** MILTER_DATA -- send message headers/body and gather final message results
4275 **
4276 ** Parameters:
4277 ** e -- current envelope.
4278 ** state -- return state from response.
4279 **
4280 ** Returns:
4281 ** response string (may be NULL)
4282 **
4283 ** Side effects:
4284 ** - Uses e->e_dfp for access to the body
4285 ** - Can call the various milter action routines to
4286 ** modify the envelope or message.
4287 */
4288
4289 /* flow through code using continue; don't wrap in do {} while */
4290 # define MILTER_CHECK_RESULTS() \
4291 if (m->mf_state == SMFS_ERROR && *state == SMFIR_CONTINUE) \
4292 { \
4293 MILTER_SET_STATE; \
4294 } \
4295 if (*state == SMFIR_ACCEPT || \
4296 m->mf_state == SMFS_DONE || \
4297 m->mf_state == SMFS_ERROR) \
4298 { \
4299 if (m->mf_state != SMFS_ERROR) \
4300 m->mf_state = SMFS_DONE; \
4301 continue; /* to next filter */ \
4302 } \
4303 if (*state != SMFIR_CONTINUE) \
4304 { \
4305 m->mf_state = SMFS_DONE; \
4306 goto finishup; \
4307 }
4308
4309 char *
milter_data(e,state)4310 milter_data(e, state)
4311 ENVELOPE *e;
4312 char *state;
4313 {
4314 bool replbody = false; /* milter_replbody() called? */
4315 bool replfailed = false; /* milter_replbody() failed? */
4316 bool rewind = false; /* rewind data file? */
4317 bool dfopen = false; /* data file open for writing? */
4318 bool newfilter; /* reset on each new filter */
4319 char rcmd;
4320 int i;
4321 int save_errno;
4322 char *response = NULL;
4323 time_t eomsent;
4324 ssize_t rlen;
4325
4326 if (tTd(64, 10))
4327 sm_dprintf("milter_data\n");
4328
4329 *state = SMFIR_CONTINUE;
4330
4331 /*
4332 ** XXX: Should actually send body chunks to each filter
4333 ** a chunk at a time instead of sending the whole body to
4334 ** each filter in turn. However, only if the filters don't
4335 ** change the body.
4336 */
4337
4338 for (i = 0; InputFilters[i] != NULL; i++)
4339 {
4340 int idx;
4341 char **macros;
4342 struct milter *m = InputFilters[i];
4343
4344 if (*state != SMFIR_CONTINUE &&
4345 *state != SMFIR_ACCEPT)
4346 {
4347 /*
4348 ** A previous filter has dealt with the message,
4349 ** safe to stop processing the filters.
4350 */
4351
4352 break;
4353 }
4354
4355 /* Now reset state for later evaluation */
4356 *state = SMFIR_CONTINUE;
4357 newfilter = true;
4358
4359 /* previous problem? */
4360 if (m->mf_state == SMFS_ERROR)
4361 {
4362 MILTER_CHECK_ERROR(false, continue);
4363 break;
4364 }
4365
4366 /* sanity checks */
4367 if (m->mf_sock < 0 ||
4368 (m->mf_state != SMFS_OPEN && m->mf_state != SMFS_INMSG))
4369 continue;
4370
4371 m->mf_state = SMFS_INMSG;
4372
4373 /* check if filter wants the headers */
4374 if (!bitset(SMFIP_NOHDRS, m->mf_pflags))
4375 {
4376 response = milter_headers(m, e, state);
4377 MILTER_CHECK_RESULTS();
4378 }
4379
4380 /* check if filter wants EOH */
4381 if (!bitset(SMFIP_NOEOH, m->mf_pflags))
4382 {
4383 if (tTd(64, 10))
4384 sm_dprintf("milter_data: eoh\n");
4385
4386 if ((m->mf_lflags & MI_LFLAGS_SYM(SMFIM_EOH)) != 0)
4387 idx = m->mf_idx;
4388 else
4389 idx = 0;
4390 SM_ASSERT(idx >= 0 && idx <= MAXFILTERS);
4391 macros = MilterMacros[SMFIM_EOH][idx];
4392
4393 if (macros != NULL)
4394 {
4395 milter_send_macros(m, macros, SMFIC_EOH, e);
4396 MILTER_CHECK_RESULTS();
4397 }
4398
4399 /* send it over */
4400 response = milter_send_command(m, SMFIC_EOH, NULL, 0,
4401 e, state, "eoh");
4402 MILTER_CHECK_RESULTS();
4403 }
4404
4405 /* check if filter wants the body */
4406 if (!bitset(SMFIP_NOBODY, m->mf_pflags) &&
4407 e->e_dfp != NULL)
4408 {
4409 rewind = true;
4410 response = milter_body(m, e, state);
4411 MILTER_CHECK_RESULTS();
4412 }
4413
4414 if ((m->mf_lflags & MI_LFLAGS_SYM(SMFIM_EOH)) != 0)
4415 idx = m->mf_idx;
4416 else
4417 idx = 0;
4418 SM_ASSERT(idx >= 0 && idx <= MAXFILTERS);
4419 macros = MilterMacros[SMFIM_EOM][idx];
4420 if (macros != NULL)
4421 {
4422 milter_send_macros(m, macros, SMFIC_BODYEOB, e);
4423 MILTER_CHECK_RESULTS();
4424 }
4425
4426 /* send the final body chunk */
4427 (void) milter_write(m, SMFIC_BODYEOB, NULL, 0,
4428 m->mf_timeout[SMFTO_WRITE], e, "eom");
4429
4430 /* Get time EOM sent for timeout */
4431 eomsent = curtime();
4432
4433 /* deal with the possibility of multiple responses */
4434 while (*state == SMFIR_CONTINUE)
4435 {
4436 /* Check total timeout from EOM to final ACK/NAK */
4437 if (m->mf_timeout[SMFTO_EOM] > 0 &&
4438 curtime() - eomsent >= m->mf_timeout[SMFTO_EOM])
4439 {
4440 if (tTd(64, 5))
4441 sm_dprintf("milter_data(%s): EOM ACK/NAK timeout\n",
4442 m->mf_name);
4443 if (MilterLogLevel > 0)
4444 sm_syslog(LOG_ERR, e->e_id,
4445 "milter_data(%s): EOM ACK/NAK timeout",
4446 m->mf_name);
4447 milter_error(m, e);
4448 MILTER_CHECK_ERROR(false, break);
4449 break;
4450 }
4451
4452 response = milter_read(m, &rcmd, &rlen,
4453 m->mf_timeout[SMFTO_READ], e,
4454 "eom");
4455 if (m->mf_state == SMFS_ERROR)
4456 break;
4457
4458 if (tTd(64, 10))
4459 sm_dprintf("milter_data(%s): state %c\n",
4460 m->mf_name, (char) rcmd);
4461
4462 switch (rcmd)
4463 {
4464 case SMFIR_REPLYCODE:
4465 MILTER_CHECK_REPLYCODE("554 5.7.1 Command rejected");
4466 if (MilterLogLevel > 12)
4467 sm_syslog(LOG_INFO, e->e_id, "milter=%s, reject=%s",
4468 m->mf_name, response);
4469 *state = rcmd;
4470 m->mf_state = SMFS_DONE;
4471 break;
4472
4473 case SMFIR_REJECT: /* log msg at end of function */
4474 if (MilterLogLevel > 12)
4475 sm_syslog(LOG_INFO, e->e_id, "milter=%s, reject",
4476 m->mf_name);
4477 *state = rcmd;
4478 m->mf_state = SMFS_DONE;
4479 break;
4480
4481 case SMFIR_DISCARD:
4482 if (MilterLogLevel > 12)
4483 sm_syslog(LOG_INFO, e->e_id, "milter=%s, discard",
4484 m->mf_name);
4485 *state = rcmd;
4486 m->mf_state = SMFS_DONE;
4487 break;
4488
4489 case SMFIR_TEMPFAIL:
4490 if (MilterLogLevel > 12)
4491 sm_syslog(LOG_INFO, e->e_id, "milter=%s, tempfail",
4492 m->mf_name);
4493 *state = rcmd;
4494 m->mf_state = SMFS_DONE;
4495 break;
4496
4497 case SMFIR_CONTINUE:
4498 case SMFIR_ACCEPT:
4499 /* this filter is done with message */
4500 if (replfailed)
4501 *state = SMFIR_TEMPFAIL;
4502 else
4503 *state = SMFIR_ACCEPT;
4504 m->mf_state = SMFS_DONE;
4505 break;
4506
4507 case SMFIR_PROGRESS:
4508 break;
4509
4510 case SMFIR_QUARANTINE:
4511 if (!bitset(SMFIF_QUARANTINE, m->mf_fflags))
4512 {
4513 if (MilterLogLevel > 9)
4514 sm_syslog(LOG_WARNING, e->e_id,
4515 "milter_data(%s): lied about quarantining, honoring request anyway",
4516 m->mf_name);
4517 }
4518 if (response == NULL)
4519 response = newstr("");
4520 if (MilterLogLevel > 3)
4521 sm_syslog(LOG_INFO, e->e_id,
4522 "milter=%s, quarantine=%s",
4523 m->mf_name, response);
4524 e->e_quarmsg = sm_rpool_strdup_x(e->e_rpool,
4525 response);
4526 macdefine(&e->e_macro, A_PERM,
4527 macid("{quarantine}"), e->e_quarmsg);
4528 break;
4529
4530 case SMFIR_ADDHEADER:
4531 if (!bitset(SMFIF_ADDHDRS, m->mf_fflags))
4532 {
4533 if (MilterLogLevel > 9)
4534 sm_syslog(LOG_WARNING, e->e_id,
4535 "milter_data(%s): lied about adding headers, honoring request anyway",
4536 m->mf_name);
4537 }
4538 milter_addheader(m, response, rlen, e);
4539 break;
4540
4541 case SMFIR_INSHEADER:
4542 if (!bitset(SMFIF_ADDHDRS, m->mf_fflags))
4543 {
4544 if (MilterLogLevel > 9)
4545 sm_syslog(LOG_WARNING, e->e_id,
4546 "milter_data(%s): lied about adding headers, honoring request anyway",
4547 m->mf_name);
4548 }
4549 milter_insheader(m, response, rlen, e);
4550 break;
4551
4552 case SMFIR_CHGHEADER:
4553 if (!bitset(SMFIF_CHGHDRS, m->mf_fflags))
4554 {
4555 if (MilterLogLevel > 9)
4556 sm_syslog(LOG_WARNING, e->e_id,
4557 "milter_data(%s): lied about changing headers, honoring request anyway",
4558 m->mf_name);
4559 }
4560 milter_changeheader(m, response, rlen, e);
4561 break;
4562
4563 case SMFIR_CHGFROM:
4564 if (!bitset(SMFIF_CHGFROM, m->mf_fflags))
4565 {
4566 if (MilterLogLevel > 9)
4567 sm_syslog(LOG_WARNING, e->e_id,
4568 "milter_data(%s) lied about changing sender, honoring request anyway",
4569 m->mf_name);
4570 }
4571 milter_chgfrom(response, rlen, e, m->mf_name);
4572 break;
4573
4574 case SMFIR_ADDRCPT:
4575 if (!bitset(SMFIF_ADDRCPT, m->mf_fflags))
4576 {
4577 if (MilterLogLevel > 9)
4578 sm_syslog(LOG_WARNING, e->e_id,
4579 "milter_data(%s) lied about adding recipients, honoring request anyway",
4580 m->mf_name);
4581 }
4582 milter_addrcpt(response, rlen, e, m->mf_name);
4583 break;
4584
4585 case SMFIR_ADDRCPT_PAR:
4586 if (!bitset(SMFIF_ADDRCPT_PAR, m->mf_fflags))
4587 {
4588 if (MilterLogLevel > 9)
4589 sm_syslog(LOG_WARNING, e->e_id,
4590 "milter_data(%s) lied about adding recipients with parameters, honoring request anyway",
4591 m->mf_name);
4592 }
4593 milter_addrcpt_par(response, rlen, e, m->mf_name);
4594 break;
4595
4596 case SMFIR_DELRCPT:
4597 if (!bitset(SMFIF_DELRCPT, m->mf_fflags))
4598 {
4599 if (MilterLogLevel > 9)
4600 sm_syslog(LOG_WARNING, e->e_id,
4601 "milter_data(%s): lied about removing recipients, honoring request anyway",
4602 m->mf_name);
4603 }
4604 milter_delrcpt(response, rlen, e, m->mf_name);
4605 break;
4606
4607 case SMFIR_REPLBODY:
4608 if (!bitset(SMFIF_MODBODY, m->mf_fflags))
4609 {
4610 if (MilterLogLevel > 0)
4611 sm_syslog(LOG_ERR, e->e_id,
4612 "milter_data(%s): lied about replacing body, rejecting request and tempfailing message",
4613 m->mf_name);
4614 replfailed = true;
4615 break;
4616 }
4617
4618 /* already failed in attempt */
4619 if (replfailed)
4620 break;
4621
4622 if (!dfopen)
4623 {
4624 if (milter_reopen_df(e) < 0)
4625 {
4626 replfailed = true;
4627 break;
4628 }
4629 dfopen = true;
4630 rewind = true;
4631 }
4632
4633 if (milter_replbody(response, rlen, newfilter,
4634 e, m->mf_name) < 0)
4635 replfailed = true;
4636 newfilter = false;
4637 replbody = true;
4638 break;
4639
4640 default:
4641 /* Invalid response to command */
4642 if (MilterLogLevel > 0)
4643 sm_syslog(LOG_ERR, e->e_id,
4644 "milter_data(%s): returned bogus response %c",
4645 m->mf_name, rcmd);
4646 milter_error(m, e);
4647 break;
4648 }
4649 if (rcmd != SMFIR_REPLYCODE && response != NULL)
4650 {
4651 sm_free(response); /* XXX */
4652 response = NULL;
4653 }
4654
4655 if (m->mf_state == SMFS_ERROR)
4656 break;
4657 }
4658
4659 if (replbody && !replfailed)
4660 {
4661 /* flush possible buffered character */
4662 milter_replbody(NULL, 0, !replbody, e, m->mf_name);
4663 replbody = false;
4664 }
4665
4666 if (m->mf_state == SMFS_ERROR)
4667 {
4668 MILTER_CHECK_ERROR(false, continue);
4669 goto finishup;
4670 }
4671 }
4672
4673 finishup:
4674 /* leave things in the expected state if we touched it */
4675 if (replfailed)
4676 {
4677 if (*state == SMFIR_CONTINUE ||
4678 *state == SMFIR_ACCEPT)
4679 {
4680 *state = SMFIR_TEMPFAIL;
4681 SM_FREE(response);
4682 }
4683
4684 if (dfopen)
4685 {
4686 (void) sm_io_close(e->e_dfp, SM_TIME_DEFAULT);
4687 e->e_dfp = NULL;
4688 e->e_flags &= ~EF_HAS_DF;
4689 dfopen = false;
4690 }
4691 rewind = false;
4692 }
4693
4694 if ((dfopen && milter_reset_df(e) < 0) ||
4695 (rewind && bfrewind(e->e_dfp) < 0))
4696 {
4697 save_errno = errno;
4698 ExitStat = EX_IOERR;
4699
4700 /*
4701 ** If filter told us to keep message but we had
4702 ** an error, we can't really keep it, tempfail it.
4703 */
4704
4705 if (*state == SMFIR_CONTINUE || *state == SMFIR_ACCEPT)
4706 {
4707 *state = SMFIR_TEMPFAIL;
4708 SM_FREE(response);
4709 }
4710
4711 errno = save_errno;
4712 syserr("milter_data: %s/%cf%s: read error",
4713 qid_printqueue(e->e_qgrp, e->e_qdir),
4714 DATAFL_LETTER, e->e_id);
4715 }
4716
4717 MILTER_CHECK_DONE_MSG();
4718 if (MilterLogLevel > 10 && *state == SMFIR_REJECT)
4719 sm_syslog(LOG_INFO, e->e_id, "Milter: reject, data");
4720 return response;
4721 }
4722
4723 /*
4724 ** MILTER_UNKNOWN -- send any unrecognized or unimplemented command
4725 ** string to milter filters
4726 **
4727 ** Parameters:
4728 ** smtpcmd -- the string itself.
4729 ** e -- current envelope.
4730 ** state -- return state from response.
4731 **
4732 **
4733 ** Returns:
4734 ** response string (may be NULL)
4735 */
4736
4737 char *
milter_unknown(smtpcmd,e,state)4738 milter_unknown(smtpcmd, e, state)
4739 char *smtpcmd;
4740 ENVELOPE *e;
4741 char *state;
4742 {
4743 if (tTd(64, 10))
4744 sm_dprintf("milter_unknown(%s)\n", smtpcmd);
4745
4746 return milter_command(SMFIC_UNKNOWN, smtpcmd, strlen(smtpcmd) + 1,
4747 SMFIM_NOMACROS, e, state, "unknown", false);
4748 }
4749
4750 /*
4751 ** MILTER_QUIT -- informs the filter(s) we are done and closes connection(s)
4752 **
4753 ** Parameters:
4754 ** e -- current envelope.
4755 **
4756 ** Returns:
4757 ** none
4758 */
4759
4760 void
milter_quit(e)4761 milter_quit(e)
4762 ENVELOPE *e;
4763 {
4764 int i;
4765
4766 if (tTd(64, 10))
4767 sm_dprintf("milter_quit(%s)\n", e->e_id);
4768
4769 for (i = 0; InputFilters[i] != NULL; i++)
4770 milter_quit_filter(InputFilters[i], e);
4771 }
4772
4773 /*
4774 ** MILTER_ABORT -- informs the filter(s) that we are aborting current message
4775 **
4776 ** Parameters:
4777 ** e -- current envelope.
4778 **
4779 ** Returns:
4780 ** none
4781 */
4782
4783 void
milter_abort(e)4784 milter_abort(e)
4785 ENVELOPE *e;
4786 {
4787 int i;
4788
4789 if (tTd(64, 10))
4790 sm_dprintf("milter_abort\n");
4791
4792 for (i = 0; InputFilters[i] != NULL; i++)
4793 {
4794 struct milter *m = InputFilters[i];
4795
4796 /* sanity checks */
4797 if (m->mf_sock < 0 || m->mf_state != SMFS_INMSG)
4798 continue;
4799
4800 milter_abort_filter(m, e);
4801 }
4802 }
4803 #endif /* MILTER */
4804