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

diff --git a/src/doveadm/doveadm-kick.c b/src/doveadm/doveadm-kick.c
index eebdc7c994d2c2a1c70f0e72e8ea3589d0730a0a..07fab3be936d09db838d9a71df91cf73f2489c4f 100644 (file)
--- a/src/doveadm/doveadm-kick.c
+++ b/src/doveadm/doveadm-kick.c
@@ -43,12 +43,15 @@ kick_user_anvil_callback(const char *reply, struct kick_context *ctx)
 
 static void kick_users_get_via_who(struct kick_context *ctx)
 {
+       const char *error;
+
        /* get a list of all user+sessions matching the filter */
        p_array_init(&ctx->kicks, ctx->who.pool, 64);
        struct doveadm_who_iter *iter =
                doveadm_who_iter_init(ctx->who.anvil_path);
        if (!doveadm_who_iter_init_filter(iter, &ctx->who.filter)) {
-               doveadm_who_iter_deinit(&iter);
+               if (doveadm_who_iter_deinit(&iter, &error) < 0)
+                       e_error(ctx->event, "%s", error);
                return;
        }
        struct who_line who_line;
@@ -59,8 +62,10 @@ static void kick_users_get_via_who(struct kick_context *ctx)
                session->username = p_strdup(ctx->who.pool, who_line.username);
                guid_128_copy(session->conn_guid, who_line.conn_guid);
        }
-       if (doveadm_who_iter_deinit(&iter) < 0)
+       if (doveadm_who_iter_deinit(&iter, &error) < 0) {
                doveadm_exit_code = EX_TEMPFAIL;
+               e_error(ctx->event, "%s", error);
+       }
 }
 
 static void kick_users_via_anvil(struct kick_context *ctx)

diff --git a/src/doveadm/doveadm-who.c b/src/doveadm/doveadm-who.c
index 36af858d6da565d9cf5b237525c6180aa6441575..2fbef7bb94f436630535aac098e76a80d4fbb8b7 100644 (file)
--- a/src/doveadm/doveadm-who.c
+++ b/src/doveadm/doveadm-who.c
@@ -30,8 +30,7 @@ struct doveadm_who_iter {
 
        unsigned int alt_username_fields_count;
        const char **alt_username_fields;
-
-       bool failed;
+       const char *error;
 };
 
 static void who_user_ip(const struct who_user *user, struct ip_addr *ip_r)
@@ -166,7 +165,8 @@ who_parse_masks(struct who_context *ctx, const char *const *masks)
                if (!str_is_numeric(masks[i], '\0') &&
                    net_parse_range(masks[i], &net_ip, &net_bits) == 0) {
                        if (ctx->filter.net_bits != 0) {
-                               i_error("Multiple network masks not supported");
+                               e_error(ctx->event,
+                                       "Multiple network masks not supported");
                                doveadm_exit_code = EX_USAGE;
                                return -1;
                        }
@@ -174,7 +174,8 @@ who_parse_masks(struct who_context *ctx, const char *const *masks)
                        ctx->filter.net_bits = net_bits;
                } else {
                        if (ctx->filter.username != NULL) {
-                               i_error("Multiple username masks not supported");
+                               e_error(ctx->event,
+                                       "Multiple username masks not supported");
                                doveadm_exit_code = EX_USAGE;
                                return -1;
                        }
@@ -195,7 +196,8 @@ int who_parse_args(struct who_context *ctx, const char *alt_username_field,
                        return -1;
        }
        if (alt_username_field != NULL && ctx->filter.username == NULL) {
-               i_error("Username must be given with passdb-field parameter");
+               e_error(ctx->event,
+                       "Username must be given with passdb-field parameter");
                doveadm_exit_code = EX_USAGE;
                return -1;
        }
@@ -221,23 +223,23 @@ struct doveadm_who_iter *doveadm_who_iter_init(const char *anvil_path)
        fd = doveadm_connect(anvil_path);
        net_set_nonblock(fd, FALSE);
        if (write(fd, ANVIL_CMD, strlen(ANVIL_CMD)) < 0) {
-               i_error("write(%s) failed: %m", anvil_path);
+               iter->error = p_strdup_printf(iter->pool,
+                                             "write(%s) failed: %m", anvil_path);
                i_close_fd(&fd);
-               iter->failed = TRUE;
                return iter;
        }
 
        iter->input = i_stream_create_fd_autoclose(&fd, SIZE_MAX);
        i_stream_set_name(iter->input, anvil_path);
        if ((line = i_stream_read_next_line(iter->input)) == NULL) {
-               i_error("anvil didn't send VERSION line");
-               iter->failed = TRUE;
+               iter->error = p_strdup_printf(iter->pool,
+                                             "anvil didn't send VERSION line");
        } else if (!version_string_verify(line, "anvil-server", 2)) {
-               i_error("Invalid VERSION line: %s", line);
-               iter->failed = TRUE;
+               iter->error = p_strdup_printf(iter->pool,
+                                             "Invalid VERSION line: %s", line);
        } else if ((line = i_stream_read_next_line(iter->input)) == NULL) {
-               i_error("anvil didn't send header line");
-               iter->failed = TRUE;
+               iter->error = p_strdup_printf(iter->pool,
+                                             "anvil didn't send header line");
        } else {
                iter->alt_username_fields =
                        (const char **)p_strsplit_tabescaped(iter->pool, line);
@@ -269,7 +271,7 @@ bool doveadm_who_iter_next(struct doveadm_who_iter *iter,
        const char *line;
        int ret;
 
-       if (iter->failed)
+       if (iter->error != NULL)
                return FALSE;
 
        if ((line = i_stream_read_next_line(iter->input)) != NULL) {
@@ -279,29 +281,33 @@ bool doveadm_who_iter_next(struct doveadm_who_iter *iter,
                        ret = who_parse_line(iter, line, who_line_r);
                } T_END;
                if (ret < 0) {
-                       i_error("Invalid input: %s", line);
-                       iter->failed = TRUE;
+                       iter->error = p_strdup_printf(iter->pool,
+                                                     "Invalid input: %s", line);
                        return FALSE;
                }
                return TRUE;
        }
        if (iter->input->stream_errno != 0) {
-               i_error("read(%s) failed: %s", i_stream_get_name(iter->input),
+               iter->error = p_strdup_printf(iter->pool,
+                       "read(%s) failed: %s", i_stream_get_name(iter->input),
                        i_stream_get_error(iter->input));
        } else {
-               i_error("read(%s) failed: Unexpected EOF",
+               iter->error = p_strdup_printf(iter->pool,
+                       "read(%s) failed: Unexpected EOF",
                        i_stream_get_name(iter->input));
        }
-       iter->failed = TRUE;
        return FALSE;
 }
 
-int doveadm_who_iter_deinit(struct doveadm_who_iter **_iter)
+int doveadm_who_iter_deinit(struct doveadm_who_iter **_iter,
+                           const char **error_r)
 {
        struct doveadm_who_iter *iter = *_iter;
-       bool failed = iter->failed;
-
        *_iter = NULL;
+
+       bool failed = iter->error != NULL;
+       if (failed)
+               *error_r = t_strdup(iter->error);
        i_stream_destroy(&iter->input);
        pool_unref(&iter->line_pool);
        pool_unref(&iter->pool);
@@ -453,6 +459,7 @@ static void cmd_who(struct doveadm_cmd_context *cctx)
        (void)doveadm_cmd_param_bool(cctx, "separate-connections", &separate_connections);
 
        ctx.pool = pool_alloconly_create("who users", 10240);
+       ctx.event = cctx->event;
        hash_table_create(&ctx.users, ctx.pool, 0, who_user_hash, who_user_cmp);
 
        if (doveadm_cmd_param_array(cctx, "mask", &masks)) {
@@ -484,8 +491,11 @@ static void cmd_who(struct doveadm_cmd_context *cctx)
                                who_print_line(&ctx, iter, &who_line);
                }
        }
-       if (doveadm_who_iter_deinit(&iter) < 0)
+       const char *error;
+       if (doveadm_who_iter_deinit(&iter, &error) < 0) {
+               e_error(cctx->event, "%s", error);
                doveadm_exit_code = EX_TEMPFAIL;
+       }
 
        hash_table_destroy(&ctx.users);
        pool_unref(&ctx.pool);

diff --git a/src/doveadm/doveadm-who.h b/src/doveadm/doveadm-who.h
index 429a39ca8cfba42b157c689373fa57cb900049b4..403b4abb736e6c8ee9576b89f3278ad55d695f76 100644 (file)
--- a/src/doveadm/doveadm-who.h
+++ b/src/doveadm/doveadm-who.h
@@ -31,6 +31,7 @@ struct who_context {
        struct who_filter filter;
 
        pool_t pool;
+       struct event *event;
        HASH_TABLE(struct who_user *, struct who_user *) users;
 };
 
@@ -49,6 +50,7 @@ bool doveadm_who_iter_init_filter(struct doveadm_who_iter *iter,
                                  struct who_filter *filter);
 bool doveadm_who_iter_next(struct doveadm_who_iter *iter,
                           struct who_line *who_line_r);
-int doveadm_who_iter_deinit(struct doveadm_who_iter **_iter);
+int doveadm_who_iter_deinit(struct doveadm_who_iter **_iter,
+                           const char **error_r);
 
 #endif /* DOVEADM_WHO_H */