submission: relay backend: Change almost all occurrences of 'proxy' to 'relay'.

This makes the naming consistent with the name of the backend. Only the lib-smtp
proxy_data is not renamed.

diff --git a/src/submission/submission-backend-relay.c b/src/submission/submission-backend-relay.c
index 4b6419e97631ec9a5eb617c7039b315cb52d1e93..6e3a53798b4079acc1cbb660ba9532f880190034 100644 (file)
--- a/src/submission/submission-backend-relay.c
+++ b/src/submission/submission-backend-relay.c
@@ -16,10 +16,10 @@
  * Common
  */
 
-/* The command handling of the submission proxy service aims to follow the
+/* The command handling of the submission relay service aims to follow the
    following rules:
 
-   - Attempt to keep pipelined commands pipelined when proxying them to the
+   - Attempt to keep pipelined commands pipelined when relaying them to the
      actual relay service.
    - Don't forward commands if they're known to fail at the relay server. Errors
      can still occur if pipelined commands fail. Abort subsequent pending
@@ -86,7 +86,7 @@ struct relay_cmd_helo_context {
        struct smtp_server_cmd_ctx *cmd;
        struct smtp_server_cmd_helo *data;
 
-       struct smtp_client_command *cmd_proxied;
+       struct smtp_client_command *cmd_relayed;
 };
 
 static void
@@ -114,7 +114,7 @@ relay_cmd_helo_reply(struct smtp_server_cmd_ctx *cmd,
 {
        struct submission_backend_relay *backend = helo->backend;
 
-       /* proxy an XCLIENT command */
+       /* relay an XCLIENT command */
        if (helo->data->changed)
                relay_cmd_helo_update_xclient(backend, helo->data);
 
@@ -124,17 +124,17 @@ relay_cmd_helo_reply(struct smtp_server_cmd_ctx *cmd,
 }
 
 static void
-relay_cmd_helo_callback(const struct smtp_reply *proxy_reply,
+relay_cmd_helo_callback(const struct smtp_reply *relay_reply,
                        struct relay_cmd_helo_context *helo)
 {
        struct smtp_server_cmd_ctx *cmd = helo->cmd;
        struct submission_backend_relay *backend = helo->backend;
        struct smtp_reply reply;
 
-       if (!backend_relay_handle_relay_reply(backend, proxy_reply, &reply))
+       if (!backend_relay_handle_relay_reply(backend, relay_reply, &reply))
                return;
 
-       if ((proxy_reply->status / 100) == 2) {
+       if ((relay_reply->status / 100) == 2) {
                relay_cmd_helo_reply(cmd, helo);
        } else {
                /* RFC 2034, Section 4:
@@ -154,7 +154,7 @@ relay_cmd_helo_start(struct smtp_server_cmd_ctx *cmd ATTR_UNUSED,
 {
        struct submission_backend_relay *backend = helo->backend;
 
-       /* proxy an XCLIENT command */
+       /* relay an XCLIENT command */
        if (helo->data->changed)
                relay_cmd_helo_update_xclient(backend, helo->data);
 }
@@ -170,11 +170,11 @@ int cmd_helo_relay(struct client *client, struct smtp_server_cmd_ctx *cmd,
        helo->cmd = cmd;
        helo->data = data;
 
-       /* this is not the first HELO/EHLO; just proxy a RSET command */
+       /* this is not the first HELO/EHLO; just relay a RSET command */
        smtp_server_command_add_hook(
                cmd->cmd, SMTP_SERVER_COMMAND_HOOK_NEXT,
                relay_cmd_helo_start, helo);
-       helo->cmd_proxied = smtp_client_command_rset_submit
+       helo->cmd_relayed = smtp_client_command_rset_submit
                (backend->conn, 0, relay_cmd_helo_callback, helo);
        return 0;
 }
@@ -189,7 +189,7 @@ struct relay_cmd_mail_context {
        struct smtp_server_cmd_ctx *cmd;
        struct smtp_server_cmd_mail *data;
 
-       struct smtp_client_command *cmd_proxied;
+       struct smtp_client_command *cmd_relayed;
 };
 
 static void
@@ -219,30 +219,30 @@ static void
 relay_cmd_mail_replied(struct smtp_server_cmd_ctx *cmd ATTR_UNUSED,
                       struct relay_cmd_mail_context *mail_cmd)
 {
-       if (mail_cmd->cmd_proxied != NULL)
-               smtp_client_command_abort(&mail_cmd->cmd_proxied);
+       if (mail_cmd->cmd_relayed != NULL)
+               smtp_client_command_abort(&mail_cmd->cmd_relayed);
 }
 
 static void
-relay_cmd_mail_callback(const struct smtp_reply *proxy_reply,
+relay_cmd_mail_callback(const struct smtp_reply *relay_reply,
                        struct relay_cmd_mail_context *mail_cmd)
 {
        struct smtp_server_cmd_ctx *cmd = mail_cmd->cmd;
        struct submission_backend_relay *backend = mail_cmd->backend;
        struct smtp_reply reply;
 
-       /* finished proxying MAIL command to relay server */
+       /* finished relaying MAIL command to relay server */
        i_assert(mail_cmd != NULL);
-       mail_cmd->cmd_proxied = NULL;
+       mail_cmd->cmd_relayed = NULL;
 
-       if (!backend_relay_handle_relay_reply(backend, proxy_reply, &reply))
+       if (!backend_relay_handle_relay_reply(backend, relay_reply, &reply))
                return;
 
-       if ((proxy_reply->status / 100) == 2) {
+       if ((relay_reply->status / 100) == 2) {
                /* if relay accepts it, we accept it too */
 
                /* the default 2.0.0 code won't do */
-               if (!smtp_reply_has_enhanced_code(proxy_reply))
+               if (!smtp_reply_has_enhanced_code(relay_reply))
                        reply.enhanced_code = SMTP_REPLY_ENH_CODE(2, 1, 0);
        }
 
@@ -253,7 +253,7 @@ relay_cmd_mail_callback(const struct smtp_reply *proxy_reply,
 static int
 relay_cmd_mail_parameter_auth(struct submission_backend_relay *backend,
                              struct smtp_server_cmd_ctx *cmd,
-                             enum smtp_capability proxy_caps,
+                             enum smtp_capability relay_caps,
                              struct smtp_server_cmd_mail *data)
 {
        struct client *client = backend->backend.client;
@@ -261,7 +261,7 @@ relay_cmd_mail_parameter_auth(struct submission_backend_relay *backend,
        struct smtp_address *auth_addr;
        const char *error;
 
-       if ((proxy_caps & SMTP_CAPABILITY_AUTH) == 0)
+       if ((relay_caps & SMTP_CAPABILITY_AUTH) == 0)
                return 0;
 
        auth_addr = NULL;
@@ -279,7 +279,7 @@ relay_cmd_mail_parameter_auth(struct submission_backend_relay *backend,
 static int
 relay_cmd_mail_parameter_size(struct submission_backend_relay *backend,
                              struct smtp_server_cmd_ctx *cmd,
-                             enum smtp_capability proxy_caps,
+                             enum smtp_capability relay_caps,
                              struct smtp_server_cmd_mail *data)
 {
        struct client *client = backend->backend.client;
@@ -287,7 +287,7 @@ relay_cmd_mail_parameter_size(struct submission_backend_relay *backend,
 
        /* SIZE=<size-value>: RFC 1870 */
 
-       if (data->params.size == 0 || (proxy_caps & SMTP_CAPABILITY_SIZE) == 0)
+       if (data->params.size == 0 || (relay_caps & SMTP_CAPABILITY_SIZE) == 0)
                return 0;
 
        /* determine actual size limit (account for our additions) */
@@ -298,7 +298,7 @@ relay_cmd_mail_parameter_size(struct submission_backend_relay *backend,
                return -1;
        }
 
-       /* proxy the SIZE parameter (account for additional size) */
+       /* relay the SIZE parameter (account for additional size) */
        data->params.size += SUBMISSION_MAX_ADDITIONAL_MAIL_SIZE;
        return 0;
 }
@@ -308,13 +308,13 @@ int cmd_mail_relay(struct client *client, struct smtp_server_cmd_ctx *cmd,
 {
        struct submission_backend_relay *backend = &client->backend;
        struct relay_cmd_mail_context *mail_cmd;
-       enum smtp_capability proxy_caps =
+       enum smtp_capability relay_caps =
                smtp_client_connection_get_capabilities(backend->conn);
 
        /* check and adjust parameters where necessary */
-       if (relay_cmd_mail_parameter_auth(backend, cmd, proxy_caps, data) < 0)
+       if (relay_cmd_mail_parameter_auth(backend, cmd, relay_caps, data) < 0)
                return -1;
-       if (relay_cmd_mail_parameter_size(backend, cmd, proxy_caps, data) < 0)
+       if (relay_cmd_mail_parameter_size(backend, cmd, relay_caps, data) < 0)
                return -1;
 
        relay_cmd_mail_update_xclient(backend);
@@ -328,7 +328,7 @@ int cmd_mail_relay(struct client *client, struct smtp_server_cmd_ctx *cmd,
        smtp_server_command_add_hook(cmd->cmd, SMTP_SERVER_COMMAND_HOOK_REPLIED,
                                     relay_cmd_mail_replied, mail_cmd);
 
-       mail_cmd->cmd_proxied = smtp_client_command_mail_submit(
+       mail_cmd->cmd_relayed = smtp_client_command_mail_submit(
                backend->conn, 0, data->path, &data->params,
                relay_cmd_mail_callback, mail_cmd);
        return 0;
@@ -344,35 +344,35 @@ struct relay_cmd_rcpt_context {
        struct smtp_server_cmd_ctx *cmd;
        struct smtp_server_cmd_rcpt *data;
 
-       struct smtp_client_command *cmd_proxied;
+       struct smtp_client_command *cmd_relayed;
 };
 
 static void
 relay_cmd_rcpt_replied(struct smtp_server_cmd_ctx *cmd ATTR_UNUSED,
                       struct relay_cmd_rcpt_context *rcpt_cmd)
 {
-       if (rcpt_cmd->cmd_proxied != NULL)
-               smtp_client_command_abort(&rcpt_cmd->cmd_proxied);
+       if (rcpt_cmd->cmd_relayed != NULL)
+               smtp_client_command_abort(&rcpt_cmd->cmd_relayed);
 }
 
 static void
-relay_cmd_rcpt_callback(const struct smtp_reply *proxy_reply,
+relay_cmd_rcpt_callback(const struct smtp_reply *relay_reply,
                        struct relay_cmd_rcpt_context *rcpt_cmd)
 {
        struct smtp_server_cmd_ctx *cmd = rcpt_cmd->cmd;
        struct submission_backend_relay *backend = rcpt_cmd->backend;
        struct smtp_reply reply;
 
-       /* finished proxying MAIL command to relay server */
+       /* finished relaying MAIL command to relay server */
        i_assert(rcpt_cmd != NULL);
-       rcpt_cmd->cmd_proxied = NULL;
+       rcpt_cmd->cmd_relayed = NULL;
 
-       if (!backend_relay_handle_relay_reply(backend, proxy_reply, &reply))
+       if (!backend_relay_handle_relay_reply(backend, relay_reply, &reply))
                return;
 
-       if ((proxy_reply->status / 100) == 2) {
+       if ((relay_reply->status / 100) == 2) {
                /* the default 2.0.0 code won't do */
-               if (!smtp_reply_has_enhanced_code(proxy_reply))
+               if (!smtp_reply_has_enhanced_code(relay_reply))
                        reply.enhanced_code = SMTP_REPLY_ENH_CODE(2, 1, 5);
        }
 
@@ -395,7 +395,7 @@ int cmd_rcpt_relay(struct client *client, struct smtp_server_cmd_ctx *cmd,
        smtp_server_command_add_hook(cmd->cmd, SMTP_SERVER_COMMAND_HOOK_REPLIED,
                                     relay_cmd_rcpt_replied, rcpt_cmd);
 
-       rcpt_cmd->cmd_proxied = smtp_client_command_rcpt_submit(
+       rcpt_cmd->cmd_relayed = smtp_client_command_rcpt_submit(
                backend->conn, 0, data->path, &data->params,
                relay_cmd_rcpt_callback, rcpt_cmd);
        return 0;
@@ -410,22 +410,22 @@ struct relay_cmd_rset_context {
 
        struct smtp_server_cmd_ctx *cmd;
 
-       struct smtp_client_command *cmd_proxied;
+       struct smtp_client_command *cmd_relayed;
 };
 
 static void
-relay_cmd_rset_callback(const struct smtp_reply *proxy_reply,
+relay_cmd_rset_callback(const struct smtp_reply *relay_reply,
                        struct relay_cmd_rset_context *rset_cmd)
 {
        struct smtp_server_cmd_ctx *cmd = rset_cmd->cmd;
        struct submission_backend_relay *backend = rset_cmd->backend;
        struct smtp_reply reply;
 
-       /* finished proxying MAIL command to relay server */
+       /* finished relaying MAIL command to relay server */
        i_assert(rset_cmd != NULL);
-       rset_cmd->cmd_proxied = NULL;
+       rset_cmd->cmd_relayed = NULL;
 
-       if (!backend_relay_handle_relay_reply(backend, proxy_reply, &reply))
+       if (!backend_relay_handle_relay_reply(backend, relay_reply, &reply))
                return;
 
        /* forward reply */
@@ -441,7 +441,7 @@ int cmd_rset_relay(struct client *client, struct smtp_server_cmd_ctx *cmd)
        rset_cmd->backend = backend;
        rset_cmd->cmd = cmd;
 
-       rset_cmd->cmd_proxied = smtp_client_command_rset_submit(
+       rset_cmd->cmd_relayed = smtp_client_command_rset_submit(
                backend->conn, 0, relay_cmd_rset_callback, rset_cmd);
        return 0;
 }
@@ -456,11 +456,11 @@ struct relay_cmd_data_context {
        struct smtp_server_cmd_ctx *cmd;
        struct smtp_server_transaction *trans;
 
-       struct smtp_client_command *cmd_proxied;
+       struct smtp_client_command *cmd_relayed;
 };
 
 static void
-relay_cmd_data_callback(const struct smtp_reply *proxy_reply,
+relay_cmd_data_callback(const struct smtp_reply *relay_reply,
                        struct relay_cmd_data_context *data_ctx)
 {
        struct smtp_server_cmd_ctx *cmd = data_ctx->cmd;
@@ -469,27 +469,27 @@ relay_cmd_data_callback(const struct smtp_reply *proxy_reply,
        struct client *client = backend->backend.client;
        struct smtp_reply reply;
 
-       /* finished proxying message to relay server */
+       /* finished relaying message to relay server */
 
        /* check for fatal problems */
-       if (!backend_relay_handle_relay_reply(backend, proxy_reply, &reply))
+       if (!backend_relay_handle_relay_reply(backend, relay_reply, &reply))
                return;
 
-       if (proxy_reply->status / 100 == 2) {
+       if (relay_reply->status / 100 == 2) {
                i_info("Successfully relayed message: "
                       "from=<%s>, size=%"PRIuUOFF_T", "
                       "id=%s, nrcpt=%u, reply=`%s'",
                       smtp_address_encode(trans->mail_from),
                       client->state.data_size, trans->id,
                       array_count(&trans->rcpt_to),
-                      str_sanitize(smtp_reply_log(proxy_reply), 128));
+                      str_sanitize(smtp_reply_log(relay_reply), 128));
 
        } else {
                i_info("Failed to relay message: "
                       "from=<%s>, size=%"PRIuUOFF_T", nrcpt=%u, reply=`%s'",
                       smtp_address_encode(trans->mail_from),
                       client->state.data_size, array_count(&trans->rcpt_to),
-                      str_sanitize(smtp_reply_log(proxy_reply), 128));
+                      str_sanitize(smtp_reply_log(relay_reply), 128));
        }
 
        smtp_server_reply_forward(cmd, &reply);
@@ -509,7 +509,7 @@ int cmd_data_relay(struct client *client, struct smtp_server_cmd_ctx *cmd,
        data_ctx->trans = trans;
        trans->context = (void*)data_ctx;
 
-       data_ctx->cmd_proxied = smtp_client_command_data_submit(
+       data_ctx->cmd_relayed = smtp_client_command_data_submit(
                backend->conn, 0, data_input, relay_cmd_data_callback,
                data_ctx);
        return 0;
@@ -523,22 +523,22 @@ struct relay_cmd_vrfy_context {
        struct submission_backend_relay *backend;
 
        struct smtp_server_cmd_ctx *cmd;
-       struct smtp_client_command *cmd_proxied;
+       struct smtp_client_command *cmd_relayed;
 };
 
 static void
-relay_cmd_vrfy_callback(const struct smtp_reply *proxy_reply,
+relay_cmd_vrfy_callback(const struct smtp_reply *relay_reply,
                        struct relay_cmd_vrfy_context *vrfy_cmd)
 {
        struct smtp_server_cmd_ctx *cmd = vrfy_cmd->cmd;
        struct submission_backend_relay *backend = vrfy_cmd->backend;
        struct smtp_reply reply;
 
-       if (!backend_relay_handle_relay_reply(backend, proxy_reply, &reply))
+       if (!backend_relay_handle_relay_reply(backend, relay_reply, &reply))
                return;
 
-       if (!smtp_reply_has_enhanced_code(proxy_reply)) {
-               switch (proxy_reply->status) {
+       if (!smtp_reply_has_enhanced_code(relay_reply)) {
+               switch (relay_reply->status) {
                case 250:
                case 251:
                case 252:
@@ -562,7 +562,7 @@ int cmd_vrfy_relay(struct client *client, struct smtp_server_cmd_ctx *cmd,
        vrfy_cmd->backend = backend;
        vrfy_cmd->cmd = cmd;
 
-       vrfy_cmd->cmd_proxied = smtp_client_command_vrfy_submit(
+       vrfy_cmd->cmd_relayed = smtp_client_command_vrfy_submit(
                backend->conn, 0, param, relay_cmd_vrfy_callback, vrfy_cmd);
        return 0;
 }
@@ -575,21 +575,21 @@ struct relay_cmd_noop_context {
        struct submission_backend_relay *backend;
 
        struct smtp_server_cmd_ctx *cmd;
-       struct smtp_client_command *cmd_proxied;
+       struct smtp_client_command *cmd_relayed;
 };
 
 static void
-relay_cmd_noop_callback(const struct smtp_reply *proxy_reply,
+relay_cmd_noop_callback(const struct smtp_reply *relay_reply,
                        struct relay_cmd_noop_context *noop_cmd)
 {
        struct smtp_server_cmd_ctx *cmd = noop_cmd->cmd;
        struct submission_backend_relay *backend = noop_cmd->backend;
        struct smtp_reply reply;
 
-       if (!backend_relay_handle_relay_reply(backend, proxy_reply, &reply))
+       if (!backend_relay_handle_relay_reply(backend, relay_reply, &reply))
                return;
 
-       if ((proxy_reply->status / 100) == 2) {
+       if ((relay_reply->status / 100) == 2) {
                smtp_server_reply(cmd, 250, "2.0.0", "OK");
        } else {
                smtp_server_reply_forward(cmd, &reply);
@@ -605,7 +605,7 @@ int cmd_noop_relay(struct client *client, struct smtp_server_cmd_ctx *cmd)
        noop_cmd->backend = backend;
        noop_cmd->cmd = cmd;
 
-       noop_cmd->cmd_proxied = smtp_client_command_noop_submit(
+       noop_cmd->cmd_relayed = smtp_client_command_noop_submit(
                backend->conn, 0, relay_cmd_noop_callback, noop_cmd);
        return 0;
 }
@@ -618,53 +618,53 @@ struct relay_cmd_quit_context {
        struct submission_backend_relay *backend;
 
        struct smtp_server_cmd_ctx *cmd;
-       struct smtp_client_command *cmd_proxied;
+       struct smtp_client_command *cmd_relayed;
 };
 
 static void
 relay_cmd_quit_destroy(struct smtp_server_cmd_ctx *cmd ATTR_UNUSED,
                       struct relay_cmd_quit_context *quit_cmd)
 {
-       if (quit_cmd->cmd_proxied != NULL)
-               smtp_client_command_abort(&quit_cmd->cmd_proxied);
+       if (quit_cmd->cmd_relayed != NULL)
+               smtp_client_command_abort(&quit_cmd->cmd_relayed);
 }
 
 static void
 relay_cmd_quit_replied(struct smtp_server_cmd_ctx *cmd ATTR_UNUSED,
                       struct relay_cmd_quit_context *quit_cmd)
 {
-       if (quit_cmd->cmd_proxied != NULL)
-               smtp_client_command_abort(&quit_cmd->cmd_proxied);
+       if (quit_cmd->cmd_relayed != NULL)
+               smtp_client_command_abort(&quit_cmd->cmd_relayed);
 }
 
 static void relay_cmd_quit_finish(struct relay_cmd_quit_context *quit_cmd)
 {
        struct smtp_server_cmd_ctx *cmd = quit_cmd->cmd;
 
-       if (quit_cmd->cmd_proxied != NULL)
-               smtp_client_command_abort(&quit_cmd->cmd_proxied);
+       if (quit_cmd->cmd_relayed != NULL)
+               smtp_client_command_abort(&quit_cmd->cmd_relayed);
        smtp_server_reply_quit(cmd);
 }
 
 static void
-relay_cmd_quit_callback(const struct smtp_reply *proxy_reply ATTR_UNUSED,
+relay_cmd_quit_callback(const struct smtp_reply *relay_reply ATTR_UNUSED,
                        struct relay_cmd_quit_context *quit_cmd)
 {
-       quit_cmd->cmd_proxied = NULL;
+       quit_cmd->cmd_relayed = NULL;
        relay_cmd_quit_finish(quit_cmd);
 }
 
-static void relay_cmd_quit_proxy(struct relay_cmd_quit_context *quit_cmd)
+static void relay_cmd_quit_relay(struct relay_cmd_quit_context *quit_cmd)
 {
        struct submission_backend_relay *backend = quit_cmd->backend;
        struct smtp_server_cmd_ctx *cmd = quit_cmd->cmd;
 
-       if (quit_cmd->cmd_proxied != NULL)
+       if (quit_cmd->cmd_relayed != NULL)
                return;
 
        if (smtp_client_connection_get_state(backend->conn)
                < SMTP_CLIENT_CONNECTION_STATE_READY) {
-               /* Don't bother proxying QUIT command when proxy is not
+               /* Don't bother relaying QUIT command when relay is not
                   fully initialized. */
                smtp_server_reply_quit(cmd);
                return;
@@ -676,11 +676,11 @@ static void relay_cmd_quit_proxy(struct relay_cmd_quit_context *quit_cmd)
           until it sends a QUIT command, and it SHOULD wait until it receives
           the reply (even if there was an error response to a previous
           command). */
-       quit_cmd->cmd_proxied =
+       quit_cmd->cmd_relayed =
                smtp_client_command_new(backend->conn, 0,
                                        relay_cmd_quit_callback, quit_cmd);
-       smtp_client_command_write(quit_cmd->cmd_proxied, "QUIT");
-       smtp_client_command_submit(quit_cmd->cmd_proxied);
+       smtp_client_command_write(quit_cmd->cmd_relayed, "QUIT");
+       smtp_client_command_submit(quit_cmd->cmd_relayed);
 }
 
 static void
@@ -688,7 +688,7 @@ relay_cmd_quit_next(struct smtp_server_cmd_ctx *cmd ATTR_UNUSED,
                    struct relay_cmd_quit_context *quit_cmd)
 {
        /* QUIT command is next to reply */
-       relay_cmd_quit_proxy(quit_cmd);
+       relay_cmd_quit_relay(quit_cmd);
 }
 
 int cmd_quit_relay(struct client *client, struct smtp_server_cmd_ctx *cmd)
@@ -709,7 +709,7 @@ int cmd_quit_relay(struct client *client, struct smtp_server_cmd_ctx *cmd)
 
        if (smtp_client_connection_get_state(backend->conn)
                >= SMTP_CLIENT_CONNECTION_STATE_READY)
-               relay_cmd_quit_proxy(quit_cmd);
+               relay_cmd_quit_relay(quit_cmd);
        return 0;
 }
 
@@ -736,7 +736,7 @@ void client_proxy_create(struct client *client,
        else
                ssl_set.allow_invalid_cert = TRUE;
 
-       /* make proxy connection */
+       /* make relay connection */
        i_zero(&smtp_set);
        smtp_set.my_hostname = set->hostname;
        smtp_set.ssl = &ssl_set;
@@ -792,7 +792,7 @@ static void client_proxy_ready_cb(const struct smtp_reply *reply,
        struct submission_backend_relay *backend = &client->backend;
        enum smtp_capability caps;
 
-       /* check proxy status */
+       /* check relay status */
        if ((reply->status / 100) != 2) {
                i_error("Failed to establish relay connection: %s",
                        smtp_reply_log(reply));