2 * Copyright (c) 1999-2009, 2012, 2013 Proofpoint, 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.281 2013-11-22 20:51:56 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, 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,
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 */
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).
88 static char *MilterMacros[SMFIM_LAST + 1][MAXFILTERS + 1][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 /* 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
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)) \
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 (tTd(71, 101)) \
124 if (e->e_quarmsg == NULL) \
126 e->e_quarmsg = sm_rpool_strdup_x(e->e_rpool, \
128 macdefine(&e->e_macro, A_PERM, macid("{quarantine}"), \
132 else MILTER_SET_STATE; \
136 # define MILTER_CHECK_REPLYCODE(default) \
137 if (response == NULL || \
138 strlen(response) + 1 != (size_t) rlen || \
140 (response[0] != '4' && response[0] != '5') || \
141 !isascii(response[1]) || !isdigit(response[1]) || \
142 !isascii(response[2]) || !isdigit(response[2])) \
144 if (response != NULL) \
145 sm_free(response); /* XXX */ \
146 response = newstr(default); \
150 char *ptr = response; \
152 /* Check for unprotected %'s in the string */ \
153 while (*ptr != '\0') \
155 if (*ptr == '%' && *++ptr != '%') \
157 sm_free(response); /* XXX */ \
158 response = newstr(default); \
165 # define MILTER_DF_ERROR(msg) \
167 int save_errno = errno; \
171 sm_dprintf(msg, dfname, sm_errstring(save_errno)); \
174 if (MilterLogLevel > 0) \
175 sm_syslog(LOG_ERR, e->e_id, msg, dfname, sm_errstring(save_errno)); \
176 if (SuperSafe == SAFE_REALLY) \
178 if (e->e_dfp != NULL) \
180 (void) sm_io_close(e->e_dfp, SM_TIME_DEFAULT); \
183 e->e_flags &= ~EF_HAS_DF; \
185 errno = save_errno; \
189 ** MILTER_TIMEOUT -- make sure socket is ready in time
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
197 ** Assumes 'm' is a milter structure for the current socket.
200 # define MILTER_TIMEOUT(routine, secs, write, started, function) \
207 if (!SM_FD_OK_SELECT(m->mf_sock)) \
210 sm_dprintf("milter_%s(%s): socket %d is larger than FD_SETSIZE %d\n", \
211 (routine), m->mf_name, m->mf_sock, \
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, \
218 milter_error(m, e); \
225 SM_FD_SET(m->mf_sock, &fds); \
226 tv.tv_sec = (secs); \
228 ret = select(m->mf_sock + 1, \
229 (write) ? NULL : &fds, \
230 (write) ? &fds : NULL, \
232 } while (ret < 0 && errno == EINTR); \
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", \
244 started ? "during" : "before", \
245 (routine), (function)); \
246 milter_error(m, e); \
250 save_errno = errno; \
252 sm_dprintf("milter_%s(%s): select: %s\n", (routine), \
253 m->mf_name, sm_errstring(save_errno)); \
254 if (MilterLogLevel > 0) \
256 sm_syslog(LOG_ERR, e->e_id, \
257 "Milter (%s): select(%s): %s", \
258 m->mf_name, (routine), \
259 sm_errstring(save_errno)); \
261 milter_error(m, e); \
265 if (SM_FD_ISSET(m->mf_sock, &fds)) \
268 sm_dprintf("milter_%s(%s): socket not ready\n", \
269 (routine), m->mf_name); \
270 if (MilterLogLevel > 0) \
272 sm_syslog(LOG_ERR, e->e_id, \
273 "Milter (%s): socket(%s) not ready", \
274 m->mf_name, (routine)); \
276 milter_error(m, e); \
282 ** Low level functions
286 ** MILTER_READ -- read from a remote milter filter
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.
296 ** response string (may be NULL)
300 milter_sysread(m, buf, sz, to, e, where)
308 time_t readstart = 0;
310 bool started = false;
315 readstart = curtime();
324 if (now - readstart >= to)
327 sm_dprintf("milter_sys_read (%s): timeout %s data read in %s",
329 started ? "during" : "before",
331 if (MilterLogLevel > 0)
332 sm_syslog(LOG_ERR, e->e_id,
333 "Milter (%s): timeout %s data read in %s",
335 started ? "during" : "before",
340 to -= now - readstart;
342 MILTER_TIMEOUT("read", to, false, started, where);
345 len = read(m->mf_sock, buf + curl, sz - curl);
349 int save_errno = errno;
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));
366 if (len == 0 || curl >= sz)
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);
387 milter_read(m, cmd, rlen, to, e, where)
395 time_t readstart = 0;
398 # if MILTER_NO_NAGLE && defined(TCP_CORK)
400 # endif /* MILTER_NO_NAGLE && defined(TCP_CORK) */
402 char data[MILTER_LEN_BYTES + 1];
406 if (MilterLogLevel > 0)
407 sm_syslog(LOG_ERR, e->e_id,
408 "milter_read(%s): socket closed, where=%s",
418 readstart = curtime();
420 # if MILTER_NO_NAGLE && defined(TCP_CORK)
421 setsockopt(m->mf_sock, IPPROTO_TCP, TCP_CORK, (char *)&cork,
423 # endif /* MILTER_NO_NAGLE && defined(TCP_CORK) */
425 if (milter_sysread(m, data, sizeof(data), to, e, where) == NULL)
428 # if MILTER_NO_NAGLE && defined(TCP_CORK)
430 setsockopt(m->mf_sock, IPPROTO_TCP, TCP_CORK, (char *)&cork,
432 # endif /* MILTER_NO_NAGLE && defined(TCP_CORK) */
440 if (now - readstart >= to)
443 sm_dprintf("milter_read(%s): timeout before data read, where=%s\n",
445 if (MilterLogLevel > 0)
446 sm_syslog(LOG_ERR, e->e_id,
447 "Milter read(%s): timeout before data read, where=%s",
452 to -= now - readstart;
455 *cmd = data[MILTER_LEN_BYTES];
456 data[MILTER_LEN_BYTES] = '\0';
457 (void) memcpy(&i, data, MILTER_LEN_BYTES);
461 sm_dprintf("milter_read(%s): expecting %ld bytes\n",
462 m->mf_name, (long) expl);
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);
480 buf = (char *) xalloc(expl);
482 if (milter_sysread(m, buf, expl, to, e, where) == NULL)
484 sm_free(buf); /* XXX */
489 sm_dprintf("milter_read(%s): Returning %*s\n",
490 m->mf_name, (int) expl, buf);
496 ** MILTER_WRITE -- write to a remote milter filter
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.
507 ** buf if successful, NULL otherwise
508 ** Not actually used anywhere but function prototype
509 ** must match milter_read()
513 milter_write(m, cmd, buf, len, to, e, where)
525 char command = (char) cmd;
526 char data[MILTER_LEN_BYTES + 1];
527 bool started = false;
528 struct iovec vector[2];
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.
536 if (len < 0 || len > MilterMaxDataSize)
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));
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);
554 if (MilterLogLevel > 0)
555 sm_syslog(LOG_ERR, e->e_id,
556 "milter_write(%s): socket closed",
563 sm_dprintf("milter_write(%s): cmd %c, len %ld\n",
564 m->mf_name, command, (long) len);
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;
571 /* set up the vector for the size / command */
572 vector[0].iov_base = (void *) data;
573 vector[0].iov_len = sl;
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.
581 /* NOTE: len<0 has already been checked for. Pedantic */
582 if (len <= 0 || buf == NULL)
584 /* There is no command data -- only a size / command data */
590 ** There is both size / command and command data.
591 ** Set up the vector for the command data.
596 vector[1].iov_base = (void *) buf;
597 vector[1].iov_len = len;
600 sm_dprintf("milter_write(%s): Sending %*s\n",
601 m->mf_name, (int) len, buf);
605 MILTER_TIMEOUT("write", to, true, started, where);
607 /* write the vector(s) */
608 i = writev(m->mf_sock, vector, num_vectors);
611 int save_errno = errno;
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));
633 ** MILTER_OPEN -- connect to remote milter filter
636 ** m -- milter to connect to.
637 ** parseonly -- parse but don't connect.
638 ** e -- current envelope.
641 ** connected socket if successful && !parseonly,
642 ** 0 upon parse success if parseonly,
646 static jmp_buf MilterConnectTimeout;
649 milter_open(m, parseonly, e)
655 SOCKADDR_LEN_T addrlen = 0;
661 struct hostent *hp = NULL;
664 if (m->mf_conn == NULL || m->mf_conn[0] == '\0')
667 sm_dprintf("X%s: empty or missing socket information\n",
670 syserr("X%s: empty or missing socket information",
672 else if (MilterLogLevel > 0)
673 sm_syslog(LOG_ERR, e->e_id,
674 "Milter (%s): empty or missing socket information",
680 /* protocol:filename or protocol:port@host */
681 memset(&addr, '\0', sizeof(addr));
683 colon = strchr(p, ':');
691 /* default to AF_UNIX */
692 addr.sa.sa_family = AF_UNIX;
695 /* default to AF_INET */
696 addr.sa.sa_family = AF_INET;
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",
709 # endif /* NETINET6 */
710 # endif /* NETINET */
711 # endif /* NETUNIX */
714 else if (sm_strcasecmp(p, "unix") == 0 ||
715 sm_strcasecmp(p, "local") == 0)
716 addr.sa.sa_family = AF_UNIX;
717 # endif /* NETUNIX */
719 else if (sm_strcasecmp(p, "inet") == 0)
720 addr.sa.sa_family = AF_INET;
721 # endif /* NETINET */
723 else if (sm_strcasecmp(p, "inet6") == 0)
724 addr.sa.sa_family = AF_INET6;
725 # endif /* NETINET6 */
728 # ifdef EPROTONOSUPPORT
729 errno = EPROTONOSUPPORT;
730 # else /* EPROTONOSUPPORT */
732 # endif /* EPROTONOSUPPORT */
734 sm_dprintf("X%s: unknown socket type %s\n",
737 syserr("X%s: unknown socket type %s",
739 else if (MilterLogLevel > 0)
740 sm_syslog(LOG_ERR, e->e_id,
741 "Milter (%s): unknown socket type %s",
750 /* default to AF_UNIX */
751 addr.sa.sa_family = AF_UNIX;
756 if (addr.sa.sa_family == AF_UNIX)
758 long sff = SFF_SAFEDIRPATH|SFF_OPENASROOT|SFF_NOLINK|SFF_EXECOK;
761 if (strlen(colon) >= sizeof(addr.sunix.sun_path))
764 sm_dprintf("X%s: local socket name %s too long\n",
768 syserr("X%s: local socket name %s too long",
770 else if (MilterLogLevel > 0)
771 sm_syslog(LOG_ERR, e->e_id,
772 "Milter (%s): local socket name %s too long",
777 errno = safefile(colon, RunAsUid, RunAsGid, RunAsUserName, sff,
778 S_IRUSR|S_IWUSR, NULL);
780 /* if just parsing .cf file, socket doesn't need to exist */
781 if (parseonly && errno == ENOENT)
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",
791 /* if not safe, don't create */
794 sm_dprintf("X%s: local socket name %s unsafe\n",
799 if (OpMode == MD_DAEMON ||
800 OpMode == MD_FGDAEMON ||
802 syserr("X%s: local socket name %s unsafe",
805 else if (MilterLogLevel > 0)
806 sm_syslog(LOG_ERR, e->e_id,
807 "Milter (%s): local socket name %s unsafe",
813 (void) sm_strlcpy(addr.sunix.sun_path, colon,
814 sizeof(addr.sunix.sun_path));
815 addrlen = sizeof(struct sockaddr_un);
818 # endif /* NETUNIX */
819 # if NETINET || NETINET6
822 || addr.sa.sa_family == AF_INET
823 # endif /* NETINET */
825 || addr.sa.sa_family == AF_INET6
826 # endif /* NETINET6 */
831 /* Parse port@host */
832 at = strchr(colon, '@');
836 sm_dprintf("X%s: bad address %s (expected port@host)\n",
839 syserr("X%s: bad address %s (expected port@host)",
841 else if (MilterLogLevel > 0)
842 sm_syslog(LOG_ERR, e->e_id,
843 "Milter (%s): bad address %s (expected port@host)",
849 if (isascii(*colon) && isdigit(*colon))
850 port = htons((unsigned short) atoi(colon));
853 # ifdef NO_GETSERVBYNAME
855 sm_dprintf("X%s: invalid port number %s\n",
858 syserr("X%s: invalid port number %s",
860 else if (MilterLogLevel > 0)
861 sm_syslog(LOG_ERR, e->e_id,
862 "Milter (%s): invalid port number %s",
866 # else /* NO_GETSERVBYNAME */
869 sp = getservbyname(colon, "tcp");
874 sm_dprintf("X%s: unknown port name %s\n",
878 syserr("X%s: unknown port name %s",
880 else if (MilterLogLevel > 0)
881 sm_syslog(LOG_ERR, e->e_id,
882 "Milter (%s): unknown port name %s",
888 # endif /* NO_GETSERVBYNAME */
895 end = strchr(at, ']');
900 unsigned long hid = INADDR_NONE;
901 # endif /* NETINET */
903 struct sockaddr_in6 hid6;
904 # endif /* NETINET6 */
908 if (addr.sa.sa_family == AF_INET &&
909 (hid = inet_addr(&at[1])) != INADDR_NONE)
911 addr.sin.sin_addr.s_addr = hid;
912 addr.sin.sin_port = port;
915 # endif /* NETINET */
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)
922 addr.sin6.sin6_addr = hid6.sin6_addr;
923 addr.sin6.sin6_port = port;
926 # endif /* NETINET6 */
931 sm_dprintf("X%s: Invalid numeric domain spec \"%s\"\n",
934 syserr("X%s: Invalid numeric domain spec \"%s\"",
936 else if (MilterLogLevel > 0)
937 sm_syslog(LOG_ERR, e->e_id,
938 "Milter (%s): Invalid numeric domain spec \"%s\"",
947 sm_dprintf("X%s: Invalid numeric domain spec \"%s\"\n",
950 syserr("X%s: Invalid numeric domain spec \"%s\"",
952 else if (MilterLogLevel > 0)
953 sm_syslog(LOG_ERR, e->e_id,
954 "Milter (%s): Invalid numeric domain spec \"%s\"",
962 hp = sm_gethostbyname(at, addr.sa.sa_family);
967 sm_dprintf("X%s: Unknown host name %s\n",
971 syserr("X%s: Unknown host name %s",
973 else if (MilterLogLevel > 0)
974 sm_syslog(LOG_ERR, e->e_id,
975 "Milter (%s): Unknown host name %s",
980 addr.sa.sa_family = hp->h_addrtype;
981 switch (hp->h_addrtype)
985 memmove(&addr.sin.sin_addr,
986 hp->h_addr, INADDRSZ);
987 addr.sin.sin_port = port;
988 addrlen = sizeof(struct sockaddr_in);
991 # endif /* NETINET */
995 memmove(&addr.sin6.sin6_addr,
996 hp->h_addr, IN6ADDRSZ);
997 addr.sin6.sin6_port = port;
998 addrlen = sizeof(struct sockaddr_in6);
1001 # endif /* NETINET6 */
1005 sm_dprintf("X%s: Unknown protocol for %s (%d)\n",
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)",
1019 # endif /* NETINET6 */
1025 # endif /* NETINET || NETINET6 */
1028 sm_dprintf("X%s: unknown socket protocol\n",
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",
1040 /* just parsing through? */
1043 m->mf_state = SMFS_READY;
1047 # endif /* NETINET6 */
1052 if (m->mf_state != SMFS_READY &&
1053 m->mf_state != SMFS_CLOSED)
1055 /* shouldn't happen */
1057 sm_dprintf("Milter (%s): Trying to open filter in state %c\n",
1058 m->mf_name, (char) m->mf_state);
1063 # endif /* NETINET6 */
1067 /* nope, actually connecting */
1070 sock = socket(addr.sa.sa_family, SOCK_STREAM, 0);
1075 sm_dprintf("Milter (%s): error creating socket: %s\n",
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));
1086 # endif /* NETINET6 */
1090 if (setjmp(MilterConnectTimeout) == 0)
1092 SM_EVENT *ev = NULL;
1095 if (m->mf_timeout[SMFTO_CONNECT] > 0)
1096 ev = sm_setevent(m->mf_timeout[SMFTO_CONNECT],
1097 milter_connect_timeout, 0);
1099 i = connect(sock, (struct sockaddr *) &addr, addrlen);
1108 /* couldn't connect.... try next address */
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));
1122 /* try next address */
1123 if (hp != NULL && hp->h_addr_list[addrno] != NULL)
1125 switch (addr.sa.sa_family)
1129 memmove(&addr.sin.sin_addr,
1130 hp->h_addr_list[addrno++],
1133 # endif /* NETINET */
1137 memmove(&addr.sin6.sin6_addr,
1138 hp->h_addr_list[addrno++],
1141 # endif /* NETINET6 */
1145 sm_dprintf("X%s: Unknown protocol for %s (%d)\n",
1148 if (MilterLogLevel > 0)
1149 sm_syslog(LOG_ERR, e->e_id,
1150 "Milter (%s): Unknown protocol for %s (%d)",
1156 # endif /* NETINET6 */
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));
1175 # endif /* NETINET6 */
1178 m->mf_state = SMFS_OPEN;
1185 # endif /* NETINET6 */
1186 # if MILTER_NO_NAGLE && !defined(TCP_CORK)
1190 setsockopt(m->mf_sock, IPPROTO_TCP, TCP_NODELAY,
1191 (char *)&nodelay, sizeof(nodelay));
1193 # endif /* MILTER_NO_NAGLE && !defined(TCP_CORK) */
1198 milter_connect_timeout(ignore)
1202 ** NOTE: THIS CAN BE CALLED FROM A SIGNAL HANDLER. DO NOT ADD
1203 ** ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE
1208 longjmp(MilterConnectTimeout, 1);
1212 ** MILTER_SETUP -- setup structure for a mail filter
1215 ** line -- the options line.
1231 /* collect the filter name */
1233 *p != '\0' && *p != ',' && !(isascii(*p) && isspace(*p));
1238 if (line[0] == '\0')
1240 syserr("name required for mail filter");
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;
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 */
1258 /* now scan through and assign info from the fields */
1263 while (*p != '\0' &&
1264 (*p == ',' || (isascii(*p) && isspace(*p))))
1267 /* p now points to field code */
1269 while (*p != '\0' && *p != '=' && *p != ',')
1273 syserr("X%s: `=' expected", m->mf_name);
1276 while (isascii(*p) && isspace(*p))
1279 /* p now points to the field body */
1280 p = munchstring(p, &delimptr, ',');
1282 /* install the field into the filter struct */
1285 case 'S': /* socket */
1289 m->mf_conn = newstr(p);
1292 case 'F': /* Milter flags configured on MTA */
1293 for (; *p != '\0'; p++)
1295 if (!(isascii(*p) && isspace(*p)))
1296 setbitn(bitidx(*p), m->mf_flags);
1300 case 'T': /* timeouts */
1301 milter_parse_timeouts(p, m);
1304 #if _FFR_MILTER_CHECK
1306 m->mf_mta_actions = strtoul(p, NULL, 0);
1309 m->mf_mta_prot_flags = strtoul(p, NULL, 0);
1312 m->mf_mta_prot_version = strtoul(p, NULL, 0);
1314 #endif /* _FFR_MILTER_CHECK */
1317 syserr("X%s: unknown filter equate %c=",
1324 /* early check for errors */
1325 (void) milter_open(m, true, CurEnv);
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);
1339 ** MILTER_CONFIG -- parse option list into an array and check config
1341 ** Called when reading configuration file.
1344 ** spec -- the filter list.
1345 ** list -- the array to fill in.
1346 ** max -- the maximum number of entries in list.
1353 milter_config(spec, list, max)
1355 struct milter **list;
1361 /* leave one for the NULL signifying the end of the list */
1364 for (p = spec; p != NULL; )
1368 while (isascii(*p) && isspace(*p))
1374 if (numitems >= max)
1376 syserr("Too many filters defined, %d max", max);
1381 p = strpbrk(p, ";,");
1385 s = stab(spec, ST_MILTER, ST_FIND);
1388 syserr("InputFilter %s not defined", spec);
1389 ExitStat = EX_CONFIG;
1392 list[numitems++] = s->s_milter;
1394 list[numitems] = NULL;
1396 /* if not set, set to LogLevel */
1397 if (MilterLogLevel == -1)
1398 MilterLogLevel = LogLevel;
1402 ** MILTER_PARSE_TIMEOUTS -- parse timeout list
1404 ** Called when reading configuration file.
1407 ** spec -- the timeout list.
1408 ** m -- milter to set.
1415 milter_parse_timeouts(spec, m)
1425 /* now scan through and assign info from the fields */
1430 while (*p != '\0' &&
1431 (*p == ';' || (isascii(*p) && isspace(*p))))
1434 /* p now points to field code */
1436 while (*p != '\0' && *p != ':')
1440 syserr("X%s, T=: `:' expected", m->mf_name);
1443 while (isascii(*p) && isspace(*p))
1446 /* p now points to the field body */
1447 p = munchstring(p, &delimptr, ';');
1450 /* install the field into the filter struct */
1454 tcode = SMFTO_CONNECT;
1458 tcode = SMFTO_WRITE;
1471 sm_dprintf("X%s: %c unknown\n",
1473 syserr("X%s: unknown filter timeout %c",
1479 m->mf_timeout[tcode] = convtime(p, 's');
1481 sm_dprintf("X%s: %c=%ld\n",
1483 (u_long) m->mf_timeout[tcode]);
1490 ** MILTER_SET_MACROS -- set milter macros
1493 ** name -- name of milter.
1494 ** macros -- where to store macros.
1495 ** val -- the value of the option.
1496 ** nummac -- current number of macros
1499 ** new number of macros
1503 milter_set_macros(name, macros, val, nummac)
1516 /* Skip leading commas, spaces */
1517 while (*p != '\0' &&
1518 (*p == ',' || (isascii(*p) && isspace(*p))))
1524 /* Find end of macro */
1526 while (*p != '\0' && *p != ',' &&
1527 isascii(*p) && !isspace(*p))
1532 if (nummac >= MAXFILTERMACROS)
1534 syserr("milter_set_option: too many macros in Milter.%s (max %d)",
1535 name, MAXFILTERMACROS);
1536 macros[nummac] = NULL;
1539 macros[nummac++] = macro;
1541 macros[nummac] = NULL;
1546 ** MILTER_SET_OPTION -- set an individual milter option
1549 ** name -- the name of the option.
1550 ** val -- the value of the option.
1551 ** sticky -- if set, don't let other setoptions override
1558 /* set if Milter sub-option is stuck */
1559 static BITMAP256 StickyMilterOpt;
1561 static struct milteropt
1563 char *mo_name; /* long name of milter option */
1564 unsigned char mo_code; /* code for option */
1567 { "macros.connect", SMFIM_CONNECT },
1568 { "macros.helo", SMFIM_HELO },
1569 { "macros.envfrom", SMFIM_ENVFROM },
1570 { "macros.envrcpt", SMFIM_ENVRCPT },
1571 { "macros.data", SMFIM_DATA },
1572 { "macros.eom", SMFIM_EOM },
1573 { "macros.eoh", SMFIM_EOH },
1575 # define MO_LOGLEVEL 0x07
1576 { "loglevel", MO_LOGLEVEL },
1577 # if _FFR_MAXDATASIZE || _FFR_MDS_NEGOTIATE
1578 # define MO_MAXDATASIZE 0x08
1579 { "maxdatasize", MO_MAXDATASIZE },
1580 # endif /* _FFR_MAXDATASIZE || _FFR_MDS_NEGOTIATE */
1581 { NULL, (unsigned char)-1 },
1585 milter_set_option(name, val, sticky)
1591 struct milteropt *mo;
1592 char **macros = NULL;
1595 if (tTd(37, 2) || tTd(64, 5))
1596 sm_dprintf("milter_set_option(%s = %s)", name, val);
1600 syserr("milter_set_option: invalid Milter option, must specify suboption");
1604 for (mo = MilterOptTab; mo->mo_name != NULL; mo++)
1606 if (sm_strcasecmp(mo->mo_name, name) == 0)
1610 if (mo->mo_name == NULL)
1612 syserr("milter_set_option: invalid Milter option %s", name);
1617 ** See if this option is preset for us.
1620 if (!sticky && bitnset(mo->mo_code, StickyMilterOpt))
1622 if (tTd(37, 2) || tTd(64,5))
1623 sm_dprintf(" (ignored)\n");
1627 if (tTd(37, 2) || tTd(64,5))
1630 switch (mo->mo_code)
1633 MilterLogLevel = atoi(val);
1636 # if _FFR_MAXDATASIZE || _FFR_MDS_NEGOTIATE
1637 case MO_MAXDATASIZE:
1638 # if _FFR_MDS_NEGOTIATE
1639 MilterMaxDataSize = (size_t)atol(val);
1640 if (MilterMaxDataSize != MILTER_MDS_64K &&
1641 MilterMaxDataSize != MILTER_MDS_256K &&
1642 MilterMaxDataSize != MILTER_MDS_1M)
1644 sm_syslog(LOG_WARNING, NOQID,
1645 "WARNING: Milter.%s=%lu, allowed are only %d, %d, and %d",
1646 name, (unsigned long) MilterMaxDataSize,
1647 MILTER_MDS_64K, MILTER_MDS_256K,
1649 if (MilterMaxDataSize < MILTER_MDS_64K)
1650 MilterMaxDataSize = MILTER_MDS_64K;
1651 else if (MilterMaxDataSize < MILTER_MDS_256K)
1652 MilterMaxDataSize = MILTER_MDS_256K;
1654 MilterMaxDataSize = MILTER_MDS_1M;
1656 # endif /* _FFR_MDS_NEGOTIATE */
1658 # endif /* _FFR_MAXDATASIZE || _FFR_MDS_NEGOTIATE */
1667 macros = MilterMacros[mo->mo_code][0];
1669 r = milter_set_macros(name, macros, val, nummac);
1675 syserr("milter_set_option: invalid Milter option %s", name);
1679 setbitn(mo->mo_code, StickyMilterOpt);
1683 ** MILTER_REOPEN_DF -- open & truncate the data file (for replbody)
1686 ** e -- current envelope.
1689 ** 0 if succesful, -1 otherwise
1696 char dfname[MAXPATHLEN];
1698 (void) sm_strlcpy(dfname, queuename(e, DATAFL_LETTER), sizeof(dfname));
1701 ** In SuperSafe == SAFE_REALLY mode, e->e_dfp is a read-only FP so
1702 ** close and reopen writable (later close and reopen
1703 ** read only again).
1705 ** In SuperSafe != SAFE_REALLY mode, e->e_dfp still points at the
1706 ** buffered file I/O descriptor, still open for writing so there
1707 ** isn't any work to do here (except checking for consistency).
1710 if (SuperSafe == SAFE_REALLY)
1712 /* close read-only data file */
1713 if (bitset(EF_HAS_DF, e->e_flags) && e->e_dfp != NULL)
1715 (void) sm_io_close(e->e_dfp, SM_TIME_DEFAULT);
1716 e->e_flags &= ~EF_HAS_DF;
1720 if ((e->e_dfp = sm_io_open(SmFtStdio, SM_TIME_DEFAULT, dfname,
1721 SM_IO_RDWR_B, NULL)) == NULL)
1723 MILTER_DF_ERROR("milter_reopen_df: sm_io_open %s: %s");
1727 else if (e->e_dfp == NULL)
1729 /* shouldn't happen */
1731 MILTER_DF_ERROR("milter_reopen_df: NULL e_dfp (%s: %s)");
1738 ** MILTER_RESET_DF -- re-open read-only the data file (for replbody)
1741 ** e -- current envelope.
1744 ** 0 if succesful, -1 otherwise
1752 char dfname[MAXPATHLEN];
1754 (void) sm_strlcpy(dfname, queuename(e, DATAFL_LETTER), sizeof(dfname));
1756 if (sm_io_flush(e->e_dfp, SM_TIME_DEFAULT) != 0 ||
1757 sm_io_error(e->e_dfp))
1759 MILTER_DF_ERROR("milter_reset_df: error writing/flushing %s: %s");
1762 else if (SuperSafe != SAFE_REALLY)
1764 /* skip next few clauses */
1767 else if ((afd = sm_io_getinfo(e->e_dfp, SM_IO_WHAT_FD, NULL)) >= 0
1770 MILTER_DF_ERROR("milter_reset_df: error sync'ing %s: %s");
1773 else if (sm_io_close(e->e_dfp, SM_TIME_DEFAULT) < 0)
1775 MILTER_DF_ERROR("milter_reset_df: error closing %s: %s");
1778 else if ((e->e_dfp = sm_io_open(SmFtStdio, SM_TIME_DEFAULT, dfname,
1779 SM_IO_RDONLY_B, NULL)) == NULL)
1781 MILTER_DF_ERROR("milter_reset_df: error reopening %s: %s");
1785 e->e_flags |= EF_HAS_DF;
1790 ** MILTER_QUIT_FILTER -- close down a single filter
1793 ** m -- milter structure of filter to close down.
1794 ** e -- current envelope.
1801 milter_quit_filter(m, e)
1806 sm_dprintf("milter_quit_filter(%s)\n", m->mf_name);
1807 if (MilterLogLevel > 18)
1808 sm_syslog(LOG_INFO, e->e_id, "Milter (%s): quit filter",
1811 /* Never replace error state */
1812 if (m->mf_state == SMFS_ERROR)
1815 if (m->mf_sock < 0 ||
1816 m->mf_state == SMFS_CLOSED ||
1817 m->mf_state == SMFS_READY)
1820 m->mf_state = SMFS_CLOSED;
1824 (void) milter_write(m, SMFIC_QUIT, (char *) NULL, 0,
1825 m->mf_timeout[SMFTO_WRITE], e, "quit_filter");
1826 if (m->mf_sock >= 0)
1828 (void) close(m->mf_sock);
1831 if (m->mf_state != SMFS_ERROR)
1832 m->mf_state = SMFS_CLOSED;
1836 ** MILTER_ABORT_FILTER -- tell filter to abort current message
1839 ** m -- milter structure of filter to abort.
1840 ** e -- current envelope.
1847 milter_abort_filter(m, e)
1852 sm_dprintf("milter_abort_filter(%s)\n", m->mf_name);
1853 if (MilterLogLevel > 10)
1854 sm_syslog(LOG_INFO, e->e_id, "Milter (%s): abort filter",
1857 if (m->mf_sock < 0 ||
1858 m->mf_state != SMFS_INMSG)
1861 (void) milter_write(m, SMFIC_ABORT, (char *) NULL, 0,
1862 m->mf_timeout[SMFTO_WRITE], e, "abort_filter");
1863 if (m->mf_state != SMFS_ERROR)
1864 m->mf_state = SMFS_DONE;
1868 ** MILTER_SEND_MACROS -- provide macros to the filters
1871 ** m -- milter to send macros to.
1872 ** macros -- macros to send for filter smfi_getsymval().
1873 ** cmd -- which command the macros are associated with.
1874 ** e -- current envelope (for macro access).
1881 milter_send_macros(m, macros, cmd, e)
1889 char command = (char) cmd;
1896 if (macros == NULL || macros[0] == NULL)
1899 /* put together data */
1900 s = 1; /* for the command character */
1901 for (i = 0; macros[i] != NULL; i++)
1903 mid = macid(macros[i]);
1906 v = macvalue(mid, e);
1909 expand(v, exp, sizeof(exp), e);
1910 s += strlen(macros[i]) + 1 + strlen(exp) + 1;
1916 buf = (char *) xalloc(s);
1919 for (i = 0; macros[i] != NULL; i++)
1921 mid = macid(macros[i]);
1924 v = macvalue(mid, e);
1927 expand(v, exp, sizeof(exp), e);
1930 sm_dprintf("milter_send_macros(%s, %c): %s=%s\n",
1931 m->mf_name, command, macros[i], exp);
1933 (void) sm_strlcpy(bp, macros[i], s - (bp - buf));
1934 bp += strlen(bp) + 1;
1935 (void) sm_strlcpy(bp, exp, s - (bp - buf));
1936 bp += strlen(bp) + 1;
1938 (void) milter_write(m, SMFIC_MACRO, buf, s,
1939 m->mf_timeout[SMFTO_WRITE], e, "send_macros");
1944 ** MILTER_SEND_COMMAND -- send a command and return the response for a filter
1947 ** m -- current milter filter
1948 ** cmd -- command to send.
1949 ** data -- optional command data.
1950 ** sz -- length of buf.
1951 ** e -- current envelope (for e->e_id).
1952 ** state -- return state word.
1955 ** response string (may be NULL)
1959 milter_send_command(m, cmd, data, sz, e, state, where)
1970 unsigned long skipflag;
1971 unsigned long norespflag = 0;
1972 char command = (char) cmd;
1978 sm_dprintf("milter_send_command(%s): cmd %c len %ld\n",
1979 m->mf_name, (char) command, (long) sz);
1981 /* find skip flag and default failure */
1985 skipflag = SMFIP_NOCONNECT;
1986 norespflag = SMFIP_NR_CONN;
1988 defresponse = "554 Command rejected";
1992 skipflag = SMFIP_NOHELO;
1993 norespflag = SMFIP_NR_HELO;
1995 defresponse = "550 Command rejected";
1999 skipflag = SMFIP_NOMAIL;
2000 norespflag = SMFIP_NR_MAIL;
2002 defresponse = "550 5.7.1 Command rejected";
2006 skipflag = SMFIP_NORCPT;
2007 norespflag = SMFIP_NR_RCPT;
2009 defresponse = "550 5.7.1 Command rejected";
2013 skipflag = SMFIP_NOHDRS;
2014 norespflag = SMFIP_NR_HDR;
2016 defresponse = "550 5.7.1 Command rejected";
2020 skipflag = SMFIP_NOBODY;
2021 norespflag = SMFIP_NR_BODY;
2023 defresponse = "554 5.7.1 Command rejected";
2027 skipflag = SMFIP_NOEOH;
2028 norespflag = SMFIP_NR_EOH;
2030 defresponse = "550 5.7.1 Command rejected";
2034 skipflag = SMFIP_NOUNKNOWN;
2035 norespflag = SMFIP_NR_UNKN;
2037 defresponse = "550 5.7.1 Command rejected";
2041 skipflag = SMFIP_NODATA;
2042 norespflag = SMFIP_NR_DATA;
2044 defresponse = "550 5.7.1 Command rejected";
2052 /* NOTE: not handled by milter_send_command() */
2058 defresponse = "550 5.7.1 Command rejected";
2063 sm_dprintf("milter_send_command(%s): skip=%lx, pflags=%x\n",
2064 m->mf_name, skipflag, m->mf_pflags);
2066 /* check if filter wants this command */
2067 if (skipflag != 0 && bitset(skipflag, m->mf_pflags))
2070 /* send the command to the filter */
2071 (void) milter_write(m, command, data, sz,
2072 m->mf_timeout[SMFTO_WRITE], e, where);
2073 if (m->mf_state == SMFS_ERROR)
2075 MILTER_CHECK_ERROR(false, return NULL);
2079 /* check if filter sends response to this command */
2080 if (norespflag != 0 && bitset(norespflag, m->mf_pflags))
2083 /* get the response from the filter */
2084 response = milter_read(m, &rcmd, &rlen,
2085 m->mf_timeout[SMFTO_READ], e, where);
2086 if (m->mf_state == SMFS_ERROR)
2088 MILTER_CHECK_ERROR(false, return NULL);
2093 sm_dprintf("milter_send_command(%s): returned %c\n",
2094 m->mf_name, (char) rcmd);
2098 case SMFIR_REPLYCODE:
2099 MILTER_CHECK_REPLYCODE(defresponse);
2100 if (MilterLogLevel > 10)
2101 sm_syslog(LOG_INFO, e->e_id,
2102 "milter=%s, action=%s, reject=%s",
2103 m->mf_name, action, response);
2108 if (MilterLogLevel > 10)
2109 sm_syslog(LOG_INFO, e->e_id,
2110 "milter=%s, action=%s, reject",
2111 m->mf_name, action);
2116 if (MilterLogLevel > 10)
2117 sm_syslog(LOG_INFO, e->e_id,
2118 "milter=%s, action=%s, discard",
2119 m->mf_name, action);
2123 case SMFIR_TEMPFAIL:
2124 if (MilterLogLevel > 10)
2125 sm_syslog(LOG_INFO, e->e_id,
2126 "milter=%s, action=%s, tempfail",
2127 m->mf_name, action);
2132 /* this filter is done with message/connection */
2133 if (command == SMFIC_HELO ||
2134 command == SMFIC_CONNECT)
2135 m->mf_state = SMFS_CLOSABLE;
2137 m->mf_state = SMFS_DONE;
2138 if (MilterLogLevel > 10)
2139 sm_syslog(LOG_INFO, e->e_id,
2140 "milter=%s, action=%s, accepted",
2141 m->mf_name, action);
2144 case SMFIR_CONTINUE:
2145 /* if MAIL command is ok, filter is in message state */
2146 if (command == SMFIC_MAIL)
2147 m->mf_state = SMFS_INMSG;
2148 if (MilterLogLevel > 12)
2149 sm_syslog(LOG_INFO, e->e_id,
2150 "milter=%s, action=%s, continue",
2151 m->mf_name, action);
2155 if (MilterLogLevel > 12)
2156 sm_syslog(LOG_INFO, e->e_id,
2157 "milter=%s, action=%s, skip",
2158 m->mf_name, action);
2159 m->mf_state = SMFS_SKIP;
2163 /* Invalid response to command */
2164 if (MilterLogLevel > 0)
2165 sm_syslog(LOG_ERR, e->e_id,
2166 "milter_send_command(%s): action=%s returned bogus response %c",
2167 m->mf_name, action, rcmd);
2168 milter_error(m, e); /* NO ERROR CHECK? */
2172 if (*state != SMFIR_REPLYCODE && response != NULL)
2174 sm_free(response); /* XXX */
2181 ** MILTER_COMMAND -- send a command and return the response for each filter
2184 ** cmd -- command to send.
2185 ** data -- optional command data.
2186 ** sz -- length of buf.
2187 ** stage -- index of macros to send for filter smfi_getsymval().
2188 ** e -- current envelope (for macro access).
2189 ** state -- return state word.
2190 ** where -- description of calling function (logging).
2191 ** cmd_error -- did the SMTP command cause an error?
2194 ** response string (may be NULL)
2198 milter_command(cmd, data, sz, stage, e, state, where, cmd_error)
2209 char command = (char) cmd;
2210 char *response = NULL;
2214 sm_dprintf("milter_command: cmd %c len %ld\n",
2215 command, (long) sz);
2217 *state = SMFIR_CONTINUE;
2218 for (i = 0; InputFilters[i] != NULL; i++)
2220 struct milter *m = InputFilters[i];
2222 /* previous problem? */
2223 if (m->mf_state == SMFS_ERROR)
2225 MILTER_CHECK_ERROR(false, continue);
2230 if (m->mf_sock < 0 ||
2231 (m->mf_state != SMFS_OPEN && m->mf_state != SMFS_INMSG))
2234 if (stage >= SMFIM_FIRST && stage <= SMFIM_LAST)
2239 if ((m->mf_lflags & MI_LFLAGS_SYM(stage)) != 0)
2243 SM_ASSERT(idx >= 0 && idx <= MAXFILTERS);
2244 macros = MilterMacros[stage][idx];
2246 /* send macros (regardless of whether we send cmd) */
2247 if (macros != NULL && macros[0] != NULL)
2249 milter_send_macros(m, macros, command, e);
2250 if (m->mf_state == SMFS_ERROR)
2252 MILTER_CHECK_ERROR(false, continue);
2258 if (MilterLogLevel > 21)
2262 ** send the command if
2263 ** there is no error
2264 ** or it's RCPT and the client asked for it:
2266 ** where == "rcpt" && m->mf_pflags & SMFIP_RCPT_REJ != 0
2267 ** negate that condition and use continue
2271 (strcmp(where, "rcpt") != 0 ||
2272 (m->mf_pflags & SMFIP_RCPT_REJ) == 0))
2275 response = milter_send_command(m, command, data, sz, e, state,
2278 if (MilterLogLevel > 21)
2280 /* log the time it took for the command per filter */
2281 sm_syslog(LOG_INFO, e->e_id,
2282 "Milter (%s): time command (%c), %d",
2283 m->mf_name, command, (int) (tn - curtime()));
2286 if (*state != SMFIR_CONTINUE)
2292 static int milter_getsymlist __P((struct milter *, char *, int, int));
2295 milter_getsymlist(m, buf, rlen, offset)
2304 SM_ASSERT(m != NULL);
2305 SM_ASSERT(buf != NULL);
2307 while (offset + MILTER_LEN_BYTES < rlen)
2313 (void) memcpy((char *) &v, buf + offset, MILTER_LEN_BYTES);
2315 if (i < SMFIM_FIRST || i > SMFIM_LAST)
2317 offset += MILTER_LEN_BYTES;
2320 #define SM_M_MACRO_NAME(i) (((i) < SM_ARRAY_SIZE(MilterOptTab) && (i) >= 0) \
2321 ? MilterOptTab[i].mo_name : "?")
2331 SM_ASSERT(m->mf_idx > 0 && m->mf_idx < MAXFILTERS);
2332 macros = MilterMacros[i][m->mf_idx];
2333 m->mf_lflags |= MI_LFLAGS_SYM(i);
2334 len = strlen(buf + offset);
2337 r = milter_set_macros(m->mf_name, macros,
2338 buf + offset, nummac);
2342 sm_dprintf("milter_getsymlist(%s, %s, \"%s\")=%d\n",
2359 ** MILTER_NEGOTIATE -- get version and flags from filter
2362 ** m -- milter filter structure.
2363 ** e -- current envelope.
2364 ** milters -- milters structure.
2367 ** 0 on success, -1 otherwise
2371 milter_negotiate(m, e, milters)
2377 mi_int32 fvers, fflags, pflags;
2378 mi_int32 mta_prot_vers, mta_prot_flags, mta_actions;
2381 char data[MILTER_OPTLEN];
2384 if (m->mf_sock < 0 || m->mf_state != SMFS_OPEN)
2386 if (MilterLogLevel > 0)
2387 sm_syslog(LOG_ERR, e->e_id,
2388 "Milter (%s): negotiate, impossible state",
2394 #if _FFR_MILTER_CHECK
2395 mta_prot_vers = m->mf_mta_prot_version;
2396 mta_prot_flags = m->mf_mta_prot_flags;
2397 mta_actions = m->mf_mta_actions;
2398 #else /* _FFR_MILTER_CHECK */
2399 mta_prot_vers = SMFI_PROT_VERSION;
2400 mta_prot_flags = SMFI_CURR_PROT;
2401 mta_actions = SMFI_CURR_ACTS;
2402 #endif /* _FFR_MILTER_CHECK */
2403 #if _FFR_MDS_NEGOTIATE
2404 if (MilterMaxDataSize == MILTER_MDS_256K)
2405 mta_prot_flags |= SMFIP_MDS_256K;
2406 else if (MilterMaxDataSize == MILTER_MDS_1M)
2407 mta_prot_flags |= SMFIP_MDS_1M;
2408 #endif /* _FFR_MDS_NEGOTIATE */
2410 fvers = htonl(mta_prot_vers);
2411 pflags = htonl(mta_prot_flags);
2412 fflags = htonl(mta_actions);
2413 (void) memcpy(data, (char *) &fvers, MILTER_LEN_BYTES);
2414 (void) memcpy(data + MILTER_LEN_BYTES,
2415 (char *) &fflags, MILTER_LEN_BYTES);
2416 (void) memcpy(data + (MILTER_LEN_BYTES * 2),
2417 (char *) &pflags, MILTER_LEN_BYTES);
2418 (void) milter_write(m, SMFIC_OPTNEG, data, sizeof(data),
2419 m->mf_timeout[SMFTO_WRITE], e, "negotiate");
2421 if (m->mf_state == SMFS_ERROR)
2425 sm_dprintf("milter_negotiate(%s): send: version %lu, fflags 0x%lx, pflags 0x%lx\n",
2426 m->mf_name, (unsigned long) ntohl(fvers),
2427 (unsigned long) ntohl(fflags),
2428 (unsigned long) ntohl(pflags));
2430 response = milter_read(m, &rcmd, &rlen, m->mf_timeout[SMFTO_READ], e,
2432 if (m->mf_state == SMFS_ERROR)
2435 if (rcmd != SMFIC_OPTNEG)
2438 sm_dprintf("milter_negotiate(%s): returned %c instead of %c\n",
2439 m->mf_name, rcmd, SMFIC_OPTNEG);
2440 if (MilterLogLevel > 0)
2441 sm_syslog(LOG_ERR, e->e_id,
2442 "Milter (%s): negotiate: returned %c instead of %c",
2443 m->mf_name, rcmd, SMFIC_OPTNEG);
2444 if (response != NULL)
2445 sm_free(response); /* XXX */
2450 /* Make sure we have enough bytes for the version */
2451 if (response == NULL || rlen < MILTER_LEN_BYTES)
2454 sm_dprintf("milter_negotiate(%s): did not return valid info\n",
2456 if (MilterLogLevel > 0)
2457 sm_syslog(LOG_ERR, e->e_id,
2458 "Milter (%s): negotiate: did not return valid info",
2460 if (response != NULL)
2461 sm_free(response); /* XXX */
2466 /* extract information */
2467 (void) memcpy((char *) &fvers, response, MILTER_LEN_BYTES);
2469 /* Now make sure we have enough for the feature bitmap */
2470 if (rlen < MILTER_OPTLEN)
2473 sm_dprintf("milter_negotiate(%s): did not return enough info\n",
2475 if (MilterLogLevel > 0)
2476 sm_syslog(LOG_ERR, e->e_id,
2477 "Milter (%s): negotiate: did not return enough info",
2479 if (response != NULL)
2480 sm_free(response); /* XXX */
2485 (void) memcpy((char *) &fflags, response + MILTER_LEN_BYTES,
2487 (void) memcpy((char *) &pflags, response + (MILTER_LEN_BYTES * 2),
2490 m->mf_fvers = ntohl(fvers);
2491 m->mf_fflags = ntohl(fflags);
2492 m->mf_pflags = ntohl(pflags);
2494 /* check for version compatibility */
2495 if (m->mf_fvers == 1 ||
2496 m->mf_fvers > SMFI_VERSION)
2499 sm_dprintf("milter_negotiate(%s): version %d != MTA milter version %d\n",
2500 m->mf_name, m->mf_fvers, SMFI_VERSION);
2501 if (MilterLogLevel > 0)
2502 sm_syslog(LOG_ERR, e->e_id,
2503 "Milter (%s): negotiate: version %d != MTA milter version %d",
2504 m->mf_name, m->mf_fvers, SMFI_VERSION);
2509 /* check for filter feature mismatch */
2510 if ((m->mf_fflags & mta_actions) != m->mf_fflags)
2513 sm_dprintf("milter_negotiate(%s): filter abilities 0x%x != MTA milter abilities 0x%lx\n",
2514 m->mf_name, m->mf_fflags,
2515 (unsigned long) mta_actions);
2516 if (MilterLogLevel > 0)
2517 sm_syslog(LOG_ERR, e->e_id,
2518 "Milter (%s): negotiate: filter abilities 0x%x != MTA milter abilities 0x%lx",
2519 m->mf_name, m->mf_fflags,
2520 (unsigned long) mta_actions);
2525 #if _FFR_MDS_NEGOTIATE
2526 /* use a table instead of sequence? */
2527 if (bitset(SMFIP_MDS_1M, m->mf_pflags))
2529 if (MilterMaxDataSize != MILTER_MDS_1M)
2531 /* this should not happen... */
2532 sm_syslog(LOG_WARNING, NOQID,
2533 "WARNING: Milter.maxdatasize: configured=%lu, set by libmilter=%d",
2534 (unsigned long) MilterMaxDataSize,
2536 MilterMaxDataSize = MILTER_MDS_1M;
2539 else if (bitset(SMFIP_MDS_256K, m->mf_pflags))
2541 if (MilterMaxDataSize != MILTER_MDS_256K)
2543 sm_syslog(LOG_WARNING, NOQID,
2544 "WARNING: Milter.maxdatasize: configured=%lu, set by libmilter=%d",
2545 (unsigned long) MilterMaxDataSize,
2547 MilterMaxDataSize = MILTER_MDS_256K;
2550 else if (MilterMaxDataSize != MILTER_MDS_64K)
2552 sm_syslog(LOG_WARNING, NOQID,
2553 "WARNING: Milter.maxdatasize: configured=%lu, set by libmilter=%d",
2554 (unsigned long) MilterMaxDataSize,
2556 MilterMaxDataSize = MILTER_MDS_64K;
2558 m->mf_pflags &= ~SMFI_INTERNAL;
2559 #endif /* _FFR_MDS_NEGOTIATE */
2561 /* check for protocol feature mismatch */
2562 if ((m->mf_pflags & mta_prot_flags) != m->mf_pflags)
2565 sm_dprintf("milter_negotiate(%s): protocol abilities 0x%x != MTA milter abilities 0x%lx\n",
2566 m->mf_name, m->mf_pflags,
2567 (unsigned long) mta_prot_flags);
2568 if (MilterLogLevel > 0)
2569 sm_syslog(LOG_ERR, e->e_id,
2570 "Milter (%s): negotiate: protocol abilities 0x%x != MTA milter abilities 0x%lx",
2571 m->mf_name, m->mf_pflags,
2572 (unsigned long) mta_prot_flags);
2577 if (m->mf_fvers <= 2)
2578 m->mf_pflags |= SMFIP_NOUNKNOWN;
2579 if (m->mf_fvers <= 3)
2580 m->mf_pflags |= SMFIP_NODATA;
2582 if (rlen > MILTER_OPTLEN)
2584 milter_getsymlist(m, response, rlen, MILTER_OPTLEN);
2587 if (bitset(SMFIF_DELRCPT, m->mf_fflags))
2588 milters->mis_flags |= MIS_FL_DEL_RCPT;
2589 if (!bitset(SMFIP_NORCPT, m->mf_pflags) &&
2590 !bitset(SMFIP_NR_RCPT, m->mf_pflags))
2591 milters->mis_flags |= MIS_FL_REJ_RCPT;
2594 sm_dprintf("milter_negotiate(%s): received: version %u, fflags 0x%x, pflags 0x%x\n",
2595 m->mf_name, m->mf_fvers, m->mf_fflags, m->mf_pflags);
2599 if (response != NULL)
2600 sm_free(response); /* XXX */
2605 ** MILTER_PER_CONNECTION_CHECK -- checks on per-connection commands
2607 ** Reduce code duplication by putting these checks in one place
2610 ** e -- current envelope.
2617 milter_per_connection_check(e)
2622 /* see if we are done with any of the filters */
2623 for (i = 0; InputFilters[i] != NULL; i++)
2625 struct milter *m = InputFilters[i];
2627 if (m->mf_state == SMFS_CLOSABLE)
2628 milter_quit_filter(m, e);
2633 ** MILTER_ERROR -- Put a milter filter into error state
2636 ** m -- the broken filter.
2637 ** e -- current envelope.
2649 ** We could send a quit here but we may have gotten here due to
2650 ** an I/O error so we don't want to try to make things worse.
2653 if (m->mf_sock >= 0)
2655 (void) close(m->mf_sock);
2658 m->mf_state = SMFS_ERROR;
2660 if (MilterLogLevel > 0)
2661 sm_syslog(LOG_INFO, e->e_id, "Milter (%s): to error state",
2666 ** MILTER_HEADERS -- send headers to a single milter filter
2669 ** m -- current filter.
2670 ** e -- current envelope.
2671 ** state -- return state from response.
2674 ** response string (may be NULL)
2678 milter_headers(m, e, state)
2683 char *response = NULL;
2686 if (MilterLogLevel > 17)
2687 sm_syslog(LOG_INFO, e->e_id, "Milter (%s): headers, send",
2690 for (h = e->e_header; h != NULL; h = h->h_link)
2692 int len_n, len_v, len_t, len_f;
2695 /* don't send over deleted headers */
2696 if (h->h_value == NULL)
2698 /* strip H_USER so not counted in milter_changeheader() */
2699 h->h_flags &= ~H_USER;
2703 /* skip auto-generated */
2704 if (!bitset(H_USER, h->h_flags))
2708 sm_dprintf("milter_headers: %s:%s\n",
2709 h->h_field, h->h_value);
2710 if (MilterLogLevel > 21)
2711 sm_syslog(LOG_INFO, e->e_id, "Milter (%s): header, %s",
2712 m->mf_name, h->h_field);
2714 if (bitset(SMFIP_HDR_LEADSPC, m->mf_pflags)
2715 || *(h->h_value) != ' ')
2718 hv = h->h_value + 1;
2719 len_f = strlen(h->h_field) + 1;
2720 len_t = len_f + strlen(hv) + 1;
2723 buf = (char *) xalloc(len_t);
2726 ** Note: currently the call to dequote_internal_chars()
2727 ** is not required as h_field is supposed to be 7-bit US-ASCII.
2730 len_n = dequote_internal_chars(h->h_field, buf, len_f);
2731 SM_ASSERT(len_n < len_f);
2732 len_v = dequote_internal_chars(hv, buf + len_n + 1,
2734 SM_ASSERT(len_t >= len_n + 1 + len_v + 1);
2735 len_t = len_n + 1 + len_v + 1;
2738 response = milter_send_command(m, SMFIC_HEADER, buf,
2739 len_t, e, state, "header");
2741 if (m->mf_state == SMFS_ERROR ||
2742 m->mf_state == SMFS_DONE ||
2743 *state != SMFIR_CONTINUE)
2746 if (MilterLogLevel > 17)
2747 sm_syslog(LOG_INFO, e->e_id, "Milter (%s): headers, sent",
2753 ** MILTER_BODY -- send the body to a filter
2756 ** m -- current filter.
2757 ** e -- current envelope.
2758 ** state -- return state from response.
2761 ** response string (may be NULL)
2765 milter_body(m, e, state)
2770 char bufchar = '\0';
2771 char prevchar = '\0';
2773 char *response = NULL;
2775 char buf[MILTER_CHUNK_SIZE];
2778 sm_dprintf("milter_body\n");
2780 if (bfrewind(e->e_dfp) < 0)
2782 ExitStat = EX_IOERR;
2783 *state = SMFIR_TEMPFAIL;
2784 syserr("milter_body: %s/%cf%s: rewind error",
2785 qid_printqueue(e->e_qgrp, e->e_qdir),
2786 DATAFL_LETTER, e->e_id);
2790 if (MilterLogLevel > 17)
2791 sm_syslog(LOG_INFO, e->e_id, "Milter (%s): body, send",
2794 while ((c = sm_io_getc(e->e_dfp, SM_TIME_DEFAULT)) != SM_IO_EOF)
2796 /* Change LF to CRLF */
2799 #if !_FFR_MILTER_CONVERT_ALL_LF_TO_CRLF
2800 /* Not a CRLF already? */
2801 if (prevchar != '\r')
2802 #endif /* !_FFR_MILTER_CONVERT_ALL_LF_TO_CRLF */
2804 /* Room for CR now? */
2805 if (bp + 2 > &buf[sizeof(buf)])
2807 /* No room, buffer LF */
2810 /* and send CR now */
2815 /* Room to do it now */
2823 if (bp >= &buf[sizeof(buf)])
2826 response = milter_send_command(m, SMFIC_BODY, buf,
2830 if (bufchar != '\0')
2837 if (m->mf_state == SMFS_ERROR ||
2838 m->mf_state == SMFS_DONE ||
2839 m->mf_state == SMFS_SKIP ||
2840 *state != SMFIR_CONTINUE)
2844 /* check for read errors */
2845 if (sm_io_error(e->e_dfp))
2847 ExitStat = EX_IOERR;
2848 if (*state == SMFIR_CONTINUE ||
2849 *state == SMFIR_ACCEPT ||
2850 m->mf_state == SMFS_SKIP)
2852 *state = SMFIR_TEMPFAIL;
2853 if (response != NULL)
2855 sm_free(response); /* XXX */
2859 syserr("milter_body: %s/%cf%s: read error",
2860 qid_printqueue(e->e_qgrp, e->e_qdir),
2861 DATAFL_LETTER, e->e_id);
2865 /* send last body chunk */
2867 m->mf_state != SMFS_ERROR &&
2868 m->mf_state != SMFS_DONE &&
2869 m->mf_state != SMFS_SKIP &&
2870 *state == SMFIR_CONTINUE)
2873 response = milter_send_command(m, SMFIC_BODY, buf, bp - buf,
2874 e, state, "last body chunk");
2877 if (MilterLogLevel > 17)
2878 sm_syslog(LOG_INFO, e->e_id, "Milter (%s): body, sent",
2880 if (m->mf_state == SMFS_SKIP)
2882 *state = SMFIR_CONTINUE;
2883 m->mf_state = SMFS_READY;
2894 ** ADDLEADINGSPACE -- Add a leading space to a string
2898 ** rp -- resource pool for allocations
2901 ** pointer to new string
2904 static char *addleadingspace __P((char *, SM_RPOOL_T *));
2907 addleadingspace(str, rp)
2914 SM_ASSERT(str != NULL);
2916 SM_ASSERT(l + 2 > l);
2917 new = sm_rpool_malloc_x(rp, l + 2);
2920 sm_strlcpy(new + 1, str, l + 1);
2925 ** MILTER_ADDHEADER -- Add the supplied header to the message
2928 ** m -- current filter.
2929 ** response -- encoded form of header/value.
2930 ** rlen -- length of response.
2931 ** e -- current envelope.
2938 milter_addheader(m, response, rlen, e)
2945 char *val, *mh_value;
2949 sm_dprintf("milter_addheader: ");
2952 if (response == NULL)
2955 sm_dprintf("NULL response\n");
2959 if (rlen < 2 || strlen(response) + 1 >= (size_t) rlen)
2962 sm_dprintf("didn't follow protocol (total len %d != rlen %d)\n",
2963 (int) strlen(response), (int) (rlen - 1));
2967 /* Find separating NUL */
2968 val = response + strlen(response) + 1;
2970 /* another sanity check */
2971 if (strlen(response) + strlen(val) + 2 != (size_t) rlen)
2974 sm_dprintf("didn't follow protocol (part len)\n");
2978 if (*response == '\0')
2981 sm_dprintf("empty field name\n");
2985 for (h = e->e_header; h != NULL; h = h->h_link)
2987 if (sm_strcasecmp(h->h_field, response) == 0 &&
2988 !bitset(H_USER, h->h_flags) &&
2989 !bitset(H_TRACE, h->h_flags))
2994 mh_value = quote_internal_chars(val, NULL, &mh_v_len);
2996 /* add to e_msgsize */
2997 e->e_msgsize += strlen(response) + 2 + strlen(val);
3002 sm_dprintf("Replace default header %s value with %s\n",
3003 h->h_field, mh_value);
3004 if (MilterLogLevel > 8)
3005 sm_syslog(LOG_INFO, e->e_id,
3006 "Milter change: default header %s value with %s",
3007 h->h_field, mh_value);
3008 if (bitset(SMFIP_HDR_LEADSPC, m->mf_pflags))
3009 h->h_value = mh_value;
3012 h->h_value = addleadingspace(mh_value, e->e_rpool);
3015 h->h_flags |= H_USER;
3020 sm_dprintf("Add %s: %s\n", response, mh_value);
3021 if (MilterLogLevel > 8)
3022 sm_syslog(LOG_INFO, e->e_id,
3023 "Milter add: header: %s: %s",
3024 response, mh_value);
3025 addheader(newstr(response), mh_value, H_USER, e,
3026 !bitset(SMFIP_HDR_LEADSPC, m->mf_pflags));
3032 ** MILTER_INSHEADER -- Insert the supplied header
3035 ** m -- current filter.
3036 ** response -- encoded form of header/value.
3037 ** rlen -- length of response.
3038 ** e -- current envelope.
3044 ** Unlike milter_addheader(), this does not attempt to determine
3045 ** if the header already exists in the envelope, even a
3046 ** deleted version. It just blindly inserts.
3050 milter_insheader(m, response, rlen, e)
3058 char *field, *val, *mh_value;
3061 sm_dprintf("milter_insheader: ");
3064 if (response == NULL)
3067 sm_dprintf("NULL response\n");
3071 if (rlen < 2 || strlen(response) + 1 >= (size_t) rlen)
3074 sm_dprintf("didn't follow protocol (total len)\n");
3079 (void) memcpy((char *) &i, response, MILTER_LEN_BYTES);
3081 field = response + MILTER_LEN_BYTES;
3082 val = field + strlen(field) + 1;
3084 /* another sanity check */
3085 if (MILTER_LEN_BYTES + strlen(field) + 1 +
3086 strlen(val) + 1 != (size_t) rlen)
3089 sm_dprintf("didn't follow protocol (part len)\n");
3096 sm_dprintf("empty field name\n");
3100 /* add to e_msgsize */
3101 e->e_msgsize += strlen(response) + 2 + strlen(val);
3104 sm_dprintf("Insert (%d) %s: %s\n", idx, field, val);
3105 if (MilterLogLevel > 8)
3106 sm_syslog(LOG_INFO, e->e_id,
3107 "Milter insert (%d): header: %s: %s",
3110 mh_value = quote_internal_chars(val, NULL, &mh_v_len);
3111 insheader(idx, newstr(field), mh_value, H_USER, e,
3112 !bitset(SMFIP_HDR_LEADSPC, m->mf_pflags));
3117 ** MILTER_CHANGEHEADER -- Change the supplied header in the message
3120 ** m -- current filter.
3121 ** response -- encoded form of header/index/value.
3122 ** rlen -- length of response.
3123 ** e -- current envelope.
3130 milter_changeheader(m, response, rlen, e)
3138 char *field, *val, *mh_value;
3142 sm_dprintf("milter_changeheader: ");
3145 if (response == NULL)
3148 sm_dprintf("NULL response\n");
3152 if (rlen < 2 || strlen(response) + 1 >= (size_t) rlen)
3155 sm_dprintf("didn't follow protocol (total len)\n");
3159 /* Find separating NUL */
3160 (void) memcpy((char *) &i, response, MILTER_LEN_BYTES);
3162 field = response + MILTER_LEN_BYTES;
3163 val = field + strlen(field) + 1;
3165 /* another sanity check */
3166 if (MILTER_LEN_BYTES + strlen(field) + 1 +
3167 strlen(val) + 1 != (size_t) rlen)
3170 sm_dprintf("didn't follow protocol (part len)\n");
3177 sm_dprintf("empty field name\n");
3182 mh_value = quote_internal_chars(val, NULL, &mh_v_len);
3185 for (h = e->e_header; h != NULL; h = h->h_link)
3187 if (sm_strcasecmp(h->h_field, field) == 0)
3189 if (bitset(H_USER, h->h_flags) && --index <= 0)
3194 else if (!bitset(H_USER, h->h_flags) &&
3195 !bitset(H_TRACE, h->h_flags))
3198 ** DRUMS msg-fmt draft says can only have
3199 ** multiple occurences of trace fields,
3200 ** so make sure we replace any non-trace,
3209 /* if not found as user-provided header at index, use sysheader */
3218 sm_dprintf("Delete (noop) %s\n", field);
3219 if (MilterLogLevel > 8)
3220 sm_syslog(LOG_INFO, e->e_id,
3221 "Milter delete (noop): header: %s"
3226 /* treat modify value with no existing header as add */
3228 sm_dprintf("Add %s: %s\n", field, mh_value);
3229 if (MilterLogLevel > 8)
3230 sm_syslog(LOG_INFO, e->e_id,
3231 "Milter change (add): header: %s: %s"
3233 addheader(newstr(field), mh_value, H_USER, e,
3234 !bitset(SMFIP_HDR_LEADSPC, m->mf_pflags));
3243 sm_dprintf("Delete%s %s:%s\n",
3244 h == sysheader ? " (default header)" : "",
3246 h->h_value == NULL ? "<NULL>" : h->h_value);
3250 sm_dprintf("Change%s %s: from %s to %s\n",
3251 h == sysheader ? " (default header)" : "",
3253 h->h_value == NULL ? "<NULL>" : h->h_value,
3258 if (MilterLogLevel > 8)
3262 sm_syslog(LOG_INFO, e->e_id,
3263 "Milter delete: header%s %s:%s",
3264 h == sysheader ? " (default header)" : "",
3266 h->h_value == NULL ? "<NULL>" : h->h_value);
3270 sm_syslog(LOG_INFO, e->e_id,
3271 "Milter change: header%s %s: from %s to %s",
3272 h == sysheader ? " (default header)" : "",
3274 h->h_value == NULL ? "<NULL>" : h->h_value,
3279 if (h != sysheader && h->h_value != NULL)
3283 l = strlen(h->h_value);
3284 if (l > e->e_msgsize)
3288 /* rpool, don't free: sm_free(h->h_value); XXX */
3293 /* Remove "Field: " from message size */
3298 l = strlen(h->h_field) + 2;
3299 if (l > e->e_msgsize)
3309 if (bitset(SMFIP_HDR_LEADSPC, m->mf_pflags))
3310 h->h_value = mh_value;
3313 h->h_value = addleadingspace(mh_value, e->e_rpool);
3316 h->h_flags |= H_USER;
3317 e->e_msgsize += strlen(h->h_value);
3322 ** MILTER_SPLIT_RESPONSE -- Split response into fields.
3325 ** response -- encoded repsonse.
3326 ** rlen -- length of response.
3327 ** pargc -- number of arguments (ouput)
3330 ** array of pointers to the individual strings
3333 static char **milter_split_response __P((char *, ssize_t, int *));
3336 milter_split_response(response, rlen, pargc)
3345 SM_ASSERT(response != NULL);
3346 SM_ASSERT(pargc != NULL);
3348 if (rlen < 2 || strlen(response) >= (size_t) rlen)
3351 sm_dprintf("didn't follow protocol (total len %d != rlen %d)\n",
3352 (int) strlen(response), (int) (rlen - 1));
3357 for (i = 0; i < rlen; i++)
3359 if (response[i] == '\0')
3365 /* last entry is only for the name */
3366 s = (char **)malloc((nelem + 1) * (sizeof(*s)));
3370 for (i = 0, elem = 0; i < rlen && elem < nelem; i++)
3372 if (response[i] == '\0')
3378 s[elem] = &(response[i + 1]);
3385 for (elem = 0; elem < nelem; elem++)
3386 sm_dprintf("argv[%d]=\"%s\"\n", elem, s[elem]);
3389 /* overwrite last entry (already done above, just paranoia) */
3395 ** MILTER_CHGFROM -- Change the envelope sender address
3398 ** response -- encoded form of recipient address.
3399 ** rlen -- length of response.
3400 ** e -- current envelope.
3407 milter_chgfrom(response, rlen, e)
3412 int olderrors, argc;
3416 sm_dprintf("milter_chgfrom: ");
3419 if (response == NULL)
3422 sm_dprintf("NULL response\n");
3426 if (*response == '\0' ||
3427 strlen(response) + 1 > (size_t) rlen)
3430 sm_dprintf("didn't follow protocol (total len %d != rlen %d)\n",
3431 (int) strlen(response), (int) (rlen - 1));
3436 sm_dprintf("%s\n", response);
3437 if (MilterLogLevel > 8)
3438 sm_syslog(LOG_INFO, e->e_id, "Milter chgfrom: %s", response);
3439 argv = milter_split_response(response, rlen, &argc);
3440 if (argc < 1 || argc > 2)
3443 sm_dprintf("didn't follow protocol argc=%d\n", argc);
3448 setsender(argv[0], e, NULL, '\0', false);
3451 reset_mail_esmtp_args(e);
3454 ** need "features" here: how to get those? via e?
3455 ** "fake" it for now: allow everything.
3458 parse_esmtp_args(e, NULL, argv[0], argv[1], "MAIL", NULL,
3466 ** MILTER_ADDRCPT_PAR -- Add the supplied recipient to the message
3469 ** response -- encoded form of recipient address.
3470 ** rlen -- length of response.
3471 ** e -- current envelope.
3478 milter_addrcpt_par(response, rlen, e)
3483 int olderrors, argc;
3489 sm_dprintf("milter_addrcpt_par: ");
3492 if (response == NULL)
3495 sm_dprintf("NULL response\n");
3500 sm_dprintf("%s\n", response);
3501 if (MilterLogLevel > 8)
3502 sm_syslog(LOG_INFO, e->e_id, "Milter add: rcpt: %s", response);
3504 argv = milter_split_response(response, rlen, &argc);
3505 if (argc < 1 || argc > 2)
3508 sm_dprintf("didn't follow protocol argc=%d\n", argc);
3513 /* how to set ESMTP arguments? */
3514 a = parseaddr(argv[0], NULLADDR, RF_COPYALL, ' ', &delimptr, e, true);
3516 if (a != NULL && olderrors == Errors)
3518 parse_esmtp_args(e, a, argv[0], argv[1], "RCPT", NULL,
3520 if (olderrors == Errors)
3521 a = recipient(a, &e->e_sendqueue, 0, e);
3523 sm_dprintf("olderrors=%d, Errors=%d\n",
3528 sm_dprintf("a=%p, olderrors=%d, Errors=%d\n",
3529 a, olderrors, Errors);
3537 ** MILTER_ADDRCPT -- Add the supplied recipient to the message
3540 ** response -- encoded form of recipient address.
3541 ** rlen -- length of response.
3542 ** e -- current envelope.
3549 milter_addrcpt(response, rlen, e)
3557 sm_dprintf("milter_addrcpt: ");
3560 if (response == NULL)
3563 sm_dprintf("NULL response\n");
3567 if (*response == '\0' ||
3568 strlen(response) + 1 != (size_t) rlen)
3571 sm_dprintf("didn't follow protocol (total len %d != rlen %d)\n",
3572 (int) strlen(response), (int) (rlen - 1));
3577 sm_dprintf("%s\n", response);
3578 if (MilterLogLevel > 8)
3579 sm_syslog(LOG_INFO, e->e_id, "Milter add: rcpt: %s", response);
3581 (void) sendtolist(response, NULLADDR, &e->e_sendqueue, 0, e);
3587 ** MILTER_DELRCPT -- Delete the supplied recipient from the message
3590 ** response -- encoded form of recipient address.
3591 ** rlen -- length of response.
3592 ** e -- current envelope.
3599 milter_delrcpt(response, rlen, e)
3605 sm_dprintf("milter_delrcpt: ");
3608 if (response == NULL)
3611 sm_dprintf("NULL response\n");
3615 if (*response == '\0' ||
3616 strlen(response) + 1 != (size_t) rlen)
3619 sm_dprintf("didn't follow protocol (total len %d != rlen %d)\n",
3620 (int) strlen(response), (int) (rlen - 1));
3625 sm_dprintf("%s\n", response);
3626 if (MilterLogLevel > 8)
3627 sm_syslog(LOG_INFO, e->e_id, "Milter delete: rcpt %s",
3629 (void) removefromlist(response, &e->e_sendqueue, e);
3634 ** MILTER_REPLBODY -- Replace the current data file with new body
3637 ** response -- encoded form of new body.
3638 ** rlen -- length of response.
3639 ** newfilter -- if first time called by a new filter
3640 ** e -- current envelope.
3643 ** 0 upon success, -1 upon failure
3647 milter_replbody(response, rlen, newfilter, e)
3653 static char prevchar;
3657 sm_dprintf("milter_replbody\n");
3659 /* If a new filter, reset previous character and truncate data file */
3663 char dfname[MAXPATHLEN];
3665 (void) sm_strlcpy(dfname, queuename(e, DATAFL_LETTER),
3668 /* Reset prevchar */
3671 /* Get the current data file information */
3672 prevsize = sm_io_getinfo(e->e_dfp, SM_IO_WHAT_SIZE, NULL);
3676 /* truncate current data file */
3677 if (sm_io_getinfo(e->e_dfp, SM_IO_WHAT_ISTYPE, BF_FILE_TYPE))
3679 if (sm_io_setinfo(e->e_dfp, SM_BF_TRUNCATE, NULL) < 0)
3681 MILTER_DF_ERROR("milter_replbody: sm_io truncate %s: %s");
3689 err = sm_io_error(e->e_dfp);
3690 (void) sm_io_flush(e->e_dfp, SM_TIME_DEFAULT);
3693 ** Clear error if tried to fflush()
3694 ** a read-only file pointer and
3695 ** there wasn't a previous error.
3699 sm_io_clearerr(e->e_dfp);
3701 /* errno is set implicitly by fseek() before return */
3702 err = sm_io_seek(e->e_dfp, SM_TIME_DEFAULT,
3706 MILTER_DF_ERROR("milter_replbody: sm_io_seek %s: %s");
3710 /* XXX: Not much we can do except rewind it */
3712 MILTER_DF_ERROR("milter_replbody: ftruncate not available on this platform (%s:%s)");
3714 # else /* NOFTRUNCATE */
3715 err = ftruncate(sm_io_getinfo(e->e_dfp,
3716 SM_IO_WHAT_FD, NULL),
3720 MILTER_DF_ERROR("milter_replbody: sm_io ftruncate %s: %s");
3723 # endif /* NOFTRUNCATE */
3726 if (prevsize > e->e_msgsize)
3729 e->e_msgsize -= prevsize;
3732 if (newfilter && MilterLogLevel > 8)
3733 sm_syslog(LOG_INFO, e->e_id, "Milter message: body replaced");
3735 if (response == NULL)
3737 /* Flush the buffered '\r' */
3738 if (prevchar == '\r')
3740 (void) sm_io_putc(e->e_dfp, SM_TIME_DEFAULT, prevchar);
3746 for (i = 0; i < rlen; i++)
3748 /* Buffered char from last chunk */
3749 if (i == 0 && prevchar == '\r')
3751 /* Not CRLF, output prevchar */
3752 if (response[i] != '\n')
3754 (void) sm_io_putc(e->e_dfp, SM_TIME_DEFAULT,
3761 /* Turn CRLF into LF */
3762 if (response[i] == '\r')
3764 /* check if at end of chunk */
3767 /* If LF, strip CR */
3768 if (response[i + 1] == '\n')
3773 /* check next chunk */
3778 (void) sm_io_putc(e->e_dfp, SM_TIME_DEFAULT, response[i]);
3789 ** MILTER_INIT -- open and negotiate with all of the filters
3792 ** e -- current envelope.
3793 ** state -- return state from response.
3794 ** milters -- milters structure.
3797 ** true iff at least one filter is active
3802 milter_init(e, state, milters)
3810 sm_dprintf("milter_init\n");
3812 memset(milters, '\0', sizeof(*milters));
3813 *state = SMFIR_CONTINUE;
3814 if (InputFilters[0] == NULL)
3816 if (MilterLogLevel > 10)
3817 sm_syslog(LOG_INFO, e->e_id,
3818 "Milter: no active filter");
3822 for (i = 0; InputFilters[i] != NULL; i++)
3824 struct milter *m = InputFilters[i];
3826 m->mf_sock = milter_open(m, false, e);
3827 if (m->mf_state == SMFS_ERROR)
3829 MILTER_CHECK_ERROR(true, continue);
3833 if (m->mf_sock < 0 ||
3834 milter_negotiate(m, e, milters) < 0 ||
3835 m->mf_state == SMFS_ERROR)
3838 sm_dprintf("milter_init(%s): failed to %s\n",
3840 m->mf_sock < 0 ? "open" :
3842 if (MilterLogLevel > 0)
3843 sm_syslog(LOG_ERR, e->e_id,
3844 "Milter (%s): init failed to %s",
3846 m->mf_sock < 0 ? "open" :
3849 /* if negotiation failure, close socket */
3851 MILTER_CHECK_ERROR(true, continue);
3854 if (MilterLogLevel > 9)
3855 sm_syslog(LOG_INFO, e->e_id,
3856 "Milter (%s): init success to %s",
3858 m->mf_sock < 0 ? "open" : "negotiate");
3862 ** If something temp/perm failed with one of the filters,
3863 ** we won't be using any of them, so clear any existing
3867 if (*state != SMFIR_CONTINUE)
3874 ** MILTER_CONNECT -- send connection info to milter filters
3877 ** hostname -- hostname of remote machine.
3878 ** addr -- address of remote machine.
3879 ** e -- current envelope.
3880 ** state -- return state from response.
3883 ** response string (may be NULL)
3887 milter_connect(hostname, addr, e, state)
3894 unsigned short port;
3897 char *sockinfo = NULL;
3900 char buf6[INET6_ADDRSTRLEN];
3901 # endif /* NETINET6 */
3904 sm_dprintf("milter_connect(%s)\n", hostname);
3905 if (MilterLogLevel > 9)
3906 sm_syslog(LOG_INFO, e->e_id, "Milter: connect to filters");
3909 switch (addr.sa.sa_family)
3913 family = SMFIA_UNIX;
3915 sockinfo = addr.sunix.sun_path;
3917 # endif /* NETUNIX */
3921 family = SMFIA_INET;
3922 port = addr.sin.sin_port;
3923 sockinfo = (char *) inet_ntoa(addr.sin.sin_addr);
3925 # endif /* NETINET */
3929 if (IN6_IS_ADDR_V4MAPPED(&addr.sin6.sin6_addr))
3930 family = SMFIA_INET;
3932 family = SMFIA_INET6;
3933 port = addr.sin6.sin6_port;
3934 sockinfo = anynet_ntop(&addr.sin6.sin6_addr, buf6,
3936 if (sockinfo == NULL)
3939 # endif /* NETINET6 */
3942 family = SMFIA_UNKNOWN;
3946 s = strlen(hostname) + 1 + sizeof(family);
3947 if (family != SMFIA_UNKNOWN)
3948 s += sizeof(port) + strlen(sockinfo) + 1;
3950 buf = (char *) xalloc(s);
3953 /* put together data */
3954 (void) memcpy(bp, hostname, strlen(hostname));
3955 bp += strlen(hostname);
3957 (void) memcpy(bp, &family, sizeof(family));
3958 bp += sizeof(family);
3959 if (family != SMFIA_UNKNOWN)
3961 (void) memcpy(bp, &port, sizeof(port));
3964 /* include trailing '\0' */
3965 (void) memcpy(bp, sockinfo, strlen(sockinfo) + 1);
3968 response = milter_command(SMFIC_CONNECT, buf, s, SMFIM_CONNECT,
3969 e, state, "connect", false);
3970 sm_free(buf); /* XXX */
3973 ** If this message connection is done for,
3974 ** close the filters.
3977 if (*state != SMFIR_CONTINUE)
3979 if (MilterLogLevel > 9)
3980 sm_syslog(LOG_INFO, e->e_id, "Milter: connect, ending");
3984 milter_per_connection_check(e);
3986 #if !_FFR_MILTER_CONNECT_REPLYCODE
3988 ** SMFIR_REPLYCODE can't work with connect due to
3989 ** the requirements of SMTP. Therefore, ignore the
3990 ** reply code text but keep the state it would reflect.
3993 if (*state == SMFIR_REPLYCODE)
3995 if (response != NULL &&
3998 if (strncmp(response, "421 ", 4) == 0)
3999 *state = SMFIR_SHUTDOWN;
4001 *state = SMFIR_TEMPFAIL;
4004 *state = SMFIR_REJECT;
4005 if (response != NULL)
4007 sm_free(response); /* XXX */
4011 #endif /* !_FFR_MILTER_CONNECT_REPLYCODE */
4016 ** MILTER_HELO -- send SMTP HELO/EHLO command info to milter filters
4019 ** helo -- argument to SMTP HELO/EHLO command.
4020 ** e -- current envelope.
4021 ** state -- return state from response.
4024 ** response string (may be NULL)
4028 milter_helo(helo, e, state)
4037 sm_dprintf("milter_helo(%s)\n", helo);
4039 /* HELO/EHLO can come at any point */
4040 for (i = 0; InputFilters[i] != NULL; i++)
4042 struct milter *m = InputFilters[i];
4044 switch (m->mf_state)
4047 /* abort in message filters */
4048 milter_abort_filter(m, e);
4052 /* reset done filters */
4053 m->mf_state = SMFS_OPEN;
4058 response = milter_command(SMFIC_HELO, helo, strlen(helo) + 1,
4059 SMFIM_HELO, e, state, "helo", false);
4060 milter_per_connection_check(e);
4065 ** MILTER_ENVFROM -- send SMTP MAIL command info to milter filters
4068 ** args -- SMTP MAIL command args (args[0] == sender).
4069 ** e -- current envelope.
4070 ** state -- return state from response.
4073 ** response string (may be NULL)
4077 milter_envfrom(args, e, state)
4089 sm_dprintf("milter_envfrom:");
4090 for (i = 0; args[i] != NULL; i++)
4091 sm_dprintf(" %s", args[i]);
4096 if (args[0] == NULL)
4098 *state = SMFIR_REJECT;
4099 if (MilterLogLevel > 10)
4100 sm_syslog(LOG_INFO, e->e_id,
4101 "Milter: reject, no sender");
4105 /* new message, so ... */
4106 for (i = 0; InputFilters[i] != NULL; i++)
4108 struct milter *m = InputFilters[i];
4110 switch (m->mf_state)
4113 /* abort in message filters */
4114 milter_abort_filter(m, e);
4118 /* reset done filters */
4119 m->mf_state = SMFS_OPEN;
4124 /* put together data */
4126 for (i = 0; args[i] != NULL; i++)
4127 s += strlen(args[i]) + 1;
4131 *state = SMFIR_TEMPFAIL;
4135 buf = (char *) xalloc(s);
4137 for (i = 0; args[i] != NULL; i++)
4139 (void) sm_strlcpy(bp, args[i], s - (bp - buf));
4140 bp += strlen(bp) + 1;
4143 if (MilterLogLevel > 14)
4144 sm_syslog(LOG_INFO, e->e_id, "Milter: sender: %s", buf);
4147 response = milter_command(SMFIC_MAIL, buf, s, SMFIM_ENVFROM,
4148 e, state, "mail", false);
4149 sm_free(buf); /* XXX */
4152 ** If filter rejects/discards a per message command,
4153 ** abort the other filters since we are done with the
4157 MILTER_CHECK_DONE_MSG();
4158 if (MilterLogLevel > 10 && *state == SMFIR_REJECT)
4159 sm_syslog(LOG_INFO, e->e_id, "Milter: reject, sender");
4164 ** MILTER_ENVRCPT -- send SMTP RCPT command info to milter filters
4167 ** args -- SMTP MAIL command args (args[0] == recipient).
4168 ** e -- current envelope.
4169 ** state -- return state from response.
4170 ** rcpt_error -- does RCPT have an error?
4173 ** response string (may be NULL)
4177 milter_envrcpt(args, e, state, rcpt_error)
4190 sm_dprintf("milter_envrcpt:");
4191 for (i = 0; args[i] != NULL; i++)
4192 sm_dprintf(" %s", args[i]);
4197 if (args[0] == NULL)
4199 *state = SMFIR_REJECT;
4200 if (MilterLogLevel > 10)
4201 sm_syslog(LOG_INFO, e->e_id, "Milter: reject, no rcpt");
4205 /* put together data */
4207 for (i = 0; args[i] != NULL; i++)
4208 s += strlen(args[i]) + 1;
4212 *state = SMFIR_TEMPFAIL;
4216 buf = (char *) xalloc(s);
4218 for (i = 0; args[i] != NULL; i++)
4220 (void) sm_strlcpy(bp, args[i], s - (bp - buf));
4221 bp += strlen(bp) + 1;
4224 if (MilterLogLevel > 14)
4225 sm_syslog(LOG_INFO, e->e_id, "Milter: rcpts: %s", buf);
4228 response = milter_command(SMFIC_RCPT, buf, s, SMFIM_ENVRCPT,
4229 e, state, "rcpt", rcpt_error);
4230 sm_free(buf); /* XXX */
4235 ** MILTER_DATA_CMD -- send SMTP DATA command info to milter filters
4238 ** e -- current envelope.
4239 ** state -- return state from response.
4242 ** response string (may be NULL)
4246 milter_data_cmd(e, state)
4251 sm_dprintf("milter_data_cmd\n");
4254 return milter_command(SMFIC_DATA, NULL, 0, SMFIM_DATA,
4255 e, state, "data", false);
4259 ** MILTER_DATA -- send message headers/body and gather final message results
4262 ** e -- current envelope.
4263 ** state -- return state from response.
4266 ** response string (may be NULL)
4269 ** - Uses e->e_dfp for access to the body
4270 ** - Can call the various milter action routines to
4271 ** modify the envelope or message.
4274 /* flow through code using continue; don't wrap in do {} while */
4275 # define MILTER_CHECK_RESULTS() \
4276 if (m->mf_state == SMFS_ERROR && *state == SMFIR_CONTINUE) \
4280 if (*state == SMFIR_ACCEPT || \
4281 m->mf_state == SMFS_DONE || \
4282 m->mf_state == SMFS_ERROR) \
4284 if (m->mf_state != SMFS_ERROR) \
4285 m->mf_state = SMFS_DONE; \
4286 continue; /* to next filter */ \
4288 if (*state != SMFIR_CONTINUE) \
4290 m->mf_state = SMFS_DONE; \
4295 milter_data(e, state)
4299 bool replbody = false; /* milter_replbody() called? */
4300 bool replfailed = false; /* milter_replbody() failed? */
4301 bool rewind = false; /* rewind data file? */
4302 bool dfopen = false; /* data file open for writing? */
4303 bool newfilter; /* reset on each new filter */
4307 char *response = NULL;
4312 sm_dprintf("milter_data\n");
4314 *state = SMFIR_CONTINUE;
4317 ** XXX: Should actually send body chunks to each filter
4318 ** a chunk at a time instead of sending the whole body to
4319 ** each filter in turn. However, only if the filters don't
4323 for (i = 0; InputFilters[i] != NULL; i++)
4327 struct milter *m = InputFilters[i];
4329 if (*state != SMFIR_CONTINUE &&
4330 *state != SMFIR_ACCEPT)
4333 ** A previous filter has dealt with the message,
4334 ** safe to stop processing the filters.
4340 /* Now reset state for later evaluation */
4341 *state = SMFIR_CONTINUE;
4344 /* previous problem? */
4345 if (m->mf_state == SMFS_ERROR)
4347 MILTER_CHECK_ERROR(false, continue);
4352 if (m->mf_sock < 0 ||
4353 (m->mf_state != SMFS_OPEN && m->mf_state != SMFS_INMSG))
4356 m->mf_state = SMFS_INMSG;
4358 /* check if filter wants the headers */
4359 if (!bitset(SMFIP_NOHDRS, m->mf_pflags))
4361 response = milter_headers(m, e, state);
4362 MILTER_CHECK_RESULTS();
4365 /* check if filter wants EOH */
4366 if (!bitset(SMFIP_NOEOH, m->mf_pflags))
4369 sm_dprintf("milter_data: eoh\n");
4371 if ((m->mf_lflags & MI_LFLAGS_SYM(SMFIM_EOH)) != 0)
4375 SM_ASSERT(idx >= 0 && idx <= MAXFILTERS);
4376 macros = MilterMacros[SMFIM_EOH][idx];
4380 milter_send_macros(m, macros, SMFIC_EOH, e);
4381 MILTER_CHECK_RESULTS();
4385 response = milter_send_command(m, SMFIC_EOH, NULL, 0,
4387 MILTER_CHECK_RESULTS();
4390 /* check if filter wants the body */
4391 if (!bitset(SMFIP_NOBODY, m->mf_pflags) &&
4395 response = milter_body(m, e, state);
4396 MILTER_CHECK_RESULTS();
4399 if ((m->mf_lflags & MI_LFLAGS_SYM(SMFIM_EOH)) != 0)
4403 SM_ASSERT(idx >= 0 && idx <= MAXFILTERS);
4404 macros = MilterMacros[SMFIM_EOM][idx];
4407 milter_send_macros(m, macros, SMFIC_BODYEOB, e);
4408 MILTER_CHECK_RESULTS();
4411 /* send the final body chunk */
4412 (void) milter_write(m, SMFIC_BODYEOB, NULL, 0,
4413 m->mf_timeout[SMFTO_WRITE], e, "eom");
4415 /* Get time EOM sent for timeout */
4416 eomsent = curtime();
4418 /* deal with the possibility of multiple responses */
4419 while (*state == SMFIR_CONTINUE)
4421 /* Check total timeout from EOM to final ACK/NAK */
4422 if (m->mf_timeout[SMFTO_EOM] > 0 &&
4423 curtime() - eomsent >= m->mf_timeout[SMFTO_EOM])
4426 sm_dprintf("milter_data(%s): EOM ACK/NAK timeout\n",
4428 if (MilterLogLevel > 0)
4429 sm_syslog(LOG_ERR, e->e_id,
4430 "milter_data(%s): EOM ACK/NAK timeout",
4433 MILTER_CHECK_ERROR(false, break);
4437 response = milter_read(m, &rcmd, &rlen,
4438 m->mf_timeout[SMFTO_READ], e,
4440 if (m->mf_state == SMFS_ERROR)
4444 sm_dprintf("milter_data(%s): state %c\n",
4445 m->mf_name, (char) rcmd);
4449 case SMFIR_REPLYCODE:
4450 MILTER_CHECK_REPLYCODE("554 5.7.1 Command rejected");
4451 if (MilterLogLevel > 12)
4452 sm_syslog(LOG_INFO, e->e_id, "milter=%s, reject=%s",
4453 m->mf_name, response);
4455 m->mf_state = SMFS_DONE;
4458 case SMFIR_REJECT: /* log msg at end of function */
4459 if (MilterLogLevel > 12)
4460 sm_syslog(LOG_INFO, e->e_id, "milter=%s, reject",
4463 m->mf_state = SMFS_DONE;
4467 if (MilterLogLevel > 12)
4468 sm_syslog(LOG_INFO, e->e_id, "milter=%s, discard",
4471 m->mf_state = SMFS_DONE;
4474 case SMFIR_TEMPFAIL:
4475 if (MilterLogLevel > 12)
4476 sm_syslog(LOG_INFO, e->e_id, "milter=%s, tempfail",
4479 m->mf_state = SMFS_DONE;
4482 case SMFIR_CONTINUE:
4484 /* this filter is done with message */
4486 *state = SMFIR_TEMPFAIL;
4488 *state = SMFIR_ACCEPT;
4489 m->mf_state = SMFS_DONE;
4492 case SMFIR_PROGRESS:
4495 case SMFIR_QUARANTINE:
4496 if (!bitset(SMFIF_QUARANTINE, m->mf_fflags))
4498 if (MilterLogLevel > 9)
4499 sm_syslog(LOG_WARNING, e->e_id,
4500 "milter_data(%s): lied about quarantining, honoring request anyway",
4503 if (response == NULL)
4504 response = newstr("");
4505 if (MilterLogLevel > 3)
4506 sm_syslog(LOG_INFO, e->e_id,
4507 "milter=%s, quarantine=%s",
4508 m->mf_name, response);
4509 e->e_quarmsg = sm_rpool_strdup_x(e->e_rpool,
4511 macdefine(&e->e_macro, A_PERM,
4512 macid("{quarantine}"), e->e_quarmsg);
4515 case SMFIR_ADDHEADER:
4516 if (!bitset(SMFIF_ADDHDRS, m->mf_fflags))
4518 if (MilterLogLevel > 9)
4519 sm_syslog(LOG_WARNING, e->e_id,
4520 "milter_data(%s): lied about adding headers, honoring request anyway",
4523 milter_addheader(m, response, rlen, e);
4526 case SMFIR_INSHEADER:
4527 if (!bitset(SMFIF_ADDHDRS, m->mf_fflags))
4529 if (MilterLogLevel > 9)
4530 sm_syslog(LOG_WARNING, e->e_id,
4531 "milter_data(%s): lied about adding headers, honoring request anyway",
4534 milter_insheader(m, response, rlen, e);
4537 case SMFIR_CHGHEADER:
4538 if (!bitset(SMFIF_CHGHDRS, m->mf_fflags))
4540 if (MilterLogLevel > 9)
4541 sm_syslog(LOG_WARNING, e->e_id,
4542 "milter_data(%s): lied about changing headers, honoring request anyway",
4545 milter_changeheader(m, response, rlen, e);
4549 if (!bitset(SMFIF_CHGFROM, m->mf_fflags))
4551 if (MilterLogLevel > 9)
4552 sm_syslog(LOG_WARNING, e->e_id,
4553 "milter_data(%s) lied about changing sender, honoring request anyway",
4556 milter_chgfrom(response, rlen, e);
4560 if (!bitset(SMFIF_ADDRCPT, m->mf_fflags))
4562 if (MilterLogLevel > 9)
4563 sm_syslog(LOG_WARNING, e->e_id,
4564 "milter_data(%s) lied about adding recipients, honoring request anyway",
4567 milter_addrcpt(response, rlen, e);
4570 case SMFIR_ADDRCPT_PAR:
4571 if (!bitset(SMFIF_ADDRCPT_PAR, m->mf_fflags))
4573 if (MilterLogLevel > 9)
4574 sm_syslog(LOG_WARNING, e->e_id,
4575 "milter_data(%s) lied about adding recipients with parameters, honoring request anyway",
4578 milter_addrcpt_par(response, rlen, e);
4582 if (!bitset(SMFIF_DELRCPT, m->mf_fflags))
4584 if (MilterLogLevel > 9)
4585 sm_syslog(LOG_WARNING, e->e_id,
4586 "milter_data(%s): lied about removing recipients, honoring request anyway",
4589 milter_delrcpt(response, rlen, e);
4592 case SMFIR_REPLBODY:
4593 if (!bitset(SMFIF_MODBODY, m->mf_fflags))
4595 if (MilterLogLevel > 0)
4596 sm_syslog(LOG_ERR, e->e_id,
4597 "milter_data(%s): lied about replacing body, rejecting request and tempfailing message",
4603 /* already failed in attempt */
4609 if (milter_reopen_df(e) < 0)
4618 if (milter_replbody(response, rlen,
4626 /* Invalid response to command */
4627 if (MilterLogLevel > 0)
4628 sm_syslog(LOG_ERR, e->e_id,
4629 "milter_data(%s): returned bogus response %c",
4634 if (rcmd != SMFIR_REPLYCODE && response != NULL)
4636 sm_free(response); /* XXX */
4640 if (m->mf_state == SMFS_ERROR)
4644 if (replbody && !replfailed)
4646 /* flush possible buffered character */
4647 milter_replbody(NULL, 0, !replbody, e);
4651 if (m->mf_state == SMFS_ERROR)
4653 MILTER_CHECK_ERROR(false, continue);
4659 /* leave things in the expected state if we touched it */
4662 if (*state == SMFIR_CONTINUE ||
4663 *state == SMFIR_ACCEPT)
4665 *state = SMFIR_TEMPFAIL;
4666 SM_FREE_CLR(response);
4671 (void) sm_io_close(e->e_dfp, SM_TIME_DEFAULT);
4673 e->e_flags &= ~EF_HAS_DF;
4679 if ((dfopen && milter_reset_df(e) < 0) ||
4680 (rewind && bfrewind(e->e_dfp) < 0))
4683 ExitStat = EX_IOERR;
4686 ** If filter told us to keep message but we had
4687 ** an error, we can't really keep it, tempfail it.
4690 if (*state == SMFIR_CONTINUE ||
4691 *state == SMFIR_ACCEPT)
4693 *state = SMFIR_TEMPFAIL;
4694 SM_FREE_CLR(response);
4698 syserr("milter_data: %s/%cf%s: read error",
4699 qid_printqueue(e->e_qgrp, e->e_qdir),
4700 DATAFL_LETTER, e->e_id);
4703 MILTER_CHECK_DONE_MSG();
4704 if (MilterLogLevel > 10 && *state == SMFIR_REJECT)
4705 sm_syslog(LOG_INFO, e->e_id, "Milter: reject, data");
4710 ** MILTER_UNKNOWN -- send any unrecognized or unimplemented command
4711 ** string to milter filters
4714 ** smtpcmd -- the string itself.
4715 ** e -- current envelope.
4716 ** state -- return state from response.
4720 ** response string (may be NULL)
4724 milter_unknown(smtpcmd, e, state)
4730 sm_dprintf("milter_unknown(%s)\n", smtpcmd);
4732 return milter_command(SMFIC_UNKNOWN, smtpcmd, strlen(smtpcmd) + 1,
4733 SMFIM_NOMACROS, e, state, "unknown", false);
4737 ** MILTER_QUIT -- informs the filter(s) we are done and closes connection(s)
4740 ** e -- current envelope.
4753 sm_dprintf("milter_quit(%s)\n", e->e_id);
4755 for (i = 0; InputFilters[i] != NULL; i++)
4756 milter_quit_filter(InputFilters[i], e);
4760 ** MILTER_ABORT -- informs the filter(s) that we are aborting current message
4763 ** e -- current envelope.
4776 sm_dprintf("milter_abort\n");
4778 for (i = 0; InputFilters[i] != NULL; i++)
4780 struct milter *m = InputFilters[i];
4783 if (m->mf_sock < 0 || m->mf_state != SMFS_INMSG)
4786 milter_abort_filter(m, e);