lib-fs: Split allocation from fs.iter_init() to a separate fs.iter_alloc()

diff --git a/src/lib-fs/fs-api-private.h b/src/lib-fs/fs-api-private.h
index e2c9ea34fa9a7ad895b7b83c84bfdac0be67a8b1..a507f927caed79e351e72122d2e0bc2b150c134a 100644 (file)
--- a/src/lib-fs/fs-api-private.h
+++ b/src/lib-fs/fs-api-private.h
@@ -63,8 +63,9 @@ struct fs_vfuncs {
        int (*rename)(struct fs_file *src, struct fs_file *dest);
        int (*delete_file)(struct fs_file *file);
 
-       struct fs_iter *(*iter_init)(struct fs *fs, const char *path,
-                                    enum fs_iter_flags flags);
+       struct fs_iter *(*iter_alloc)(void);
+       void (*iter_init)(struct fs_iter *iter, const char *path,
+                         enum fs_iter_flags flags);
        const char *(*iter_next)(struct fs_iter *iter);
        int (*iter_deinit)(struct fs_iter *iter);
 

diff --git a/src/lib-fs/fs-api.c b/src/lib-fs/fs-api.c
index 415fecb099e61aa7c24877d6b93facbb0ee199d8..37b24e7d2587bc4d3ac835cdee3d17f6550507f8 100644 (file)
--- a/src/lib-fs/fs-api.c
+++ b/src/lib-fs/fs-api.c
@@ -1078,7 +1078,9 @@ fs_iter_init(struct fs *fs, const char *path, enum fs_iter_flags flags)
                iter = i_new(struct fs_iter, 1);
                iter->fs = fs;
        } else T_BEGIN {
-               iter = fs->v.iter_init(fs, path, flags);
+               iter = fs->v.iter_alloc();
+               iter->fs = fs;
+               fs->v.iter_init(iter, path, flags);
        } T_END;
        iter->start_time = now;
        DLLIST_PREPEND(&fs->iters, iter);

diff --git a/src/lib-fs/fs-dict.c b/src/lib-fs/fs-dict.c
index 7bdc2a8cb555f85b936de6d99a44b71a0e4686ef..31573203b075dd661809cf74744c2a965e9efd58 100644 (file)
--- a/src/lib-fs/fs-dict.c
+++ b/src/lib-fs/fs-dict.c
@@ -275,20 +275,24 @@ static int fs_dict_delete(struct fs_file *_file)
        return 0;
 }
 
-static struct fs_iter *
-fs_dict_iter_init(struct fs *_fs, const char *path, enum fs_iter_flags flags)
+static struct fs_iter *fs_dict_iter_alloc(void)
 {
-       struct dict_fs *fs = (struct dict_fs *)_fs;
-       struct dict_fs_iter *iter;
+       struct dict_fs_iter *iter = i_new(struct dict_fs_iter, 1);
+       return &iter->iter;
+}
+
+static void
+fs_dict_iter_init(struct fs_iter *_iter, const char *path,
+                 enum fs_iter_flags flags)
+{
+       struct dict_fs_iter *iter = (struct dict_fs_iter *)_iter;
+       struct dict_fs *fs = (struct dict_fs *)_iter->fs;
 
-       iter = i_new(struct dict_fs_iter, 1);
-       iter->iter.fs = _fs;
        iter->iter.flags = flags;
        if (fs->path_prefix != NULL)
                path = t_strconcat(fs->path_prefix, path, NULL);
 
        iter->dict_iter = dict_iterate_init(fs->dict, path, 0);
-       return &iter->iter;
 }
 
 static const char *fs_dict_iter_next(struct fs_iter *_iter)
@@ -342,6 +346,7 @@ const struct fs fs_class_dict = {
                fs_default_copy,
                NULL,
                fs_dict_delete,
+               fs_dict_iter_alloc,
                fs_dict_iter_init,
                fs_dict_iter_next,
                fs_dict_iter_deinit,

diff --git a/src/lib-fs/fs-metawrap.c b/src/lib-fs/fs-metawrap.c
index 969ad6d14f3034574be42a191643f8f0073e60ad..fbbb1f291f9101019f29559f3c5bc27376dd7aea 100644 (file)
--- a/src/lib-fs/fs-metawrap.c
+++ b/src/lib-fs/fs-metawrap.c
@@ -518,6 +518,7 @@ const struct fs fs_class_metawrap = {
                fs_metawrap_copy,
                fs_wrapper_rename,
                fs_wrapper_delete,
+               fs_wrapper_iter_alloc,
                fs_wrapper_iter_init,
                fs_wrapper_iter_next,
                fs_wrapper_iter_deinit,

diff --git a/src/lib-fs/fs-posix.c b/src/lib-fs/fs-posix.c
index 34503060635e460fc037cf10bed82efd22e52678..5c67db5bca612198a0b0de320a49ac5b3e4964da 100644 (file)
--- a/src/lib-fs/fs-posix.c
+++ b/src/lib-fs/fs-posix.c
@@ -782,14 +782,19 @@ static int fs_posix_delete(struct fs_file *_file)
        return 0;
 }
 
-static struct fs_iter *
-fs_posix_iter_init(struct fs *_fs, const char *path, enum fs_iter_flags flags)
+static struct fs_iter *fs_posix_iter_alloc(void)
 {
-       struct posix_fs *fs = (struct posix_fs *)_fs;
-       struct posix_fs_iter *iter;
+       struct posix_fs_iter *iter = i_new(struct posix_fs_iter, 1);
+       return &iter->iter;
+}
+
+static void
+fs_posix_iter_init(struct fs_iter *_iter, const char *path,
+                  enum fs_iter_flags flags)
+{
+       struct posix_fs_iter *iter = (struct posix_fs_iter *)_iter;
+       struct posix_fs *fs = (struct posix_fs *)_iter->fs;
 
-       iter = i_new(struct posix_fs_iter, 1);
-       iter->iter.fs = _fs;
        iter->iter.flags = flags;
        iter->path = fs->path_prefix == NULL ? i_strdup(path) :
                i_strconcat(fs->path_prefix, path, NULL);
@@ -800,9 +805,8 @@ fs_posix_iter_init(struct fs *_fs, const char *path, enum fs_iter_flags flags)
        iter->dir = opendir(iter->path);
        if (iter->dir == NULL && errno != ENOENT) {
                iter->err = errno;
-               fs_set_error(_fs, "opendir(%s) failed: %m", iter->path);
+               fs_set_error(_iter->fs, "opendir(%s) failed: %m", iter->path);
        }
-       return &iter->iter;
 }
 
 static bool fs_posix_iter_want(struct posix_fs_iter *iter, const char *fname)
@@ -916,6 +920,7 @@ const struct fs fs_class_posix = {
                fs_posix_copy,
                fs_posix_rename,
                fs_posix_delete,
+               fs_posix_iter_alloc,
                fs_posix_iter_init,
                fs_posix_iter_next,
                fs_posix_iter_deinit,

diff --git a/src/lib-fs/fs-randomfail.c b/src/lib-fs/fs-randomfail.c
index 31d6483a02027ef387da9eb885d6b0084cd3e0d3..32440bef8baf262c5afb5fcd28097204d9fe639d 100644 (file)
--- a/src/lib-fs/fs-randomfail.c
+++ b/src/lib-fs/fs-randomfail.c
@@ -460,20 +460,23 @@ static int fs_randomfail_delete(struct fs_file *_file)
        return fs_file_random_fail_end(file, ret, FS_OP_DELETE);
 }
 
-static struct fs_iter *
-fs_randomfail_iter_init(struct fs *_fs, const char *path,
-                     enum fs_iter_flags flags)
+static struct fs_iter *fs_randomfail_iter_alloc(void)
 {
-       struct randomfail_fs_iter *iter;
+       struct randomfail_fs_iter *iter = i_new(struct randomfail_fs_iter, 1);
+       return &iter->iter;
+}
+
+static void
+fs_randomfail_iter_init(struct fs_iter *_iter, const char *path,
+                       enum fs_iter_flags flags)
+{
+       struct randomfail_fs_iter *iter = (struct randomfail_fs_iter *)_iter;
        uoff_t pos;
 
-       iter = i_new(struct randomfail_fs_iter, 1);
-       iter->iter.fs = _fs;
        iter->iter.flags = flags;
-       iter->super = fs_iter_init(_fs->parent, path, flags);
-       if (fs_random_fail_range(_fs, FS_OP_ITER, &pos))
+       iter->super = fs_iter_init(_iter->fs->parent, path, flags);
+       if (fs_random_fail_range(_iter->fs, FS_OP_ITER, &pos))
                iter->fail_pos = pos + 1;
-       return &iter->iter;
 }
 
 static const char *fs_randomfail_iter_next(struct fs_iter *_iter)
@@ -539,6 +542,7 @@ const struct fs fs_class_randomfail = {
                fs_randomfail_copy,
                fs_randomfail_rename,
                fs_randomfail_delete,
+               fs_randomfail_iter_alloc,
                fs_randomfail_iter_init,
                fs_randomfail_iter_next,
                fs_randomfail_iter_deinit,

diff --git a/src/lib-fs/fs-sis-queue.c b/src/lib-fs/fs-sis-queue.c
index 79d70a7e5f02f76f51901f6126fd0ab843562940..edbc85f985e12623592843ebea97cc8b0eadd2c6 100644 (file)
--- a/src/lib-fs/fs-sis-queue.c
+++ b/src/lib-fs/fs-sis-queue.c
@@ -202,6 +202,7 @@ const struct fs fs_class_sis_queue = {
                fs_wrapper_copy,
                fs_wrapper_rename,
                fs_sis_queue_delete,
+               fs_wrapper_iter_alloc,
                fs_wrapper_iter_init,
                NULL,
                NULL,

diff --git a/src/lib-fs/fs-sis.c b/src/lib-fs/fs-sis.c
index ea965c73573cd79db20795ca92e6c845ae7c4444..c8d25e1040331bf749f9e3d6205ba9d460d5d565 100644 (file)
--- a/src/lib-fs/fs-sis.c
+++ b/src/lib-fs/fs-sis.c
@@ -351,6 +351,7 @@ const struct fs fs_class_sis = {
                fs_wrapper_copy,
                fs_wrapper_rename,
                fs_sis_delete,
+               fs_wrapper_iter_alloc,
                fs_wrapper_iter_init,
                NULL,
                NULL,

diff --git a/src/lib-fs/fs-test.c b/src/lib-fs/fs-test.c
index d6979884cefdb8cd248b61aed3b09dd953c61a69..820f3df502cda0a16a535e971d852fe9a6912fb8 100644 (file)
--- a/src/lib-fs/fs-test.c
+++ b/src/lib-fs/fs-test.c
@@ -301,21 +301,24 @@ static int fs_test_delete(struct fs_file *_file)
        return 0;
 }
 
-static struct fs_iter *
-fs_test_iter_init(struct fs *_fs, const char *path,
+static struct fs_iter *fs_test_iter_alloc(void)
+{
+       struct test_fs_iter *iter = i_new(struct test_fs_iter, 1);
+       return &iter->iter;
+}
+
+static void
+fs_test_iter_init(struct fs_iter *_iter, const char *path,
                  enum fs_iter_flags flags)
 {
-       struct test_fs *fs = (struct test_fs *)_fs;
-       struct test_fs_iter *iter;
+       struct test_fs_iter *iter = (struct test_fs_iter *)_iter;
+       struct test_fs *fs = (struct test_fs *)_iter->fs;
 
-       iter = i_new(struct test_fs_iter, 1);
-       iter->iter.fs = _fs;
        iter->iter.flags = flags;
        iter->prefix = i_strdup(path);
        iter->prefix_len = strlen(iter->prefix);
        iter->prev_dir = i_strdup("");
        array_sort(&fs->iter_files, i_strcmp_p);
-       return &iter->iter;
 }
 
 static const char *fs_test_iter_next(struct fs_iter *_iter)
@@ -418,6 +421,7 @@ const struct fs fs_class_test = {
                fs_test_copy,
                fs_test_rename,
                fs_test_delete,
+               fs_test_iter_alloc,
                fs_test_iter_init,
                fs_test_iter_next,
                fs_test_iter_deinit,

diff --git a/src/lib-fs/fs-wrapper.c b/src/lib-fs/fs-wrapper.c
index 80240ee831c26ae423c8f37a31cb6f3a9c84570b..fb30822645024ae34d0df0e08aca33fff141cc35 100644 (file)
--- a/src/lib-fs/fs-wrapper.c
+++ b/src/lib-fs/fs-wrapper.c
@@ -132,17 +132,19 @@ int fs_wrapper_delete(struct fs_file *file)
        return fs_delete(file->parent);
 }
 
-struct fs_iter *
-fs_wrapper_iter_init(struct fs *fs, const char *path,
-                    enum fs_iter_flags flags)
+struct fs_iter *fs_wrapper_iter_alloc(void)
 {
-       struct wrapper_fs_iter *iter;
+       struct wrapper_fs_iter *iter = i_new(struct wrapper_fs_iter, 1);
+       return &iter->iter;
+}
+
+void fs_wrapper_iter_init(struct fs_iter *_iter, const char *path,
+                         enum fs_iter_flags flags)
+{
+       struct wrapper_fs_iter *iter = (struct wrapper_fs_iter *)_iter;
 
-       iter = i_new(struct wrapper_fs_iter, 1);
-       iter->iter.fs = fs;
        iter->iter.flags = flags;
-       iter->parent = fs_iter_init(fs->parent, path, flags);
-       return &iter->iter;
+       iter->parent = fs_iter_init(_iter->fs->parent, path, flags);
 }
 
 const char *fs_wrapper_iter_next(struct fs_iter *_iter)

diff --git a/src/lib-fs/fs-wrapper.h b/src/lib-fs/fs-wrapper.h
index c6d99da06929e696a405075932d3a12028f4dabb..e888e9d81c72d47ae8e9b203a47076d1733f9fad 100644 (file)
--- a/src/lib-fs/fs-wrapper.h
+++ b/src/lib-fs/fs-wrapper.h
@@ -28,9 +28,9 @@ int fs_wrapper_get_nlinks(struct fs_file *file, nlink_t *nlinks_r);
 int fs_wrapper_copy(struct fs_file *src, struct fs_file *dest);
 int fs_wrapper_rename(struct fs_file *src, struct fs_file *dest);
 int fs_wrapper_delete(struct fs_file *file);
-struct fs_iter *
-fs_wrapper_iter_init(struct fs *fs, const char *path,
-                    enum fs_iter_flags flags);
+struct fs_iter *fs_wrapper_iter_alloc(void);
+void fs_wrapper_iter_init(struct fs_iter *iter, const char *path,
+                         enum fs_iter_flags flags);
 const char *fs_wrapper_iter_next(struct fs_iter *iter);
 int fs_wrapper_iter_deinit(struct fs_iter *iter);
 

diff --git a/src/plugins/fs-compress/fs-compress.c b/src/plugins/fs-compress/fs-compress.c
index 1063f53782807aa6fa37ea62dbbd5b4496f9275f..64a919f2916d8c5089e4e242ab108a623ba3741c 100644 (file)
--- a/src/plugins/fs-compress/fs-compress.c
+++ b/src/plugins/fs-compress/fs-compress.c
@@ -293,6 +293,7 @@ const struct fs fs_class_compress = {
                fs_wrapper_copy,
                fs_wrapper_rename,
                fs_wrapper_delete,
+               fs_wrapper_iter_alloc,
                fs_wrapper_iter_init,
                fs_wrapper_iter_next,
                fs_wrapper_iter_deinit,

diff --git a/src/plugins/mail-crypt/fs-crypt.c b/src/plugins/mail-crypt/fs-crypt.c
index f961e3f831ce166c99232a455a872d5dfc5dce0b..56d58fc395116b6768409e8ee56ecffc7d664163 100644 (file)
--- a/src/plugins/mail-crypt/fs-crypt.c
+++ b/src/plugins/mail-crypt/fs-crypt.c
@@ -54,6 +54,7 @@ const struct fs fs_class_crypt = {
                fs_wrapper_copy,
                fs_wrapper_rename,
                fs_wrapper_delete,
+               fs_wrapper_iter_alloc,
                fs_wrapper_iter_init,
                fs_wrapper_iter_next,
                fs_wrapper_iter_deinit,

diff --git a/src/plugins/mail-crypt/fs-mail-crypt.c b/src/plugins/mail-crypt/fs-mail-crypt.c
index 42304410e5cfa51952ee013b7598078adba800b9..7c8808b172b326516720e4a39e11d12686c54ec9 100644 (file)
--- a/src/plugins/mail-crypt/fs-mail-crypt.c
+++ b/src/plugins/mail-crypt/fs-mail-crypt.c
@@ -61,6 +61,7 @@ const struct fs fs_class_mail_crypt = {
                fs_wrapper_copy,
                fs_wrapper_rename,
                fs_wrapper_delete,
+               fs_wrapper_iter_alloc,
                fs_wrapper_iter_init,
                fs_wrapper_iter_next,
                fs_wrapper_iter_deinit,