lib-fs, global: Rename fs_settings to fs_parameters

These are internal parameters. A later commit will add back fs_settings
where the settings are coming from config file.

diff --git a/src/doveadm/doveadm-fs.c b/src/doveadm/doveadm-fs.c
index 7754d77157cd8565327e869df3a5c85b26230823..c5602c6fb388036567bc85c9b39cb0869709e178 100644 (file)
--- a/src/doveadm/doveadm-fs.c
+++ b/src/doveadm/doveadm-fs.c
@@ -23,7 +23,7 @@ static void cmd_fs_delete(struct doveadm_cmd_context *cctx);
 static struct fs *
 cmd_fs_init(struct doveadm_cmd_context *cctx)
 {
-       struct fs_settings fs_set;
+       struct fs_parameters fs_param;
        struct fs *fs;
        const char *fs_driver, *fs_args, *error;
 
@@ -31,11 +31,12 @@ cmd_fs_init(struct doveadm_cmd_context *cctx)
            !doveadm_cmd_param_str(cctx, "fs-args", &fs_args))
                fs_cmd_help(cctx);
 
-       i_zero(&fs_set);
-       fs_set.temp_dir = doveadm_settings->mail_temp_dir;
-       fs_set.base_dir = doveadm_settings->base_dir;
+       i_zero(&fs_param);
+       fs_param.temp_dir = doveadm_settings->mail_temp_dir;
+       fs_param.base_dir = doveadm_settings->base_dir;
 
-       if (fs_init(fs_driver, fs_args, cctx->event, &fs_set, &fs, &error) < 0)
+       if (fs_init(fs_driver, fs_args, cctx->event, &fs_param,
+                   &fs, &error) < 0)
                i_fatal("fs_init() failed: %s", error);
        return fs;
 }

diff --git a/src/lib-dict-extra/dict-fs.c b/src/lib-dict-extra/dict-fs.c
index 80737b398bc69055d7d2f1e398cdf620447ae3b1..9018ea54d1f5914fcfb2d6eba96962e5ebc6158d 100644 (file)
--- a/src/lib-dict-extra/dict-fs.c
+++ b/src/lib-dict-extra/dict-fs.c
@@ -29,7 +29,7 @@ fs_dict_init_legacy(struct dict *driver, const char *uri,
                    const struct dict_legacy_settings *set,
                    struct dict **dict_r, const char **error_r)
 {
-       struct fs_settings fs_set;
+       struct fs_parameters fs_param;
        struct fs *fs;
        struct fs_dict *dict;
        const char *p, *fs_driver, *fs_args;
@@ -43,9 +43,9 @@ fs_dict_init_legacy(struct dict *driver, const char *uri,
                fs_args = p+1;
        }
 
-       i_zero(&fs_set);
-       fs_set.base_dir = set->base_dir;
-       if (fs_init(fs_driver, fs_args, set->event_parent, &fs_set,
+       i_zero(&fs_param);
+       fs_param.base_dir = set->base_dir;
+       if (fs_init(fs_driver, fs_args, set->event_parent, &fs_param,
                    &fs, error_r) < 0)
                return -1;
 

diff --git a/src/lib-fs/fs-api-private.h b/src/lib-fs/fs-api-private.h
index 6c1fc00777ddb6c9fffd16d76a7a2b38c8d90695..add6c9a4a81eab5bdabe22c5fe4e1fa47d8bb4d7 100644 (file)
--- a/src/lib-fs/fs-api-private.h
+++ b/src/lib-fs/fs-api-private.h
@@ -28,7 +28,8 @@ extern struct fs_api_module_register fs_api_module_register;
 struct fs_vfuncs {
        struct fs *(*alloc)(void);
        int (*init)(struct fs *fs, const char *args,
-                   struct event *event_parent, const struct fs_settings *set,
+                   struct event *event_parent,
+                   const struct fs_parameters *params,
                    const char **error_r);
        void (*deinit)(struct fs *fs);
        void (*free)(struct fs *fs);

diff --git a/src/lib-fs/fs-api.c b/src/lib-fs/fs-api.c
index 4fcc4e40588b50c945cae4c4822686f1c29c9405..5ad714ff86f5e69c2c9ca9b5ea4d0146d94d8848 100644 (file)
--- a/src/lib-fs/fs-api.c
+++ b/src/lib-fs/fs-api.c
@@ -38,7 +38,7 @@ static struct event *fs_create_event(struct fs *fs, struct event *parent)
 
 static int
 fs_alloc(const struct fs *fs_class, const char *args,
-        struct event *event_parent, const struct fs_settings *set,
+        struct event *event_parent, const struct fs_parameters *params,
         struct fs **fs_r, const char **error_r)
 {
        struct fs *fs;
@@ -47,20 +47,20 @@ fs_alloc(const struct fs *fs_class, const char *args,
 
        fs = fs_class->v.alloc();
        fs->refcount = 1;
-       fs->enable_timing = set->enable_timing;
+       fs->enable_timing = params->enable_timing;
        i_array_init(&fs->module_contexts, 5);
        fs->event = fs_create_event(fs, event_parent);
 
        T_BEGIN {
-               ret = fs_class->v.init(fs, args, event_parent, set, &error);
+               ret = fs_class->v.init(fs, args, event_parent, params, &error);
        } T_END_PASS_STR_IF(ret < 0, &error);
        if (ret < 0) {
                *error_r = t_strdup_printf("%s: %s", fs_class->name, error);
                fs_unref(&fs);
                return -1;
        }
-       fs->username = i_strdup(set->username);
-       fs->session_id = i_strdup(set->session_id);
+       fs->username = i_strdup(params->username);
+       fs->session_id = i_strdup(params->session_id);
        *fs_r = fs;
        return 0;
 }
@@ -143,7 +143,7 @@ static void fs_class_try_load_plugin(const char *driver)
 }
 
 int fs_init(const char *driver, const char *args,
-           struct event *event_parent, const struct fs_settings *set,
+           struct event *event_parent, const struct fs_parameters *params,
            struct fs **fs_r, const char **error_r)
 {
        const struct fs *fs_class;
@@ -160,17 +160,17 @@ int fs_init(const char *driver, const char *args,
                *error_r = t_strdup_printf("Unknown fs driver: %s", driver);
                return -1;
        }
-       if (fs_alloc(fs_class, args, event_parent, set, fs_r, error_r) < 0)
+       if (fs_alloc(fs_class, args, event_parent, params, fs_r, error_r) < 0)
                return -1;
        event_set_ptr((*fs_r)->event, FS_EVENT_FIELD_FS, *fs_r);
 
-       temp_file_prefix = set->temp_file_prefix != NULL ?
-               set->temp_file_prefix : ".temp.dovecot";
-       if(set->temp_dir == NULL)
+       temp_file_prefix = params->temp_file_prefix != NULL ?
+               params->temp_file_prefix : ".temp.dovecot";
+       if(params->temp_dir == NULL)
                (*fs_r)->temp_path_prefix = i_strconcat("/tmp/",
                                                temp_file_prefix, NULL);
        else
-               (*fs_r)->temp_path_prefix = i_strconcat(set->temp_dir, "/",
+               (*fs_r)->temp_path_prefix = i_strconcat(params->temp_dir, "/",
                                                temp_file_prefix, NULL);
        return 0;
 }

diff --git a/src/lib-fs/fs-api.h b/src/lib-fs/fs-api.h
index 6166c9c56c52e56704ae0bfe2e40296f3b171750..842a2bf96de9f7f64a0d0ef913447402e3e29064 100644 (file)
--- a/src/lib-fs/fs-api.h
+++ b/src/lib-fs/fs-api.h
@@ -123,7 +123,7 @@ enum fs_op {
        FS_OP_COUNT
 };
 
-struct fs_settings {
+struct fs_parameters {
        /* Username and session ID are mainly used for debugging/logging,
           but may also be useful for other purposes if they exist (they
           may be NULL). */
@@ -186,7 +186,7 @@ struct fs_stats {
        uint64_t write_bytes;
 
        /* Cumulative sum of usecs spent on calls - set only if
-          fs_settings.enable_timing=TRUE */
+          fs_parameters.enable_timing=TRUE */
        struct stats_dist *timings[FS_OP_COUNT];
 };
 
@@ -200,7 +200,7 @@ typedef void fs_file_async_callback_t(void *context);
 
 /* event_parent can be overridden by fs_file_init_with_event() */
 int fs_init(const char *driver, const char *args,
-           struct event *event_parent, const struct fs_settings *set,
+           struct event *event_parent, const struct fs_parameters *params,
            struct fs **fs_r, const char **error_r);
 /* same as fs_unref() */
 void fs_deinit(struct fs **fs);

diff --git a/src/lib-fs/fs-dict.c b/src/lib-fs/fs-dict.c
index 368194e508d9e38026427fd6eb196d1a0c479f2f..e2a2735dd569ffe7b8f1bc93519c979f13f23297 100644 (file)
--- a/src/lib-fs/fs-dict.c
+++ b/src/lib-fs/fs-dict.c
@@ -47,7 +47,7 @@ static struct fs *fs_dict_alloc(void)
 
 static int
 fs_dict_init(struct fs *_fs, const char *args, struct event *event_parent,
-            const struct fs_settings *set, const char **error_r)
+            const struct fs_parameters *params, const char **error_r)
 {
        struct dict_fs *fs = (struct dict_fs *)_fs;
        struct dict_legacy_settings dict_set;
@@ -72,7 +72,7 @@ fs_dict_init(struct fs *_fs, const char *args, struct event *event_parent,
        }
 
        i_zero(&dict_set);
-       dict_set.base_dir = set->base_dir;
+       dict_set.base_dir = params->base_dir;
        dict_set.event_parent = event_parent;
 
        if (dict_init_legacy(p, &dict_set, &fs->dict, &error) < 0) {

diff --git a/src/lib-fs/fs-metawrap.c b/src/lib-fs/fs-metawrap.c
index 64b2d1961800d0fcf8dcd41d088ba66582a20bce..2a2a66d0b36ebb5d168b17bd88925c153420b40b 100644 (file)
--- a/src/lib-fs/fs-metawrap.c
+++ b/src/lib-fs/fs-metawrap.c
@@ -47,7 +47,7 @@ static struct fs *fs_metawrap_alloc(void)
 
 static int
 fs_metawrap_init(struct fs *_fs, const char *args,
-                struct event *event_parent, const struct fs_settings *set,
+                struct event *event_parent, const struct fs_parameters *params,
                 const char **error_r)
 {
        struct metawrap_fs *fs = METAWRAP_FS(_fs);
@@ -66,7 +66,7 @@ fs_metawrap_init(struct fs *_fs, const char *args,
                parent_name = t_strdup_until(args, parent_args);
                parent_args++;
        }
-       if (fs_init(parent_name, parent_args, event_parent, set,
+       if (fs_init(parent_name, parent_args, event_parent, params,
                    &_fs->parent, error_r) < 0)
                return -1;
        if ((fs_get_properties(_fs->parent) & FS_PROPERTY_METADATA) == 0)

diff --git a/src/lib-fs/fs-posix.c b/src/lib-fs/fs-posix.c
index 78e640833d5e401aa1e1009e9b2e95d31635efd1..0cfe01f6172abc31f36cc206209f157174432444 100644 (file)
--- a/src/lib-fs/fs-posix.c
+++ b/src/lib-fs/fs-posix.c
@@ -78,15 +78,15 @@ static struct fs *fs_posix_alloc(void)
 static int
 fs_posix_init(struct fs *_fs, const char *args,
              struct event *event_parent ATTR_UNUSED,
-             const struct fs_settings *set, const char **error_r)
+             const struct fs_parameters *params, const char **error_r)
 {
        struct posix_fs *fs = container_of(_fs, struct posix_fs, fs);
        const char *value, *const *tmp;
 
-       fs->temp_file_prefix = set->temp_file_prefix != NULL ?
-               i_strdup(set->temp_file_prefix) : i_strdup("temp.dovecot.");
+       fs->temp_file_prefix = params->temp_file_prefix != NULL ?
+               i_strdup(params->temp_file_prefix) : i_strdup("temp.dovecot.");
        fs->temp_file_prefix_len = strlen(fs->temp_file_prefix);
-       fs->root_path = i_strdup(set->root_path);
+       fs->root_path = i_strdup(params->root_path);
 
        fs->lock_method = FS_POSIX_LOCK_METHOD_FLOCK;
        fs->mode = FS_DEFAULT_MODE;

diff --git a/src/lib-fs/fs-randomfail.c b/src/lib-fs/fs-randomfail.c
index 3f134445694e45e16a5bafa5da88073ffeb98a64..16a9e9b5e7eb4b2be0e7574eb9dd4745765cc76d 100644 (file)
--- a/src/lib-fs/fs-randomfail.c
+++ b/src/lib-fs/fs-randomfail.c
@@ -163,9 +163,8 @@ static int fs_randomfail_parse_params(struct randomfail_fs *fs,
 }
 
 static int
-fs_randomfail_init(struct fs *_fs, const char *args,
-                  struct event *event_parent, const struct fs_settings *set,
-                  const char **error_r)
+fs_randomfail_init(struct fs *_fs, const char *args, struct event *event_parent,
+                  const struct fs_parameters *params, const char **error_r)
 {
        struct randomfail_fs *fs = RANDOMFAIL_FS(_fs);
        const char *p, *parent_name, *parent_args, *error;
@@ -195,7 +194,7 @@ fs_randomfail_init(struct fs *_fs, const char *args,
                parent_name = t_strdup_until(args, parent_args);
                parent_args++;
        }
-       if (fs_init(parent_name, parent_args, event_parent, set,
+       if (fs_init(parent_name, parent_args, event_parent, params,
                    &_fs->parent, error_r) < 0)
                return -1;
        return 0;

diff --git a/src/lib-fs/fs-sis-queue.c b/src/lib-fs/fs-sis-queue.c
index 61dbbb30947ea99f3b44cb34ae71dc7f02eaed9d..27f9108c0a8bbc8c856cc9bde6760452d3239ce5 100644 (file)
--- a/src/lib-fs/fs-sis-queue.c
+++ b/src/lib-fs/fs-sis-queue.c
@@ -29,9 +29,8 @@ static struct fs *fs_sis_queue_alloc(void)
 }
 
 static int
-fs_sis_queue_init(struct fs *_fs, const char *args,
-                 struct event *event_parent, const struct fs_settings *set,
-                 const char **error_r)
+fs_sis_queue_init(struct fs *_fs, const char *args, struct event *event_parent,
+                 const struct fs_parameters *params, const char **error_r)
 {
        struct sis_queue_fs *fs = SISQUEUE_FS(_fs);
        const char *p, *parent_name, *parent_args;
@@ -52,7 +51,7 @@ fs_sis_queue_init(struct fs *_fs, const char *args,
                parent_args = "";
        else
                parent_name = t_strdup_until(parent_name, parent_args++);
-       if (fs_init(parent_name, parent_args, event_parent, set,
+       if (fs_init(parent_name, parent_args, event_parent, params,
                    &_fs->parent, error_r) < 0)
                return -1;
        return 0;

diff --git a/src/lib-fs/fs-sis.c b/src/lib-fs/fs-sis.c
index ae85e38b85c5f1bb6eb9608582c6872ad28c231e..fc59b25d2bda3481856c0f44bb65f4979afd0514 100644 (file)
--- a/src/lib-fs/fs-sis.c
+++ b/src/lib-fs/fs-sis.c
@@ -42,7 +42,7 @@ static struct fs *fs_sis_alloc(void)
 
 static int
 fs_sis_init(struct fs *_fs, const char *args, struct event *event_parent,
-           const struct fs_settings *set, const char **error_r)
+           const struct fs_parameters *params, const char **error_r)
 {
        enum fs_properties props;
        const char *parent_name, *parent_args;
@@ -60,7 +60,7 @@ fs_sis_init(struct fs *_fs, const char *args, struct event *event_parent,
                parent_name = t_strdup_until(args, parent_args);
                parent_args++;
        }
-       if (fs_init(parent_name, parent_args, event_parent, set,
+       if (fs_init(parent_name, parent_args, event_parent, params,
                    &_fs->parent, error_r) < 0)
                return -1;
        props = fs_get_properties(_fs->parent);

diff --git a/src/lib-fs/fs-test-async.c b/src/lib-fs/fs-test-async.c
index 841718ee4d10fddd59a494999f2f7701f7838ba2..916a17b6e591af1c4485433eaa7ad080aeeb7539 100644 (file)
--- a/src/lib-fs/fs-test-async.c
+++ b/src/lib-fs/fs-test-async.c
@@ -84,13 +84,13 @@ static void test_fs_async_copy(const char *test_name, struct fs *fs)
 void test_fs_async(const char *test_name, enum fs_properties properties,
                   const char *driver, const char *args)
 {
-       struct fs_settings fs_set;
+       struct fs_parameters fs_params;
        struct fs *fs;
        struct test_fs *test_fs;
        const char *error;
 
-       i_zero(&fs_set);
-       if (fs_init(driver, args, NULL, &fs_set, &fs, &error) < 0)
+       i_zero(&fs_params);
+       if (fs_init(driver, args, NULL, &fs_params, &fs, &error) < 0)
                i_fatal("fs_init() failed: %s", error);
 
        test_fs = test_fs_get(fs);

diff --git a/src/lib-fs/fs-test.c b/src/lib-fs/fs-test.c
index 9be332853ceeeb0f01b05b09a01ab907c521c210..ba215b6bb3c8b919f81e4da7c934b78ec7b17a97 100644 (file)
--- a/src/lib-fs/fs-test.c
+++ b/src/lib-fs/fs-test.c
@@ -19,7 +19,7 @@ static struct fs *fs_test_alloc(void)
 static int
 fs_test_init(struct fs *_fs ATTR_UNUSED, const char *args ATTR_UNUSED,
             struct event *event_parent ATTR_UNUSED,
-            const struct fs_settings *set ATTR_UNUSED,
+            const struct fs_parameters *params ATTR_UNUSED,
             const char **error_r ATTR_UNUSED)
 {
        return 0;

diff --git a/src/lib-fs/test-fs-metawrap.c b/src/lib-fs/test-fs-metawrap.c
index 02ef5ba7a695daecd3870c53b1778981d7906bb2..0940e62bd941a6c9278df4a288a92a26ffdb6aea 100644 (file)
--- a/src/lib-fs/test-fs-metawrap.c
+++ b/src/lib-fs/test-fs-metawrap.c
@@ -7,7 +7,7 @@
 #include "fs-test.h"
 #include "test-common.h"
 
-static const struct fs_settings fs_set;
+static const struct fs_parameters fs_params;
 
 static void test_fs_metawrap_stat(void)
 {
@@ -21,7 +21,7 @@ static void test_fs_metawrap_stat(void)
 
        test_begin("fs metawrap stat");
 
-       if (fs_init("metawrap", "test", NULL, &fs_set, &fs, &error) < 0)
+       if (fs_init("metawrap", "test", NULL, &fs_params, &fs, &error) < 0)
                i_fatal("fs_init() failed: %s", error);
 
        for (i = 0; i < 2; i++) {
@@ -60,7 +60,7 @@ static void test_fs_metawrap_write_empty(void)
        const char *error;
 
        test_begin("fs metawrap write empty file");
-       if (fs_init("metawrap", "test", NULL, &fs_set, &fs, &error) < 0)
+       if (fs_init("metawrap", "test", NULL, &fs_params, &fs, &error) < 0)
                i_fatal("fs_init() failed: %s", error);
        struct fs_file *file = fs_file_init(fs, "foo", FS_OPEN_MODE_REPLACE);
        struct ostream *output = fs_write_stream(file);
@@ -77,7 +77,7 @@ static void test_fs_metawrap_write_fname_rename(void)
        const char *error;
 
        test_begin("fs metawrap write fname rename");
-       if (fs_init("metawrap", "test", NULL, &fs_set, &fs, &error) < 0)
+       if (fs_init("metawrap", "test", NULL, &fs_params, &fs, &error) < 0)
                i_fatal("fs_init() failed: %s", error);
        struct fs_file *file = fs_file_init(fs, "foo", FS_OPEN_MODE_REPLACE);
        struct ostream *output = fs_write_stream(file);

diff --git a/src/lib-fs/test-fs-posix.c b/src/lib-fs/test-fs-posix.c
index da76d03a893bda8970755a7134dd2be4ec91cba8..4bf781e86bd59dba015d3d86f0b9268a8694b126 100644 (file)
--- a/src/lib-fs/test-fs-posix.c
+++ b/src/lib-fs/test-fs-posix.c
@@ -28,12 +28,12 @@ static void test_fs_posix(void)
        int ret;
        const char *error;
        struct fs *fs;
-       struct fs_settings fs_set;
+       struct fs_parameters fs_params;
 
        test_begin("test-fs-posix filesystem");
-       i_zero(&fs_set);
+       i_zero(&fs_params);
        ret = fs_init("posix", t_strdup_printf("prefix=%s/", testdir), NULL,
-                     &fs_set, &fs, &error);
+                     &fs_params, &fs, &error);
        test_out_quiet("fs_init() failed", ret >= 0);
        if (ret < 0) {
                test_end();

diff --git a/src/lib-storage/mail-storage.c b/src/lib-storage/mail-storage.c
index fbf05f511faa4de1da2ea5b512929650f8c0045a..c9f5ba9daf92c6459e29364bd3d3edda9d02a2f3 100644 (file)
--- a/src/lib-storage/mail-storage.c
+++ b/src/lib-storage/mail-storage.c
@@ -452,12 +452,12 @@ mail_storage_create_full_real(struct mail_namespace *ns, const char *driver,
           wants to use its own. */
        if (storage->v.list_index_rebuild != NULL &&
            storage->mailboxes_fs == NULL) {
-               struct fs_settings fs_set;
+               struct fs_parameters fs_params;
                const char *error;
-               i_zero(&fs_set);
+               i_zero(&fs_params);
 
-               mail_user_init_fs_settings(storage->user, &fs_set);
-               if (fs_init("posix", "", storage->user->event, &fs_set,
+               mail_user_init_fs_settings(storage->user, &fs_params);
+               if (fs_init("posix", "", storage->user->event, &fs_params,
                            &storage->mailboxes_fs, &error) < 0) {
                        *error_r = t_strdup_printf("fs_init(posix) failed: %s", error);
                        storage->v.destroy(storage);

diff --git a/src/lib-storage/mail-user.c b/src/lib-storage/mail-user.c
index 1d23e8693a64412edb95153438b3ebb90796b054..2631da03a1ecb18f8108c11b18e83434bbf509c3 100644 (file)
--- a/src/lib-storage/mail-user.c
+++ b/src/lib-storage/mail-user.c
@@ -741,13 +741,13 @@ struct mail_user *mail_user_dup(struct mail_user *user)
 }
 
 void mail_user_init_fs_settings(struct mail_user *user,
-                               struct fs_settings *fs_set)
+                               struct fs_parameters *fs_params)
 {
-       fs_set->username = user->username;
-       fs_set->session_id = user->session_id;
-       fs_set->base_dir = user->set->base_dir;
-       fs_set->temp_dir = user->set->mail_temp_dir;
-       fs_set->enable_timing = user->stats_enabled;
+       fs_params->username = user->username;
+       fs_params->session_id = user->session_id;
+       fs_params->base_dir = user->set->base_dir;
+       fs_params->temp_dir = user->set->mail_temp_dir;
+       fs_params->enable_timing = user->stats_enabled;
 }
 
 static int

diff --git a/src/lib-storage/mail-user.h b/src/lib-storage/mail-user.h
index 03300218fe1b1cc8d03968ca051d9f8170cd9d64..d9d66d66ab4df61630442509aa716c4d84d14957 100644 (file)
--- a/src/lib-storage/mail-user.h
+++ b/src/lib-storage/mail-user.h
@@ -7,7 +7,7 @@
 #include "process-stat.h"
 
 struct module;
-struct fs_settings;
+struct fs_parameters;
 struct ssl_iostream_settings;
 struct master_service_anvil_session;
 struct mail_user;
@@ -201,9 +201,9 @@ mail_user_get_storage_class(struct mail_user *user, const char *name);
 /* Import any event_ fields from userdb fields to mail user event. */
 void mail_user_add_event_fields(struct mail_user *user);
 
-/* Initialize fs_settings from mail_user settings. */
+/* Initialize fs_parameters from mail_user settings. */
 void mail_user_init_fs_settings(struct mail_user *user,
-                               struct fs_settings *fs_set);
+                               struct fs_parameters *fs_set);
 
 /* Try to mkdir() user's home directory. Ideally this should be called only
    after the caller tries to create a file to the home directory, but it fails

diff --git a/src/lib-storage/mailbox-list.c b/src/lib-storage/mailbox-list.c
index 6d95517617082376e7d40da8043ecac76332a629..c2afc623e8c063635cfd0d3862219b22821f54e3 100644 (file)
--- a/src/lib-storage/mailbox-list.c
+++ b/src/lib-storage/mailbox-list.c
@@ -2084,18 +2084,18 @@ int mailbox_list_init_fs(struct mailbox_list *list, struct event *event_parent,
                         const char *args, const char *root_dir,
                         struct fs **fs_r, const char **error_r)
 {
-       struct fs_settings fs_set;
+       struct fs_parameters fs_params;
        struct mailbox_list_fs_context *ctx;
        struct fs *parent_fs;
 
-       i_zero(&fs_set);
-       mail_user_init_fs_settings(list->ns->user, &fs_set);
-       fs_set.root_path = root_dir;
-       fs_set.temp_file_prefix = mailbox_list_get_global_temp_prefix(list);
+       i_zero(&fs_params);
+       mail_user_init_fs_settings(list->ns->user, &fs_params);
+       fs_params.root_path = root_dir;
+       fs_params.temp_file_prefix = mailbox_list_get_global_temp_prefix(list);
 
        if (event_parent == NULL)
                event_parent = list->ns->user->event;
-       if (fs_init(driver, args, event_parent, &fs_set, fs_r, error_r) < 0)
+       if (fs_init(driver, args, event_parent, &fs_params, fs_r, error_r) < 0)
                return -1;
 
        /* add mailbox_list context to the parent fs, which allows

diff --git a/src/plugins/fs-compress/fs-compress.c b/src/plugins/fs-compress/fs-compress.c
index 3dbe7a30906f0f115e463604d8a4356b72ac4409..20d41eac2da0aae6e66bf99ddf7b79a65616be31 100644 (file)
--- a/src/plugins/fs-compress/fs-compress.c
+++ b/src/plugins/fs-compress/fs-compress.c
@@ -46,7 +46,7 @@ static struct fs *fs_compress_alloc(void)
 
 static int
 fs_compress_init(struct fs *_fs, const char *args,
-                struct event *event_parent, const struct fs_settings *set,
+                struct event *event_parent, const struct fs_parameters *params,
                 const char **error_r)
 {
        struct compress_fs *fs = COMPRESS_FS(_fs);
@@ -100,7 +100,7 @@ fs_compress_init(struct fs *_fs, const char *args,
                parent_name = t_strdup_until(args, parent_args);
                parent_args++;
        }
-       return fs_init(parent_name, parent_args, event_parent, set,
+       return fs_init(parent_name, parent_args, event_parent, params,
                       &_fs->parent, error_r);
 }
 

diff --git a/src/plugins/mail-crypt/fs-crypt-common.c b/src/plugins/mail-crypt/fs-crypt-common.c
index aaacd89c6088b4d62abf2c7858e3b093abb516a8..a19521829ce183f85520c060cc120fb05903f282 100644 (file)
--- a/src/plugins/mail-crypt/fs-crypt-common.c
+++ b/src/plugins/mail-crypt/fs-crypt-common.c
@@ -63,7 +63,7 @@ static struct fs *fs_crypt_alloc(void)
 
 static int
 fs_crypt_init(struct fs *_fs, const char *args, struct event *event_parent,
-             const struct fs_settings *set, const char **error_r)
+             const struct fs_parameters *params, const char **error_r)
 {
        struct crypt_fs *fs = CRYPT_FS(_fs);
        const char *enc_algo, *set_prefix;
@@ -116,7 +116,7 @@ fs_crypt_init(struct fs *_fs, const char *args, struct event *event_parent,
                parent_name = t_strdup_until(args, parent_args);
                parent_args++;
        }
-       if (fs_init(parent_name, parent_args, event_parent, set,
+       if (fs_init(parent_name, parent_args, event_parent, params,
                    &_fs->parent, error_r) < 0)
                return -1;
        fs->enc_algo = i_strdup(enc_algo);

diff --git a/src/plugins/mail-crypt/test-fs-crypt.c b/src/plugins/mail-crypt/test-fs-crypt.c
index 9ec8242052488d54cf2f7561f0c055a056f38da7..bec5c7dcc81d6b118d98c9236f968f0a8d1e40f3 100644 (file)
--- a/src/plugins/mail-crypt/test-fs-crypt.c
+++ b/src/plugins/mail-crypt/test-fs-crypt.c
@@ -26,7 +26,7 @@ const char *public_key_pem = "-----BEGIN PUBLIC KEY-----\n"
 
 extern const struct fs fs_class_crypt;
 
-static struct fs_settings test_fs_set;
+static struct fs_parameters test_fs_params;
 
 static void test_setup(void)
 {
@@ -34,8 +34,8 @@ static void test_setup(void)
        struct fs_file *file;
        const char *error;
 
-       test_fs_set.base_dir = ".";
-       test_fs_set.temp_dir = ".";
+       test_fs_params.base_dir = ".";
+       test_fs_params.temp_dir = ".";
 
        i_unlink_if_exists("test_public_key.pem");
        i_unlink_if_exists("test_private_key.pem");
@@ -43,7 +43,7 @@ static void test_setup(void)
        fs_class_register(&fs_class_posix);
        fs_class_register(&fs_class_crypt);
 
-       if (fs_init("posix", "", NULL, &test_fs_set, &fs, &error) < 0)
+       if (fs_init("posix", "", NULL, &test_fs_params, &fs, &error) < 0)
                 i_fatal("fs_init(posix) failed: %s", error);
        /* write keys to disk */
        file = fs_file_init(fs, "test_public_key.pem", FS_OPEN_MODE_CREATE);
@@ -69,7 +69,7 @@ static void test_fs_crypt_read_write(void)
 
        if (fs_init("crypt", "public_key_path=test_public_key.pem:"
                    "private_key_path=test_private_key.pem:posix",
-                   NULL, &test_fs_set, &fs, &error) < 0)
+                   NULL, &test_fs_params, &fs, &error) < 0)
                i_fatal("fs_init(crypt:posix) failed: %s", error);
 
        i_unlink_if_exists("test_file");
@@ -118,7 +118,7 @@ static void test_fs_crypt_read_write_0(void)
 
        if (fs_init("crypt", "public_key_path=test_public_key.pem:"
                    "private_key_path=test_private_key.pem:posix",
-                   NULL, &test_fs_set, &fs, &error) < 0)
+                   NULL, &test_fs_params, &fs, &error) < 0)
                i_fatal("fs_init(crypt:posix) failed: %s", error);
 
        i_unlink_if_exists("test_file");
@@ -160,7 +160,7 @@ static void test_fs_crypt_read_write_unencrypted(void)
        if (fs_init("crypt", "public_key_path=:"
                    "private_key_path=test_private_key.pem:"
                    "maybe:posix",
-                   NULL, &test_fs_set, &fs, &error) < 0)
+                   NULL, &test_fs_params, &fs, &error) < 0)
                i_fatal("fs_init(crypt:posix) failed: %s", error);
 
        i_unlink_if_exists("test_file");
@@ -202,7 +202,7 @@ static void test_fs_crypt_read_write_unencrypted(void)
        if (fs_init("crypt", "public_key_path=test_public_key.pem:"
                    "private_key_path=test_private_key.pem:"
                    "maybe:posix",
-                   NULL, &test_fs_set, &fs, &error) < 0)
+                   NULL, &test_fs_params, &fs, &error) < 0)
                i_fatal("fs_init(crypt:posix) failed: %s", error);
 
        i_unlink_if_exists("test_file");

diff --git a/src/util/test-fs.c b/src/util/test-fs.c
index 6f918ae92c94288049703ee8d5ae26d8bc3765ec..6aa275a837fa50c818b9dbe451c9f78ebbe53e25 100644 (file)
--- a/src/util/test-fs.c
+++ b/src/util/test-fs.c
@@ -365,7 +365,7 @@ static void stats_output(struct test_ctx *ctx)
 
 int main(int argc, char *argv[])
 {
-       struct fs_settings set;
+       struct fs_parameters params;
        struct test_ctx ctx;
        const char *error;
        unsigned int timeout_secs = 0;
@@ -376,8 +376,8 @@ int main(int argc, char *argv[])
        ctx.max_parallel_ops = DEFAULT_MAX_PARALLEL_OPS;
        ctx.files_count = DEFAULT_FILES_COUNT;
 
-       i_zero(&set);
-       set.base_dir = PKG_RUNDIR;
+       i_zero(&params);
+       params.base_dir = PKG_RUNDIR;
        master_service = master_service_init("test-fs",
                                             MASTER_SERVICE_FLAG_STANDALONE,
                                             &argc, &argv, "Daf:p:st:u:");
@@ -402,7 +402,7 @@ int main(int argc, char *argv[])
                        ctx.sync_only = TRUE;
                        break;
                case 'u':
-                       set.username = optarg;
+                       params.username = optarg;
                        break;
                case 't':
                        if (str_to_uint(optarg, &timeout_secs) < 0)
@@ -422,7 +422,7 @@ int main(int argc, char *argv[])
        dict_drivers_register_builtin();
 
        if (fs_init(argv[0], argv[1], master_service_get_event(master_service),
-                   &set, &ctx.fs, &error) < 0)
+                   &params, &ctx.fs, &error) < 0)
                i_fatal("fs_init() failed: %s", error);
        ctx.prefix = argv[2];