doveadm: doveadm-mail-* - Replace i_<log>() with e_<log>()

doveadm-mail
doveadm-mail-altmove
doveadm-mail-copymove
doveadm-mail-deduplicate
doveadm-mail-expunge
doveadm-mail-fetch
doveadm-mail-flags
doveadm-mail-import
doveadm-mail-index
doveadm-mail-iter
doveadm-mail-mailbox
doveadm-mail-mailbox-cache
doveadm-mail-mailbox-metadata
doveadm-mail-mailbox-status
doveadm-mail-save
doveadm-mail-search
doveadm-mail-server

diff --git a/src/doveadm/doveadm-mail-altmove.c b/src/doveadm/doveadm-mail-altmove.c
index db448d1e69346dba64d200f3afbdadf8dd05afff..7a630fa95939dd3073159f6362e87ff561351d09 100644 (file)
--- a/src/doveadm/doveadm-mail-altmove.c
+++ b/src/doveadm/doveadm-mail-altmove.c
@@ -30,10 +30,7 @@ cmd_altmove_box(struct doveadm_mail_cmd_context *ctx,
                return ret;
 
        while (doveadm_mail_iter_next(iter, &mail)) {
-               if (doveadm_debug) {
-                       i_debug("altmove: box=%s uid=%u",
-                               info->vname, mail->uid);
-               }
+               e_debug(mail_event(mail), "altmove");
                mail_update_flags(mail, modify_type,
                        (enum mail_flags)MAIL_INDEX_MAIL_FLAG_BACKEND);
        }
@@ -45,7 +42,8 @@ ns_purge(struct doveadm_mail_cmd_context *ctx, struct mail_namespace *ns,
         struct mail_storage *storage)
 {
        if (mail_storage_purge(storage) < 0) {
-               i_error("Purging namespace '%s' failed: %s", ns->prefix,
+               e_error(ns->user->event,
+                       "Purging namespace '%s' failed: %s", ns->prefix,
                        mail_storage_get_last_internal_error(storage, NULL));
                doveadm_mail_failed_storage(ctx, storage);
                return -1;

diff --git a/src/doveadm/doveadm-mail-copymove.c b/src/doveadm/doveadm-mail-copymove.c
index d90af68ff8725d7fc58751313b3fdbc35be99b3f..261679bfadc5710ec5ea03118c42210ba63c5ca3 100644 (file)
--- a/src/doveadm/doveadm-mail-copymove.c
+++ b/src/doveadm/doveadm-mail-copymove.c
@@ -52,7 +52,8 @@ cmd_copy_box(struct copy_cmd_context *ctx, struct mailbox *destbox,
                else
                        ret2 = mailbox_copy(&save_ctx, mail);
                if (ret2 < 0) {
-                       i_error("%s message UID %u from '%s' failed: %s",
+                       e_error(ctx->ctx.cctx->event,
+                               "%s message UID %u from '%s' failed: %s",
                                ctx->move ? "Moving" : "Copying",
                                mail->uid, info->vname,
                                mailbox_get_last_internal_error(destbox, NULL));
@@ -62,7 +63,7 @@ cmd_copy_box(struct copy_cmd_context *ctx, struct mailbox *destbox,
        }
 
        if (mailbox_transaction_commit(&desttrans) < 0) {
-               i_error("Committing %s mails failed: %s",
+               e_error(ctx->ctx.cctx->event, "Committing %s mails failed: %s",
                        ctx->move ? "moved" : "copied",
                        mailbox_get_last_internal_error(destbox, NULL));
                doveadm_mail_failed_mailbox(&ctx->ctx, destbox);
@@ -116,7 +117,8 @@ cmd_copy_run(struct doveadm_mail_cmd_context *_ctx, struct mail_user *user)
        ns = mail_namespace_find(user->namespaces, ctx->destname);
        destbox = mailbox_alloc(ns->list, ctx->destname, MAILBOX_FLAG_SAVEONLY);
        if (mailbox_open(destbox) < 0) {
-               i_error("Can't open mailbox '%s': %s", ctx->destname,
+               e_error(ctx->ctx.cctx->event,
+                       "Can't open mailbox '%s': %s", ctx->destname,
                        mailbox_get_last_internal_error(destbox, NULL));
                doveadm_mail_failed_mailbox(&ctx->ctx, destbox);
                mailbox_free(&destbox);
@@ -134,7 +136,8 @@ cmd_copy_run(struct doveadm_mail_cmd_context *_ctx, struct mail_user *user)
                ret = -1;
 
        if (mailbox_sync(destbox, 0) < 0) {
-               i_error("Syncing mailbox '%s' failed: %s", ctx->destname,
+               e_error(ctx->ctx.cctx->event,
+                       "Syncing mailbox '%s' failed: %s", ctx->destname,
                        mailbox_get_last_internal_error(destbox, NULL));
                doveadm_mail_failed_mailbox(&ctx->ctx, destbox);
                ret = -1;

diff --git a/src/doveadm/doveadm-mail-deduplicate.c b/src/doveadm/doveadm-mail-deduplicate.c
index 2152482876bec2209100e76aad32790265c47f10..f1759fd5c4e634a8c55473b56e095e389d9413f3 100644 (file)
--- a/src/doveadm/doveadm-mail-deduplicate.c
+++ b/src/doveadm/doveadm-mail-deduplicate.c
@@ -42,7 +42,8 @@ cmd_deduplicate_box(struct doveadm_mail_cmd_context *_ctx,
                                errstr = mailbox_get_last_internal_error(mail->box, &error);
                                if (error == MAIL_ERROR_NOTFOUND)
                                        continue;
-                               i_error("Couldn't lookup Message-ID: for UID=%u: %s",
+                               e_error(ctx->ctx.cctx->event,
+                                       "Couldn't lookup Message-ID: for UID=%u: %s",
                                        mail->uid, errstr);
                                doveadm_mail_failed_error(_ctx, error);
                                ret = -1;
@@ -53,7 +54,8 @@ cmd_deduplicate_box(struct doveadm_mail_cmd_context *_ctx,
                                errstr = mailbox_get_last_internal_error(mail->box, &error);
                                if (error == MAIL_ERROR_NOTFOUND)
                                        continue;
-                               i_error("Couldn't lookup GUID: for UID=%u: %s",
+                               e_error(ctx->ctx.cctx->event,
+                                       "Couldn't lookup GUID: for UID=%u: %s",
                                        mail->uid, errstr);
                                doveadm_mail_failed_error(_ctx, error);
                                ret = -1;

diff --git a/src/doveadm/doveadm-mail-expunge.c b/src/doveadm/doveadm-mail-expunge.c
index 0acbc1fd08eb32a68f82073f01e0d9efdac39b11..043460f3f86d7b0039e7ae6ec4521a89ad44599b 100644 (file)
--- a/src/doveadm/doveadm-mail-expunge.c
+++ b/src/doveadm/doveadm-mail-expunge.c
@@ -34,17 +34,15 @@ cmd_expunge_box(struct doveadm_mail_cmd_context *_ctx,
 
        ret = 0;
        while (doveadm_mail_iter_next(iter, &mail)) {
-               if (doveadm_debug) {
-                       i_debug("expunge: box=%s uid=%u",
-                               info->vname, mail->uid);
-               }
+               e_debug(mail_event(mail), "expunge");
                mail_expunge(mail);
        }
 
        if (doveadm_mail_iter_deinit_keep_box(&iter, &box) < 0)
                ret = -1;
        else if (mailbox_sync(box, 0) < 0) {
-               i_error("Syncing mailbox '%s' failed: %s",
+               e_debug(ctx->ctx.cctx->event,
+                       "Syncing mailbox '%s' failed: %s",
                        mailbox_get_vname(box),
                        mailbox_get_last_internal_error(box, NULL));
                doveadm_mail_failed_mailbox(_ctx, box);
@@ -55,7 +53,8 @@ cmd_expunge_box(struct doveadm_mail_cmd_context *_ctx,
                if (mailbox_delete_empty(box) < 0) {
                        error = mailbox_get_last_mail_error(box);
                        if (error != MAIL_ERROR_EXISTS) {
-                               i_error("Deleting mailbox '%s' failed: %s",
+                               e_debug(ctx->ctx.cctx->event,
+                                       "Deleting mailbox '%s' failed: %s",
                                        mailbox_get_vname(box),
                                        mailbox_get_last_internal_error(box, NULL));
                                doveadm_mail_failed_mailbox(_ctx, box);
@@ -63,7 +62,8 @@ cmd_expunge_box(struct doveadm_mail_cmd_context *_ctx,
                        }
                } else {
                        if (mailbox_set_subscribed(box, FALSE) < 0) {
-                               i_error("Unsubscribing mailbox '%s' failed: %s",
+                               e_debug(ctx->ctx.cctx->event,
+                                       "Unsubscribing mailbox '%s' failed: %s",
                                        mailbox_get_vname(box),
                                        mailbox_get_last_internal_error(box, NULL));
                                doveadm_mail_failed_mailbox(_ctx, box);

diff --git a/src/doveadm/doveadm-mail-fetch.c b/src/doveadm/doveadm-mail-fetch.c
index 0374c5e50ea58717505ba6de9a44d0cf823631ce..86e1f6773710d807207c195477b21524d51f581a 100644 (file)
--- a/src/doveadm/doveadm-mail-fetch.c
+++ b/src/doveadm/doveadm-mail-fetch.c
@@ -312,7 +312,8 @@ static int fetch_text_utf8(struct fetch_cmd_context *ctx)
 
        doveadm_print_stream("", 0);
        if (input->stream_errno != 0) {
-               i_error("read(%s) failed: %s", i_stream_get_name(input),
+               e_error(ctx->ctx.cctx->event,
+                       "read(%s) failed: %s", i_stream_get_name(input),
                        i_stream_get_error(input));
                return -1;
        }
@@ -585,7 +586,8 @@ static int cmd_fetch_mail(struct fetch_cmd_context *ctx)
        array_foreach(&ctx->fields, field) {
                ctx->cur_field = field;
                if (field->print(ctx) < 0) {
-                       i_error("fetch(%s) failed for box=%s uid=%u: %s",
+                       e_error(ctx->ctx.cctx->event,
+                               "fetch(%s) failed for box=%s uid=%u: %s",
                                field->name, mailbox_get_vname(mail->box),
                                mail->uid,
                                ctx->print_error != NULL ? ctx->print_error :

diff --git a/src/doveadm/doveadm-mail-flags.c b/src/doveadm/doveadm-mail-flags.c
index ff3b6c0ce8a9694cfdf9b4041ca85a3e9db55c5f..4344f9088161e670deb1c678d4b4a4f3352814c6 100644 (file)
--- a/src/doveadm/doveadm-mail-flags.c
+++ b/src/doveadm/doveadm-mail-flags.c
@@ -33,7 +33,7 @@ cmd_flags_run_box(struct flags_cmd_context *ctx,
 
        if (ctx->keywords != NULL) {
                if (mailbox_keywords_create(box, ctx->keywords, &kw) < 0) {
-                       i_error("Invalid keywords: %s",
+                       e_error(ctx->ctx.cctx->event, "Invalid keywords: %s",
                                mailbox_get_last_internal_error(box, NULL));
                        (void)doveadm_mail_iter_deinit(&iter);
                        ctx->ctx.exit_code = DOVEADM_EX_NOTPOSSIBLE;

diff --git a/src/doveadm/doveadm-mail-import.c b/src/doveadm/doveadm-mail-import.c
index 6a14235b20cd94bdae092ecb550cd2d85fe9ac32..8ee0884dcd195e3f10b043408e1047acd2888941 100644 (file)
--- a/src/doveadm/doveadm-mail-import.c
+++ b/src/doveadm/doveadm-mail-import.c
@@ -66,7 +66,8 @@ dest_mailbox_open_or_create(struct import_cmd_context *ctx,
        if (mailbox_create(box, NULL, FALSE) < 0) {
                errstr = mailbox_get_last_internal_error(box, &error);
                if (error != MAIL_ERROR_EXISTS) {
-                       i_error("Couldn't create mailbox %s: %s", name, errstr);
+                       e_error(user->event,
+                               "Couldn't create mailbox %s: %s", name, errstr);
                        doveadm_mail_failed_mailbox(&ctx->ctx, box);
                        mailbox_free(&box);
                        return -1;
@@ -74,12 +75,14 @@ dest_mailbox_open_or_create(struct import_cmd_context *ctx,
        }
        if (ctx->subscribe) {
                if (mailbox_set_subscribed(box, TRUE) < 0) {
-                       i_error("Couldn't subscribe to mailbox %s: %s",
+                       e_error(user->event,
+                               "Couldn't subscribe to mailbox %s: %s",
                                name, mailbox_get_last_internal_error(box, NULL));
                }
        }
        if (mailbox_sync(box, MAILBOX_SYNC_FLAG_FULL_READ) < 0) {
-               i_error("Syncing mailbox %s failed: %s", name,
+               e_error(user->event,
+                       "Syncing mailbox %s failed: %s", name,
                        mailbox_get_last_internal_error(box, NULL));
                doveadm_mail_failed_mailbox(&ctx->ctx, box);
                mailbox_free(&box);
@@ -96,29 +99,26 @@ cmd_import_box_contents(struct doveadm_mail_cmd_context *ctx,
 {
        struct mail_save_context *save_ctx;
        struct mailbox_transaction_context *dest_trans;
-       const char *mailbox = mailbox_get_vname(dest_box);
        int ret = 0;
 
        dest_trans = mailbox_transaction_begin(dest_box,
                                        MAILBOX_TRANSACTION_FLAG_EXTERNAL |
                                        ctx->transaction_flags, __func__);
        do {
-               if (doveadm_debug) {
-                       i_debug("import: box=%s uid=%u",
-                               mailbox, src_mail->uid);
-               }
+               e_debug(mail_event(src_mail), "import");
                save_ctx = mailbox_save_alloc(dest_trans);
                mailbox_save_copy_flags(save_ctx, src_mail);
                if (mailbox_copy(&save_ctx, src_mail) < 0) {
-                       i_error("Copying box=%s uid=%u failed: %s",
-                               mailbox, src_mail->uid,
+                       e_error(mail_event(src_mail),
+                               "Copying failed: %s",
                                mailbox_get_last_internal_error(dest_box, NULL));
                        ret = -1;
                }
        } while (doveadm_mail_iter_next(iter, &src_mail));
 
        if (mailbox_transaction_commit(&dest_trans) < 0) {
-               i_error("Committing copied mails to %s failed: %s", mailbox,
+               e_error(ctx->cctx->event,
+                       "Committing copied mails failed: %s",
                        mailbox_get_last_internal_error(dest_box, NULL));
                ret = -1;
        }

diff --git a/src/doveadm/doveadm-mail-index.c b/src/doveadm/doveadm-mail-index.c
index 89f85192f17f016b3449f726853bf3cace590219..e808debc1d8dd2b4d9ac678146db02c3ba4e0197 100644 (file)
--- a/src/doveadm/doveadm-mail-index.c
+++ b/src/doveadm/doveadm-mail-index.c
@@ -31,6 +31,7 @@ struct index_cmd_context {
 static int cmd_index_box_precache(struct doveadm_mail_cmd_context *dctx,
                                  struct mailbox *box)
 {
+       struct event *event = dctx->cctx->event;
        struct mailbox_status status;
        struct mailbox_transaction_context *trans;
        struct mail_search_args *search_args;
@@ -43,13 +44,13 @@ static int cmd_index_box_precache(struct doveadm_mail_cmd_context *dctx,
 
        if (mailbox_get_metadata(box, MAILBOX_METADATA_PRECACHE_FIELDS,
                                 &metadata) < 0) {
-               i_error("Mailbox %s: Precache-fields lookup failed: %s",
+               e_error(event, "Mailbox %s: Precache-fields lookup failed: %s",
                        mailbox_get_vname(box),
                        mailbox_get_last_internal_error(box, NULL));
        }
        if (mailbox_get_status(box, STATUS_MESSAGES | STATUS_LAST_CACHED_SEQ,
                               &status) < 0) {
-               i_error("Mailbox %s: Status lookup failed: %s",
+               e_error(event, "Mailbox %s: Status lookup failed: %s",
                        mailbox_get_vname(box),
                        mailbox_get_last_internal_error(box, NULL));
                return -1;
@@ -58,13 +59,13 @@ static int cmd_index_box_precache(struct doveadm_mail_cmd_context *dctx,
        seq = status.last_cached_seq + 1;
        if (seq > status.messages) {
                if (doveadm_verbose) {
-                       i_info("%s: Cache is already up to date",
+                       e_info(event, "%s: Cache is already up to date",
                               mailbox_get_vname(box));
                }
                return 0;
        }
        if (doveadm_verbose) {
-               i_info("%s: Caching mails seq=%u..%u",
+               e_info(event, "%s: Caching mails seq=%u..%u",
                       mailbox_get_vname(box), seq, status.messages);
        }
 
@@ -79,7 +80,8 @@ static int cmd_index_box_precache(struct doveadm_mail_cmd_context *dctx,
        max = status.messages - seq + 1;
        while (mailbox_search_next(ctx, &mail)) {
                if (mail_precache(mail) < 0) {
-                       i_error("Mailbox %s: Precache for UID=%u failed: %s",
+                       e_error(event,
+                               "Mailbox %s: Precache for UID=%u failed: %s",
                                mailbox_get_vname(box), mail->uid,
                                mailbox_get_last_internal_error(box, NULL));
                        ret = -1;
@@ -93,13 +95,13 @@ static int cmd_index_box_precache(struct doveadm_mail_cmd_context *dctx,
        if (doveadm_verbose)
                printf("\r%u/%u\n", counter, max);
        if (mailbox_search_deinit(&ctx) < 0) {
-               i_error("Mailbox %s: Mail search failed: %s",
+               e_error(event, "Mailbox %s: Mail search failed: %s",
                        mailbox_get_vname(box),
                        mailbox_get_last_internal_error(box, NULL));
                ret = -1;
        }
        if (mailbox_transaction_commit(&trans) < 0) {
-               i_error("Mailbox %s: Transaction commit failed: %s",
+               e_error(event, "Mailbox %s: Transaction commit failed: %s",
                        mailbox_get_vname(box),
                        mailbox_get_last_internal_error(box, NULL));
                ret = -1;
@@ -110,6 +112,7 @@ static int cmd_index_box_precache(struct doveadm_mail_cmd_context *dctx,
 static int
 cmd_index_box(struct index_cmd_context *ctx, const struct mailbox_info *info)
 {
+       struct event *event = ctx->ctx.cctx->event;
        struct mailbox *box;
        struct mailbox_status status;
        int ret = 0;
@@ -121,7 +124,8 @@ cmd_index_box(struct index_cmd_context *ctx, const struct mailbox_info *info)
                   don't bother syncing the mailbox, that alone can take a
                   while with large maildirs. */
                if (mailbox_open(box) < 0) {
-                       i_error("Opening mailbox %s failed: %s", info->vname,
+                       e_error(event,
+                               "Opening mailbox %s failed: %s", info->vname,
                                mailbox_get_last_internal_error(box, NULL));
                        doveadm_mail_failed_mailbox(&ctx->ctx, box);
                        mailbox_free(&box);
@@ -136,7 +140,7 @@ cmd_index_box(struct index_cmd_context *ctx, const struct mailbox_info *info)
        }
 
        if (mailbox_sync(box, MAILBOX_SYNC_FLAG_FULL_READ) < 0) {
-               i_error("Syncing mailbox %s failed: %s", info->vname,
+               e_error(event, "Syncing mailbox %s failed: %s", info->vname,
                        mailbox_get_last_internal_error(box, NULL));
                doveadm_mail_failed_mailbox(&ctx->ctx, box);
                ret = -1;
@@ -203,6 +207,7 @@ cmd_index_run(struct doveadm_mail_cmd_context *_ctx, struct mail_user *user)
 {
        struct index_cmd_context *ctx =
                container_of(_ctx, struct index_cmd_context, ctx);
+       struct event *event = ctx->ctx.cctx->event;
        const enum mailbox_list_iter_flags iter_flags =
                MAILBOX_LIST_ITER_NO_AUTO_BOXES |
                MAILBOX_LIST_ITER_RETURN_NO_FLAGS |
@@ -234,7 +239,7 @@ cmd_index_run(struct doveadm_mail_cmd_context *_ctx, struct mail_user *user)
                } T_END;
        }
        if (mailbox_list_iter_deinit(&iter) < 0) {
-               i_error("Listing mailboxes failed: %s",
+               e_error(event, "Listing mailboxes failed: %s",
                        mailbox_list_get_last_internal_error(user->namespaces->list, NULL));
                doveadm_mail_failed_error(_ctx, MAIL_ERROR_TEMP);
                ret = -1;

diff --git a/src/doveadm/doveadm-mail-iter.c b/src/doveadm/doveadm-mail-iter.c
index 452ce337282cd3e11f8bef1ba049bbece4780b2b..99256bb31a92e8ff4af8398e86e24aa1dbbe4ef9 100644 (file)
--- a/src/doveadm/doveadm-mail-iter.c
+++ b/src/doveadm/doveadm-mail-iter.c
@@ -48,7 +48,8 @@ int doveadm_mail_iter_init(struct doveadm_mail_cmd_context *ctx,
                *iter_r = NULL;
                errstr = mailbox_get_last_internal_error(iter->box, &error);
                if (error != MAIL_ERROR_NOTFOUND) {
-                       i_error("Syncing mailbox %s failed: %s", info->vname, errstr);
+                       e_error(ctx->cctx->event, "Syncing mailbox %s failed: %s",
+                               info->vname, errstr);
                        doveadm_mail_failed_mailbox(ctx, iter->box);
                }
                mailbox_free(&iter->box);
@@ -77,7 +78,8 @@ doveadm_mail_iter_deinit_transaction(struct doveadm_mail_iter *iter,
 
        if (iter->search_ctx != NULL) {
                if (mailbox_search_deinit(&iter->search_ctx) < 0) {
-                       i_error("Searching mailbox %s failed: %s",
+                       e_error(iter->ctx->cctx->event,
+                               "Searching mailbox %s failed: %s",
                                mailbox_get_vname(iter->box),
                                mailbox_get_last_internal_error(iter->box, NULL));
                        ret = -1;
@@ -87,7 +89,8 @@ doveadm_mail_iter_deinit_transaction(struct doveadm_mail_iter *iter,
                ;
        else if (commit) {
                if (mailbox_transaction_commit(&iter->t) < 0) {
-                       i_error("Committing mailbox %s failed: %s",
+                       e_error(iter->ctx->cctx->event,
+                               "Committing mailbox %s failed: %s",
                                mailbox_get_vname(iter->box),
                                mailbox_get_last_internal_error(iter->box, NULL));
                        ret = -1;
@@ -112,7 +115,8 @@ doveadm_mail_iter_deinit_full(struct doveadm_mail_iter **_iter,
        if (ret == 0 && sync) {
                ret = mailbox_sync(iter->box, 0);
                if (ret < 0) {
-                       i_error("Mailbox %s: Mailbox sync failed: %s",
+                       e_error(iter->ctx->cctx->event,
+                               "Mailbox %s: Mailbox sync failed: %s",
                                mailbox_get_vname(iter->box),
                                mailbox_get_last_internal_error(iter->box, NULL));
                }

diff --git a/src/doveadm/doveadm-mail-mailbox-cache.c b/src/doveadm/doveadm-mail-mailbox-cache.c
index 99fe30e8ccc16388d234bd9fb41e9fdee209a7bd..7be26da4b7718ca7d251b93bf6e1256607c36e30 100644 (file)
--- a/src/doveadm/doveadm-mail-mailbox-cache.c
+++ b/src/doveadm/doveadm-mail-mailbox-cache.c
@@ -33,7 +33,7 @@ static int cmd_mailbox_cache_open_box(struct doveadm_mail_cmd_context *ctx,
        struct mailbox *box = doveadm_mailbox_find(user, boxname);
 
        if (mailbox_open(box) < 0 || mailbox_sync(box, 0) < 0) {
-               i_error("Cannot open mailbox %s: %s",
+               e_error(ctx->cctx->event, "Cannot open mailbox %s: %s",
                        mailbox_get_vname(box),
                        mailbox_get_last_internal_error(box, NULL));
                doveadm_mail_failed_mailbox(ctx, box);
@@ -179,7 +179,7 @@ static int cmd_mailbox_cache_decision_run_box(struct mailbox_cache_cmd_context *
        if (mail_cache_open_and_verify(cache) < 0 ||
            MAIL_CACHE_IS_UNUSABLE(cache)) {
                mailbox_transaction_rollback(&t);
-               i_error("Cache is unusable");
+               e_error(ctx->ctx.cctx->event, "Cache is unusable");
                ctx->ctx.exit_code = EX_TEMPFAIL;
                return -1;
        }
@@ -198,7 +198,7 @@ static int cmd_mailbox_cache_decision_run_box(struct mailbox_cache_cmd_context *
        mail_cache_view_close(&view);
 
        if (mailbox_transaction_commit(&t) < 0) {
-               i_error("mailbox_transaction_commit() failed: %s",
+               e_error(ctx->ctx.cctx->event, "mailbox_transaction_commit() failed: %s",
                        mailbox_get_last_internal_error(box, NULL));
                doveadm_mail_failed_mailbox(&ctx->ctx, box);
                return -1;
@@ -260,7 +260,7 @@ static int cmd_mailbox_cache_remove_box(struct mailbox_cache_cmd_context *ctx,
 
        ret = 0;
        if (mail_index_transaction_commit(&t) < 0) {
-               i_error("mail_index_transaction_commit() failed: %s",
+               e_error(ctx->ctx.cctx->event, "mail_index_transaction_commit() failed: %s",
                        mailbox_get_last_internal_error(box, NULL));
                doveadm_mail_failed_mailbox(&ctx->ctx, box);
                ret = -1;

diff --git a/src/doveadm/doveadm-mail-mailbox-metadata.c b/src/doveadm/doveadm-mail-mailbox-metadata.c
index 4e97681b61891f6ee2bffa9e8a19c295171a45db..c97be854e161ca1935f297afd887bcfe074e1648 100644 (file)
--- a/src/doveadm/doveadm-mail-mailbox-metadata.c
+++ b/src/doveadm/doveadm-mail-mailbox-metadata.c
@@ -45,7 +45,7 @@ cmd_mailbox_metadata_get_mailbox(struct metadata_cmd_context *mctx,
        if (mctx->empty_mailbox_name) {
                if (!mctx->allow_empty_mailbox_name) {
                        const char *op_str = doveadm_metadata_op_names[op];
-                       i_error("Failed to %s: %s", op_str,
+                       e_error(mctx->ctx.cctx->event, "Failed to %s: %s", op_str,
                                "mailbox name cannot be empty");
                        mctx->ctx.exit_code = EX_USAGE;
                        return -1;
@@ -69,7 +69,7 @@ cmd_mailbox_metadata_get_mailbox(struct metadata_cmd_context *mctx,
 
        if (op == DOVEADM_METADATA_OP_SET &&
            mailbox_open(*box_r) < 0) {
-               i_error("Failed to open mailbox: %s",
+               e_error(mctx->ctx.cctx->event, "Failed to open mailbox: %s",
                        mailbox_get_last_internal_error(*box_r, NULL));
                doveadm_mail_failed_mailbox(&mctx->ctx, *box_r);
                mailbox_free(box_r);
@@ -104,12 +104,12 @@ cmd_mailbox_metadata_set_run(struct doveadm_mail_cmd_context *_ctx,
                mailbox_attribute_unset(trans, ctx->key_type, ctx->key) :
                mailbox_attribute_set(trans, ctx->key_type, ctx->key, &ctx->value);
        if (ret < 0) {
-               i_error("Failed to set attribute: %s",
+               e_error(ctx->ctx.cctx->event, "Failed to set attribute: %s",
                        mailbox_get_last_internal_error(box, NULL));
                doveadm_mail_failed_mailbox(_ctx, box);
                mailbox_transaction_rollback(&trans);
        } else if (mailbox_transaction_commit(&trans) < 0) {
-               i_error("Failed to commit transaction: %s",
+               e_error(ctx->ctx.cctx->event, "Failed to commit transaction: %s",
                        mailbox_get_last_internal_error(box, NULL));
                doveadm_mail_failed_mailbox(_ctx, box);
                ret = -1;
@@ -239,7 +239,7 @@ cmd_mailbox_metadata_get_run(struct doveadm_mail_cmd_context *_ctx,
 
        ret = mailbox_attribute_get_stream(box, ctx->key_type, ctx->key, &value);
        if (ret < 0) {
-               i_error("Failed to get attribute: %s",
+               e_error(ctx->ctx.cctx->event, "Failed to get attribute: %s",
                        mailbox_get_last_internal_error(box, NULL));
                doveadm_mail_failed_mailbox(_ctx, box);
        } else if (ret == 0) {
@@ -247,7 +247,7 @@ cmd_mailbox_metadata_get_run(struct doveadm_mail_cmd_context *_ctx,
                doveadm_print("");
        } else if (value.value_stream != NULL) {
                if (doveadm_print_istream(value.value_stream) < 0) {
-                       i_error("read(%s) failed: %s",
+                       e_error(ctx->ctx.cctx->event, "read(%s) failed: %s",
                                i_stream_get_name(value.value_stream),
                                i_stream_get_error(value.value_stream));
                        ret = -1;
@@ -313,7 +313,7 @@ cmd_mailbox_metadata_list_run_iter(struct metadata_cmd_context *ctx,
                }
        }
        if (mailbox_attribute_iter_deinit(&iter) < 0) {
-               i_error("Mailbox %s: Failed to iterate mailbox attributes: %s",
+               e_error(ctx->ctx.cctx->event, "Mailbox %s: Failed to iterate mailbox attributes: %s",
                        mailbox_get_vname(box),
                        mailbox_get_last_internal_error(box, NULL));
                return -1;

diff --git a/src/doveadm/doveadm-mail-mailbox-status.c b/src/doveadm/doveadm-mail-mailbox-status.c
index 392047d3fd9081e1bdac84e01bb8333e04447db4..bb4874341aa01994cc5a9e75dd85ddd240c702ea 100644 (file)
--- a/src/doveadm/doveadm-mail-mailbox-status.c
+++ b/src/doveadm/doveadm-mail-mailbox-status.c
@@ -138,7 +138,8 @@ status_mailbox(struct status_cmd_context *ctx, const struct mailbox_info *info)
        box = doveadm_mailbox_find(ctx->ctx.cur_mail_user, info->vname);
        if (mailbox_get_status(box, ctx->status_items, &status) < 0 ||
            mailbox_get_metadata(box, ctx->metadata_items, &metadata) < 0) {
-               i_error("Mailbox %s: Failed to lookup mailbox status: %s",
+               e_error(ctx->ctx.cctx->event,
+                       "Mailbox %s: Failed to lookup mailbox status: %s",
                        mailbox_get_vname(box),
                        mailbox_get_last_internal_error(box, NULL));
                doveadm_mail_failed_mailbox(&ctx->ctx, box);

diff --git a/src/doveadm/doveadm-mail-mailbox.c b/src/doveadm/doveadm-mail-mailbox.c
index 6b341412de8aacd7d695f3f89afab67f701781f9..2980bb0fbec79902901d8f6886c35153be3ab04c 100644 (file)
--- a/src/doveadm/doveadm-mail-mailbox.c
+++ b/src/doveadm/doveadm-mail-mailbox.c
@@ -215,14 +215,16 @@ cmd_mailbox_create_run(struct doveadm_mail_cmd_context *_ctx,
 
                box = mailbox_alloc(ns->list, name, 0);
                if (mailbox_create(box, &ctx->update, directory) < 0) {
-                       i_error("Can't create mailbox %s: %s", name,
+                       e_error(ctx->ctx.ctx.cctx->event,
+                               "Can't create mailbox %s: %s", name,
                                mailbox_get_last_internal_error(box, NULL));
                        doveadm_mail_failed_mailbox(_ctx, box);
                        ret = -1;
                }
                if (ctx->ctx.subscriptions) {
                        if (mailbox_set_subscribed(box, TRUE) < 0) {
-                               i_error("Can't subscribe to mailbox %s: %s", name,
+                               e_error(ctx->ctx.ctx.cctx->event,
+                                       "Can't subscribe to mailbox %s: %s", name,
                                        mailbox_get_last_internal_error(box, NULL));
                                doveadm_mail_failed_mailbox(_ctx, box);
                                ret = -1;
@@ -329,14 +331,16 @@ cmd_mailbox_delete_run(struct doveadm_mail_cmd_context *_ctx,
                ret2 = ctx->require_empty ? mailbox_delete_empty(box) :
                        mailbox_delete(box);
                if (ret2 < 0) {
-                       i_error("Can't delete mailbox %s: %s", name,
+                       e_error(ctx->ctx.ctx.cctx->event,
+                               "Can't delete mailbox %s: %s", name,
                                mailbox_get_last_internal_error(box, NULL));
                        doveadm_mail_failed_mailbox(_ctx, box);
                        ret = -1;
                }
                if (ctx->ctx.subscriptions) {
                        if (mailbox_set_subscribed(box, FALSE) < 0) {
-                               i_error("Can't unsubscribe mailbox %s: %s", name,
+                               e_error(ctx->ctx.ctx.cctx->event,
+                                       "Can't unsubscribe mailbox %s: %s", name,
                                        mail_storage_get_last_internal_error(storage, NULL));
                                doveadm_mail_failed_mailbox(_ctx, box);
                                ret = -1;
@@ -394,20 +398,23 @@ cmd_mailbox_rename_run(struct doveadm_mail_cmd_context *_ctx,
        oldbox = mailbox_alloc(oldns->list, oldname, 0);
        newbox = mailbox_alloc(newns->list, newname, 0);
        if (mailbox_rename(oldbox, newbox) < 0) {
-               i_error("Can't rename mailbox %s to %s: %s", oldname, newname,
+               e_error(ctx->ctx.ctx.cctx->event,
+                       "Can't rename mailbox %s to %s: %s", oldname, newname,
                        mailbox_get_last_internal_error(oldbox, NULL));
                doveadm_mail_failed_mailbox(_ctx, oldbox);
                ret = -1;
        }
        if (ctx->ctx.subscriptions) {
                if (mailbox_set_subscribed(oldbox, FALSE) < 0) {
-                       i_error("Can't unsubscribe mailbox %s: %s", ctx->oldname,
+                       e_error(ctx->ctx.ctx.cctx->event,
+                               "Can't unsubscribe mailbox %s: %s", ctx->oldname,
                                mailbox_get_last_internal_error(oldbox, NULL));
                        doveadm_mail_failed_mailbox(_ctx, oldbox);
                        ret = -1;
                }
                if (mailbox_set_subscribed(newbox, TRUE) < 0) {
-                       i_error("Can't subscribe to mailbox %s: %s", ctx->newname,
+                       e_error(ctx->ctx.ctx.cctx->event,
+                               "Can't subscribe to mailbox %s: %s", ctx->newname,
                                mailbox_get_last_internal_error(newbox, NULL));
                        doveadm_mail_failed_mailbox(_ctx, newbox);
                        ret = -1;
@@ -459,9 +466,10 @@ cmd_mailbox_subscribe_run(struct doveadm_mail_cmd_context *_ctx,
                ns = mail_namespace_find(user->namespaces, name);
                box = mailbox_alloc(ns->list, name, 0);
                if (mailbox_set_subscribed(box, ctx->ctx.subscriptions) < 0) {
-                       i_error("Can't %s mailbox %s: %s", name,
-                               ctx->ctx.subscriptions ? "subscribe to" :
-                               "unsubscribe",
+                       e_error(ctx->ctx.ctx.cctx->event,
+                               "Can't %s mailbox %s: %s", name,
+                               ctx->ctx.subscriptions ?
+                                       "subscribe to" : "unsubscribe",
                                mailbox_get_last_internal_error(box, NULL));
                        doveadm_mail_failed_mailbox(_ctx, box);
                        ret = -1;
@@ -552,9 +560,10 @@ int cmd_mailbox_update_run(struct doveadm_mail_cmd_context *_ctx,
        box = mailbox_alloc(ns->list, ctx->mailbox, 0);
 
        if ((ret = mailbox_update(box, &(ctx->update))) != 0) {
-               i_error("Cannot update %s: %s",
-                       ctx->mailbox,
-                       mailbox_get_last_internal_error(box, &mail_error));
+               const char *error = mailbox_get_last_internal_error(
+                       box, &mail_error);
+               e_error(ctx->ctx.ctx.cctx->event,
+                       "Cannot update %s: %s", ctx->mailbox, error);
                doveadm_mail_failed_error(_ctx, mail_error);
        }
 
@@ -626,9 +635,11 @@ cmd_mailbox_path_run(struct doveadm_mail_cmd_context *_ctx,
        storage_name = mailbox_list_get_storage_name(ns->list, ctx->mailbox);
        ret = mailbox_list_get_path(ns->list, storage_name, ctx->path_type, &path);
        if (ret < 0) {
-               i_error("Failed to lookup mailbox %s path: %s",
-                       ctx->mailbox,
-                       mailbox_list_get_last_internal_error(ns->list, &mail_error));
+               const char *error = mailbox_list_get_last_internal_error(
+                       ns->list, &mail_error);
+               e_error(ctx->ctx.ctx.cctx->event,
+                       "Failed to lookup mailbox %s path: %s",
+                       ctx->mailbox, error);
                doveadm_mail_failed_error(_ctx, mail_error);
        } else if (ret > 0) {
                doveadm_print(path);

diff --git a/src/doveadm/doveadm-mail-save.c b/src/doveadm/doveadm-mail-save.c
index 3553a0810ba2d24a9aa7d90e5c1b38736aab32db..640f378f0fe34004ade3a81c1cb33ce49ce39eec 100644 (file)
--- a/src/doveadm/doveadm-mail-save.c
+++ b/src/doveadm/doveadm-mail-save.c
@@ -21,7 +21,7 @@ cmd_save_to_mailbox(struct save_cmd_context *ctx, struct mailbox *box,
        bool save_failed = FALSE;
 
        if (input->stream_errno != 0) {
-               i_error("open(%s) failed: %s",
+               e_error(ctx->ctx.cctx->event, "open(%s) failed: %s",
                        i_stream_get_name(input),
                        i_stream_get_error(input));
                ctx->ctx.exit_code = EX_TEMPFAIL;
@@ -29,7 +29,7 @@ cmd_save_to_mailbox(struct save_cmd_context *ctx, struct mailbox *box,
        }
 
        if (mailbox_open(box) < 0) {
-               i_error("Failed to open mailbox %s: %s",
+               e_error(ctx->ctx.cctx->event, "Failed to open mailbox %s: %s",
                        mailbox_get_vname(box),
                        mailbox_get_last_internal_error(box, NULL));
                doveadm_mail_failed_storage(&ctx->ctx, storage);
@@ -40,7 +40,7 @@ cmd_save_to_mailbox(struct save_cmd_context *ctx, struct mailbox *box,
                                          ctx->ctx.transaction_flags, __func__);
        save_ctx = mailbox_save_alloc(trans);
        if (mailbox_save_begin(&save_ctx, input) < 0) {
-               i_error("Saving failed: %s",
+               e_error(ctx->ctx.cctx->event, "Saving failed: %s",
                        mailbox_get_last_internal_error(box, NULL));
                doveadm_mail_failed_storage(&ctx->ctx, storage);
                mailbox_transaction_rollback(&trans);
@@ -56,18 +56,20 @@ cmd_save_to_mailbox(struct save_cmd_context *ctx, struct mailbox *box,
        i_assert(ret == -1);
 
        if (input->stream_errno != 0) {
-               i_error("read(msg input) failed: %s", i_stream_get_error(input));
+               e_error(ctx->ctx.cctx->event,
+                       "read(msg input) failed: %s", i_stream_get_error(input));
                doveadm_mail_failed_error(&ctx->ctx, MAIL_ERROR_TEMP);
        } else if (save_failed) {
-               i_error("Saving failed: %s",
+               e_error(ctx->ctx.cctx->event, "Saving failed: %s",
                        mailbox_get_last_internal_error(box, NULL));
                doveadm_mail_failed_storage(&ctx->ctx, storage);
        } else if (mailbox_save_finish(&save_ctx) < 0) {
-               i_error("Saving failed: %s",
+               e_error(ctx->ctx.cctx->event, "Saving failed: %s",
                        mailbox_get_last_internal_error(box, NULL));
                doveadm_mail_failed_storage(&ctx->ctx, storage);
        } else if (mailbox_transaction_commit(&trans) < 0) {
-               i_error("Save transaction commit failed: %s",
+               e_error(ctx->ctx.cctx->event,
+                       "Save transaction commit failed: %s",
                        mailbox_get_last_internal_error(box, NULL));
                doveadm_mail_failed_storage(&ctx->ctx, storage);
        } else {

diff --git a/src/doveadm/doveadm-mail-search.c b/src/doveadm/doveadm-mail-search.c
index 5523674ad471de35c9cf2ec2cd0c2dfe0196af37..7983ef0bed737ce73d18eb5fe7ea6c898991da76 100644 (file)
--- a/src/doveadm/doveadm-mail-search.c
+++ b/src/doveadm/doveadm-mail-search.c
@@ -29,7 +29,7 @@ cmd_search_box(struct doveadm_mail_cmd_context *ctx,
 
        ret = 0;
        if (mailbox_get_metadata(box, MAILBOX_METADATA_GUID, &metadata) < 0) {
-               i_error("Couldn't get mailbox '%s' GUID: %s",
+               e_error(ctx->cctx->event, "Couldn't get mailbox '%s' GUID: %s",
                        mailbox_get_vname(box),
                        mailbox_get_last_internal_error(box, NULL));
                ret = -1;

diff --git a/src/doveadm/doveadm-mail-server.c b/src/doveadm/doveadm-mail-server.c
index 0b4ec1fbd1580d871bcd0b1320168a7e69e90327..3eb180b446ecbe3c2c8d7a3aad336bbe570b8170 100644 (file)
--- a/src/doveadm/doveadm-mail-server.c
+++ b/src/doveadm/doveadm-mail-server.c
@@ -432,7 +432,8 @@ static int doveadm_cmd_redirect(struct doveadm_mail_server_cmd *servercmd,
        int ret;
 
        if (!auth_proxy_parse_redirect(destination, &destuser, &host, &port)) {
-               i_error("%s: Invalid redirect destination: %s",
+               e_error(cmd_ctx->cctx->event,
+                       "%s: Invalid redirect destination: %s",
                        orig_server->name, destination);
                return -1;
        }
@@ -444,7 +445,8 @@ static int doveadm_cmd_redirect(struct doveadm_mail_server_cmd *servercmd,
                                                    destuser, &error);
        } else {
                if (net_addr2ip(host, &ip) < 0) {
-                       i_error("%s: Redirect destination host is not an IP: %s",
+                       e_error(cmd_ctx->cctx->event,
+                               "%s: Redirect destination host is not an IP: %s",
                                orig_server->name, destination);
                        return -1;
                }
@@ -453,7 +455,8 @@ static int doveadm_cmd_redirect(struct doveadm_mail_server_cmd *servercmd,
                                                  &error);
        }
        if (ret < 0) {
-               i_error("%s: %s", orig_server->name, error);
+               e_error(cmd_ctx->cctx->event,
+                       "%s: %s", orig_server->name, error);
                return -1;
        }
        return ret;
@@ -499,7 +502,8 @@ static void doveadm_cmd_callback(const struct doveadm_server_reply *reply,
        case 0:
                break;
        case DOVEADM_CLIENT_EXIT_CODE_DISCONNECTED:
-               i_error("%s: Command %s failed for %s: %s",
+               e_error(cmd_ctx->cctx->event,
+                       "%s: Command %s failed for %s: %s",
                        server->name, cmd_ctx->cmd->name, servercmd->username,
                        reply->error);
                internal_failure = TRUE;
@@ -507,7 +511,8 @@ static void doveadm_cmd_callback(const struct doveadm_server_reply *reply,
                doveadm_mail_server_cmd_free(&servercmd);
                return;
        case EX_NOUSER:
-               i_error("%s: No such user: %s", server->name,
+               e_error(cmd_ctx->cctx->event,
+                       "%s: No such user: %s", server->name,
                        servercmd->username);
                if (cmd_ctx->exit_code == 0)
                        cmd_ctx->exit_code = EX_NOUSER;
@@ -718,7 +723,8 @@ doveadm_mail_cmd_extra_fields_parse(struct doveadm_mail_cmd_context *ctx)
                if (strcmp(key, "proxy-ttl") == 0) {
                        if (str_to_int(value, &ctx->proxy_ttl) < 0 ||
                            ctx->proxy_ttl <= 0)
-                               i_error("Invalid proxy-ttl value: %s", value);
+                               e_error(ctx->cctx->event,
+                                       "Invalid proxy-ttl value: %s", value);
                } else if (strcmp(key, "forward") == 0) {
                        if (!array_is_created(&ctx->proxy_forward_fields)) {
                                p_array_init(&ctx->proxy_forward_fields,
@@ -852,7 +858,7 @@ void doveadm_mail_server_flush(void)
                if (array_count(&doveadm_server_request_queue) == 0)
                        break;
                if (doveadm_mail_server_request_queue_handle_next(&error) < 0) {
-                       i_error("%s", error);
+                       e_error(cmd_ctx->cctx->event, "%s", error);
                        break;
                }
        }
@@ -863,7 +869,7 @@ void doveadm_mail_server_flush(void)
 
        doveadm_clients_destroy_all();
        if (master_service_is_killed(master_service))
-               i_error("Aborted");
+               e_error(cmd_ctx->cctx->event, "Aborted");
        if (DOVEADM_MAIL_SERVER_FAILED())
                doveadm_mail_failed_error(cmd_ctx, MAIL_ERROR_TEMP);
 

diff --git a/src/doveadm/doveadm-mail.c b/src/doveadm/doveadm-mail.c
index 4eb1d7b1b93163849ad001ade6910e816ed17d4c..d0e43828b7309f4efd69ddd4295729820b87ed89 100644 (file)
--- a/src/doveadm/doveadm-mail.c
+++ b/src/doveadm/doveadm-mail.c
@@ -148,7 +148,8 @@ cmd_purge_run(struct doveadm_mail_cmd_context *ctx, struct mail_user *user)
 
                storage = mail_namespace_get_default_storage(ns);
                if (mail_storage_purge(storage) < 0) {
-                       i_error("Purging namespace '%s' failed: %s", ns->prefix,
+                       e_error(ctx->cctx->event,
+                               "Purging namespace '%s' failed: %s", ns->prefix,
                                mail_storage_get_last_internal_error(storage, NULL));
                        doveadm_mail_failed_storage(ctx, storage);
                        ret = -1;
@@ -177,7 +178,7 @@ static void doveadm_mail_cmd_input_input(struct doveadm_mail_cmd_context *ctx)
                return;
 
        if (ctx->cmd_input->stream_errno != 0) {
-               i_error("read(%s) failed: %s",
+               e_error(ctx->cctx->event, "read(%s) failed: %s",
                        i_stream_get_name(ctx->cmd_input),
                        i_stream_get_error(ctx->cmd_input));
        }
@@ -308,13 +309,15 @@ static int cmd_force_resync_box(struct doveadm_mail_cmd_context *_ctx,
 
        box = mailbox_alloc(info->ns->list, info->vname, flags);
        if (mailbox_open(box) < 0) {
-               i_error("Opening mailbox %s failed: %s", info->vname,
+               e_error(ctx->ctx.cctx->event,
+                       "Opening mailbox %s failed: %s", info->vname,
                        mailbox_get_last_internal_error(box, NULL));
                doveadm_mail_failed_mailbox(_ctx, box);
                ret = -1;
        } else if (mailbox_sync(box, MAILBOX_SYNC_FLAG_FORCE_RESYNC |
                                MAILBOX_SYNC_FLAG_FIX_INCONSISTENT) < 0) {
-               i_error("Forcing a resync on mailbox %s failed: %s",
+               e_error(ctx->ctx.cctx->event,
+                       "Forcing a resync on mailbox %s failed: %s",
                        info->vname, mailbox_get_last_internal_error(box, NULL));
                doveadm_mail_failed_mailbox(_ctx, box);
                ret = -1;
@@ -364,7 +367,8 @@ static int cmd_force_resync_run(struct doveadm_mail_cmd_context *_ctx,
                } T_END;
        }
        if (mailbox_list_iter_deinit(&iter) < 0) {
-               i_error("Listing mailboxes failed: %s",
+               e_error(ctx->ctx.cctx->event,
+                       "Listing mailboxes failed: %s",
                        mailbox_list_get_last_internal_error(user->namespaces->list, NULL));
                doveadm_mail_failed_list(_ctx, user->namespaces->list);
                ret = -1;
@@ -541,9 +545,10 @@ doveadm_mail_all_users(struct doveadm_mail_cmd_context *ctx,
                T_BEGIN {
                        ret = doveadm_mail_next_user(ctx, &error);
                        if (ret < 0)
-                               i_error("%s", error);
+                               e_error(ctx->cctx->event, "%s", error);
                        else if (ret == 0)
-                               i_info("User no longer exists, skipping");
+                               e_info(ctx->cctx->event,
+                                      "User no longer exists, skipping");
                } T_END;
                if (ret == -1)
                        break;
@@ -566,7 +571,7 @@ doveadm_mail_all_users(struct doveadm_mail_cmd_context *ctx,
        else
                i_set_failure_prefix("doveadm(%s): ", ip);
        if (ret < 0) {
-               i_error("Failed to iterate through some users");
+               e_error(ctx->cctx->event, "Failed to iterate through some users");
                ctx->exit_code = EX_TEMPFAIL;
        }
 }
@@ -585,7 +590,7 @@ doveadm_mail_cmd_get_next_user(struct doveadm_mail_cmd_context *ctx,
 
        *username_r = i_stream_read_next_line(ctx->users_list_input);
        if (ctx->users_list_input->stream_errno != 0) {
-               i_error("read(%s) failed: %s",
+               e_error(ctx->cctx->event, "read(%s) failed: %s",
                        i_stream_get_name(ctx->users_list_input),
                        i_stream_get_error(ctx->users_list_input));
                return -1;
@@ -662,10 +667,10 @@ doveadm_mail_cmd_exec(struct doveadm_mail_cmd_context *ctx,
                if (ret < 0) {
                        /* user lookup/init failed somehow */
                        doveadm_exit_code = EX_TEMPFAIL;
-                       i_error("%s", error);
+                       e_error(ctx->cctx->event, "%s", error);
                } else if (ret == 0) {
                        doveadm_exit_code = EX_NOUSER;
-                       i_error("User doesn't exist");
+                       e_error(ctx->cctx->event, "User doesn't exist");
                }
        } else {
                ctx->service_flags |= MAIL_STORAGE_SERVICE_FLAG_TEMP_PRIV_DROP;