lib-dict: Renamed dict_init_full() to dict_init()

src/auth/db-dict.c

@@ -268,6 +268,7 @@ db_dict_settings_parse(struct db_dict_settings *set)
 
 struct dict_connection *db_dict_init(const char *config_path)
 {
+	struct dict_settings dict_set;
 	struct dict_settings_parser_ctx ctx;
 	struct dict_connection *conn;
 	const char *error;
@@ -305,8 +306,11 @@ struct dict_connection *db_dict_init(const char *config_path)
 
 	if (conn->set.uri == NULL)
 		i_fatal("dict %s: Empty uri setting", config_path);
-	if (dict_init(conn->set.uri, DICT_DATA_TYPE_STRING, "",
-		      global_auth_settings->base_dir, &conn->dict, &error) < 0)
+
+	memset(&dict_set, 0, sizeof(dict_set));
+	dict_set.username = "";
+	dict_set.base_dir = global_auth_settings->base_dir;
+	if (dict_init(conn->set.uri, &dict_set, &conn->dict, &error) < 0)
 		i_fatal("dict %s: Failed to init dict: %s", config_path, error);
 
 	conn->next = connections;

src/dict/dict-connection.c

@@ -72,6 +72,7 @@ static int dict_connection_parse_handshake(struct dict_connection *conn,
 
 static int dict_connection_dict_init(struct dict_connection *conn)
 {
+	struct dict_settings dict_set;
 	const char *const *strlist;
 	unsigned int i, count;
 	const char *uri, *error;
@@ -89,8 +90,11 @@ static int dict_connection_dict_init(struct dict_connection *conn)
 	}
 	uri = strlist[i+1];
 
-	if (dict_init(uri, conn->value_type, conn->username,
-		      dict_settings->base_dir, &conn->dict, &error) < 0) {
+	memset(&dict_set, 0, sizeof(dict_set));
+	dict_set.value_type = conn->value_type;
+	dict_set.username = conn->username;
+	dict_set.base_dir = dict_settings->base_dir;
+	if (dict_init(uri, &dict_set, &conn->dict, &error) < 0) {
 		/* dictionary initialization failed */
 		i_error("Failed to initialize dictionary '%s': %s",
 			conn->name, error);

src/doveadm/doveadm-dict.c

@@ -16,6 +16,7 @@ cmd_dict_init_full(int *argc, char **argv[], int own_arg_count, int key_arg_idx,
 		   struct dict **dict_r)
 {
 	const char *getopt_args = iter_flags == NULL ? "u:" : "1Ru:V";
+	struct dict_settings dict_set;
 	struct dict *dict;
 	const char *dict_uri, *error, *username = "";
 	int c;
@@ -70,8 +71,10 @@ cmd_dict_init_full(int *argc, char **argv[], int own_arg_count, int key_arg_idx,
 	}
 
 	dict_drivers_register_builtin();
-	if (dict_init(dict_uri, DICT_DATA_TYPE_STRING, username,
-		      doveadm_settings->base_dir, &dict, &error) < 0) {
+	memset(&dict_set, 0, sizeof(dict_set));
+	dict_set.username = username;
+	dict_set.base_dir = doveadm_settings->base_dir;
+	if (dict_init(dict_uri, &dict_set, &dict, &error) < 0) {
 		i_error("dict_init(%s) failed: %s", dict_uri, error);
 		doveadm_exit_code = EX_TEMPFAIL;
 		return -1;

src/lib-dict/dict.c

@@ -52,21 +52,8 @@ void dict_driver_unregister(struct dict *driver)
 		array_free(&dict_drivers);
 }
 
-int dict_init(const char *uri, enum dict_data_type value_type,
-	      const char *username, const char *base_dir, struct dict **dict_r,
-	      const char **error_r)
-{
-	struct dict_settings set;
-
-	memset(&set, 0, sizeof(set));
-	set.value_type = value_type;
-	set.username = username;
-	set.base_dir = base_dir;
-	return dict_init_full(uri, &set, dict_r, error_r);
-}
-
-int dict_init_full(const char *uri, const struct dict_settings *set,
-		   struct dict **dict_r, const char **error_r)
+int dict_init(const char *uri, const struct dict_settings *set,
+	      struct dict **dict_r, const char **error_r)
 {
 	struct dict *dict;
 	const char *p, *name, *error;

src/lib-dict/dict.h

@@ -60,11 +60,8 @@ void dict_drivers_unregister_all(void);
 
 /* Open dictionary with given URI (type:data).
    Returns 0 if ok, -1 if URI is invalid. */
-int dict_init(const char *uri, enum dict_data_type value_type,
-	      const char *username, const char *base_dir, struct dict **dict_r,
-	      const char **error_r);
-int dict_init_full(const char *uri, const struct dict_settings *set,
-		   struct dict **dict_r, const char **error_r);
+int dict_init(const char *uri, const struct dict_settings *set,
+	      struct dict **dict_r, const char **error_r);
 /* Close dictionary. */
 void dict_deinit(struct dict **dict);
 /* Wait for all pending asynchronous operations to finish.

src/lib-fs/fs-dict.c

@@ -73,7 +73,7 @@ fs_dict_init(struct fs *_fs, const char *args, const struct fs_settings *set)
 	dict_set.username = set->username;
 	dict_set.base_dir = set->base_dir;
 
-	if (dict_init_full(p, &dict_set, &fs->dict, &error) < 0) {
+	if (dict_init(p, &dict_set, &fs->dict, &error) < 0) {
 		fs_set_error(_fs, "dict_init(%s) failed: %s", args, error);
 		return -1;
 	}

src/lib-storage/index/index-attribute.c

@@ -33,6 +33,7 @@ static int
 index_storage_get_user_dict(struct mail_storage *err_storage,
 			    struct mail_user *user, struct dict **dict_r)
 {
+	struct dict_settings dict_set;
 	struct mail_namespace *ns;
 	struct mail_storage *attr_storage;
 	const char *error;
@@ -61,9 +62,10 @@ index_storage_get_user_dict(struct mail_storage *err_storage,
 		return -1;
 	}
 
-	if (dict_init(attr_storage->set->mail_attribute_dict,
-		      DICT_DATA_TYPE_STRING,
-		      user->username, user->set->base_dir,
+	memset(&dict_set, 0, sizeof(dict_set));
+	dict_set.username = user->username;
+	dict_set.base_dir = user->set->base_dir;
+	if (dict_init(attr_storage->set->mail_attribute_dict, &dict_set,
 		      &user->_attr_dict, &error) < 0) {
 		mail_storage_set_critical(err_storage,
 			"mail_attribute_dict: dict_init(%s) failed: %s",
@@ -124,8 +126,8 @@ index_storage_get_dict(struct mailbox *box, enum mail_attribute_type type,
 	set.base_dir = storage->user->set->base_dir;
 	if (mail_user_get_home(storage->user, &set.home_dir) <= 0)
 		set.home_dir = NULL;
-	if (dict_init_full(storage->set->mail_attribute_dict, &set,
-			   &storage->_shared_attr_dict, &error) < 0) {
+	if (dict_init(storage->set->mail_attribute_dict, &set,
+		      &storage->_shared_attr_dict, &error) < 0) {
 		mail_storage_set_critical(storage,
 			"mail_attribute_dict: dict_init(%s) failed: %s",
 			storage->set->mail_attribute_dict, error);

src/plugins/acl/acl-lookup-dict.c

@@ -41,8 +41,12 @@ struct acl_lookup_dict *acl_lookup_dict_init(struct mail_user *user)
 
 	uri = mail_user_plugin_getenv(user, "acl_shared_dict");
 	if (uri != NULL) {
-		if (dict_init(uri, DICT_DATA_TYPE_STRING, "",
-			      user->set->base_dir, &dict->dict, &error) < 0)
+		struct dict_settings dict_set;
+
+		memset(&dict_set, 0, sizeof(dict_set));
+		dict_set.username = "";
+		dict_set.base_dir = user->set->base_dir;
+		if (dict_init(uri, &dict_set, &dict->dict, &error) < 0)
 			i_error("acl: dict_init(%s) failed: %s", uri, error);
 	} else if (user->mail_debug) {
 		i_debug("acl: No acl_shared_dict setting - "

src/plugins/expire/doveadm-expire.c

@@ -368,6 +368,7 @@ static void doveadm_expire_mail_cmd_deinit(struct doveadm_mail_cmd_context *ctx)
 static void doveadm_expire_mail_init(struct doveadm_mail_cmd_context *ctx)
 {
 	struct doveadm_expire_mail_cmd_context *ectx;
+	struct dict_settings dict_set;
 	struct dict *dict;
 	const struct expire_query *query;
 	const char *expire_dict, *username, *value, *error;
@@ -407,8 +408,11 @@ static void doveadm_expire_mail_init(struct doveadm_mail_cmd_context *ctx)
 	if (doveadm_debug)
 		i_debug("expire: Searching only users listed in expire database");
 
-	if (dict_init(expire_dict, DICT_DATA_TYPE_UINT32, "",
-		      doveadm_settings->base_dir, &dict, &error) < 0) {
+	memset(&dict_set, 0, sizeof(dict_set));
+	dict_set.value_type = DICT_DATA_TYPE_UINT32;
+	dict_set.username = "";
+	dict_set.base_dir = doveadm_settings->base_dir;
+	if (dict_init(expire_dict, &dict_set, &dict, &error) < 0) {
 		i_error("dict_init(%s) failed, not using it: %s",
 			expire_dict, error);
 		return;

src/plugins/expire/expire-plugin.c

@@ -402,6 +402,7 @@ static void expire_mail_namespaces_created(struct mail_namespace *ns)
 	struct mail_user *user = ns->user;
 	struct mail_user_vfuncs *v = user->vlast;
 	struct expire_mail_user *euser;
+	struct dict_settings dict_set;
 	struct dict *db;
 	const char *dict_uri, *error;
 
@@ -417,8 +418,11 @@ static void expire_mail_namespaces_created(struct mail_namespace *ns)
 		return;
 	}
 	/* we're using only shared dictionary, the username doesn't matter. */
-	if (dict_init(dict_uri, DICT_DATA_TYPE_UINT32, "",
-		      user->set->base_dir, &db, &error) < 0) {
+	memset(&dict_set, 0, sizeof(dict_set));
+	dict_set.value_type = DICT_DATA_TYPE_UINT32;
+	dict_set.username = "";
+	dict_set.base_dir = user->set->base_dir;
+	if (dict_init(dict_uri, &dict_set, &db, &error) < 0) {
 		i_error("expire plugin: dict_init(%s) failed: %s",
 			dict_uri, error);
 		return;

src/plugins/last-login/last-login-plugin.c

@@ -80,7 +80,7 @@ static void last_login_mail_user_created(struct mail_user *user)
 	set.base_dir = user->set->base_dir;
 	if (mail_user_get_home(user, &set.home_dir) <= 0)
 		set.home_dir = NULL;
-	if (dict_init_full(dict_value, &set, &dict, &error) < 0) {
+	if (dict_init(dict_value, &set, &dict, &error) < 0) {
 		i_error("last_login_dict: dict_init(%s) failed: %s",
 			dict_value, error);
 		return;

src/plugins/quota-clone/quota-clone-plugin.c

@@ -172,7 +172,7 @@ static void quota_clone_mail_user_created(struct mail_user *user)
 	dict_set.username = user->username;
 	dict_set.base_dir = user->set->base_dir;
 	(void)mail_user_get_home(user, &dict_set.home_dir);
-	if (dict_init_full(uri, &dict_set, &dict, &error) < 0) {
+	if (dict_init(uri, &dict_set, &dict, &error) < 0) {
 		i_error("quota_clone_dict: Failed to initialize '%s': %s",
 			uri, error);
 		return;

src/plugins/quota/quota-dict.c

@@ -89,7 +89,7 @@ static int dict_quota_init(struct quota_root *_root, const char *args,
 	set.base_dir = _root->quota->user->set->base_dir;
 	if (mail_user_get_home(_root->quota->user, &set.home_dir) <= 0)
 		set.home_dir = NULL;
-	if (dict_init_full(args, &set, &root->dict, &error) < 0) {
+	if (dict_init(args, &set, &root->dict, &error) < 0) {
 		*error_r = t_strdup_printf("dict_init(%s) failed: %s", args, error);
 		return -1;
 	}

src/plugins/quota/quota.c

@@ -734,8 +734,8 @@ int quota_set_resource(struct quota_root *root, const char *name,
 		set.base_dir = root->quota->user->set->base_dir;
 		if (mail_user_get_home(root->quota->user, &set.home_dir) <= 0)
 			set.home_dir = NULL;
-		if (dict_init_full(root->set->limit_set, &set,
-				   &root->limit_set_dict, error_r) < 0)
+		if (dict_init(root->set->limit_set, &set,
+			      &root->limit_set_dict, error_r) < 0)
 			return -1;
 	}