/*      $OpenBSD: mta.c,v 1.248 2024/04/23 13:34:51 jsg Exp $   */

/*
 * Copyright (c) 2008 Pierre-Yves Ritschard <pyr@openbsd.org>
 * Copyright (c) 2008 Gilles Chehade <gilles@poolp.org>
 * Copyright (c) 2009 Jacek Masiulaniec <jacekm@dobremiasto.net>
 * Copyright (c) 2012 Eric Faurot <eric@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <inttypes.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <tls.h>

#include "smtpd.h"
#include "log.h"
#include "ssl.h"

#define MAXERROR_PER_ROUTE      4

#define DELAY_CHECK_SOURCE      1
#define DELAY_CHECK_SOURCE_SLOW 10
#define DELAY_CHECK_SOURCE_FAST 0
#define DELAY_CHECK_LIMIT       5

#define DELAY_QUADRATIC         1
#define DELAY_ROUTE_BASE        15
#define DELAY_ROUTE_MAX         3600

#define RELAY_ONHOLD            0x01
#define RELAY_HOLDQ             0x02

static void mta_setup_dispatcher(struct dispatcher *);
static void mta_handle_envelope(struct envelope *, const char *);
static void mta_query_smarthost(struct envelope *);
static void mta_on_smarthost(struct envelope *, const char *);
static void mta_query_mx(struct mta_relay *);
static void mta_query_secret(struct mta_relay *);
static void mta_query_preference(struct mta_relay *);
static void mta_query_source(struct mta_relay *);
static void mta_on_mx(void *, void *, void *);
static void mta_on_secret(struct mta_relay *, const char *);
static void mta_on_preference(struct mta_relay *, int);
static void mta_on_source(struct mta_relay *, struct mta_source *);
static void mta_on_timeout(struct runq *, void *);
static void mta_connect(struct mta_connector *);
static void mta_route_enable(struct mta_route *);
static void mta_route_disable(struct mta_route *, int, int);
static void mta_drain(struct mta_relay *);
static void mta_delivery_flush_event(int, short, void *);
static void mta_flush(struct mta_relay *, int, const char *);
static struct mta_route *mta_find_route(struct mta_connector *, time_t, int*,
    time_t*, struct mta_mx **);
static void mta_log(const struct mta_envelope *, const char *, const char *,
    const char *, const char *);

SPLAY_HEAD(mta_relay_tree, mta_relay);
static struct mta_relay *mta_relay(struct envelope *, struct relayhost *);
static void mta_relay_ref(struct mta_relay *);
static void mta_relay_unref(struct mta_relay *);
static void mta_relay_show(struct mta_relay *, struct mproc *, uint32_t, time_t);
static int mta_relay_cmp(const struct mta_relay *, const struct mta_relay *);
SPLAY_PROTOTYPE(mta_relay_tree, mta_relay, entry, mta_relay_cmp);

SPLAY_HEAD(mta_host_tree, mta_host);
static struct mta_host *mta_host(const struct sockaddr *);
static void mta_host_ref(struct mta_host *);
static void mta_host_unref(struct mta_host *);
static int mta_host_cmp(const struct mta_host *, const struct mta_host *);
SPLAY_PROTOTYPE(mta_host_tree, mta_host, entry, mta_host_cmp);

SPLAY_HEAD(mta_domain_tree, mta_domain);
static struct mta_domain *mta_domain(char *, int);
#if 0
static void mta_domain_ref(struct mta_domain *);
#endif
static void mta_domain_unref(struct mta_domain *);
static int mta_domain_cmp(const struct mta_domain *, const struct mta_domain *);
SPLAY_PROTOTYPE(mta_domain_tree, mta_domain, entry, mta_domain_cmp);

SPLAY_HEAD(mta_source_tree, mta_source);
static struct mta_source *mta_source(const struct sockaddr *);
static void mta_source_ref(struct mta_source *);
static void mta_source_unref(struct mta_source *);
static const char *mta_source_to_text(struct mta_source *);
static int mta_source_cmp(const struct mta_source *, const struct mta_source *);
SPLAY_PROTOTYPE(mta_source_tree, mta_source, entry, mta_source_cmp);

static struct mta_connector *mta_connector(struct mta_relay *,
    struct mta_source *);
static void mta_connector_free(struct mta_connector *);
static const char *mta_connector_to_text(struct mta_connector *);

SPLAY_HEAD(mta_route_tree, mta_route);
static struct mta_route *mta_route(struct mta_source *, struct mta_host *);
static void mta_route_ref(struct mta_route *);
static void mta_route_unref(struct mta_route *);
static const char *mta_route_to_text(struct mta_route *);
static int mta_route_cmp(const struct mta_route *, const struct mta_route *);
SPLAY_PROTOTYPE(mta_route_tree, mta_route, entry, mta_route_cmp);

struct mta_block {
        SPLAY_ENTRY(mta_block)   entry;
        struct mta_source       *source;
        char                    *domain;
};

SPLAY_HEAD(mta_block_tree, mta_block);
void mta_block(struct mta_source *, char *);
void mta_unblock(struct mta_source *, char *);
int mta_is_blocked(struct mta_source *, char *);
static int mta_block_cmp(const struct mta_block *, const struct mta_block *);
SPLAY_PROTOTYPE(mta_block_tree, mta_block, entry, mta_block_cmp);

/*
 * This function is not publicy exported because it is a hack until libtls
 * has a proper privsep setup
 */
void tls_config_use_fake_private_key(struct tls_config *config);

static struct mta_relay_tree            relays;
static struct mta_domain_tree           domains;
static struct mta_host_tree             hosts;
static struct mta_source_tree           sources;
static struct mta_route_tree            routes;
static struct mta_block_tree            blocks;

static struct tree wait_mx;
static struct tree wait_preference;
static struct tree wait_secret;
static struct tree wait_smarthost;
static struct tree wait_source;
static struct tree flush_evp;
static struct event ev_flush_evp;

static struct runq *runq_relay;
static struct runq *runq_connector;
static struct runq *runq_route;
static struct runq *runq_hoststat;

static time_t   max_seen_conndelay_route;
static time_t   max_seen_discdelay_route;

#define HOSTSTAT_EXPIRE_DELAY   (4 * 3600)
struct hoststat {
        char                     name[HOST_NAME_MAX+1];
        time_t                   tm;
        char                     error[LINE_MAX];
        struct tree              deferred;
};
static struct dict hoststat;

void mta_hoststat_update(const char *, const char *);
void mta_hoststat_cache(const char *, uint64_t);
void mta_hoststat_uncache(const char *, uint64_t);
void mta_hoststat_reschedule(const char *);
static void mta_hoststat_remove_entry(struct hoststat *);

void
mta_imsg(struct mproc *p, struct imsg *imsg)
{
        struct mta_relay        *relay;
        struct mta_domain       *domain;
        struct mta_host         *host;
        struct mta_route        *route;
        struct mta_block        *block;
        struct mta_mx           *mx, *imx;
        struct mta_source       *source;
        struct hoststat         *hs;
        struct sockaddr_storage  ss;
        struct envelope          evp, *e;
        struct msg               m;
        const char              *secret;
        const char              *hostname;
        const char              *dom;
        const char              *smarthost;
        uint64_t                 reqid;
        time_t                   t;
        char                     buf[LINE_MAX];
        int                      dnserror, preference, v, status;
        void                    *iter;
        uint64_t                 u64;

        switch (imsg->hdr.type) {
        case IMSG_QUEUE_TRANSFER:
                m_msg(&m, imsg);
                m_get_envelope(&m, &evp);
                m_end(&m);
                mta_handle_envelope(&evp, NULL);
                return;

        case IMSG_MTA_OPEN_MESSAGE:
                mta_session_imsg(p, imsg);
                return;

        case IMSG_MTA_LOOKUP_CREDENTIALS:
                m_msg(&m, imsg);
                m_get_id(&m, &reqid);
                m_get_string(&m, &secret);
                m_end(&m);
                relay = tree_xpop(&wait_secret, reqid);
                mta_on_secret(relay, secret[0] ? secret : NULL);
                return;

        case IMSG_MTA_LOOKUP_SOURCE:
                m_msg(&m, imsg);
                m_get_id(&m, &reqid);
                m_get_int(&m, &status);
                if (status == LKA_OK)
                        m_get_sockaddr(&m, (struct sockaddr*)&ss);
                m_end(&m);

                relay = tree_xpop(&wait_source, reqid);
                mta_on_source(relay, (status == LKA_OK) ?
                    mta_source((struct sockaddr *)&ss) : NULL);
                return;

        case IMSG_MTA_LOOKUP_SMARTHOST:
                m_msg(&m, imsg);
                m_get_id(&m, &reqid);
                m_get_int(&m, &status);
                smarthost = NULL;
                if (status == LKA_OK)
                        m_get_string(&m, &smarthost);
                m_end(&m);

                e = tree_xpop(&wait_smarthost, reqid);
                mta_on_smarthost(e, smarthost);
                return;

        case IMSG_MTA_LOOKUP_HELO:
                mta_session_imsg(p, imsg);
                return;

        case IMSG_MTA_DNS_HOST:
                m_msg(&m, imsg);
                m_get_id(&m, &reqid);
                m_get_string(&m, &hostname);
                m_get_sockaddr(&m, (struct sockaddr*)&ss);
                m_get_int(&m, &preference);
                m_end(&m);
                domain = tree_xget(&wait_mx, reqid);
                mx = xcalloc(1, sizeof *mx);
                mx->mxname = xstrdup(hostname);
                mx->host = mta_host((struct sockaddr*)&ss);
                mx->preference = preference;
                TAILQ_FOREACH(imx, &domain->mxs, entry) {
                        if (imx->preference > mx->preference) {
                                TAILQ_INSERT_BEFORE(imx, mx, entry);
                                return;
                        }
                }
                TAILQ_INSERT_TAIL(&domain->mxs, mx, entry);
                return;

        case IMSG_MTA_DNS_HOST_END:
                m_msg(&m, imsg);
                m_get_id(&m, &reqid);
                m_get_int(&m, &dnserror);
                m_end(&m);
                domain = tree_xpop(&wait_mx, reqid);
                domain->mxstatus = dnserror;
                if (domain->mxstatus == DNS_OK) {
                        log_debug("debug: MXs for domain %s:",
                            domain->name);
                        TAILQ_FOREACH(mx, &domain->mxs, entry)
                                log_debug("     %s preference %d",
                                    sa_to_text(mx->host->sa),
                                    mx->preference);
                }
                else {
                        log_debug("debug: Failed MX query for %s:",
                            domain->name);
                }
                domain->lastmxquery = time(NULL);
                waitq_run(&domain->mxs, domain);
                return;

        case IMSG_MTA_DNS_MX_PREFERENCE:
                m_msg(&m, imsg);
                m_get_id(&m, &reqid);
                m_get_int(&m, &dnserror);
                if (dnserror == 0)
                        m_get_int(&m, &preference);
                m_end(&m);

                relay = tree_xpop(&wait_preference, reqid);
                if (dnserror) {
                        log_warnx("warn: Couldn't find backup "
                            "preference for %s: error %d",
                            mta_relay_to_text(relay), dnserror);
                        preference = INT_MAX;
                }
                mta_on_preference(relay, preference);
                return;

        case IMSG_CTL_RESUME_ROUTE:
                u64 = *((uint64_t *)imsg->data);
                if (u64)
                        log_debug("resuming route: %llu",
                            (unsigned long long)u64);
                else
                        log_debug("resuming all routes");
                SPLAY_FOREACH(route, mta_route_tree, &routes) {
                        if (u64 && route->id != u64)
                                continue;

                        if (route->flags & ROUTE_DISABLED) {
                                log_info("smtp-out: Enabling route %s per admin request",
                                    mta_route_to_text(route));
                                if (!runq_cancel(runq_route, route)) {
                                        log_warnx("warn: route not on runq");
                                        fatalx("exiting");
                                }
                                route->flags &= ~ROUTE_DISABLED;
                                route->flags |= ROUTE_NEW;
                                route->nerror = 0;
                                route->penalty = 0;
                                mta_route_unref(route); /* from mta_route_disable */
                        }

                        if (u64)
                                break;
                }
                return;

        case IMSG_CTL_MTA_SHOW_HOSTS:
                t = time(NULL);
                SPLAY_FOREACH(host, mta_host_tree, &hosts) {
                        (void)snprintf(buf, sizeof(buf),
                            "%s %s refcount=%d nconn=%zu lastconn=%s",
                            sockaddr_to_text(host->sa),
                            host->ptrname,
                            host->refcount,
                            host->nconn,
                            host->lastconn ? duration_to_text(t - host->lastconn) : "-");
                        m_compose(p, IMSG_CTL_MTA_SHOW_HOSTS,
                            imsg->hdr.peerid, 0, -1,
                            buf, strlen(buf) + 1);
                }
                m_compose(p, IMSG_CTL_MTA_SHOW_HOSTS, imsg->hdr.peerid,
                    0, -1, NULL, 0);
                return;

        case IMSG_CTL_MTA_SHOW_RELAYS:
                t = time(NULL);
                SPLAY_FOREACH(relay, mta_relay_tree, &relays)
                        mta_relay_show(relay, p, imsg->hdr.peerid, t);
                m_compose(p, IMSG_CTL_MTA_SHOW_RELAYS, imsg->hdr.peerid,
                    0, -1, NULL, 0);
                return;

        case IMSG_CTL_MTA_SHOW_ROUTES:
                SPLAY_FOREACH(route, mta_route_tree, &routes) {
                        v = runq_pending(runq_route, route, &t);
                        (void)snprintf(buf, sizeof(buf),
                            "%llu. %s %c%c%c%c nconn=%zu nerror=%d penalty=%d timeout=%s",
                            (unsigned long long)route->id,
                            mta_route_to_text(route),
                            route->flags & ROUTE_NEW ? 'N' : '-',
                            route->flags & ROUTE_DISABLED ? 'D' : '-',
                            route->flags & ROUTE_RUNQ ? 'Q' : '-',
                            route->flags & ROUTE_KEEPALIVE ? 'K' : '-',
                            route->nconn,
                            route->nerror,
                            route->penalty,
                            v ? duration_to_text(t - time(NULL)) : "-");
                        m_compose(p, IMSG_CTL_MTA_SHOW_ROUTES,
                            imsg->hdr.peerid, 0, -1,
                            buf, strlen(buf) + 1);
                }
                m_compose(p, IMSG_CTL_MTA_SHOW_ROUTES, imsg->hdr.peerid,
                    0, -1, NULL, 0);
                return;

        case IMSG_CTL_MTA_SHOW_HOSTSTATS:
                iter = NULL;
                while (dict_iter(&hoststat, &iter, &hostname,
                        (void **)&hs)) {
                        (void)snprintf(buf, sizeof(buf),
                            "%s|%llu|%s",
                            hostname, (unsigned long long) hs->tm,
                            hs->error);
                        m_compose(p, IMSG_CTL_MTA_SHOW_HOSTSTATS,
                            imsg->hdr.peerid, 0, -1,
                            buf, strlen(buf) + 1);
                }
                m_compose(p, IMSG_CTL_MTA_SHOW_HOSTSTATS,
                    imsg->hdr.peerid,
                    0, -1, NULL, 0);
                return;

        case IMSG_CTL_MTA_BLOCK:
                m_msg(&m, imsg);
                m_get_sockaddr(&m, (struct sockaddr*)&ss);
                m_get_string(&m, &dom);
                m_end(&m);
                source = mta_source((struct sockaddr*)&ss);
                if (*dom != '\0') {
                        if (!(strlcpy(buf, dom, sizeof(buf))
                                >= sizeof(buf)))
                                mta_block(source, buf);
                }
                else
                        mta_block(source, NULL);
                mta_source_unref(source);
                m_compose(p, IMSG_CTL_OK, imsg->hdr.peerid, 0, -1, NULL, 0);
                return;

        case IMSG_CTL_MTA_UNBLOCK:
                m_msg(&m, imsg);
                m_get_sockaddr(&m, (struct sockaddr*)&ss);
                m_get_string(&m, &dom);
                m_end(&m);
                source = mta_source((struct sockaddr*)&ss);
                if (*dom != '\0') {
                        if (!(strlcpy(buf, dom, sizeof(buf))
                                >= sizeof(buf)))
                                mta_unblock(source, buf);
                }
                else
                        mta_unblock(source, NULL);
                mta_source_unref(source);
                m_compose(p, IMSG_CTL_OK, imsg->hdr.peerid, 0, -1, NULL, 0);
                return;

        case IMSG_CTL_MTA_SHOW_BLOCK:
                SPLAY_FOREACH(block, mta_block_tree, &blocks) {
                        (void)snprintf(buf, sizeof(buf), "%s -> %s",
                            mta_source_to_text(block->source),
                            block->domain ? block->domain : "*");
                        m_compose(p, IMSG_CTL_MTA_SHOW_BLOCK,
                            imsg->hdr.peerid, 0, -1, buf, strlen(buf) + 1);
                }
                m_compose(p, IMSG_CTL_MTA_SHOW_BLOCK, imsg->hdr.peerid,
                    0, -1, NULL, 0);
                return;
        }

        fatalx("mta_imsg: unexpected %s imsg", imsg_to_str(imsg->hdr.type));
}

void
mta_postfork(void)
{
        struct dispatcher *dispatcher;
        const char *key;
        void *iter;

        iter = NULL;
        while (dict_iter(env->sc_dispatchers, &iter, &key, (void **)&dispatcher)) {
                log_debug("%s: %s", __func__, key);
                mta_setup_dispatcher(dispatcher);
        }
}

static void
mta_setup_dispatcher(struct dispatcher *dispatcher)
{
        struct dispatcher_remote *remote;
        static const char *dheparams[] = { "none", "auto", "legacy" };
        struct tls_config *config;
        struct pki *pki;
        struct ca *ca;
        const char *ciphers;
        uint32_t protos;

        if (dispatcher->type != DISPATCHER_REMOTE)
                return;

        remote = &dispatcher->u.remote;

        if ((config = tls_config_new()) == NULL)
                fatal("smtpd: tls_config_new");

        ciphers = env->sc_tls_ciphers;
        if (remote->tls_ciphers)
                ciphers = remote->tls_ciphers;
        if (ciphers && tls_config_set_ciphers(config, ciphers) == -1)
                fatalx("%s", tls_config_error(config));

        if (remote->tls_protocols) {
                if (tls_config_parse_protocols(&protos,
                    remote->tls_protocols) == -1)
                        fatalx("failed to parse protocols \"%s\"",
                            remote->tls_protocols);
                if (tls_config_set_protocols(config, protos) == -1)
                        fatalx("%s", tls_config_error(config));
        }

        if (remote->pki) {
                pki = dict_get(env->sc_pki_dict, remote->pki);
                if (pki == NULL)
                        fatalx("client pki \"%s\" not found", remote->pki);

                tls_config_set_dheparams(config, dheparams[pki->pki_dhe]);
                tls_config_use_fake_private_key(config);
                if (tls_config_set_keypair_mem(config, pki->pki_cert,
                    pki->pki_cert_len, NULL, 0) == -1)
                        fatalx("tls_config_set_keypair_mem: %s",
                            tls_config_error(config));
        }

        if (remote->ca) {
                ca = dict_get(env->sc_ca_dict, remote->ca);
                if (tls_config_set_ca_mem(config, ca->ca_cert, ca->ca_cert_len)
                    == -1)
                        fatalx("tls_config_set_ca_mem: %s",
                            tls_config_error(config));
        }
        else if (tls_config_set_ca_file(config, tls_default_ca_cert_file())
            == -1)
                fatalx("tls_config_set_ca_file: %s",
                    tls_config_error(config));

        if (remote->tls_verify) {
                tls_config_verify(config);
        } else {
                tls_config_insecure_noverifycert(config);
                tls_config_insecure_noverifyname(config);
                tls_config_insecure_noverifytime(config);
        }

        remote->tls_config = config;
}

void
mta_postprivdrop(void)
{
        SPLAY_INIT(&relays);
        SPLAY_INIT(&domains);
        SPLAY_INIT(&hosts);
        SPLAY_INIT(&sources);
        SPLAY_INIT(&routes);
        SPLAY_INIT(&blocks);

        tree_init(&wait_secret);
        tree_init(&wait_smarthost);
        tree_init(&wait_mx);
        tree_init(&wait_preference);
        tree_init(&wait_source);
        tree_init(&flush_evp);
        dict_init(&hoststat);

        evtimer_set(&ev_flush_evp, mta_delivery_flush_event, NULL);

        runq_init(&runq_relay, mta_on_timeout);
        runq_init(&runq_connector, mta_on_timeout);
        runq_init(&runq_route, mta_on_timeout);
        runq_init(&runq_hoststat, mta_on_timeout);
}


/*
 * Local error on the given source.
 */
void
mta_source_error(struct mta_relay *relay, struct mta_route *route, const char *e)
{
        struct mta_connector    *c;

        /*
         * Remember the source as broken for this connector.
         */
        c = mta_connector(relay, route->src);
        if (!(c->flags & CONNECTOR_ERROR_SOURCE))
                log_info("smtp-out: Error on %s: %s",
                    mta_route_to_text(route), e);
        c->flags |= CONNECTOR_ERROR_SOURCE;
}

void
mta_route_error(struct mta_relay *relay, struct mta_route *route)
{
#if 0
        route->nerror += 1;

        if (route->nerror > MAXERROR_PER_ROUTE) {
                log_info("smtp-out: Too many errors on %s: "
                    "disabling for a while", mta_route_to_text(route));
                mta_route_disable(route, 2, ROUTE_DISABLED_SMTP);
        }
#endif
}

void
mta_route_ok(struct mta_relay *relay, struct mta_route *route)
{
        struct mta_connector    *c;

        if (!(route->flags & ROUTE_NEW))
                return;

        log_debug("debug: mta-routing: route %s is now valid.",
            mta_route_to_text(route));

        route->nerror = 0;
        route->flags &= ~ROUTE_NEW;

        c = mta_connector(relay, route->src);
        mta_connect(c);
}

void
mta_route_down(struct mta_relay *relay, struct mta_route *route)
{
#if 0
        mta_route_disable(route, 2, ROUTE_DISABLED_SMTP);
#endif
}

void
mta_route_collect(struct mta_relay *relay, struct mta_route *route)
{
        struct mta_connector    *c;

        log_debug("debug: mta_route_collect(%s)",
            mta_route_to_text(route));

        relay->nconn -= 1;
        relay->domain->nconn -= 1;
        route->nconn -= 1;
        route->src->nconn -= 1;
        route->dst->nconn -= 1;
        route->lastdisc = time(NULL);

        /* First connection failed */
        if (route->flags & ROUTE_NEW)
                mta_route_disable(route, 1, ROUTE_DISABLED_NET);

        c = mta_connector(relay, route->src);
        c->nconn -= 1;
        mta_connect(c);
        mta_route_unref(route); /* from mta_find_route() */
        mta_relay_unref(relay); /* from mta_connect() */
}

struct mta_task *
mta_route_next_task(struct mta_relay *relay, struct mta_route *route)
{
        struct mta_task *task;

        if ((task = TAILQ_FIRST(&relay->tasks))) {
                TAILQ_REMOVE(&relay->tasks, task, entry);
                relay->ntask -= 1;
                task->relay = NULL;

                /* When the number of tasks is down to lowat, query some evp */
                if (relay->ntask == (size_t)relay->limits->task_lowat) {
                        if (relay->state & RELAY_ONHOLD) {
                                log_info("smtp-out: back to lowat on %s: releasing",
                                    mta_relay_to_text(relay));
                                relay->state &= ~RELAY_ONHOLD;
                        }
                        if (relay->state & RELAY_HOLDQ) {
                                m_create(p_queue, IMSG_MTA_HOLDQ_RELEASE, 0, 0, -1);
                                m_add_id(p_queue, relay->id);
                                m_add_int(p_queue, relay->limits->task_release);
                                m_close(p_queue);
                        }
                }
                else if (relay->ntask == 0 && relay->state & RELAY_HOLDQ) {
                        m_create(p_queue, IMSG_MTA_HOLDQ_RELEASE, 0, 0, -1);
                        m_add_id(p_queue, relay->id);
                        m_add_int(p_queue, 0);
                        m_close(p_queue);
                }
        }

        return (task);
}

static void
mta_handle_envelope(struct envelope *evp, const char *smarthost)
{
        struct mta_relay        *relay;
        struct mta_task         *task;
        struct mta_envelope     *e;
        struct dispatcher       *dispatcher;
        struct mailaddr          maddr;
        struct relayhost         relayh;
        char                     buf[LINE_MAX];

        dispatcher = dict_xget(env->sc_dispatchers, evp->dispatcher);
        if (dispatcher->u.remote.smarthost && smarthost == NULL) {
                mta_query_smarthost(evp);
                return;
        }

        memset(&relayh, 0, sizeof(relayh));
        relayh.tls = RELAY_TLS_OPPORTUNISTIC;
        if (smarthost && !text_to_relayhost(&relayh, smarthost)) {
                log_warnx("warn: Failed to parse smarthost %s", smarthost);
                m_create(p_queue, IMSG_MTA_DELIVERY_TEMPFAIL, 0, 0, -1);
                m_add_evpid(p_queue, evp->id);
                m_add_string(p_queue, "Cannot parse smarthost");
                m_add_int(p_queue, ESC_OTHER_STATUS);
                m_close(p_queue);
                return;
        }

        if (relayh.flags & RELAY_AUTH && dispatcher->u.remote.auth == NULL) {
                log_warnx("warn: No auth table on action \"%s\" for relay %s",
                    evp->dispatcher, smarthost);
                m_create(p_queue, IMSG_MTA_DELIVERY_TEMPFAIL, 0, 0, -1);
                m_add_evpid(p_queue, evp->id);
                m_add_string(p_queue, "No auth table for relaying");
                m_add_int(p_queue, ESC_OTHER_STATUS);
                m_close(p_queue);
                return;
        }

        if (dispatcher->u.remote.tls_required) {
                /* Reject relay if smtp+notls:// is requested */
                if (relayh.tls == RELAY_TLS_NO) {
                        log_warnx("warn: TLS required for action \"%s\"",
                            evp->dispatcher);
                        m_create(p_queue, IMSG_MTA_DELIVERY_TEMPFAIL, 0, 0, -1);
                        m_add_evpid(p_queue, evp->id);
                        m_add_string(p_queue, "TLS required for relaying");
                        m_add_int(p_queue, ESC_OTHER_STATUS);
                        m_close(p_queue);
                        return;
                }
                /* Update smtp:// to smtp+tls:// */
                if (relayh.tls == RELAY_TLS_OPPORTUNISTIC)
                        relayh.tls = RELAY_TLS_STARTTLS;
        }

        relay = mta_relay(evp, &relayh);
        /* ignore if we don't know the limits yet */
        if (relay->limits &&
            relay->ntask >= (size_t)relay->limits->task_hiwat) {
                if (!(relay->state & RELAY_ONHOLD)) {
                        log_info("smtp-out: hiwat reached on %s: holding envelopes",
                            mta_relay_to_text(relay));
                        relay->state |= RELAY_ONHOLD;
                }
        }

        /*
         * If the relay has too many pending tasks, tell the
         * scheduler to hold it until further notice
         */
        if (relay->state & RELAY_ONHOLD) {
                relay->state |= RELAY_HOLDQ;
                m_create(p_queue, IMSG_MTA_DELIVERY_HOLD, 0, 0, -1);
                m_add_evpid(p_queue, evp->id);
                m_add_id(p_queue, relay->id);
                m_close(p_queue);
                mta_relay_unref(relay); /* from here */
                return;
        }

        task = NULL;
        TAILQ_FOREACH(task, &relay->tasks, entry)
                if (task->msgid == evpid_to_msgid(evp->id))
                        break;

        if (task == NULL) {
                task = xmalloc(sizeof *task);
                TAILQ_INIT(&task->envelopes);
                task->relay = relay;
                relay->ntask += 1;
                TAILQ_INSERT_TAIL(&relay->tasks, task, entry);
                task->msgid = evpid_to_msgid(evp->id);
                if (evp->sender.user[0] || evp->sender.domain[0])
                        (void)snprintf(buf, sizeof buf, "%s@%s",
                            evp->sender.user, evp->sender.domain);
                else
                        buf[0] = '\0';

                if (dispatcher->u.remote.mail_from && evp->sender.user[0]) {
                        memset(&maddr, 0, sizeof (maddr));
                        if (text_to_mailaddr(&maddr,
                                dispatcher->u.remote.mail_from)) {
                                (void)snprintf(buf, sizeof buf, "%s@%s",
                                    maddr.user[0] ? maddr.user : evp->sender.user,
                                    maddr.domain[0] ? maddr.domain : evp->sender.domain);
                        }
                }

                task->sender = xstrdup(buf);
                stat_increment("mta.task", 1);
        }

        e = xcalloc(1, sizeof *e);
        e->id = evp->id;
        e->creation = evp->creation;
        e->smtpname = xstrdup(evp->smtpname);
        (void)snprintf(buf, sizeof buf, "%s@%s",
            evp->dest.user, evp->dest.domain);
        e->dest = xstrdup(buf);
        (void)snprintf(buf, sizeof buf, "%s@%s",
            evp->rcpt.user, evp->rcpt.domain);
        if (strcmp(buf, e->dest))
                e->rcpt = xstrdup(buf);
        e->task = task;
        if (evp->dsn_orcpt[0] != '\0')
                e->dsn_orcpt = xstrdup(evp->dsn_orcpt);
        (void)strlcpy(e->dsn_envid, evp->dsn_envid,
            sizeof e->dsn_envid);
        e->dsn_notify = evp->dsn_notify;
        e->dsn_ret = evp->dsn_ret;

        TAILQ_INSERT_TAIL(&task->envelopes, e, entry);
        log_debug("debug: mta: received evp:%016" PRIx64
            " for <%s>", e->id, e->dest);

        stat_increment("mta.envelope", 1);

        mta_drain(relay);
        mta_relay_unref(relay); /* from here */
}

static void
mta_delivery_flush_event(int fd, short event, void *arg)
{
        struct mta_envelope     *e;
        struct timeval           tv;

        if (tree_poproot(&flush_evp, NULL, (void**)(&e))) {

                if (e->delivery == IMSG_MTA_DELIVERY_OK) {
                        m_create(p_queue, IMSG_MTA_DELIVERY_OK, 0, 0, -1);
                        m_add_evpid(p_queue, e->id);
                        m_add_int(p_queue, e->ext);
                        m_close(p_queue);
                } else if (e->delivery == IMSG_MTA_DELIVERY_TEMPFAIL) {
                        m_create(p_queue, IMSG_MTA_DELIVERY_TEMPFAIL, 0, 0, -1);
                        m_add_evpid(p_queue, e->id);
                        m_add_string(p_queue, e->status);
                        m_add_int(p_queue, ESC_OTHER_STATUS);
                        m_close(p_queue);
                }
                else if (e->delivery == IMSG_MTA_DELIVERY_PERMFAIL) {
                        m_create(p_queue, IMSG_MTA_DELIVERY_PERMFAIL, 0, 0, -1);
                        m_add_evpid(p_queue, e->id);
                        m_add_string(p_queue, e->status);
                        m_add_int(p_queue, ESC_OTHER_STATUS);
                        m_close(p_queue);
                }
                else if (e->delivery == IMSG_MTA_DELIVERY_LOOP) {
                        m_create(p_queue, IMSG_MTA_DELIVERY_LOOP, 0, 0, -1);
                        m_add_evpid(p_queue, e->id);
                        m_close(p_queue);
                }
                else {
                        log_warnx("warn: bad delivery type %d for %016" PRIx64,
                            e->delivery, e->id);
                        fatalx("aborting");
                }

                log_debug("debug: mta: flush for %016"PRIx64" (-> %s)", e->id, e->dest);

                free(e->smtpname);
                free(e->dest);
                free(e->rcpt);
                free(e->dsn_orcpt);
                free(e);

                tv.tv_sec = 0;
                tv.tv_usec = 0;
                evtimer_add(&ev_flush_evp, &tv);
        }
}

void
mta_delivery_log(struct mta_envelope *e, const char *source, const char *relay,
    int delivery, const char *status)
{
        if (delivery == IMSG_MTA_DELIVERY_OK)
                mta_log(e, "Ok", source, relay, status);
        else if (delivery == IMSG_MTA_DELIVERY_TEMPFAIL)
                mta_log(e, "TempFail", source, relay, status);
        else if (delivery == IMSG_MTA_DELIVERY_PERMFAIL)
                mta_log(e, "PermFail", source, relay, status);
        else if (delivery == IMSG_MTA_DELIVERY_LOOP)
                mta_log(e, "PermFail", source, relay, "Loop detected");
        else {
                log_warnx("warn: bad delivery type %d for %016" PRIx64,
                    delivery, e->id);
                fatalx("aborting");
        }

        e->delivery = delivery;
        if (status)
                (void)strlcpy(e->status, status, sizeof(e->status));
}

void
mta_delivery_notify(struct mta_envelope *e)
{
        struct timeval  tv;

        tree_xset(&flush_evp, e->id, e);
        if (tree_count(&flush_evp) == 1) {
                tv.tv_sec = 0;
                tv.tv_usec = 0;
                evtimer_add(&ev_flush_evp, &tv);
        }
}

static void
mta_query_mx(struct mta_relay *relay)
{
        uint64_t        id;

        if (relay->status & RELAY_WAIT_MX)
                return;

        log_debug("debug: mta: querying MX for %s...",
            mta_relay_to_text(relay));

        if (waitq_wait(&relay->domain->mxs, mta_on_mx, relay)) {
                id = generate_uid();
                tree_xset(&wait_mx, id, relay->domain);
                if (relay->domain->as_host)
                        m_create(p_lka,  IMSG_MTA_DNS_HOST, 0, 0, -1);
                else
                        m_create(p_lka,  IMSG_MTA_DNS_MX, 0, 0, -1);
                m_add_id(p_lka, id);
                m_add_string(p_lka, relay->domain->name);
                m_close(p_lka);
        }
        relay->status |= RELAY_WAIT_MX;
        mta_relay_ref(relay);
}

static void
mta_query_limits(struct mta_relay *relay)
{
        if (relay->status & RELAY_WAIT_LIMITS)
                return;

        relay->limits = dict_get(env->sc_limits_dict, relay->domain->name);
        if (relay->limits == NULL)
                relay->limits = dict_get(env->sc_limits_dict, "default");

        if (max_seen_conndelay_route < relay->limits->conndelay_route)
                max_seen_conndelay_route = relay->limits->conndelay_route;
        if (max_seen_discdelay_route < relay->limits->discdelay_route)
                max_seen_discdelay_route = relay->limits->discdelay_route;
}

static void
mta_query_secret(struct mta_relay *relay)
{
        if (relay->status & RELAY_WAIT_SECRET)
                return;

        log_debug("debug: mta: querying secret for %s...",
            mta_relay_to_text(relay));

        tree_xset(&wait_secret, relay->id, relay);
        relay->status |= RELAY_WAIT_SECRET;

        m_create(p_lka, IMSG_MTA_LOOKUP_CREDENTIALS, 0, 0, -1);
        m_add_id(p_lka, relay->id);
        m_add_string(p_lka, relay->authtable);
        m_add_string(p_lka, relay->authlabel);
        m_close(p_lka);

        mta_relay_ref(relay);
}

static void
mta_query_smarthost(struct envelope *evp0)
{
        struct dispatcher *dispatcher;
        struct envelope *evp;

        evp = malloc(sizeof(*evp));
        memmove(evp, evp0, sizeof(*evp));

        dispatcher = dict_xget(env->sc_dispatchers, evp->dispatcher);

        log_debug("debug: mta: querying smarthost for %s:%s...",
            evp->dispatcher, dispatcher->u.remote.smarthost);

        tree_xset(&wait_smarthost, evp->id, evp);

        m_create(p_lka, IMSG_MTA_LOOKUP_SMARTHOST, 0, 0, -1);
        m_add_id(p_lka, evp->id);
        if (dispatcher->u.remote.smarthost_domain)
                m_add_string(p_lka, evp->dest.domain);
        else
                m_add_string(p_lka, NULL);
        m_add_string(p_lka, dispatcher->u.remote.smarthost);
        m_close(p_lka);

        log_debug("debug: mta: querying smarthost");
}

static void
mta_query_preference(struct mta_relay *relay)
{
        if (relay->status & RELAY_WAIT_PREFERENCE)
                return;

        log_debug("debug: mta: querying preference for %s...",
            mta_relay_to_text(relay));

        tree_xset(&wait_preference, relay->id, relay);
        relay->status |= RELAY_WAIT_PREFERENCE;

        m_create(p_lka,  IMSG_MTA_DNS_MX_PREFERENCE, 0, 0, -1);
        m_add_id(p_lka, relay->id);
        m_add_string(p_lka, relay->domain->name);
        m_add_string(p_lka, relay->backupname);
        m_close(p_lka);

        mta_relay_ref(relay);
}

static void
mta_query_source(struct mta_relay *relay)
{
        log_debug("debug: mta: querying source for %s...",
            mta_relay_to_text(relay));

        relay->sourceloop += 1;

        if (relay->sourcetable == NULL) {
                /*
                 * This is a recursive call, but it only happens once, since
                 * another source will not be queried immediately.
                 */
                mta_relay_ref(relay);
                mta_on_source(relay, mta_source(NULL));
                return;
        }

        m_create(p_lka, IMSG_MTA_LOOKUP_SOURCE, 0, 0, -1);
        m_add_id(p_lka, relay->id);
        m_add_string(p_lka, relay->sourcetable);
        m_close(p_lka);

        tree_xset(&wait_source, relay->id, relay);
        relay->status |= RELAY_WAIT_SOURCE;
        mta_relay_ref(relay);
}

static void
mta_on_mx(void *tag, void *arg, void *data)
{
        struct mta_domain       *domain = data;
        struct mta_relay        *relay = arg;

        log_debug("debug: mta: ... got mx (%p, %s, %s)",
            tag, domain->name, mta_relay_to_text(relay));

        switch (domain->mxstatus) {
        case DNS_OK:
                break;
        case DNS_RETRY:
                relay->fail = IMSG_MTA_DELIVERY_TEMPFAIL;
                relay->failstr = "Temporary failure in MX lookup";
                break;
        case DNS_EINVAL:
                relay->fail = IMSG_MTA_DELIVERY_PERMFAIL;
                relay->failstr = "Invalid domain name";
                break;
        case DNS_ENONAME:
                relay->fail = IMSG_MTA_DELIVERY_PERMFAIL;
                relay->failstr = "Domain does not exist";
                break;
        case DNS_ENOTFOUND:
                relay->fail = IMSG_MTA_DELIVERY_TEMPFAIL;
                if (relay->domain->as_host)
                        relay->failstr = "Host not found";
                else
                        relay->failstr = "No MX found for domain";
                break;
        case DNS_NULLMX:
                relay->fail = IMSG_MTA_DELIVERY_PERMFAIL;
                relay->failstr = "Domain does not accept mail";
                break;
        default:
                fatalx("bad DNS lookup error code");
                break;
        }

        if (domain->mxstatus)
                log_info("smtp-out: Failed to resolve MX for %s: %s",
                    mta_relay_to_text(relay), relay->failstr);

        relay->status &= ~RELAY_WAIT_MX;
        mta_drain(relay);
        mta_relay_unref(relay); /* from mta_drain() */
}

static void
mta_on_secret(struct mta_relay *relay, const char *secret)
{
        log_debug("debug: mta: ... got secret for %s: %s",
            mta_relay_to_text(relay), secret);

        if (secret)
                relay->secret = strdup(secret);

        if (relay->secret == NULL) {
                log_warnx("warn: Failed to retrieve secret "
                            "for %s", mta_relay_to_text(relay));
                relay->fail = IMSG_MTA_DELIVERY_TEMPFAIL;
                relay->failstr = "Could not retrieve credentials";
        }

        relay->status &= ~RELAY_WAIT_SECRET;
        mta_drain(relay);
        mta_relay_unref(relay); /* from mta_query_secret() */
}

static void
mta_on_smarthost(struct envelope *evp, const char *smarthost)
{
        if (smarthost == NULL) {
                log_warnx("warn: Failed to retrieve smarthost "
                            "for envelope %"PRIx64, evp->id);
                m_create(p_queue, IMSG_MTA_DELIVERY_TEMPFAIL, 0, 0, -1);
                m_add_evpid(p_queue, evp->id);
                m_add_string(p_queue, "Cannot retrieve smarthost");
                m_add_int(p_queue, ESC_OTHER_STATUS);
                m_close(p_queue);
                return;
        }

        log_debug("debug: mta: ... got smarthost for %016"PRIx64": %s",
            evp->id, smarthost);
        mta_handle_envelope(evp, smarthost);
        free(evp);
}

static void
mta_on_preference(struct mta_relay *relay, int preference)
{
        log_debug("debug: mta: ... got preference for %s: %d",
            mta_relay_to_text(relay), preference);

        relay->backuppref = preference;

        relay->status &= ~RELAY_WAIT_PREFERENCE;
        mta_drain(relay);
        mta_relay_unref(relay); /* from mta_query_preference() */
}

static void
mta_on_source(struct mta_relay *relay, struct mta_source *source)
{
        struct mta_connector    *c;
        void                    *iter;
        int                      delay, errmask;

        log_debug("debug: mta: ... got source for %s: %s",
            mta_relay_to_text(relay), source ? mta_source_to_text(source) : "NULL");

        relay->lastsource = time(NULL);
        delay = DELAY_CHECK_SOURCE_SLOW;

        if (source) {
                c = mta_connector(relay, source);
                if (c->flags & CONNECTOR_NEW) {
                        c->flags &= ~CONNECTOR_NEW;
                        delay = DELAY_CHECK_SOURCE;
                }
                mta_connect(c);
                if ((c->flags & CONNECTOR_ERROR) == 0)
                        relay->sourceloop = 0;
                else
                        delay = DELAY_CHECK_SOURCE_FAST;
                mta_source_unref(source); /* from constructor */
        }
        else {
                log_warnx("warn: Failed to get source address for %s",
                    mta_relay_to_text(relay));
        }

        if (tree_count(&relay->connectors) == 0) {
                relay->fail = IMSG_MTA_DELIVERY_TEMPFAIL;
                relay->failstr = "Could not retrieve source address";
        }
        if (tree_count(&relay->connectors) < relay->sourceloop) {
                relay->fail = IMSG_MTA_DELIVERY_TEMPFAIL;
                relay->failstr = "No valid route to remote MX";

                errmask = 0;
                iter = NULL;
                while (tree_iter(&relay->connectors, &iter, NULL, (void **)&c))
                        errmask |= c->flags;

                if (errmask & CONNECTOR_ERROR_ROUTE_SMTP)
                        relay->failstr = "Destination seem to reject all mails";
                else if (errmask & CONNECTOR_ERROR_ROUTE_NET)
                        relay->failstr = "Network error on destination MXs";
                else if (errmask & CONNECTOR_ERROR_MX)
                        relay->failstr = "No MX found for destination";
                else if (errmask & CONNECTOR_ERROR_FAMILY)
                        relay->failstr = "Address family mismatch on destination MXs";
                else if (errmask & CONNECTOR_ERROR_BLOCKED)
                        relay->failstr = "All routes to destination blocked";
                else
                        relay->failstr = "No valid route to destination";
        }

        relay->nextsource = relay->lastsource + delay;
        relay->status &= ~RELAY_WAIT_SOURCE;
        mta_drain(relay);
        mta_relay_unref(relay); /* from mta_query_source() */
}

static void
mta_connect(struct mta_connector *c)
{
        struct mta_route        *route;
        struct mta_mx           *mx;
        struct mta_limits       *l = c->relay->limits;
        int                      limits;
        time_t                   nextconn, now;

        /* toggle the block flag */
        if (mta_is_blocked(c->source, c->relay->domain->name))
                c->flags |= CONNECTOR_ERROR_BLOCKED;
        else
                c->flags &= ~CONNECTOR_ERROR_BLOCKED;

    again:

        log_debug("debug: mta: connecting with %s", mta_connector_to_text(c));

        /* Do not connect if this connector has an error. */
        if (c->flags & CONNECTOR_ERROR) {
                log_debug("debug: mta: connector error");
                return;
        }

        if (c->flags & CONNECTOR_WAIT) {
                log_debug("debug: mta: cancelling connector timeout");
                runq_cancel(runq_connector, c);
                c->flags &= ~CONNECTOR_WAIT;
        }

        /* No job. */
        if (c->relay->ntask == 0) {
                log_debug("debug: mta: no task for connector");
                return;
        }

        /* Do not create more connections than necessary */
        if ((c->relay->nconn_ready >= c->relay->ntask) ||
            (c->relay->nconn > 2 && c->relay->nconn >= c->relay->ntask / 2)) {
                log_debug("debug: mta: enough connections already");
                return;
        }

        limits = 0;
        nextconn = now = time(NULL);

        if (c->relay->domain->lastconn + l->conndelay_domain > nextconn) {
                log_debug("debug: mta: cannot use domain %s before %llus",
                    c->relay->domain->name,
                    (unsigned long long) c->relay->domain->lastconn + l->conndelay_domain - now);
                nextconn = c->relay->domain->lastconn + l->conndelay_domain;
        }
        if (c->relay->domain->nconn >= l->maxconn_per_domain) {
                log_debug("debug: mta: hit domain limit");
                limits |= CONNECTOR_LIMIT_DOMAIN;
        }

        if (c->source->lastconn + l->conndelay_source > nextconn) {
                log_debug("debug: mta: cannot use source %s before %llus",
                    mta_source_to_text(c->source),
                    (unsigned long long) c->source->lastconn + l->conndelay_source - now);
                nextconn = c->source->lastconn + l->conndelay_source;
        }
        if (c->source->nconn >= l->maxconn_per_source) {
                log_debug("debug: mta: hit source limit");
                limits |= CONNECTOR_LIMIT_SOURCE;
        }

        if (c->lastconn + l->conndelay_connector > nextconn) {
                log_debug("debug: mta: cannot use %s before %llus",
                    mta_connector_to_text(c),
                    (unsigned long long) c->lastconn + l->conndelay_connector - now);
                nextconn = c->lastconn + l->conndelay_connector;
        }
        if (c->nconn >= l->maxconn_per_connector) {
                log_debug("debug: mta: hit connector limit");
                limits |= CONNECTOR_LIMIT_CONN;
        }

        if (c->relay->lastconn + l->conndelay_relay > nextconn) {
                log_debug("debug: mta: cannot use %s before %llus",
                    mta_relay_to_text(c->relay),
                    (unsigned long long) c->relay->lastconn + l->conndelay_relay - now);
                nextconn = c->relay->lastconn + l->conndelay_relay;
        }
        if (c->relay->nconn >= l->maxconn_per_relay) {
                log_debug("debug: mta: hit relay limit");
                limits |= CONNECTOR_LIMIT_RELAY;
        }

        /* We can connect now, find a route */
        if (!limits && nextconn <= now)
                route = mta_find_route(c, now, &limits, &nextconn, &mx);
        else
                route = NULL;

        /* No route */
        if (route == NULL) {

                if (c->flags & CONNECTOR_ERROR) {
                        /* XXX we might want to clear this flag later */
                        log_debug("debug: mta-routing: no route available for %s: errors on connector",
                            mta_connector_to_text(c));
                        return;
                }
                else if (limits) {
                        log_debug("debug: mta-routing: no route available for %s: limits reached",
                            mta_connector_to_text(c));
                        nextconn = now + DELAY_CHECK_LIMIT;
                }
                else {
                        log_debug("debug: mta-routing: no route available for %s: must wait a bit",
                            mta_connector_to_text(c));
                }
                log_debug("debug: mta: retrying to connect on %s in %llus...",
                    mta_connector_to_text(c),
                    (unsigned long long) nextconn - time(NULL));
                c->flags |= CONNECTOR_WAIT;
                runq_schedule_at(runq_connector, nextconn, c);
                return;
        }

        log_debug("debug: mta-routing: spawning new connection on %s",
                    mta_route_to_text(route));

        c->nconn += 1;
        c->lastconn = time(NULL);

        c->relay->nconn += 1;
        c->relay->lastconn = c->lastconn;
        c->relay->domain->nconn += 1;
        c->relay->domain->lastconn = c->lastconn;
        route->nconn += 1;
        route->lastconn = c->lastconn;
        route->src->nconn += 1;
        route->src->lastconn = c->lastconn;
        route->dst->nconn += 1;
        route->dst->lastconn = c->lastconn;

        mta_session(c->relay, route, mx->mxname);       /* this never fails synchronously */
        mta_relay_ref(c->relay);

        goto again;
}

static void
mta_on_timeout(struct runq *runq, void *arg)
{
        struct mta_connector    *connector = arg;
        struct mta_relay        *relay = arg;
        struct mta_route        *route = arg;
        struct hoststat         *hs = arg;

        if (runq == runq_relay) {
                log_debug("debug: mta: ... timeout for %s",
                    mta_relay_to_text(relay));
                relay->status &= ~RELAY_WAIT_CONNECTOR;
                mta_drain(relay);
                mta_relay_unref(relay); /* from mta_drain() */
        }
        else if (runq == runq_connector) {
                log_debug("debug: mta: ... timeout for %s",
                    mta_connector_to_text(connector));
                connector->flags &= ~CONNECTOR_WAIT;
                mta_connect(connector);
        }
        else if (runq == runq_route) {
                route->flags &= ~ROUTE_RUNQ;
                mta_route_enable(route);
                mta_route_unref(route);
        }
        else if (runq == runq_hoststat) {
                log_debug("debug: mta: ... timeout for hoststat %s",
                        hs->name);
                mta_hoststat_remove_entry(hs);
                free(hs);
        }
}

static void
mta_route_disable(struct mta_route *route, int penalty, int reason)
{
        unsigned long long      delay;

        route->penalty += penalty;
        route->lastpenalty = time(NULL);
        delay = (unsigned long long)DELAY_ROUTE_BASE * route->penalty * route->penalty;
        if (delay > DELAY_ROUTE_MAX)
                delay = DELAY_ROUTE_MAX;
#if 0
        delay = 60;
#endif

        log_info("smtp-out: Disabling route %s for %llus",
            mta_route_to_text(route), delay);

        if (route->flags & ROUTE_DISABLED)
                runq_cancel(runq_route, route);
        else
                mta_route_ref(route);

        route->flags |= reason & ROUTE_DISABLED;
        runq_schedule(runq_route, delay, route);
}

static void
mta_route_enable(struct mta_route *route)
{
        if (route->flags & ROUTE_DISABLED) {
                log_info("smtp-out: Enabling route %s",
                    mta_route_to_text(route));
                route->flags &= ~ROUTE_DISABLED;
                route->flags |= ROUTE_NEW;
                route->nerror = 0;
        }

        if (route->penalty) {
#if DELAY_QUADRATIC
                route->penalty -= 1;
                route->lastpenalty = time(NULL);
#else
                route->penalty = 0;
#endif
        }
}

static void
mta_drain(struct mta_relay *r)
{
        char                     buf[64];

        log_debug("debug: mta: draining %s "
            "refcount=%d, ntask=%zu, nconnector=%zu, nconn=%zu",
            mta_relay_to_text(r),
            r->refcount, r->ntask, tree_count(&r->connectors), r->nconn);

        /*
         * All done.
         */
        if (r->ntask == 0) {
                log_debug("debug: mta: all done for %s", mta_relay_to_text(r));
                return;
        }

        /*
         * If we know that this relay is failing flush the tasks.
         */
        if (r->fail) {
                mta_flush(r, r->fail, r->failstr);
                return;
        }

        /* Query secret if needed. */
        if (r->flags & RELAY_AUTH && r->secret == NULL)
                mta_query_secret(r);

        /* Query our preference if needed. */
        if (r->backupname && r->backuppref == -1)
                mta_query_preference(r);

        /* Query the domain MXs if needed. */
        if (r->domain->lastmxquery == 0)
                mta_query_mx(r);

        /* Query the limits if needed. */
        if (r->limits == NULL)
                mta_query_limits(r);

        /* Wait until we are ready to proceed. */
        if (r->status & RELAY_WAITMASK) {
                buf[0] = '\0';
                if (r->status & RELAY_WAIT_MX)
                        (void)strlcat(buf, " MX", sizeof buf);
                if (r->status & RELAY_WAIT_PREFERENCE)
                        (void)strlcat(buf, " preference", sizeof buf);
                if (r->status & RELAY_WAIT_SECRET)
                        (void)strlcat(buf, " secret", sizeof buf);
                if (r->status & RELAY_WAIT_SOURCE)
                        (void)strlcat(buf, " source", sizeof buf);
                if (r->status & RELAY_WAIT_CONNECTOR)
                        (void)strlcat(buf, " connector", sizeof buf);
                log_debug("debug: mta: %s waiting for%s",
                    mta_relay_to_text(r), buf);
                return;
        }

        /*
         * We have pending task, and it's maybe time too try a new source.
         */
        if (r->nextsource <= time(NULL))
                mta_query_source(r);
        else {
                log_debug("debug: mta: scheduling relay %s in %llus...",
                    mta_relay_to_text(r),
                    (unsigned long long) r->nextsource - time(NULL));
                runq_schedule_at(runq_relay, r->nextsource, r);
                r->status |= RELAY_WAIT_CONNECTOR;
                mta_relay_ref(r);
        }
}

static void
mta_flush(struct mta_relay *relay, int fail, const char *error)
{
        struct mta_envelope     *e;
        struct mta_task         *task;
        const char              *domain;
        void                    *iter;
        struct mta_connector    *c;
        size_t                   n, r;

        log_debug("debug: mta_flush(%s, %d, \"%s\")",
            mta_relay_to_text(relay), fail, error);

        if (fail != IMSG_MTA_DELIVERY_TEMPFAIL && fail != IMSG_MTA_DELIVERY_PERMFAIL)
                fatalx("unexpected delivery status %d", fail);

        n = 0;
        while ((task = TAILQ_FIRST(&relay->tasks))) {
                TAILQ_REMOVE(&relay->tasks, task, entry);
                while ((e = TAILQ_FIRST(&task->envelopes))) {
                        TAILQ_REMOVE(&task->envelopes, e, entry);

                        /*
                         * host was suspended, cache envelope id in hoststat tree
                         * so that it can be retried when a delivery succeeds for
                         * that domain.
                         */
                        domain = strchr(e->dest, '@');
                        if (fail == IMSG_MTA_DELIVERY_TEMPFAIL && domain) {
                                r = 0;
                                iter = NULL;
                                while (tree_iter(&relay->connectors, &iter,
                                        NULL, (void **)&c)) {
                                        if (c->flags & CONNECTOR_ERROR_ROUTE)
                                                r++;
                                }
                                if (tree_count(&relay->connectors) == r)
                                        mta_hoststat_cache(domain+1, e->id);
                        }

                        mta_delivery_log(e, NULL, relay->domain->name, fail, error);
                        mta_delivery_notify(e);

                        n++;
                }
                free(task->sender);
                free(task);
        }

        stat_decrement("mta.task", relay->ntask);
        stat_decrement("mta.envelope", n);
        relay->ntask = 0;

        /* release all waiting envelopes for the relay */
        if (relay->state & RELAY_HOLDQ) {
                m_create(p_queue, IMSG_MTA_HOLDQ_RELEASE, 0, 0, -1);
                m_add_id(p_queue, relay->id);
                m_add_int(p_queue, -1);
                m_close(p_queue);
        }
}

/*
 * Find a route to use for this connector
 */
static struct mta_route *
mta_find_route(struct mta_connector *c, time_t now, int *limits,
    time_t *nextconn, struct mta_mx **pmx)
{
        struct mta_route        *route, *best;
        struct mta_limits       *l = c->relay->limits;
        struct mta_mx           *mx;
        int                      level, limit_host, limit_route;
        int                      family_mismatch, seen, suspended_route;
        time_t                   tm;

        log_debug("debug: mta-routing: searching new route for %s...",
            mta_connector_to_text(c));

        tm = 0;
        limit_host = 0;
        limit_route = 0;
        suspended_route = 0;
        family_mismatch = 0;
        level = -1;
        best = NULL;
        seen = 0;

        TAILQ_FOREACH(mx, &c->relay->domain->mxs, entry) {
                /*
                 * New preference level
                 */
                if (mx->preference > level) {
#ifndef IGNORE_MX_PREFERENCE
                        /*
                         * Use the current best MX if found.
                         */
                        if (best)
                                break;

                        /*
                         * No candidate found.  There are valid MXs at this
                         * preference level but they reached their limit, or
                         * we can't connect yet.
                         */
                        if (limit_host || limit_route || tm)
                                break;

                        /*
                         *  If we are a backup MX, do not relay to MXs with
                         *  a greater preference value.
                         */
                        if (c->relay->backuppref >= 0 &&
                            mx->preference >= c->relay->backuppref)
                                break;

                        /*
                         * Start looking at MXs on this preference level.
                         */
#endif
                        level = mx->preference;
                }

                if (mx->host->flags & HOST_IGNORE)
                        continue;

                /* Found a possibly valid mx */
                seen++;

                if ((c->source->sa &&
                     c->source->sa->sa_family != mx->host->sa->sa_family) ||
                    (l->family && l->family != mx->host->sa->sa_family)) {
                        log_debug("debug: mta-routing: skipping host %s: AF mismatch",
                            mta_host_to_text(mx->host));
                        family_mismatch = 1;
                        continue;
                }

                if (mx->host->nconn >= l->maxconn_per_host) {
                        log_debug("debug: mta-routing: skipping host %s: too many connections",
                            mta_host_to_text(mx->host));
                        limit_host = 1;
                        continue;
                }

                if (mx->host->lastconn + l->conndelay_host > now) {
                        log_debug("debug: mta-routing: skipping host %s: cannot use before %llus",
                            mta_host_to_text(mx->host),
                            (unsigned long long) mx->host->lastconn + l->conndelay_host - now);
                        if (tm == 0 || mx->host->lastconn + l->conndelay_host < tm)
                                tm = mx->host->lastconn + l->conndelay_host;
                        continue;
                }

                route = mta_route(c->source, mx->host);

                if (route->flags & ROUTE_DISABLED) {
                        log_debug("debug: mta-routing: skipping route %s: suspend",
                            mta_route_to_text(route));
                        suspended_route |= route->flags & ROUTE_DISABLED;
                        mta_route_unref(route); /* from here */
                        continue;
                }

                if (route->nconn && (route->flags & ROUTE_NEW)) {
                        log_debug("debug: mta-routing: skipping route %s: not validated yet",
                            mta_route_to_text(route));
                        limit_route = 1;
                        mta_route_unref(route); /* from here */
                        continue;
                }

                if (route->nconn >= l->maxconn_per_route) {
                        log_debug("debug: mta-routing: skipping route %s: too many connections",
                            mta_route_to_text(route));
                        limit_route = 1;
                        mta_route_unref(route); /* from here */
                        continue;
                }

                if (route->lastconn + l->conndelay_route > now) {
                        log_debug("debug: mta-routing: skipping route %s: cannot use before %llus (delay after connect)",
                            mta_route_to_text(route),
                            (unsigned long long) route->lastconn + l->conndelay_route - now);
                        if (tm == 0 || route->lastconn + l->conndelay_route < tm)
                                tm = route->lastconn + l->conndelay_route;
                        mta_route_unref(route); /* from here */
                        continue;
                }

                if (route->lastdisc + l->discdelay_route > now) {
                        log_debug("debug: mta-routing: skipping route %s: cannot use before %llus (delay after disconnect)",
                            mta_route_to_text(route),
                            (unsigned long long) route->lastdisc + l->discdelay_route - now);
                        if (tm == 0 || route->lastdisc + l->discdelay_route < tm)
                                tm = route->lastdisc + l->discdelay_route;
                        mta_route_unref(route); /* from here */
                        continue;
                }

                /* Use the route with the lowest number of connections. */
                if (best && route->nconn >= best->nconn) {
                        log_debug("debug: mta-routing: skipping route %s: current one is better",
                            mta_route_to_text(route));
                        mta_route_unref(route); /* from here */
                        continue;
                }

                if (best)
                        mta_route_unref(best); /* from here */
                best = route;
                *pmx = mx;
                log_debug("debug: mta-routing: selecting candidate route %s",
                    mta_route_to_text(route));
        }

        if (best)
                return (best);

        /* Order is important */
        if (seen == 0) {
                log_info("smtp-out: No MX found for %s",
                    mta_connector_to_text(c));
                c->flags |= CONNECTOR_ERROR_MX;
        }
        else if (limit_route) {
                log_debug("debug: mta: hit route limit");
                *limits |= CONNECTOR_LIMIT_ROUTE;
        }
        else if (limit_host) {
                log_debug("debug: mta: hit host limit");
                *limits |= CONNECTOR_LIMIT_HOST;
        }
        else if (tm) {
                if (tm > *nextconn)
                        *nextconn = tm;
        }
        else if (family_mismatch) {
                log_info("smtp-out: Address family mismatch on %s",
                    mta_connector_to_text(c));
                c->flags |= CONNECTOR_ERROR_FAMILY;
        }
        else if (suspended_route) {
                log_info("smtp-out: No valid route for %s",
                    mta_connector_to_text(c));
                if (suspended_route & ROUTE_DISABLED_NET)
                        c->flags |= CONNECTOR_ERROR_ROUTE_NET;
                if (suspended_route & ROUTE_DISABLED_SMTP)
                        c->flags |= CONNECTOR_ERROR_ROUTE_SMTP;
        }

        return (NULL);
}

static void
mta_log(const struct mta_envelope *evp, const char *prefix, const char *source,
    const char *relay, const char *status)
{
        log_info("%016"PRIx64" mta delivery evpid=%016"PRIx64" "
            "from=<%s> to=<%s> rcpt=<%s> source=\"%s\" "
            "relay=\"%s\" delay=%s result=\"%s\" stat=\"%s\"",
            evp->session,
            evp->id,
            evp->task->sender,
            evp->dest,
            evp->rcpt ? evp->rcpt : "-",
            source ? source : "-",
            relay,
            duration_to_text(time(NULL) - evp->creation),
            prefix,
            status);
}

static struct mta_relay *
mta_relay(struct envelope *e, struct relayhost *relayh)
{
        struct dispatcher       *dispatcher;
        struct mta_relay         key, *r;

        dispatcher = dict_xget(env->sc_dispatchers, e->dispatcher);

        memset(&key, 0, sizeof key);

        key.pki_name = dispatcher->u.remote.pki;
        key.ca_name = dispatcher->u.remote.ca;
        key.authtable = dispatcher->u.remote.auth;
        key.sourcetable = dispatcher->u.remote.source;
        key.helotable = dispatcher->u.remote.helo_source;
        key.heloname = dispatcher->u.remote.helo;
        key.srs = dispatcher->u.remote.srs;

        if (relayh->hostname[0]) {
                key.domain = mta_domain(relayh->hostname, 1);
        }
        else {
                key.domain = mta_domain(e->dest.domain, 0);
                if (dispatcher->u.remote.backup) {
                        key.backupname = dispatcher->u.remote.backupmx;
                        if (key.backupname == NULL)
                                key.backupname = e->smtpname;
                }
        }

        key.tls = relayh->tls;
        key.flags |= relayh->flags;
        key.port = relayh->port;
        key.authlabel = relayh->authlabel;
        if (!key.authlabel[0])
                key.authlabel = NULL;

        if ((r = SPLAY_FIND(mta_relay_tree, &relays, &key)) == NULL) {
                r = xcalloc(1, sizeof *r);
                TAILQ_INIT(&r->tasks);
                r->id = generate_uid();
                r->dispatcher = dispatcher;
                r->tls = key.tls;
                r->flags = key.flags;
                r->domain = key.domain;
                r->backupname = key.backupname ?
                    xstrdup(key.backupname) : NULL;
                r->backuppref = -1;
                r->port = key.port;
                r->pki_name = key.pki_name ? xstrdup(key.pki_name) : NULL;
                r->ca_name = key.ca_name ? xstrdup(key.ca_name) : NULL;
                if (key.authtable)
                        r->authtable = xstrdup(key.authtable);
                if (key.authlabel)
                        r->authlabel = xstrdup(key.authlabel);
                if (key.sourcetable)
                        r->sourcetable = xstrdup(key.sourcetable);
                if (key.helotable)
                        r->helotable = xstrdup(key.helotable);
                if (key.heloname)
                        r->heloname = xstrdup(key.heloname);
                r->srs = key.srs;
                SPLAY_INSERT(mta_relay_tree, &relays, r);
                stat_increment("mta.relay", 1);
        } else {
                mta_domain_unref(key.domain); /* from here */
        }

        r->refcount++;
        return (r);
}

static void
mta_relay_ref(struct mta_relay *r)
{
        r->refcount++;
}

static void
mta_relay_unref(struct mta_relay *relay)
{
        struct mta_connector    *c;

        if (--relay->refcount)
                return;

        /* Make sure they are no envelopes held for this relay */
        if (relay->state & RELAY_HOLDQ) {
                m_create(p_queue, IMSG_MTA_HOLDQ_RELEASE, 0, 0, -1);
                m_add_id(p_queue, relay->id);
                m_add_int(p_queue, 0);
                m_close(p_queue);
        }

        log_debug("debug: mta: freeing %s", mta_relay_to_text(relay));
        SPLAY_REMOVE(mta_relay_tree, &relays, relay);

        while ((tree_poproot(&relay->connectors, NULL, (void**)&c)))
                mta_connector_free(c);

        free(relay->authlabel);
        free(relay->authtable);
        free(relay->backupname);
        free(relay->pki_name);
        free(relay->ca_name);
        free(relay->helotable);
        free(relay->heloname);
        free(relay->secret);
        free(relay->sourcetable);

        mta_domain_unref(relay->domain); /* from constructor */
        free(relay);
        stat_decrement("mta.relay", 1);
}

const char *
mta_relay_to_text(struct mta_relay *relay)
{
        static char      buf[1024];
        char             tmp[32];
        const char      *sep = ",";

        (void)snprintf(buf, sizeof buf, "[relay:%s", relay->domain->name);

        if (relay->port) {
                (void)strlcat(buf, sep, sizeof buf);
                (void)snprintf(tmp, sizeof tmp, "port=%d", (int)relay->port);
                (void)strlcat(buf, tmp, sizeof buf);
        }

        (void)strlcat(buf, sep, sizeof buf);
        switch(relay->tls) {
        case RELAY_TLS_OPPORTUNISTIC:
                (void)strlcat(buf, "smtp", sizeof buf);
                break;
        case RELAY_TLS_STARTTLS:
                (void)strlcat(buf, "smtp+tls", sizeof buf);
                break;
        case RELAY_TLS_SMTPS:
                (void)strlcat(buf, "smtps", sizeof buf);
                break;
        case RELAY_TLS_NO:
                if (relay->flags & RELAY_LMTP)
                        (void)strlcat(buf, "lmtp", sizeof buf);
                else
                        (void)strlcat(buf, "smtp+notls", sizeof buf);
                break;
        default:
                (void)strlcat(buf, "???", sizeof buf);
        }

        if (relay->flags & RELAY_AUTH) {
                (void)strlcat(buf, sep, sizeof buf);
                (void)strlcat(buf, "auth=", sizeof buf);
                (void)strlcat(buf, relay->authtable, sizeof buf);
                (void)strlcat(buf, ":", sizeof buf);
                (void)strlcat(buf, relay->authlabel, sizeof buf);
        }

        if (relay->pki_name) {
                (void)strlcat(buf, sep, sizeof buf);
                (void)strlcat(buf, "pki_name=", sizeof buf);
                (void)strlcat(buf, relay->pki_name, sizeof buf);
        }

        if (relay->domain->as_host) {
                (void)strlcat(buf, sep, sizeof buf);
                (void)strlcat(buf, "mx", sizeof buf);
        }

        if (relay->backupname) {
                (void)strlcat(buf, sep, sizeof buf);
                (void)strlcat(buf, "backup=", sizeof buf);
                (void)strlcat(buf, relay->backupname, sizeof buf);
        }

        if (relay->sourcetable) {
                (void)strlcat(buf, sep, sizeof buf);
                (void)strlcat(buf, "sourcetable=", sizeof buf);
                (void)strlcat(buf, relay->sourcetable, sizeof buf);
        }

        if (relay->helotable) {
                (void)strlcat(buf, sep, sizeof buf);
                (void)strlcat(buf, "helotable=", sizeof buf);
                (void)strlcat(buf, relay->helotable, sizeof buf);
        }

        if (relay->heloname) {
                (void)strlcat(buf, sep, sizeof buf);
                (void)strlcat(buf, "heloname=", sizeof buf);
                (void)strlcat(buf, relay->heloname, sizeof buf);
        }

        (void)strlcat(buf, "]", sizeof buf);

        return (buf);
}

static void
mta_relay_show(struct mta_relay *r, struct mproc *p, uint32_t id, time_t t)
{
        struct mta_connector    *c;
        void                    *iter;
        char                     buf[1024], flags[1024], dur[64];
        time_t                   to;

        flags[0] = '\0';

#define SHOWSTATUS(f, n) do {                                                   \
                if (r->status & (f)) {                                          \
                        if (flags[0])                                           \
                                (void)strlcat(flags, ",", sizeof(flags));       \
                        (void)strlcat(flags, (n), sizeof(flags));               \
                }                                                               \
        } while(0)

        SHOWSTATUS(RELAY_WAIT_MX, "MX");
        SHOWSTATUS(RELAY_WAIT_PREFERENCE, "preference");
        SHOWSTATUS(RELAY_WAIT_SECRET, "secret");
        SHOWSTATUS(RELAY_WAIT_LIMITS, "limits");
        SHOWSTATUS(RELAY_WAIT_SOURCE, "source");
        SHOWSTATUS(RELAY_WAIT_CONNECTOR, "connector");
#undef SHOWSTATUS

        if (runq_pending(runq_relay, r, &to))
                (void)snprintf(dur, sizeof(dur), "%s", duration_to_text(to - t));
        else
                (void)strlcpy(dur, "-", sizeof(dur));

        (void)snprintf(buf, sizeof(buf), "%s refcount=%d ntask=%zu nconn=%zu lastconn=%s timeout=%s wait=%s%s",
            mta_relay_to_text(r),
            r->refcount,
            r->ntask,
            r->nconn,
            r->lastconn ? duration_to_text(t - r->lastconn) : "-",
            dur,
            flags,
            (r->state & RELAY_ONHOLD) ? "ONHOLD" : "");
        m_compose(p, IMSG_CTL_MTA_SHOW_RELAYS, id, 0, -1, buf, strlen(buf) + 1);

        iter = NULL;
        while (tree_iter(&r->connectors, &iter, NULL, (void **)&c)) {

                if (runq_pending(runq_connector, c, &to))
                        (void)snprintf(dur, sizeof(dur), "%s", duration_to_text(to - t));
                else
                        (void)strlcpy(dur, "-", sizeof(dur));

                flags[0] = '\0';

#define SHOWFLAG(f, n) do {                                                     \
                if (c->flags & (f)) {                                           \
                        if (flags[0])                                           \
                                (void)strlcat(flags, ",", sizeof(flags));       \
                        (void)strlcat(flags, (n), sizeof(flags));               \
                }                                                               \
        } while(0)

                SHOWFLAG(CONNECTOR_NEW,         "NEW");
                SHOWFLAG(CONNECTOR_WAIT,        "WAIT");

                SHOWFLAG(CONNECTOR_ERROR_FAMILY,        "ERROR_FAMILY");
                SHOWFLAG(CONNECTOR_ERROR_SOURCE,        "ERROR_SOURCE");
                SHOWFLAG(CONNECTOR_ERROR_MX,            "ERROR_MX");
                SHOWFLAG(CONNECTOR_ERROR_ROUTE_NET,     "ERROR_ROUTE_NET");
                SHOWFLAG(CONNECTOR_ERROR_ROUTE_SMTP,    "ERROR_ROUTE_SMTP");
                SHOWFLAG(CONNECTOR_ERROR_BLOCKED,       "ERROR_BLOCKED");

                SHOWFLAG(CONNECTOR_LIMIT_HOST,          "LIMIT_HOST");
                SHOWFLAG(CONNECTOR_LIMIT_ROUTE,         "LIMIT_ROUTE");
                SHOWFLAG(CONNECTOR_LIMIT_SOURCE,        "LIMIT_SOURCE");
                SHOWFLAG(CONNECTOR_LIMIT_RELAY,         "LIMIT_RELAY");
                SHOWFLAG(CONNECTOR_LIMIT_CONN,          "LIMIT_CONN");
                SHOWFLAG(CONNECTOR_LIMIT_DOMAIN,        "LIMIT_DOMAIN");
#undef SHOWFLAG

                (void)snprintf(buf, sizeof(buf),
                    "  connector %s refcount=%d nconn=%zu lastconn=%s timeout=%s flags=%s",
                    mta_source_to_text(c->source),
                    c->refcount,
                    c->nconn,
                    c->lastconn ? duration_to_text(t - c->lastconn) : "-",
                    dur,
                    flags);
                m_compose(p, IMSG_CTL_MTA_SHOW_RELAYS, id, 0, -1, buf,
                    strlen(buf) + 1);


        }
}

static int
mta_relay_cmp(const struct mta_relay *a, const struct mta_relay *b)
{
        int     r;

        if (a->domain < b->domain)
                return (-1);
        if (a->domain > b->domain)
                return (1);

        if (a->tls < b->tls)
                return (-1);
        if (a->tls > b->tls)
                return (1);

        if (a->flags < b->flags)
                return (-1);
        if (a->flags > b->flags)
                return (1);

        if (a->port < b->port)
                return (-1);
        if (a->port > b->port)
                return (1);

        if (a->authtable == NULL && b->authtable)
                return (-1);
        if (a->authtable && b->authtable == NULL)
                return (1);
        if (a->authtable && ((r = strcmp(a->authtable, b->authtable))))
                return (r);
        if (a->authlabel == NULL && b->authlabel)
                return (-1);
        if (a->authlabel && b->authlabel == NULL)
                return (1);
        if (a->authlabel && ((r = strcmp(a->authlabel, b->authlabel))))
                return (r);
        if (a->sourcetable == NULL && b->sourcetable)
                return (-1);
        if (a->sourcetable && b->sourcetable == NULL)
                return (1);
        if (a->sourcetable && ((r = strcmp(a->sourcetable, b->sourcetable))))
                return (r);
        if (a->helotable == NULL && b->helotable)
                return (-1);
        if (a->helotable && b->helotable == NULL)
                return (1);
        if (a->helotable && ((r = strcmp(a->helotable, b->helotable))))
                return (r);
        if (a->heloname == NULL && b->heloname)
                return (-1);
        if (a->heloname && b->heloname == NULL)
                return (1);
        if (a->heloname && ((r = strcmp(a->heloname, b->heloname))))
                return (r);

        if (a->pki_name == NULL && b->pki_name)
                return (-1);
        if (a->pki_name && b->pki_name == NULL)
                return (1);
        if (a->pki_name && ((r = strcmp(a->pki_name, b->pki_name))))
                return (r);

        if (a->ca_name == NULL && b->ca_name)
                return (-1);
        if (a->ca_name && b->ca_name == NULL)
                return (1);
        if (a->ca_name && ((r = strcmp(a->ca_name, b->ca_name))))
                return (r);

        if (a->backupname == NULL && b->backupname)
                return (-1);
        if (a->backupname && b->backupname == NULL)
                return (1);
        if (a->backupname && ((r = strcmp(a->backupname, b->backupname))))
                return (r);

        if (a->srs < b->srs)
                return (-1);
        if (a->srs > b->srs)
                return (1);

        return (0);
}

SPLAY_GENERATE(mta_relay_tree, mta_relay, entry, mta_relay_cmp);

static struct mta_host *
mta_host(const struct sockaddr *sa)
{
        struct mta_host         key, *h;
        struct sockaddr_storage ss;

        memmove(&ss, sa, sa->sa_len);
        key.sa = (struct sockaddr*)&ss;
        h = SPLAY_FIND(mta_host_tree, &hosts, &key);

        if (h == NULL) {
                h = xcalloc(1, sizeof(*h));
                h->sa = xmemdup(sa, sa->sa_len);
                SPLAY_INSERT(mta_host_tree, &hosts, h);
                stat_increment("mta.host", 1);
        }

        h->refcount++;
        return (h);
}

static void
mta_host_ref(struct mta_host *h)
{
        h->refcount++;
}

static void
mta_host_unref(struct mta_host *h)
{
        if (--h->refcount)
                return;

        SPLAY_REMOVE(mta_host_tree, &hosts, h);
        free(h->sa);
        free(h->ptrname);
        free(h);
        stat_decrement("mta.host", 1);
}

const char *
mta_host_to_text(struct mta_host *h)
{
        static char buf[1024];

        if (h->ptrname)
                (void)snprintf(buf, sizeof buf, "%s (%s)",
                    sa_to_text(h->sa), h->ptrname);
        else
                (void)snprintf(buf, sizeof buf, "%s", sa_to_text(h->sa));

        return (buf);
}

static int
mta_host_cmp(const struct mta_host *a, const struct mta_host *b)
{
        if (a->sa->sa_len < b->sa->sa_len)
                return (-1);
        if (a->sa->sa_len > b->sa->sa_len)
                return (1);
        return (memcmp(a->sa, b->sa, a->sa->sa_len));
}

SPLAY_GENERATE(mta_host_tree, mta_host, entry, mta_host_cmp);

static struct mta_domain *
mta_domain(char *name, int as_host)
{
        struct mta_domain       key, *d;

        key.name = name;
        key.as_host = as_host;
        d = SPLAY_FIND(mta_domain_tree, &domains, &key);

        if (d == NULL) {
                d = xcalloc(1, sizeof(*d));
                d->name = xstrdup(name);
                d->as_host = as_host;
                TAILQ_INIT(&d->mxs);
                SPLAY_INSERT(mta_domain_tree, &domains, d);
                stat_increment("mta.domain", 1);
        }

        d->refcount++;
        return (d);
}

#if 0
static void
mta_domain_ref(struct mta_domain *d)
{
        d->refcount++;
}
#endif

static void
mta_domain_unref(struct mta_domain *d)
{
        struct mta_mx   *mx;

        if (--d->refcount)
                return;

        while ((mx = TAILQ_FIRST(&d->mxs))) {
                TAILQ_REMOVE(&d->mxs, mx, entry);
                mta_host_unref(mx->host); /* from IMSG_DNS_HOST */
                free(mx->mxname);
                free(mx);
        }

        SPLAY_REMOVE(mta_domain_tree, &domains, d);
        free(d->name);
        free(d);
        stat_decrement("mta.domain", 1);
}

static int
mta_domain_cmp(const struct mta_domain *a, const struct mta_domain *b)
{
        if (a->as_host < b->as_host)
                return (-1);
        if (a->as_host > b->as_host)
                return (1);
        return (strcasecmp(a->name, b->name));
}

SPLAY_GENERATE(mta_domain_tree, mta_domain, entry, mta_domain_cmp);

static struct mta_source *
mta_source(const struct sockaddr *sa)
{
        struct mta_source       key, *s;
        struct sockaddr_storage ss;

        if (sa) {
                memmove(&ss, sa, sa->sa_len);
                key.sa = (struct sockaddr*)&ss;
        } else
                key.sa = NULL;
        s = SPLAY_FIND(mta_source_tree, &sources, &key);

        if (s == NULL) {
                s = xcalloc(1, sizeof(*s));
                if (sa)
                        s->sa = xmemdup(sa, sa->sa_len);
                SPLAY_INSERT(mta_source_tree, &sources, s);
                stat_increment("mta.source", 1);
        }

        s->refcount++;
        return (s);
}

static void
mta_source_ref(struct mta_source *s)
{
        s->refcount++;
}

static void
mta_source_unref(struct mta_source *s)
{
        if (--s->refcount)
                return;

        SPLAY_REMOVE(mta_source_tree, &sources, s);
        free(s->sa);
        free(s);
        stat_decrement("mta.source", 1);
}

static const char *
mta_source_to_text(struct mta_source *s)
{
        static char buf[1024];

        if (s->sa == NULL)
                return "[]";
        (void)snprintf(buf, sizeof buf, "%s", sa_to_text(s->sa));
        return (buf);
}

static int
mta_source_cmp(const struct mta_source *a, const struct mta_source *b)
{
        if (a->sa == NULL)
                return ((b->sa == NULL) ? 0 : -1);
        if (b->sa == NULL)
                return (1);
        if (a->sa->sa_len < b->sa->sa_len)
                return (-1);
        if (a->sa->sa_len > b->sa->sa_len)
                return (1);
        return (memcmp(a->sa, b->sa, a->sa->sa_len));
}

SPLAY_GENERATE(mta_source_tree, mta_source, entry, mta_source_cmp);

static struct mta_connector *
mta_connector(struct mta_relay *relay, struct mta_source *source)
{
        struct mta_connector    *c;

        c = tree_get(&relay->connectors, (uintptr_t)(source));
        if (c == NULL) {
                c = xcalloc(1, sizeof(*c));
                c->relay = relay;
                c->source = source;
                c->flags |= CONNECTOR_NEW;
                mta_source_ref(source);
                tree_xset(&relay->connectors, (uintptr_t)(source), c);
                stat_increment("mta.connector", 1);
                log_debug("debug: mta: new %s", mta_connector_to_text(c));
        }

        return (c);
}

static void
mta_connector_free(struct mta_connector *c)
{
        log_debug("debug: mta: freeing %s",
            mta_connector_to_text(c));

        if (c->flags & CONNECTOR_WAIT) {
                log_debug("debug: mta: cancelling timeout for %s",
                    mta_connector_to_text(c));
                runq_cancel(runq_connector, c);
        }
        mta_source_unref(c->source); /* from constructor */
        free(c);

        stat_decrement("mta.connector", 1);
}

static const char *
mta_connector_to_text(struct mta_connector *c)
{
        static char buf[1024];

        (void)snprintf(buf, sizeof buf, "[connector:%s->%s,0x%x]",
            mta_source_to_text(c->source),
            mta_relay_to_text(c->relay),
            c->flags);
        return (buf);
}

static struct mta_route *
mta_route(struct mta_source *src, struct mta_host *dst)
{
        struct mta_route        key, *r;
        static uint64_t         rid = 0;

        key.src = src;
        key.dst = dst;
        r = SPLAY_FIND(mta_route_tree, &routes, &key);

        if (r == NULL) {
                r = xcalloc(1, sizeof(*r));
                r->src = src;
                r->dst = dst;
                r->flags |= ROUTE_NEW;
                r->id = ++rid;
                SPLAY_INSERT(mta_route_tree, &routes, r);
                mta_source_ref(src);
                mta_host_ref(dst);
                stat_increment("mta.route", 1);
        }
        else if (r->flags & ROUTE_RUNQ) {
                log_debug("debug: mta: mta_route_ref(): cancelling runq for route %s",
                    mta_route_to_text(r));
                r->flags &= ~(ROUTE_RUNQ | ROUTE_KEEPALIVE);
                runq_cancel(runq_route, r);
                r->refcount--; /* from mta_route_unref() */
        }

        r->refcount++;
        return (r);
}

static void
mta_route_ref(struct mta_route *r)
{
        r->refcount++;
}

static void
mta_route_unref(struct mta_route *r)
{
        time_t  sched, now;
        int     delay;

        if (--r->refcount)
                return;

        /*
         * Nothing references this route, but we might want to keep it alive
         * for a while.
         */
        now = time(NULL);
        sched = 0;

        if (r->penalty) {
#if DELAY_QUADRATIC
                delay = DELAY_ROUTE_BASE * r->penalty * r->penalty;
#else
                delay = 15 * 60;
#endif
                if (delay > DELAY_ROUTE_MAX)
                        delay = DELAY_ROUTE_MAX;
                sched = r->lastpenalty + delay;
                log_debug("debug: mta: mta_route_unref(): keeping route %s alive for %llus (penalty %d)",
                    mta_route_to_text(r), (unsigned long long) sched - now, r->penalty);
        } else if (!(r->flags & ROUTE_KEEPALIVE)) {
                if (r->lastconn + max_seen_conndelay_route > now)
                        sched = r->lastconn + max_seen_conndelay_route;
                if (r->lastdisc + max_seen_discdelay_route > now &&
                    r->lastdisc + max_seen_discdelay_route < sched)
                        sched = r->lastdisc + max_seen_discdelay_route;

                if (sched > now)
                        log_debug("debug: mta: mta_route_unref(): keeping route %s alive for %llus (imposed delay)",
                            mta_route_to_text(r), (unsigned long long) sched - now);
        }

        if (sched > now) {
                r->flags |= ROUTE_RUNQ;
                runq_schedule_at(runq_route, sched, r);
                r->refcount++;
                return;
        }

        log_debug("debug: mta: mta_route_unref(): really discarding route %s",
            mta_route_to_text(r));

        SPLAY_REMOVE(mta_route_tree, &routes, r);
        mta_source_unref(r->src); /* from constructor */
        mta_host_unref(r->dst); /* from constructor */
        free(r);
        stat_decrement("mta.route", 1);
}

static const char *
mta_route_to_text(struct mta_route *r)
{
        static char     buf[1024];

        (void)snprintf(buf, sizeof buf, "%s <-> %s",
            mta_source_to_text(r->src),
            mta_host_to_text(r->dst));

        return (buf);
}

static int
mta_route_cmp(const struct mta_route *a, const struct mta_route *b)
{
        if (a->src < b->src)
                return (-1);
        if (a->src > b->src)
                return (1);

        if (a->dst < b->dst)
                return (-1);
        if (a->dst > b->dst)
                return (1);

        return (0);
}

SPLAY_GENERATE(mta_route_tree, mta_route, entry, mta_route_cmp);

void
mta_block(struct mta_source *src, char *dom)
{
        struct mta_block key, *b;

        key.source = src;
        key.domain = dom;

        b = SPLAY_FIND(mta_block_tree, &blocks, &key);
        if (b != NULL)
                return;

        b = xcalloc(1, sizeof(*b));
        if (dom)
                b->domain = xstrdup(dom);
        b->source = src;
        mta_source_ref(src);
        SPLAY_INSERT(mta_block_tree, &blocks, b);
}

void
mta_unblock(struct mta_source *src, char *dom)
{
        struct mta_block key, *b;

        key.source = src;
        key.domain = dom;

        b = SPLAY_FIND(mta_block_tree, &blocks, &key);
        if (b == NULL)
                return;

        SPLAY_REMOVE(mta_block_tree, &blocks, b);

        mta_source_unref(b->source);
        free(b->domain);
        free(b);
}

int
mta_is_blocked(struct mta_source *src, char *dom)
{
        struct mta_block key;

        key.source = src;
        key.domain = dom;

        if (SPLAY_FIND(mta_block_tree, &blocks, &key))
                return (1);

        return (0);
}

static
int
mta_block_cmp(const struct mta_block *a, const struct mta_block *b)
{
        if (a->source < b->source)
                return (-1);
        if (a->source > b->source)
                return (1);
        if (!a->domain && b->domain)
                return (-1);
        if (a->domain && !b->domain)
                return (1);
        if (a->domain == b->domain)
                return (0);
        return (strcasecmp(a->domain, b->domain));
}

SPLAY_GENERATE(mta_block_tree, mta_block, entry, mta_block_cmp);



/* hoststat errors are not critical, we do best effort */
void
mta_hoststat_update(const char *host, const char *error)
{
        struct hoststat *hs = NULL;
        char             buf[HOST_NAME_MAX+1];

        if (!lowercase(buf, host, sizeof buf))
                return;

        hs = dict_get(&hoststat, buf);
        if (hs == NULL) {
                if ((hs = calloc(1, sizeof *hs)) == NULL)
                        return;
                tree_init(&hs->deferred);
                runq_schedule(runq_hoststat, HOSTSTAT_EXPIRE_DELAY, hs);
        }
        (void)strlcpy(hs->name, buf, sizeof hs->name);
        (void)strlcpy(hs->error, error, sizeof hs->error);
        hs->tm = time(NULL);
        dict_set(&hoststat, buf, hs);

        runq_cancel(runq_hoststat, hs);
        runq_schedule(runq_hoststat, HOSTSTAT_EXPIRE_DELAY, hs);
}

void
mta_hoststat_cache(const char *host, uint64_t evpid)
{
        struct hoststat *hs = NULL;
        char buf[HOST_NAME_MAX+1];

        if (!lowercase(buf, host, sizeof buf))
                return;

        hs = dict_get(&hoststat, buf);
        if (hs == NULL)
                return;

        if (tree_count(&hs->deferred) >= env->sc_mta_max_deferred)
                return;

        tree_set(&hs->deferred, evpid, NULL);
}

void
mta_hoststat_uncache(const char *host, uint64_t evpid)
{
        struct hoststat *hs = NULL;
        char buf[HOST_NAME_MAX+1];

        if (!lowercase(buf, host, sizeof buf))
                return;

        hs = dict_get(&hoststat, buf);
        if (hs == NULL)
                return;

        tree_pop(&hs->deferred, evpid);
}

void
mta_hoststat_reschedule(const char *host)
{
        struct hoststat *hs = NULL;
        char             buf[HOST_NAME_MAX+1];
        uint64_t         evpid;

        if (!lowercase(buf, host, sizeof buf))
                return;

        hs = dict_get(&hoststat, buf);
        if (hs == NULL)
                return;

        while (tree_poproot(&hs->deferred, &evpid, NULL)) {
                m_compose(p_queue, IMSG_MTA_SCHEDULE, 0, 0, -1,
                    &evpid, sizeof evpid);
        }
}

static void
mta_hoststat_remove_entry(struct hoststat *hs)
{
        while (tree_poproot(&hs->deferred, NULL, NULL))
                ;
        dict_pop(&hoststat, hs->name);
        runq_cancel(runq_hoststat, hs);
}