2 * Copyright (c) 1999-2006 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.269 2007/06/06 17:26:12 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
)
517 time_t writestart
= (time_t) 0;
521 char command
= (char) cmd
;
522 char data
[MILTER_LEN_BYTES
+ 1];
523 bool started
= false;
524 struct iovec vector
[2];
527 ** At most two buffers will be written, though
528 ** only one may actually be used (see num_vectors).
529 ** The first is the size/command and the second is the command data.
532 if (len
< 0 || len
> MilterMaxDataSize
)
535 sm_dprintf("milter_write(%s): length %ld out of range\n",
536 m
->mf_name
, (long) len
);
537 if (MilterLogLevel
> 0)
538 sm_syslog(LOG_ERR
, e
->e_id
,
539 "milter_write(%s): length %ld out of range",
540 m
->mf_name
, (long) len
);
546 if (MilterLogLevel
> 0)
547 sm_syslog(LOG_ERR
, e
->e_id
,
548 "milter_write(%s): socket closed",
555 sm_dprintf("milter_write(%s): cmd %c, len %ld\n",
556 m
->mf_name
, command
, (long) len
);
558 nl
= htonl(len
+ 1); /* add 1 for the command char */
559 (void) memcpy(data
, (char *) &nl
, MILTER_LEN_BYTES
);
560 data
[MILTER_LEN_BYTES
] = command
;
561 sl
= MILTER_LEN_BYTES
+ 1;
563 /* set up the vector for the size / command */
564 vector
[0].iov_base
= (void *) data
;
565 vector
[0].iov_len
= sl
;
568 ** Determine if there is command data. If so, there will be two
569 ** vectors. If not, there will be only one. The vectors are set
570 ** up here and 'num_vectors' and 'sl' are set appropriately.
573 /* NOTE: len<0 has already been checked for. Pedantic */
574 if (len
<= 0 || buf
== NULL
)
576 /* There is no command data -- only a size / command data */
582 ** There is both size / command and command data.
583 ** Set up the vector for the command data.
588 vector
[1].iov_base
= (void *) buf
;
589 vector
[1].iov_len
= len
;
592 sm_dprintf("milter_write(%s): Sending %*s\n",
593 m
->mf_name
, (int) len
, buf
);
598 writestart
= curtime();
599 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
1576 # define MO_MAXDATASIZE 0x08
1577 { "maxdatasize", MO_MAXDATASIZE
},
1578 # endif /* _FFR_MAXDATASIZE */
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
1635 case MO_MAXDATASIZE
:
1636 MilterMaxDataSize
= (size_t)atol(val
);
1638 #endif /* _FFR_MAXDATASIZE */
1640 case MO_MACROS_CONNECT
:
1642 macros
= MilterConnectMacros
;
1645 case MO_MACROS_HELO
:
1647 macros
= MilterHeloMacros
;
1650 case MO_MACROS_ENVFROM
:
1652 macros
= MilterEnvFromMacros
;
1655 case MO_MACROS_ENVRCPT
:
1657 macros
= MilterEnvRcptMacros
;
1662 macros
= MilterEOHMacros
;
1667 macros
= MilterEOMMacros
;
1670 case MO_MACROS_DATA
:
1672 macros
= MilterDataMacros
;
1674 r
= milter_set_macros(name
, macros
, val
, nummac
);
1680 syserr("milter_set_option: invalid Milter option %s", name
);
1684 setbitn(mo
->mo_code
, StickyMilterOpt
);
1688 ** MILTER_REOPEN_DF -- open & truncate the data file (for replbody)
1691 ** e -- current envelope.
1694 ** 0 if succesful, -1 otherwise
1701 char dfname
[MAXPATHLEN
];
1703 (void) sm_strlcpy(dfname
, queuename(e
, DATAFL_LETTER
), sizeof(dfname
));
1706 ** In SuperSafe == SAFE_REALLY mode, e->e_dfp is a read-only FP so
1707 ** close and reopen writable (later close and reopen
1708 ** read only again).
1710 ** In SuperSafe != SAFE_REALLY mode, e->e_dfp still points at the
1711 ** buffered file I/O descriptor, still open for writing so there
1712 ** isn't any work to do here (except checking for consistency).
1715 if (SuperSafe
== SAFE_REALLY
)
1717 /* close read-only data file */
1718 if (bitset(EF_HAS_DF
, e
->e_flags
) && e
->e_dfp
!= NULL
)
1720 (void) sm_io_close(e
->e_dfp
, SM_TIME_DEFAULT
);
1721 e
->e_flags
&= ~EF_HAS_DF
;
1725 if ((e
->e_dfp
= sm_io_open(SmFtStdio
, SM_TIME_DEFAULT
, dfname
,
1726 SM_IO_RDWR_B
, NULL
)) == NULL
)
1728 MILTER_DF_ERROR("milter_reopen_df: sm_io_open %s: %s");
1732 else if (e
->e_dfp
== NULL
)
1734 /* shouldn't happen */
1736 MILTER_DF_ERROR("milter_reopen_df: NULL e_dfp (%s: %s)");
1743 ** MILTER_RESET_DF -- re-open read-only the data file (for replbody)
1746 ** e -- current envelope.
1749 ** 0 if succesful, -1 otherwise
1757 char dfname
[MAXPATHLEN
];
1759 (void) sm_strlcpy(dfname
, queuename(e
, DATAFL_LETTER
), sizeof(dfname
));
1761 if (sm_io_flush(e
->e_dfp
, SM_TIME_DEFAULT
) != 0 ||
1762 sm_io_error(e
->e_dfp
))
1764 MILTER_DF_ERROR("milter_reset_df: error writing/flushing %s: %s");
1767 else if (SuperSafe
!= SAFE_REALLY
)
1769 /* skip next few clauses */
1772 else if ((afd
= sm_io_getinfo(e
->e_dfp
, SM_IO_WHAT_FD
, NULL
)) >= 0
1775 MILTER_DF_ERROR("milter_reset_df: error sync'ing %s: %s");
1778 else if (sm_io_close(e
->e_dfp
, SM_TIME_DEFAULT
) < 0)
1780 MILTER_DF_ERROR("milter_reset_df: error closing %s: %s");
1783 else if ((e
->e_dfp
= sm_io_open(SmFtStdio
, SM_TIME_DEFAULT
, dfname
,
1784 SM_IO_RDONLY_B
, NULL
)) == NULL
)
1786 MILTER_DF_ERROR("milter_reset_df: error reopening %s: %s");
1790 e
->e_flags
|= EF_HAS_DF
;
1795 ** MILTER_QUIT_FILTER -- close down a single filter
1798 ** m -- milter structure of filter to close down.
1799 ** e -- current envelope.
1806 milter_quit_filter(m
, e
)
1811 sm_dprintf("milter_quit_filter(%s)\n", m
->mf_name
);
1812 if (MilterLogLevel
> 18)
1813 sm_syslog(LOG_INFO
, e
->e_id
, "Milter (%s): quit filter",
1816 /* Never replace error state */
1817 if (m
->mf_state
== SMFS_ERROR
)
1820 if (m
->mf_sock
< 0 ||
1821 m
->mf_state
== SMFS_CLOSED
||
1822 m
->mf_state
== SMFS_READY
)
1825 m
->mf_state
= SMFS_CLOSED
;
1829 (void) milter_write(m
, SMFIC_QUIT
, (char *) NULL
, 0,
1830 m
->mf_timeout
[SMFTO_WRITE
], e
, "quit_filter");
1831 if (m
->mf_sock
>= 0)
1833 (void) close(m
->mf_sock
);
1836 if (m
->mf_state
!= SMFS_ERROR
)
1837 m
->mf_state
= SMFS_CLOSED
;
1841 ** MILTER_ABORT_FILTER -- tell filter to abort current message
1844 ** m -- milter structure of filter to abort.
1845 ** e -- current envelope.
1852 milter_abort_filter(m
, e
)
1857 sm_dprintf("milter_abort_filter(%s)\n", m
->mf_name
);
1858 if (MilterLogLevel
> 10)
1859 sm_syslog(LOG_INFO
, e
->e_id
, "Milter (%s): abort filter",
1862 if (m
->mf_sock
< 0 ||
1863 m
->mf_state
!= SMFS_INMSG
)
1866 (void) milter_write(m
, SMFIC_ABORT
, (char *) NULL
, 0,
1867 m
->mf_timeout
[SMFTO_WRITE
], e
, "abort_filter");
1868 if (m
->mf_state
!= SMFS_ERROR
)
1869 m
->mf_state
= SMFS_DONE
;
1873 ** MILTER_SEND_MACROS -- provide macros to the filters
1876 ** m -- milter to send macros to.
1877 ** macros -- macros to send for filter smfi_getsymval().
1878 ** cmd -- which command the macros are associated with.
1879 ** e -- current envelope (for macro access).
1886 milter_send_macros(m
, macros
, cmd
, e
)
1894 char command
= (char) cmd
;
1901 if (macros
== NULL
|| macros
[0] == NULL
)
1904 /* put together data */
1905 s
= 1; /* for the command character */
1906 for (i
= 0; macros
[i
] != NULL
; i
++)
1908 mid
= macid(macros
[i
]);
1911 v
= macvalue(mid
, e
);
1914 expand(v
, exp
, sizeof(exp
), e
);
1915 s
+= strlen(macros
[i
]) + 1 + strlen(exp
) + 1;
1921 buf
= (char *) xalloc(s
);
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
);
1935 sm_dprintf("milter_send_macros(%s, %c): %s=%s\n",
1936 m
->mf_name
, command
, macros
[i
], exp
);
1938 (void) sm_strlcpy(bp
, macros
[i
], s
- (bp
- buf
));
1939 bp
+= strlen(bp
) + 1;
1940 (void) sm_strlcpy(bp
, exp
, s
- (bp
- buf
));
1941 bp
+= strlen(bp
) + 1;
1943 (void) milter_write(m
, SMFIC_MACRO
, buf
, s
,
1944 m
->mf_timeout
[SMFTO_WRITE
], e
, "send_macros");
1949 ** MILTER_SEND_COMMAND -- send a command and return the response for a filter
1952 ** m -- current milter filter
1953 ** cmd -- command to send.
1954 ** data -- optional command data.
1955 ** sz -- length of buf.
1956 ** e -- current envelope (for e->e_id).
1957 ** state -- return state word.
1960 ** response string (may be NULL)
1964 milter_send_command(m
, cmd
, data
, sz
, e
, state
, where
)
1975 unsigned long skipflag
;
1976 unsigned long norespflag
= 0;
1977 char command
= (char) cmd
;
1983 sm_dprintf("milter_send_command(%s): cmd %c len %ld\n",
1984 m
->mf_name
, (char) command
, (long) sz
);
1986 /* find skip flag and default failure */
1990 skipflag
= SMFIP_NOCONNECT
;
1991 norespflag
= SMFIP_NR_CONN
;
1993 defresponse
= "554 Command rejected";
1997 skipflag
= SMFIP_NOHELO
;
1998 norespflag
= SMFIP_NR_HELO
;
2000 defresponse
= "550 Command rejected";
2004 skipflag
= SMFIP_NOMAIL
;
2005 norespflag
= SMFIP_NR_MAIL
;
2007 defresponse
= "550 5.7.1 Command rejected";
2011 skipflag
= SMFIP_NORCPT
;
2012 norespflag
= SMFIP_NR_RCPT
;
2014 defresponse
= "550 5.7.1 Command rejected";
2018 skipflag
= SMFIP_NOHDRS
;
2019 norespflag
= SMFIP_NR_HDR
;
2021 defresponse
= "550 5.7.1 Command rejected";
2025 skipflag
= SMFIP_NOBODY
;
2026 norespflag
= SMFIP_NR_BODY
;
2028 defresponse
= "554 5.7.1 Command rejected";
2032 skipflag
= SMFIP_NOEOH
;
2033 norespflag
= SMFIP_NR_EOH
;
2035 defresponse
= "550 5.7.1 Command rejected";
2039 skipflag
= SMFIP_NOUNKNOWN
;
2040 norespflag
= SMFIP_NR_UNKN
;
2042 defresponse
= "550 5.7.1 Command rejected";
2046 skipflag
= SMFIP_NODATA
;
2047 norespflag
= SMFIP_NR_DATA
;
2049 defresponse
= "550 5.7.1 Command rejected";
2057 /* NOTE: not handled by milter_send_command() */
2063 defresponse
= "550 5.7.1 Command rejected";
2068 sm_dprintf("milter_send_command(%s): skip=%lx, pflags=%x\n",
2069 m
->mf_name
, skipflag
, m
->mf_pflags
);
2071 /* check if filter wants this command */
2072 if (skipflag
!= 0 && bitset(skipflag
, m
->mf_pflags
))
2075 /* send the command to the filter */
2076 (void) milter_write(m
, command
, data
, sz
,
2077 m
->mf_timeout
[SMFTO_WRITE
], e
, where
);
2078 if (m
->mf_state
== SMFS_ERROR
)
2080 MILTER_CHECK_ERROR(false, return NULL
);
2084 /* check if filter sends response to this command */
2085 if (norespflag
!= 0 && bitset(norespflag
, m
->mf_pflags
))
2088 /* get the response from the filter */
2089 response
= milter_read(m
, &rcmd
, &rlen
,
2090 m
->mf_timeout
[SMFTO_READ
], e
, where
);
2091 if (m
->mf_state
== SMFS_ERROR
)
2093 MILTER_CHECK_ERROR(false, return NULL
);
2098 sm_dprintf("milter_send_command(%s): returned %c\n",
2099 m
->mf_name
, (char) rcmd
);
2103 case SMFIR_REPLYCODE
:
2104 MILTER_CHECK_REPLYCODE(defresponse
);
2105 if (MilterLogLevel
> 10)
2106 sm_syslog(LOG_INFO
, e
->e_id
,
2107 "milter=%s, action=%s, reject=%s",
2108 m
->mf_name
, action
, response
);
2113 if (MilterLogLevel
> 10)
2114 sm_syslog(LOG_INFO
, e
->e_id
,
2115 "milter=%s, action=%s, reject",
2116 m
->mf_name
, action
);
2121 if (MilterLogLevel
> 10)
2122 sm_syslog(LOG_INFO
, e
->e_id
,
2123 "milter=%s, action=%s, discard",
2124 m
->mf_name
, action
);
2128 case SMFIR_TEMPFAIL
:
2129 if (MilterLogLevel
> 10)
2130 sm_syslog(LOG_INFO
, e
->e_id
,
2131 "milter=%s, action=%s, tempfail",
2132 m
->mf_name
, action
);
2137 /* this filter is done with message/connection */
2138 if (command
== SMFIC_HELO
||
2139 command
== SMFIC_CONNECT
)
2140 m
->mf_state
= SMFS_CLOSABLE
;
2142 m
->mf_state
= SMFS_DONE
;
2143 if (MilterLogLevel
> 10)
2144 sm_syslog(LOG_INFO
, e
->e_id
,
2145 "milter=%s, action=%s, accepted",
2146 m
->mf_name
, action
);
2149 case SMFIR_CONTINUE
:
2150 /* if MAIL command is ok, filter is in message state */
2151 if (command
== SMFIC_MAIL
)
2152 m
->mf_state
= SMFS_INMSG
;
2153 if (MilterLogLevel
> 12)
2154 sm_syslog(LOG_INFO
, e
->e_id
,
2155 "milter=%s, action=%s, continue",
2156 m
->mf_name
, action
);
2160 if (MilterLogLevel
> 12)
2161 sm_syslog(LOG_INFO
, e
->e_id
,
2162 "milter=%s, action=%s, skip",
2163 m
->mf_name
, action
);
2164 m
->mf_state
= SMFS_SKIP
;
2168 /* Invalid response to command */
2169 if (MilterLogLevel
> 0)
2170 sm_syslog(LOG_ERR
, e
->e_id
,
2171 "milter_send_command(%s): action=%s returned bogus response %c",
2172 m
->mf_name
, action
, rcmd
);
2177 if (*state
!= SMFIR_REPLYCODE
&& response
!= NULL
)
2179 sm_free(response
); /* XXX */
2186 ** MILTER_COMMAND -- send a command and return the response for each filter
2189 ** cmd -- command to send.
2190 ** data -- optional command data.
2191 ** sz -- length of buf.
2192 ** macros -- macros to send for filter smfi_getsymval().
2193 ** e -- current envelope (for macro access).
2194 ** state -- return state word.
2195 ** where -- description of calling function (logging).
2196 ** cmd_error -- did the SMTP command cause an error?
2199 ** response string (may be NULL)
2203 milter_command(cmd
, data
, sz
, macros
, e
, state
, where
, cmd_error
)
2214 char command
= (char) cmd
;
2215 char *response
= NULL
;
2219 sm_dprintf("milter_command: cmd %c len %ld\n",
2220 command
, (long) sz
);
2222 *state
= SMFIR_CONTINUE
;
2223 for (i
= 0; InputFilters
[i
] != NULL
; i
++)
2225 struct milter
*m
= InputFilters
[i
];
2227 /* previous problem? */
2228 if (m
->mf_state
== SMFS_ERROR
)
2230 MILTER_CHECK_ERROR(false, continue);
2235 if (m
->mf_sock
< 0 ||
2236 (m
->mf_state
!= SMFS_OPEN
&& m
->mf_state
!= SMFS_INMSG
))
2239 /* send macros (regardless of whether we send command) */
2240 if (macros
!= NULL
&& macros
[0] != NULL
)
2242 milter_send_macros(m
, macros
, command
, e
);
2243 if (m
->mf_state
== SMFS_ERROR
)
2245 MILTER_CHECK_ERROR(false, continue);
2250 if (MilterLogLevel
> 21)
2254 ** send the command if
2255 ** there is no error
2256 ** or it's RCPT and the client asked for it:
2258 ** where == "rcpt" && m->mf_pflags & SMFIP_RCPT_REJ != 0
2259 ** negate that condition and use continue
2263 (strcmp(where
, "rcpt") != 0 ||
2264 (m
->mf_pflags
& SMFIP_RCPT_REJ
) == 0))
2267 response
= milter_send_command(m
, command
, data
, sz
, e
, state
,
2270 if (MilterLogLevel
> 21)
2272 /* log the time it took for the command per filter */
2273 sm_syslog(LOG_INFO
, e
->e_id
,
2274 "Milter (%s): time command (%c), %d",
2275 m
->mf_name
, command
, (int) (tn
- curtime()));
2278 if (*state
!= SMFIR_CONTINUE
)
2284 static int milter_getsymlist
__P((struct milter
*, char *, int, int));
2287 milter_getsymlist(m
, buf
, rlen
, offset
)
2296 SM_ASSERT(m
!= NULL
);
2297 SM_ASSERT(buf
!= NULL
);
2299 while (offset
+ MILTER_LEN_BYTES
< rlen
)
2305 (void) memcpy((char *) &v
, buf
+ offset
, MILTER_LEN_BYTES
);
2307 if (i
< SMFIM_FIRST
|| i
> SMFIM_LAST
)
2309 offset
+= MILTER_LEN_BYTES
;
2314 case MO_MACROS_CONNECT
:
2316 macros
= MilterConnectMacros
;
2319 case MO_MACROS_HELO
:
2321 macros
= MilterHeloMacros
;
2324 case MO_MACROS_ENVFROM
:
2326 macros
= MilterEnvFromMacros
;
2329 case MO_MACROS_ENVRCPT
:
2331 macros
= MilterEnvRcptMacros
;
2336 macros
= MilterEOMMacros
;
2341 macros
= MilterEOHMacros
;
2344 case MO_MACROS_DATA
:
2346 macros
= MilterDataMacros
;
2348 len
= strlen(buf
+ offset
);
2351 r
= milter_set_macros(m
->mf_name
, macros
,
2352 buf
+ offset
, nummac
);
2370 ** MILTER_NEGOTIATE -- get version and flags from filter
2373 ** m -- milter filter structure.
2374 ** e -- current envelope.
2375 ** milters -- milters structure.
2378 ** 0 on success, -1 otherwise
2382 milter_negotiate(m
, e
, milters
)
2388 mi_int32 fvers
, fflags
, pflags
;
2389 mi_int32 mta_prot_vers
, mta_prot_flags
, mta_actions
;
2392 char data
[MILTER_OPTLEN
];
2395 if (m
->mf_sock
< 0 || m
->mf_state
!= SMFS_OPEN
)
2397 if (MilterLogLevel
> 0)
2398 sm_syslog(LOG_ERR
, e
->e_id
,
2399 "Milter (%s): negotiate, impossible state",
2405 #if _FFR_MILTER_CHECK
2406 mta_prot_vers
= m
->mf_mta_prot_version
;
2407 mta_prot_flags
= m
->mf_mta_prot_flags
;
2408 mta_actions
= m
->mf_mta_actions
;
2409 #else /* _FFR_MILTER_CHECK */
2410 mta_prot_vers
= SMFI_PROT_VERSION
;
2411 mta_prot_flags
= SMFI_CURR_PROT
;
2412 mta_actions
= SMFI_CURR_ACTS
;
2413 #endif /* _FFR_MILTER_CHECK */
2415 fvers
= htonl(mta_prot_vers
);
2416 pflags
= htonl(mta_prot_flags
);
2417 fflags
= htonl(mta_actions
);
2418 (void) memcpy(data
, (char *) &fvers
, MILTER_LEN_BYTES
);
2419 (void) memcpy(data
+ MILTER_LEN_BYTES
,
2420 (char *) &fflags
, MILTER_LEN_BYTES
);
2421 (void) memcpy(data
+ (MILTER_LEN_BYTES
* 2),
2422 (char *) &pflags
, MILTER_LEN_BYTES
);
2423 (void) milter_write(m
, SMFIC_OPTNEG
, data
, sizeof(data
),
2424 m
->mf_timeout
[SMFTO_WRITE
], e
, "negotiate");
2426 if (m
->mf_state
== SMFS_ERROR
)
2430 sm_dprintf("milter_negotiate(%s): send: version %lu, fflags 0x%lx, pflags 0x%lx\n",
2431 m
->mf_name
, ntohl(fvers
), ntohl(fflags
), ntohl(pflags
));
2433 response
= milter_read(m
, &rcmd
, &rlen
, m
->mf_timeout
[SMFTO_READ
], e
,
2435 if (m
->mf_state
== SMFS_ERROR
)
2438 if (rcmd
!= SMFIC_OPTNEG
)
2441 sm_dprintf("milter_negotiate(%s): returned %c instead of %c\n",
2442 m
->mf_name
, rcmd
, SMFIC_OPTNEG
);
2443 if (MilterLogLevel
> 0)
2444 sm_syslog(LOG_ERR
, e
->e_id
,
2445 "Milter (%s): negotiate: returned %c instead of %c",
2446 m
->mf_name
, rcmd
, SMFIC_OPTNEG
);
2447 if (response
!= NULL
)
2448 sm_free(response
); /* XXX */
2453 /* Make sure we have enough bytes for the version */
2454 if (response
== NULL
|| rlen
< MILTER_LEN_BYTES
)
2457 sm_dprintf("milter_negotiate(%s): did not return valid info\n",
2459 if (MilterLogLevel
> 0)
2460 sm_syslog(LOG_ERR
, e
->e_id
,
2461 "Milter (%s): negotiate: did not return valid info",
2463 if (response
!= NULL
)
2464 sm_free(response
); /* XXX */
2469 /* extract information */
2470 (void) memcpy((char *) &fvers
, response
, MILTER_LEN_BYTES
);
2472 /* Now make sure we have enough for the feature bitmap */
2473 if (rlen
< MILTER_OPTLEN
)
2476 sm_dprintf("milter_negotiate(%s): did not return enough info\n",
2478 if (MilterLogLevel
> 0)
2479 sm_syslog(LOG_ERR
, e
->e_id
,
2480 "Milter (%s): negotiate: did not return enough info",
2482 if (response
!= NULL
)
2483 sm_free(response
); /* XXX */
2488 (void) memcpy((char *) &fflags
, response
+ MILTER_LEN_BYTES
,
2490 (void) memcpy((char *) &pflags
, response
+ (MILTER_LEN_BYTES
* 2),
2493 m
->mf_fvers
= ntohl(fvers
);
2494 m
->mf_fflags
= ntohl(fflags
);
2495 m
->mf_pflags
= ntohl(pflags
);
2497 /* check for version compatibility */
2498 if (m
->mf_fvers
== 1 ||
2499 m
->mf_fvers
> SMFI_VERSION
)
2502 sm_dprintf("milter_negotiate(%s): version %d != MTA milter version %d\n",
2503 m
->mf_name
, m
->mf_fvers
, SMFI_VERSION
);
2504 if (MilterLogLevel
> 0)
2505 sm_syslog(LOG_ERR
, e
->e_id
,
2506 "Milter (%s): negotiate: version %d != MTA milter version %d",
2507 m
->mf_name
, m
->mf_fvers
, SMFI_VERSION
);
2512 /* check for filter feature mismatch */
2513 if ((m
->mf_fflags
& mta_actions
) != m
->mf_fflags
)
2516 sm_dprintf("milter_negotiate(%s): filter abilities 0x%x != MTA milter abilities 0x%lx\n",
2517 m
->mf_name
, m
->mf_fflags
,
2518 (unsigned long) mta_actions
);
2519 if (MilterLogLevel
> 0)
2520 sm_syslog(LOG_ERR
, e
->e_id
,
2521 "Milter (%s): negotiate: filter abilities 0x%x != MTA milter abilities 0x%lx",
2522 m
->mf_name
, m
->mf_fflags
,
2523 (unsigned long) mta_actions
);
2528 /* check for protocol feature mismatch */
2529 if ((m
->mf_pflags
& mta_prot_flags
) != m
->mf_pflags
)
2532 sm_dprintf("milter_negotiate(%s): protocol abilities 0x%x != MTA milter abilities 0x%lx\n",
2533 m
->mf_name
, m
->mf_pflags
,
2534 (unsigned long) mta_prot_flags
);
2535 if (MilterLogLevel
> 0)
2536 sm_syslog(LOG_ERR
, e
->e_id
,
2537 "Milter (%s): negotiate: protocol abilities 0x%x != MTA milter abilities 0x%lx",
2538 m
->mf_name
, m
->mf_pflags
,
2539 (unsigned long) mta_prot_flags
);
2544 if (m
->mf_fvers
<= 2)
2545 m
->mf_pflags
|= SMFIP_NOUNKNOWN
;
2546 if (m
->mf_fvers
<= 3)
2547 m
->mf_pflags
|= SMFIP_NODATA
;
2549 if (rlen
> MILTER_OPTLEN
)
2551 milter_getsymlist(m
, response
, rlen
, MILTER_OPTLEN
);
2554 if (bitset(SMFIF_DELRCPT
, m
->mf_fflags
))
2555 milters
->mis_flags
|= MIS_FL_DEL_RCPT
;
2556 if (!bitset(SMFIP_NORCPT
, m
->mf_pflags
) &&
2557 !bitset(SMFIP_NR_RCPT
, m
->mf_pflags
))
2558 milters
->mis_flags
|= MIS_FL_REJ_RCPT
;
2561 sm_dprintf("milter_negotiate(%s): received: version %u, fflags 0x%x, pflags 0x%x\n",
2562 m
->mf_name
, m
->mf_fvers
, m
->mf_fflags
, m
->mf_pflags
);
2566 if (response
!= NULL
)
2567 sm_free(response
); /* XXX */
2572 ** MILTER_PER_CONNECTION_CHECK -- checks on per-connection commands
2574 ** Reduce code duplication by putting these checks in one place
2577 ** e -- current envelope.
2584 milter_per_connection_check(e
)
2589 /* see if we are done with any of the filters */
2590 for (i
= 0; InputFilters
[i
] != NULL
; i
++)
2592 struct milter
*m
= InputFilters
[i
];
2594 if (m
->mf_state
== SMFS_CLOSABLE
)
2595 milter_quit_filter(m
, e
);
2600 ** MILTER_ERROR -- Put a milter filter into error state
2603 ** m -- the broken filter.
2604 ** e -- current envelope.
2616 ** We could send a quit here but we may have gotten here due to
2617 ** an I/O error so we don't want to try to make things worse.
2620 if (m
->mf_sock
>= 0)
2622 (void) close(m
->mf_sock
);
2625 m
->mf_state
= SMFS_ERROR
;
2627 if (MilterLogLevel
> 0)
2628 sm_syslog(LOG_INFO
, e
->e_id
, "Milter (%s): to error state",
2633 ** MILTER_HEADERS -- send headers to a single milter filter
2636 ** m -- current filter.
2637 ** e -- current envelope.
2638 ** state -- return state from response.
2641 ** response string (may be NULL)
2645 milter_headers(m
, e
, state
)
2650 char *response
= NULL
;
2653 if (MilterLogLevel
> 17)
2654 sm_syslog(LOG_INFO
, e
->e_id
, "Milter (%s): headers, send",
2657 for (h
= e
->e_header
; h
!= NULL
; h
= h
->h_link
)
2659 int len_n
, len_v
, len_t
, len_f
;
2662 /* don't send over deleted headers */
2663 if (h
->h_value
== NULL
)
2665 /* strip H_USER so not counted in milter_changeheader() */
2666 h
->h_flags
&= ~H_USER
;
2670 /* skip auto-generated */
2671 if (!bitset(H_USER
, h
->h_flags
))
2675 sm_dprintf("milter_headers: %s:%s\n",
2676 h
->h_field
, h
->h_value
);
2677 if (MilterLogLevel
> 21)
2678 sm_syslog(LOG_INFO
, e
->e_id
, "Milter (%s): header, %s",
2679 m
->mf_name
, h
->h_field
);
2681 if (bitset(SMFIP_HDR_LEADSPC
, m
->mf_pflags
)
2682 || *(h
->h_value
) != ' ')
2685 hv
= h
->h_value
+ 1;
2686 len_f
= strlen(h
->h_field
) + 1;
2687 len_t
= len_f
+ strlen(hv
) + 1;
2690 buf
= (char *) xalloc(len_t
);
2693 ** Note: currently the call to dequote_internal_chars()
2694 ** is not required as h_field is supposed to be 7-bit US-ASCII.
2697 len_n
= dequote_internal_chars(h
->h_field
, buf
, len_f
);
2698 SM_ASSERT(len_n
< len_f
);
2699 len_v
= dequote_internal_chars(hv
, buf
+ len_n
+ 1,
2701 SM_ASSERT(len_t
>= len_n
+ 1 + len_v
+ 1);
2702 len_t
= len_n
+ 1 + len_v
+ 1;
2705 response
= milter_send_command(m
, SMFIC_HEADER
, buf
,
2706 len_t
, e
, state
, "header");
2708 if (m
->mf_state
== SMFS_ERROR
||
2709 m
->mf_state
== SMFS_DONE
||
2710 *state
!= SMFIR_CONTINUE
)
2713 if (MilterLogLevel
> 17)
2714 sm_syslog(LOG_INFO
, e
->e_id
, "Milter (%s): headers, sent",
2720 ** MILTER_BODY -- send the body to a filter
2723 ** m -- current filter.
2724 ** e -- current envelope.
2725 ** state -- return state from response.
2728 ** response string (may be NULL)
2732 milter_body(m
, e
, state
)
2737 char bufchar
= '\0';
2738 char prevchar
= '\0';
2740 char *response
= NULL
;
2742 char buf
[MILTER_CHUNK_SIZE
];
2745 sm_dprintf("milter_body\n");
2747 if (bfrewind(e
->e_dfp
) < 0)
2749 ExitStat
= EX_IOERR
;
2750 *state
= SMFIR_TEMPFAIL
;
2751 syserr("milter_body: %s/%cf%s: rewind error",
2752 qid_printqueue(e
->e_qgrp
, e
->e_qdir
),
2753 DATAFL_LETTER
, e
->e_id
);
2757 if (MilterLogLevel
> 17)
2758 sm_syslog(LOG_INFO
, e
->e_id
, "Milter (%s): body, send",
2761 while ((c
= sm_io_getc(e
->e_dfp
, SM_TIME_DEFAULT
)) != SM_IO_EOF
)
2763 /* Change LF to CRLF */
2766 #if !_FFR_MILTER_CONVERT_ALL_LF_TO_CRLF
2767 /* Not a CRLF already? */
2768 if (prevchar
!= '\r')
2769 #endif /* !_FFR_MILTER_CONVERT_ALL_LF_TO_CRLF */
2771 /* Room for CR now? */
2772 if (bp
+ 2 > &buf
[sizeof(buf
)])
2774 /* No room, buffer LF */
2777 /* and send CR now */
2782 /* Room to do it now */
2790 if (bp
>= &buf
[sizeof(buf
)])
2793 response
= milter_send_command(m
, SMFIC_BODY
, buf
,
2797 if (bufchar
!= '\0')
2804 if (m
->mf_state
== SMFS_ERROR
||
2805 m
->mf_state
== SMFS_DONE
||
2806 m
->mf_state
== SMFS_SKIP
||
2807 *state
!= SMFIR_CONTINUE
)
2811 /* check for read errors */
2812 if (sm_io_error(e
->e_dfp
))
2814 ExitStat
= EX_IOERR
;
2815 if (*state
== SMFIR_CONTINUE
||
2816 *state
== SMFIR_ACCEPT
||
2817 m
->mf_state
== SMFS_SKIP
)
2819 *state
= SMFIR_TEMPFAIL
;
2820 if (response
!= NULL
)
2822 sm_free(response
); /* XXX */
2826 syserr("milter_body: %s/%cf%s: read error",
2827 qid_printqueue(e
->e_qgrp
, e
->e_qdir
),
2828 DATAFL_LETTER
, e
->e_id
);
2832 /* send last body chunk */
2834 m
->mf_state
!= SMFS_ERROR
&&
2835 m
->mf_state
!= SMFS_DONE
&&
2836 m
->mf_state
!= SMFS_SKIP
&&
2837 *state
== SMFIR_CONTINUE
)
2840 response
= milter_send_command(m
, SMFIC_BODY
, buf
, bp
- buf
,
2841 e
, state
, "last body chunk");
2844 if (MilterLogLevel
> 17)
2845 sm_syslog(LOG_INFO
, e
->e_id
, "Milter (%s): body, sent",
2847 if (m
->mf_state
== SMFS_SKIP
)
2849 *state
= SMFIR_CONTINUE
;
2850 m
->mf_state
= SMFS_READY
;
2861 ** ADDLEADINGSPACE -- Add a leading space to a string
2865 ** rp -- resource pool for allocations
2868 ** pointer to new string
2871 static char *addleadingspace
__P((char *, SM_RPOOL_T
*));
2874 addleadingspace(str
, rp
)
2881 SM_ASSERT(str
!= NULL
);
2883 SM_ASSERT(l
+ 2 > l
);
2884 new = sm_rpool_malloc_x(rp
, l
+ 2);
2887 sm_strlcpy(new + 1, str
, l
+ 1);
2892 ** MILTER_ADDHEADER -- Add the supplied header to the message
2895 ** m -- current filter.
2896 ** response -- encoded form of header/value.
2897 ** rlen -- length of response.
2898 ** e -- current envelope.
2905 milter_addheader(m
, response
, rlen
, e
)
2912 char *val
, *mh_value
;
2916 sm_dprintf("milter_addheader: ");
2919 if (response
== NULL
)
2922 sm_dprintf("NULL response\n");
2926 if (rlen
< 2 || strlen(response
) + 1 >= (size_t) rlen
)
2929 sm_dprintf("didn't follow protocol (total len %d != rlen %d)\n",
2930 (int) strlen(response
), (int) (rlen
- 1));
2934 /* Find separating NUL */
2935 val
= response
+ strlen(response
) + 1;
2937 /* another sanity check */
2938 if (strlen(response
) + strlen(val
) + 2 != (size_t) rlen
)
2941 sm_dprintf("didn't follow protocol (part len)\n");
2945 if (*response
== '\0')
2948 sm_dprintf("empty field name\n");
2952 for (h
= e
->e_header
; h
!= NULL
; h
= h
->h_link
)
2954 if (sm_strcasecmp(h
->h_field
, response
) == 0 &&
2955 !bitset(H_USER
, h
->h_flags
) &&
2956 !bitset(H_TRACE
, h
->h_flags
))
2961 mh_value
= quote_internal_chars(val
, NULL
, &mh_v_len
);
2963 /* add to e_msgsize */
2964 e
->e_msgsize
+= strlen(response
) + 2 + strlen(val
);
2969 sm_dprintf("Replace default header %s value with %s\n",
2970 h
->h_field
, mh_value
);
2971 if (MilterLogLevel
> 8)
2972 sm_syslog(LOG_INFO
, e
->e_id
,
2973 "Milter change: default header %s value with %s",
2974 h
->h_field
, mh_value
);
2975 if (bitset(SMFIP_HDR_LEADSPC
, m
->mf_pflags
))
2976 h
->h_value
= mh_value
;
2979 h
->h_value
= addleadingspace (mh_value
, e
->e_rpool
);
2982 h
->h_flags
|= H_USER
;
2987 sm_dprintf("Add %s: %s\n", response
, mh_value
);
2988 if (MilterLogLevel
> 8)
2989 sm_syslog(LOG_INFO
, e
->e_id
,
2990 "Milter add: header: %s: %s",
2991 response
, mh_value
);
2992 addheader(newstr(response
), mh_value
, H_USER
, e
,
2993 !bitset(SMFIP_HDR_LEADSPC
, m
->mf_pflags
));
2999 ** MILTER_INSHEADER -- Insert the supplied header
3002 ** m -- current filter.
3003 ** response -- encoded form of header/value.
3004 ** rlen -- length of response.
3005 ** e -- current envelope.
3011 ** Unlike milter_addheader(), this does not attempt to determine
3012 ** if the header already exists in the envelope, even a
3013 ** deleted version. It just blindly inserts.
3017 milter_insheader(m
, response
, rlen
, e
)
3025 char *field
, *val
, *mh_value
;
3028 sm_dprintf("milter_insheader: ");
3031 if (response
== NULL
)
3034 sm_dprintf("NULL response\n");
3038 if (rlen
< 2 || strlen(response
) + 1 >= (size_t) rlen
)
3041 sm_dprintf("didn't follow protocol (total len)\n");
3046 (void) memcpy((char *) &i
, response
, MILTER_LEN_BYTES
);
3048 field
= response
+ MILTER_LEN_BYTES
;
3049 val
= field
+ strlen(field
) + 1;
3051 /* another sanity check */
3052 if (MILTER_LEN_BYTES
+ strlen(field
) + 1 +
3053 strlen(val
) + 1 != (size_t) rlen
)
3056 sm_dprintf("didn't follow protocol (part len)\n");
3063 sm_dprintf("empty field name\n");
3067 /* add to e_msgsize */
3068 e
->e_msgsize
+= strlen(response
) + 2 + strlen(val
);
3071 sm_dprintf("Insert (%d) %s: %s\n", idx
, field
, val
);
3072 if (MilterLogLevel
> 8)
3073 sm_syslog(LOG_INFO
, e
->e_id
,
3074 "Milter insert (%d): header: %s: %s",
3077 mh_value
= quote_internal_chars(val
, NULL
, &mh_v_len
);
3078 insheader(idx
, newstr(field
), mh_value
, H_USER
, e
,
3079 !bitset(SMFIP_HDR_LEADSPC
, m
->mf_pflags
));
3084 ** MILTER_CHANGEHEADER -- Change the supplied header in the message
3087 ** m -- current filter.
3088 ** response -- encoded form of header/index/value.
3089 ** rlen -- length of response.
3090 ** e -- current envelope.
3097 milter_changeheader(m
, response
, rlen
, e
)
3105 char *field
, *val
, *mh_value
;
3109 sm_dprintf("milter_changeheader: ");
3112 if (response
== NULL
)
3115 sm_dprintf("NULL response\n");
3119 if (rlen
< 2 || strlen(response
) + 1 >= (size_t) rlen
)
3122 sm_dprintf("didn't follow protocol (total len)\n");
3126 /* Find separating NUL */
3127 (void) memcpy((char *) &i
, response
, MILTER_LEN_BYTES
);
3129 field
= response
+ MILTER_LEN_BYTES
;
3130 val
= field
+ strlen(field
) + 1;
3132 /* another sanity check */
3133 if (MILTER_LEN_BYTES
+ strlen(field
) + 1 +
3134 strlen(val
) + 1 != (size_t) rlen
)
3137 sm_dprintf("didn't follow protocol (part len)\n");
3144 sm_dprintf("empty field name\n");
3149 mh_value
= quote_internal_chars(val
, NULL
, &mh_v_len
);
3152 for (h
= e
->e_header
; h
!= NULL
; h
= h
->h_link
)
3154 if (sm_strcasecmp(h
->h_field
, field
) == 0)
3156 if (bitset(H_USER
, h
->h_flags
) && --index
<= 0)
3161 else if (!bitset(H_USER
, h
->h_flags
) &&
3162 !bitset(H_TRACE
, h
->h_flags
))
3165 ** DRUMS msg-fmt draft says can only have
3166 ** multiple occurences of trace fields,
3167 ** so make sure we replace any non-trace,
3176 /* if not found as user-provided header at index, use sysheader */
3185 sm_dprintf("Delete (noop) %s\n", field
);
3186 if (MilterLogLevel
> 8)
3187 sm_syslog(LOG_INFO
, e
->e_id
,
3188 "Milter delete (noop): header: %s"
3193 /* treat modify value with no existing header as add */
3195 sm_dprintf("Add %s: %s\n", field
, mh_value
);
3196 if (MilterLogLevel
> 8)
3197 sm_syslog(LOG_INFO
, e
->e_id
,
3198 "Milter change (add): header: %s: %s"
3200 addheader(newstr(field
), mh_value
, H_USER
, e
,
3201 !bitset(SMFIP_HDR_LEADSPC
, m
->mf_pflags
));
3210 sm_dprintf("Delete%s %s:%s\n",
3211 h
== sysheader
? " (default header)" : "",
3213 h
->h_value
== NULL
? "<NULL>" : h
->h_value
);
3217 sm_dprintf("Change%s %s: from %s to %s\n",
3218 h
== sysheader
? " (default header)" : "",
3220 h
->h_value
== NULL
? "<NULL>" : h
->h_value
,
3225 if (MilterLogLevel
> 8)
3229 sm_syslog(LOG_INFO
, e
->e_id
,
3230 "Milter delete: header%s %s:%s",
3231 h
== sysheader
? " (default header)" : "",
3233 h
->h_value
== NULL
? "<NULL>" : h
->h_value
);
3237 sm_syslog(LOG_INFO
, e
->e_id
,
3238 "Milter change: header%s %s: from %s to %s",
3239 h
== sysheader
? " (default header)" : "",
3241 h
->h_value
== NULL
? "<NULL>" : h
->h_value
,
3246 if (h
!= sysheader
&& h
->h_value
!= NULL
)
3250 l
= strlen(h
->h_value
);
3251 if (l
> e
->e_msgsize
)
3255 /* rpool, don't free: sm_free(h->h_value); XXX */
3260 /* Remove "Field: " from message size */
3265 l
= strlen(h
->h_field
) + 2;
3266 if (l
> e
->e_msgsize
)
3276 if (bitset(SMFIP_HDR_LEADSPC
, m
->mf_pflags
))
3277 h
->h_value
= mh_value
;
3280 h
->h_value
= addleadingspace (mh_value
, e
->e_rpool
);
3283 h
->h_flags
|= H_USER
;
3284 e
->e_msgsize
+= strlen(h
->h_value
);
3289 ** MILTER_SPLIT_RESPONSE -- Split response into fields.
3292 ** response -- encoded repsonse.
3293 ** rlen -- length of response.
3294 ** pargc -- number of arguments (ouput)
3297 ** array of pointers to the individual strings
3300 static char **milter_split_response
__P((char *, ssize_t
, int *));
3303 milter_split_response(response
, rlen
, pargc
)
3312 SM_ASSERT(response
!= NULL
);
3313 SM_ASSERT(pargc
!= NULL
);
3315 if (rlen
< 2 || strlen(response
) >= (size_t) rlen
)
3318 sm_dprintf("didn't follow protocol (total len %d != rlen %d)\n",
3319 (int) strlen(response
), (int) (rlen
- 1));
3324 for (i
= 0; i
< rlen
; i
++)
3326 if (response
[i
] == '\0')
3332 /* last entry is only for the name */
3333 s
= (char **)malloc(nelem
* (sizeof(*s
)));
3337 for (i
= 0, elem
= 0; i
< rlen
&& elem
< nelem
; i
++)
3339 if (response
[i
] == '\0')
3345 s
[elem
] = &(response
[i
+ 1]);
3352 for (elem
= 0; elem
< nelem
; elem
++)
3353 sm_dprintf("argv[%d]=\"%s\"\n", elem
, s
[elem
]);
3356 /* overwrite last entry (already done above, just paranoia) */
3362 ** MILTER_CHGFROM -- Change the envelope sender address
3365 ** response -- encoded form of recipient address.
3366 ** rlen -- length of response.
3367 ** e -- current envelope.
3374 milter_chgfrom(response
, rlen
, e
)
3379 int olderrors
, argc
;
3383 sm_dprintf("milter_chgfrom: ");
3386 if (response
== NULL
)
3389 sm_dprintf("NULL response\n");
3393 if (*response
== '\0' ||
3394 strlen(response
) + 1 > (size_t) rlen
)
3397 sm_dprintf("didn't follow protocol (total len %d != rlen %d)\n",
3398 (int) strlen(response
), (int) (rlen
- 1));
3403 sm_dprintf("%s\n", response
);
3404 if (MilterLogLevel
> 8)
3405 sm_syslog(LOG_INFO
, e
->e_id
, "Milter chgfrom: %s", response
);
3406 argv
= milter_split_response(response
, rlen
, &argc
);
3407 if (argc
< 1 || argc
> 2)
3410 sm_dprintf("didn't follow protocol argc=%d\n", argc
);
3415 setsender(argv
[0], e
, NULL
, '\0', false);
3418 reset_mail_esmtp_args(e
);
3421 ** need "features" here: how to get those? via e?
3422 ** "fake" it for now: allow everything.
3425 parse_esmtp_args(e
, NULL
, argv
[0], argv
[1], "MAIL", NULL
,
3433 ** MILTER_ADDRCPT_PAR -- Add the supplied recipient to the message
3436 ** response -- encoded form of recipient address.
3437 ** rlen -- length of response.
3438 ** e -- current envelope.
3445 milter_addrcpt_par(response
, rlen
, e
)
3450 int olderrors
, argc
;
3456 sm_dprintf("milter_addrcpt_par: ");
3459 if (response
== NULL
)
3462 sm_dprintf("NULL response\n");
3467 sm_dprintf("%s\n", response
);
3468 if (MilterLogLevel
> 8)
3469 sm_syslog(LOG_INFO
, e
->e_id
, "Milter add: rcpt: %s", response
);
3471 argv
= milter_split_response(response
, rlen
, &argc
);
3472 if (argc
< 1 || argc
> 2)
3475 sm_dprintf("didn't follow protocol argc=%d\n", argc
);
3480 /* how to set ESMTP arguments? */
3481 a
= parseaddr(argv
[0], NULLADDR
, RF_COPYALL
, ' ', &delimptr
, e
, true);
3483 if (a
!= NULL
&& olderrors
== Errors
)
3485 parse_esmtp_args(e
, a
, argv
[0], argv
[1], "RCPT", NULL
,
3487 if (olderrors
== Errors
)
3488 a
= recipient(a
, &e
->e_sendqueue
, 0, e
);
3490 sm_dprintf("olderrors=%d, Errors=%d\n",
3495 sm_dprintf("a=%p, olderrors=%d, Errors=%d\n",
3496 a
, olderrors
, Errors
);
3504 ** MILTER_ADDRCPT -- Add the supplied recipient to the message
3507 ** response -- encoded form of recipient address.
3508 ** rlen -- length of response.
3509 ** e -- current envelope.
3516 milter_addrcpt(response
, rlen
, e
)
3524 sm_dprintf("milter_addrcpt: ");
3527 if (response
== NULL
)
3530 sm_dprintf("NULL response\n");
3534 if (*response
== '\0' ||
3535 strlen(response
) + 1 != (size_t) rlen
)
3538 sm_dprintf("didn't follow protocol (total len %d != rlen %d)\n",
3539 (int) strlen(response
), (int) (rlen
- 1));
3544 sm_dprintf("%s\n", response
);
3545 if (MilterLogLevel
> 8)
3546 sm_syslog(LOG_INFO
, e
->e_id
, "Milter add: rcpt: %s", response
);
3548 (void) sendtolist(response
, NULLADDR
, &e
->e_sendqueue
, 0, e
);
3554 ** MILTER_DELRCPT -- Delete the supplied recipient from the message
3557 ** response -- encoded form of recipient address.
3558 ** rlen -- length of response.
3559 ** e -- current envelope.
3566 milter_delrcpt(response
, rlen
, e
)
3572 sm_dprintf("milter_delrcpt: ");
3575 if (response
== NULL
)
3578 sm_dprintf("NULL response\n");
3582 if (*response
== '\0' ||
3583 strlen(response
) + 1 != (size_t) rlen
)
3586 sm_dprintf("didn't follow protocol (total len %d != rlen %d)\n",
3587 (int) strlen(response
), (int) (rlen
- 1));
3592 sm_dprintf("%s\n", response
);
3593 if (MilterLogLevel
> 8)
3594 sm_syslog(LOG_INFO
, e
->e_id
, "Milter delete: rcpt %s",
3596 (void) removefromlist(response
, &e
->e_sendqueue
, e
);
3601 ** MILTER_REPLBODY -- Replace the current data file with new body
3604 ** response -- encoded form of new body.
3605 ** rlen -- length of response.
3606 ** newfilter -- if first time called by a new filter
3607 ** e -- current envelope.
3610 ** 0 upon success, -1 upon failure
3614 milter_replbody(response
, rlen
, newfilter
, e
)
3620 static char prevchar
;
3624 sm_dprintf("milter_replbody\n");
3626 /* If a new filter, reset previous character and truncate data file */
3630 char dfname
[MAXPATHLEN
];
3632 (void) sm_strlcpy(dfname
, queuename(e
, DATAFL_LETTER
),
3635 /* Reset prevchar */
3638 /* Get the current data file information */
3639 prevsize
= sm_io_getinfo(e
->e_dfp
, SM_IO_WHAT_SIZE
, NULL
);
3643 /* truncate current data file */
3644 if (sm_io_getinfo(e
->e_dfp
, SM_IO_WHAT_ISTYPE
, BF_FILE_TYPE
))
3646 if (sm_io_setinfo(e
->e_dfp
, SM_BF_TRUNCATE
, NULL
) < 0)
3648 MILTER_DF_ERROR("milter_replbody: sm_io truncate %s: %s");
3656 err
= sm_io_error(e
->e_dfp
);
3657 (void) sm_io_flush(e
->e_dfp
, SM_TIME_DEFAULT
);
3660 ** Clear error if tried to fflush()
3661 ** a read-only file pointer and
3662 ** there wasn't a previous error.
3666 sm_io_clearerr(e
->e_dfp
);
3668 /* errno is set implicitly by fseek() before return */
3669 err
= sm_io_seek(e
->e_dfp
, SM_TIME_DEFAULT
,
3673 MILTER_DF_ERROR("milter_replbody: sm_io_seek %s: %s");
3677 /* XXX: Not much we can do except rewind it */
3679 MILTER_DF_ERROR("milter_replbody: ftruncate not available on this platform (%s:%s)");
3681 # else /* NOFTRUNCATE */
3682 err
= ftruncate(sm_io_getinfo(e
->e_dfp
,
3683 SM_IO_WHAT_FD
, NULL
),
3687 MILTER_DF_ERROR("milter_replbody: sm_io ftruncate %s: %s");
3690 # endif /* NOFTRUNCATE */
3693 if (prevsize
> e
->e_msgsize
)
3696 e
->e_msgsize
-= prevsize
;
3699 if (newfilter
&& MilterLogLevel
> 8)
3700 sm_syslog(LOG_INFO
, e
->e_id
, "Milter message: body replaced");
3702 if (response
== NULL
)
3704 /* Flush the buffered '\r' */
3705 if (prevchar
== '\r')
3707 (void) sm_io_putc(e
->e_dfp
, SM_TIME_DEFAULT
, prevchar
);
3713 for (i
= 0; i
< rlen
; i
++)
3715 /* Buffered char from last chunk */
3716 if (i
== 0 && prevchar
== '\r')
3718 /* Not CRLF, output prevchar */
3719 if (response
[i
] != '\n')
3721 (void) sm_io_putc(e
->e_dfp
, SM_TIME_DEFAULT
,
3728 /* Turn CRLF into LF */
3729 if (response
[i
] == '\r')
3731 /* check if at end of chunk */
3734 /* If LF, strip CR */
3735 if (response
[i
+ 1] == '\n')
3740 /* check next chunk */
3745 (void) sm_io_putc(e
->e_dfp
, SM_TIME_DEFAULT
, response
[i
]);
3756 ** MILTER_INIT -- open and negotiate with all of the filters
3759 ** e -- current envelope.
3760 ** state -- return state from response.
3761 ** milters -- milters structure.
3764 ** true iff at least one filter is active
3769 milter_init(e
, state
, milters
)
3777 sm_dprintf("milter_init\n");
3779 memset(milters
, '\0', sizeof(*milters
));
3780 *state
= SMFIR_CONTINUE
;
3781 if (InputFilters
[0] == NULL
)
3783 if (MilterLogLevel
> 10)
3784 sm_syslog(LOG_INFO
, e
->e_id
,
3785 "Milter: no active filter");
3789 for (i
= 0; InputFilters
[i
] != NULL
; i
++)
3791 struct milter
*m
= InputFilters
[i
];
3793 m
->mf_sock
= milter_open(m
, false, e
);
3794 if (m
->mf_state
== SMFS_ERROR
)
3796 MILTER_CHECK_ERROR(true, continue);
3800 if (m
->mf_sock
< 0 ||
3801 milter_negotiate(m
, e
, milters
) < 0 ||
3802 m
->mf_state
== SMFS_ERROR
)
3805 sm_dprintf("milter_init(%s): failed to %s\n",
3807 m
->mf_sock
< 0 ? "open" :
3809 if (MilterLogLevel
> 0)
3810 sm_syslog(LOG_ERR
, e
->e_id
,
3811 "Milter (%s): init failed to %s",
3813 m
->mf_sock
< 0 ? "open" :
3816 /* if negotation failure, close socket */
3818 MILTER_CHECK_ERROR(true, continue);
3821 if (MilterLogLevel
> 9)
3822 sm_syslog(LOG_INFO
, e
->e_id
,
3823 "Milter (%s): init success to %s",
3825 m
->mf_sock
< 0 ? "open" : "negotiate");
3829 ** If something temp/perm failed with one of the filters,
3830 ** we won't be using any of them, so clear any existing
3834 if (*state
!= SMFIR_CONTINUE
)
3841 ** MILTER_CONNECT -- send connection info to milter filters
3844 ** hostname -- hostname of remote machine.
3845 ** addr -- address of remote machine.
3846 ** e -- current envelope.
3847 ** state -- return state from response.
3850 ** response string (may be NULL)
3854 milter_connect(hostname
, addr
, e
, state
)
3861 unsigned short port
;
3864 char *sockinfo
= NULL
;
3867 char buf6
[INET6_ADDRSTRLEN
];
3868 # endif /* NETINET6 */
3871 sm_dprintf("milter_connect(%s)\n", hostname
);
3872 if (MilterLogLevel
> 9)
3873 sm_syslog(LOG_INFO
, e
->e_id
, "Milter: connect to filters");
3876 switch (addr
.sa
.sa_family
)
3880 family
= SMFIA_UNIX
;
3882 sockinfo
= addr
.sunix
.sun_path
;
3884 # endif /* NETUNIX */
3888 family
= SMFIA_INET
;
3889 port
= addr
.sin
.sin_port
;
3890 sockinfo
= (char *) inet_ntoa(addr
.sin
.sin_addr
);
3892 # endif /* NETINET */
3896 if (IN6_IS_ADDR_V4MAPPED(&addr
.sin6
.sin6_addr
))
3897 family
= SMFIA_INET
;
3899 family
= SMFIA_INET6
;
3900 port
= addr
.sin6
.sin6_port
;
3901 sockinfo
= anynet_ntop(&addr
.sin6
.sin6_addr
, buf6
,
3903 if (sockinfo
== NULL
)
3906 # endif /* NETINET6 */
3909 family
= SMFIA_UNKNOWN
;
3913 s
= strlen(hostname
) + 1 + sizeof(family
);
3914 if (family
!= SMFIA_UNKNOWN
)
3915 s
+= sizeof(port
) + strlen(sockinfo
) + 1;
3917 buf
= (char *) xalloc(s
);
3920 /* put together data */
3921 (void) memcpy(bp
, hostname
, strlen(hostname
));
3922 bp
+= strlen(hostname
);
3924 (void) memcpy(bp
, &family
, sizeof(family
));
3925 bp
+= sizeof(family
);
3926 if (family
!= SMFIA_UNKNOWN
)
3928 (void) memcpy(bp
, &port
, sizeof(port
));
3931 /* include trailing '\0' */
3932 (void) memcpy(bp
, sockinfo
, strlen(sockinfo
) + 1);
3935 response
= milter_command(SMFIC_CONNECT
, buf
, s
, MilterConnectMacros
,
3936 e
, state
, "connect", false);
3937 sm_free(buf
); /* XXX */
3940 ** If this message connection is done for,
3941 ** close the filters.
3944 if (*state
!= SMFIR_CONTINUE
)
3946 if (MilterLogLevel
> 9)
3947 sm_syslog(LOG_INFO
, e
->e_id
, "Milter: connect, ending");
3951 milter_per_connection_check(e
);
3954 ** SMFIR_REPLYCODE can't work with connect due to
3955 ** the requirements of SMTP. Therefore, ignore the
3956 ** reply code text but keep the state it would reflect.
3959 if (*state
== SMFIR_REPLYCODE
)
3961 if (response
!= NULL
&&
3964 if (strncmp(response
, "421 ", 4) == 0)
3965 *state
= SMFIR_SHUTDOWN
;
3967 *state
= SMFIR_TEMPFAIL
;
3970 *state
= SMFIR_REJECT
;
3971 if (response
!= NULL
)
3973 sm_free(response
); /* XXX */
3981 ** MILTER_HELO -- send SMTP HELO/EHLO command info to milter filters
3984 ** helo -- argument to SMTP HELO/EHLO command.
3985 ** e -- current envelope.
3986 ** state -- return state from response.
3989 ** response string (may be NULL)
3993 milter_helo(helo
, e
, state
)
4002 sm_dprintf("milter_helo(%s)\n", helo
);
4004 /* HELO/EHLO can come at any point */
4005 for (i
= 0; InputFilters
[i
] != NULL
; i
++)
4007 struct milter
*m
= InputFilters
[i
];
4009 switch (m
->mf_state
)
4012 /* abort in message filters */
4013 milter_abort_filter(m
, e
);
4017 /* reset done filters */
4018 m
->mf_state
= SMFS_OPEN
;
4023 response
= milter_command(SMFIC_HELO
, helo
, strlen(helo
) + 1,
4024 MilterHeloMacros
, e
, state
, "helo", false);
4025 milter_per_connection_check(e
);
4030 ** MILTER_ENVFROM -- send SMTP MAIL command info to milter filters
4033 ** args -- SMTP MAIL command args (args[0] == sender).
4034 ** e -- current envelope.
4035 ** state -- return state from response.
4038 ** response string (may be NULL)
4042 milter_envfrom(args
, e
, state
)
4054 sm_dprintf("milter_envfrom:");
4055 for (i
= 0; args
[i
] != NULL
; i
++)
4056 sm_dprintf(" %s", args
[i
]);
4061 if (args
[0] == NULL
)
4063 *state
= SMFIR_REJECT
;
4064 if (MilterLogLevel
> 10)
4065 sm_syslog(LOG_INFO
, e
->e_id
,
4066 "Milter: reject, no sender");
4070 /* new message, so ... */
4071 for (i
= 0; InputFilters
[i
] != NULL
; i
++)
4073 struct milter
*m
= InputFilters
[i
];
4075 switch (m
->mf_state
)
4078 /* abort in message filters */
4079 milter_abort_filter(m
, e
);
4083 /* reset done filters */
4084 m
->mf_state
= SMFS_OPEN
;
4089 /* put together data */
4091 for (i
= 0; args
[i
] != NULL
; i
++)
4092 s
+= strlen(args
[i
]) + 1;
4096 *state
= SMFIR_TEMPFAIL
;
4100 buf
= (char *) xalloc(s
);
4102 for (i
= 0; args
[i
] != NULL
; i
++)
4104 (void) sm_strlcpy(bp
, args
[i
], s
- (bp
- buf
));
4105 bp
+= strlen(bp
) + 1;
4108 if (MilterLogLevel
> 14)
4109 sm_syslog(LOG_INFO
, e
->e_id
, "Milter: sender: %s", buf
);
4112 response
= milter_command(SMFIC_MAIL
, buf
, s
, MilterEnvFromMacros
,
4113 e
, state
, "mail", false);
4114 sm_free(buf
); /* XXX */
4117 ** If filter rejects/discards a per message command,
4118 ** abort the other filters since we are done with the
4122 MILTER_CHECK_DONE_MSG();
4123 if (MilterLogLevel
> 10 && *state
== SMFIR_REJECT
)
4124 sm_syslog(LOG_INFO
, e
->e_id
, "Milter: reject, sender");
4129 ** MILTER_ENVRCPT -- send SMTP RCPT command info to milter filters
4132 ** args -- SMTP MAIL command args (args[0] == recipient).
4133 ** e -- current envelope.
4134 ** state -- return state from response.
4135 ** rcpt_error -- does RCPT have an error?
4138 ** response string (may be NULL)
4142 milter_envrcpt(args
, e
, state
, rcpt_error
)
4155 sm_dprintf("milter_envrcpt:");
4156 for (i
= 0; args
[i
] != NULL
; i
++)
4157 sm_dprintf(" %s", args
[i
]);
4162 if (args
[0] == NULL
)
4164 *state
= SMFIR_REJECT
;
4165 if (MilterLogLevel
> 10)
4166 sm_syslog(LOG_INFO
, e
->e_id
, "Milter: reject, no rcpt");
4170 /* put together data */
4172 for (i
= 0; args
[i
] != NULL
; i
++)
4173 s
+= strlen(args
[i
]) + 1;
4177 *state
= SMFIR_TEMPFAIL
;
4181 buf
= (char *) xalloc(s
);
4183 for (i
= 0; args
[i
] != NULL
; i
++)
4185 (void) sm_strlcpy(bp
, args
[i
], s
- (bp
- buf
));
4186 bp
+= strlen(bp
) + 1;
4189 if (MilterLogLevel
> 14)
4190 sm_syslog(LOG_INFO
, e
->e_id
, "Milter: rcpts: %s", buf
);
4193 response
= milter_command(SMFIC_RCPT
, buf
, s
, MilterEnvRcptMacros
,
4194 e
, state
, "rcpt", rcpt_error
);
4195 sm_free(buf
); /* XXX */
4200 ** MILTER_DATA_CMD -- send SMTP DATA command info to milter filters
4203 ** e -- current envelope.
4204 ** state -- return state from response.
4207 ** response string (may be NULL)
4211 milter_data_cmd(e
, state
)
4216 sm_dprintf("milter_data_cmd\n");
4219 return milter_command(SMFIC_DATA
, NULL
, 0, MilterDataMacros
, e
, state
,
4224 ** MILTER_DATA -- send message headers/body and gather final message results
4227 ** e -- current envelope.
4228 ** state -- return state from response.
4231 ** response string (may be NULL)
4234 ** - Uses e->e_dfp for access to the body
4235 ** - Can call the various milter action routines to
4236 ** modify the envelope or message.
4239 # define MILTER_CHECK_RESULTS() \
4240 if (*state == SMFIR_ACCEPT || \
4241 m->mf_state == SMFS_DONE || \
4242 m->mf_state == SMFS_ERROR) \
4244 if (m->mf_state != SMFS_ERROR) \
4245 m->mf_state = SMFS_DONE; \
4246 continue; /* to next filter */ \
4248 if (*state != SMFIR_CONTINUE) \
4250 m->mf_state = SMFS_DONE; \
4255 milter_data(e
, state
)
4259 bool replbody
= false; /* milter_replbody() called? */
4260 bool replfailed
= false; /* milter_replbody() failed? */
4261 bool rewind
= false; /* rewind data file? */
4262 bool dfopen
= false; /* data file open for writing? */
4263 bool newfilter
; /* reset on each new filter */
4267 char *response
= NULL
;
4272 sm_dprintf("milter_data\n");
4274 *state
= SMFIR_CONTINUE
;
4277 ** XXX: Should actually send body chunks to each filter
4278 ** a chunk at a time instead of sending the whole body to
4279 ** each filter in turn. However, only if the filters don't
4283 for (i
= 0; InputFilters
[i
] != NULL
; i
++)
4285 struct milter
*m
= InputFilters
[i
];
4287 if (*state
!= SMFIR_CONTINUE
&&
4288 *state
!= SMFIR_ACCEPT
)
4291 ** A previous filter has dealt with the message,
4292 ** safe to stop processing the filters.
4298 /* Now reset state for later evaluation */
4299 *state
= SMFIR_CONTINUE
;
4302 /* previous problem? */
4303 if (m
->mf_state
== SMFS_ERROR
)
4305 MILTER_CHECK_ERROR(false, continue);
4310 if (m
->mf_sock
< 0 ||
4311 (m
->mf_state
!= SMFS_OPEN
&& m
->mf_state
!= SMFS_INMSG
))
4314 m
->mf_state
= SMFS_INMSG
;
4316 /* check if filter wants the headers */
4317 if (!bitset(SMFIP_NOHDRS
, m
->mf_pflags
))
4319 response
= milter_headers(m
, e
, state
);
4320 MILTER_CHECK_RESULTS();
4323 /* check if filter wants EOH */
4324 if (!bitset(SMFIP_NOEOH
, m
->mf_pflags
))
4327 sm_dprintf("milter_data: eoh\n");
4329 if (MilterEOHMacros
[0] != NULL
)
4331 milter_send_macros(m
, MilterEOHMacros
,
4333 MILTER_CHECK_RESULTS();
4337 response
= milter_send_command(m
, SMFIC_EOH
, NULL
, 0,
4339 MILTER_CHECK_RESULTS();
4342 /* check if filter wants the body */
4343 if (!bitset(SMFIP_NOBODY
, m
->mf_pflags
) &&
4347 response
= milter_body(m
, e
, state
);
4348 MILTER_CHECK_RESULTS();
4351 if (MilterEOMMacros
[0] != NULL
)
4353 milter_send_macros(m
, MilterEOMMacros
,
4355 MILTER_CHECK_RESULTS();
4358 /* send the final body chunk */
4359 (void) milter_write(m
, SMFIC_BODYEOB
, NULL
, 0,
4360 m
->mf_timeout
[SMFTO_WRITE
], e
, "eom");
4362 /* Get time EOM sent for timeout */
4363 eomsent
= curtime();
4365 /* deal with the possibility of multiple responses */
4366 while (*state
== SMFIR_CONTINUE
)
4368 /* Check total timeout from EOM to final ACK/NAK */
4369 if (m
->mf_timeout
[SMFTO_EOM
] > 0 &&
4370 curtime() - eomsent
>= m
->mf_timeout
[SMFTO_EOM
])
4373 sm_dprintf("milter_data(%s): EOM ACK/NAK timeout\n",
4375 if (MilterLogLevel
> 0)
4376 sm_syslog(LOG_ERR
, e
->e_id
,
4377 "milter_data(%s): EOM ACK/NAK timeout",
4380 MILTER_CHECK_ERROR(false, break);
4384 response
= milter_read(m
, &rcmd
, &rlen
,
4385 m
->mf_timeout
[SMFTO_READ
], e
,
4387 if (m
->mf_state
== SMFS_ERROR
)
4391 sm_dprintf("milter_data(%s): state %c\n",
4392 m
->mf_name
, (char) rcmd
);
4396 case SMFIR_REPLYCODE
:
4397 MILTER_CHECK_REPLYCODE("554 5.7.1 Command rejected");
4398 if (MilterLogLevel
> 12)
4399 sm_syslog(LOG_INFO
, e
->e_id
, "milter=%s, reject=%s",
4400 m
->mf_name
, response
);
4402 m
->mf_state
= SMFS_DONE
;
4405 case SMFIR_REJECT
: /* log msg at end of function */
4406 if (MilterLogLevel
> 12)
4407 sm_syslog(LOG_INFO
, e
->e_id
, "milter=%s, reject",
4410 m
->mf_state
= SMFS_DONE
;
4414 if (MilterLogLevel
> 12)
4415 sm_syslog(LOG_INFO
, e
->e_id
, "milter=%s, discard",
4418 m
->mf_state
= SMFS_DONE
;
4421 case SMFIR_TEMPFAIL
:
4422 if (MilterLogLevel
> 12)
4423 sm_syslog(LOG_INFO
, e
->e_id
, "milter=%s, tempfail",
4426 m
->mf_state
= SMFS_DONE
;
4429 case SMFIR_CONTINUE
:
4431 /* this filter is done with message */
4433 *state
= SMFIR_TEMPFAIL
;
4435 *state
= SMFIR_ACCEPT
;
4436 m
->mf_state
= SMFS_DONE
;
4439 case SMFIR_PROGRESS
:
4442 case SMFIR_QUARANTINE
:
4443 if (!bitset(SMFIF_QUARANTINE
, m
->mf_fflags
))
4445 if (MilterLogLevel
> 9)
4446 sm_syslog(LOG_WARNING
, e
->e_id
,
4447 "milter_data(%s): lied about quarantining, honoring request anyway",
4450 if (response
== NULL
)
4451 response
= newstr("");
4452 if (MilterLogLevel
> 3)
4453 sm_syslog(LOG_INFO
, e
->e_id
,
4454 "milter=%s, quarantine=%s",
4455 m
->mf_name
, response
);
4456 e
->e_quarmsg
= sm_rpool_strdup_x(e
->e_rpool
,
4458 macdefine(&e
->e_macro
, A_PERM
,
4459 macid("{quarantine}"), e
->e_quarmsg
);
4462 case SMFIR_ADDHEADER
:
4463 if (!bitset(SMFIF_ADDHDRS
, m
->mf_fflags
))
4465 if (MilterLogLevel
> 9)
4466 sm_syslog(LOG_WARNING
, e
->e_id
,
4467 "milter_data(%s): lied about adding headers, honoring request anyway",
4470 milter_addheader(m
, response
, rlen
, e
);
4473 case SMFIR_INSHEADER
:
4474 if (!bitset(SMFIF_ADDHDRS
, m
->mf_fflags
))
4476 if (MilterLogLevel
> 9)
4477 sm_syslog(LOG_WARNING
, e
->e_id
,
4478 "milter_data(%s): lied about adding headers, honoring request anyway",
4481 milter_insheader(m
, response
, rlen
, e
);
4484 case SMFIR_CHGHEADER
:
4485 if (!bitset(SMFIF_CHGHDRS
, m
->mf_fflags
))
4487 if (MilterLogLevel
> 9)
4488 sm_syslog(LOG_WARNING
, e
->e_id
,
4489 "milter_data(%s): lied about changing headers, honoring request anyway",
4492 milter_changeheader(m
, response
, rlen
, e
);
4496 if (!bitset(SMFIF_CHGFROM
, m
->mf_fflags
))
4498 if (MilterLogLevel
> 9)
4499 sm_syslog(LOG_WARNING
, e
->e_id
,
4500 "milter_data(%s) lied about changing sender, honoring request anyway",
4503 milter_chgfrom(response
, rlen
, e
);
4507 if (!bitset(SMFIF_ADDRCPT
, m
->mf_fflags
))
4509 if (MilterLogLevel
> 9)
4510 sm_syslog(LOG_WARNING
, e
->e_id
,
4511 "milter_data(%s) lied about adding recipients, honoring request anyway",
4514 milter_addrcpt(response
, rlen
, e
);
4517 case SMFIR_ADDRCPT_PAR
:
4518 if (!bitset(SMFIF_ADDRCPT_PAR
, m
->mf_fflags
))
4520 if (MilterLogLevel
> 9)
4521 sm_syslog(LOG_WARNING
, e
->e_id
,
4522 "milter_data(%s) lied about adding recipients with parameters, honoring request anyway",
4525 milter_addrcpt_par(response
, rlen
, e
);
4529 if (!bitset(SMFIF_DELRCPT
, m
->mf_fflags
))
4531 if (MilterLogLevel
> 9)
4532 sm_syslog(LOG_WARNING
, e
->e_id
,
4533 "milter_data(%s): lied about removing recipients, honoring request anyway",
4536 milter_delrcpt(response
, rlen
, e
);
4539 case SMFIR_REPLBODY
:
4540 if (!bitset(SMFIF_MODBODY
, m
->mf_fflags
))
4542 if (MilterLogLevel
> 0)
4543 sm_syslog(LOG_ERR
, e
->e_id
,
4544 "milter_data(%s): lied about replacing body, rejecting request and tempfailing message",
4550 /* already failed in attempt */
4556 if (milter_reopen_df(e
) < 0)
4565 if (milter_replbody(response
, rlen
,
4573 /* Invalid response to command */
4574 if (MilterLogLevel
> 0)
4575 sm_syslog(LOG_ERR
, e
->e_id
,
4576 "milter_data(%s): returned bogus response %c",
4581 if (rcmd
!= SMFIR_REPLYCODE
&& response
!= NULL
)
4583 sm_free(response
); /* XXX */
4587 if (m
->mf_state
== SMFS_ERROR
)
4591 if (replbody
&& !replfailed
)
4593 /* flush possible buffered character */
4594 milter_replbody(NULL
, 0, !replbody
, e
);
4598 if (m
->mf_state
== SMFS_ERROR
)
4600 MILTER_CHECK_ERROR(false, continue);
4606 /* leave things in the expected state if we touched it */
4609 if (*state
== SMFIR_CONTINUE
||
4610 *state
== SMFIR_ACCEPT
)
4612 *state
= SMFIR_TEMPFAIL
;
4613 SM_FREE_CLR(response
);
4618 (void) sm_io_close(e
->e_dfp
, SM_TIME_DEFAULT
);
4620 e
->e_flags
&= ~EF_HAS_DF
;
4626 if ((dfopen
&& milter_reset_df(e
) < 0) ||
4627 (rewind
&& bfrewind(e
->e_dfp
) < 0))
4630 ExitStat
= EX_IOERR
;
4633 ** If filter told us to keep message but we had
4634 ** an error, we can't really keep it, tempfail it.
4637 if (*state
== SMFIR_CONTINUE
||
4638 *state
== SMFIR_ACCEPT
)
4640 *state
= SMFIR_TEMPFAIL
;
4641 SM_FREE_CLR(response
);
4645 syserr("milter_data: %s/%cf%s: read error",
4646 qid_printqueue(e
->e_qgrp
, e
->e_qdir
),
4647 DATAFL_LETTER
, e
->e_id
);
4650 MILTER_CHECK_DONE_MSG();
4651 if (MilterLogLevel
> 10 && *state
== SMFIR_REJECT
)
4652 sm_syslog(LOG_INFO
, e
->e_id
, "Milter: reject, data");
4657 ** MILTER_UNKNOWN -- send any unrecognized or unimplemented command
4658 ** string to milter filters
4661 ** smtpcmd -- the string itself.
4662 ** e -- current envelope.
4663 ** state -- return state from response.
4667 ** response string (may be NULL)
4671 milter_unknown(smtpcmd
, e
, state
)
4677 sm_dprintf("milter_unknown(%s)\n", smtpcmd
);
4679 return milter_command(SMFIC_UNKNOWN
, smtpcmd
, strlen(smtpcmd
) + 1,
4680 NULL
, e
, state
, "unknown", false);
4684 ** MILTER_QUIT -- informs the filter(s) we are done and closes connection(s)
4687 ** e -- current envelope.
4700 sm_dprintf("milter_quit(%s)\n", e
->e_id
);
4702 for (i
= 0; InputFilters
[i
] != NULL
; i
++)
4703 milter_quit_filter(InputFilters
[i
], e
);
4707 ** MILTER_ABORT -- informs the filter(s) that we are aborting current message
4710 ** e -- current envelope.
4723 sm_dprintf("milter_abort\n");
4725 for (i
= 0; InputFilters
[i
] != NULL
; i
++)
4727 struct milter
*m
= InputFilters
[i
];
4730 if (m
->mf_sock
< 0 || m
->mf_state
!= SMFS_INMSG
)
4733 milter_abort_filter(m
, e
);