imap,lib-storage: Rename error_r sent to clients as client_error_r

diff --git a/src/imap/cmd-append.c b/src/imap/cmd-append.c
index 6365ca848695447270c7c048ad01d36b56e403b3..f04d49946bcb7b2fbf7855f42a4313ea271bebb9 100644 (file)
--- a/src/imap/cmd-append.c
+++ b/src/imap/cmd-append.c
@@ -170,11 +170,11 @@ cmd_append_catenate_mpurl(struct client_command_context *cmd,
        struct cmd_append_context *ctx = cmd->context;
        struct imap_msgpart_open_result mpresult;
        uoff_t newsize;
-       const char *error;
+       const char *client_error;
        int ret;
 
        /* catenate URL */
-       ret = imap_msgpart_url_read_part(mpurl, &mpresult, &error);
+       ret = imap_msgpart_url_read_part(mpurl, &mpresult, &client_error);
        if (ret < 0) {
                client_send_box_error(cmd, ctx->box);
                return -1;
@@ -182,7 +182,8 @@ cmd_append_catenate_mpurl(struct client_command_context *cmd,
        if (ret == 0) {
                /* invalid url, abort */
                client_send_tagline(cmd,
-                       t_strdup_printf("NO [BADURL %s] %s.", caturl, error));
+                       t_strdup_printf("NO [BADURL %s] %s.",
+                                       caturl, client_error));
                return -1;
        }
        if (mpresult.size == 0) {
@@ -231,14 +232,14 @@ cmd_append_catenate_url(struct client_command_context *cmd, const char *caturl)
 {
        struct cmd_append_context *ctx = cmd->context;
        struct imap_msgpart_url *mpurl;
-       const char *error;
+       const char *client_error;
        int ret;
 
        if (ctx->failed)
                return -1;
 
        ret = imap_msgpart_url_parse(cmd->client->user, cmd->client->mailbox,
-                                    caturl, &mpurl, &error);
+                                    caturl, &mpurl, &client_error);
        if (ret < 0) {
                client_send_box_error(cmd, ctx->box);
                return -1;
@@ -246,7 +247,8 @@ cmd_append_catenate_url(struct client_command_context *cmd, const char *caturl)
        if (ret == 0) {
                /* invalid url, abort */
                client_send_tagline(cmd,
-                       t_strdup_printf("NO [BADURL %s] %s.", caturl, error));
+                       t_strdup_printf("NO [BADURL %s] %s.",
+                                       caturl, client_error));
                return -1;
        }
        ret = cmd_append_catenate_mpurl(cmd, caturl, mpurl);
@@ -385,7 +387,7 @@ static bool cmd_append_continue_catenate(struct client_command_context *cmd)
        struct client *client = cmd->client;
        struct cmd_append_context *ctx = cmd->context;
        const struct imap_arg *args;
-       const char *msg;
+       const char *client_error;
        enum imap_parser_error parse_error;
        bool nonsync = FALSE;
        int ret;
@@ -407,19 +409,20 @@ static bool cmd_append_continue_catenate(struct client_command_context *cmd)
                                            IMAP_PARSE_FLAG_INSIDE_LIST, &args);
        } while (ret > 0 && !catenate_args_can_stop(ctx, args));
        if (ret == -1) {
-               msg = imap_parser_get_error(ctx->save_parser, &parse_error);
+               client_error = imap_parser_get_error(ctx->save_parser,
+                                                    &parse_error);
                switch (parse_error) {
                case IMAP_PARSE_ERROR_NONE:
                        i_unreached();
                case IMAP_PARSE_ERROR_LITERAL_TOO_BIG:
                        client_send_line(client, t_strconcat("* BYE ",
                                (client->set->imap_literal_minus ? "[TOOBIG] " : ""),
-                               msg, NULL));
-                       client_disconnect(client, msg);
+                               client_error, NULL));
+                       client_disconnect(client, client_error);
                        break;
                default:
                        if (!ctx->failed)
-                               client_send_command_error(cmd, msg);
+                               client_send_command_error(cmd, client_error);
                }
                client->input_skip_line = TRUE;
                cmd_append_finish(ctx);
@@ -719,7 +722,7 @@ static bool cmd_append_parse_new_msg(struct client_command_context *cmd)
        struct client *client = cmd->client;
        struct cmd_append_context *ctx = cmd->context;
        const struct imap_arg *args;
-       const char *msg;
+       const char *client_error;
        enum imap_parser_error parse_error;
        unsigned int arg_min_count;
        bool nonsync, last_literal;
@@ -755,18 +758,18 @@ static bool cmd_append_parse_new_msg(struct client_command_context *cmd)
                 !cmd_append_args_can_stop(ctx, args, &last_literal));
        if (ret == -1) {
                if (!ctx->failed) {
-                       msg = imap_parser_get_error(ctx->save_parser, &parse_error);
+                       client_error = imap_parser_get_error(ctx->save_parser, &parse_error);
                        switch (parse_error) {
                        case IMAP_PARSE_ERROR_NONE:
                                i_unreached();
                        case IMAP_PARSE_ERROR_LITERAL_TOO_BIG:
                                client_send_line(client, t_strconcat("* BYE ",
                                        (client->set->imap_literal_minus ? "[TOOBIG] " : ""),
-                                       msg, NULL));
-                               client_disconnect(client, msg);
+                                       client_error, NULL));
+                               client_disconnect(client, client_error);
                                break;
                        default:
-                               client_send_command_error(cmd, msg);
+                               client_send_command_error(cmd, client_error);
                        }
                }
                cmd_append_finish(ctx);

diff --git a/src/imap/cmd-delete.c b/src/imap/cmd-delete.c
index 5296f5e6c6734501b2c446b6f8a5dbe9aa86be9a..929b1fe3f445f12d61d8aac250ffbc81f0459812 100644 (file)
--- a/src/imap/cmd-delete.c
+++ b/src/imap/cmd-delete.c
@@ -8,7 +8,7 @@ bool cmd_delete(struct client_command_context *cmd)
        struct client *client = cmd->client;
        struct mail_namespace *ns;
        struct mailbox *box;
-       const char *name, *errstr;
+       const char *name, *client_error;
        enum mail_error error;
        bool disconnect = FALSE;
 
@@ -40,12 +40,13 @@ bool cmd_delete(struct client_command_context *cmd)
        if (mailbox_delete(box) == 0)
                client_send_tagline(cmd, "OK Delete completed.");
        else {
-               errstr = mailbox_get_last_error(box, &error);
+               client_error = mailbox_get_last_error(box, &error);
                if (error != MAIL_ERROR_EXISTS)
                        client_send_box_error(cmd, box);
                else {
                        /* mailbox has children */
-                       client_send_tagline(cmd, t_strdup_printf("NO %s", errstr));
+                       client_send_tagline(cmd, t_strdup_printf("NO %s",
+                                                                client_error));
                }
        }
        mailbox_free(&box);

diff --git a/src/imap/cmd-fetch.c b/src/imap/cmd-fetch.c
index bde2e4689d81f70888e386475f3d6ba49abf3fc0..1e4bd2a01ff3d5f9583122cabb822a833a1b7acc 100644 (file)
--- a/src/imap/cmd-fetch.c
+++ b/src/imap/cmd-fetch.c
@@ -212,7 +212,7 @@ static bool cmd_fetch_finish(struct imap_fetch_context *ctx,
        }
 
        if (imap_fetch_end(ctx) < 0) {
-               const char *errstr;
+               const char *client_error;
 
                if (cmd->client->output->closed) {
                        /* If we're canceling we need to finish this command
@@ -228,19 +228,19 @@ static bool cmd_fetch_finish(struct imap_fetch_context *ctx,
                }
 
                if (ctx->error == MAIL_ERROR_NONE)
-                       errstr = mailbox_get_last_error(cmd->client->mailbox, &error);
+                       client_error = mailbox_get_last_error(cmd->client->mailbox, &error);
                else {
-                       errstr = ctx->errstr;
+                       client_error = ctx->errstr;
                        error = ctx->error;
                }
                if (error == MAIL_ERROR_CONVERSION) {
                        /* BINARY found unsupported Content-Transfer-Encoding */
                        tagged_reply = t_strdup_printf(
-                               "NO ["IMAP_RESP_CODE_UNKNOWN_CTE"] %s", errstr);
+                               "NO ["IMAP_RESP_CODE_UNKNOWN_CTE"] %s", client_error);
                } else if (error == MAIL_ERROR_INVALIDDATA) {
                        /* Content was invalid */
                        tagged_reply = t_strdup_printf(
-                               "NO ["IMAP_RESP_CODE_PARSE"] %s", errstr);
+                               "NO ["IMAP_RESP_CODE_PARSE"] %s", client_error);
                } else if (cmd->client->set->parsed_fetch_failure != IMAP_CLIENT_FETCH_FAILURE_NO_AFTER ||
                           imap_fetch_is_failed_retry(ctx)) {
                        /* By default we never want to reply NO to FETCH
@@ -248,7 +248,7 @@ static bool cmd_fetch_finish(struct imap_fetch_context *ctx,
                           about what they should on NO. A disconnection causes
                           less confusion. */
                        client_disconnect_with_error(cmd->client,
-                               t_strconcat("FETCH failed: ", errstr, NULL));
+                               t_strconcat("FETCH failed: ", client_error, NULL));
                        imap_fetch_free(&ctx);
                        return TRUE;
                } else {
@@ -257,7 +257,7 @@ static bool cmd_fetch_finish(struct imap_fetch_context *ctx,
                           we avoid infinitely retries from client.) */
                        imap_fetch_add_failed_uids(ctx);
                        tagged_reply = t_strdup_printf(
-                               "NO ["IMAP_RESP_CODE_SERVERBUG"] %s", errstr);
+                               "NO ["IMAP_RESP_CODE_SERVERBUG"] %s", client_error);
                }
        }
        imap_fetch_free(&ctx);

diff --git a/src/imap/cmd-genurlauth.c b/src/imap/cmd-genurlauth.c
index 790037df5209f41c3cd60a859d86e90447caea0e..2cdbdd134094af6629c579263992a3e0f343f134 100644 (file)
--- a/src/imap/cmd-genurlauth.c
+++ b/src/imap/cmd-genurlauth.c
@@ -23,7 +23,7 @@ bool cmd_genurlauth(struct client_command_context *cmd)
        response = t_str_new(1024);
        str_append(response, "* GENURLAUTH");
        for (;;) {
-               const char *url_rump, *mechanism, *url, *error;
+               const char *url_rump, *mechanism, *url, *client_error;
 
                if (IMAP_ARG_IS_EOL(args))
                        break;
@@ -34,12 +34,13 @@ bool cmd_genurlauth(struct client_command_context *cmd)
                }
 
                ret = imap_urlauth_generate(cmd->client->urlauth_ctx,
-                                           mechanism, url_rump, &url, &error);
+                                           mechanism, url_rump, &url,
+                                           &client_error);
                if (ret <= 0) {
                        if (ret < 0)
                                client_send_internal_error(cmd);
                        else
-                               client_send_command_error(cmd, error);
+                               client_send_command_error(cmd, client_error);
                        return TRUE;
                }
 

diff --git a/src/imap/cmd-getmetadata.c b/src/imap/cmd-getmetadata.c
index d2dfca27f81bd40175d46fc3646837c9f9c62e2a..7e9ea0f0e83a7d58ca30031ace19f93e6c8268c3 100644 (file)
--- a/src/imap/cmd-getmetadata.c
+++ b/src/imap/cmd-getmetadata.c
@@ -83,7 +83,7 @@ static bool
 imap_metadata_parse_entry_names(struct imap_getmetadata_context *ctx,
                                const struct imap_arg *entries)
 {
-       const char *value, *error;
+       const char *value, *client_error;
 
        p_array_init(&ctx->entries, ctx->cmd->pool, 4);
        for (; !IMAP_ARG_IS_EOL(entries); entries++) {
@@ -91,8 +91,8 @@ imap_metadata_parse_entry_names(struct imap_getmetadata_context *ctx,
                        client_send_command_error(ctx->cmd, "Entry isn't astring");
                        return FALSE;
                }
-               if (!imap_metadata_verify_entry_name(value, &error)) {
-                       client_send_command_error(ctx->cmd, error);
+               if (!imap_metadata_verify_entry_name(value, &client_error)) {
+                       client_send_command_error(ctx->cmd, client_error);
                        return FALSE;
                }
 

diff --git a/src/imap/cmd-notify.c b/src/imap/cmd-notify.c
index 7fb2417de8ebcbbd0809398e52a33e7fe4e65d7b..d8d998ae564ba609556bbfb3b25355162b1c68f3 100644 (file)
--- a/src/imap/cmd-notify.c
+++ b/src/imap/cmd-notify.c
@@ -542,19 +542,19 @@ bool cmd_notify(struct client_command_context *cmd)
        }
 
        if ((ctx->global_used_events & UNSUPPORTED_EVENTS) != 0) {
-               string_t *str = t_str_new(128);
+               string_t *client_error = t_str_new(128);
                unsigned int i;
 
-               str_append(str, "NO [BADEVENT");
+               str_append(client_error, "NO [BADEVENT");
                for (i = 0; i < N_ELEMENTS(imap_notify_event_names); i++) {
                        if ((ctx->global_used_events & (1 << i)) != 0 &&
                            ((1 << i) & UNSUPPORTED_EVENTS) != 0) {
-                               str_append_c(str, ' ');
-                               str_append(str, imap_notify_event_names[i]);
+                               str_append_c(client_error, ' ');
+                               str_append(client_error, imap_notify_event_names[i]);
                        }
                }
-               str_append(str, "] Unsupported NOTIFY events.");
-               client_send_tagline(cmd, str_c(str));
+               str_append(client_error, "] Unsupported NOTIFY events.");
+               client_send_tagline(cmd, str_c(client_error));
                pool_unref(&pool);
                return TRUE;
        }

diff --git a/src/imap/cmd-select.c b/src/imap/cmd-select.c
index f17e7177305b9c773ad143f8e94f36bd300481c2..1c7153ce753d1eef6c33a0b5590b47cfb6bbf069 100644 (file)
--- a/src/imap/cmd-select.c
+++ b/src/imap/cmd-select.c
@@ -368,7 +368,7 @@ bool cmd_select_full(struct client_command_context *cmd, bool readonly)
        struct client *client = cmd->client;
        struct imap_select_context *ctx;
        const struct imap_arg *args, *list_args;
-       const char *mailbox, *error;
+       const char *mailbox, *client_error;
        int ret;
 
        /* <mailbox> [(optional parameters)] */
@@ -383,20 +383,20 @@ bool cmd_select_full(struct client_command_context *cmd, bool readonly)
 
        ctx = p_new(cmd->pool, struct imap_select_context, 1);
        ctx->cmd = cmd;
-       ctx->ns = client_find_namespace_full(cmd->client, &mailbox, &error);
+       ctx->ns = client_find_namespace_full(cmd->client, &mailbox, &client_error);
        if (ctx->ns == NULL) {
                /* send * OK [CLOSED] before the tagged reply */
                close_selected_mailbox(client);
-               client_send_tagline(cmd, error);
+               client_send_tagline(cmd, client_error);
                return TRUE;
        }
 
        if (imap_arg_get_list(&args[1], &list_args)) {
-               if (!select_parse_options(ctx, list_args, &error)) {
+               if (!select_parse_options(ctx, list_args, &client_error)) {
                        select_context_free(ctx);
                        /* send * OK [CLOSED] before the tagged reply */
                        close_selected_mailbox(client);
-                       client_send_command_error(ctx->cmd, error);
+                       client_send_command_error(ctx->cmd, client_error);
                        return TRUE;
                }
        }

diff --git a/src/imap/cmd-setmetadata.c b/src/imap/cmd-setmetadata.c
index 072dfc20f281d3e5a56214836cd82a18e3fba123..8516e369d6a3b059496cba4d7463b51b03b68d8b 100644 (file)
--- a/src/imap/cmd-setmetadata.c
+++ b/src/imap/cmd-setmetadata.c
@@ -45,7 +45,7 @@ cmd_setmetadata_parse_entryvalue(struct imap_setmetadata_context *ctx,
                                 const struct imap_arg **value_r)
 {
        const struct imap_arg *args;
-       const char *name, *error;
+       const char *name, *client_error;
        enum imap_parser_error parse_error;
        int ret;
 
@@ -72,15 +72,16 @@ cmd_setmetadata_parse_entryvalue(struct imap_setmetadata_context *ctx,
        if (ret < 0) {
                if (ret == -2)
                        return 0;
-               error = imap_parser_get_error(ctx->parser, &parse_error);
+               client_error = imap_parser_get_error(ctx->parser, &parse_error);
                switch (parse_error) {
                case IMAP_PARSE_ERROR_NONE:
                        i_unreached();
                case IMAP_PARSE_ERROR_LITERAL_TOO_BIG:
-                       client_disconnect_with_error(ctx->cmd->client, error);
+                       client_disconnect_with_error(ctx->cmd->client,
+                                                    client_error);
                        break;
                default:
-                       client_send_command_error(ctx->cmd, error);
+                       client_send_command_error(ctx->cmd, client_error);
                        break;
                }
                return -1;
@@ -94,8 +95,8 @@ cmd_setmetadata_parse_entryvalue(struct imap_setmetadata_context *ctx,
                return -1;
        }
        if (!ctx->cmd_error_sent &&
-           !imap_metadata_verify_entry_name(name, &error)) {
-               client_send_command_error(ctx->cmd, error);
+           !imap_metadata_verify_entry_name(name, &client_error)) {
+               client_send_command_error(ctx->cmd, client_error);
                ctx->cmd_error_sent = TRUE;
        }
        if (ctx->cmd_error_sent) {
@@ -214,7 +215,7 @@ cmd_setmetadata_entry(struct imap_setmetadata_context *ctx,
 static bool cmd_setmetadata_continue(struct client_command_context *cmd)
 {
        struct imap_setmetadata_context *ctx = cmd->context;
-       const char *entry, *error_string;
+       const char *entry, *client_error;
        enum mail_error error;
        const struct imap_arg *value;
        int ret;
@@ -249,16 +250,16 @@ static bool cmd_setmetadata_continue(struct client_command_context *cmd)
        } else if (ctx->storage_failure) {
                if (ctx->box == NULL)
                        client_disconnect_if_inconsistent(cmd->client);
-               error_string = imap_metadata_transaction_get_last_error
+               client_error = imap_metadata_transaction_get_last_error
                        (ctx->trans, &error);
                client_send_tagline(cmd,
-                       imap_get_error_string(cmd, error_string, error));
+                       imap_get_error_string(cmd, client_error, error));
        } else if (imap_metadata_transaction_commit(&ctx->trans, 
-                                               &error, &error_string) < 0) {
+                                               &error, &client_error) < 0) {
                if (ctx->box == NULL)
                        client_disconnect_if_inconsistent(cmd->client);
                client_send_tagline(cmd,
-                       imap_get_error_string(cmd, error_string, error));
+                       imap_get_error_string(cmd, client_error, error));
        } else {
                client_send_tagline(cmd, "OK Setmetadata completed.");
        }

diff --git a/src/imap/imap-client.c b/src/imap/imap-client.c
index 078a1259b9599e142c442f7e10a3703129a9f8bf..8c308ba02bcff439dd961c3447ec221827040641 100644 (file)
--- a/src/imap/imap-client.c
+++ b/src/imap/imap-client.c
@@ -541,10 +541,11 @@ void client_disconnect(struct client *client, const char *reason)
        client->to_idle = timeout_add(0, client_destroy_timeout, client);
 }
 
-void client_disconnect_with_error(struct client *client, const char *msg)
+void client_disconnect_with_error(struct client *client,
+                                 const char *client_error)
 {
-       client_send_line(client, t_strconcat("* BYE ", msg, NULL));
-       client_disconnect(client, msg);
+       client_send_line(client, t_strconcat("* BYE ", client_error, NULL));
+       client_disconnect(client, client_error);
 }
 
 void client_add_capability(struct client *client, const char *capability)
@@ -660,19 +661,19 @@ client_default_sync_notify_more(struct imap_sync_context *ctx ATTR_UNUSED)
 }
 
 void client_send_command_error(struct client_command_context *cmd,
-                              const char *msg)
+                              const char *client_error)
 {
        struct client *client = cmd->client;
        const char *error, *cmd_name;
        enum imap_parser_error parse_error;
 
-       if (msg == NULL) {
-               msg = imap_parser_get_error(cmd->parser, &parse_error);
+       if (client_error == NULL) {
+               client_error = imap_parser_get_error(cmd->parser, &parse_error);
                switch (parse_error) {
                case IMAP_PARSE_ERROR_NONE:
                        i_unreached();
                case IMAP_PARSE_ERROR_LITERAL_TOO_BIG:
-                       client_disconnect_with_error(client, msg);
+                       client_disconnect_with_error(client, client_error);
                        return;
                default:
                        break;
@@ -680,13 +681,13 @@ void client_send_command_error(struct client_command_context *cmd,
        }
 
        if (cmd->tag == NULL)
-               error = t_strconcat("BAD Error in IMAP tag: ", msg, NULL);
+               error = t_strconcat("BAD Error in IMAP tag: ", client_error, NULL);
        else if (cmd->name == NULL)
-               error = t_strconcat("BAD Error in IMAP command: ", msg, NULL);
+               error = t_strconcat("BAD Error in IMAP command: ", client_error, NULL);
        else {
                cmd_name = t_str_ucase(cmd->name);
                error = t_strconcat("BAD Error in IMAP command ",
-                                   cmd_name, ": ", msg, NULL);
+                                   cmd_name, ": ", client_error, NULL);
        }
 
        client_send_tagline(cmd, error);

diff --git a/src/imap/imap-client.h b/src/imap/imap-client.h
index 11e541730cef8092d7c5ee5df3f0c761c480ad5b..42d987eb143246d7e9f271f9908b7838cab0916c 100644 (file)
--- a/src/imap/imap-client.h
+++ b/src/imap/imap-client.h
@@ -266,7 +266,8 @@ void client_destroy(struct client *client, const char *reason) ATTR_NULL(2);
 
 /* Disconnect client connection */
 void client_disconnect(struct client *client, const char *reason);
-void client_disconnect_with_error(struct client *client, const char *msg);
+void client_disconnect_with_error(struct client *client,
+                                 const char *client_error);
 
 /* Add the given capability to the CAPABILITY reply. If imap_capability setting
    has an explicit capability, nothing is changed. */
@@ -283,10 +284,10 @@ int client_send_line_next(struct client *client, const char *data);
 void client_send_tagline(struct client_command_context *cmd, const char *data);
 
 /* Send a BAD command reply to client via client_send_tagline(). If there have
-   been too many command errors, the client is disconnected. msg may be NULL,
-   in which case the error is looked up from imap_parser. */
+   been too many command errors, the client is disconnected. client_error may
+   be NULL, in which case the error is looked up from imap_parser. */
 void client_send_command_error(struct client_command_context *cmd,
-                              const char *msg);
+                              const char *client_error);
 
 /* Send a NO command reply with the default internal error message to client
    via client_send_tagline(). */

diff --git a/src/imap/imap-commands-util.c b/src/imap/imap-commands-util.c
index d7492676ba098e52fd66e3f1b6aff387555ec588..5c48b87abe50e923e910d3cbee5e72833d3dcd05 100644 (file)
--- a/src/imap/imap-commands-util.c
+++ b/src/imap/imap-commands-util.c
@@ -16,7 +16,7 @@
 
 struct mail_namespace *
 client_find_namespace_full(struct client *client,
-                          const char **mailbox, const char **error_r)
+                          const char **mailbox, const char **client_error_r)
 {
        struct mail_namespace *namespaces = client->user->namespaces;
        struct mail_namespace *ns;
@@ -24,7 +24,7 @@ client_find_namespace_full(struct client *client,
 
        utf8_name = t_str_new(64);
        if (imap_utf7_to_utf8(*mailbox, utf8_name) < 0) {
-               *error_r = "NO Mailbox name is not valid mUTF-7";
+               *client_error_r = "NO Mailbox name is not valid mUTF-7";
                return NULL;
        }
 
@@ -33,7 +33,7 @@ client_find_namespace_full(struct client *client,
            ns->prefix_len == 0) {
                /* this matched only the autocreated prefix="" namespace.
                   give a nice human-readable error message */
-               *error_r = t_strdup_printf(
+               *client_error_r = t_strdup_printf(
                        "NO Client tried to access nonexistent namespace. "
                        "(Mailbox name should probably be prefixed with: %s)",
                        mail_namespace_find_inbox(namespaces)->prefix);
@@ -56,11 +56,11 @@ struct mail_namespace *
 client_find_namespace(struct client_command_context *cmd, const char **mailbox)
 {
        struct mail_namespace *ns;
-       const char *error;
+       const char *client_error;
 
-       ns = client_find_namespace_full(cmd->client, mailbox, &error);
+       ns = client_find_namespace_full(cmd->client, mailbox, &client_error);
        if (ns == NULL)
-               client_send_tagline(cmd, error);
+               client_send_tagline(cmd, client_error);
        return ns;
 }
 

diff --git a/src/imap/imap-commands-util.h b/src/imap/imap-commands-util.h
index 48f4f6be33a1ee11e07596afa86455fd262d885f..c475909d17c9a5dc353e697d103a67ee9a4b6819 100644 (file)
--- a/src/imap/imap-commands-util.h
+++ b/src/imap/imap-commands-util.h
@@ -15,7 +15,7 @@ struct mail_namespace *
 client_find_namespace(struct client_command_context *cmd, const char **mailbox);
 struct mail_namespace *
 client_find_namespace_full(struct client *client,
-                          const char **mailbox, const char **error_r);
+                          const char **mailbox, const char **client_error_r);
 
 /* Returns TRUE if mailbox is selected. If not, sends "No mailbox selected"
    error message to client. */

diff --git a/src/imap/imap-fetch.c b/src/imap/imap-fetch.c
index ed1c51211c34c1484b9cca6c2e902acc6a4808c8..e8bfc011488a74519a1d8d51d59c3fee6bd35e63 100644 (file)
--- a/src/imap/imap-fetch.c
+++ b/src/imap/imap-fetch.c
@@ -96,7 +96,7 @@ void imap_fetch_init_nofail_handler(struct imap_fetch_context *ctx,
 int imap_fetch_att_list_parse(struct client *client, pool_t pool,
                              const struct imap_arg *list,
                              struct imap_fetch_context **fetch_ctx_r,
-                             const char **error_r)
+                             const char **client_error_r)
 {
        struct imap_fetch_init_context init_ctx;
        const char *str;
@@ -110,14 +110,14 @@ int imap_fetch_att_list_parse(struct client *client, pool_t pool,
                init_ctx.name = t_str_ucase(str);
                init_ctx.args++;
                if (!imap_fetch_init_handler(&init_ctx)) {
-                       *error_r = t_strconcat("Invalid fetch-att list: ",
-                                              init_ctx.error, NULL);
+                       *client_error_r = t_strconcat("Invalid fetch-att list: ",
+                                                     init_ctx.error, NULL);
                        imap_fetch_free(&init_ctx.fetch_ctx);
                        return -1;
                }
        }
        if (!IMAP_ARG_IS_EOL(init_ctx.args)) {
-               *error_r = "fetch-att list contains non-atoms.";
+               *client_error_r = "fetch-att list contains non-atoms.";
                imap_fetch_free(&init_ctx.fetch_ctx);
                return -1;
        }

diff --git a/src/imap/imap-fetch.h b/src/imap/imap-fetch.h
index 55055d2d15064469eec30440294f549b671a3c1d..1ed49f8bffdf0712f6484b6d19d535d8e535a076 100644 (file)
--- a/src/imap/imap-fetch.h
+++ b/src/imap/imap-fetch.h
@@ -121,7 +121,7 @@ void imap_fetch_add_handler(struct imap_fetch_init_context *ctx,
 int imap_fetch_att_list_parse(struct client *client, pool_t pool,
                              const struct imap_arg *list,
                              struct imap_fetch_context **fetch_ctx_r,
-                             const char **error_r);
+                             const char **client_error_r);
 
 struct imap_fetch_context *
 imap_fetch_alloc(struct client *client, pool_t pool, const char *reason);

diff --git a/src/imap/imap-search-args.c b/src/imap/imap-search-args.c
index 1b6facd2df7e132ed82472705b7f648321ab73d2..59d332b0036e884726cb70b97c5b6e82746ad834 100644 (file)
--- a/src/imap/imap-search-args.c
+++ b/src/imap/imap-search-args.c
@@ -41,7 +41,7 @@ int imap_search_args_build(struct client_command_context *cmd,
 {
        struct mail_search_parser *parser;
        struct mail_search_args *sargs;
-       const char *error;
+       const char *client_error;
        int ret;
 
        if (IMAP_ARG_IS_EOL(args)) {
@@ -51,14 +51,14 @@ int imap_search_args_build(struct client_command_context *cmd,
 
        parser = mail_search_parser_init_imap(args);
        ret = mail_search_build(mail_search_register_get_imap(),
-                               parser, &charset, &sargs, &error);
+                               parser, &charset, &sargs, &client_error);
        mail_search_parser_deinit(&parser);
        if (ret < 0) {
                if (charset == NULL) {
                        client_send_tagline(cmd, t_strconcat(
-                               "BAD [BADCHARSET] ", error, NULL));
+                               "BAD [BADCHARSET] ", client_error, NULL));
                } else {
-                       client_send_command_error(cmd, error);
+                       client_send_command_error(cmd, client_error);
                }
                return -1;
        }
@@ -188,7 +188,7 @@ int imap_search_get_anyset(struct client_command_context *cmd,
                           const char *set, bool uid,
                           struct mail_search_args **search_args_r)
 {
-       const char *error = NULL;
+       const char *client_error = NULL;
        int ret;
 
        if (strcmp(set, "$") == 0) {
@@ -198,12 +198,13 @@ int imap_search_get_anyset(struct client_command_context *cmd,
        }
        if (!uid) {
                ret = imap_search_get_msgset_arg(cmd, set, search_args_r,
-                                                &error);
+                                                &client_error);
        } else {
-               ret = imap_search_get_uidset_arg(set, search_args_r, &error);
+               ret = imap_search_get_uidset_arg(set, search_args_r,
+                                                &client_error);
        }
        if (ret < 0) {
-               client_send_command_error(cmd, error);
+               client_send_command_error(cmd, client_error);
                return -1;
        }
        return 1;

diff --git a/src/imap/imap-search.c b/src/imap/imap-search.c
index 5a5372fd93c9616d5e6ae45f45a1baebf7b9eac2..dead3cceb87544d575fc1b4b5f52762580b7b3ed 100644 (file)
--- a/src/imap/imap-search.c
+++ b/src/imap/imap-search.c
@@ -45,13 +45,14 @@ static bool
 search_parse_fetch_att(struct imap_search_context *ctx,
                       const struct imap_arg *update_args)
 {
-       const char *error;
+       const char *client_error;
 
        ctx->fetch_pool = pool_alloconly_create("search update fetch", 512);
        if (imap_fetch_att_list_parse(ctx->cmd->client, ctx->fetch_pool,
-                                     update_args, &ctx->fetch_ctx, &error) < 0) {
+                                     update_args, &ctx->fetch_ctx,
+                                     &client_error) < 0) {
                client_send_command_error(ctx->cmd, t_strconcat(
-                       "SEARCH UPDATE fetch-att: ", error, NULL));
+                       "SEARCH UPDATE fetch-att: ", client_error, NULL));
                pool_unref(&ctx->fetch_pool);
                return FALSE;
        }

diff --git a/src/lib-storage/mail-search-build.c b/src/lib-storage/mail-search-build.c
index f36f5d0c8d3e2611a2e80389c9a00b486de04874..7c86ee3e102a4f5c826a33e93c2cc2f66973c9e9 100644 (file)
--- a/src/lib-storage/mail-search-build.c
+++ b/src/lib-storage/mail-search-build.c
@@ -134,7 +134,8 @@ static int mail_search_build_list(struct mail_search_build_context *ctx,
 
 int mail_search_build(struct mail_search_register *reg,
                      struct mail_search_parser *parser, const char **charset,
-                     struct mail_search_args **args_r, const char **error_r)
+                     struct mail_search_args **args_r,
+                     const char **client_error_r)
 {
         struct mail_search_build_context ctx;
        struct mail_search_args *args;
@@ -143,7 +144,7 @@ int mail_search_build(struct mail_search_register *reg,
        int ret;
 
        *args_r = NULL;
-       *error_r = NULL;
+       *client_error_r = NULL;
 
        i_zero(&ctx);
        ctx.args = args = mail_search_build_init();
@@ -158,7 +159,7 @@ int mail_search_build(struct mail_search_register *reg,
                ret = mail_search_build_get_utf8(&ctx, "", &str);
        }
        if (ret < 0) {
-               *error_r = ctx._error != NULL ? t_strdup(ctx._error) :
+               *client_error_r = ctx._error != NULL ? t_strdup(ctx._error) :
                        t_strdup(mail_search_parser_get_error(parser));
                if (ctx.unknown_charset)
                        *charset = NULL;

diff --git a/src/lib-storage/mail-search-build.h b/src/lib-storage/mail-search-build.h
index d9f86e60806bd678d66d2b0b0d90a9e2518b5e85..7bba1ce5d8593cce71f7769ec223e1cfee4a070d 100644 (file)
--- a/src/lib-storage/mail-search-build.h
+++ b/src/lib-storage/mail-search-build.h
@@ -28,7 +28,8 @@ struct mail_search_args *mail_search_build_init(void);
    If charset is unknown, it's changed to NULL. */
 int mail_search_build(struct mail_search_register *reg,
                      struct mail_search_parser *parser, const char **charset,
-                     struct mail_search_args **args_r, const char **error_r);
+                     struct mail_search_args **args_r,
+                     const char **client_error_r);
 
 /* Add new search arg with given type. */
 struct mail_search_arg *