cleanup_envelope.c [plain text]
#include <sys_defs.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <msg.h>
#include <vstring.h>
#include <vstream.h>
#include <mymalloc.h>
#include <stringops.h>
#include <nvtable.h>
#include <record.h>
#include <rec_type.h>
#include <cleanup_user.h>
#include <qmgr_user.h>
#include <mail_params.h>
#include <verp_sender.h>
#include <mail_proto.h>
#include <dsn_mask.h>
#include <rec_attr_map.h>
#include "cleanup.h"
#define STR vstring_str
#define STREQ(x,y) (strcmp((x), (y)) == 0)
static void cleanup_envelope_process(CLEANUP_STATE *, int, const char *, ssize_t);
void cleanup_envelope(CLEANUP_STATE *state, int type,
const char *str, ssize_t len)
{
cleanup_out_format(state, REC_TYPE_SIZE, REC_TYPE_SIZE_FORMAT,
(REC_TYPE_SIZE_CAST1) 0,
(REC_TYPE_SIZE_CAST2) 0,
(REC_TYPE_SIZE_CAST3) 0,
(REC_TYPE_SIZE_CAST4) 0,
(REC_TYPE_SIZE_CAST5) 0);
state->action = cleanup_envelope_process;
cleanup_envelope_process(state, type, str, len);
}
static void cleanup_envelope_process(CLEANUP_STATE *state, int type,
const char *buf, ssize_t len)
{
const char *myname = "cleanup_envelope_process";
char *attr_name;
char *attr_value;
const char *error_text;
int extra_opts;
int junk;
int mapped_type = type;
const char *mapped_buf = buf;
int milter_count;
#ifdef DELAY_ACTION
int defer_delay;
#endif
if (msg_verbose)
msg_info("initial envelope %c %.*s", type, (int) len, buf);
if (type == REC_TYPE_FLGS) {
extra_opts = atoi(buf);
if (extra_opts & ~CLEANUP_FLAG_MASK_EXTRA)
msg_warn("%s: ignoring bad extra flags: 0x%x",
state->queue_id, extra_opts);
else
state->flags |= extra_opts;
return;
}
#ifdef DELAY_ACTION
if (type == REC_TYPE_DELAY) {
defer_delay = atoi(buf);
if (defer_delay <= 0)
msg_warn("%s: ignoring bad delay time: %s", state->queue_id, buf);
else
state->defer_delay = defer_delay;
return;
}
#endif
if (type == REC_TYPE_MILT_COUNT) {
if (state->milters != 0) {
msg_warn("%s: message rejected: too many milter instances",
state->queue_id);
state->errs |= CLEANUP_STAT_BAD;
return;
}
if ((milter_count = atoi(buf)) > 0)
cleanup_milter_receive(state, milter_count);
return;
}
if (type == REC_TYPE_ATTR) {
vstring_strcpy(state->attr_buf, buf);
error_text = split_nameval(STR(state->attr_buf), &attr_name, &attr_value);
if (error_text != 0) {
msg_warn("%s: message rejected: malformed attribute: %s: %.100s",
state->queue_id, error_text, buf);
state->errs |= CLEANUP_STAT_BAD;
return;
}
if (*attr_value == 0) {
msg_warn("%s: spurious null attribute value for \"%s\" -- ignored",
state->queue_id, attr_name);
return;
}
if ((junk = rec_attr_map(attr_name)) != 0) {
mapped_buf = attr_value;
mapped_type = junk;
}
}
if (strchr(REC_TYPE_ENVELOPE, type) == 0) {
msg_warn("%s: message rejected: unexpected record type %d in envelope",
state->queue_id, type);
state->errs |= CLEANUP_STAT_BAD;
return;
}
if ((state->flags & CLEANUP_FLAG_INRCPT) == 0
&& strchr(REC_TYPE_ENV_RECIPIENT, type) != 0) {
if (state->sender == 0) {
msg_warn("%s: message rejected: missing sender envelope record",
state->queue_id);
state->errs |= CLEANUP_STAT_BAD;
return;
}
if (state->arrival_time.tv_sec == 0) {
msg_warn("%s: message rejected: missing time envelope record",
state->queue_id);
state->errs |= CLEANUP_STAT_BAD;
return;
}
if ((state->flags & CLEANUP_FLAG_WARN_SEEN) == 0
&& state->sender && *state->sender
&& var_delay_warn_time > 0) {
cleanup_out_format(state, REC_TYPE_WARN, REC_TYPE_WARN_FORMAT,
REC_TYPE_WARN_ARG(state->arrival_time.tv_sec
+ var_delay_warn_time));
}
state->flags |= CLEANUP_FLAG_INRCPT;
}
if (type == REC_TYPE_RCPT) {
if (state->sender == 0) {
msg_warn("%s: message rejected: envelope recipient precedes sender",
state->queue_id);
state->errs |= CLEANUP_STAT_BAD;
return;
}
if (state->orig_rcpt == 0)
state->orig_rcpt = mystrdup(buf);
cleanup_addr_recipient(state, buf);
if (cleanup_milters != 0
&& state->milters == 0
&& CLEANUP_MILTER_OK(state))
cleanup_milter_emul_rcpt(state, cleanup_milters, buf);
myfree(state->orig_rcpt);
state->orig_rcpt = 0;
if (state->dsn_orcpt != 0) {
myfree(state->dsn_orcpt);
state->dsn_orcpt = 0;
}
state->dsn_notify = 0;
return;
}
if (type == REC_TYPE_DONE || type == REC_TYPE_DRCP) {
if (state->orig_rcpt != 0) {
myfree(state->orig_rcpt);
state->orig_rcpt = 0;
}
if (state->dsn_orcpt != 0) {
myfree(state->dsn_orcpt);
state->dsn_orcpt = 0;
}
state->dsn_notify = 0;
return;
}
if (mapped_type == REC_TYPE_DSN_ORCPT) {
if (state->dsn_orcpt) {
msg_warn("%s: ignoring out-of-order DSN original recipient record <%.200s>",
state->queue_id, state->dsn_orcpt);
myfree(state->dsn_orcpt);
}
state->dsn_orcpt = mystrdup(mapped_buf);
return;
}
if (mapped_type == REC_TYPE_DSN_NOTIFY) {
if (state->dsn_notify) {
msg_warn("%s: ignoring out-of-order DSN notify record <%d>",
state->queue_id, state->dsn_notify);
state->dsn_notify = 0;
}
if (!alldig(mapped_buf) || (junk = atoi(mapped_buf)) == 0
|| DSN_NOTIFY_OK(junk) == 0)
msg_warn("%s: ignoring malformed DSN notify record <%.200s>",
state->queue_id, buf);
else
state->qmgr_opts |=
QMGR_READ_FLAG_FROM_DSN(state->dsn_notify = junk);
return;
}
if (type == REC_TYPE_ORCP) {
if (state->orig_rcpt != 0) {
msg_warn("%s: ignoring out-of-order original recipient record <%.200s>",
state->queue_id, state->orig_rcpt);
myfree(state->orig_rcpt);
}
state->orig_rcpt = mystrdup(buf);
return;
}
if (type == REC_TYPE_MESG) {
state->action = cleanup_message;
if (state->flags & CLEANUP_FLAG_INRCPT) {
if (state->milters || cleanup_milters) {
if ((state->append_rcpt_pt_offset = vstream_ftell(state->dst)) < 0)
msg_fatal("%s: vstream_ftell %s: %m:", myname, cleanup_path);
cleanup_out_format(state, REC_TYPE_PTR, REC_TYPE_PTR_FORMAT, 0L);
if ((state->append_rcpt_pt_target = vstream_ftell(state->dst)) < 0)
msg_fatal("%s: vstream_ftell %s: %m:", myname, cleanup_path);
}
state->flags &= ~CLEANUP_FLAG_INRCPT;
}
return;
}
if (state->flags & CLEANUP_FLAG_INRCPT)
state->qmgr_opts |= QMGR_READ_FLAG_MIXED_RCPT_OTHER;
if (type == REC_TYPE_SIZE)
return;
if (mapped_type == REC_TYPE_CTIME)
return;
if (type == REC_TYPE_TIME) {
if (state->arrival_time.tv_sec == 0) {
REC_TYPE_TIME_SCAN(buf, state->arrival_time);
cleanup_out(state, type, buf, len);
}
cleanup_out_format(state, REC_TYPE_ATTR, "%s=%ld",
MAIL_ATTR_CREATE_TIME, (long) time((time_t *) 0));
return;
}
if (type == REC_TYPE_FULL) {
if (state->fullname == 0) {
state->fullname = mystrdup(buf);
cleanup_out(state, type, buf, len);
}
return;
}
if (type == REC_TYPE_FROM) {
if (state->sender != 0) {
msg_warn("%s: message rejected: multiple envelope sender records",
state->queue_id);
state->errs |= CLEANUP_STAT_BAD;
return;
}
cleanup_addr_sender(state, buf);
if (cleanup_milters != 0
&& state->milters == 0
&& CLEANUP_MILTER_OK(state))
cleanup_milter_emul_mail(state, cleanup_milters, buf);
return;
}
if (mapped_type == REC_TYPE_DSN_ENVID) {
if (state->dsn_envid != 0) {
msg_warn("%s: message rejected: multiple DSN envelope ID records",
state->queue_id);
state->errs |= CLEANUP_STAT_BAD;
return;
}
if (!allprint(mapped_buf)) {
msg_warn("%s: message rejected: bad DSN envelope ID record",
state->queue_id);
state->errs |= CLEANUP_STAT_BAD;
return;
}
state->dsn_envid = mystrdup(mapped_buf);
cleanup_out(state, type, buf, len);
return;
}
if (mapped_type == REC_TYPE_DSN_RET) {
if (state->dsn_ret != 0) {
msg_warn("%s: message rejected: multiple DSN RET records",
state->queue_id);
state->errs |= CLEANUP_STAT_BAD;
return;
}
if (!alldig(mapped_buf) || (junk = atoi(mapped_buf)) == 0
|| DSN_RET_OK(junk) == 0) {
msg_warn("%s: message rejected: bad DSN RET record <%.200s>",
state->queue_id, buf);
state->errs |= CLEANUP_STAT_BAD;
return;
}
state->dsn_ret = junk;
cleanup_out(state, type, buf, len);
return;
}
if (type == REC_TYPE_WARN) {
if ((state->flags & CLEANUP_FLAG_WARN_SEEN) == 0) {
state->flags |= CLEANUP_FLAG_WARN_SEEN;
cleanup_out(state, type, buf, len);
}
return;
}
if (type == REC_TYPE_VERP) {
if (state->verp_delims == 0) {
if (state->sender == 0 || state->sender[0] == 0) {
msg_warn("%s: ignoring VERP request for null sender",
state->queue_id);
} else if (verp_delims_verify(buf) != 0) {
msg_warn("%s: ignoring bad VERP request: \"%.100s\"",
state->queue_id, buf);
} else {
state->verp_delims = mystrdup(buf);
cleanup_out(state, type, buf, len);
}
}
return;
}
if (type == REC_TYPE_ATTR) {
if (state->attr->used >= var_qattr_count_limit) {
msg_warn("%s: message rejected: attribute count exceeds limit %d",
state->queue_id, var_qattr_count_limit);
state->errs |= CLEANUP_STAT_BAD;
return;
}
if (strcmp(attr_name, MAIL_ATTR_RWR_CONTEXT) == 0) {
if (STREQ(attr_value, MAIL_ATTR_RWR_LOCAL)) {
state->hdr_rewrite_context = MAIL_ATTR_RWR_LOCAL;
} else if (STREQ(attr_value, MAIL_ATTR_RWR_REMOTE)) {
state->hdr_rewrite_context =
(*var_remote_rwr_domain ? MAIL_ATTR_RWR_REMOTE : 0);
} else {
msg_warn("%s: message rejected: bad rewriting context: %.100s",
state->queue_id, attr_value);
state->errs |= CLEANUP_STAT_BAD;
return;
}
}
nvtable_update(state->attr, attr_name, attr_value);
cleanup_out(state, type, buf, len);
return;
} else {
cleanup_out(state, type, buf, len);
return;
}
}