2 * Copyright (c) 1999-2009 Sendmail, Inc. and its suppliers.
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.
13 SM_RCSID("@(#)$Id: milter.c,v 8.277 2009/11/06 00:57:06 ca Exp $")
16 # include <sm/sendmail.h>
17 # include <libmilter/mfapi.h>
18 # include <libmilter/mfdef.h>
24 # if NETINET || NETINET6
25 # include <arpa/inet.h>
27 # include <netinet/tcp.h>
28 # endif /* MILTER_NO_NAGLE */
29 # endif /* NETINET || NETINET6 */
31 # include <sm/fdset.h>
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, char **,
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,
54 static int milter_negotiate __P((struct milter *, ENVELOPE *,
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,
60 static void milter_insheader __P((struct milter *, char *, ssize_t,
62 static void milter_changeheader __P((struct milter *, char *, ssize_t,
64 static void milter_chgfrom __P((char *, ssize_t, ENVELOPE *));
65 static void milter_addrcpt __P((char *, ssize_t, ENVELOPE *));
66 static void milter_addrcpt_par __P((char *, ssize_t, ENVELOPE *));
67 static void milter_delrcpt __P((char *, ssize_t, ENVELOPE *));
68 static int milter_replbody __P((char *, ssize_t, bool, ENVELOPE *));
69 static int milter_set_macros __P((char *, char **, char *, int));
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 */
82 static char *MilterConnectMacros[MAXFILTERMACROS + 1];
83 static char *MilterHeloMacros[MAXFILTERMACROS + 1];
84 static char *MilterEnvFromMacros[MAXFILTERMACROS + 1];
85 static char *MilterEnvRcptMacros[MAXFILTERMACROS + 1];
86 static char *MilterDataMacros[MAXFILTERMACROS + 1];
87 static char *MilterEOMMacros[MAXFILTERMACROS + 1];
88 static char *MilterEOHMacros[MAXFILTERMACROS + 1];
89 static size_t MilterMaxDataSize = MILTER_MAX_DATA_SIZE;
91 # define MILTER_CHECK_DONE_MSG() \
92 if (*state == SMFIR_REPLYCODE || \
93 *state == SMFIR_REJECT || \
94 *state == SMFIR_DISCARD || \
95 *state == SMFIR_TEMPFAIL) \
97 /* Abort the filters to let them know we are done with msg */ \
101 # define MILTER_CHECK_ERROR(initial, action) \
102 if (!initial && tTd(71, 100)) \
104 if (e->e_quarmsg == NULL) \
106 e->e_quarmsg = sm_rpool_strdup_x(e->e_rpool, \
108 macdefine(&e->e_macro, A_PERM, macid("{quarantine}"), \
112 else if (tTd(71, 101)) \
114 if (e->e_quarmsg == NULL) \
116 e->e_quarmsg = sm_rpool_strdup_x(e->e_rpool, \
118 macdefine(&e->e_macro, A_PERM, macid("{quarantine}"), \
122 else if (bitnset(SMF_TEMPFAIL, m->mf_flags)) \
123 *state = SMFIR_TEMPFAIL; \
124 else if (bitnset(SMF_TEMPDROP, m->mf_flags)) \
125 *state = SMFIR_SHUTDOWN; \
126 else if (bitnset(SMF_REJECT, m->mf_flags)) \
127 *state = SMFIR_REJECT; \
131 # define MILTER_CHECK_REPLYCODE(default) \
132 if (response == NULL || \
133 strlen(response) + 1 != (size_t) rlen || \
135 (response[0] != '4' && response[0] != '5') || \
136 !isascii(response[1]) || !isdigit(response[1]) || \
137 !isascii(response[2]) || !isdigit(response[2])) \
139 if (response != NULL) \
140 sm_free(response); /* XXX */ \
141 response = newstr(default); \
145 char *ptr = response; \
147 /* Check for unprotected %'s in the string */ \
148 while (*ptr != '\0') \
150 if (*ptr == '%' && *++ptr != '%') \
152 sm_free(response); /* XXX */ \
153 response = newstr(default); \
160 # define MILTER_DF_ERROR(msg) \
162 int save_errno = errno; \
166 sm_dprintf(msg, dfname, sm_errstring(save_errno)); \
169 if (MilterLogLevel > 0) \
170 sm_syslog(LOG_ERR, e->e_id, msg, dfname, sm_errstring(save_errno)); \
171 if (SuperSafe == SAFE_REALLY) \
173 if (e->e_dfp != NULL) \
175 (void) sm_io_close(e->e_dfp, SM_TIME_DEFAULT); \
178 e->e_flags &= ~EF_HAS_DF; \
180 errno = save_errno; \
184 ** MILTER_TIMEOUT -- make sure socket is ready in time
187 ** routine -- routine name for debug/logging
188 ** secs -- number of seconds in timeout
189 ** write -- waiting to read or write?
190 ** started -- whether this is part of a previous sequence
192 ** Assumes 'm' is a milter structure for the current socket.
195 # define MILTER_TIMEOUT(routine, secs, write, started, function) \
202 if (SM_FD_SETSIZE > 0 && m->mf_sock >= SM_FD_SETSIZE) \
205 sm_dprintf("milter_%s(%s): socket %d is larger than FD_SETSIZE %d\n", \
206 (routine), m->mf_name, m->mf_sock, \
208 if (MilterLogLevel > 0) \
209 sm_syslog(LOG_ERR, e->e_id, \
210 "Milter (%s): socket(%s) %d is larger than FD_SETSIZE %d", \
211 m->mf_name, (routine), m->mf_sock, \
213 milter_error(m, e); \
220 SM_FD_SET(m->mf_sock, &fds); \
221 tv.tv_sec = (secs); \
223 ret = select(m->mf_sock + 1, \
224 (write) ? NULL : &fds, \
225 (write) ? &fds : NULL, \
227 } while (ret < 0 && errno == EINTR); \
233 sm_dprintf("milter_%s(%s): timeout, where=%s\n", \
234 (routine), m->mf_name, (function)); \
235 if (MilterLogLevel > 0) \
236 sm_syslog(LOG_ERR, e->e_id, \
237 "Milter (%s): timeout %s data %s, where=%s", \
239 started ? "during" : "before", \
240 (routine), (function)); \
241 milter_error(m, e); \
245 save_errno = errno; \
247 sm_dprintf("milter_%s(%s): select: %s\n", (routine), \
248 m->mf_name, sm_errstring(save_errno)); \
249 if (MilterLogLevel > 0) \
251 sm_syslog(LOG_ERR, e->e_id, \
252 "Milter (%s): select(%s): %s", \
253 m->mf_name, (routine), \
254 sm_errstring(save_errno)); \
256 milter_error(m, e); \
260 if (SM_FD_ISSET(m->mf_sock, &fds)) \
263 sm_dprintf("milter_%s(%s): socket not ready\n", \
264 (routine), m->mf_name); \
265 if (MilterLogLevel > 0) \
267 sm_syslog(LOG_ERR, e->e_id, \
268 "Milter (%s): socket(%s) not ready", \
269 m->mf_name, (routine)); \
271 milter_error(m, e); \
277 ** Low level functions
281 ** MILTER_READ -- read from a remote milter filter
284 ** m -- milter to read from.
285 ** cmd -- return param for command read.
286 ** rlen -- return length of response string.
287 ** to -- timeout in seconds.
288 ** e -- current envelope.
291 ** response string (may be NULL)
295 milter_sysread(m, buf, sz, to, e, where)
303 time_t readstart = 0;
305 bool started = false;
310 readstart = curtime();
319 if (now - readstart >= to)
322 sm_dprintf("milter_sys_read (%s): timeout %s data read in %s",
324 started ? "during" : "before",
326 if (MilterLogLevel > 0)
327 sm_syslog(LOG_ERR, e->e_id,
328 "Milter (%s): timeout %s data read in %s",
330 started ? "during" : "before",
335 to -= now - readstart;
337 MILTER_TIMEOUT("read", to, false, started, where);
340 len = read(m->mf_sock, buf + curl, sz - curl);
344 int save_errno = errno;
347 sm_dprintf("milter_sys_read(%s): read returned %ld: %s\n",
348 m->mf_name, (long) len,
349 sm_errstring(save_errno));
350 if (MilterLogLevel > 0)
351 sm_syslog(LOG_ERR, e->e_id,
352 "Milter (%s): read returned %ld: %s",
353 m->mf_name, (long) len,
354 sm_errstring(save_errno));
361 if (len == 0 || curl >= sz)
369 sm_dprintf("milter_sys_read(%s): cmd read returned %ld, expecting %ld\n",
370 m->mf_name, (long) curl, (long) sz);
371 if (MilterLogLevel > 0)
372 sm_syslog(LOG_ERR, e->e_id,
373 "milter_sys_read(%s): cmd read returned %ld, expecting %ld",
374 m->mf_name, (long) curl, (long) sz);
382 milter_read(m, cmd, rlen, to, e, where)
390 time_t readstart = 0;
393 # if MILTER_NO_NAGLE && defined(TCP_CORK)
395 # endif /* MILTER_NO_NAGLE && defined(TCP_CORK) */
397 char data[MILTER_LEN_BYTES + 1];
401 if (MilterLogLevel > 0)
402 sm_syslog(LOG_ERR, e->e_id,
403 "milter_read(%s): socket closed, where=%s",
413 readstart = curtime();
415 # if MILTER_NO_NAGLE && defined(TCP_CORK)
416 setsockopt(m->mf_sock, IPPROTO_TCP, TCP_CORK, (char *)&cork,
418 # endif /* MILTER_NO_NAGLE && defined(TCP_CORK) */
420 if (milter_sysread(m, data, sizeof(data), to, e, where) == NULL)
423 # if MILTER_NO_NAGLE && defined(TCP_CORK)
425 setsockopt(m->mf_sock, IPPROTO_TCP, TCP_CORK, (char *)&cork,
427 # endif /* MILTER_NO_NAGLE && defined(TCP_CORK) */
435 if (now - readstart >= to)
438 sm_dprintf("milter_read(%s): timeout before data read, where=%s\n",
440 if (MilterLogLevel > 0)
441 sm_syslog(LOG_ERR, e->e_id,
442 "Milter read(%s): timeout before data read, where=%s",
447 to -= now - readstart;
450 *cmd = data[MILTER_LEN_BYTES];
451 data[MILTER_LEN_BYTES] = '\0';
452 (void) memcpy(&i, data, MILTER_LEN_BYTES);
456 sm_dprintf("milter_read(%s): expecting %ld bytes\n",
457 m->mf_name, (long) expl);
462 sm_dprintf("milter_read(%s): read size %ld out of range, where=%s\n",
463 m->mf_name, (long) expl, where);
464 if (MilterLogLevel > 0)
465 sm_syslog(LOG_ERR, e->e_id,
466 "milter_read(%s): read size %ld out of range, where=%s",
467 m->mf_name, (long) expl, where);
475 buf = (char *) xalloc(expl);
477 if (milter_sysread(m, buf, expl, to, e, where) == NULL)
479 sm_free(buf); /* XXX */
484 sm_dprintf("milter_read(%s): Returning %*s\n",
485 m->mf_name, (int) expl, buf);
491 ** MILTER_WRITE -- write to a remote milter filter
494 ** m -- milter to read from.
495 ** cmd -- command to send.
496 ** buf -- optional command data.
497 ** len -- length of buf.
498 ** to -- timeout in seconds.
499 ** e -- current envelope.
502 ** buf if successful, NULL otherwise
503 ** Not actually used anywhere but function prototype
504 ** must match milter_read()
508 milter_write(m, cmd, buf, len, to, e, where)
520 char command = (char) cmd;
521 char data[MILTER_LEN_BYTES + 1];
522 bool started = false;
523 struct iovec vector[2];
526 ** At most two buffers will be written, though
527 ** only one may actually be used (see num_vectors).
528 ** The first is the size/command and the second is the command data.
531 if (len < 0 || len > MilterMaxDataSize)
535 sm_dprintf("milter_write(%s): length %ld out of range, cmd=%c\n",
536 m->mf_name, (long) len, command);
537 sm_dprintf("milter_write(%s): buf=%s\n",
538 m->mf_name, str2prt(buf));
540 if (MilterLogLevel > 0)
541 sm_syslog(LOG_ERR, e->e_id,
542 "milter_write(%s): length %ld out of range, cmd=%c",
543 m->mf_name, (long) len, command);
549 if (MilterLogLevel > 0)
550 sm_syslog(LOG_ERR, e->e_id,
551 "milter_write(%s): socket closed",
558 sm_dprintf("milter_write(%s): cmd %c, len %ld\n",
559 m->mf_name, command, (long) len);
561 nl = htonl(len + 1); /* add 1 for the command char */
562 (void) memcpy(data, (char *) &nl, MILTER_LEN_BYTES);
563 data[MILTER_LEN_BYTES] = command;
564 sl = MILTER_LEN_BYTES + 1;
566 /* set up the vector for the size / command */
567 vector[0].iov_base = (void *) data;
568 vector[0].iov_len = sl;
571 ** Determine if there is command data. If so, there will be two
572 ** vectors. If not, there will be only one. The vectors are set
573 ** up here and 'num_vectors' and 'sl' are set appropriately.
576 /* NOTE: len<0 has already been checked for. Pedantic */
577 if (len <= 0 || buf == NULL)
579 /* There is no command data -- only a size / command data */
585 ** There is both size / command and command data.
586 ** Set up the vector for the command data.
591 vector[1].iov_base = (void *) buf;
592 vector[1].iov_len = len;
595 sm_dprintf("milter_write(%s): Sending %*s\n",
596 m->mf_name, (int) len, buf);
600 MILTER_TIMEOUT("write", to, true, started, where);
602 /* write the vector(s) */
603 i = writev(m->mf_sock, vector, num_vectors);
606 int save_errno = errno;
609 sm_dprintf("milter_write(%s): write(%c) returned %ld, expected %ld: %s\n",
610 m->mf_name, command, (long) i, (long) sl,
611 sm_errstring(save_errno));
612 if (MilterLogLevel > 0)
613 sm_syslog(LOG_ERR, e->e_id,
614 "Milter (%s): write(%c) returned %ld, expected %ld: %s",
615 m->mf_name, command, (long) i, (long) sl,
616 sm_errstring(save_errno));
628 ** MILTER_OPEN -- connect to remote milter filter
631 ** m -- milter to connect to.
632 ** parseonly -- parse but don't connect.
633 ** e -- current envelope.
636 ** connected socket if successful && !parseonly,
637 ** 0 upon parse success if parseonly,
641 static jmp_buf MilterConnectTimeout;
644 milter_open(m, parseonly, e)
650 SOCKADDR_LEN_T addrlen = 0;
656 struct hostent *hp = NULL;
659 if (m->mf_conn == NULL || m->mf_conn[0] == '\0')
662 sm_dprintf("X%s: empty or missing socket information\n",
665 syserr("X%s: empty or missing socket information",
667 else if (MilterLogLevel > 0)
668 sm_syslog(LOG_ERR, e->e_id,
669 "Milter (%s): empty or missing socket information",
675 /* protocol:filename or protocol:port@host */
676 memset(&addr, '\0', sizeof(addr));
678 colon = strchr(p, ':');
686 /* default to AF_UNIX */
687 addr.sa.sa_family = AF_UNIX;
690 /* default to AF_INET */
691 addr.sa.sa_family = AF_INET;
694 /* default to AF_INET6 */
695 addr.sa.sa_family = AF_INET6;
696 # else /* NETINET6 */
697 /* no protocols available */
698 if (MilterLogLevel > 0)
699 sm_syslog(LOG_ERR, e->e_id,
700 "Milter (%s): no valid socket protocols available",
704 # endif /* NETINET6 */
705 # endif /* NETINET */
706 # endif /* NETUNIX */
709 else if (sm_strcasecmp(p, "unix") == 0 ||
710 sm_strcasecmp(p, "local") == 0)
711 addr.sa.sa_family = AF_UNIX;
712 # endif /* NETUNIX */
714 else if (sm_strcasecmp(p, "inet") == 0)
715 addr.sa.sa_family = AF_INET;
716 # endif /* NETINET */
718 else if (sm_strcasecmp(p, "inet6") == 0)
719 addr.sa.sa_family = AF_INET6;
720 # endif /* NETINET6 */
723 # ifdef EPROTONOSUPPORT
724 errno = EPROTONOSUPPORT;
725 # else /* EPROTONOSUPPORT */
727 # endif /* EPROTONOSUPPORT */
729 sm_dprintf("X%s: unknown socket type %s\n",
732 syserr("X%s: unknown socket type %s",
734 else if (MilterLogLevel > 0)
735 sm_syslog(LOG_ERR, e->e_id,
736 "Milter (%s): unknown socket type %s",
745 /* default to AF_UNIX */
746 addr.sa.sa_family = AF_UNIX;
751 if (addr.sa.sa_family == AF_UNIX)
753 long sff = SFF_SAFEDIRPATH|SFF_OPENASROOT|SFF_NOLINK|SFF_EXECOK;
756 if (strlen(colon) >= sizeof(addr.sunix.sun_path))
759 sm_dprintf("X%s: local socket name %s too long\n",
763 syserr("X%s: local socket name %s too long",
765 else if (MilterLogLevel > 0)
766 sm_syslog(LOG_ERR, e->e_id,
767 "Milter (%s): local socket name %s too long",
772 errno = safefile(colon, RunAsUid, RunAsGid, RunAsUserName, sff,
773 S_IRUSR|S_IWUSR, NULL);
775 /* if just parsing .cf file, socket doesn't need to exist */
776 if (parseonly && errno == ENOENT)
778 if (OpMode == MD_DAEMON ||
779 OpMode == MD_FGDAEMON)
780 (void) sm_io_fprintf(smioerr, SM_TIME_DEFAULT,
781 "WARNING: X%s: local socket name %s missing\n",
786 /* if not safe, don't create */
789 sm_dprintf("X%s: local socket name %s unsafe\n",
794 if (OpMode == MD_DAEMON ||
795 OpMode == MD_FGDAEMON ||
797 syserr("X%s: local socket name %s unsafe",
800 else if (MilterLogLevel > 0)
801 sm_syslog(LOG_ERR, e->e_id,
802 "Milter (%s): local socket name %s unsafe",
808 (void) sm_strlcpy(addr.sunix.sun_path, colon,
809 sizeof(addr.sunix.sun_path));
810 addrlen = sizeof(struct sockaddr_un);
813 # endif /* NETUNIX */
814 # if NETINET || NETINET6
817 || addr.sa.sa_family == AF_INET
818 # endif /* NETINET */
820 || addr.sa.sa_family == AF_INET6
821 # endif /* NETINET6 */
826 /* Parse port@host */
827 at = strchr(colon, '@');
831 sm_dprintf("X%s: bad address %s (expected port@host)\n",
834 syserr("X%s: bad address %s (expected port@host)",
836 else if (MilterLogLevel > 0)
837 sm_syslog(LOG_ERR, e->e_id,
838 "Milter (%s): bad address %s (expected port@host)",
844 if (isascii(*colon) && isdigit(*colon))
845 port = htons((unsigned short) atoi(colon));
848 # ifdef NO_GETSERVBYNAME
850 sm_dprintf("X%s: invalid port number %s\n",
853 syserr("X%s: invalid port number %s",
855 else if (MilterLogLevel > 0)
856 sm_syslog(LOG_ERR, e->e_id,
857 "Milter (%s): invalid port number %s",
861 # else /* NO_GETSERVBYNAME */
864 sp = getservbyname(colon, "tcp");
869 sm_dprintf("X%s: unknown port name %s\n",
873 syserr("X%s: unknown port name %s",
875 else if (MilterLogLevel > 0)
876 sm_syslog(LOG_ERR, e->e_id,
877 "Milter (%s): unknown port name %s",
883 # endif /* NO_GETSERVBYNAME */
890 end = strchr(at, ']');
895 unsigned long hid = INADDR_NONE;
896 # endif /* NETINET */
898 struct sockaddr_in6 hid6;
899 # endif /* NETINET6 */
903 if (addr.sa.sa_family == AF_INET &&
904 (hid = inet_addr(&at[1])) != INADDR_NONE)
906 addr.sin.sin_addr.s_addr = hid;
907 addr.sin.sin_port = port;
910 # endif /* NETINET */
912 (void) memset(&hid6, '\0', sizeof(hid6));
913 if (addr.sa.sa_family == AF_INET6 &&
914 anynet_pton(AF_INET6, &at[1],
915 &hid6.sin6_addr) == 1)
917 addr.sin6.sin6_addr = hid6.sin6_addr;
918 addr.sin6.sin6_port = port;
921 # endif /* NETINET6 */
926 sm_dprintf("X%s: Invalid numeric domain spec \"%s\"\n",
929 syserr("X%s: Invalid numeric domain spec \"%s\"",
931 else if (MilterLogLevel > 0)
932 sm_syslog(LOG_ERR, e->e_id,
933 "Milter (%s): Invalid numeric domain spec \"%s\"",
942 sm_dprintf("X%s: Invalid numeric domain spec \"%s\"\n",
945 syserr("X%s: Invalid numeric domain spec \"%s\"",
947 else if (MilterLogLevel > 0)
948 sm_syslog(LOG_ERR, e->e_id,
949 "Milter (%s): Invalid numeric domain spec \"%s\"",
957 hp = sm_gethostbyname(at, addr.sa.sa_family);
962 sm_dprintf("X%s: Unknown host name %s\n",
966 syserr("X%s: Unknown host name %s",
968 else if (MilterLogLevel > 0)
969 sm_syslog(LOG_ERR, e->e_id,
970 "Milter (%s): Unknown host name %s",
975 addr.sa.sa_family = hp->h_addrtype;
976 switch (hp->h_addrtype)
980 memmove(&addr.sin.sin_addr,
981 hp->h_addr, INADDRSZ);
982 addr.sin.sin_port = port;
983 addrlen = sizeof(struct sockaddr_in);
986 # endif /* NETINET */
990 memmove(&addr.sin6.sin6_addr,
991 hp->h_addr, IN6ADDRSZ);
992 addr.sin6.sin6_port = port;
993 addrlen = sizeof(struct sockaddr_in6);
996 # endif /* NETINET6 */
1000 sm_dprintf("X%s: Unknown protocol for %s (%d)\n",
1004 syserr("X%s: Unknown protocol for %s (%d)",
1005 m->mf_name, at, hp->h_addrtype);
1006 else if (MilterLogLevel > 0)
1007 sm_syslog(LOG_ERR, e->e_id,
1008 "Milter (%s): Unknown protocol for %s (%d)",
1014 # endif /* NETINET6 */
1020 # endif /* NETINET || NETINET6 */
1023 sm_dprintf("X%s: unknown socket protocol\n",
1026 syserr("X%s: unknown socket protocol", m->mf_name);
1027 else if (MilterLogLevel > 0)
1028 sm_syslog(LOG_ERR, e->e_id,
1029 "Milter (%s): unknown socket protocol",
1035 /* just parsing through? */
1038 m->mf_state = SMFS_READY;
1042 # endif /* NETINET6 */
1047 if (m->mf_state != SMFS_READY &&
1048 m->mf_state != SMFS_CLOSED)
1050 /* shouldn't happen */
1052 sm_dprintf("Milter (%s): Trying to open filter in state %c\n",
1053 m->mf_name, (char) m->mf_state);
1058 # endif /* NETINET6 */
1062 /* nope, actually connecting */
1065 sock = socket(addr.sa.sa_family, SOCK_STREAM, 0);
1070 sm_dprintf("Milter (%s): error creating socket: %s\n",
1072 sm_errstring(save_errno));
1073 if (MilterLogLevel > 0)
1074 sm_syslog(LOG_ERR, e->e_id,
1075 "Milter (%s): error creating socket: %s",
1076 m->mf_name, sm_errstring(save_errno));
1081 # endif /* NETINET6 */
1085 if (setjmp(MilterConnectTimeout) == 0)
1087 SM_EVENT *ev = NULL;
1090 if (m->mf_timeout[SMFTO_CONNECT] > 0)
1091 ev = sm_setevent(m->mf_timeout[SMFTO_CONNECT],
1092 milter_connect_timeout, 0);
1094 i = connect(sock, (struct sockaddr *) &addr, addrlen);
1103 /* couldn't connect.... try next address */
1108 sm_dprintf("milter_open (%s): open %s failed: %s\n",
1109 m->mf_name, at, sm_errstring(save_errno));
1110 if (MilterLogLevel > 13)
1111 sm_syslog(LOG_INFO, e->e_id,
1112 "Milter (%s): open %s failed: %s",
1113 m->mf_name, at, sm_errstring(save_errno));
1117 /* try next address */
1118 if (hp != NULL && hp->h_addr_list[addrno] != NULL)
1120 switch (addr.sa.sa_family)
1124 memmove(&addr.sin.sin_addr,
1125 hp->h_addr_list[addrno++],
1128 # endif /* NETINET */
1132 memmove(&addr.sin6.sin6_addr,
1133 hp->h_addr_list[addrno++],
1136 # endif /* NETINET6 */
1140 sm_dprintf("X%s: Unknown protocol for %s (%d)\n",
1143 if (MilterLogLevel > 0)
1144 sm_syslog(LOG_ERR, e->e_id,
1145 "Milter (%s): Unknown protocol for %s (%d)",
1151 # endif /* NETINET6 */
1159 sm_dprintf("X%s: error connecting to filter: %s\n",
1160 m->mf_name, sm_errstring(save_errno));
1161 if (MilterLogLevel > 0)
1162 sm_syslog(LOG_ERR, e->e_id,
1163 "Milter (%s): error connecting to filter: %s",
1164 m->mf_name, sm_errstring(save_errno));
1170 # endif /* NETINET6 */
1173 m->mf_state = SMFS_OPEN;
1180 # endif /* NETINET6 */
1181 # if MILTER_NO_NAGLE && !defined(TCP_CORK)
1185 setsockopt(m->mf_sock, IPPROTO_TCP, TCP_NODELAY,
1186 (char *)&nodelay, sizeof(nodelay));
1188 # endif /* MILTER_NO_NAGLE && !defined(TCP_CORK) */
1193 milter_connect_timeout(ignore)
1197 ** NOTE: THIS CAN BE CALLED FROM A SIGNAL HANDLER. DO NOT ADD
1198 ** ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE
1203 longjmp(MilterConnectTimeout, 1);
1207 ** MILTER_SETUP -- setup structure for a mail filter
1210 ** line -- the options line.
1225 /* collect the filter name */
1227 *p != '\0' && *p != ',' && !(isascii(*p) && isspace(*p));
1232 if (line[0] == '\0')
1234 syserr("name required for mail filter");
1237 m = (struct milter *) xalloc(sizeof(*m));
1238 memset((char *) m, '\0', sizeof(*m));
1239 m->mf_name = newstr(line);
1240 m->mf_state = SMFS_READY;
1242 m->mf_timeout[SMFTO_CONNECT] = (time_t) 300;
1243 m->mf_timeout[SMFTO_WRITE] = (time_t) 10;
1244 m->mf_timeout[SMFTO_READ] = (time_t) 10;
1245 m->mf_timeout[SMFTO_EOM] = (time_t) 300;
1246 #if _FFR_MILTER_CHECK
1247 m->mf_mta_prot_version = SMFI_PROT_VERSION;
1248 m->mf_mta_prot_flags = SMFI_CURR_PROT;
1249 m->mf_mta_actions = SMFI_CURR_ACTS;
1250 #endif /* _FFR_MILTER_CHECK */
1252 /* now scan through and assign info from the fields */
1257 while (*p != '\0' &&
1258 (*p == ',' || (isascii(*p) && isspace(*p))))
1261 /* p now points to field code */
1263 while (*p != '\0' && *p != '=' && *p != ',')
1267 syserr("X%s: `=' expected", m->mf_name);
1270 while (isascii(*p) && isspace(*p))
1273 /* p now points to the field body */
1274 p = munchstring(p, &delimptr, ',');
1276 /* install the field into the filter struct */
1279 case 'S': /* socket */
1283 m->mf_conn = newstr(p);
1286 case 'F': /* Milter flags configured on MTA */
1287 for (; *p != '\0'; p++)
1289 if (!(isascii(*p) && isspace(*p)))
1290 setbitn(bitidx(*p), m->mf_flags);
1294 case 'T': /* timeouts */
1295 milter_parse_timeouts(p, m);
1298 #if _FFR_MILTER_CHECK
1300 m->mf_mta_actions = strtoul(p, NULL, 0);
1303 m->mf_mta_prot_flags = strtoul(p, NULL, 0);
1306 m->mf_mta_prot_version = strtoul(p, NULL, 0);
1308 #endif /* _FFR_MILTER_CHECK */
1311 syserr("X%s: unknown filter equate %c=",
1318 /* early check for errors */
1319 (void) milter_open(m, true, CurEnv);
1321 /* enter the filter into the symbol table */
1322 s = stab(m->mf_name, ST_MILTER, ST_ENTER);
1323 if (s->s_milter != NULL)
1324 syserr("X%s: duplicate filter definition", m->mf_name);
1330 ** MILTER_CONFIG -- parse option list into an array and check config
1332 ** Called when reading configuration file.
1335 ** spec -- the filter list.
1336 ** list -- the array to fill in.
1337 ** max -- the maximum number of entries in list.
1344 milter_config(spec, list, max)
1346 struct milter **list;
1352 /* leave one for the NULL signifying the end of the list */
1355 for (p = spec; p != NULL; )
1359 while (isascii(*p) && isspace(*p))
1365 if (numitems >= max)
1367 syserr("Too many filters defined, %d max", max);
1372 p = strpbrk(p, ";,");
1376 s = stab(spec, ST_MILTER, ST_FIND);
1379 syserr("InputFilter %s not defined", spec);
1380 ExitStat = EX_CONFIG;
1383 list[numitems++] = s->s_milter;
1385 list[numitems] = NULL;
1387 /* if not set, set to LogLevel */
1388 if (MilterLogLevel == -1)
1389 MilterLogLevel = LogLevel;
1393 ** MILTER_PARSE_TIMEOUTS -- parse timeout list
1395 ** Called when reading configuration file.
1398 ** spec -- the timeout list.
1399 ** m -- milter to set.
1406 milter_parse_timeouts(spec, m)
1416 /* now scan through and assign info from the fields */
1421 while (*p != '\0' &&
1422 (*p == ';' || (isascii(*p) && isspace(*p))))
1425 /* p now points to field code */
1427 while (*p != '\0' && *p != ':')
1431 syserr("X%s, T=: `:' expected", m->mf_name);
1434 while (isascii(*p) && isspace(*p))
1437 /* p now points to the field body */
1438 p = munchstring(p, &delimptr, ';');
1441 /* install the field into the filter struct */
1445 tcode = SMFTO_CONNECT;
1449 tcode = SMFTO_WRITE;
1462 sm_dprintf("X%s: %c unknown\n",
1464 syserr("X%s: unknown filter timeout %c",
1470 m->mf_timeout[tcode] = convtime(p, 's');
1472 sm_dprintf("X%s: %c=%ld\n",
1474 (u_long) m->mf_timeout[tcode]);
1481 ** MILTER_SET_MACROS -- set milter macros
1484 ** name -- name of milter.
1485 ** macros -- where to store macros.
1486 ** val -- the value of the option.
1487 ** nummac -- current number of macros
1490 ** new number of macros
1494 milter_set_macros(name, macros, val, nummac)
1507 /* Skip leading commas, spaces */
1508 while (*p != '\0' &&
1509 (*p == ',' || (isascii(*p) && isspace(*p))))
1515 /* Find end of macro */
1517 while (*p != '\0' && *p != ',' &&
1518 isascii(*p) && !isspace(*p))
1523 if (nummac >= MAXFILTERMACROS)
1525 syserr("milter_set_option: too many macros in Milter.%s (max %d)",
1526 name, MAXFILTERMACROS);
1527 macros[nummac] = NULL;
1530 macros[nummac++] = macro;
1532 macros[nummac] = NULL;
1537 ** MILTER_SET_OPTION -- set an individual milter option
1540 ** name -- the name of the option.
1541 ** val -- the value of the option.
1542 ** sticky -- if set, don't let other setoptions override
1549 /* set if Milter sub-option is stuck */
1550 static BITMAP256 StickyMilterOpt;
1552 static struct milteropt
1554 char *mo_name; /* long name of milter option */
1555 unsigned char mo_code; /* code for option */
1558 # define MO_MACROS_CONNECT SMFIM_CONNECT
1559 { "macros.connect", MO_MACROS_CONNECT },
1560 # define MO_MACROS_HELO SMFIM_HELO
1561 { "macros.helo", MO_MACROS_HELO },
1562 # define MO_MACROS_ENVFROM SMFIM_ENVFROM
1563 { "macros.envfrom", MO_MACROS_ENVFROM },
1564 # define MO_MACROS_ENVRCPT SMFIM_ENVRCPT
1565 { "macros.envrcpt", MO_MACROS_ENVRCPT },
1566 # define MO_MACROS_DATA SMFIM_DATA
1567 { "macros.data", MO_MACROS_DATA },
1568 # define MO_MACROS_EOM SMFIM_EOM
1569 { "macros.eom", MO_MACROS_EOM },
1570 # define MO_MACROS_EOH SMFIM_EOH
1571 { "macros.eoh", MO_MACROS_EOH },
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 /* _FFR_MAXDATASIZE || _FFR_MDS_NEGOTIATE */
1579 { NULL, (unsigned char)-1 },
1583 milter_set_option(name, val, sticky)
1589 struct milteropt *mo;
1590 char **macros = NULL;
1593 if (tTd(37, 2) || tTd(64, 5))
1594 sm_dprintf("milter_set_option(%s = %s)", name, val);
1598 syserr("milter_set_option: invalid Milter option, must specify suboption");
1602 for (mo = MilterOptTab; mo->mo_name != NULL; mo++)
1604 if (sm_strcasecmp(mo->mo_name, name) == 0)
1608 if (mo->mo_name == NULL)
1610 syserr("milter_set_option: invalid Milter option %s", name);
1615 ** See if this option is preset for us.
1618 if (!sticky && bitnset(mo->mo_code, StickyMilterOpt))
1620 if (tTd(37, 2) || tTd(64,5))
1621 sm_dprintf(" (ignored)\n");
1625 if (tTd(37, 2) || tTd(64,5))
1628 switch (mo->mo_code)
1631 MilterLogLevel = atoi(val);
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)
1642 sm_syslog(LOG_WARNING, NOQID,
1643 "WARNING: Milter.%s=%d, allowed are only %d, %d, and %d",
1644 name, MilterMaxDataSize,
1645 MILTER_MDS_64K, MILTER_MDS_256K,
1647 if (MilterMaxDataSize < MILTER_MDS_64K)
1648 MilterMaxDataSize = MILTER_MDS_64K;
1649 else if (MilterMaxDataSize < MILTER_MDS_256K)
1650 MilterMaxDataSize = MILTER_MDS_256K;
1652 MilterMaxDataSize = MILTER_MDS_1M;
1654 # endif /* _FFR_MDS_NEGOTIATE */
1656 # endif /* _FFR_MAXDATASIZE || _FFR_MDS_NEGOTIATE */
1658 case MO_MACROS_CONNECT:
1660 macros = MilterConnectMacros;
1663 case MO_MACROS_HELO:
1665 macros = MilterHeloMacros;
1668 case MO_MACROS_ENVFROM:
1670 macros = MilterEnvFromMacros;
1673 case MO_MACROS_ENVRCPT:
1675 macros = MilterEnvRcptMacros;
1680 macros = MilterEOHMacros;
1685 macros = MilterEOMMacros;
1688 case MO_MACROS_DATA:
1690 macros = MilterDataMacros;
1692 r = milter_set_macros(name, macros, val, nummac);
1698 syserr("milter_set_option: invalid Milter option %s", name);
1702 setbitn(mo->mo_code, StickyMilterOpt);
1706 ** MILTER_REOPEN_DF -- open & truncate the data file (for replbody)
1709 ** e -- current envelope.
1712 ** 0 if succesful, -1 otherwise
1719 char dfname[MAXPATHLEN];
1721 (void) sm_strlcpy(dfname, queuename(e, DATAFL_LETTER), sizeof(dfname));
1724 ** In SuperSafe == SAFE_REALLY mode, e->e_dfp is a read-only FP so
1725 ** close and reopen writable (later close and reopen
1726 ** read only again).
1728 ** In SuperSafe != SAFE_REALLY mode, e->e_dfp still points at the
1729 ** buffered file I/O descriptor, still open for writing so there
1730 ** isn't any work to do here (except checking for consistency).
1733 if (SuperSafe == SAFE_REALLY)
1735 /* close read-only data file */
1736 if (bitset(EF_HAS_DF, e->e_flags) && e->e_dfp != NULL)
1738 (void) sm_io_close(e->e_dfp, SM_TIME_DEFAULT);
1739 e->e_flags &= ~EF_HAS_DF;
1743 if ((e->e_dfp = sm_io_open(SmFtStdio, SM_TIME_DEFAULT, dfname,
1744 SM_IO_RDWR_B, NULL)) == NULL)
1746 MILTER_DF_ERROR("milter_reopen_df: sm_io_open %s: %s");
1750 else if (e->e_dfp == NULL)
1752 /* shouldn't happen */
1754 MILTER_DF_ERROR("milter_reopen_df: NULL e_dfp (%s: %s)");
1761 ** MILTER_RESET_DF -- re-open read-only the data file (for replbody)
1764 ** e -- current envelope.
1767 ** 0 if succesful, -1 otherwise
1775 char dfname[MAXPATHLEN];
1777 (void) sm_strlcpy(dfname, queuename(e, DATAFL_LETTER), sizeof(dfname));
1779 if (sm_io_flush(e->e_dfp, SM_TIME_DEFAULT) != 0 ||
1780 sm_io_error(e->e_dfp))
1782 MILTER_DF_ERROR("milter_reset_df: error writing/flushing %s: %s");
1785 else if (SuperSafe != SAFE_REALLY)
1787 /* skip next few clauses */
1790 else if ((afd = sm_io_getinfo(e->e_dfp, SM_IO_WHAT_FD, NULL)) >= 0
1793 MILTER_DF_ERROR("milter_reset_df: error sync'ing %s: %s");
1796 else if (sm_io_close(e->e_dfp, SM_TIME_DEFAULT) < 0)
1798 MILTER_DF_ERROR("milter_reset_df: error closing %s: %s");
1801 else if ((e->e_dfp = sm_io_open(SmFtStdio, SM_TIME_DEFAULT, dfname,
1802 SM_IO_RDONLY_B, NULL)) == NULL)
1804 MILTER_DF_ERROR("milter_reset_df: error reopening %s: %s");
1808 e->e_flags |= EF_HAS_DF;
1813 ** MILTER_QUIT_FILTER -- close down a single filter
1816 ** m -- milter structure of filter to close down.
1817 ** e -- current envelope.
1824 milter_quit_filter(m, e)
1829 sm_dprintf("milter_quit_filter(%s)\n", m->mf_name);
1830 if (MilterLogLevel > 18)
1831 sm_syslog(LOG_INFO, e->e_id, "Milter (%s): quit filter",
1834 /* Never replace error state */
1835 if (m->mf_state == SMFS_ERROR)
1838 if (m->mf_sock < 0 ||
1839 m->mf_state == SMFS_CLOSED ||
1840 m->mf_state == SMFS_READY)
1843 m->mf_state = SMFS_CLOSED;
1847 (void) milter_write(m, SMFIC_QUIT, (char *) NULL, 0,
1848 m->mf_timeout[SMFTO_WRITE], e, "quit_filter");
1849 if (m->mf_sock >= 0)
1851 (void) close(m->mf_sock);
1854 if (m->mf_state != SMFS_ERROR)
1855 m->mf_state = SMFS_CLOSED;
1859 ** MILTER_ABORT_FILTER -- tell filter to abort current message
1862 ** m -- milter structure of filter to abort.
1863 ** e -- current envelope.
1870 milter_abort_filter(m, e)
1875 sm_dprintf("milter_abort_filter(%s)\n", m->mf_name);
1876 if (MilterLogLevel > 10)
1877 sm_syslog(LOG_INFO, e->e_id, "Milter (%s): abort filter",
1880 if (m->mf_sock < 0 ||
1881 m->mf_state != SMFS_INMSG)
1884 (void) milter_write(m, SMFIC_ABORT, (char *) NULL, 0,
1885 m->mf_timeout[SMFTO_WRITE], e, "abort_filter");
1886 if (m->mf_state != SMFS_ERROR)
1887 m->mf_state = SMFS_DONE;
1891 ** MILTER_SEND_MACROS -- provide macros to the filters
1894 ** m -- milter to send macros to.
1895 ** macros -- macros to send for filter smfi_getsymval().
1896 ** cmd -- which command the macros are associated with.
1897 ** e -- current envelope (for macro access).
1904 milter_send_macros(m, macros, cmd, e)
1912 char command = (char) cmd;
1919 if (macros == NULL || macros[0] == NULL)
1922 /* put together data */
1923 s = 1; /* for the command character */
1924 for (i = 0; macros[i] != NULL; i++)
1926 mid = macid(macros[i]);
1929 v = macvalue(mid, e);
1932 expand(v, exp, sizeof(exp), e);
1933 s += strlen(macros[i]) + 1 + strlen(exp) + 1;
1939 buf = (char *) xalloc(s);
1942 for (i = 0; macros[i] != NULL; i++)
1944 mid = macid(macros[i]);
1947 v = macvalue(mid, e);
1950 expand(v, exp, sizeof(exp), e);
1953 sm_dprintf("milter_send_macros(%s, %c): %s=%s\n",
1954 m->mf_name, command, macros[i], exp);
1956 (void) sm_strlcpy(bp, macros[i], s - (bp - buf));
1957 bp += strlen(bp) + 1;
1958 (void) sm_strlcpy(bp, exp, s - (bp - buf));
1959 bp += strlen(bp) + 1;
1961 (void) milter_write(m, SMFIC_MACRO, buf, s,
1962 m->mf_timeout[SMFTO_WRITE], e, "send_macros");
1967 ** MILTER_SEND_COMMAND -- send a command and return the response for a filter
1970 ** m -- current milter filter
1971 ** cmd -- command to send.
1972 ** data -- optional command data.
1973 ** sz -- length of buf.
1974 ** e -- current envelope (for e->e_id).
1975 ** state -- return state word.
1978 ** response string (may be NULL)
1982 milter_send_command(m, cmd, data, sz, e, state, where)
1993 unsigned long skipflag;
1994 unsigned long norespflag = 0;
1995 char command = (char) cmd;
2001 sm_dprintf("milter_send_command(%s): cmd %c len %ld\n",
2002 m->mf_name, (char) command, (long) sz);
2004 /* find skip flag and default failure */
2008 skipflag = SMFIP_NOCONNECT;
2009 norespflag = SMFIP_NR_CONN;
2011 defresponse = "554 Command rejected";
2015 skipflag = SMFIP_NOHELO;
2016 norespflag = SMFIP_NR_HELO;
2018 defresponse = "550 Command rejected";
2022 skipflag = SMFIP_NOMAIL;
2023 norespflag = SMFIP_NR_MAIL;
2025 defresponse = "550 5.7.1 Command rejected";
2029 skipflag = SMFIP_NORCPT;
2030 norespflag = SMFIP_NR_RCPT;
2032 defresponse = "550 5.7.1 Command rejected";
2036 skipflag = SMFIP_NOHDRS;
2037 norespflag = SMFIP_NR_HDR;
2039 defresponse = "550 5.7.1 Command rejected";
2043 skipflag = SMFIP_NOBODY;
2044 norespflag = SMFIP_NR_BODY;
2046 defresponse = "554 5.7.1 Command rejected";
2050 skipflag = SMFIP_NOEOH;
2051 norespflag = SMFIP_NR_EOH;
2053 defresponse = "550 5.7.1 Command rejected";
2057 skipflag = SMFIP_NOUNKNOWN;
2058 norespflag = SMFIP_NR_UNKN;
2060 defresponse = "550 5.7.1 Command rejected";
2064 skipflag = SMFIP_NODATA;
2065 norespflag = SMFIP_NR_DATA;
2067 defresponse = "550 5.7.1 Command rejected";
2075 /* NOTE: not handled by milter_send_command() */
2081 defresponse = "550 5.7.1 Command rejected";
2086 sm_dprintf("milter_send_command(%s): skip=%lx, pflags=%x\n",
2087 m->mf_name, skipflag, m->mf_pflags);
2089 /* check if filter wants this command */
2090 if (skipflag != 0 && bitset(skipflag, m->mf_pflags))
2093 /* send the command to the filter */
2094 (void) milter_write(m, command, data, sz,
2095 m->mf_timeout[SMFTO_WRITE], e, where);
2096 if (m->mf_state == SMFS_ERROR)
2098 MILTER_CHECK_ERROR(false, return NULL);
2102 /* check if filter sends response to this command */
2103 if (norespflag != 0 && bitset(norespflag, m->mf_pflags))
2106 /* get the response from the filter */
2107 response = milter_read(m, &rcmd, &rlen,
2108 m->mf_timeout[SMFTO_READ], e, where);
2109 if (m->mf_state == SMFS_ERROR)
2111 MILTER_CHECK_ERROR(false, return NULL);
2116 sm_dprintf("milter_send_command(%s): returned %c\n",
2117 m->mf_name, (char) rcmd);
2121 case SMFIR_REPLYCODE:
2122 MILTER_CHECK_REPLYCODE(defresponse);
2123 if (MilterLogLevel > 10)
2124 sm_syslog(LOG_INFO, e->e_id,
2125 "milter=%s, action=%s, reject=%s",
2126 m->mf_name, action, response);
2131 if (MilterLogLevel > 10)
2132 sm_syslog(LOG_INFO, e->e_id,
2133 "milter=%s, action=%s, reject",
2134 m->mf_name, action);
2139 if (MilterLogLevel > 10)
2140 sm_syslog(LOG_INFO, e->e_id,
2141 "milter=%s, action=%s, discard",
2142 m->mf_name, action);
2146 case SMFIR_TEMPFAIL:
2147 if (MilterLogLevel > 10)
2148 sm_syslog(LOG_INFO, e->e_id,
2149 "milter=%s, action=%s, tempfail",
2150 m->mf_name, action);
2155 /* this filter is done with message/connection */
2156 if (command == SMFIC_HELO ||
2157 command == SMFIC_CONNECT)
2158 m->mf_state = SMFS_CLOSABLE;
2160 m->mf_state = SMFS_DONE;
2161 if (MilterLogLevel > 10)
2162 sm_syslog(LOG_INFO, e->e_id,
2163 "milter=%s, action=%s, accepted",
2164 m->mf_name, action);
2167 case SMFIR_CONTINUE:
2168 /* if MAIL command is ok, filter is in message state */
2169 if (command == SMFIC_MAIL)
2170 m->mf_state = SMFS_INMSG;
2171 if (MilterLogLevel > 12)
2172 sm_syslog(LOG_INFO, e->e_id,
2173 "milter=%s, action=%s, continue",
2174 m->mf_name, action);
2178 if (MilterLogLevel > 12)
2179 sm_syslog(LOG_INFO, e->e_id,
2180 "milter=%s, action=%s, skip",
2181 m->mf_name, action);
2182 m->mf_state = SMFS_SKIP;
2186 /* Invalid response to command */
2187 if (MilterLogLevel > 0)
2188 sm_syslog(LOG_ERR, e->e_id,
2189 "milter_send_command(%s): action=%s returned bogus response %c",
2190 m->mf_name, action, rcmd);
2195 if (*state != SMFIR_REPLYCODE && response != NULL)
2197 sm_free(response); /* XXX */
2204 ** MILTER_COMMAND -- send a command and return the response for each filter
2207 ** cmd -- command to send.
2208 ** data -- optional command data.
2209 ** sz -- length of buf.
2210 ** macros -- macros to send for filter smfi_getsymval().
2211 ** e -- current envelope (for macro access).
2212 ** state -- return state word.
2213 ** where -- description of calling function (logging).
2214 ** cmd_error -- did the SMTP command cause an error?
2217 ** response string (may be NULL)
2221 milter_command(cmd, data, sz, macros, e, state, where, cmd_error)
2232 char command = (char) cmd;
2233 char *response = NULL;
2237 sm_dprintf("milter_command: cmd %c len %ld\n",
2238 command, (long) sz);
2240 *state = SMFIR_CONTINUE;
2241 for (i = 0; InputFilters[i] != NULL; i++)
2243 struct milter *m = InputFilters[i];
2245 /* previous problem? */
2246 if (m->mf_state == SMFS_ERROR)
2248 MILTER_CHECK_ERROR(false, continue);
2253 if (m->mf_sock < 0 ||
2254 (m->mf_state != SMFS_OPEN && m->mf_state != SMFS_INMSG))
2257 /* send macros (regardless of whether we send command) */
2258 if (macros != NULL && macros[0] != NULL)
2260 milter_send_macros(m, macros, command, e);
2261 if (m->mf_state == SMFS_ERROR)
2263 MILTER_CHECK_ERROR(false, continue);
2268 if (MilterLogLevel > 21)
2272 ** send the command if
2273 ** there is no error
2274 ** or it's RCPT and the client asked for it:
2276 ** where == "rcpt" && m->mf_pflags & SMFIP_RCPT_REJ != 0
2277 ** negate that condition and use continue
2281 (strcmp(where, "rcpt") != 0 ||
2282 (m->mf_pflags & SMFIP_RCPT_REJ) == 0))
2285 response = milter_send_command(m, command, data, sz, e, state,
2288 if (MilterLogLevel > 21)
2290 /* log the time it took for the command per filter */
2291 sm_syslog(LOG_INFO, e->e_id,
2292 "Milter (%s): time command (%c), %d",
2293 m->mf_name, command, (int) (tn - curtime()));
2296 if (*state != SMFIR_CONTINUE)
2302 static int milter_getsymlist __P((struct milter *, char *, int, int));
2305 milter_getsymlist(m, buf, rlen, offset)
2314 SM_ASSERT(m != NULL);
2315 SM_ASSERT(buf != NULL);
2317 while (offset + MILTER_LEN_BYTES < rlen)
2323 (void) memcpy((char *) &v, buf + offset, MILTER_LEN_BYTES);
2325 if (i < SMFIM_FIRST || i > SMFIM_LAST)
2327 offset += MILTER_LEN_BYTES;
2332 case MO_MACROS_CONNECT:
2334 macros = MilterConnectMacros;
2337 case MO_MACROS_HELO:
2339 macros = MilterHeloMacros;
2342 case MO_MACROS_ENVFROM:
2344 macros = MilterEnvFromMacros;
2347 case MO_MACROS_ENVRCPT:
2349 macros = MilterEnvRcptMacros;
2354 macros = MilterEOMMacros;
2359 macros = MilterEOHMacros;
2362 case MO_MACROS_DATA:
2364 macros = MilterDataMacros;
2366 len = strlen(buf + offset);
2369 r = milter_set_macros(m->mf_name, macros,
2370 buf + offset, nummac);
2388 ** MILTER_NEGOTIATE -- get version and flags from filter
2391 ** m -- milter filter structure.
2392 ** e -- current envelope.
2393 ** milters -- milters structure.
2396 ** 0 on success, -1 otherwise
2400 milter_negotiate(m, e, milters)
2406 mi_int32 fvers, fflags, pflags;
2407 mi_int32 mta_prot_vers, mta_prot_flags, mta_actions;
2410 char data[MILTER_OPTLEN];
2413 if (m->mf_sock < 0 || m->mf_state != SMFS_OPEN)
2415 if (MilterLogLevel > 0)
2416 sm_syslog(LOG_ERR, e->e_id,
2417 "Milter (%s): negotiate, impossible state",
2423 #if _FFR_MILTER_CHECK
2424 mta_prot_vers = m->mf_mta_prot_version;
2425 mta_prot_flags = m->mf_mta_prot_flags;
2426 mta_actions = m->mf_mta_actions;
2427 #else /* _FFR_MILTER_CHECK */
2428 mta_prot_vers = SMFI_PROT_VERSION;
2429 mta_prot_flags = SMFI_CURR_PROT;
2430 mta_actions = SMFI_CURR_ACTS;
2431 #endif /* _FFR_MILTER_CHECK */
2432 #if _FFR_MDS_NEGOTIATE
2433 if (MilterMaxDataSize == MILTER_MDS_256K)
2434 mta_prot_flags |= SMFIP_MDS_256K;
2435 else if (MilterMaxDataSize == MILTER_MDS_1M)
2436 mta_prot_flags |= SMFIP_MDS_1M;
2437 #endif /* _FFR_MDS_NEGOTIATE */
2439 fvers = htonl(mta_prot_vers);
2440 pflags = htonl(mta_prot_flags);
2441 fflags = htonl(mta_actions);
2442 (void) memcpy(data, (char *) &fvers, MILTER_LEN_BYTES);
2443 (void) memcpy(data + MILTER_LEN_BYTES,
2444 (char *) &fflags, MILTER_LEN_BYTES);
2445 (void) memcpy(data + (MILTER_LEN_BYTES * 2),
2446 (char *) &pflags, MILTER_LEN_BYTES);
2447 (void) milter_write(m, SMFIC_OPTNEG, data, sizeof(data),
2448 m->mf_timeout[SMFTO_WRITE], e, "negotiate");
2450 if (m->mf_state == SMFS_ERROR)
2454 sm_dprintf("milter_negotiate(%s): send: version %lu, fflags 0x%lx, pflags 0x%lx\n",
2455 m->mf_name, ntohl(fvers), ntohl(fflags), ntohl(pflags));
2457 response = milter_read(m, &rcmd, &rlen, m->mf_timeout[SMFTO_READ], e,
2459 if (m->mf_state == SMFS_ERROR)
2462 if (rcmd != SMFIC_OPTNEG)
2465 sm_dprintf("milter_negotiate(%s): returned %c instead of %c\n",
2466 m->mf_name, rcmd, SMFIC_OPTNEG);
2467 if (MilterLogLevel > 0)
2468 sm_syslog(LOG_ERR, e->e_id,
2469 "Milter (%s): negotiate: returned %c instead of %c",
2470 m->mf_name, rcmd, SMFIC_OPTNEG);
2471 if (response != NULL)
2472 sm_free(response); /* XXX */
2477 /* Make sure we have enough bytes for the version */
2478 if (response == NULL || rlen < MILTER_LEN_BYTES)
2481 sm_dprintf("milter_negotiate(%s): did not return valid info\n",
2483 if (MilterLogLevel > 0)
2484 sm_syslog(LOG_ERR, e->e_id,
2485 "Milter (%s): negotiate: did not return valid info",
2487 if (response != NULL)
2488 sm_free(response); /* XXX */
2493 /* extract information */
2494 (void) memcpy((char *) &fvers, response, MILTER_LEN_BYTES);
2496 /* Now make sure we have enough for the feature bitmap */
2497 if (rlen < MILTER_OPTLEN)
2500 sm_dprintf("milter_negotiate(%s): did not return enough info\n",
2502 if (MilterLogLevel > 0)
2503 sm_syslog(LOG_ERR, e->e_id,
2504 "Milter (%s): negotiate: did not return enough info",
2506 if (response != NULL)
2507 sm_free(response); /* XXX */
2512 (void) memcpy((char *) &fflags, response + MILTER_LEN_BYTES,
2514 (void) memcpy((char *) &pflags, response + (MILTER_LEN_BYTES * 2),
2517 m->mf_fvers = ntohl(fvers);
2518 m->mf_fflags = ntohl(fflags);
2519 m->mf_pflags = ntohl(pflags);
2521 /* check for version compatibility */
2522 if (m->mf_fvers == 1 ||
2523 m->mf_fvers > SMFI_VERSION)
2526 sm_dprintf("milter_negotiate(%s): version %d != MTA milter version %d\n",
2527 m->mf_name, m->mf_fvers, SMFI_VERSION);
2528 if (MilterLogLevel > 0)
2529 sm_syslog(LOG_ERR, e->e_id,
2530 "Milter (%s): negotiate: version %d != MTA milter version %d",
2531 m->mf_name, m->mf_fvers, SMFI_VERSION);
2536 /* check for filter feature mismatch */
2537 if ((m->mf_fflags & mta_actions) != m->mf_fflags)
2540 sm_dprintf("milter_negotiate(%s): filter abilities 0x%x != MTA milter abilities 0x%lx\n",
2541 m->mf_name, m->mf_fflags,
2542 (unsigned long) mta_actions);
2543 if (MilterLogLevel > 0)
2544 sm_syslog(LOG_ERR, e->e_id,
2545 "Milter (%s): negotiate: filter abilities 0x%x != MTA milter abilities 0x%lx",
2546 m->mf_name, m->mf_fflags,
2547 (unsigned long) mta_actions);
2552 #if _FFR_MDS_NEGOTIATE
2553 /* use a table instead of sequence? */
2554 if (bitset(SMFIP_MDS_1M, m->mf_pflags))
2556 if (MilterMaxDataSize != MILTER_MDS_1M)
2558 /* this should not happen... */
2559 sm_syslog(LOG_WARNING, NOQID,
2560 "WARNING: Milter.maxdatasize: configured=%d, set by libmilter=%d",
2561 MilterMaxDataSize, MILTER_MDS_1M);
2562 MilterMaxDataSize = MILTER_MDS_1M;
2565 else if (bitset(SMFIP_MDS_256K, m->mf_pflags))
2567 if (MilterMaxDataSize != MILTER_MDS_256K)
2569 sm_syslog(LOG_WARNING, NOQID,
2570 "WARNING: Milter.maxdatasize: configured=%d, set by libmilter=%d",
2571 MilterMaxDataSize, MILTER_MDS_256K);
2572 MilterMaxDataSize = MILTER_MDS_256K;
2575 else if (MilterMaxDataSize != MILTER_MDS_64K)
2577 sm_syslog(LOG_WARNING, NOQID,
2578 "WARNING: Milter.maxdatasize: configured=%d, set by libmilter=%d",
2579 MilterMaxDataSize, MILTER_MDS_64K);
2580 MilterMaxDataSize = MILTER_MDS_64K;
2582 m->mf_pflags &= ~SMFI_INTERNAL;
2583 #endif /* _FFR_MDS_NEGOTIATE */
2585 /* check for protocol feature mismatch */
2586 if ((m->mf_pflags & mta_prot_flags) != m->mf_pflags)
2589 sm_dprintf("milter_negotiate(%s): protocol abilities 0x%x != MTA milter abilities 0x%lx\n",
2590 m->mf_name, m->mf_pflags,
2591 (unsigned long) mta_prot_flags);
2592 if (MilterLogLevel > 0)
2593 sm_syslog(LOG_ERR, e->e_id,
2594 "Milter (%s): negotiate: protocol abilities 0x%x != MTA milter abilities 0x%lx",
2595 m->mf_name, m->mf_pflags,
2596 (unsigned long) mta_prot_flags);
2601 if (m->mf_fvers <= 2)
2602 m->mf_pflags |= SMFIP_NOUNKNOWN;
2603 if (m->mf_fvers <= 3)
2604 m->mf_pflags |= SMFIP_NODATA;
2606 if (rlen > MILTER_OPTLEN)
2608 milter_getsymlist(m, response, rlen, MILTER_OPTLEN);
2611 if (bitset(SMFIF_DELRCPT, m->mf_fflags))
2612 milters->mis_flags |= MIS_FL_DEL_RCPT;
2613 if (!bitset(SMFIP_NORCPT, m->mf_pflags) &&
2614 !bitset(SMFIP_NR_RCPT, m->mf_pflags))
2615 milters->mis_flags |= MIS_FL_REJ_RCPT;
2618 sm_dprintf("milter_negotiate(%s): received: version %u, fflags 0x%x, pflags 0x%x\n",
2619 m->mf_name, m->mf_fvers, m->mf_fflags, m->mf_pflags);
2623 if (response != NULL)
2624 sm_free(response); /* XXX */
2629 ** MILTER_PER_CONNECTION_CHECK -- checks on per-connection commands
2631 ** Reduce code duplication by putting these checks in one place
2634 ** e -- current envelope.
2641 milter_per_connection_check(e)
2646 /* see if we are done with any of the filters */
2647 for (i = 0; InputFilters[i] != NULL; i++)
2649 struct milter *m = InputFilters[i];
2651 if (m->mf_state == SMFS_CLOSABLE)
2652 milter_quit_filter(m, e);
2657 ** MILTER_ERROR -- Put a milter filter into error state
2660 ** m -- the broken filter.
2661 ** e -- current envelope.
2673 ** We could send a quit here but we may have gotten here due to
2674 ** an I/O error so we don't want to try to make things worse.
2677 if (m->mf_sock >= 0)
2679 (void) close(m->mf_sock);
2682 m->mf_state = SMFS_ERROR;
2684 if (MilterLogLevel > 0)
2685 sm_syslog(LOG_INFO, e->e_id, "Milter (%s): to error state",
2690 ** MILTER_HEADERS -- send headers to a single milter filter
2693 ** m -- current filter.
2694 ** e -- current envelope.
2695 ** state -- return state from response.
2698 ** response string (may be NULL)
2702 milter_headers(m, e, state)
2707 char *response = NULL;
2710 if (MilterLogLevel > 17)
2711 sm_syslog(LOG_INFO, e->e_id, "Milter (%s): headers, send",
2714 for (h = e->e_header; h != NULL; h = h->h_link)
2716 int len_n, len_v, len_t, len_f;
2719 /* don't send over deleted headers */
2720 if (h->h_value == NULL)
2722 /* strip H_USER so not counted in milter_changeheader() */
2723 h->h_flags &= ~H_USER;
2727 /* skip auto-generated */
2728 if (!bitset(H_USER, h->h_flags))
2732 sm_dprintf("milter_headers: %s:%s\n",
2733 h->h_field, h->h_value);
2734 if (MilterLogLevel > 21)
2735 sm_syslog(LOG_INFO, e->e_id, "Milter (%s): header, %s",
2736 m->mf_name, h->h_field);
2738 if (bitset(SMFIP_HDR_LEADSPC, m->mf_pflags)
2739 || *(h->h_value) != ' ')
2742 hv = h->h_value + 1;
2743 len_f = strlen(h->h_field) + 1;
2744 len_t = len_f + strlen(hv) + 1;
2747 buf = (char *) xalloc(len_t);
2750 ** Note: currently the call to dequote_internal_chars()
2751 ** is not required as h_field is supposed to be 7-bit US-ASCII.
2754 len_n = dequote_internal_chars(h->h_field, buf, len_f);
2755 SM_ASSERT(len_n < len_f);
2756 len_v = dequote_internal_chars(hv, buf + len_n + 1,
2758 SM_ASSERT(len_t >= len_n + 1 + len_v + 1);
2759 len_t = len_n + 1 + len_v + 1;
2762 response = milter_send_command(m, SMFIC_HEADER, buf,
2763 len_t, e, state, "header");
2765 if (m->mf_state == SMFS_ERROR ||
2766 m->mf_state == SMFS_DONE ||
2767 *state != SMFIR_CONTINUE)
2770 if (MilterLogLevel > 17)
2771 sm_syslog(LOG_INFO, e->e_id, "Milter (%s): headers, sent",
2777 ** MILTER_BODY -- send the body to a filter
2780 ** m -- current filter.
2781 ** e -- current envelope.
2782 ** state -- return state from response.
2785 ** response string (may be NULL)
2789 milter_body(m, e, state)
2794 char bufchar = '\0';
2795 char prevchar = '\0';
2797 char *response = NULL;
2799 char buf[MILTER_CHUNK_SIZE];
2802 sm_dprintf("milter_body\n");
2804 if (bfrewind(e->e_dfp) < 0)
2806 ExitStat = EX_IOERR;
2807 *state = SMFIR_TEMPFAIL;
2808 syserr("milter_body: %s/%cf%s: rewind error",
2809 qid_printqueue(e->e_qgrp, e->e_qdir),
2810 DATAFL_LETTER, e->e_id);
2814 if (MilterLogLevel > 17)
2815 sm_syslog(LOG_INFO, e->e_id, "Milter (%s): body, send",
2818 while ((c = sm_io_getc(e->e_dfp, SM_TIME_DEFAULT)) != SM_IO_EOF)
2820 /* Change LF to CRLF */
2823 #if !_FFR_MILTER_CONVERT_ALL_LF_TO_CRLF
2824 /* Not a CRLF already? */
2825 if (prevchar != '\r')
2826 #endif /* !_FFR_MILTER_CONVERT_ALL_LF_TO_CRLF */
2828 /* Room for CR now? */
2829 if (bp + 2 > &buf[sizeof(buf)])
2831 /* No room, buffer LF */
2834 /* and send CR now */
2839 /* Room to do it now */
2847 if (bp >= &buf[sizeof(buf)])
2850 response = milter_send_command(m, SMFIC_BODY, buf,
2854 if (bufchar != '\0')
2861 if (m->mf_state == SMFS_ERROR ||
2862 m->mf_state == SMFS_DONE ||
2863 m->mf_state == SMFS_SKIP ||
2864 *state != SMFIR_CONTINUE)
2868 /* check for read errors */
2869 if (sm_io_error(e->e_dfp))
2871 ExitStat = EX_IOERR;
2872 if (*state == SMFIR_CONTINUE ||
2873 *state == SMFIR_ACCEPT ||
2874 m->mf_state == SMFS_SKIP)
2876 *state = SMFIR_TEMPFAIL;
2877 if (response != NULL)
2879 sm_free(response); /* XXX */
2883 syserr("milter_body: %s/%cf%s: read error",
2884 qid_printqueue(e->e_qgrp, e->e_qdir),
2885 DATAFL_LETTER, e->e_id);
2889 /* send last body chunk */
2891 m->mf_state != SMFS_ERROR &&
2892 m->mf_state != SMFS_DONE &&
2893 m->mf_state != SMFS_SKIP &&
2894 *state == SMFIR_CONTINUE)
2897 response = milter_send_command(m, SMFIC_BODY, buf, bp - buf,
2898 e, state, "last body chunk");
2901 if (MilterLogLevel > 17)
2902 sm_syslog(LOG_INFO, e->e_id, "Milter (%s): body, sent",
2904 if (m->mf_state == SMFS_SKIP)
2906 *state = SMFIR_CONTINUE;
2907 m->mf_state = SMFS_READY;
2918 ** ADDLEADINGSPACE -- Add a leading space to a string
2922 ** rp -- resource pool for allocations
2925 ** pointer to new string
2928 static char *addleadingspace __P((char *, SM_RPOOL_T *));
2931 addleadingspace(str, rp)
2938 SM_ASSERT(str != NULL);
2940 SM_ASSERT(l + 2 > l);
2941 new = sm_rpool_malloc_x(rp, l + 2);
2944 sm_strlcpy(new + 1, str, l + 1);
2949 ** MILTER_ADDHEADER -- Add the supplied header to the message
2952 ** m -- current filter.
2953 ** response -- encoded form of header/value.
2954 ** rlen -- length of response.
2955 ** e -- current envelope.
2962 milter_addheader(m, response, rlen, e)
2969 char *val, *mh_value;
2973 sm_dprintf("milter_addheader: ");
2976 if (response == NULL)
2979 sm_dprintf("NULL response\n");
2983 if (rlen < 2 || strlen(response) + 1 >= (size_t) rlen)
2986 sm_dprintf("didn't follow protocol (total len %d != rlen %d)\n",
2987 (int) strlen(response), (int) (rlen - 1));
2991 /* Find separating NUL */
2992 val = response + strlen(response) + 1;
2994 /* another sanity check */
2995 if (strlen(response) + strlen(val) + 2 != (size_t) rlen)
2998 sm_dprintf("didn't follow protocol (part len)\n");
3002 if (*response == '\0')
3005 sm_dprintf("empty field name\n");
3009 for (h = e->e_header; h != NULL; h = h->h_link)
3011 if (sm_strcasecmp(h->h_field, response) == 0 &&
3012 !bitset(H_USER, h->h_flags) &&
3013 !bitset(H_TRACE, h->h_flags))
3018 mh_value = quote_internal_chars(val, NULL, &mh_v_len);
3020 /* add to e_msgsize */
3021 e->e_msgsize += strlen(response) + 2 + strlen(val);
3026 sm_dprintf("Replace default header %s value with %s\n",
3027 h->h_field, mh_value);
3028 if (MilterLogLevel > 8)
3029 sm_syslog(LOG_INFO, e->e_id,
3030 "Milter change: default header %s value with %s",
3031 h->h_field, mh_value);
3032 if (bitset(SMFIP_HDR_LEADSPC, m->mf_pflags))
3033 h->h_value = mh_value;
3036 h->h_value = addleadingspace(mh_value, e->e_rpool);
3039 h->h_flags |= H_USER;
3044 sm_dprintf("Add %s: %s\n", response, mh_value);
3045 if (MilterLogLevel > 8)
3046 sm_syslog(LOG_INFO, e->e_id,
3047 "Milter add: header: %s: %s",
3048 response, mh_value);
3049 addheader(newstr(response), mh_value, H_USER, e,
3050 !bitset(SMFIP_HDR_LEADSPC, m->mf_pflags));
3056 ** MILTER_INSHEADER -- Insert the supplied header
3059 ** m -- current filter.
3060 ** response -- encoded form of header/value.
3061 ** rlen -- length of response.
3062 ** e -- current envelope.
3068 ** Unlike milter_addheader(), this does not attempt to determine
3069 ** if the header already exists in the envelope, even a
3070 ** deleted version. It just blindly inserts.
3074 milter_insheader(m, response, rlen, e)
3082 char *field, *val, *mh_value;
3085 sm_dprintf("milter_insheader: ");
3088 if (response == NULL)
3091 sm_dprintf("NULL response\n");
3095 if (rlen < 2 || strlen(response) + 1 >= (size_t) rlen)
3098 sm_dprintf("didn't follow protocol (total len)\n");
3103 (void) memcpy((char *) &i, response, MILTER_LEN_BYTES);
3105 field = response + MILTER_LEN_BYTES;
3106 val = field + strlen(field) + 1;
3108 /* another sanity check */
3109 if (MILTER_LEN_BYTES + strlen(field) + 1 +
3110 strlen(val) + 1 != (size_t) rlen)
3113 sm_dprintf("didn't follow protocol (part len)\n");
3120 sm_dprintf("empty field name\n");
3124 /* add to e_msgsize */
3125 e->e_msgsize += strlen(response) + 2 + strlen(val);
3128 sm_dprintf("Insert (%d) %s: %s\n", idx, field, val);
3129 if (MilterLogLevel > 8)
3130 sm_syslog(LOG_INFO, e->e_id,
3131 "Milter insert (%d): header: %s: %s",
3134 mh_value = quote_internal_chars(val, NULL, &mh_v_len);
3135 insheader(idx, newstr(field), mh_value, H_USER, e,
3136 !bitset(SMFIP_HDR_LEADSPC, m->mf_pflags));
3141 ** MILTER_CHANGEHEADER -- Change the supplied header in the message
3144 ** m -- current filter.
3145 ** response -- encoded form of header/index/value.
3146 ** rlen -- length of response.
3147 ** e -- current envelope.
3154 milter_changeheader(m, response, rlen, e)
3162 char *field, *val, *mh_value;
3166 sm_dprintf("milter_changeheader: ");
3169 if (response == NULL)
3172 sm_dprintf("NULL response\n");
3176 if (rlen < 2 || strlen(response) + 1 >= (size_t) rlen)
3179 sm_dprintf("didn't follow protocol (total len)\n");
3183 /* Find separating NUL */
3184 (void) memcpy((char *) &i, response, MILTER_LEN_BYTES);
3186 field = response + MILTER_LEN_BYTES;
3187 val = field + strlen(field) + 1;
3189 /* another sanity check */
3190 if (MILTER_LEN_BYTES + strlen(field) + 1 +
3191 strlen(val) + 1 != (size_t) rlen)
3194 sm_dprintf("didn't follow protocol (part len)\n");
3201 sm_dprintf("empty field name\n");
3206 mh_value = quote_internal_chars(val, NULL, &mh_v_len);
3209 for (h = e->e_header; h != NULL; h = h->h_link)
3211 if (sm_strcasecmp(h->h_field, field) == 0)
3213 if (bitset(H_USER, h->h_flags) && --index <= 0)
3218 else if (!bitset(H_USER, h->h_flags) &&
3219 !bitset(H_TRACE, h->h_flags))
3222 ** DRUMS msg-fmt draft says can only have
3223 ** multiple occurences of trace fields,
3224 ** so make sure we replace any non-trace,
3233 /* if not found as user-provided header at index, use sysheader */
3242 sm_dprintf("Delete (noop) %s\n", field);
3243 if (MilterLogLevel > 8)
3244 sm_syslog(LOG_INFO, e->e_id,
3245 "Milter delete (noop): header: %s"
3250 /* treat modify value with no existing header as add */
3252 sm_dprintf("Add %s: %s\n", field, mh_value);
3253 if (MilterLogLevel > 8)
3254 sm_syslog(LOG_INFO, e->e_id,
3255 "Milter change (add): header: %s: %s"
3257 addheader(newstr(field), mh_value, H_USER, e,
3258 !bitset(SMFIP_HDR_LEADSPC, m->mf_pflags));
3267 sm_dprintf("Delete%s %s:%s\n",
3268 h == sysheader ? " (default header)" : "",
3270 h->h_value == NULL ? "<NULL>" : h->h_value);
3274 sm_dprintf("Change%s %s: from %s to %s\n",
3275 h == sysheader ? " (default header)" : "",
3277 h->h_value == NULL ? "<NULL>" : h->h_value,
3282 if (MilterLogLevel > 8)
3286 sm_syslog(LOG_INFO, e->e_id,
3287 "Milter delete: header%s %s:%s",
3288 h == sysheader ? " (default header)" : "",
3290 h->h_value == NULL ? "<NULL>" : h->h_value);
3294 sm_syslog(LOG_INFO, e->e_id,
3295 "Milter change: header%s %s: from %s to %s",
3296 h == sysheader ? " (default header)" : "",
3298 h->h_value == NULL ? "<NULL>" : h->h_value,
3303 if (h != sysheader && h->h_value != NULL)
3307 l = strlen(h->h_value);
3308 if (l > e->e_msgsize)
3312 /* rpool, don't free: sm_free(h->h_value); XXX */
3317 /* Remove "Field: " from message size */
3322 l = strlen(h->h_field) + 2;
3323 if (l > e->e_msgsize)
3333 if (bitset(SMFIP_HDR_LEADSPC, m->mf_pflags))
3334 h->h_value = mh_value;
3337 h->h_value = addleadingspace(mh_value, e->e_rpool);
3340 h->h_flags |= H_USER;
3341 e->e_msgsize += strlen(h->h_value);
3346 ** MILTER_SPLIT_RESPONSE -- Split response into fields.
3349 ** response -- encoded repsonse.
3350 ** rlen -- length of response.
3351 ** pargc -- number of arguments (ouput)
3354 ** array of pointers to the individual strings
3357 static char **milter_split_response __P((char *, ssize_t, int *));
3360 milter_split_response(response, rlen, pargc)
3369 SM_ASSERT(response != NULL);
3370 SM_ASSERT(pargc != NULL);
3372 if (rlen < 2 || strlen(response) >= (size_t) rlen)
3375 sm_dprintf("didn't follow protocol (total len %d != rlen %d)\n",
3376 (int) strlen(response), (int) (rlen - 1));
3381 for (i = 0; i < rlen; i++)
3383 if (response[i] == '\0')
3389 /* last entry is only for the name */
3390 s = (char **)malloc((nelem + 1) * (sizeof(*s)));
3394 for (i = 0, elem = 0; i < rlen && elem < nelem; i++)
3396 if (response[i] == '\0')
3402 s[elem] = &(response[i + 1]);
3409 for (elem = 0; elem < nelem; elem++)
3410 sm_dprintf("argv[%d]=\"%s\"\n", elem, s[elem]);
3413 /* overwrite last entry (already done above, just paranoia) */
3419 ** MILTER_CHGFROM -- Change the envelope sender address
3422 ** response -- encoded form of recipient address.
3423 ** rlen -- length of response.
3424 ** e -- current envelope.
3431 milter_chgfrom(response, rlen, e)
3436 int olderrors, argc;
3440 sm_dprintf("milter_chgfrom: ");
3443 if (response == NULL)
3446 sm_dprintf("NULL response\n");
3450 if (*response == '\0' ||
3451 strlen(response) + 1 > (size_t) rlen)
3454 sm_dprintf("didn't follow protocol (total len %d != rlen %d)\n",
3455 (int) strlen(response), (int) (rlen - 1));
3460 sm_dprintf("%s\n", response);
3461 if (MilterLogLevel > 8)
3462 sm_syslog(LOG_INFO, e->e_id, "Milter chgfrom: %s", response);
3463 argv = milter_split_response(response, rlen, &argc);
3464 if (argc < 1 || argc > 2)
3467 sm_dprintf("didn't follow protocol argc=%d\n", argc);
3472 setsender(argv[0], e, NULL, '\0', false);
3475 reset_mail_esmtp_args(e);
3478 ** need "features" here: how to get those? via e?
3479 ** "fake" it for now: allow everything.
3482 parse_esmtp_args(e, NULL, argv[0], argv[1], "MAIL", NULL,
3490 ** MILTER_ADDRCPT_PAR -- Add the supplied recipient to the message
3493 ** response -- encoded form of recipient address.
3494 ** rlen -- length of response.
3495 ** e -- current envelope.
3502 milter_addrcpt_par(response, rlen, e)
3507 int olderrors, argc;
3513 sm_dprintf("milter_addrcpt_par: ");
3516 if (response == NULL)
3519 sm_dprintf("NULL response\n");
3524 sm_dprintf("%s\n", response);
3525 if (MilterLogLevel > 8)
3526 sm_syslog(LOG_INFO, e->e_id, "Milter add: rcpt: %s", response);
3528 argv = milter_split_response(response, rlen, &argc);
3529 if (argc < 1 || argc > 2)
3532 sm_dprintf("didn't follow protocol argc=%d\n", argc);
3537 /* how to set ESMTP arguments? */
3538 a = parseaddr(argv[0], NULLADDR, RF_COPYALL, ' ', &delimptr, e, true);
3540 if (a != NULL && olderrors == Errors)
3542 parse_esmtp_args(e, a, argv[0], argv[1], "RCPT", NULL,
3544 if (olderrors == Errors)
3545 a = recipient(a, &e->e_sendqueue, 0, e);
3547 sm_dprintf("olderrors=%d, Errors=%d\n",
3552 sm_dprintf("a=%p, olderrors=%d, Errors=%d\n",
3553 a, olderrors, Errors);
3561 ** MILTER_ADDRCPT -- Add the supplied recipient to the message
3564 ** response -- encoded form of recipient address.
3565 ** rlen -- length of response.
3566 ** e -- current envelope.
3573 milter_addrcpt(response, rlen, e)
3581 sm_dprintf("milter_addrcpt: ");
3584 if (response == NULL)
3587 sm_dprintf("NULL response\n");
3591 if (*response == '\0' ||
3592 strlen(response) + 1 != (size_t) rlen)
3595 sm_dprintf("didn't follow protocol (total len %d != rlen %d)\n",
3596 (int) strlen(response), (int) (rlen - 1));
3601 sm_dprintf("%s\n", response);
3602 if (MilterLogLevel > 8)
3603 sm_syslog(LOG_INFO, e->e_id, "Milter add: rcpt: %s", response);
3605 (void) sendtolist(response, NULLADDR, &e->e_sendqueue, 0, e);
3611 ** MILTER_DELRCPT -- Delete the supplied recipient from the message
3614 ** response -- encoded form of recipient address.
3615 ** rlen -- length of response.
3616 ** e -- current envelope.
3623 milter_delrcpt(response, rlen, e)
3629 sm_dprintf("milter_delrcpt: ");
3632 if (response == NULL)
3635 sm_dprintf("NULL response\n");
3639 if (*response == '\0' ||
3640 strlen(response) + 1 != (size_t) rlen)
3643 sm_dprintf("didn't follow protocol (total len %d != rlen %d)\n",
3644 (int) strlen(response), (int) (rlen - 1));
3649 sm_dprintf("%s\n", response);
3650 if (MilterLogLevel > 8)
3651 sm_syslog(LOG_INFO, e->e_id, "Milter delete: rcpt %s",
3653 (void) removefromlist(response, &e->e_sendqueue, e);
3658 ** MILTER_REPLBODY -- Replace the current data file with new body
3661 ** response -- encoded form of new body.
3662 ** rlen -- length of response.
3663 ** newfilter -- if first time called by a new filter
3664 ** e -- current envelope.
3667 ** 0 upon success, -1 upon failure
3671 milter_replbody(response, rlen, newfilter, e)
3677 static char prevchar;
3681 sm_dprintf("milter_replbody\n");
3683 /* If a new filter, reset previous character and truncate data file */
3687 char dfname[MAXPATHLEN];
3689 (void) sm_strlcpy(dfname, queuename(e, DATAFL_LETTER),
3692 /* Reset prevchar */
3695 /* Get the current data file information */
3696 prevsize = sm_io_getinfo(e->e_dfp, SM_IO_WHAT_SIZE, NULL);
3700 /* truncate current data file */
3701 if (sm_io_getinfo(e->e_dfp, SM_IO_WHAT_ISTYPE, BF_FILE_TYPE))
3703 if (sm_io_setinfo(e->e_dfp, SM_BF_TRUNCATE, NULL) < 0)
3705 MILTER_DF_ERROR("milter_replbody: sm_io truncate %s: %s");
3713 err = sm_io_error(e->e_dfp);
3714 (void) sm_io_flush(e->e_dfp, SM_TIME_DEFAULT);
3717 ** Clear error if tried to fflush()
3718 ** a read-only file pointer and
3719 ** there wasn't a previous error.
3723 sm_io_clearerr(e->e_dfp);
3725 /* errno is set implicitly by fseek() before return */
3726 err = sm_io_seek(e->e_dfp, SM_TIME_DEFAULT,
3730 MILTER_DF_ERROR("milter_replbody: sm_io_seek %s: %s");
3734 /* XXX: Not much we can do except rewind it */
3736 MILTER_DF_ERROR("milter_replbody: ftruncate not available on this platform (%s:%s)");
3738 # else /* NOFTRUNCATE */
3739 err = ftruncate(sm_io_getinfo(e->e_dfp,
3740 SM_IO_WHAT_FD, NULL),
3744 MILTER_DF_ERROR("milter_replbody: sm_io ftruncate %s: %s");
3747 # endif /* NOFTRUNCATE */
3750 if (prevsize > e->e_msgsize)
3753 e->e_msgsize -= prevsize;
3756 if (newfilter && MilterLogLevel > 8)
3757 sm_syslog(LOG_INFO, e->e_id, "Milter message: body replaced");
3759 if (response == NULL)
3761 /* Flush the buffered '\r' */
3762 if (prevchar == '\r')
3764 (void) sm_io_putc(e->e_dfp, SM_TIME_DEFAULT, prevchar);
3770 for (i = 0; i < rlen; i++)
3772 /* Buffered char from last chunk */
3773 if (i == 0 && prevchar == '\r')
3775 /* Not CRLF, output prevchar */
3776 if (response[i] != '\n')
3778 (void) sm_io_putc(e->e_dfp, SM_TIME_DEFAULT,
3785 /* Turn CRLF into LF */
3786 if (response[i] == '\r')
3788 /* check if at end of chunk */
3791 /* If LF, strip CR */
3792 if (response[i + 1] == '\n')
3797 /* check next chunk */
3802 (void) sm_io_putc(e->e_dfp, SM_TIME_DEFAULT, response[i]);
3813 ** MILTER_INIT -- open and negotiate with all of the filters
3816 ** e -- current envelope.
3817 ** state -- return state from response.
3818 ** milters -- milters structure.
3821 ** true iff at least one filter is active
3826 milter_init(e, state, milters)
3834 sm_dprintf("milter_init\n");
3836 memset(milters, '\0', sizeof(*milters));
3837 *state = SMFIR_CONTINUE;
3838 if (InputFilters[0] == NULL)
3840 if (MilterLogLevel > 10)
3841 sm_syslog(LOG_INFO, e->e_id,
3842 "Milter: no active filter");
3846 for (i = 0; InputFilters[i] != NULL; i++)
3848 struct milter *m = InputFilters[i];
3850 m->mf_sock = milter_open(m, false, e);
3851 if (m->mf_state == SMFS_ERROR)
3853 MILTER_CHECK_ERROR(true, continue);
3857 if (m->mf_sock < 0 ||
3858 milter_negotiate(m, e, milters) < 0 ||
3859 m->mf_state == SMFS_ERROR)
3862 sm_dprintf("milter_init(%s): failed to %s\n",
3864 m->mf_sock < 0 ? "open" :
3866 if (MilterLogLevel > 0)
3867 sm_syslog(LOG_ERR, e->e_id,
3868 "Milter (%s): init failed to %s",
3870 m->mf_sock < 0 ? "open" :
3873 /* if negotiation failure, close socket */
3875 MILTER_CHECK_ERROR(true, continue);
3878 if (MilterLogLevel > 9)
3879 sm_syslog(LOG_INFO, e->e_id,
3880 "Milter (%s): init success to %s",
3882 m->mf_sock < 0 ? "open" : "negotiate");
3886 ** If something temp/perm failed with one of the filters,
3887 ** we won't be using any of them, so clear any existing
3891 if (*state != SMFIR_CONTINUE)
3898 ** MILTER_CONNECT -- send connection info to milter filters
3901 ** hostname -- hostname of remote machine.
3902 ** addr -- address of remote machine.
3903 ** e -- current envelope.
3904 ** state -- return state from response.
3907 ** response string (may be NULL)
3911 milter_connect(hostname, addr, e, state)
3918 unsigned short port;
3921 char *sockinfo = NULL;
3924 char buf6[INET6_ADDRSTRLEN];
3925 # endif /* NETINET6 */
3928 sm_dprintf("milter_connect(%s)\n", hostname);
3929 if (MilterLogLevel > 9)
3930 sm_syslog(LOG_INFO, e->e_id, "Milter: connect to filters");
3933 switch (addr.sa.sa_family)
3937 family = SMFIA_UNIX;
3939 sockinfo = addr.sunix.sun_path;
3941 # endif /* NETUNIX */
3945 family = SMFIA_INET;
3946 port = addr.sin.sin_port;
3947 sockinfo = (char *) inet_ntoa(addr.sin.sin_addr);
3949 # endif /* NETINET */
3953 if (IN6_IS_ADDR_V4MAPPED(&addr.sin6.sin6_addr))
3954 family = SMFIA_INET;
3956 family = SMFIA_INET6;
3957 port = addr.sin6.sin6_port;
3958 sockinfo = anynet_ntop(&addr.sin6.sin6_addr, buf6,
3960 if (sockinfo == NULL)
3963 # endif /* NETINET6 */
3966 family = SMFIA_UNKNOWN;
3970 s = strlen(hostname) + 1 + sizeof(family);
3971 if (family != SMFIA_UNKNOWN)
3972 s += sizeof(port) + strlen(sockinfo) + 1;
3974 buf = (char *) xalloc(s);
3977 /* put together data */
3978 (void) memcpy(bp, hostname, strlen(hostname));
3979 bp += strlen(hostname);
3981 (void) memcpy(bp, &family, sizeof(family));
3982 bp += sizeof(family);
3983 if (family != SMFIA_UNKNOWN)
3985 (void) memcpy(bp, &port, sizeof(port));
3988 /* include trailing '\0' */
3989 (void) memcpy(bp, sockinfo, strlen(sockinfo) + 1);
3992 response = milter_command(SMFIC_CONNECT, buf, s, MilterConnectMacros,
3993 e, state, "connect", false);
3994 sm_free(buf); /* XXX */
3997 ** If this message connection is done for,
3998 ** close the filters.
4001 if (*state != SMFIR_CONTINUE)
4003 if (MilterLogLevel > 9)
4004 sm_syslog(LOG_INFO, e->e_id, "Milter: connect, ending");
4008 milter_per_connection_check(e);
4011 ** SMFIR_REPLYCODE can't work with connect due to
4012 ** the requirements of SMTP. Therefore, ignore the
4013 ** reply code text but keep the state it would reflect.
4016 if (*state == SMFIR_REPLYCODE)
4018 if (response != NULL &&
4021 if (strncmp(response, "421 ", 4) == 0)
4022 *state = SMFIR_SHUTDOWN;
4024 *state = SMFIR_TEMPFAIL;
4027 *state = SMFIR_REJECT;
4028 if (response != NULL)
4030 sm_free(response); /* XXX */
4038 ** MILTER_HELO -- send SMTP HELO/EHLO command info to milter filters
4041 ** helo -- argument to SMTP HELO/EHLO command.
4042 ** e -- current envelope.
4043 ** state -- return state from response.
4046 ** response string (may be NULL)
4050 milter_helo(helo, e, state)
4059 sm_dprintf("milter_helo(%s)\n", helo);
4061 /* HELO/EHLO can come at any point */
4062 for (i = 0; InputFilters[i] != NULL; i++)
4064 struct milter *m = InputFilters[i];
4066 switch (m->mf_state)
4069 /* abort in message filters */
4070 milter_abort_filter(m, e);
4074 /* reset done filters */
4075 m->mf_state = SMFS_OPEN;
4080 response = milter_command(SMFIC_HELO, helo, strlen(helo) + 1,
4081 MilterHeloMacros, e, state, "helo", false);
4082 milter_per_connection_check(e);
4087 ** MILTER_ENVFROM -- send SMTP MAIL command info to milter filters
4090 ** args -- SMTP MAIL command args (args[0] == sender).
4091 ** e -- current envelope.
4092 ** state -- return state from response.
4095 ** response string (may be NULL)
4099 milter_envfrom(args, e, state)
4111 sm_dprintf("milter_envfrom:");
4112 for (i = 0; args[i] != NULL; i++)
4113 sm_dprintf(" %s", args[i]);
4118 if (args[0] == NULL)
4120 *state = SMFIR_REJECT;
4121 if (MilterLogLevel > 10)
4122 sm_syslog(LOG_INFO, e->e_id,
4123 "Milter: reject, no sender");
4127 /* new message, so ... */
4128 for (i = 0; InputFilters[i] != NULL; i++)
4130 struct milter *m = InputFilters[i];
4132 switch (m->mf_state)
4135 /* abort in message filters */
4136 milter_abort_filter(m, e);
4140 /* reset done filters */
4141 m->mf_state = SMFS_OPEN;
4146 /* put together data */
4148 for (i = 0; args[i] != NULL; i++)
4149 s += strlen(args[i]) + 1;
4153 *state = SMFIR_TEMPFAIL;
4157 buf = (char *) xalloc(s);
4159 for (i = 0; args[i] != NULL; i++)
4161 (void) sm_strlcpy(bp, args[i], s - (bp - buf));
4162 bp += strlen(bp) + 1;
4165 if (MilterLogLevel > 14)
4166 sm_syslog(LOG_INFO, e->e_id, "Milter: sender: %s", buf);
4169 response = milter_command(SMFIC_MAIL, buf, s, MilterEnvFromMacros,
4170 e, state, "mail", false);
4171 sm_free(buf); /* XXX */
4174 ** If filter rejects/discards a per message command,
4175 ** abort the other filters since we are done with the
4179 MILTER_CHECK_DONE_MSG();
4180 if (MilterLogLevel > 10 && *state == SMFIR_REJECT)
4181 sm_syslog(LOG_INFO, e->e_id, "Milter: reject, sender");
4186 ** MILTER_ENVRCPT -- send SMTP RCPT command info to milter filters
4189 ** args -- SMTP MAIL command args (args[0] == recipient).
4190 ** e -- current envelope.
4191 ** state -- return state from response.
4192 ** rcpt_error -- does RCPT have an error?
4195 ** response string (may be NULL)
4199 milter_envrcpt(args, e, state, rcpt_error)
4212 sm_dprintf("milter_envrcpt:");
4213 for (i = 0; args[i] != NULL; i++)
4214 sm_dprintf(" %s", args[i]);
4219 if (args[0] == NULL)
4221 *state = SMFIR_REJECT;
4222 if (MilterLogLevel > 10)
4223 sm_syslog(LOG_INFO, e->e_id, "Milter: reject, no rcpt");
4227 /* put together data */
4229 for (i = 0; args[i] != NULL; i++)
4230 s += strlen(args[i]) + 1;
4234 *state = SMFIR_TEMPFAIL;
4238 buf = (char *) xalloc(s);
4240 for (i = 0; args[i] != NULL; i++)
4242 (void) sm_strlcpy(bp, args[i], s - (bp - buf));
4243 bp += strlen(bp) + 1;
4246 if (MilterLogLevel > 14)
4247 sm_syslog(LOG_INFO, e->e_id, "Milter: rcpts: %s", buf);
4250 response = milter_command(SMFIC_RCPT, buf, s, MilterEnvRcptMacros,
4251 e, state, "rcpt", rcpt_error);
4252 sm_free(buf); /* XXX */
4257 ** MILTER_DATA_CMD -- send SMTP DATA command info to milter filters
4260 ** e -- current envelope.
4261 ** state -- return state from response.
4264 ** response string (may be NULL)
4268 milter_data_cmd(e, state)
4273 sm_dprintf("milter_data_cmd\n");
4276 return milter_command(SMFIC_DATA, NULL, 0, MilterDataMacros, e, state,
4281 ** MILTER_DATA -- send message headers/body and gather final message results
4284 ** e -- current envelope.
4285 ** state -- return state from response.
4288 ** response string (may be NULL)
4291 ** - Uses e->e_dfp for access to the body
4292 ** - Can call the various milter action routines to
4293 ** modify the envelope or message.
4296 # define MILTER_CHECK_RESULTS() \
4297 if (*state == SMFIR_ACCEPT || \
4298 m->mf_state == SMFS_DONE || \
4299 m->mf_state == SMFS_ERROR) \
4301 if (m->mf_state != SMFS_ERROR) \
4302 m->mf_state = SMFS_DONE; \
4303 continue; /* to next filter */ \
4305 if (*state != SMFIR_CONTINUE) \
4307 m->mf_state = SMFS_DONE; \
4312 milter_data(e, state)
4316 bool replbody = false; /* milter_replbody() called? */
4317 bool replfailed = false; /* milter_replbody() failed? */
4318 bool rewind = false; /* rewind data file? */
4319 bool dfopen = false; /* data file open for writing? */
4320 bool newfilter; /* reset on each new filter */
4324 char *response = NULL;
4329 sm_dprintf("milter_data\n");
4331 *state = SMFIR_CONTINUE;
4334 ** XXX: Should actually send body chunks to each filter
4335 ** a chunk at a time instead of sending the whole body to
4336 ** each filter in turn. However, only if the filters don't
4340 for (i = 0; InputFilters[i] != NULL; i++)
4342 struct milter *m = InputFilters[i];
4344 if (*state != SMFIR_CONTINUE &&
4345 *state != SMFIR_ACCEPT)
4348 ** A previous filter has dealt with the message,
4349 ** safe to stop processing the filters.
4355 /* Now reset state for later evaluation */
4356 *state = SMFIR_CONTINUE;
4359 /* previous problem? */
4360 if (m->mf_state == SMFS_ERROR)
4362 MILTER_CHECK_ERROR(false, continue);
4367 if (m->mf_sock < 0 ||
4368 (m->mf_state != SMFS_OPEN && m->mf_state != SMFS_INMSG))
4371 m->mf_state = SMFS_INMSG;
4373 /* check if filter wants the headers */
4374 if (!bitset(SMFIP_NOHDRS, m->mf_pflags))
4376 response = milter_headers(m, e, state);
4377 MILTER_CHECK_RESULTS();
4380 /* check if filter wants EOH */
4381 if (!bitset(SMFIP_NOEOH, m->mf_pflags))
4384 sm_dprintf("milter_data: eoh\n");
4386 if (MilterEOHMacros[0] != NULL)
4388 milter_send_macros(m, MilterEOHMacros,
4390 MILTER_CHECK_RESULTS();
4394 response = milter_send_command(m, SMFIC_EOH, NULL, 0,
4396 MILTER_CHECK_RESULTS();
4399 /* check if filter wants the body */
4400 if (!bitset(SMFIP_NOBODY, m->mf_pflags) &&
4404 response = milter_body(m, e, state);
4405 MILTER_CHECK_RESULTS();
4408 if (MilterEOMMacros[0] != NULL)
4410 milter_send_macros(m, MilterEOMMacros,
4412 MILTER_CHECK_RESULTS();
4415 /* send the final body chunk */
4416 (void) milter_write(m, SMFIC_BODYEOB, NULL, 0,
4417 m->mf_timeout[SMFTO_WRITE], e, "eom");
4419 /* Get time EOM sent for timeout */
4420 eomsent = curtime();
4422 /* deal with the possibility of multiple responses */
4423 while (*state == SMFIR_CONTINUE)
4425 /* Check total timeout from EOM to final ACK/NAK */
4426 if (m->mf_timeout[SMFTO_EOM] > 0 &&
4427 curtime() - eomsent >= m->mf_timeout[SMFTO_EOM])
4430 sm_dprintf("milter_data(%s): EOM ACK/NAK timeout\n",
4432 if (MilterLogLevel > 0)
4433 sm_syslog(LOG_ERR, e->e_id,
4434 "milter_data(%s): EOM ACK/NAK timeout",
4437 MILTER_CHECK_ERROR(false, break);
4441 response = milter_read(m, &rcmd, &rlen,
4442 m->mf_timeout[SMFTO_READ], e,
4444 if (m->mf_state == SMFS_ERROR)
4448 sm_dprintf("milter_data(%s): state %c\n",
4449 m->mf_name, (char) rcmd);
4453 case SMFIR_REPLYCODE:
4454 MILTER_CHECK_REPLYCODE("554 5.7.1 Command rejected");
4455 if (MilterLogLevel > 12)
4456 sm_syslog(LOG_INFO, e->e_id, "milter=%s, reject=%s",
4457 m->mf_name, response);
4459 m->mf_state = SMFS_DONE;
4462 case SMFIR_REJECT: /* log msg at end of function */
4463 if (MilterLogLevel > 12)
4464 sm_syslog(LOG_INFO, e->e_id, "milter=%s, reject",
4467 m->mf_state = SMFS_DONE;
4471 if (MilterLogLevel > 12)
4472 sm_syslog(LOG_INFO, e->e_id, "milter=%s, discard",
4475 m->mf_state = SMFS_DONE;
4478 case SMFIR_TEMPFAIL:
4479 if (MilterLogLevel > 12)
4480 sm_syslog(LOG_INFO, e->e_id, "milter=%s, tempfail",
4483 m->mf_state = SMFS_DONE;
4486 case SMFIR_CONTINUE:
4488 /* this filter is done with message */
4490 *state = SMFIR_TEMPFAIL;
4492 *state = SMFIR_ACCEPT;
4493 m->mf_state = SMFS_DONE;
4496 case SMFIR_PROGRESS:
4499 case SMFIR_QUARANTINE:
4500 if (!bitset(SMFIF_QUARANTINE, m->mf_fflags))
4502 if (MilterLogLevel > 9)
4503 sm_syslog(LOG_WARNING, e->e_id,
4504 "milter_data(%s): lied about quarantining, honoring request anyway",
4507 if (response == NULL)
4508 response = newstr("");
4509 if (MilterLogLevel > 3)
4510 sm_syslog(LOG_INFO, e->e_id,
4511 "milter=%s, quarantine=%s",
4512 m->mf_name, response);
4513 e->e_quarmsg = sm_rpool_strdup_x(e->e_rpool,
4515 macdefine(&e->e_macro, A_PERM,
4516 macid("{quarantine}"), e->e_quarmsg);
4519 case SMFIR_ADDHEADER:
4520 if (!bitset(SMFIF_ADDHDRS, m->mf_fflags))
4522 if (MilterLogLevel > 9)
4523 sm_syslog(LOG_WARNING, e->e_id,
4524 "milter_data(%s): lied about adding headers, honoring request anyway",
4527 milter_addheader(m, response, rlen, e);
4530 case SMFIR_INSHEADER:
4531 if (!bitset(SMFIF_ADDHDRS, m->mf_fflags))
4533 if (MilterLogLevel > 9)
4534 sm_syslog(LOG_WARNING, e->e_id,
4535 "milter_data(%s): lied about adding headers, honoring request anyway",
4538 milter_insheader(m, response, rlen, e);
4541 case SMFIR_CHGHEADER:
4542 if (!bitset(SMFIF_CHGHDRS, m->mf_fflags))
4544 if (MilterLogLevel > 9)
4545 sm_syslog(LOG_WARNING, e->e_id,
4546 "milter_data(%s): lied about changing headers, honoring request anyway",
4549 milter_changeheader(m, response, rlen, e);
4553 if (!bitset(SMFIF_CHGFROM, m->mf_fflags))
4555 if (MilterLogLevel > 9)
4556 sm_syslog(LOG_WARNING, e->e_id,
4557 "milter_data(%s) lied about changing sender, honoring request anyway",
4560 milter_chgfrom(response, rlen, e);
4564 if (!bitset(SMFIF_ADDRCPT, m->mf_fflags))
4566 if (MilterLogLevel > 9)
4567 sm_syslog(LOG_WARNING, e->e_id,
4568 "milter_data(%s) lied about adding recipients, honoring request anyway",
4571 milter_addrcpt(response, rlen, e);
4574 case SMFIR_ADDRCPT_PAR:
4575 if (!bitset(SMFIF_ADDRCPT_PAR, m->mf_fflags))
4577 if (MilterLogLevel > 9)
4578 sm_syslog(LOG_WARNING, e->e_id,
4579 "milter_data(%s) lied about adding recipients with parameters, honoring request anyway",
4582 milter_addrcpt_par(response, rlen, e);
4586 if (!bitset(SMFIF_DELRCPT, m->mf_fflags))
4588 if (MilterLogLevel > 9)
4589 sm_syslog(LOG_WARNING, e->e_id,
4590 "milter_data(%s): lied about removing recipients, honoring request anyway",
4593 milter_delrcpt(response, rlen, e);
4596 case SMFIR_REPLBODY:
4597 if (!bitset(SMFIF_MODBODY, m->mf_fflags))
4599 if (MilterLogLevel > 0)
4600 sm_syslog(LOG_ERR, e->e_id,
4601 "milter_data(%s): lied about replacing body, rejecting request and tempfailing message",
4607 /* already failed in attempt */
4613 if (milter_reopen_df(e) < 0)
4622 if (milter_replbody(response, rlen,
4630 /* Invalid response to command */
4631 if (MilterLogLevel > 0)
4632 sm_syslog(LOG_ERR, e->e_id,
4633 "milter_data(%s): returned bogus response %c",
4638 if (rcmd != SMFIR_REPLYCODE && response != NULL)
4640 sm_free(response); /* XXX */
4644 if (m->mf_state == SMFS_ERROR)
4648 if (replbody && !replfailed)
4650 /* flush possible buffered character */
4651 milter_replbody(NULL, 0, !replbody, e);
4655 if (m->mf_state == SMFS_ERROR)
4657 MILTER_CHECK_ERROR(false, continue);
4663 /* leave things in the expected state if we touched it */
4666 if (*state == SMFIR_CONTINUE ||
4667 *state == SMFIR_ACCEPT)
4669 *state = SMFIR_TEMPFAIL;
4670 SM_FREE_CLR(response);
4675 (void) sm_io_close(e->e_dfp, SM_TIME_DEFAULT);
4677 e->e_flags &= ~EF_HAS_DF;
4683 if ((dfopen && milter_reset_df(e) < 0) ||
4684 (rewind && bfrewind(e->e_dfp) < 0))
4687 ExitStat = EX_IOERR;
4690 ** If filter told us to keep message but we had
4691 ** an error, we can't really keep it, tempfail it.
4694 if (*state == SMFIR_CONTINUE ||
4695 *state == SMFIR_ACCEPT)
4697 *state = SMFIR_TEMPFAIL;
4698 SM_FREE_CLR(response);
4702 syserr("milter_data: %s/%cf%s: read error",
4703 qid_printqueue(e->e_qgrp, e->e_qdir),
4704 DATAFL_LETTER, e->e_id);
4707 MILTER_CHECK_DONE_MSG();
4708 if (MilterLogLevel > 10 && *state == SMFIR_REJECT)
4709 sm_syslog(LOG_INFO, e->e_id, "Milter: reject, data");
4714 ** MILTER_UNKNOWN -- send any unrecognized or unimplemented command
4715 ** string to milter filters
4718 ** smtpcmd -- the string itself.
4719 ** e -- current envelope.
4720 ** state -- return state from response.
4724 ** response string (may be NULL)
4728 milter_unknown(smtpcmd, e, state)
4734 sm_dprintf("milter_unknown(%s)\n", smtpcmd);
4736 return milter_command(SMFIC_UNKNOWN, smtpcmd, strlen(smtpcmd) + 1,
4737 NULL, e, state, "unknown", false);
4741 ** MILTER_QUIT -- informs the filter(s) we are done and closes connection(s)
4744 ** e -- current envelope.
4757 sm_dprintf("milter_quit(%s)\n", e->e_id);
4759 for (i = 0; InputFilters[i] != NULL; i++)
4760 milter_quit_filter(InputFilters[i], e);
4764 ** MILTER_ABORT -- informs the filter(s) that we are aborting current message
4767 ** e -- current envelope.
4780 sm_dprintf("milter_abort\n");
4782 for (i = 0; InputFilters[i] != NULL; i++)
4784 struct milter *m = InputFilters[i];
4787 if (m->mf_sock < 0 || m->mf_state != SMFS_INMSG)
4790 milter_abort_filter(m, e);