"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "src/doveadm/doveadm-dict.c" between
dovecot-2.3.16.tar.gz and dovecot-2.3.17.tar.gz

About: Dovecot is an IMAP and POP3 server, written with security primarily in mind.

[ To the main dovecot source changes report ]

doveadm-dict.c  (dovecot-2.3.16):doveadm-dict.c  (dovecot-2.3.17)
skipping to change at line 14 skipping to change at line 14
#include "dict.h" #include "dict.h"
#include "doveadm.h" #include "doveadm.h"
#include "doveadm-print.h" #include "doveadm-print.h"
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>
static int static int
cmd_dict_init_full(struct doveadm_cmd_context *cctx, cmd_dict_init_full(struct doveadm_cmd_context *cctx,
doveadm_command_ver2_t *cmd ATTR_UNUSED, enum dict_iterate_fla gs *iter_flags, doveadm_command_ver2_t *cmd ATTR_UNUSED, enum dict_iterate_fla gs *iter_flags,
struct dict **dict_r) struct dict **dict_r, struct dict_op_settings *dopset_r)
{ {
struct dict_settings dict_set; struct dict_settings dict_set;
struct dict *dict; struct dict *dict;
bool set = FALSE; bool set = FALSE;
const char *dict_uri, *error, *key, *username = ""; const char *dict_uri, *error, *key, *username = "";
i_zero(dopset_r);
if (doveadm_cmd_param_bool(cctx, "exact", &set) && set) if (doveadm_cmd_param_bool(cctx, "exact", &set) && set)
*iter_flags |= DICT_ITERATE_FLAG_EXACT_KEY; *iter_flags |= DICT_ITERATE_FLAG_EXACT_KEY;
if (doveadm_cmd_param_bool(cctx, "recurse", &set) && set) if (doveadm_cmd_param_bool(cctx, "recurse", &set) && set)
*iter_flags |= DICT_ITERATE_FLAG_RECURSE; *iter_flags |= DICT_ITERATE_FLAG_RECURSE;
if (doveadm_cmd_param_bool(cctx, "no-value", &set) && set) if (doveadm_cmd_param_bool(cctx, "no-value", &set) && set)
*iter_flags |= DICT_ITERATE_FLAG_NO_VALUE; *iter_flags |= DICT_ITERATE_FLAG_NO_VALUE;
(void)doveadm_cmd_param_str(cctx, "user", &username); (void)doveadm_cmd_param_str(cctx, "user", &username);
dopset_r->username = username;
if (!doveadm_cmd_param_str(cctx, "dict-uri", &dict_uri)) { if (!doveadm_cmd_param_str(cctx, "dict-uri", &dict_uri)) {
i_error("dictionary URI must be specified"); i_error("dictionary URI must be specified");
doveadm_exit_code = EX_USAGE; doveadm_exit_code = EX_USAGE;
return -1; return -1;
} }
if (!doveadm_cmd_param_str(cctx, "prefix", &key) && if (!doveadm_cmd_param_str(cctx, "prefix", &key) &&
!doveadm_cmd_param_str(cctx, "key", &key)) !doveadm_cmd_param_str(cctx, "key", &key))
key = ""; key = "";
skipping to change at line 55 skipping to change at line 57
} }
if (username[0] == '\0' && if (username[0] == '\0' &&
str_begins(key, DICT_PATH_PRIVATE)) { str_begins(key, DICT_PATH_PRIVATE)) {
i_error("-u must be specified for "DICT_PATH_PRIVATE" keys"); i_error("-u must be specified for "DICT_PATH_PRIVATE" keys");
doveadm_exit_code = EX_USAGE; doveadm_exit_code = EX_USAGE;
return -1; return -1;
} }
dict_drivers_register_builtin(); dict_drivers_register_builtin();
i_zero(&dict_set); i_zero(&dict_set);
dict_set.username = username;
dict_set.base_dir = doveadm_settings->base_dir; dict_set.base_dir = doveadm_settings->base_dir;
if (dict_init(dict_uri, &dict_set, &dict, &error) < 0) { if (dict_init(dict_uri, &dict_set, &dict, &error) < 0) {
i_error("dict_init(%s) failed: %s", dict_uri, error); i_error("dict_init(%s) failed: %s", dict_uri, error);
doveadm_exit_code = EX_TEMPFAIL; doveadm_exit_code = EX_TEMPFAIL;
return -1; return -1;
} }
*dict_r = dict; *dict_r = dict;
return 0; return 0;
} }
static int static int
cmd_dict_init(struct doveadm_cmd_context *cctx, cmd_dict_init(struct doveadm_cmd_context *cctx,
doveadm_command_ver2_t *cmd, struct dict **dict_r) doveadm_command_ver2_t *cmd, struct dict **dict_r,
struct dict_op_settings *set_r)
{ {
enum dict_iterate_flags iter_flags = 0; enum dict_iterate_flags iter_flags = 0;
return cmd_dict_init_full(cctx, cmd, &iter_flags, dict_r); return cmd_dict_init_full(cctx, cmd, &iter_flags, dict_r, set_r);
} }
struct doveadm_dict_ctx { struct doveadm_dict_ctx {
pool_t pool; pool_t pool;
int ret; int ret;
const char *const *values; const char *const *values;
const char *error; const char *error;
}; };
static void dict_lookup_callback(const struct dict_lookup_result *result, static void dict_lookup_callback(const struct dict_lookup_result *result,
skipping to change at line 95 skipping to change at line 97
ctx->values = result->values == NULL ? NULL : ctx->values = result->values == NULL ? NULL :
p_strarray_dup(ctx->pool, result->values); p_strarray_dup(ctx->pool, result->values);
ctx->error = p_strdup(ctx->pool, result->error); ctx->error = p_strdup(ctx->pool, result->error);
} }
static void cmd_dict_get(struct doveadm_cmd_context *cctx) static void cmd_dict_get(struct doveadm_cmd_context *cctx)
{ {
struct doveadm_dict_ctx ctx; struct doveadm_dict_ctx ctx;
struct dict *dict; struct dict *dict;
const char *key; const char *key;
struct dict_op_settings set;
if (!doveadm_cmd_param_str(cctx, "key", &key)) { if (!doveadm_cmd_param_str(cctx, "key", &key)) {
i_error("dict-get: Missing key"); i_error("dict-get: Missing key");
doveadm_exit_code = EX_USAGE; doveadm_exit_code = EX_USAGE;
return; return;
} }
if (cmd_dict_init(cctx, cmd_dict_get, &dict) < 0) if (cmd_dict_init(cctx, cmd_dict_get, &dict, &set) < 0)
return; return;
doveadm_print_init(DOVEADM_PRINT_TYPE_TABLE); doveadm_print_init(DOVEADM_PRINT_TYPE_TABLE);
doveadm_print_header("value", "", DOVEADM_PRINT_HEADER_FLAG_HIDE_TITLE); doveadm_print_header("value", "", DOVEADM_PRINT_HEADER_FLAG_HIDE_TITLE);
i_zero(&ctx); i_zero(&ctx);
ctx.pool = pool_alloconly_create("doveadm dict lookup", 512); ctx.pool = pool_alloconly_create("doveadm dict lookup", 512);
ctx.ret = -2; ctx.ret = -2;
dict_lookup_async(dict, key, dict_lookup_callback, &ctx); dict_lookup_async(dict, &set, key, dict_lookup_callback, &ctx);
while (ctx.ret == -2) while (ctx.ret == -2)
dict_wait(dict); dict_wait(dict);
if (ctx.ret < 0) { if (ctx.ret < 0) {
i_error("dict_lookup(%s) failed: %s", key, ctx.error); i_error("dict_lookup(%s) failed: %s", key, ctx.error);
doveadm_exit_code = EX_TEMPFAIL; doveadm_exit_code = EX_TEMPFAIL;
} else if (ctx.ret == 0) { } else if (ctx.ret == 0) {
i_error("%s doesn't exist", key); i_error("%s doesn't exist", key);
doveadm_exit_code = DOVEADM_EX_NOTFOUND; doveadm_exit_code = DOVEADM_EX_NOTFOUND;
} else { } else {
unsigned int i, values_count = str_array_length(ctx.values); unsigned int i, values_count = str_array_length(ctx.values);
skipping to change at line 138 skipping to change at line 141
pool_unref(&ctx.pool); pool_unref(&ctx.pool);
dict_deinit(&dict); dict_deinit(&dict);
} }
static void cmd_dict_set(struct doveadm_cmd_context *cctx) static void cmd_dict_set(struct doveadm_cmd_context *cctx)
{ {
struct dict *dict; struct dict *dict;
struct dict_transaction_context *trans; struct dict_transaction_context *trans;
const char *error; const char *error;
const char *key, *value = ""; const char *key, *value = "";
struct dict_op_settings set;
if (!doveadm_cmd_param_str(cctx, "key", &key) || if (!doveadm_cmd_param_str(cctx, "key", &key) ||
!doveadm_cmd_param_str(cctx, "value", &value)) { !doveadm_cmd_param_str(cctx, "value", &value)) {
i_error("dict set: Missing parameters"); i_error("dict set: Missing parameters");
doveadm_exit_code = EX_USAGE; doveadm_exit_code = EX_USAGE;
return; return;
} }
if (cmd_dict_init(cctx, cmd_dict_set, &dict) < 0) if (cmd_dict_init(cctx, cmd_dict_set, &dict, &set) < 0)
return; return;
trans = dict_transaction_begin(dict); trans = dict_transaction_begin(dict, &set);
dict_set(trans, key, value); dict_set(trans, key, value);
if (dict_transaction_commit(&trans, &error) <= 0) { if (dict_transaction_commit(&trans, &error) <= 0) {
i_error("dict_transaction_commit() failed: %s", error); i_error("dict_transaction_commit() failed: %s", error);
doveadm_exit_code = EX_TEMPFAIL; doveadm_exit_code = EX_TEMPFAIL;
} }
dict_deinit(&dict); dict_deinit(&dict);
} }
static void cmd_dict_unset(struct doveadm_cmd_context *cctx) static void cmd_dict_unset(struct doveadm_cmd_context *cctx)
{ {
struct dict *dict; struct dict *dict;
struct dict_transaction_context *trans; struct dict_transaction_context *trans;
const char *error; const char *error;
const char *key; const char *key;
struct dict_op_settings set;
if (!doveadm_cmd_param_str(cctx, "key", &key)) { if (!doveadm_cmd_param_str(cctx, "key", &key)) {
i_error("dict unset: Missing key"); i_error("dict unset: Missing key");
doveadm_exit_code = EX_USAGE; doveadm_exit_code = EX_USAGE;
return; return;
} }
if (cmd_dict_init(cctx, cmd_dict_unset, &dict) < 0) if (cmd_dict_init(cctx, cmd_dict_unset, &dict, &set) < 0)
return; return;
trans = dict_transaction_begin(dict); trans = dict_transaction_begin(dict, &set);
dict_unset(trans, key); dict_unset(trans, key);
if (dict_transaction_commit(&trans, &error) <= 0) { if (dict_transaction_commit(&trans, &error) <= 0) {
i_error("dict_transaction_commit() failed: %s", error); i_error("dict_transaction_commit() failed: %s", error);
doveadm_exit_code = EX_TEMPFAIL; doveadm_exit_code = EX_TEMPFAIL;
} }
dict_deinit(&dict); dict_deinit(&dict);
} }
static void cmd_dict_inc(struct doveadm_cmd_context *cctx) static void cmd_dict_inc(struct doveadm_cmd_context *cctx)
{ {
struct dict *dict; struct dict *dict;
struct dict_transaction_context *trans; struct dict_transaction_context *trans;
const char *error; const char *error;
const char *key; const char *key;
int64_t diff; int64_t diff;
int ret; int ret;
struct dict_op_settings set;
if (!doveadm_cmd_param_str(cctx, "key", &key) || if (!doveadm_cmd_param_str(cctx, "key", &key) ||
!doveadm_cmd_param_int64(cctx, "difference", &diff)) { !doveadm_cmd_param_int64(cctx, "difference", &diff)) {
i_error("dict-inc: Missing parameters"); i_error("dict-inc: Missing parameters");
doveadm_exit_code = EX_USAGE; doveadm_exit_code = EX_USAGE;
return; return;
} }
if (cmd_dict_init(cctx, cmd_dict_inc, &dict) < 0) if (cmd_dict_init(cctx, cmd_dict_inc, &dict, &set) < 0)
return; return;
trans = dict_transaction_begin(dict); trans = dict_transaction_begin(dict, &set);
dict_atomic_inc(trans, key, diff); dict_atomic_inc(trans, key, diff);
ret = dict_transaction_commit(&trans, &error); ret = dict_transaction_commit(&trans, &error);
if (ret < 0) { if (ret < 0) {
i_error("dict_transaction_commit() failed: %s", error); i_error("dict_transaction_commit() failed: %s", error);
doveadm_exit_code = EX_TEMPFAIL; doveadm_exit_code = EX_TEMPFAIL;
} else if (ret == 0) { } else if (ret == 0) {
i_error("%s doesn't exist", key); i_error("%s doesn't exist", key);
doveadm_exit_code = DOVEADM_EX_NOTFOUND; doveadm_exit_code = DOVEADM_EX_NOTFOUND;
} }
dict_deinit(&dict); dict_deinit(&dict);
} }
static void cmd_dict_iter(struct doveadm_cmd_context *cctx) static void cmd_dict_iter(struct doveadm_cmd_context *cctx)
{ {
struct dict *dict; struct dict *dict;
struct dict_iterate_context *iter; struct dict_iterate_context *iter;
enum dict_iterate_flags iter_flags = 0; enum dict_iterate_flags iter_flags = 0;
const char *prefix, *key, *const *values, *error; const char *prefix, *key, *const *values, *error;
bool header_printed = FALSE; bool header_printed = FALSE;
struct dict_op_settings set;
if (!doveadm_cmd_param_str(cctx, "prefix", &prefix)) { if (!doveadm_cmd_param_str(cctx, "prefix", &prefix)) {
i_error("dict-iter: Missing prefix"); i_error("dict-iter: Missing prefix");
doveadm_exit_code = EX_USAGE; doveadm_exit_code = EX_USAGE;
return; return;
} }
if (cmd_dict_init_full(cctx, cmd_dict_iter, &iter_flags, &dict) < 0) if (cmd_dict_init_full(cctx, cmd_dict_iter, &iter_flags, &dict, &set) < 0 )
return; return;
doveadm_print_init(DOVEADM_PRINT_TYPE_TAB); doveadm_print_init(DOVEADM_PRINT_TYPE_TAB);
doveadm_print_header_simple("key"); doveadm_print_header_simple("key");
if ((iter_flags & DICT_ITERATE_FLAG_NO_VALUE) == 0) if ((iter_flags & DICT_ITERATE_FLAG_NO_VALUE) == 0)
doveadm_print_header_simple("value"); doveadm_print_header_simple("value");
iter = dict_iterate_init(dict, prefix, iter_flags); iter = dict_iterate_init(dict, &set, prefix, iter_flags);
while (dict_iterate_values(iter, &key, &values)) { while (dict_iterate_values(iter, &key, &values)) {
unsigned int values_count = str_array_length(values); unsigned int values_count = str_array_length(values);
if (!header_printed) { if (!header_printed) {
for (unsigned int i = 1; i < values_count; i++) for (unsigned int i = 1; i < values_count; i++)
doveadm_print_header_simple("value"); doveadm_print_header_simple("value");
header_printed = TRUE; header_printed = TRUE;
} }
doveadm_print(key); doveadm_print(key);
if ((iter_flags & DICT_ITERATE_FLAG_NO_VALUE) == 0) { if ((iter_flags & DICT_ITERATE_FLAG_NO_VALUE) == 0) {
for (unsigned int i = 0; i < values_count; i++) for (unsigned int i = 0; i < values_count; i++)
 End of changes. 21 change blocks. 
14 lines changed or deleted 21 lines changed or added
To the C Programs section of the dovecot source changes report or the top of this page
Mainly generated by pkgdiff using rfcdiff
Home  |  About  |  Features  |  All  |  Newest  |  Dox  |  Diffs  |  RSS Feeds  |  Screenshots  |  Comments  |  Imprint  |  Privacy  |  HTTP(S)