lib-lda: Renamed smtp-client to smtp-submit (2/2).

Renamed smtp_client identifiers to smtp_submit.
Also, created temporary backwards-compatibility in smtp-client.h.

diff --git a/src/lib-lda/Makefile.am b/src/lib-lda/Makefile.am
index 3a298e870d14a394b3101d20f1c1bb5dcbbafce3..8b35e599b7c3d02bcb68bf77d183905f3fcf803e 100644 (file)
--- a/src/lib-lda/Makefile.am
+++ b/src/lib-lda/Makefile.am
@@ -19,14 +19,16 @@ liblda_la_SOURCES = \
        lda-settings.c \
        mail-deliver.c \
        mail-send.c \
-       smtp-submit.c
+       smtp-submit.c \
+       smtp-client.c
 
 headers = \
        duplicate.h \
        lda-settings.h \
        mail-deliver.h \
        mail-send.h \
-       smtp-submit.h
+       smtp-submit.h \
+       smtp-client.h
 
 pkginc_libdir=$(pkgincludedir)
 pkginc_lib_HEADERS = $(headers)

diff --git a/src/lib-lda/mail-send.c b/src/lib-lda/mail-send.c
index 9753c78ee583dd98991b0189da3e71bcab1c87b9..9314f8ecbf7e93982a5b0bf3bc39d586dfb49357 100644 (file)
--- a/src/lib-lda/mail-send.c
+++ b/src/lib-lda/mail-send.c
@@ -47,7 +47,7 @@ int mail_send_rejection(struct mail_deliver_context *ctx, const char *recipient,
 {
        struct mail *mail = ctx->src_mail;
        struct istream *input;
-       struct smtp_client *smtp_client;
+       struct smtp_submit *smtp_submit;
        struct ostream *output;
        const char *return_addr, *hdr;
        const char *value, *msgid, *orig_msgid, *boundary, *error;
@@ -81,9 +81,9 @@ int mail_send_rejection(struct mail_deliver_context *ctx, const char *recipient,
 
        vtable = get_var_expand_table(mail, reason, recipient);
 
-       smtp_client = smtp_client_init(ctx->set, NULL);
-       smtp_client_add_rcpt(smtp_client, return_addr);
-       output = smtp_client_send(smtp_client);
+       smtp_submit = smtp_submit_init(ctx->set, NULL);
+       smtp_submit_add_rcpt(smtp_submit, return_addr);
+       output = smtp_submit_send(smtp_submit);
 
        msgid = mail_deliver_get_new_message_id(ctx);
        boundary = t_strdup_printf("%s/%s", my_pid, ctx->set->hostname);
@@ -181,8 +181,8 @@ int mail_send_rejection(struct mail_deliver_context *ctx, const char *recipient,
        str_truncate(str, 0);
        str_printfa(str, "\r\n\r\n--%s--\r\n", boundary);
        o_stream_nsend(output, str_data(str), str_len(str));
-       if ((ret = smtp_client_deinit_timeout
-               (smtp_client, ctx->timeout_secs, &error)) < 0) {
+       if ((ret = smtp_submit_deinit_timeout
+               (smtp_submit, ctx->timeout_secs, &error)) < 0) {
                i_error("msgid=%s: Temporarily failed to send rejection: %s",
                        orig_msgid == NULL ? "" : str_sanitize(orig_msgid, 80),
                        str_sanitize(error, 512));

diff --git a/src/lib-lda/smtp-client.c b/src/lib-lda/smtp-client.c
new file mode 100644 (file)
index 0000000..f17d8f0
--- /dev/null
+++ b/src/lib-lda/smtp-client.c
@@ -0,0 +1,55 @@
+/* Copyright (c) 2006-2017 Dovecot authors, see the included COPYING file */
+
+#include "lib.h"
+#include "lda-settings.h"
+#include "smtp-submit.h"
+#include "smtp-client.h"
+
+struct smtp_client {
+       struct smtp_submit *submit;
+};
+
+struct smtp_client *
+smtp_client_init(const struct lda_settings *set, const char *return_path)
+{
+       struct smtp_client *client;
+
+       client = i_new(struct smtp_client, 1);
+       client->submit = smtp_submit_init(set, return_path);
+       return client;
+}
+
+void smtp_client_add_rcpt(struct smtp_client *client, const char *address)
+{
+       smtp_submit_add_rcpt(client->submit, address);
+}
+
+struct ostream *smtp_client_send(struct smtp_client *client)
+{
+       return smtp_submit_send(client->submit);
+}
+
+void smtp_client_abort(struct smtp_client **_client)
+{
+       struct smtp_client *client = *_client;
+
+       *_client = NULL;
+
+       smtp_submit_abort(&client->submit);
+       i_free(client);
+}
+
+int smtp_client_deinit(struct smtp_client *client, const char **error_r)
+{
+       return smtp_client_deinit_timeout(client, 0, error_r);
+}
+
+int smtp_client_deinit_timeout(struct smtp_client *client,
+                              unsigned int timeout_secs, const char **error_r)
+{
+       int  ret;
+
+       ret = smtp_submit_deinit_timeout(client->submit, timeout_secs, error_r);
+       i_free(client);
+       return ret;
+}

diff --git a/src/lib-lda/smtp-client.h b/src/lib-lda/smtp-client.h
index 2f40c075d17c3cac206b81b10e95f984eaed9f35..585bb2276c8402d20a6ff9497a48d481c73028ca 100644 (file)
--- a/src/lib-lda/smtp-client.h
+++ b/src/lib-lda/smtp-client.h
@@ -1 +1,18 @@
-#include "smtp-submit.h"
+#ifndef SMTP_CLIENT_H
+#define SMTP_CLIENT_H
+
+struct smtp_client * ATTR_NULL(3)
+smtp_client_init(const struct lda_settings *set, const char *return_path);
+/* Add a new recipient */
+void smtp_client_add_rcpt(struct smtp_client *client, const char *address);
+/* Get an output stream where the message can be written to. The recipients
+   must already be added before calling this. */
+struct ostream *smtp_client_send(struct smtp_client *client);
+void smtp_client_abort(struct smtp_client **client);
+/* Returns 1 on success, 0 on permanent failure (e.g. invalid destination),
+   -1 on temporary failure. */
+int smtp_client_deinit(struct smtp_client *client, const char **error_r);
+/* Same as smtp_client_deinit(), but timeout after given number of seconds. */
+int smtp_client_deinit_timeout(struct smtp_client *client,
+                              unsigned int timeout_secs, const char **error_r);
+#endif

diff --git a/src/lib-lda/smtp-submit.c b/src/lib-lda/smtp-submit.c
index 538fe2ee022fd8586977204113127003ea90dc36..d284742d0c6170978aed00b80bddbb1825bb2ad1 100644 (file)
--- a/src/lib-lda/smtp-submit.c
+++ b/src/lib-lda/smtp-submit.c
@@ -21,7 +21,7 @@
 
 #define DEFAULT_SUBMISSION_PORT 25
 
-struct smtp_client {
+struct smtp_submit {
        pool_t pool;
        struct ostream *output;
        struct istream *input;
@@ -36,89 +36,89 @@ struct smtp_client {
        bool tempfail:1;
 };
 
-struct smtp_client *
-smtp_client_init(const struct lda_settings *set, const char *return_path)
+struct smtp_submit *
+smtp_submit_init(const struct lda_settings *set, const char *return_path)
 {
-       struct smtp_client *client;
+       struct smtp_submit *subm;
        pool_t pool;
 
-       pool = pool_alloconly_create("smtp client", 256);
-       client = p_new(pool, struct smtp_client, 1);
-       client->pool = pool;
-       client->set = set;
-       client->return_path = p_strdup(pool, return_path);
-       p_array_init(&client->destinations, pool, 2);
-       return client;
+       pool = pool_alloconly_create("smtp submit", 256);
+       subm = p_new(pool, struct smtp_submit, 1);
+       subm->pool = pool;
+       subm->set = set;
+       subm->return_path = p_strdup(pool, return_path);
+       p_array_init(&subm->destinations, pool, 2);
+       return subm;
 }
 
-void smtp_client_add_rcpt(struct smtp_client *client, const char *address)
+void smtp_submit_add_rcpt(struct smtp_submit *subm, const char *address)
 {
-       i_assert(client->output == NULL);
+       i_assert(subm->output == NULL);
 
-       address = p_strdup(client->pool, address);
-       array_append(&client->destinations, &address, 1);
+       address = p_strdup(subm->pool, address);
+       array_append(&subm->destinations, &address, 1);
 }
 
-struct ostream *smtp_client_send(struct smtp_client *client)
+struct ostream *smtp_submit_send(struct smtp_submit *subm)
 {
-       i_assert(client->output == NULL);
-       i_assert(array_count(&client->destinations) > 0);
+       i_assert(subm->output == NULL);
+       i_assert(array_count(&subm->destinations) > 0);
 
-       client->output = iostream_temp_create
+       subm->output = iostream_temp_create
                (t_strconcat("/tmp/dovecot.",
                        master_service_get_name(master_service), NULL), 0);
-       o_stream_set_no_error_handling(client->output, TRUE);
-       return client->output;
+       o_stream_set_no_error_handling(subm->output, TRUE);
+       return subm->output;
 }
 
-static void smtp_client_send_finished(void *context)
+static void smtp_submit_send_finished(void *context)
 {
-       struct smtp_client *smtp_client = context;
+       struct smtp_submit *smtp_submit = context;
 
-       smtp_client->finished = TRUE;
+       smtp_submit->finished = TRUE;
        io_loop_stop(current_ioloop);
 }
 
 static void
-smtp_client_error(struct smtp_client *client,
+smtp_submit_error(struct smtp_submit *subm,
                 bool tempfail, const char *error)
 {
-       if (client->error == NULL) {
-               client->tempfail = tempfail;
-               client->error = p_strdup_printf(client->pool,
+       if (subm->error == NULL) {
+               subm->tempfail = tempfail;
+               subm->error = p_strdup_printf(subm->pool,
                        "smtp(%s): %s",
-                       client->set->submission_host, error);
+                       subm->set->submission_host, error);
        }
 }
 
 static void
 rcpt_to_callback(enum lmtp_client_result result, const char *reply, void *context)
 {
-       struct smtp_client *client = context;
+       struct smtp_submit *subm = context;
 
        if (result != LMTP_CLIENT_RESULT_OK) {
-               smtp_client_error(client, (reply[0] != '5'),
+               smtp_submit_error(subm, (reply[0] != '5'),
                        t_strdup_printf("RCPT TO failed: %s", reply));
-               smtp_client_send_finished(client);
+               smtp_submit_send_finished(subm);
        }
 }
 
 static void
 data_callback(enum lmtp_client_result result, const char *reply, void *context)
 {
-       struct smtp_client *client = context;
+       struct smtp_submit *subm = context;
 
        if (result != LMTP_CLIENT_RESULT_OK) {
-               smtp_client_error(client, (reply[0] != '5'),
+               smtp_submit_error(subm, (reply[0] != '5'),
                        t_strdup_printf("DATA failed: %s", reply));
-               smtp_client_send_finished(client);
+               smtp_submit_send_finished(subm);
        } else {
-               client->success = TRUE;
+               subm->success = TRUE;
        }
 }
 
 static int
-smtp_client_send_host(struct smtp_client *client,
+smtp_submit_send_host(struct smtp_submit *subm,
                       unsigned int timeout_secs, const char **error_r)
 {
        struct lmtp_client_settings client_set;
@@ -127,7 +127,7 @@ smtp_client_send_host(struct smtp_client *client,
        const char *host, *const *destp;
        in_port_t port;
 
-       if (net_str2hostport(client->set->submission_host,
+       if (net_str2hostport(subm->set->submission_host,
                             DEFAULT_SUBMISSION_PORT, &host, &port) < 0) {
                *error_r = t_strdup_printf(
                        "Invalid submission_host: %s", host);
@@ -135,14 +135,14 @@ smtp_client_send_host(struct smtp_client *client,
        }
 
        i_zero(&client_set);
-       client_set.mail_from = client->return_path == NULL ? "<>" :
-               t_strconcat("<", client->return_path, ">", NULL);
-       client_set.my_hostname = client->set->hostname;
+       client_set.mail_from = subm->return_path == NULL ? "<>" :
+               t_strconcat("<", subm->return_path, ">", NULL);
+       client_set.my_hostname = subm->set->hostname;
        client_set.timeout_secs = timeout_secs;
 
        ioloop = io_loop_create();
-       lmtp_client = lmtp_client_init(&client_set, smtp_client_send_finished,
-                                 client);
+       lmtp_client = lmtp_client_init(&client_set, smtp_submit_send_finished,
+                                 subm);
 
        if (lmtp_client_connect_tcp(lmtp_client, LMTP_CLIENT_PROTOCOL_SMTP,
                                    host, port) < 0) {
@@ -153,34 +153,34 @@ smtp_client_send_host(struct smtp_client *client,
                return -1;
        }
 
-       array_foreach(&client->destinations, destp) {
+       array_foreach(&subm->destinations, destp) {
                lmtp_client_add_rcpt(lmtp_client, *destp, rcpt_to_callback,
-                                    data_callback, client);
+                                    data_callback, subm);
        }
 
-       lmtp_client_send(lmtp_client, client->input);
-       i_stream_unref(&client->input);
+       lmtp_client_send(lmtp_client, subm->input);
+       i_stream_unref(&subm->input);
 
-       if (!client->finished)
+       if (!subm->finished)
                io_loop_run(ioloop);
        lmtp_client_deinit(&lmtp_client);
        io_loop_destroy(&ioloop);
 
-       if (client->success)
+       if (subm->success)
                return 1;
-       else if (client->tempfail) {
-               i_assert(client->error != NULL);
-               *error_r = t_strdup(client->error);
+       else if (subm->tempfail) {
+               i_assert(subm->error != NULL);
+               *error_r = t_strdup(subm->error);
                return -1;
        } else {
-               i_assert(client->error != NULL);
-               *error_r = t_strdup(client->error);
+               i_assert(subm->error != NULL);
+               *error_r = t_strdup(subm->error);
                return 0;
        }
 }
 
 static int
-smtp_client_send_sendmail(struct smtp_client *client,
+smtp_submit_send_sendmail(struct smtp_submit *subm,
                       unsigned int timeout_secs, const char **error_r)
 {
        const char *const *sendmail_args, *sendmail_bin, *str;
@@ -190,7 +190,7 @@ smtp_client_send_sendmail(struct smtp_client *client,
        struct program_client *pc;
        int ret;
 
-       sendmail_args = t_strsplit(client->set->sendmail_path, " ");
+       sendmail_args = t_strsplit(subm->set->sendmail_path, " ");
        t_array_init(&args, 16);
        i_assert(sendmail_args[0] != NULL);
        sendmail_bin = sendmail_args[0];
@@ -199,13 +199,13 @@ smtp_client_send_sendmail(struct smtp_client *client,
 
        str = "-i"; array_append(&args, &str, 1); /* ignore dots */
        str = "-f"; array_append(&args, &str, 1);
-       str = (client->return_path != NULL &&
-               *client->return_path != '\0' ?
-                       client->return_path : "<>");
+       str = (subm->return_path != NULL &&
+               *subm->return_path != '\0' ?
+                       subm->return_path : "<>");
        array_append(&args, &str, 1);
 
        str = "--"; array_append(&args, &str, 1);
-       array_append_array(&args, &client->destinations);
+       array_append_array(&args, &subm->destinations);
        array_append_zero(&args);
 
        i_zero(&pc_set);
@@ -216,8 +216,8 @@ smtp_client_send_sendmail(struct smtp_client *client,
        pc = program_client_local_create
                (sendmail_bin, array_idx(&args, 0), &pc_set);
 
-       program_client_set_input(pc, client->input);
-       i_stream_unref(&client->input);
+       program_client_set_input(pc, subm->input);
+       i_stream_unref(&subm->input);
 
        ret = program_client_run(pc);
 
@@ -233,43 +233,43 @@ smtp_client_send_sendmail(struct smtp_client *client,
        return 1;
 }
 
-void smtp_client_abort(struct smtp_client **_client)
+void smtp_submit_abort(struct smtp_submit **_subm)
 {
-       struct smtp_client *client = *_client;
+       struct smtp_submit *subm = *_subm;
 
-       *_client = NULL;
+       *_subm = NULL;
 
-       if (client->output != NULL) {
-               o_stream_ignore_last_errors(client->output);
-               o_stream_destroy(&client->output);
+       if (subm->output != NULL) {
+               o_stream_ignore_last_errors(subm->output);
+               o_stream_destroy(&subm->output);
        }
-       if (client->input != NULL)
-               i_stream_destroy(&client->input);
-       pool_unref(&client->pool);
+       if (subm->input != NULL)
+               i_stream_destroy(&subm->input);
+       pool_unref(&subm->pool);
 }
 
-int smtp_client_deinit(struct smtp_client *client, const char **error_r)
+int smtp_submit_deinit(struct smtp_submit *subm, const char **error_r)
 {
-       return smtp_client_deinit_timeout(client, 0, error_r);
+       return smtp_submit_deinit_timeout(subm, 0, error_r);
 }
 
-int smtp_client_deinit_timeout(struct smtp_client *client,
+int smtp_submit_deinit_timeout(struct smtp_submit *subm,
                               unsigned int timeout_secs, const char **error_r)
 {
        int ret;
 
        /* the mail has been written to a file. now actually send it. */
-       client->input = iostream_temp_finish
-               (&client->output, IO_BLOCK_SIZE);
+       subm->input = iostream_temp_finish
+               (&subm->output, IO_BLOCK_SIZE);
 
-       if (*client->set->submission_host != '\0') {
-               ret = smtp_client_send_host
-                       (client, timeout_secs, error_r);
+       if (*subm->set->submission_host != '\0') {
+               ret = smtp_submit_send_host
+                       (subm, timeout_secs, error_r);
        } else {
-               ret = smtp_client_send_sendmail
-                       (client, timeout_secs, error_r);
+               ret = smtp_submit_send_sendmail
+                       (subm, timeout_secs, error_r);
        }
 
-       smtp_client_abort(&client);
+       smtp_submit_abort(&subm);
        return ret;
 }

diff --git a/src/lib-lda/smtp-submit.h b/src/lib-lda/smtp-submit.h
index 585bb2276c8402d20a6ff9497a48d481c73028ca..51c877ef8a84674949e00d2c361d9863c724c6b4 100644 (file)
--- a/src/lib-lda/smtp-submit.h
+++ b/src/lib-lda/smtp-submit.h
@@ -1,18 +1,18 @@
-#ifndef SMTP_CLIENT_H
-#define SMTP_CLIENT_H
+#ifndef SMTP_SUBMIT_H
+#define SMTP_SUBMIT_H
 
-struct smtp_client * ATTR_NULL(3)
-smtp_client_init(const struct lda_settings *set, const char *return_path);
+struct smtp_submit * ATTR_NULL(3)
+smtp_submit_init(const struct lda_settings *set, const char *return_path);
 /* Add a new recipient */
-void smtp_client_add_rcpt(struct smtp_client *client, const char *address);
+void smtp_submit_add_rcpt(struct smtp_submit *subm, const char *address);
 /* Get an output stream where the message can be written to. The recipients
    must already be added before calling this. */
-struct ostream *smtp_client_send(struct smtp_client *client);
-void smtp_client_abort(struct smtp_client **client);
+struct ostream *smtp_submit_send(struct smtp_submit *subm);
+void smtp_submit_abort(struct smtp_submit **_subm);
 /* Returns 1 on success, 0 on permanent failure (e.g. invalid destination),
    -1 on temporary failure. */
-int smtp_client_deinit(struct smtp_client *client, const char **error_r);
-/* Same as smtp_client_deinit(), but timeout after given number of seconds. */
-int smtp_client_deinit_timeout(struct smtp_client *client,
+int smtp_submit_deinit(struct smtp_submit *subm, const char **error_r);
+/* Same as smtp_submit_deinit(), but timeout after given number of seconds. */
+int smtp_submit_deinit_timeout(struct smtp_submit *subm,
                               unsigned int timeout_secs, const char **error_r);
 #endif

diff --git a/src/lib-lda/test-smtp-submit.c b/src/lib-lda/test-smtp-submit.c
index 46c93a8ae9a38a4138f07a2d057cb551c2fa6ea7..c305687d719d5617c05e57a7b8257ddcf61e3fe3 100644 (file)
--- a/src/lib-lda/test-smtp-submit.c
+++ b/src/lib-lda/test-smtp-submit.c
@@ -46,7 +46,7 @@ struct server_connection {
 
 typedef void (*test_server_init_t)(unsigned int index);
 typedef bool (*test_client_init_t)
-       (const struct lda_settings *client_set);
+       (const struct lda_settings *submit_set);
 
 /*
  * State
@@ -103,7 +103,7 @@ static void
 test_message_delivery(const char *message, const char *file);
 
 static void test_run_client_server(
-       const struct lda_settings *client_set,
+       const struct lda_settings *submit_set,
        test_client_init_t client_test,
        test_server_init_t server_test,
        unsigned int server_tests_count)
@@ -116,12 +116,12 @@ static void test_run_client_server(
 /* client */
 
 static bool
-test_client_host_lookup_failed(const struct lda_settings *client_set)
+test_client_host_lookup_failed(const struct lda_settings *submit_set)
 {
        const char *error = NULL;
        int ret;
 
-       ret = test_client_smtp_send_simple(client_set,
+       ret = test_client_smtp_send_simple(submit_set,
                test_message1, "host.invalid", 5, &error);
        test_out_reason("run (ret < 0)", ret < 0, error);
 
@@ -132,13 +132,13 @@ test_client_host_lookup_failed(const struct lda_settings *client_set)
 
 static void test_host_lookup_failed(void)
 {
-       struct lda_settings smtp_client_set;
+       struct lda_settings smtp_submit_set;
 
-       test_client_defaults(&smtp_client_set);
+       test_client_defaults(&smtp_submit_set);
 
        test_begin("host lookup failed");
        test_expect_errors(1);
-       test_run_client_server(&smtp_client_set,
+       test_run_client_server(&smtp_submit_set,
                test_client_host_lookup_failed,
                NULL, 0);
        test_end();
@@ -159,12 +159,12 @@ test_server_connection_refused(unsigned int index ATTR_UNUSED)
 /* client */
 
 static bool
-test_client_connection_refused(const struct lda_settings *client_set)
+test_client_connection_refused(const struct lda_settings *submit_set)
 {
        const char *error = NULL;
        int ret;
 
-       ret = test_client_smtp_send_simple_port(client_set,
+       ret = test_client_smtp_send_simple_port(submit_set,
                test_message1, bind_ports[0], 5, &error);
        test_out_reason("run (ret < 0)", ret < 0, error);
 
@@ -175,13 +175,13 @@ test_client_connection_refused(const struct lda_settings *client_set)
 
 static void test_connection_refused(void)
 {
-       struct lda_settings smtp_client_set;
+       struct lda_settings smtp_submit_set;
 
-       test_client_defaults(&smtp_client_set);
+       test_client_defaults(&smtp_submit_set);
 
        test_begin("connection refused");
        test_expect_errors(1);
-       test_run_client_server(&smtp_client_set,
+       test_run_client_server(&smtp_submit_set,
                test_client_connection_refused,
                test_server_connection_refused, 1);
        test_end();
@@ -208,7 +208,7 @@ static void test_server_connection_timed_out(unsigned int index)
 /* client */
 
 static bool
-test_client_connection_timed_out(const struct lda_settings *client_set)
+test_client_connection_timed_out(const struct lda_settings *submit_set)
 {
        time_t time;
        const char *error = NULL;
@@ -216,7 +216,7 @@ test_client_connection_timed_out(const struct lda_settings *client_set)
 
        io_loop_time_refresh();
        time = ioloop_time;
-       ret = test_client_smtp_send_simple_port(client_set,
+       ret = test_client_smtp_send_simple_port(submit_set,
                test_message1, bind_ports[0], 1, &error);
        test_out_reason("run (ret < 0)", ret < 0, error);
 
@@ -230,13 +230,13 @@ test_client_connection_timed_out(const struct lda_settings *client_set)
 
 static void test_connection_timed_out(void)
 {
-       struct lda_settings smtp_client_set;
+       struct lda_settings smtp_submit_set;
 
-       test_client_defaults(&smtp_client_set);
+       test_client_defaults(&smtp_submit_set);
 
        test_begin("connection timed out");
        test_expect_errors(0);
-       test_run_client_server(&smtp_client_set,
+       test_run_client_server(&smtp_submit_set,
                test_client_connection_timed_out,
                test_server_connection_timed_out, 1);
        test_end();
@@ -271,12 +271,12 @@ static void test_server_bad_greeting(unsigned int index)
 /* client */
 
 static bool
-test_client_bad_greeting(const struct lda_settings *client_set)
+test_client_bad_greeting(const struct lda_settings *submit_set)
 {
        const char *error = NULL;
        int ret;
 
-       ret = test_client_smtp_send_simple_port(client_set,
+       ret = test_client_smtp_send_simple_port(submit_set,
                test_message1, bind_ports[0], 5, &error);
        // FIXME: lmtp client handles this wrong, the greeting is not "bad"
        //test_out_reason("run", ret == 0, error);
@@ -289,13 +289,13 @@ test_client_bad_greeting(const struct lda_settings *client_set)
 
 static void test_bad_greeting(void)
 {
-       struct lda_settings smtp_client_set;
+       struct lda_settings smtp_submit_set;
 
-       test_client_defaults(&smtp_client_set);
+       test_client_defaults(&smtp_submit_set);
 
        test_begin("bad greeting");
        test_expect_errors(0);
-       test_run_client_server(&smtp_client_set,
+       test_run_client_server(&smtp_submit_set,
                test_client_bad_greeting,
                test_server_bad_greeting, 1);
        test_end();
@@ -341,12 +341,12 @@ static void test_server_denied_helo(unsigned int index)
 /* client */
 
 static bool
-test_client_denied_helo(const struct lda_settings *client_set)
+test_client_denied_helo(const struct lda_settings *submit_set)
 {
        const char *error = NULL;
        int ret;
 
-       ret = test_client_smtp_send_simple_port(client_set,
+       ret = test_client_smtp_send_simple_port(submit_set,
                test_message1, bind_ports[0], 5, &error);
        // FIXME: lmtp client handles this wrong, the greeting is not "bad"
        //test_out_reason("run", ret == 0, error);
@@ -359,13 +359,13 @@ test_client_denied_helo(const struct lda_settings *client_set)
 
 static void test_denied_helo(void)
 {
-       struct lda_settings smtp_client_set;
+       struct lda_settings smtp_submit_set;
 
-       test_client_defaults(&smtp_client_set);
+       test_client_defaults(&smtp_submit_set);
 
        test_begin("denied helo");
        test_expect_errors(0);
-       test_run_client_server(&smtp_client_set,
+       test_run_client_server(&smtp_submit_set,
                test_client_denied_helo,
                test_server_denied_helo, 1);
        test_end();
@@ -409,12 +409,12 @@ static void test_server_disconnect_helo(unsigned int index)
 /* client */
 
 static bool
-test_client_disconnect_helo(const struct lda_settings *client_set)
+test_client_disconnect_helo(const struct lda_settings *submit_set)
 {
        const char *error = NULL;
        int ret;
 
-       ret = test_client_smtp_send_simple_port(client_set,
+       ret = test_client_smtp_send_simple_port(submit_set,
                test_message1, bind_ports[0], 5, &error);
        // FIXME: lmtp client handles this wrong, the greeting is not "bad"
        //test_out_reason("run", ret == 0, error);
@@ -427,13 +427,13 @@ test_client_disconnect_helo(const struct lda_settings *client_set)
 
 static void test_disconnect_helo(void)
 {
-       struct lda_settings smtp_client_set;
+       struct lda_settings smtp_submit_set;
 
-       test_client_defaults(&smtp_client_set);
+       test_client_defaults(&smtp_submit_set);
 
        test_begin("disconnect helo");
        test_expect_errors(0);
-       test_run_client_server(&smtp_client_set,
+       test_run_client_server(&smtp_submit_set,
                test_client_disconnect_helo,
                test_server_disconnect_helo, 1);
        test_end();
@@ -513,12 +513,12 @@ static void test_server_denied_mail(unsigned int index)
 /* client */
 
 static bool
-test_client_denied_mail(const struct lda_settings *client_set)
+test_client_denied_mail(const struct lda_settings *submit_set)
 {
        const char *error = NULL;
        int ret;
 
-       ret = test_client_smtp_send_simple_port(client_set,
+       ret = test_client_smtp_send_simple_port(submit_set,
                test_message1, bind_ports[0], 5, &error);
        // FIXME: lmtp client handles this wrong, the greeting is not "bad"
        //test_out_reason("run", ret == 0, error);
@@ -531,13 +531,13 @@ test_client_denied_mail(const struct lda_settings *client_set)
 
 static void test_denied_mail(void)
 {
-       struct lda_settings smtp_client_set;
+       struct lda_settings smtp_submit_set;
 
-       test_client_defaults(&smtp_client_set);
+       test_client_defaults(&smtp_submit_set);
 
        test_begin("denied mail");
        test_expect_errors(0);
-       test_run_client_server(&smtp_client_set,
+       test_run_client_server(&smtp_submit_set,
                test_client_denied_mail,
                test_server_denied_mail, 1);
        test_end();
@@ -623,12 +623,12 @@ static void test_server_denied_rcpt(unsigned int index)
 /* client */
 
 static bool
-test_client_denied_rcpt(const struct lda_settings *client_set)
+test_client_denied_rcpt(const struct lda_settings *submit_set)
 {
        const char *error = NULL;
        int ret;
 
-       ret = test_client_smtp_send_simple_port(client_set,
+       ret = test_client_smtp_send_simple_port(submit_set,
                test_message1, bind_ports[0], 5, &error);
        test_out_reason("run (ret == 0)", ret == 0, error);
 
@@ -639,13 +639,13 @@ test_client_denied_rcpt(const struct lda_settings *client_set)
 
 static void test_denied_rcpt(void)
 {
-       struct lda_settings smtp_client_set;
+       struct lda_settings smtp_submit_set;
 
-       test_client_defaults(&smtp_client_set);
+       test_client_defaults(&smtp_submit_set);
 
        test_begin("denied rcpt");
        test_expect_errors(0);
-       test_run_client_server(&smtp_client_set,
+       test_run_client_server(&smtp_submit_set,
                test_client_denied_rcpt,
                test_server_denied_rcpt, 1);
        test_end();
@@ -737,26 +737,26 @@ static void test_server_denied_second_rcpt(unsigned int index)
 /* client */
 
 static bool
-test_client_denied_second_rcpt(const struct lda_settings *client_set)
+test_client_denied_second_rcpt(const struct lda_settings *submit_set)
 {
-       struct smtp_client *smtp_client;
-       struct lda_settings smtp_client_set;
+       struct smtp_submit *smtp_submit;
+       struct lda_settings smtp_submit_set;
        struct ostream *output;
        const char *error = NULL;
        int ret;
 
-       smtp_client_set = *client_set;
-       smtp_client_set.submission_host =
+       smtp_submit_set = *submit_set;
+       smtp_submit_set.submission_host =
                t_strdup_printf("127.0.0.1:%u", bind_ports[0]);
 
-       smtp_client = smtp_client_init(&smtp_client_set, "sender@example.com");
+       smtp_submit = smtp_submit_init(&smtp_submit_set, "sender@example.com");
 
-       smtp_client_add_rcpt(smtp_client, "rcpt@example.com");
-       smtp_client_add_rcpt(smtp_client, "rcpt2@example.com");
-       output = smtp_client_send(smtp_client);
+       smtp_submit_add_rcpt(smtp_submit, "rcpt@example.com");
+       smtp_submit_add_rcpt(smtp_submit, "rcpt2@example.com");
+       output = smtp_submit_send(smtp_submit);
        o_stream_send_str(output, test_message1);
 
-       ret = smtp_client_deinit_timeout(smtp_client, 5, &error);
+       ret = smtp_submit_deinit_timeout(smtp_submit, 5, &error);
        test_out_reason("run (ret == 0)", ret == 0, error);
 
        return FALSE;
@@ -766,13 +766,13 @@ test_client_denied_second_rcpt(const struct lda_settings *client_set)
 
 static void test_denied_second_rcpt(void)
 {
-       struct lda_settings smtp_client_set;
+       struct lda_settings smtp_submit_set;
 
-       test_client_defaults(&smtp_client_set);
+       test_client_defaults(&smtp_submit_set);
 
        test_begin("denied second rcpt");
        test_expect_errors(0);
-       test_run_client_server(&smtp_client_set,
+       test_run_client_server(&smtp_submit_set,
                test_client_denied_second_rcpt,
                test_server_denied_second_rcpt, 1);
        test_end();
@@ -864,12 +864,12 @@ static void test_server_denied_data(unsigned int index)
 /* client */
 
 static bool
-test_client_denied_data(const struct lda_settings *client_set)
+test_client_denied_data(const struct lda_settings *submit_set)
 {
        const char *error = NULL;
        int ret;
 
-       ret = test_client_smtp_send_simple_port(client_set,
+       ret = test_client_smtp_send_simple_port(submit_set,
                test_message1, bind_ports[0], 5, &error);
        test_out_reason("run (ret == 0)", ret == 0, error);
 
@@ -880,13 +880,13 @@ test_client_denied_data(const struct lda_settings *client_set)
 
 static void test_denied_data(void)
 {
-       struct lda_settings smtp_client_set;
+       struct lda_settings smtp_submit_set;
 
-       test_client_defaults(&smtp_client_set);
+       test_client_defaults(&smtp_submit_set);
 
        test_begin("denied data");
        test_expect_errors(0);
-       test_run_client_server(&smtp_client_set,
+       test_run_client_server(&smtp_submit_set,
                test_client_denied_data,
                test_server_denied_data, 1);
        test_end();
@@ -987,12 +987,12 @@ static void test_server_data_failure(unsigned int index)
 /* client */
 
 static bool
-test_client_data_failure(const struct lda_settings *client_set)
+test_client_data_failure(const struct lda_settings *submit_set)
 {
        const char *error = NULL;
        int ret;
 
-       ret = test_client_smtp_send_simple_port(client_set,
+       ret = test_client_smtp_send_simple_port(submit_set,
                test_message1, bind_ports[0], 5, &error);
        test_out_reason("run (ret == 0)", ret == 0, error);
 
@@ -1003,13 +1003,13 @@ test_client_data_failure(const struct lda_settings *client_set)
 
 static void test_data_failure(void)
 {
-       struct lda_settings smtp_client_set;
+       struct lda_settings smtp_submit_set;
 
-       test_client_defaults(&smtp_client_set);
+       test_client_defaults(&smtp_submit_set);
 
        test_begin("data failure");
        test_expect_errors(0);
-       test_run_client_server(&smtp_client_set,
+       test_run_client_server(&smtp_submit_set,
                test_client_data_failure,
                test_server_data_failure, 1);
        test_end();
@@ -1105,12 +1105,12 @@ static void test_server_data_disconnect(unsigned int index)
 /* client */
 
 static bool
-test_client_data_disconnect(const struct lda_settings *client_set)
+test_client_data_disconnect(const struct lda_settings *submit_set)
 {
        const char *error = NULL;
        int ret;
 
-       ret = test_client_smtp_send_simple_port(client_set,
+       ret = test_client_smtp_send_simple_port(submit_set,
                test_message1, bind_ports[0], 5, &error);
        test_out_reason("run (ret < 0)", ret < 0, error);
 
@@ -1121,13 +1121,13 @@ test_client_data_disconnect(const struct lda_settings *client_set)
 
 static void test_data_disconnect(void)
 {
-       struct lda_settings smtp_client_set;
+       struct lda_settings smtp_submit_set;
 
-       test_client_defaults(&smtp_client_set);
+       test_client_defaults(&smtp_submit_set);
 
        test_begin("data disconnect");
        test_expect_errors(0);
-       test_run_client_server(&smtp_client_set,
+       test_run_client_server(&smtp_submit_set,
                test_client_data_disconnect,
                test_server_data_disconnect, 1);
        test_end();
@@ -1224,7 +1224,7 @@ static void test_server_data_timout(unsigned int index)
 /* client */
 
 static bool
-test_client_data_timout(const struct lda_settings *client_set)
+test_client_data_timout(const struct lda_settings *submit_set)
 {
        time_t time;
        const char *error = NULL;
@@ -1232,7 +1232,7 @@ test_client_data_timout(const struct lda_settings *client_set)
 
        io_loop_time_refresh();
        time = ioloop_time;
-       ret = test_client_smtp_send_simple_port(client_set,
+       ret = test_client_smtp_send_simple_port(submit_set,
                test_message1, bind_ports[0], 2, &error);
        test_out_reason("run (ret < 0)", ret < 0, error);
 
@@ -1246,13 +1246,13 @@ test_client_data_timout(const struct lda_settings *client_set)
 
 static void test_data_timeout(void)
 {
-       struct lda_settings smtp_client_set;
+       struct lda_settings smtp_submit_set;
 
-       test_client_defaults(&smtp_client_set);
+       test_client_defaults(&smtp_submit_set);
 
        test_begin("data timeout");
        test_expect_errors(0);
-       test_run_client_server(&smtp_client_set,
+       test_run_client_server(&smtp_submit_set,
                test_client_data_timout,
                test_server_data_timout, 1);
        test_end();
@@ -1406,13 +1406,13 @@ static void test_server_successful_delivery(unsigned int index)
 /* client */
 
 static bool
-test_client_successful_delivery(const struct lda_settings *client_set)
+test_client_successful_delivery(const struct lda_settings *submit_set)
 {
        const char *error = NULL;
        int ret;
 
        /* send the message */
-       ret = test_client_smtp_send_simple_port(client_set,
+       ret = test_client_smtp_send_simple_port(submit_set,
                test_message1, bind_ports[0], 5, &error);
        test_out_reason("run (ret > 0)", ret > 0, error);
 
@@ -1428,13 +1428,13 @@ test_client_successful_delivery(const struct lda_settings *client_set)
 
 static void test_successful_delivery(void)
 {
-       struct lda_settings smtp_client_set;
+       struct lda_settings smtp_submit_set;
 
-       test_client_defaults(&smtp_client_set);
+       test_client_defaults(&smtp_submit_set);
 
        test_begin("successful delivery");
        test_expect_errors(0);
-       test_run_client_server(&smtp_client_set,
+       test_run_client_server(&smtp_submit_set,
                test_client_successful_delivery,
                test_server_successful_delivery, 1);
        test_end();
@@ -1447,26 +1447,26 @@ static void test_successful_delivery(void)
 /* client */
 
 static bool
-test_client_failed_sendmail(const struct lda_settings *client_set)
+test_client_failed_sendmail(const struct lda_settings *submit_set)
 {
-       struct lda_settings smtp_client_set;
-       struct smtp_client *smtp_client;
+       struct lda_settings smtp_submit_set;
+       struct smtp_submit *smtp_submit;
        struct ostream *output;
        const char *sendmail_path, *error = NULL;
        int ret;
 
        sendmail_path = TEST_BIN_DIR"/sendmail-exit-1.sh";
 
-       smtp_client_set = *client_set;
-       smtp_client_set.sendmail_path = sendmail_path;
+       smtp_submit_set = *submit_set;
+       smtp_submit_set.sendmail_path = sendmail_path;
 
-       smtp_client = smtp_client_init(&smtp_client_set, "sender@example.com");
+       smtp_submit = smtp_submit_init(&smtp_submit_set, "sender@example.com");
 
-       smtp_client_add_rcpt(smtp_client, "rcpt@example.com");
-       output = smtp_client_send(smtp_client);
+       smtp_submit_add_rcpt(smtp_submit, "rcpt@example.com");
+       output = smtp_submit_send(smtp_submit);
        o_stream_send_str(output, test_message1);
 
-       ret = smtp_client_deinit_timeout(smtp_client, 5, &error);
+       ret = smtp_submit_deinit_timeout(smtp_submit, 5, &error);
        test_out_reason("run (ret < 0)", ret < 0, error);
 
        return FALSE;
@@ -1476,13 +1476,13 @@ test_client_failed_sendmail(const struct lda_settings *client_set)
 
 static void test_failed_sendmail(void)
 {
-       struct lda_settings smtp_client_set;
+       struct lda_settings smtp_submit_set;
 
-       test_client_defaults(&smtp_client_set);
+       test_client_defaults(&smtp_submit_set);
 
        test_begin("failed sendmail");
        test_expect_errors(0);
-       test_run_client_server(&smtp_client_set,
+       test_run_client_server(&smtp_submit_set,
                test_client_failed_sendmail, NULL, 0);
        test_end();
 }
@@ -1494,10 +1494,10 @@ static void test_failed_sendmail(void)
 /* client */
 
 static bool
-test_client_successful_sendmail(const struct lda_settings *client_set)
+test_client_successful_sendmail(const struct lda_settings *submit_set)
 {
-       struct lda_settings smtp_client_set;
-       struct smtp_client *smtp_client;
+       struct lda_settings smtp_submit_set;
+       struct smtp_submit *smtp_submit;
        struct ostream *output;
        const char *sendmail_path, *msg_path, *error = NULL;
        int ret;
@@ -1507,16 +1507,16 @@ test_client_successful_sendmail(const struct lda_settings *client_set)
        sendmail_path = t_strdup_printf(
                TEST_BIN_DIR"/sendmail-success.sh %s", msg_path);
 
-       smtp_client_set = *client_set;
-       smtp_client_set.sendmail_path = sendmail_path;
+       smtp_submit_set = *submit_set;
+       smtp_submit_set.sendmail_path = sendmail_path;
 
-       smtp_client = smtp_client_init(&smtp_client_set, "sender@example.com");
+       smtp_submit = smtp_submit_init(&smtp_submit_set, "sender@example.com");
 
-       smtp_client_add_rcpt(smtp_client, "rcpt@example.com");
-       output = smtp_client_send(smtp_client);
+       smtp_submit_add_rcpt(smtp_submit, "rcpt@example.com");
+       output = smtp_submit_send(smtp_submit);
        o_stream_send_str(output, test_message1);
 
-       ret = smtp_client_deinit_timeout(smtp_client, 5, &error);
+       ret = smtp_submit_deinit_timeout(smtp_submit, 5, &error);
        test_out_reason("run (ret > 0)", ret > 0, error);
 
        /* verify delivery */
@@ -1586,22 +1586,22 @@ test_client_smtp_send_simple(const struct lda_settings *smtp_set,
        const char *message, const char *host,
        unsigned int timeout_secs, const char **error_r)
 {
-       struct lda_settings smtp_client_set;
-       struct smtp_client *smtp_client;
+       struct lda_settings smtp_submit_set;
+       struct smtp_submit *smtp_submit;
        struct ostream *output;
 
        /* send the message */
-       smtp_client_set = *smtp_set;
-       smtp_client_set.submission_host = host,
+       smtp_submit_set = *smtp_set;
+       smtp_submit_set.submission_host = host,
 
-       smtp_client = smtp_client_init(&smtp_client_set, "sender@example.com");
+       smtp_submit = smtp_submit_init(&smtp_submit_set, "sender@example.com");
 
-       smtp_client_add_rcpt(smtp_client, "rcpt@example.com");
-       output = smtp_client_send(smtp_client);
+       smtp_submit_add_rcpt(smtp_submit, "rcpt@example.com");
+       output = smtp_submit_send(smtp_submit);
        o_stream_send_str(output, message);
 
-       return smtp_client_deinit_timeout
-               (smtp_client, timeout_secs, error_r);
+       return smtp_submit_deinit_timeout
+               (smtp_submit, timeout_secs, error_r);
 }
 
 static int
@@ -1815,7 +1815,7 @@ test_message_delivery(const char *message, const char *file)
 }
 
 static void test_run_client_server(
-       const struct lda_settings *client_set,
+       const struct lda_settings *submit_set,
        test_client_init_t client_test,
        test_server_init_t server_test,
        unsigned int server_tests_count)
@@ -1887,7 +1887,7 @@ static void test_run_client_server(
        server_port = 0;
 
        ioloop = io_loop_create();
-       if (client_test(client_set))
+       if (client_test(submit_set))
                io_loop_run(ioloop);
        test_client_deinit();
        io_loop_destroy(&ioloop);
@@ -1935,7 +1935,7 @@ int main(int argc, char *argv[])
        (void)signal(SIGSEGV, test_signal_handler);
        (void)signal(SIGABRT, test_signal_handler);
 
-       master_service = master_service_init("test-smtp-client",
+       master_service = master_service_init("test-smtp-submit",
                MASTER_SERVICE_FLAG_STANDALONE, &argc, &argv, "D");
 
        while ((c = master_getopt(master_service)) > 0) {