#include <sys_defs.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <limits.h>
#ifndef SHUT_RDWR
#define SHUT_RDWR 2
#endif
#include <msg.h>
#include <mymalloc.h>
#include <split_at.h>
#include <connect.h>
#include <argv.h>
#include <name_mask.h>
#include <name_code.h>
#include <stringops.h>
#include <mail_params.h>
#include <mail_proto.h>
#include <rec_type.h>
#include <record.h>
#include <mime_state.h>
#include <is_header.h>
#include <milter.h>
#define SMFIC_ABORT 'A'
#define SMFIC_BODY 'B'
#define SMFIC_CONNECT 'C'
#define SMFIC_MACRO 'D'
#define SMFIC_BODYEOB 'E'
#define SMFIC_HELO 'H'
#define SMFIC_HEADER 'L'
#define SMFIC_MAIL 'M'
#define SMFIC_EOH 'N'
#define SMFIC_OPTNEG 'O'
#define SMFIC_QUIT 'Q'
#define SMFIC_RCPT 'R'
#define SMFIC_DATA 'T'
#define SMFIC_UNKNOWN 'U'
#define SMFIC_QUIT_NC 'K'
static const NAME_CODE smfic_table[] = {
"SMFIC_ABORT", SMFIC_ABORT,
"SMFIC_BODY", SMFIC_BODY,
"SMFIC_CONNECT", SMFIC_CONNECT,
"SMFIC_MACRO", SMFIC_MACRO,
"SMFIC_BODYEOB", SMFIC_BODYEOB,
"SMFIC_HELO", SMFIC_HELO,
"SMFIC_HEADER", SMFIC_HEADER,
"SMFIC_MAIL", SMFIC_MAIL,
"SMFIC_EOH", SMFIC_EOH,
"SMFIC_OPTNEG", SMFIC_OPTNEG,
"SMFIC_QUIT", SMFIC_QUIT,
"SMFIC_RCPT", SMFIC_RCPT,
"SMFIC_DATA", SMFIC_DATA,
"SMFIC_UNKNOWN", SMFIC_UNKNOWN,
"SMFIC_QUIT_NC", SMFIC_QUIT_NC,
0, 0,
};
#define SMFIR_ADDRCPT '+'
#define SMFIR_DELRCPT '-'
#define SMFIR_ACCEPT 'a'
#define SMFIR_REPLBODY 'b'
#define SMFIR_CONTINUE 'c'
#define SMFIR_DISCARD 'd'
#define SMFIR_CONN_FAIL 'f'
#define SMFIR_CHGHEADER 'm'
#define SMFIR_PROGRESS 'p'
#define SMFIR_REJECT 'r'
#define SMFIR_TEMPFAIL 't'
#define SMFIR_SHUTDOWN '4'
#define SMFIR_ADDHEADER 'h'
#define SMFIR_INSHEADER 'i'
#define SMFIR_REPLYCODE 'y'
#define SMFIR_QUARANTINE 'q'
#define SMFIR_SKIP 's'
#define SMFIR_CHGFROM 'e'
#define SMFIR_ADDRCPT_PAR '2'
#define SMFIR_SETSYMLIST 'l'
static const NAME_CODE smfir_table[] = {
"SMFIR_ADDRCPT", SMFIR_ADDRCPT,
"SMFIR_DELRCPT", SMFIR_DELRCPT,
"SMFIR_ACCEPT", SMFIR_ACCEPT,
"SMFIR_REPLBODY", SMFIR_REPLBODY,
"SMFIR_CONTINUE", SMFIR_CONTINUE,
"SMFIR_DISCARD", SMFIR_DISCARD,
"SMFIR_CONN_FAIL", SMFIR_CONN_FAIL,
"SMFIR_CHGHEADER", SMFIR_CHGHEADER,
"SMFIR_PROGRESS", SMFIR_PROGRESS,
"SMFIR_REJECT", SMFIR_REJECT,
"SMFIR_TEMPFAIL", SMFIR_TEMPFAIL,
"SMFIR_SHUTDOWN", SMFIR_SHUTDOWN,
"SMFIR_ADDHEADER", SMFIR_ADDHEADER,
"SMFIR_INSHEADER", SMFIR_INSHEADER,
"SMFIR_REPLYCODE", SMFIR_REPLYCODE,
"SMFIR_QUARANTINE", SMFIR_QUARANTINE,
"SMFIR_SKIP", SMFIR_SKIP,
"SMFIR_CHGFROM", SMFIR_CHGFROM,
"SMFIR_ADDRCPT_PAR", SMFIR_ADDRCPT_PAR,
"SMFIR_SETSYMLIST", SMFIR_SETSYMLIST,
0, 0,
};
#define SMFIP_NOCONNECT (1L<<0)
#define SMFIP_NOHELO (1L<<1)
#define SMFIP_NOMAIL (1L<<2)
#define SMFIP_NORCPT (1L<<3)
#define SMFIP_NOBODY (1L<<4)
#define SMFIP_NOHDRS (1L<<5)
#define SMFIP_NOEOH (1L<<6)
#define SMFIP_NR_HDR (1L<<7)
#define SMFIP_NOHREPL SMFIP_NR_HDR
#define SMFIP_NOUNKNOWN (1L<<8)
#define SMFIP_NODATA (1L<<9)
#define SMFIP_SKIP (1L<<10)
#define SMFIP_RCPT_REJ (1L<<11)
#define SMFIP_NR_CONN (1L<<12)
#define SMFIP_NR_HELO (1L<<13)
#define SMFIP_NR_MAIL (1L<<14)
#define SMFIP_NR_RCPT (1L<<15)
#define SMFIP_NR_DATA (1L<<16)
#define SMFIP_NR_UNKN (1L<<17)
#define SMFIP_NR_EOH (1L<<18)
#define SMFIP_NR_BODY (1L<<19)
#define SMFIP_HDR_LEADSPC (1L<<20)
#define SMFIP_NOSEND_MASK \
(SMFIP_NOCONNECT | SMFIP_NOHELO | SMFIP_NOMAIL | SMFIP_NORCPT \
| SMFIP_NOBODY | SMFIP_NOHDRS | SMFIP_NOEOH | SMFIP_NOUNKNOWN \
| SMFIP_NODATA)
#define SMFIP_NOREPLY_MASK \
(SMFIP_NR_CONN | SMFIP_NR_HELO | SMFIP_NR_MAIL | SMFIP_NR_RCPT \
| SMFIP_NR_DATA | SMFIP_NR_UNKN | SMFIP_NR_HDR | SMFIP_NR_EOH | \
SMFIP_NR_BODY)
static const NAME_MASK smfip_table[] = {
"SMFIP_NOCONNECT", SMFIP_NOCONNECT,
"SMFIP_NOHELO", SMFIP_NOHELO,
"SMFIP_NOMAIL", SMFIP_NOMAIL,
"SMFIP_NORCPT", SMFIP_NORCPT,
"SMFIP_NOBODY", SMFIP_NOBODY,
"SMFIP_NOHDRS", SMFIP_NOHDRS,
"SMFIP_NOEOH", SMFIP_NOEOH,
"SMFIP_NR_HDR", SMFIP_NR_HDR,
"SMFIP_NOUNKNOWN", SMFIP_NOUNKNOWN,
"SMFIP_NODATA", SMFIP_NODATA,
"SMFIP_SKIP", SMFIP_SKIP,
"SMFIP_RCPT_REJ", SMFIP_RCPT_REJ,
"SMFIP_NR_CONN", SMFIP_NR_CONN,
"SMFIP_NR_HELO", SMFIP_NR_HELO,
"SMFIP_NR_MAIL", SMFIP_NR_MAIL,
"SMFIP_NR_RCPT", SMFIP_NR_RCPT,
"SMFIP_NR_DATA", SMFIP_NR_DATA,
"SMFIP_NR_UNKN", SMFIP_NR_UNKN,
"SMFIP_NR_EOH", SMFIP_NR_EOH,
"SMFIP_NR_BODY", SMFIP_NR_BODY,
"SMFIP_HDR_LEADSPC", SMFIP_HDR_LEADSPC,
0, 0,
};
#define SMFIF_ADDHDRS (1L<<0)
#define SMFIF_CHGBODY (1L<<1)
#define SMFIF_ADDRCPT (1L<<2)
#define SMFIF_DELRCPT (1L<<3)
#define SMFIF_CHGHDRS (1L<<4)
#define SMFIF_QUARANTINE (1L<<5)
#define SMFIF_CHGFROM (1L<<6)
#define SMFIF_ADDRCPT_PAR (1L<<7)
#define SMFIF_SETSYMLIST (1L<<8)
static const NAME_MASK smfif_table[] = {
"SMFIF_ADDHDRS", SMFIF_ADDHDRS,
"SMFIF_CHGBODY", SMFIF_CHGBODY,
"SMFIF_ADDRCPT", SMFIF_ADDRCPT,
"SMFIF_DELRCPT", SMFIF_DELRCPT,
"SMFIF_CHGHDRS", SMFIF_CHGHDRS,
"SMFIF_QUARANTINE", SMFIF_QUARANTINE,
"SMFIF_CHGFROM", SMFIF_CHGFROM,
"SMFIF_ADDRCPT_PAR", SMFIF_ADDRCPT_PAR,
"SMFIF_SETSYMLIST", SMFIF_SETSYMLIST,
0, 0,
};
#define SMFIA_UNKNOWN 'U'
#define SMFIA_UNIX 'L'
#define SMFIA_INET '4'
#define SMFIA_INET6 '6'
#define SMFIM_CONNECT 0
#define SMFIM_HELO 1
#define SMFIM_ENVFROM 2
#define SMFIM_ENVRCPT 3
#define SMFIM_DATA 4
#define SMFIM_EOM 5
#define SMFIM_EOH 6
static const NAME_CODE smfim_table[] = {
"SMFIM_CONNECT", SMFIM_CONNECT,
"SMFIM_HELO", SMFIM_HELO,
"SMFIM_ENVFROM", SMFIM_ENVFROM,
"SMFIM_ENVRCPT", SMFIM_ENVRCPT,
"SMFIM_DATA", SMFIM_DATA,
"SMFIM_EOM", SMFIM_EOM,
"SMFIM_EOH", SMFIM_EOH,
0, 0,
};
static const size_t milter8_macro_offsets[] = {
offsetof(MILTER_MACROS, conn_macros),
offsetof(MILTER_MACROS, helo_macros),
offsetof(MILTER_MACROS, mail_macros),
offsetof(MILTER_MACROS, rcpt_macros),
offsetof(MILTER_MACROS, data_macros),
offsetof(MILTER_MACROS, eod_macros),
offsetof(MILTER_MACROS, eoh_macros),
};
#define MILTER8_MACRO_PTR(__macros, __class) \
((char **) (((char *) (__macros)) + milter8_macro_offsets[(__class)]))
#define MILTER_CHUNK_SIZE 65535
typedef struct {
MILTER m;
int conn_timeout;
int cmd_timeout;
int msg_timeout;
char *protocol;
char *def_action;
int version;
int rq_mask;
int ev_mask;
int np_mask;
VSTRING *buf;
VSTRING *body;
VSTREAM *fp;
int state;
char *def_reply;
int skip_event_type;
} MILTER8;
#define LIBMILTER_AUTO_DISCONNECT
#define MILTER8_STAT_ERROR 1
#define MILTER8_STAT_CLOSED 2
#define MILTER8_STAT_READY 3
#define MILTER8_STAT_ENVELOPE 4
#define MILTER8_STAT_MESSAGE 5
#define MILTER8_STAT_ACCEPT_CON 6
#define MILTER8_STAT_ACCEPT_MSG 7
#define MILTER8_STAT_REJECT_CON 8
#define MILTER8_DATA_END 0
#define MILTER8_DATA_HLONG 1
#define MILTER8_DATA_BUFFER 2
#define MILTER8_DATA_STRING 3
#define MILTER8_DATA_NSHORT 4
#define MILTER8_DATA_ARGV 5
#define MILTER8_DATA_OCTET 6
#define MILTER8_DATA_MORE 7
#define XXX_MAX_DATA (INT_MAX / 2)
#define XXX_TIMEOUT 10
#define MILTER8_V2_PROTO_MASK \
(SMFIP_NOCONNECT | SMFIP_NOHELO | SMFIP_NOMAIL | SMFIP_NORCPT | \
SMFIP_NOBODY | SMFIP_NOHDRS | SMFIP_NOEOH)
#define MILTER8_V3_PROTO_MASK (MILTER8_V2_PROTO_MASK | SMFIP_NOUNKNOWN)
#define MILTER8_V4_PROTO_MASK (MILTER8_V3_PROTO_MASK | SMFIP_NODATA)
#define MILTER8_V6_PROTO_MASK \
(MILTER8_V4_PROTO_MASK | SMFIP_SKIP | SMFIP_RCPT_REJ \
| SMFIP_NOREPLY_MASK | SMFIP_HDR_LEADSPC)
static const NAME_CODE milter8_event_masks[] = {
"6", MILTER8_V6_PROTO_MASK,
"4", MILTER8_V4_PROTO_MASK,
"3", MILTER8_V3_PROTO_MASK,
"2", MILTER8_V2_PROTO_MASK,
"no_header_reply", SMFIP_NOHREPL,
0, -1,
};
static const NAME_CODE milter8_versions[] = {
"2", 2,
"3", 3,
"4", 4,
"6", 6,
"no_header_reply", 0,
0, -1,
};
#define STR(x) vstring_str(x)
#define LEN(x) VSTRING_LEN(x)
static const char *milter8_def_reply(MILTER8 *milter, const char *reply)
{
if (milter->def_reply)
myfree(milter->def_reply);
milter->def_reply = reply ? mystrdup(reply) : 0;
return (milter->def_reply);
}
static int milter8_conf_error(MILTER8 *milter)
{
const char *reply;
if (milter->fp != 0) {
(void) shutdown(vstream_fileno(milter->fp), SHUT_RDWR);
(void) vstream_fclose(milter->fp);
milter->fp = 0;
}
if (strcasecmp(milter->def_action, "accept") == 0) {
reply = 0;
} else if (strcasecmp(milter->def_action, "quarantine") == 0) {
reply = "H";
} else {
reply = "451 4.3.5 Server configuration problem - try again later";
}
milter8_def_reply(milter, reply);
return (milter->state = MILTER8_STAT_ERROR);
}
static int milter8_comm_error(MILTER8 *milter)
{
const char *reply;
if (milter->fp != 0) {
(void) shutdown(vstream_fileno(milter->fp), SHUT_RDWR);
(void) vstream_fclose(milter->fp);
milter->fp = 0;
}
if (strcasecmp(milter->def_action, "accept") == 0) {
reply = 0;
} else if (strcasecmp(milter->def_action, "reject") == 0) {
reply = "550 5.5.0 Service unavailable";
} else if (strcasecmp(milter->def_action, "tempfail") == 0) {
reply = "451 4.7.1 Service unavailable - try again later";
} else if (strcasecmp(milter->def_action, "quarantine") == 0) {
reply = "H";
} else {
msg_warn("milter %s: unrecognized default action: %s",
milter->m.name, milter->def_action);
reply = "451 4.3.5 Server configuration problem - try again later";
}
milter8_def_reply(milter, reply);
return (milter->state = MILTER8_STAT_ERROR);
}
static void milter8_close_stream(MILTER8 *milter)
{
if (milter->fp != 0) {
(void) vstream_fclose(milter->fp);
milter->fp = 0;
}
milter->state = MILTER8_STAT_CLOSED;
}
static int milter8_read_resp(MILTER8 *milter, int event, unsigned char *command,
ssize_t *data_len)
{
UINT32_TYPE len;
ssize_t pkt_len;
const char *smfic_name;
int cmd;
if ((vstream_fread(milter->fp, (char *) &len, UINT32_SIZE))
!= UINT32_SIZE) {
smfic_name = str_name_code(smfic_table, event);
msg_warn("milter %s: can't read %s reply packet header: %m",
milter->m.name, smfic_name != 0 ?
smfic_name : "(unknown MTA event)");
return (milter8_comm_error(milter));
} else if ((pkt_len = ntohl(len)) < 1) {
msg_warn("milter %s: bad packet length: %ld",
milter->m.name, (long) pkt_len);
return (milter8_comm_error(milter));
} else if (pkt_len > XXX_MAX_DATA) {
msg_warn("milter %s: unreasonable packet length: %ld > %ld",
milter->m.name, (long) pkt_len, (long) XXX_MAX_DATA);
return (milter8_comm_error(milter));
}
else if ((cmd = VSTREAM_GETC(milter->fp)) == VSTREAM_EOF) {
msg_warn("milter %s: EOF while reading command code: %m",
milter->m.name);
return (milter8_comm_error(milter));
}
else {
*command = cmd;
*data_len = pkt_len - 1;
return (0);
}
}
static int milter8_read_data(MILTER8 *milter, ssize_t *data_len,...);
static int vmilter8_read_data(MILTER8 *milter, ssize_t *data_len, va_list ap)
{
const char *myname = "milter8_read_data";
int arg_type;
UINT32_TYPE net_long;
UINT32_TYPE *host_long_ptr;
VSTRING *buf;
int ch;
while ((arg_type = va_arg(ap, int)) > 0 && arg_type != MILTER8_DATA_MORE) {
switch (arg_type) {
case MILTER8_DATA_HLONG:
if (*data_len < UINT32_SIZE) {
msg_warn("milter %s: input packet too short for network long",
milter->m.name);
return (milter8_comm_error(milter));
}
host_long_ptr = va_arg(ap, UINT32_TYPE *);
if (vstream_fread(milter->fp, (char *) &net_long, UINT32_SIZE)
!= UINT32_SIZE) {
msg_warn("milter %s: EOF while reading network long: %m",
milter->m.name);
return (milter8_comm_error(milter));
}
*data_len -= UINT32_SIZE;
*host_long_ptr = ntohl(net_long);
break;
case MILTER8_DATA_BUFFER:
if (*data_len < 0) {
msg_warn("milter %s: no data in input packet", milter->m.name);
return (milter8_comm_error(milter));
}
buf = va_arg(ap, VSTRING *);
VSTRING_RESET(buf);
VSTRING_SPACE(buf, *data_len);
if (vstream_fread(milter->fp, (char *) STR(buf), *data_len)
!= *data_len) {
msg_warn("milter %s: EOF while reading data: %m", milter->m.name);
return (milter8_comm_error(milter));
}
VSTRING_AT_OFFSET(buf, *data_len);
*data_len = 0;
break;
case MILTER8_DATA_STRING:
if (*data_len < 1) {
msg_warn("milter %s: packet too short for string",
milter->m.name);
return (milter8_comm_error(milter));
}
buf = va_arg(ap, VSTRING *);
VSTRING_RESET(buf);
for (;;) {
if ((ch = VSTREAM_GETC(milter->fp)) == VSTREAM_EOF) {
msg_warn("%s: milter %s: EOF while reading string: %m",
myname, milter->m.name);
return (milter8_comm_error(milter));
}
*data_len -= 1;
if (ch == 0)
break;
VSTRING_ADDCH(buf, ch);
if (*data_len <= 0) {
msg_warn("%s: milter %s: missing string null termimator",
myname, milter->m.name);
return (milter8_comm_error(milter));
}
}
VSTRING_TERMINATE(buf);
break;
default:
msg_panic("%s: unknown argument type: %d", myname, arg_type);
}
}
if (arg_type != MILTER8_DATA_MORE && *data_len > 0) {
msg_warn("%s: left-over data %ld bytes", myname, (long) *data_len);
return (milter8_comm_error(milter));
}
if (*data_len < 0)
msg_panic("%s: bad left-over data count %ld",
myname, (long) *data_len);
return (0);
}
static int milter8_read_data(MILTER8 *milter, ssize_t *data_len,...)
{
va_list ap;
int ret;
va_start(ap, data_len);
ret = vmilter8_read_data(milter, data_len, ap);
va_end(ap);
return (ret);
}
static ssize_t vmilter8_size_data(va_list ap)
{
const char *myname = "vmilter8_size_data";
ssize_t data_len;
int arg_type;
VSTRING *buf;
const char *str;
const char **cpp;
for (data_len = 0; (arg_type = va_arg(ap, int)) > 0; ) {
switch (arg_type) {
case MILTER8_DATA_HLONG:
(void) va_arg(ap, UINT32_TYPE);
data_len += UINT32_SIZE;
break;
case MILTER8_DATA_BUFFER:
buf = va_arg(ap, VSTRING *);
data_len += LEN(buf);
break;
case MILTER8_DATA_STRING:
str = va_arg(ap, char *);
data_len += strlen(str) + 1;
break;
case MILTER8_DATA_ARGV:
for (cpp = va_arg(ap, const char **); *cpp; cpp++)
data_len += strlen(*cpp) + 1;
break;
case MILTER8_DATA_NSHORT:
(void) va_arg(ap, unsigned);
data_len += UINT16_SIZE;
break;
case MILTER8_DATA_OCTET:
(void) va_arg(ap, unsigned);
data_len += 1;
break;
default:
msg_panic("%s: bad argument type: %d", myname, arg_type);
}
}
va_end(ap);
return (data_len);
}
static int vmilter8_write_cmd(MILTER8 *milter, int command, ssize_t data_len,
va_list ap)
{
const char *myname = "vmilter8_write_cmd";
int arg_type;
UINT32_TYPE pkt_len;
UINT32_TYPE host_long;
UINT32_TYPE net_long;
UINT16_TYPE net_short;
VSTRING *buf;
const char *str;
const char **cpp;
char ch;
if ((pkt_len = 1 + data_len) < 1)
msg_panic("%s: bad packet length %d", myname, pkt_len);
pkt_len = htonl(pkt_len);
(void) vstream_fwrite(milter->fp, (char *) &pkt_len, UINT32_SIZE);
(void) VSTREAM_PUTC(command, milter->fp);
while ((arg_type = va_arg(ap, int)) > 0) {
switch (arg_type) {
case MILTER8_DATA_HLONG:
host_long = va_arg(ap, UINT32_TYPE);
net_long = htonl(host_long);
(void) vstream_fwrite(milter->fp, (char *) &net_long, UINT32_SIZE);
break;
case MILTER8_DATA_BUFFER:
buf = va_arg(ap, VSTRING *);
(void) vstream_fwrite(milter->fp, STR(buf), LEN(buf));
break;
case MILTER8_DATA_STRING:
str = va_arg(ap, char *);
(void) vstream_fwrite(milter->fp, str, strlen(str) + 1);
break;
case MILTER8_DATA_OCTET:
ch = va_arg(ap, unsigned);
(void) vstream_fwrite(milter->fp, &ch, 1);
break;
case MILTER8_DATA_ARGV:
for (cpp = va_arg(ap, const char **); *cpp; cpp++)
(void) vstream_fwrite(milter->fp, *cpp, strlen(*cpp) + 1);
break;
case MILTER8_DATA_NSHORT:
net_short = va_arg(ap, unsigned);
(void) vstream_fwrite(milter->fp, (char *) &net_short, UINT16_SIZE);
break;
default:
msg_panic("%s: bad argument type: %d", myname, arg_type);
}
if (vstream_ferror(milter->fp)) {
msg_warn("milter %s: error writing command: %m", milter->m.name);
milter8_comm_error(milter);
break;
}
}
va_end(ap);
return (milter->state == MILTER8_STAT_ERROR);
}
static int milter8_write_cmd(MILTER8 *milter, int command,...)
{
va_list ap;
ssize_t data_len;
int err;
va_start(ap, command);
data_len = vmilter8_size_data(ap);
va_end(ap);
va_start(ap, command);
err = vmilter8_write_cmd(milter, command, data_len, ap);
va_end(ap);
return (err);
}
static const char *milter8_event(MILTER8 *milter, int event,
int skip_event_flag,
int skip_reply,
ARGV *macros,...)
{
const char *myname = "milter8_event";
va_list ap;
ssize_t data_len;
int err;
unsigned char cmd;
ssize_t data_size;
const char *smfic_name;
const char *smfir_name;
MILTERS *parent = milter->m.parent;
UINT32_TYPE index;
const char *edit_resp = 0;
const char *retval = 0;
VSTRING *body_line_buf = 0;
int done = 0;
int body_edit_lockout = 0;
#define DONT_SKIP_REPLY 0
if (milter->fp == 0 || milter->def_reply != 0) {
msg_warn("%s: attempt to send event %s to milter %s after error",
myname,
(smfic_name = str_name_code(smfic_table, event)) != 0 ?
smfic_name : "(unknown MTA event)", milter->m.name);
return (milter->def_reply);
}
if ((skip_event_flag & milter->np_mask) != 0) {
if (msg_verbose)
msg_info("skipping non-protocol event %s for milter %s",
(smfic_name = str_name_code(smfic_table, event)) != 0 ?
smfic_name : "(unknown MTA event)", milter->m.name);
return (milter->def_reply);
}
if (milter->skip_event_type != 0) {
if (event == milter->skip_event_type) {
if (msg_verbose)
msg_info("skipping event %s after SMFIR_SKIP from milter %s",
(smfic_name = str_name_code(smfic_table, event)) != 0 ?
smfic_name : "(unknown MTA event)", milter->m.name);
return (milter->def_reply);
} else {
milter->skip_event_type = 0;
}
}
if (msg_verbose) {
VSTRING *buf = vstring_alloc(100);
if (macros) {
if (macros->argc > 0) {
char **cpp;
for (cpp = macros->argv; *cpp && cpp[1]; cpp += 2)
vstring_sprintf_append(buf, " %s=%s", *cpp, cpp[1]);
}
}
msg_info("event: %s; macros:%s",
(smfic_name = str_name_code(smfic_table, event)) != 0 ?
smfic_name : "(unknown MTA event)", *STR(buf) ?
STR(buf) : " (none)");
vstring_free(buf);
}
if (macros) {
if (milter8_write_cmd(milter, SMFIC_MACRO,
MILTER8_DATA_OCTET, event,
MILTER8_DATA_ARGV, macros->argv,
MILTER8_DATA_END) != 0)
return (milter->def_reply);
}
if ((skip_event_flag & milter->ev_mask) != 0) {
if (msg_verbose)
msg_info("skipping event %s for milter %s",
(smfic_name = str_name_code(smfic_table, event)) != 0 ?
smfic_name : "(unknown MTA event)", milter->m.name);
return (milter->def_reply);
}
va_start(ap, macros);
data_len = vmilter8_size_data(ap);
va_end(ap);
va_start(ap, macros);
err = vmilter8_write_cmd(milter, event, data_len, ap);
va_end(ap);
if (err != 0)
return (milter->def_reply);
if (skip_reply) {
if (msg_verbose)
msg_info("skipping reply for event %s from milter %s",
(smfic_name = str_name_code(smfic_table, event)) != 0 ?
smfic_name : "(unknown MTA event)", milter->m.name);
return (milter->def_reply);
}
#define IN_CONNECT_EVENT(e) ((e) == SMFIC_CONNECT || (e) == SMFIC_HELO)
#define MILTER8_EVENT_BREAK(s) { \
retval = (s); \
done = 1; \
continue; \
}
while (done == 0) {
char *cp;
char *rp;
char ch;
char *next;
if (milter8_read_resp(milter, event, &cmd, &data_size) != 0)
MILTER8_EVENT_BREAK(milter->def_reply);
if (msg_verbose)
msg_info("reply: %s data %ld bytes",
(smfir_name = str_name_code(smfir_table, cmd)) != 0 ?
smfir_name : "unknown", (long) data_size);
if (body_line_buf != 0 && cmd != SMFIR_REPLBODY) {
if (edit_resp == 0 && LEN(body_line_buf) > 0)
edit_resp = parent->repl_body(parent->chg_context,
MILTER_BODY_LINE,
body_line_buf);
if (edit_resp == 0)
edit_resp = parent->repl_body(parent->chg_context,
MILTER_BODY_END,
(VSTRING *) 0);
body_edit_lockout = 1;
vstring_free(body_line_buf);
body_line_buf = 0;
}
switch (cmd) {
case SMFIR_PROGRESS:
if (data_size != 0)
break;
continue;
case SMFIR_CONTINUE:
if (data_size != 0)
break;
MILTER8_EVENT_BREAK(milter->def_reply);
case SMFIR_ACCEPT:
if (data_size != 0)
break;
if (IN_CONNECT_EVENT(event)) {
#ifdef LIBMILTER_AUTO_DISCONNECT
milter8_close_stream(milter);
#endif
milter->state = MILTER8_STAT_ACCEPT_CON;
} else {
milter->state = MILTER8_STAT_ACCEPT_MSG;
}
MILTER8_EVENT_BREAK(milter->def_reply);
case SMFIR_DISCARD:
if (data_size != 0)
break;
if (IN_CONNECT_EVENT(event)) {
msg_warn("milter %s: DISCARD action is not allowed "
"for connect or helo", milter->m.name);
MILTER8_EVENT_BREAK(milter->def_reply);
} else {
milter->state = MILTER8_STAT_ACCEPT_MSG;
MILTER8_EVENT_BREAK("D");
}
case SMFIR_REJECT:
if (data_size != 0)
break;
if (IN_CONNECT_EVENT(event)) {
#ifdef LIBMILTER_AUTO_DISCONNECT
milter8_close_stream(milter);
#endif
milter->state = MILTER8_STAT_REJECT_CON;
MILTER8_EVENT_BREAK(milter8_def_reply(milter, "550 5.7.1 Command rejected"));
} else {
MILTER8_EVENT_BREAK("550 5.7.1 Command rejected");
}
case SMFIR_TEMPFAIL:
if (data_size != 0)
break;
if (IN_CONNECT_EVENT(event)) {
#ifdef LIBMILTER_AUTO_DISCONNECT
milter8_close_stream(milter);
#endif
milter->state = MILTER8_STAT_REJECT_CON;
MILTER8_EVENT_BREAK(milter8_def_reply(milter,
"451 4.7.1 Service unavailable - try again later"));
} else {
MILTER8_EVENT_BREAK("451 4.7.1 Service unavailable - try again later");
}
case SMFIR_SHUTDOWN:
if (data_size != 0)
break;
#ifdef LIBMILTER_AUTO_DISCONNECT
milter8_close_stream(milter);
#endif
milter->state = MILTER8_STAT_REJECT_CON;
MILTER8_EVENT_BREAK(milter8_def_reply(milter, "S"));
case SMFIR_REPLYCODE:
if (milter8_read_data(milter, &data_size,
MILTER8_DATA_BUFFER, milter->buf,
MILTER8_DATA_END) != 0)
MILTER8_EVENT_BREAK(milter->def_reply);
if ((STR(milter->buf)[0] != '4' && STR(milter->buf)[0] != '5')
|| !ISDIGIT(STR(milter->buf)[1])
|| !ISDIGIT(STR(milter->buf)[2])
|| (STR(milter->buf)[3] != ' ' && STR(milter->buf)[3] != '-')
|| (ISDIGIT(STR(milter->buf)[4])
&& (STR(milter->buf)[4] != STR(milter->buf)[0]))) {
msg_warn("milter %s: malformed reply: %s",
milter->m.name, STR(milter->buf));
milter8_conf_error(milter);
MILTER8_EVENT_BREAK(milter->def_reply);
}
if ((rp = cp = strchr(STR(milter->buf), '%')) != 0) {
for (;;) {
if ((ch = *cp++) == '%')
ch = *cp++;
*rp++ = ch;
if (ch == 0)
break;
}
}
if (var_soft_bounce) {
for (cp = STR(milter->buf); ; cp = next) {
if (cp[0] == '5') {
cp[0] = '4';
if (cp[4] == '5')
cp[4] = '4';
}
if ((next = strstr(cp, "\r\n")) == 0)
break;
next += 2;
}
}
if (IN_CONNECT_EVENT(event)) {
#ifdef LIBMILTER_AUTO_DISCONNECT
milter8_close_stream(milter);
#endif
milter->state = MILTER8_STAT_REJECT_CON;
MILTER8_EVENT_BREAK(milter8_def_reply(milter, STR(milter->buf)));
} else {
MILTER8_EVENT_BREAK(STR(milter->buf));
}
case SMFIR_QUARANTINE:
if (milter8_read_data(milter, &data_size,
MILTER8_DATA_BUFFER, milter->buf,
MILTER8_DATA_END) != 0)
MILTER8_EVENT_BREAK(milter->def_reply);
milter8_def_reply(milter, "H");
continue;
case SMFIR_SKIP:
if (data_size != 0)
break;
milter->skip_event_type = event;
MILTER8_EVENT_BREAK(milter->def_reply);
default:
if (event == SMFIC_BODYEOB) {
switch (cmd) {
#define MILTER8_HDR_SPACE(m) (((m)->ev_mask & SMFIP_HDR_LEADSPC) ? "" : " ")
case SMFIR_CHGHEADER:
if (milter8_read_data(milter, &data_size,
MILTER8_DATA_HLONG, &index,
MILTER8_DATA_STRING, milter->buf,
MILTER8_DATA_STRING, milter->body,
MILTER8_DATA_END) != 0)
MILTER8_EVENT_BREAK(milter->def_reply);
if (edit_resp)
continue;
if (index == 0)
index = 1;
if ((ssize_t) index < 1) {
msg_warn("milter %s: bad change header index: %ld",
milter->m.name, (long) index);
milter8_conf_error(milter);
MILTER8_EVENT_BREAK(milter->def_reply);
}
if (LEN(milter->buf) == 0) {
msg_warn("milter %s: null change header name",
milter->m.name);
milter8_conf_error(milter);
MILTER8_EVENT_BREAK(milter->def_reply);
}
if (STR(milter->body)[0])
edit_resp = parent->upd_header(parent->chg_context,
(ssize_t) index,
STR(milter->buf),
MILTER8_HDR_SPACE(milter),
STR(milter->body));
else
edit_resp = parent->del_header(parent->chg_context,
(ssize_t) index,
STR(milter->buf));
continue;
case SMFIR_ADDHEADER:
if (milter8_read_data(milter, &data_size,
MILTER8_DATA_STRING, milter->buf,
MILTER8_DATA_STRING, milter->body,
MILTER8_DATA_END) != 0)
MILTER8_EVENT_BREAK(milter->def_reply);
if (edit_resp)
continue;
edit_resp = parent->add_header(parent->chg_context,
STR(milter->buf),
MILTER8_HDR_SPACE(milter),
STR(milter->body));
continue;
case SMFIR_INSHEADER:
if (milter8_read_data(milter, &data_size,
MILTER8_DATA_HLONG, &index,
MILTER8_DATA_STRING, milter->buf,
MILTER8_DATA_STRING, milter->body,
MILTER8_DATA_END) != 0)
MILTER8_EVENT_BREAK(milter->def_reply);
if (edit_resp)
continue;
if ((ssize_t) index + 1 < 1) {
msg_warn("milter %s: bad insert header index: %ld",
milter->m.name, (long) index);
milter8_conf_error(milter);
MILTER8_EVENT_BREAK(milter->def_reply);
}
edit_resp = parent->ins_header(parent->chg_context,
(ssize_t) index + 1,
STR(milter->buf),
MILTER8_HDR_SPACE(milter),
STR(milter->body));
continue;
case SMFIR_CHGFROM:
if (milter8_read_data(milter, &data_size,
MILTER8_DATA_STRING, milter->buf,
MILTER8_DATA_MORE) != 0)
MILTER8_EVENT_BREAK(milter->def_reply);
if (data_size > 0) {
if (milter8_read_data(milter, &data_size,
MILTER8_DATA_STRING, milter->body,
MILTER8_DATA_END) != 0)
MILTER8_EVENT_BREAK(milter->def_reply);
} else {
VSTRING_RESET(milter->body);
VSTRING_TERMINATE(milter->body);
}
if (edit_resp)
continue;
edit_resp = parent->chg_from(parent->chg_context,
STR(milter->buf),
STR(milter->body));
continue;
case SMFIR_ADDRCPT:
if (milter8_read_data(milter, &data_size,
MILTER8_DATA_STRING, milter->buf,
MILTER8_DATA_END) != 0)
MILTER8_EVENT_BREAK(milter->def_reply);
if (edit_resp)
continue;
edit_resp = parent->add_rcpt(parent->chg_context,
STR(milter->buf));
continue;
case SMFIR_ADDRCPT_PAR:
if (milter8_read_data(milter, &data_size,
MILTER8_DATA_STRING, milter->buf,
MILTER8_DATA_MORE) != 0)
MILTER8_EVENT_BREAK(milter->def_reply);
if (data_size > 0) {
if (milter8_read_data(milter, &data_size,
MILTER8_DATA_STRING, milter->body,
MILTER8_DATA_END) != 0)
MILTER8_EVENT_BREAK(milter->def_reply);
} else {
VSTRING_RESET(milter->body);
VSTRING_TERMINATE(milter->body);
}
if (edit_resp)
continue;
edit_resp = parent->add_rcpt_par(parent->chg_context,
STR(milter->buf),
STR(milter->body));
continue;
case SMFIR_DELRCPT:
if (milter8_read_data(milter, &data_size,
MILTER8_DATA_STRING, milter->buf,
MILTER8_DATA_END) != 0)
MILTER8_EVENT_BREAK(milter->def_reply);
if (edit_resp)
continue;
edit_resp = parent->del_rcpt(parent->chg_context,
STR(milter->buf));
continue;
case SMFIR_REPLBODY:
if (body_edit_lockout) {
msg_warn("milter %s: body replacement requests can't "
"currently be mixed with other requests",
milter->m.name);
milter8_conf_error(milter);
MILTER8_EVENT_BREAK(milter->def_reply);
}
if (milter8_read_data(milter, &data_size,
MILTER8_DATA_BUFFER, milter->body,
MILTER8_DATA_END) != 0)
MILTER8_EVENT_BREAK(milter->def_reply);
if (edit_resp)
continue;
if (body_line_buf == 0) {
body_line_buf = vstring_alloc(var_line_limit);
edit_resp = parent->repl_body(parent->chg_context,
MILTER_BODY_START,
(VSTRING *) 0);
}
for (cp = STR(milter->body); edit_resp == 0
&& cp < vstring_end(milter->body); cp++) {
ch = *(unsigned char *) cp;
if (ch == '\n') {
if (LEN(body_line_buf) > 0
&& vstring_end(body_line_buf)[-1] == '\r')
vstring_truncate(body_line_buf,
LEN(body_line_buf) - 1);
edit_resp = parent->repl_body(parent->chg_context,
MILTER_BODY_LINE,
body_line_buf);
VSTRING_RESET(body_line_buf);
} else {
VSTRING_ADDCH(body_line_buf, ch);
}
}
continue;
}
}
msg_warn("milter %s: unexpected filter response %s after event %s",
milter->m.name,
(smfir_name = str_name_code(smfir_table, cmd)) != 0 ?
smfir_name : "(unknown filter reply)",
(smfic_name = str_name_code(smfic_table, event)) != 0 ?
smfic_name : "(unknown MTA event)");
milter8_comm_error(milter);
MILTER8_EVENT_BREAK(milter->def_reply);
}
msg_warn("milter %s: reply %s was followed by %ld data bytes",
milter->m.name, (smfir_name = str_name_code(smfir_table, cmd)) != 0 ?
smfir_name : "unknown", (long) data_len);
milter8_comm_error(milter);
MILTER8_EVENT_BREAK(milter->def_reply);
}
if (body_line_buf)
vstring_free(body_line_buf);
if (edit_resp && (retval == 0 || strchr("DS4", retval[0]) == 0))
retval = edit_resp;
return (retval);
}
static void milter8_connect(MILTER8 *milter)
{
const char *myname = "milter8_connect";
ssize_t data_len;
unsigned char cmd;
char *transport;
char *endpoint;
int (*connect_fn) (const char *, int, int);
int fd;
const UINT32_TYPE my_actions = (SMFIF_ADDHDRS | SMFIF_ADDRCPT
| SMFIF_DELRCPT | SMFIF_CHGHDRS
| SMFIF_CHGBODY
| SMFIF_QUARANTINE
| SMFIF_CHGFROM
| SMFIF_ADDRCPT_PAR
| SMFIF_SETSYMLIST
);
UINT32_TYPE my_version = 0;
UINT32_TYPE my_events = 0;
char *saved_version;
char *cp;
char *name;
if (milter->fp != 0)
msg_panic("%s: milter %s: socket is not closed",
myname, milter->m.name);
cp = saved_version = mystrdup(milter->protocol);
while ((name = mystrtok(&cp, " ,\t\r\n")) != 0) {
int mask;
int vers;
if ((mask = name_code(milter8_event_masks,
NAME_CODE_FLAG_NONE, name)) == -1
|| (vers = name_code(milter8_versions,
NAME_CODE_FLAG_NONE, name)) == -1
|| (vers != 0 && my_version != 0)) {
msg_warn("milter %s: bad protocol information: %s",
milter->m.name, name);
milter8_conf_error(milter);
return;
}
if (vers != 0)
my_version = vers;
my_events |= mask;
}
myfree(saved_version);
if (my_events == 0 || my_version == 0) {
msg_warn("milter %s: no protocol version information", milter->m.name);
milter8_conf_error(milter);
return;
}
milter->np_mask = (SMFIP_NOSEND_MASK & ~my_events);
if (msg_verbose)
msg_info("%s: non-protocol events for protocol version %d: %s",
myname, my_version,
str_name_mask_opt(milter->buf, "non-protocol event mask",
smfip_table, milter->np_mask, NAME_MASK_NUMBER));
#define FREE_TRANSPORT_AND_BAIL_OUT(milter, milter_error) do { \
myfree(transport); \
milter_error(milter); \
return; \
} while (0);
transport = mystrdup(milter->m.name);
if ((endpoint = split_at(transport, ':')) == 0
|| *endpoint == 0 || *transport == 0) {
msg_warn("Milter service needs transport:endpoint instead of \"%s\"",
milter->m.name);
FREE_TRANSPORT_AND_BAIL_OUT(milter, milter8_conf_error);
}
if (msg_verbose)
msg_info("%s: transport=%s endpoint=%s", myname, transport, endpoint);
if (strcmp(transport, "inet") == 0) {
connect_fn = inet_connect;
} else if (strcmp(transport, "unix") == 0) {
connect_fn = unix_connect;
} else if (strcmp(transport, "local") == 0) {
connect_fn = LOCAL_CONNECT;
} else {
msg_warn("invalid transport name: %s in Milter service: %s",
transport, milter->m.name);
FREE_TRANSPORT_AND_BAIL_OUT(milter, milter8_conf_error);
}
if ((fd = connect_fn(endpoint, BLOCKING, milter->conn_timeout)) < 0) {
msg_warn("connect to Milter service %s: %m", milter->m.name);
FREE_TRANSPORT_AND_BAIL_OUT(milter, milter8_comm_error);
}
myfree(transport);
milter->fp = vstream_fdopen(fd, O_RDWR);
vstream_control(milter->fp,
VSTREAM_CTL_DOUBLE,
VSTREAM_CTL_TIMEOUT, milter->cmd_timeout,
VSTREAM_CTL_END);
if (connect_fn == inet_connect)
vstream_tweak_tcp(milter->fp);
if (msg_verbose) {
msg_info("%s: my_version=0x%lx", myname, (long) my_version);
msg_info("%s: my_actions=0x%lx %s", myname, (long) my_actions,
str_name_mask_opt(milter->buf, "request mask",
smfif_table, my_actions, NAME_MASK_NUMBER));
msg_info("%s: my_events=0x%lx %s", myname, (long) my_events,
str_name_mask_opt(milter->buf, "event mask",
smfip_table, my_events, NAME_MASK_NUMBER));
}
errno = 0;
if (milter8_write_cmd(milter, SMFIC_OPTNEG,
MILTER8_DATA_HLONG, my_version,
MILTER8_DATA_HLONG, my_actions,
MILTER8_DATA_HLONG, my_events,
MILTER8_DATA_END) != 0) {
msg_warn("milter %s: write error in initial handshake",
milter->m.name);
return;
}
if (milter8_read_resp(milter, SMFIC_OPTNEG, &cmd, &data_len) != 0) {
msg_warn("milter %s: read error in initial handshake", milter->m.name);
return;
}
if (cmd != SMFIC_OPTNEG) {
msg_warn("milter %s: unexpected reply \"%c\" in initial handshake",
milter->m.name, cmd);
(void) milter8_comm_error(milter);
return;
}
if (milter8_read_data(milter, &data_len,
MILTER8_DATA_HLONG, &milter->version,
MILTER8_DATA_HLONG, &milter->rq_mask,
MILTER8_DATA_HLONG, &milter->ev_mask,
MILTER8_DATA_MORE) != 0) {
msg_warn("milter %s: read error in initial handshake", milter->m.name);
return;
}
if (milter->version > my_version) {
msg_warn("milter %s: protocol version %d conflict"
" with MTA protocol version %d",
milter->m.name, milter->version, my_version);
(void) milter8_comm_error(milter);
return;
}
if ((milter->rq_mask & my_actions) != milter->rq_mask) {
msg_warn("milter %s: request mask 0x%x conflict"
" with MTA request mask 0x%lx",
milter->m.name, milter->rq_mask, (long) my_actions);
(void) milter8_comm_error(milter);
return;
}
if (milter->ev_mask & SMFIP_RCPT_REJ)
milter->m.flags |= MILTER_FLAG_WANT_RCPT_REJ;
if (milter->version < my_version) {
const NAME_CODE *np;
int version;
for (np = milter8_event_masks; ; np++) {
if (np->name == 0) {
msg_warn("milter %s: unexpected protocol version %d",
milter->m.name, milter->version);
break;
}
if ((version = atoi(np->name)) > 0 && version <= milter->version) {
milter->np_mask |= (SMFIP_NOSEND_MASK & ~np->code);
if (msg_verbose)
msg_info("%s: non-protocol events for milter %s"
" protocol version %d: %s",
myname, milter->m.name, milter->version,
str_name_mask_opt(milter->buf,
"non-protocol event mask",
smfip_table, milter->np_mask,
NAME_MASK_NUMBER));
break;
}
}
}
if (msg_verbose) {
if ((milter->ev_mask & my_events) != milter->ev_mask)
msg_info("milter %s: event mask 0x%x includes features not"
" offered in MTA event mask 0x%lx",
milter->m.name, milter->ev_mask, (long) my_events);
msg_info("%s: milter %s version %d",
myname, milter->m.name, milter->version);
msg_info("%s: events %s", myname,
str_name_mask_opt(milter->buf, "event mask",
smfip_table, milter->ev_mask, NAME_MASK_NUMBER));
msg_info("%s: requests %s", myname,
str_name_mask_opt(milter->buf, "request mask",
smfif_table, milter->rq_mask, NAME_MASK_NUMBER));
}
milter->state = MILTER8_STAT_READY;
milter8_def_reply(milter, 0);
milter->skip_event_type = 0;
if (data_len > 0) {
VSTRING *buf = vstring_alloc(100);
UINT32_TYPE mac_type;
const char *smfim_name;
char **mac_value_ptr;
milter->m.macros = milter_macros_alloc(MILTER_MACROS_ALLOC_EMPTY);
while (data_len > 0
&& milter8_read_data(milter, &data_len,
MILTER8_DATA_HLONG, &mac_type,
MILTER8_DATA_STRING, buf,
MILTER8_DATA_MORE) == 0) {
smfim_name = str_name_code(smfim_table, mac_type);
if (smfim_name == 0) {
msg_warn("milter %s: ignoring unknown macro type %u",
milter->m.name, (unsigned) mac_type);
} else {
if (msg_verbose)
msg_info("override %s macro list with \"%s\"",
smfim_name, STR(buf));
mac_value_ptr = MILTER8_MACRO_PTR(milter->m.macros, mac_type);
myfree(*mac_value_ptr);
*mac_value_ptr = mystrdup(STR(buf));
}
}
vstring_free(buf);
}
}
static const char *milter8_conn_event(MILTER *m,
const char *client_name,
const char *client_addr,
const char *client_port,
unsigned addr_family,
ARGV *macros)
{
const char *myname = "milter8_conn_event";
MILTER8 *milter = (MILTER8 *) m;
int port;
int skip_reply;
const char *sm_name;
char *ptr = 0;
const char *resp;
#define XXX_UNKNOWN "unknown"
#define STR_EQ(x,y) (strcmp((x), (y)) == 0)
#define STR_NE(x,y) (strcmp((x), (y)) != 0)
#ifdef LIBMILTER_AUTO_DISCONNECT
milter8_connect(milter);
#endif
switch (milter->state) {
case MILTER8_STAT_ERROR:
if (msg_verbose)
msg_info("%s: skip milter %s", myname, milter->m.name);
return (milter->def_reply);
case MILTER8_STAT_READY:
if (msg_verbose)
msg_info("%s: milter %s: connect %s/%s",
myname, milter->m.name, client_name, client_addr);
if (client_port == 0) {
port = 0;
} else if (!alldig(client_port) || (port = atoi(client_port)) < 0
|| port > 65535) {
msg_warn("milter %s: bad client port number %s",
milter->m.name, client_port);
port = 0;
}
milter->state = MILTER8_STAT_ENVELOPE;
skip_reply = ((milter->ev_mask & SMFIP_NR_CONN) != 0);
sm_name = (STR_NE(client_name, XXX_UNKNOWN) ? client_name :
STR_EQ(client_addr, XXX_UNKNOWN) ? client_name :
(ptr = concatenate("[", client_addr, "]", (char *) 0)));
switch (addr_family) {
case AF_INET:
resp = milter8_event(milter, SMFIC_CONNECT, SMFIP_NOCONNECT,
skip_reply, macros,
MILTER8_DATA_STRING, sm_name,
MILTER8_DATA_OCTET, SMFIA_INET,
MILTER8_DATA_NSHORT, htons(port),
MILTER8_DATA_STRING, client_addr,
MILTER8_DATA_END);
break;
#ifdef HAS_IPV6
case AF_INET6:
resp = milter8_event(milter, SMFIC_CONNECT, SMFIP_NOCONNECT,
skip_reply, macros,
MILTER8_DATA_STRING, sm_name,
MILTER8_DATA_OCTET, SMFIA_INET6,
MILTER8_DATA_NSHORT, htons(port),
MILTER8_DATA_STRING, client_addr,
MILTER8_DATA_END);
break;
#endif
case AF_UNIX:
resp = milter8_event(milter, SMFIC_CONNECT, SMFIP_NOCONNECT,
skip_reply, macros,
MILTER8_DATA_STRING, sm_name,
MILTER8_DATA_OCTET, SMFIA_UNIX,
MILTER8_DATA_NSHORT, htons(0),
MILTER8_DATA_STRING, client_addr,
MILTER8_DATA_END);
break;
default:
resp = milter8_event(milter, SMFIC_CONNECT, SMFIP_NOCONNECT,
skip_reply, macros,
MILTER8_DATA_STRING, sm_name,
MILTER8_DATA_OCTET, SMFIA_UNKNOWN,
MILTER8_DATA_END);
break;
}
if (ptr != 0)
myfree(ptr);
return (resp);
default:
msg_panic("%s: milter %s: bad state %d",
myname, milter->m.name, milter->state);
}
}
static const char *milter8_helo_event(MILTER *m, const char *helo_name,
int unused_esmtp,
ARGV *macros)
{
const char *myname = "milter8_helo_event";
MILTER8 *milter = (MILTER8 *) m;
int skip_reply;
switch (milter->state) {
case MILTER8_STAT_ERROR:
case MILTER8_STAT_ACCEPT_CON:
case MILTER8_STAT_REJECT_CON:
if (msg_verbose)
msg_info("%s: skip milter %s", myname, milter->m.name);
return (milter->def_reply);
case MILTER8_STAT_ENVELOPE:
case MILTER8_STAT_ACCEPT_MSG:
if (msg_verbose)
msg_info("%s: milter %s: helo %s",
myname, milter->m.name, helo_name);
skip_reply = ((milter->ev_mask & SMFIP_NR_HELO) != 0);
return (milter8_event(milter, SMFIC_HELO, SMFIP_NOHELO,
skip_reply, macros,
MILTER8_DATA_STRING, helo_name,
MILTER8_DATA_END));
default:
msg_panic("%s: milter %s: bad state %d",
myname, milter->m.name, milter->state);
}
}
static const char *milter8_mail_event(MILTER *m, const char **argv,
ARGV *macros)
{
const char *myname = "milter8_mail_event";
MILTER8 *milter = (MILTER8 *) m;
const char **cpp;
int skip_reply;
switch (milter->state) {
case MILTER8_STAT_ERROR:
case MILTER8_STAT_ACCEPT_CON:
case MILTER8_STAT_REJECT_CON:
if (msg_verbose)
msg_info("%s: skip milter %s", myname, milter->m.name);
return (milter->def_reply);
case MILTER8_STAT_ENVELOPE:
if (msg_verbose) {
VSTRING *buf = vstring_alloc(100);
for (cpp = argv; *cpp; cpp++)
vstring_sprintf_append(buf, " %s", *cpp);
msg_info("%s: milter %s: mail%s",
myname, milter->m.name, STR(buf));
vstring_free(buf);
}
skip_reply = ((milter->ev_mask & SMFIP_NR_MAIL) != 0);
return (milter8_event(milter, SMFIC_MAIL, SMFIP_NOMAIL,
skip_reply, macros,
MILTER8_DATA_ARGV, argv,
MILTER8_DATA_END));
default:
msg_panic("%s: milter %s: bad state %d",
myname, milter->m.name, milter->state);
}
}
static const char *milter8_rcpt_event(MILTER *m, const char **argv,
ARGV *macros)
{
const char *myname = "milter8_rcpt_event";
MILTER8 *milter = (MILTER8 *) m;
const char **cpp;
int skip_reply;
switch (milter->state) {
case MILTER8_STAT_ERROR:
case MILTER8_STAT_ACCEPT_CON:
case MILTER8_STAT_REJECT_CON:
case MILTER8_STAT_ACCEPT_MSG:
if (msg_verbose)
msg_info("%s: skip milter %s", myname, milter->m.name);
return (milter->def_reply);
case MILTER8_STAT_ENVELOPE:
if (msg_verbose) {
VSTRING *buf = vstring_alloc(100);
for (cpp = argv; *cpp; cpp++)
vstring_sprintf_append(buf, " %s", *cpp);
msg_info("%s: milter %s: rcpt%s",
myname, milter->m.name, STR(buf));
vstring_free(buf);
}
skip_reply = ((milter->ev_mask & SMFIP_NR_RCPT) != 0);
return (milter8_event(milter, SMFIC_RCPT, SMFIP_NORCPT,
skip_reply, macros,
MILTER8_DATA_ARGV, argv,
MILTER8_DATA_END));
default:
msg_panic("%s: milter %s: bad state %d",
myname, milter->m.name, milter->state);
}
}
static const char *milter8_data_event(MILTER *m, ARGV *macros)
{
const char *myname = "milter8_data_event";
MILTER8 *milter = (MILTER8 *) m;
int skip_reply;
switch (milter->state) {
case MILTER8_STAT_ERROR:
case MILTER8_STAT_ACCEPT_CON:
case MILTER8_STAT_REJECT_CON:
case MILTER8_STAT_ACCEPT_MSG:
if (msg_verbose)
msg_info("%s: skip milter %s", myname, milter->m.name);
return (milter->def_reply);
case MILTER8_STAT_ENVELOPE:
if (msg_verbose)
msg_info("%s: milter %s: data command", myname, milter->m.name);
skip_reply = ((milter->ev_mask & SMFIP_NR_DATA) != 0);
return (milter8_event(milter, SMFIC_DATA, SMFIP_NODATA,
skip_reply, macros,
MILTER8_DATA_END));
default:
msg_panic("%s: milter %s: bad state %d",
myname, milter->m.name, milter->state);
}
}
static const char *milter8_unknown_event(MILTER *m, const char *command,
ARGV *macros)
{
const char *myname = "milter8_unknown_event";
MILTER8 *milter = (MILTER8 *) m;
int skip_reply;
switch (milter->state) {
case MILTER8_STAT_ERROR:
case MILTER8_STAT_ACCEPT_CON:
case MILTER8_STAT_REJECT_CON:
case MILTER8_STAT_ACCEPT_MSG:
if (msg_verbose)
msg_info("%s: skip milter %s", myname, milter->m.name);
return (milter->def_reply);
case MILTER8_STAT_ENVELOPE:
if (msg_verbose)
msg_info("%s: milter %s: unknown command: %s",
myname, milter->m.name, command);
skip_reply = ((milter->ev_mask & SMFIP_NR_UNKN) != 0);
return (milter8_event(milter, SMFIC_UNKNOWN, SMFIP_NOUNKNOWN,
skip_reply, macros,
MILTER8_DATA_STRING, command,
MILTER8_DATA_END));
default:
msg_panic("%s: milter %s: bad state %d",
myname, milter->m.name, milter->state);
}
}
static const char *milter8_other_event(MILTER *m)
{
const char *myname = "milter8_other_event";
MILTER8 *milter = (MILTER8 *) m;
if (msg_verbose)
msg_info("%s: milter %s", myname, milter->m.name);
return (milter->def_reply);
}
static void milter8_abort(MILTER *m)
{
const char *myname = "milter8_abort";
MILTER8 *milter = (MILTER8 *) m;
switch (milter->state) {
case MILTER8_STAT_CLOSED:
case MILTER8_STAT_READY:
return;
case MILTER8_STAT_ERROR:
case MILTER8_STAT_ACCEPT_CON:
case MILTER8_STAT_REJECT_CON:
if (msg_verbose)
msg_info("%s: skip milter %s", myname, milter->m.name);
break;
case MILTER8_STAT_ENVELOPE:
case MILTER8_STAT_MESSAGE:
case MILTER8_STAT_ACCEPT_MSG:
if (msg_verbose)
msg_info("%s: abort milter %s", myname, milter->m.name);
(void) milter8_write_cmd(milter, SMFIC_ABORT, MILTER8_DATA_END);
if (milter->state != MILTER8_STAT_ERROR)
milter->state = MILTER8_STAT_ENVELOPE;
break;
default:
msg_panic("%s: milter %s: bad state %d",
myname, milter->m.name, milter->state);
}
}
static void milter8_disc_event(MILTER *m)
{
const char *myname = "milter8_disc_event";
MILTER8 *milter = (MILTER8 *) m;
switch (milter->state) {
case MILTER8_STAT_CLOSED:
case MILTER8_STAT_READY:
return;
case MILTER8_STAT_ERROR:
#ifdef LIBMILTER_AUTO_DISCONNECT
case MILTER8_STAT_ACCEPT_CON:
case MILTER8_STAT_REJECT_CON:
#endif
if (msg_verbose)
msg_info("%s: skip quit milter %s", myname, milter->m.name);
break;
case MILTER8_STAT_ENVELOPE:
case MILTER8_STAT_MESSAGE:
#ifndef LIBMILTER_AUTO_DISCONNECT
case MILTER8_STAT_ACCEPT_CON:
case MILTER8_STAT_REJECT_CON:
#endif
case MILTER8_STAT_ACCEPT_MSG:
if (msg_verbose)
msg_info("%s: quit milter %s", myname, milter->m.name);
(void) milter8_write_cmd(milter, SMFIC_QUIT, MILTER8_DATA_END);
break;
}
#ifdef LIBMILTER_AUTO_DISCONNECT
milter8_close_stream(milter);
#else
if (milter->state != MILTER8_STAT_ERROR)
milter->state = MILTER8_STAT_READY;
#endif
milter8_def_reply(milter, 0);
}
typedef struct {
MILTER8 *milter;
ARGV *eoh_macros;
ARGV *eod_macros;
int first_header;
int first_body;
const char *resp;
} MILTER_MSG_CONTEXT;
static void milter8_header(void *ptr, int unused_header_class,
const HEADER_OPTS *header_info,
VSTRING *buf, off_t unused_offset)
{
const char *myname = "milter8_header";
MILTER_MSG_CONTEXT *msg_ctx = (MILTER_MSG_CONTEXT *) ptr;
MILTER8 *milter = msg_ctx->milter;
char *cp;
int skip_reply;
#define MILTER8_MESSAGE_DONE(milter, msg_ctx) \
((milter)->state != MILTER8_STAT_MESSAGE || (msg_ctx)->resp != 0)
if (MILTER8_MESSAGE_DONE(milter, msg_ctx))
return;
if (msg_ctx->first_header) {
msg_ctx->first_header = 0;
return;
}
if (msg_verbose > 1)
msg_info("%s: header milter %s: %.100s",
myname, milter->m.name, STR(buf));
cp = STR(buf) + (header_info ? strlen(header_info->name) :
is_header(STR(buf)));
while (*cp == ' ' || *cp == '\t')
*cp++ = 0;
if (*cp != ':')
msg_panic("%s: header label not followed by ':'", myname);
*cp++ = 0;
if ((milter->ev_mask & SMFIP_HDR_LEADSPC) == 0 && *cp == ' ')
cp++;
skip_reply = ((milter->ev_mask & SMFIP_NOHREPL) != 0);
msg_ctx->resp =
milter8_event(milter, SMFIC_HEADER, SMFIP_NOHDRS,
skip_reply, msg_ctx->eoh_macros,
MILTER8_DATA_STRING, STR(buf),
MILTER8_DATA_STRING, cp,
MILTER8_DATA_END);
}
static void milter8_eoh(void *ptr)
{
const char *myname = "milter8_eoh";
MILTER_MSG_CONTEXT *msg_ctx = (MILTER_MSG_CONTEXT *) ptr;
MILTER8 *milter = msg_ctx->milter;
int skip_reply;
if (MILTER8_MESSAGE_DONE(milter, msg_ctx))
return;
if (msg_verbose)
msg_info("%s: eoh milter %s", myname, milter->m.name);
skip_reply = ((milter->ev_mask & SMFIP_NR_EOH) != 0);
msg_ctx->resp =
milter8_event(milter, SMFIC_EOH, SMFIP_NOEOH,
skip_reply, msg_ctx->eoh_macros,
MILTER8_DATA_END);
}
static void milter8_body(void *ptr, int rec_type,
const char *buf, ssize_t len,
off_t offset)
{
const char *myname = "milter8_body";
MILTER_MSG_CONTEXT *msg_ctx = (MILTER_MSG_CONTEXT *) ptr;
MILTER8 *milter = msg_ctx->milter;
ssize_t todo = len;
const char *bp = buf;
ssize_t space;
ssize_t count;
int skip_reply;
if (MILTER8_MESSAGE_DONE(milter, msg_ctx))
return;
if (msg_ctx->first_body) {
msg_ctx->first_body = 0;
return;
}
if (msg_verbose > 1)
msg_info("%s: body milter %s: %.100s", myname, milter->m.name, buf);
skip_reply = ((milter->ev_mask & SMFIP_NR_BODY) != 0);
if (rec_type == REC_TYPE_NORM && todo == 0) {
bp = "\r\n";
todo = 2;
rec_type = REC_TYPE_EOF;
}
while (todo > 0) {
space = MILTER_CHUNK_SIZE - LEN(milter->body);
if (space <= 0)
msg_panic("%s: bad buffer size: %ld",
myname, (long) LEN(milter->body));
count = (todo > space ? space : todo);
vstring_memcat(milter->body, bp, count);
bp += count;
todo -= count;
if (LEN(milter->body) == MILTER_CHUNK_SIZE) {
msg_ctx->resp =
milter8_event(milter, SMFIC_BODY, SMFIP_NOBODY,
skip_reply, msg_ctx->eod_macros,
MILTER8_DATA_BUFFER, milter->body,
MILTER8_DATA_END);
if (MILTER8_MESSAGE_DONE(milter, msg_ctx))
break;
VSTRING_RESET(milter->body);
}
if (rec_type == REC_TYPE_NORM && todo == 0) {
bp = "\r\n";
todo = 2;
rec_type = REC_TYPE_EOF;
}
}
}
static void milter8_eob(void *ptr)
{
const char *myname = "milter8_eob";
MILTER_MSG_CONTEXT *msg_ctx = (MILTER_MSG_CONTEXT *) ptr;
MILTER8 *milter = msg_ctx->milter;
int skip_reply;
if (MILTER8_MESSAGE_DONE(milter, msg_ctx))
return;
if (msg_verbose)
msg_info("%s: eob milter %s", myname, milter->m.name);
if (LEN(milter->body) > 0) {
skip_reply = ((milter->ev_mask & SMFIP_NR_BODY) != 0);
msg_ctx->resp =
milter8_event(milter, SMFIC_BODY, SMFIP_NOBODY,
skip_reply, msg_ctx->eod_macros,
MILTER8_DATA_BUFFER, milter->body,
MILTER8_DATA_END);
if (MILTER8_MESSAGE_DONE(milter, msg_ctx))
return;
}
msg_ctx->resp =
milter8_event(msg_ctx->milter, SMFIC_BODYEOB, 0,
DONT_SKIP_REPLY, msg_ctx->eod_macros,
MILTER8_DATA_END);
}
static const char *milter8_message(MILTER *m, VSTREAM *qfile,
off_t data_offset,
ARGV *eoh_macros,
ARGV *eod_macros)
{
const char *myname = "milter8_message";
MILTER8 *milter = (MILTER8 *) m;
MIME_STATE *mime_state;
int rec_type;
const MIME_STATE_DETAIL *detail;
int mime_errs = 0;
MILTER_MSG_CONTEXT msg_ctx;
VSTRING *buf;
int saved_errno;
switch (milter->state) {
case MILTER8_STAT_ERROR:
case MILTER8_STAT_ACCEPT_CON:
case MILTER8_STAT_REJECT_CON:
case MILTER8_STAT_ACCEPT_MSG:
if (msg_verbose)
msg_info("%s: skip message to milter %s", myname, milter->m.name);
return (milter->def_reply);
case MILTER8_STAT_ENVELOPE:
if (msg_verbose)
msg_info("%s: message to milter %s", myname, milter->m.name);
if (vstream_fseek(qfile, data_offset, SEEK_SET) < 0) {
saved_errno = errno;
msg_warn("%s: vstream_fseek %s: %m", myname, VSTREAM_PATH(qfile));
return (saved_errno == EFBIG ?
"552 5.3.4 Message file too big" :
"451 4.3.0 Queue file write error");
}
msg_ctx.milter = milter;
msg_ctx.eoh_macros = eoh_macros;
msg_ctx.eod_macros = eod_macros;
msg_ctx.first_header = 1;
msg_ctx.first_body = 1;
msg_ctx.resp = 0;
mime_state =
mime_state_alloc(MIME_OPT_DISABLE_MIME,
(milter->ev_mask & SMFIP_NOHDRS) ?
(MIME_STATE_HEAD_OUT) 0 : milter8_header,
(milter->ev_mask & SMFIP_NOEOH) ?
(MIME_STATE_ANY_END) 0 : milter8_eoh,
(milter->ev_mask & SMFIP_NOBODY) ?
(MIME_STATE_BODY_OUT) 0 : milter8_body,
milter8_eob,
(MIME_STATE_ERR_PRINT) 0,
(void *) &msg_ctx);
buf = vstring_alloc(100);
milter->state = MILTER8_STAT_MESSAGE;
VSTRING_RESET(milter->body);
vstream_control(milter->fp,
VSTREAM_CTL_DOUBLE,
VSTREAM_CTL_TIMEOUT, milter->msg_timeout,
VSTREAM_CTL_END);
for (;;) {
if ((rec_type = rec_get(qfile, buf, 0)) < 0) {
msg_warn("%s: error reading %s: %m",
myname, VSTREAM_PATH(qfile));
msg_ctx.resp = "450 4.3.0 Queue file write error";
break;
}
mime_errs = mime_state_update(mime_state, rec_type,
STR(buf), LEN(buf));
if (mime_errs) {
detail = mime_state_detail(mime_errs);
msg_warn("%s: MIME problem %s in %s",
myname, detail->text, VSTREAM_PATH(qfile));
msg_ctx.resp = "450 4.3.0 Queue file write error";
break;
}
if (MILTER8_MESSAGE_DONE(milter, &msg_ctx))
break;
if (rec_type != REC_TYPE_NORM && rec_type != REC_TYPE_CONT)
break;
}
mime_state_free(mime_state);
vstring_free(buf);
if (milter->fp)
vstream_control(milter->fp,
VSTREAM_CTL_DOUBLE,
VSTREAM_CTL_TIMEOUT, milter->cmd_timeout,
VSTREAM_CTL_END);
if (milter->state == MILTER8_STAT_MESSAGE
|| milter->state == MILTER8_STAT_ACCEPT_MSG)
milter->state = MILTER8_STAT_ENVELOPE;
return (msg_ctx.resp);
default:
msg_panic("%s: milter %s: bad state %d",
myname, milter->m.name, milter->state);
}
}
#define MAIL_ATTR_MILT_NAME "milter_name"
#define MAIL_ATTR_MILT_VERS "milter_version"
#define MAIL_ATTR_MILT_ACTS "milter_actions"
#define MAIL_ATTR_MILT_EVTS "milter_events"
#define MAIL_ATTR_MILT_NPTS "milter_non_events"
#define MAIL_ATTR_MILT_STAT "milter_state"
#define MAIL_ATTR_MILT_CONN "milter_conn_timeout"
#define MAIL_ATTR_MILT_CMD "milter_cmd_timeout"
#define MAIL_ATTR_MILT_MSG "milter_msg_timeout"
#define MAIL_ATTR_MILT_ACT "milter_action"
#define MAIL_ATTR_MILT_MAC "milter_macro_list"
static int milter8_active(MILTER *m)
{
MILTER8 *milter = (MILTER8 *) m;
return (milter->fp != 0
&& (milter->state == MILTER8_STAT_ENVELOPE
|| milter->state == MILTER8_STAT_READY));
}
static int milter8_send(MILTER *m, VSTREAM *stream)
{
const char *myname = "milter8_send";
MILTER8 *milter = (MILTER8 *) m;
if (msg_verbose)
msg_info("%s: milter %s", myname, milter->m.name);
if (milter->fp)
vstream_fflush(milter->fp);
if (attr_print(stream, ATTR_FLAG_MORE,
ATTR_TYPE_STR, MAIL_ATTR_MILT_NAME, milter->m.name,
ATTR_TYPE_INT, MAIL_ATTR_MILT_VERS, milter->version,
ATTR_TYPE_INT, MAIL_ATTR_MILT_ACTS, milter->rq_mask,
ATTR_TYPE_INT, MAIL_ATTR_MILT_EVTS, milter->ev_mask,
ATTR_TYPE_INT, MAIL_ATTR_MILT_NPTS, milter->np_mask,
ATTR_TYPE_INT, MAIL_ATTR_MILT_STAT, milter->state,
ATTR_TYPE_INT, MAIL_ATTR_MILT_CONN, milter->conn_timeout,
ATTR_TYPE_INT, MAIL_ATTR_MILT_CMD, milter->cmd_timeout,
ATTR_TYPE_INT, MAIL_ATTR_MILT_MSG, milter->msg_timeout,
ATTR_TYPE_STR, MAIL_ATTR_MILT_ACT, milter->def_action,
ATTR_TYPE_INT, MAIL_ATTR_MILT_MAC, milter->m.macros != 0,
ATTR_TYPE_END) != 0
|| (milter->m.macros != 0
&& attr_print(stream, ATTR_FLAG_NONE,
ATTR_TYPE_FUNC, milter_macros_print,
(void *) milter->m.macros,
ATTR_TYPE_END) != 0)
|| (milter->m.macros == 0
&& attr_print(stream, ATTR_FLAG_NONE,
ATTR_TYPE_END) != 0)
|| vstream_fflush(stream) != 0) {
return (-1);
#ifdef CANT_WRITE_BEFORE_SENDING_FD
} else if (attr_scan(stream, ATTR_FLAG_STRICT,
ATTR_TYPE_STR, MAIL_ATTR_DUMMY, milter->buf,
ATTR_TYPE_END) != 1) {
return (-1);
#endif
} else if (LOCAL_SEND_FD(vstream_fileno(stream),
vstream_fileno(milter->fp)) < 0) {
return (-1);
#ifdef MUST_READ_AFTER_SENDING_FD
} else if (attr_scan(stream, ATTR_FLAG_STRICT,
ATTR_TYPE_STR, MAIL_ATTR_DUMMY, milter->buf,
ATTR_TYPE_END) != 1) {
return (-1);
#endif
} else {
return (0);
}
}
static MILTER8 *milter8_alloc(const char *, int, int, int, const char *,
const char *, MILTERS *);
MILTER *milter8_receive(VSTREAM *stream, MILTERS *parent)
{
const char *myname = "milter8_receive";
static VSTRING *name_buf;
static VSTRING *act_buf;
MILTER8 *milter;
int version;
int rq_mask;
int ev_mask;
int np_mask;
int state;
int conn_timeout;
int cmd_timeout;
int msg_timeout;
int fd;
int has_macros;
MILTER_MACROS *macros = 0;
#define FREE_MACROS_AND_RETURN(x) do { \
if (macros) \
milter_macros_free(macros); \
return (x); \
} while (0)
if (name_buf == 0) {
name_buf = vstring_alloc(10);
act_buf = vstring_alloc(10);
}
if (attr_scan(stream, ATTR_FLAG_STRICT | ATTR_FLAG_MORE,
ATTR_TYPE_STR, MAIL_ATTR_MILT_NAME, name_buf,
ATTR_TYPE_INT, MAIL_ATTR_MILT_VERS, &version,
ATTR_TYPE_INT, MAIL_ATTR_MILT_ACTS, &rq_mask,
ATTR_TYPE_INT, MAIL_ATTR_MILT_EVTS, &ev_mask,
ATTR_TYPE_INT, MAIL_ATTR_MILT_NPTS, &np_mask,
ATTR_TYPE_INT, MAIL_ATTR_MILT_STAT, &state,
ATTR_TYPE_INT, MAIL_ATTR_MILT_CONN, &conn_timeout,
ATTR_TYPE_INT, MAIL_ATTR_MILT_CMD, &cmd_timeout,
ATTR_TYPE_INT, MAIL_ATTR_MILT_MSG, &msg_timeout,
ATTR_TYPE_STR, MAIL_ATTR_MILT_ACT, act_buf,
ATTR_TYPE_INT, MAIL_ATTR_MILT_MAC, &has_macros,
ATTR_TYPE_END) < 10
|| (has_macros != 0
&& attr_scan(stream, ATTR_FLAG_STRICT,
ATTR_TYPE_FUNC, milter_macros_scan,
(void *) (macros =
milter_macros_alloc(MILTER_MACROS_ALLOC_ZERO)),
ATTR_TYPE_END) < 1)
|| (has_macros == 0
&& attr_scan(stream, ATTR_FLAG_STRICT,
ATTR_TYPE_END) < 0)) {
FREE_MACROS_AND_RETURN(0);
#ifdef CANT_WRITE_BEFORE_SENDING_FD
} else if (attr_print(stream, ATTR_FLAG_NONE,
ATTR_TYPE_STR, MAIL_ATTR_DUMMY, "",
ATTR_TYPE_END) != 0
|| vstream_fflush(stream) != 0) {
FREE_MACROS_AND_RETURN(0);
#endif
} else if ((fd = LOCAL_RECV_FD(vstream_fileno(stream))) < 0) {
FREE_MACROS_AND_RETURN(0);
} else {
#ifdef MUST_READ_AFTER_SENDING_FD
(void) attr_print(stream, ATTR_FLAG_NONE,
ATTR_TYPE_STR, MAIL_ATTR_DUMMY, "",
ATTR_TYPE_END);
#endif
#define NO_PROTOCOL ((char *) 0)
if (msg_verbose)
msg_info("%s: milter %s", myname, STR(name_buf));
milter = milter8_alloc(STR(name_buf), conn_timeout, cmd_timeout,
msg_timeout, NO_PROTOCOL, STR(act_buf), parent);
milter->fp = vstream_fdopen(fd, O_RDWR);
milter->m.macros = macros;
vstream_control(milter->fp, VSTREAM_CTL_DOUBLE, VSTREAM_CTL_END);
vstream_tweak_sock(milter->fp);
milter->version = version;
milter->rq_mask = rq_mask;
milter->ev_mask = ev_mask;
milter->np_mask = np_mask;
milter->state = state;
return (&milter->m);
}
}
static void milter8_free(MILTER *m)
{
MILTER8 *milter = (MILTER8 *) m;
if (msg_verbose)
msg_info("free milter %s", milter->m.name);
if (milter->fp)
(void) vstream_fclose(milter->fp);
myfree(milter->m.name);
vstring_free(milter->buf);
vstring_free(milter->body);
if (milter->protocol)
myfree(milter->protocol);
myfree(milter->def_action);
if (milter->def_reply)
myfree(milter->def_reply);
if (milter->m.macros)
milter_macros_free(milter->m.macros);
myfree((char *) milter);
}
static MILTER8 *milter8_alloc(const char *name, int conn_timeout,
int cmd_timeout, int msg_timeout,
const char *protocol,
const char *def_action,
MILTERS *parent)
{
MILTER8 *milter;
milter = (MILTER8 *) mymalloc(sizeof(*milter));
milter->m.name = mystrdup(name);
milter->m.flags = 0;
milter->m.next = 0;
milter->m.parent = parent;
milter->m.macros = 0;
milter->m.conn_event = milter8_conn_event;
milter->m.helo_event = milter8_helo_event;
milter->m.mail_event = milter8_mail_event;
milter->m.rcpt_event = milter8_rcpt_event;
milter->m.data_event = milter8_data_event;
milter->m.message = milter8_message;
milter->m.unknown_event = milter8_unknown_event;
milter->m.other_event = milter8_other_event;
milter->m.abort = milter8_abort;
milter->m.disc_event = milter8_disc_event;
milter->m.active = milter8_active;
milter->m.send = milter8_send;
milter->m.free = milter8_free;
milter->fp = 0;
milter->buf = vstring_alloc(100);
milter->body = vstring_alloc(100);
milter->version = 0;
milter->rq_mask = 0;
milter->ev_mask = 0;
milter->state = MILTER8_STAT_CLOSED;
milter->conn_timeout = conn_timeout;
milter->cmd_timeout = cmd_timeout;
milter->msg_timeout = msg_timeout;
milter->protocol = (protocol ? mystrdup(protocol) : 0);
milter->def_action = mystrdup(def_action);
milter->def_reply = 0;
milter->skip_event_type = 0;
return (milter);
}
MILTER *milter8_create(const char *name, int conn_timeout, int cmd_timeout,
int msg_timeout, const char *protocol,
const char *def_action, MILTERS *parent)
{
MILTER8 *milter;
milter = milter8_alloc(name, conn_timeout, cmd_timeout, msg_timeout,
protocol, def_action, parent);
#ifndef LIBMILTER_AUTO_DISCONNECT
milter8_connect(milter);
#endif
return (&milter->m);
}