#include <sys_defs.h>
#include <ctype.h>
#include <unistd.h>
#ifdef STRCASECMP_IN_STRINGS_H
#include <strings.h>
#endif
#include <msg.h>
#include <vstream.h>
#include <vstring.h>
#include <stringops.h>
#include <connect.h>
#include <name_code.h>
#include <mymalloc.h>
#include <mail_error.h>
#include <smtp_stream.h>
#include <cleanup_user.h>
#include <mail_params.h>
#include <rec_type.h>
#include <mail_proto.h>
#include <mail_params.h>
#include <xtext.h>
#include <record.h>
#include <mail_queue.h>
#include <smtpd.h>
#include <smtpd_proxy.h>
#define SMTPD_PROXY_XFORWARD_NAME (1<<0)
#define SMTPD_PROXY_XFORWARD_ADDR (1<<1)
#define SMTPD_PROXY_XFORWARD_PROTO (1<<2)
#define SMTPD_PROXY_XFORWARD_HELO (1<<3)
#define SMTPD_PROXY_XFORWARD_IDENT (1<<4)
#define SMTPD_PROXY_XFORWARD_DOMAIN (1<<5)
#define SMTPD_PROXY_XFORWARD_PORT (1<<6)
static VSTREAM *smtpd_proxy_replay_stream;
static void smtpd_proxy_fake_server_reply(SMTPD_STATE *, int);
static int smtpd_proxy_rdwr_error(SMTPD_STATE *, int);
static int smtpd_proxy_cmd(SMTPD_STATE *, int, const char *,...);
static int smtpd_proxy_rec_put(VSTREAM *, int, const char *, ssize_t);
#define STR(x) vstring_str(x)
#define LEN(x) VSTRING_LEN(x)
#define SMTPD_PROXY_CONN_FMT null_format_string
#define STREQ(x, y) (strcmp((x), (y)) == 0)
static int smtpd_proxy_xforward_flush(SMTPD_STATE *state, VSTRING *buf)
{
int ret;
if (VSTRING_LEN(buf) > 0) {
ret = smtpd_proxy_cmd(state, SMTPD_PROX_WANT_OK,
XFORWARD_CMD "%s", STR(buf));
VSTRING_RESET(buf);
return (ret);
}
return (0);
}
static int smtpd_proxy_xforward_send(SMTPD_STATE *state, VSTRING *buf,
const char *name,
int value_available,
const char *value)
{
size_t new_len;
int ret;
#define CONSTR_LEN(s) (sizeof(s) - 1)
#define PAYLOAD_LIMIT (512 - CONSTR_LEN("250 " XFORWARD_CMD "\r\n"))
if (!value_available)
value = XFORWARD_UNAVAILABLE;
if (state->expand_buf == 0)
state->expand_buf = vstring_alloc(100);
xtext_quote(state->expand_buf, value, "");
new_len = strlen(name) + strlen(STR(state->expand_buf)) + 2;
if (new_len > PAYLOAD_LIMIT)
msg_warn("%s command payload %s=%.10s... exceeds SMTP protocol limit",
XFORWARD_CMD, name, value);
if (VSTRING_LEN(buf) > 0 && VSTRING_LEN(buf) + new_len > PAYLOAD_LIMIT)
if ((ret = smtpd_proxy_xforward_flush(state, buf)) < 0)
return (ret);
vstring_sprintf_append(buf, " %s=%s", name, STR(state->expand_buf));
return (0);
}
static int smtpd_proxy_connect(SMTPD_STATE *state)
{
SMTPD_PROXY *proxy = state->proxy;
int fd;
char *lines;
char *words;
VSTRING *buf;
int bad;
char *word;
static const NAME_CODE known_xforward_features[] = {
XFORWARD_NAME, SMTPD_PROXY_XFORWARD_NAME,
XFORWARD_ADDR, SMTPD_PROXY_XFORWARD_ADDR,
XFORWARD_PORT, SMTPD_PROXY_XFORWARD_PORT,
XFORWARD_PROTO, SMTPD_PROXY_XFORWARD_PROTO,
XFORWARD_HELO, SMTPD_PROXY_XFORWARD_HELO,
XFORWARD_IDENT, SMTPD_PROXY_XFORWARD_IDENT,
XFORWARD_DOMAIN, SMTPD_PROXY_XFORWARD_DOMAIN,
0, 0,
};
int server_xforward_features;
int (*connect_fn) (const char *, int, int);
const char *endpoint;
if (strncasecmp("unix:", proxy->service_name, 5) == 0) {
endpoint = proxy->service_name + 5;
connect_fn = unix_connect;
} else {
if (strncasecmp("inet:", proxy->service_name, 5) == 0)
endpoint = proxy->service_name + 5;
else
endpoint = proxy->service_name;
connect_fn = inet_connect;
}
if ((fd = connect_fn(endpoint, BLOCKING, proxy->timeout)) < 0) {
msg_warn("connect to proxy filter %s: %m", proxy->service_name);
return (smtpd_proxy_rdwr_error(state, 0));
}
proxy->service_stream = vstream_fdopen(fd, O_RDWR);
vstream_control(proxy->service_stream, VSTREAM_CTL_CONTEXT,
(char *) state, VSTREAM_CTL_END);
if (connect_fn == inet_connect)
vstream_tweak_tcp(proxy->service_stream);
smtp_timeout_setup(proxy->service_stream, proxy->timeout);
if (smtpd_proxy_cmd(state, SMTPD_PROX_WANT_OK, SMTPD_PROXY_CONN_FMT)) {
smtpd_proxy_fake_server_reply(state, CLEANUP_STAT_PROXY);
smtpd_proxy_close(state);
return (-1);
}
if (smtpd_proxy_cmd(state, SMTPD_PROX_WANT_OK, "EHLO %s",
proxy->ehlo_name)) {
smtpd_proxy_fake_server_reply(state, CLEANUP_STAT_PROXY);
smtpd_proxy_close(state);
return (-1);
}
server_xforward_features = 0;
lines = STR(proxy->buffer);
while ((words = mystrtok(&lines, "\n")) != 0) {
if (mystrtok(&words, "- ") && (word = mystrtok(&words, " \t")) != 0) {
if (strcasecmp(word, XFORWARD_CMD) == 0)
while ((word = mystrtok(&words, " \t")) != 0)
server_xforward_features |=
name_code(known_xforward_features,
NAME_CODE_FLAG_NONE, word);
}
}
if (server_xforward_features) {
buf = vstring_alloc(100);
bad =
(((server_xforward_features & SMTPD_PROXY_XFORWARD_NAME)
&& smtpd_proxy_xforward_send(state, buf, XFORWARD_NAME,
IS_AVAIL_CLIENT_NAME(FORWARD_NAME(state)),
FORWARD_NAME(state)))
|| ((server_xforward_features & SMTPD_PROXY_XFORWARD_ADDR)
&& smtpd_proxy_xforward_send(state, buf, XFORWARD_ADDR,
IS_AVAIL_CLIENT_ADDR(FORWARD_ADDR(state)),
FORWARD_ADDR(state)))
|| ((server_xforward_features & SMTPD_PROXY_XFORWARD_PORT)
&& smtpd_proxy_xforward_send(state, buf, XFORWARD_PORT,
IS_AVAIL_CLIENT_PORT(FORWARD_PORT(state)),
FORWARD_PORT(state)))
|| ((server_xforward_features & SMTPD_PROXY_XFORWARD_HELO)
&& smtpd_proxy_xforward_send(state, buf, XFORWARD_HELO,
IS_AVAIL_CLIENT_HELO(FORWARD_HELO(state)),
FORWARD_HELO(state)))
|| ((server_xforward_features & SMTPD_PROXY_XFORWARD_IDENT)
&& smtpd_proxy_xforward_send(state, buf, XFORWARD_IDENT,
IS_AVAIL_CLIENT_IDENT(FORWARD_IDENT(state)),
FORWARD_IDENT(state)))
|| ((server_xforward_features & SMTPD_PROXY_XFORWARD_PROTO)
&& smtpd_proxy_xforward_send(state, buf, XFORWARD_PROTO,
IS_AVAIL_CLIENT_PROTO(FORWARD_PROTO(state)),
FORWARD_PROTO(state)))
|| ((server_xforward_features & SMTPD_PROXY_XFORWARD_DOMAIN)
&& smtpd_proxy_xforward_send(state, buf, XFORWARD_DOMAIN, 1,
STREQ(FORWARD_DOMAIN(state), MAIL_ATTR_RWR_LOCAL) ?
XFORWARD_DOM_LOCAL : XFORWARD_DOM_REMOTE))
|| smtpd_proxy_xforward_flush(state, buf));
vstring_free(buf);
if (bad) {
smtpd_proxy_fake_server_reply(state, CLEANUP_STAT_PROXY);
smtpd_proxy_close(state);
return (-1);
}
}
if (smtpd_proxy_cmd(state, SMTPD_PROX_WANT_OK, "%s",
proxy->mail_from) != 0) {
smtpd_proxy_close(state);
return (-1);
}
return (0);
}
static void smtpd_proxy_fake_server_reply(SMTPD_STATE *state, int status)
{
const CLEANUP_STAT_DETAIL *detail;
detail = cleanup_stat_detail(status);
vstring_sprintf(state->proxy->buffer,
"%d %s Error: %s",
detail->smtp, detail->dsn, detail->text);
}
static int smtpd_proxy_replay_rdwr_error(SMTPD_STATE *state)
{
msg_warn("proxy speed-adjust log I/O error: %m");
state->error_mask |= MAIL_ERROR_RESOURCE;
state->err |= CLEANUP_STAT_PROXY;
smtpd_proxy_fake_server_reply(state, CLEANUP_STAT_PROXY);
return (-1);
}
static int smtpd_proxy_rdwr_error(SMTPD_STATE *state, int err)
{
const char *myname = "smtpd_proxy_rdwr_error";
SMTPD_PROXY *proxy = state->proxy;
if (err != 0 && err != SMTP_ERR_NONE && proxy == 0)
msg_panic("%s: proxy error %d without proxy handle", myname, err);
switch (err) {
case 0:
case SMTP_ERR_NONE:
break;
case SMTP_ERR_EOF:
msg_warn("lost connection with proxy %s", proxy->service_name);
break;
case SMTP_ERR_TIME:
msg_warn("timeout talking to proxy %s", proxy->service_name);
break;
default:
msg_panic("%s: unknown proxy %s error %d",
myname, proxy->service_name, err);
}
state->error_mask |= MAIL_ERROR_SOFTWARE;
state->err |= CLEANUP_STAT_PROXY;
smtpd_proxy_fake_server_reply(state, CLEANUP_STAT_PROXY);
return (-1);
}
static int smtpd_proxy_replay_send(SMTPD_STATE *state)
{
const char *myname = "smtpd_proxy_replay_send";
static VSTRING *replay_buf = 0;
SMTPD_PROXY *proxy = state->proxy;
int rec_type;
int expect = SMTPD_PROX_WANT_BAD;
if (smtpd_proxy_replay_stream == 0)
msg_panic("%s: no before-queue filter speed-adjust log", myname);
if (vstream_ferror(smtpd_proxy_replay_stream)
|| vstream_feof(smtpd_proxy_replay_stream)
|| rec_put(smtpd_proxy_replay_stream, REC_TYPE_END, "", 0) != REC_TYPE_END
|| vstream_fflush(smtpd_proxy_replay_stream))
return (smtpd_proxy_replay_rdwr_error(state));
if (smtpd_proxy_connect(state) < 0)
return (-1);
if (replay_buf == 0)
replay_buf = vstring_alloc(100);
if (vstream_fseek(smtpd_proxy_replay_stream, (off_t) 0, SEEK_SET) < 0)
return (smtpd_proxy_replay_rdwr_error(state));
for (;;) {
switch (rec_type = rec_get(smtpd_proxy_replay_stream, replay_buf,
REC_FLAG_NONE)) {
case REC_TYPE_NORM:
case REC_TYPE_CONT:
if (smtpd_proxy_rec_put(proxy->service_stream, rec_type,
STR(replay_buf), LEN(replay_buf)) < 0)
return (-1);
break;
case REC_TYPE_RCPT:
if (!alldig(STR(replay_buf))
|| (expect = atoi(STR(replay_buf))) == SMTPD_PROX_WANT_BAD)
msg_panic("%s: malformed server reply type: %s",
myname, STR(replay_buf));
break;
case REC_TYPE_FROM:
if (expect == SMTPD_PROX_WANT_BAD)
msg_panic("%s: missing server reply type", myname);
if (smtpd_proxy_cmd(state, expect, *STR(replay_buf) ? "%s" :
SMTPD_PROXY_CONN_FMT, STR(replay_buf)) < 0)
return (-1);
expect = SMTPD_PROX_WANT_BAD;
break;
case REC_TYPE_END:
return (0);
case REC_TYPE_ERROR:
return (smtpd_proxy_replay_rdwr_error(state));
default:
msg_panic("%s: unexpected record type; %d", myname, rec_type);
}
}
}
static int smtpd_proxy_save_cmd(SMTPD_STATE *state, int expect, const char *fmt,...)
{
va_list ap;
if (vstream_ferror(smtpd_proxy_replay_stream)
|| vstream_feof(smtpd_proxy_replay_stream))
return (smtpd_proxy_replay_rdwr_error(state));
rec_fprintf(smtpd_proxy_replay_stream, REC_TYPE_RCPT, "%d", expect);
if (fmt == SMTPD_PROXY_CONN_FMT)
fmt = "";
va_start(ap, fmt);
rec_vfprintf(smtpd_proxy_replay_stream, REC_TYPE_FROM, fmt, ap);
va_end(ap);
return (strcmp(fmt, ".") ? 0 : smtpd_proxy_replay_send(state));
}
static void smtpd_proxy_cmd_warn(SMTPD_STATE *state, const char *fmt,
va_list ap)
{
SMTPD_PROXY *proxy = state->proxy;
VSTRING *buf;
buf = vstring_alloc(100);
vstring_vsprintf(buf, fmt == SMTPD_PROXY_CONN_FMT ?
"connection request" : fmt, ap);
msg_warn("proxy %s rejected \"%s\": \"%s\"",
proxy->service_name, STR(buf), STR(proxy->buffer));
vstring_free(buf);
}
static int smtpd_proxy_cmd(SMTPD_STATE *state, int expect, const char *fmt,...)
{
SMTPD_PROXY *proxy = state->proxy;
va_list ap;
char *cp;
int last_char;
int err = 0;
static VSTRING *buffer = 0;
if (vstream_ferror(proxy->service_stream)
|| vstream_feof(proxy->service_stream)
|| (err = vstream_setjmp(proxy->service_stream)) != 0) {
return (smtpd_proxy_rdwr_error(state, err));
}
if (fmt != SMTPD_PROXY_CONN_FMT) {
va_start(ap, fmt);
vstring_vsprintf(proxy->buffer, fmt, ap);
va_end(ap);
if (msg_verbose)
msg_info("> %s: %s", proxy->service_name, STR(proxy->buffer));
smtp_fputs(STR(proxy->buffer), LEN(proxy->buffer),
proxy->service_stream);
}
if (expect == SMTPD_PROX_WANT_NONE)
return (0);
VSTRING_RESET(proxy->buffer);
if (buffer == 0)
buffer = vstring_alloc(10);
for (;;) {
last_char = smtp_get(buffer, proxy->service_stream, var_line_limit,
SMTP_GET_FLAG_SKIP);
printable(STR(buffer), '?');
if (last_char != '\n')
msg_warn("%s: response longer than %d: %.30s...",
proxy->service_name, var_line_limit,
STR(buffer));
if (msg_verbose)
msg_info("< %s: %.100s", proxy->service_name, STR(buffer));
if (LEN(proxy->buffer) < var_line_limit) {
if (VSTRING_LEN(proxy->buffer))
vstring_strcat(proxy->buffer, "\r\n");
vstring_strcat(proxy->buffer, STR(buffer));
}
for (cp = STR(buffer); *cp && ISDIGIT(*cp); cp++)
;
if (cp - STR(buffer) == 3) {
if (*cp == '-')
continue;
if (*cp == ' ' || *cp == 0)
break;
}
msg_warn("received garbage from proxy %s: %.100s",
proxy->service_name, STR(buffer));
}
if (expect != SMTPD_PROX_WANT_ANY && expect != *STR(proxy->buffer)) {
va_start(ap, fmt);
smtpd_proxy_cmd_warn(state, fmt, ap);
va_end(ap);
if (*STR(proxy->buffer) == SMTPD_PROX_WANT_OK
|| *STR(proxy->buffer) == SMTPD_PROX_WANT_MORE) {
smtpd_proxy_rdwr_error(state, 0);
}
return (-1);
} else {
return (0);
}
}
static int smtpd_proxy_save_rec_put(VSTREAM *stream, int rec_type,
const char *data, ssize_t len)
{
const char *myname = "smtpd_proxy_save_rec_put";
int ret;
#define VSTREAM_TO_SMTPD_STATE(s) ((SMTPD_STATE *) vstream_context(s))
if (stream == 0)
msg_panic("%s: attempt to use closed stream", myname);
if (rec_type == REC_TYPE_NORM || rec_type == REC_TYPE_CONT)
ret = rec_put(stream, rec_type, data, len);
else
msg_panic("%s: need REC_TYPE_NORM or REC_TYPE_CONT", myname);
if (ret != rec_type) {
(void) smtpd_proxy_replay_rdwr_error(VSTREAM_TO_SMTPD_STATE(stream));
return (REC_TYPE_ERROR);
}
return (rec_type);
}
static int smtpd_proxy_rec_put(VSTREAM *stream, int rec_type,
const char *data, ssize_t len)
{
const char *myname = "smtpd_proxy_rec_put";
int err = 0;
if (vstream_ferror(stream) || vstream_feof(stream)
|| (err = vstream_setjmp(stream)) != 0) {
(void) smtpd_proxy_rdwr_error(VSTREAM_TO_SMTPD_STATE(stream), err);
return (REC_TYPE_ERROR);
}
if (rec_type == REC_TYPE_NORM)
smtp_fputs(data, len, stream);
else if (rec_type == REC_TYPE_CONT)
smtp_fwrite(data, len, stream);
else
msg_panic("%s: need REC_TYPE_NORM or REC_TYPE_CONT", myname);
return (rec_type);
}
static int smtpd_proxy_save_rec_fprintf(VSTREAM *stream, int rec_type,
const char *fmt,...)
{
const char *myname = "smtpd_proxy_save_rec_fprintf";
va_list ap;
int ret;
if (stream == 0)
msg_panic("%s: attempt to use closed stream", myname);
va_start(ap, fmt);
if (rec_type == REC_TYPE_NORM)
ret = rec_vfprintf(stream, rec_type, fmt, ap);
else
msg_panic("%s: need REC_TYPE_NORM", myname);
va_end(ap);
if (ret != rec_type) {
(void) smtpd_proxy_replay_rdwr_error(VSTREAM_TO_SMTPD_STATE(stream));
return (REC_TYPE_ERROR);
}
return (rec_type);
}
static int smtpd_proxy_rec_fprintf(VSTREAM *stream, int rec_type,
const char *fmt,...)
{
const char *myname = "smtpd_proxy_rec_fprintf";
va_list ap;
int err = 0;
if (vstream_ferror(stream) || vstream_feof(stream)
|| (err = vstream_setjmp(stream)) != 0) {
(void) smtpd_proxy_rdwr_error(VSTREAM_TO_SMTPD_STATE(stream), err);
return (REC_TYPE_ERROR);
}
va_start(ap, fmt);
if (rec_type == REC_TYPE_NORM)
smtp_vprintf(stream, fmt, ap);
else
msg_panic("%s: need REC_TYPE_NORM", myname);
va_end(ap);
return (rec_type);
}
#ifndef NO_TRUNCATE
static int smtpd_proxy_replay_setup(SMTPD_STATE *state)
{
const char *myname = "smtpd_proxy_replay_setup";
off_t file_offs;
if (smtpd_proxy_replay_stream != 0) {
if ((file_offs = vstream_ftell(smtpd_proxy_replay_stream)) != 0)
msg_panic("%s: bad before-queue filter speed-adjust log offset %lu",
myname, (unsigned long) file_offs);
vstream_clearerr(smtpd_proxy_replay_stream);
if (msg_verbose)
msg_info("%s: reuse speed-adjust stream fd=%d", myname,
vstream_fileno(smtpd_proxy_replay_stream));
}
if (smtpd_proxy_replay_stream == 0) {
smtpd_proxy_replay_stream = mail_queue_enter(MAIL_QUEUE_INCOMING, 0,
(struct timeval *) 0);
if (smtpd_proxy_replay_stream == 0)
return (smtpd_proxy_replay_rdwr_error(state));
if (unlink(VSTREAM_PATH(smtpd_proxy_replay_stream)) < 0)
msg_warn("remove before-queue filter speed-adjust log %s: %m",
VSTREAM_PATH(smtpd_proxy_replay_stream));
if (msg_verbose)
msg_info("%s: new speed-adjust stream fd=%d", myname,
vstream_fileno(smtpd_proxy_replay_stream));
}
vstream_control(smtpd_proxy_replay_stream, VSTREAM_CTL_CONTEXT,
(char *) state, VSTREAM_CTL_END);
return (0);
}
#endif
int smtpd_proxy_create(SMTPD_STATE *state, int flags, const char *service,
int timeout, const char *ehlo_name,
const char *mail_from)
{
SMTPD_PROXY *proxy;
#define SMTPD_PROXY_ALLOC(p, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) \
((p) = (SMTPD_PROXY *) mymalloc(sizeof(*(p))), (p)->a1, (p)->a2, \
(p)->a3, (p)->a4, (p)->a5, (p)->a6, (p)->a7, (p)->a8, (p)->a9, \
(p)->a10, (p)->a11, (p))
if (state->proxy != 0)
msg_panic("smtpd_proxy_create: handle still exists");
if ((flags & SMTPD_PROXY_FLAG_SPEED_ADJUST) == 0) {
state->proxy =
SMTPD_PROXY_ALLOC(proxy, stream = 0, buffer = vstring_alloc(10),
cmd = smtpd_proxy_cmd,
rec_fprintf = smtpd_proxy_rec_fprintf,
rec_put = smtpd_proxy_rec_put,
flags = flags, service_stream = 0,
service_name = service, timeout = timeout,
ehlo_name = ehlo_name, mail_from = mail_from);
if (smtpd_proxy_connect(state) < 0) {
return (-1);
}
proxy->stream = proxy->service_stream;
return (0);
}
else {
#ifdef NO_TRUNCATE
msg_panic("smtpd_proxy_create: speed-adjust support is not available");
#else
if (smtpd_proxy_replay_setup(state) < 0)
return (-1);
state->proxy =
SMTPD_PROXY_ALLOC(proxy, stream = smtpd_proxy_replay_stream,
buffer = vstring_alloc(10),
cmd = smtpd_proxy_save_cmd,
rec_fprintf = smtpd_proxy_save_rec_fprintf,
rec_put = smtpd_proxy_save_rec_put,
flags = flags, service_stream = 0,
service_name = service, timeout = timeout,
ehlo_name = ehlo_name, mail_from = mail_from);
return (0);
#endif
}
}
void smtpd_proxy_close(SMTPD_STATE *state)
{
SMTPD_PROXY *proxy = state->proxy;
if (proxy->service_stream != 0) {
#if 0
if (vstream_feof(proxy->service_stream) == 0
&& vstream_ferror(proxy->service_stream) == 0)
(void) smtpd_proxy_cmd(state, SMTPD_PROX_WANT_NONE,
SMTPD_CMD_QUIT);
#endif
(void) vstream_fclose(proxy->service_stream);
if (proxy->stream == proxy->service_stream)
proxy->stream = 0;
proxy->service_stream = 0;
}
}
void smtpd_proxy_free(SMTPD_STATE *state)
{
SMTPD_PROXY *proxy = state->proxy;
if (proxy->service_stream != 0)
(void) smtpd_proxy_close(state);
if (proxy->buffer != 0)
vstring_free(proxy->buffer);
myfree((char *) proxy);
state->proxy = 0;
if (smtpd_proxy_replay_stream == 0)
return;
if (vstream_ferror(smtpd_proxy_replay_stream)) {
(void) vstream_fclose(smtpd_proxy_replay_stream);
smtpd_proxy_replay_stream = 0;
return;
}
if (vstream_fseek(smtpd_proxy_replay_stream, (off_t) 0, SEEK_SET) < 0) {
msg_warn("seek before-queue filter speed-adjust log: %m");
(void) vstream_fclose(smtpd_proxy_replay_stream);
smtpd_proxy_replay_stream = 0;
return;
}
if (ftruncate(vstream_fileno(smtpd_proxy_replay_stream), (off_t) 0) < 0) {
msg_warn("truncate before-queue filter speed-adjust log: %m");
(void) vstream_fclose(smtpd_proxy_replay_stream);
smtpd_proxy_replay_stream = 0;
return;
}
}
int smtpd_proxy_parse_opts(const char *param_name, const char *param_val)
{
static const NAME_MASK proxy_opts_table[] = {
SMTPD_PROXY_NAME_SPEED_ADJUST, SMTPD_PROXY_FLAG_SPEED_ADJUST,
0, 0,
};
int flags;
flags = name_mask(param_name, proxy_opts_table, param_val);
if (flags & SMTPD_PROXY_FLAG_SPEED_ADJUST) {
#ifdef NO_TRUNCATE
msg_warn("smtpd_proxy %s support is not available",
SMTPD_PROXY_NAME_SPEED_ADJUST);
flags &= ~SMTPD_PROXY_FLAG_SPEED_ADJUST;
#endif
}
return (flags);
}