allow to specify mount options

doc/config.md

@@ -5,7 +5,7 @@ A config file is used to configure webfuse daemon.
 ## Config file
 
 ```
-version = { major = 1, minor = 0 }
+version = { major = 1, minor = 1 }
 
 server:
 {
@@ -35,7 +35,7 @@ authentication:
 
 filesystems:
 (
-    {name = "test",  mount_point = "/tmp/webfused" }
+    {name = "test",  mount_point = "/tmp/webfused", mount_options = () }
 )
 
 log:

etc/webfused.conf

@@ -1,12 +1,12 @@
 # Webfuse deamon configuration file
 
-version = { major = 1, minor = 0 }
+version = { major = 1, minor = 1 }
 
 server:
 {
     vhost_name = "localhost"
     port = 8080
-    
+
     # tls:
     # {
     #    certificate = "/etc/webfused/cert.pem"
@@ -36,7 +36,7 @@ authentication:
 
 filesystems:
 (
-    {name = "test",  mount_point = "/tmp/webfused" }
+    {name = "test",  mount_point = "/tmp/webfused", mount_options = () }
 )
 
 log:

meson.build

@@ -1,4 +1,5 @@
-project('webfused', 'c', 'cpp', version: '0.6.0', license: 'LGPL-3.0+')
+project('webfused', 'c', 'cpp', version: '0.6.0', license: 'LGPL-3.0+',
+    default_options: ['c_std=gnu99', 'cpp_std=gnu++14'])
 
 without_tests = get_option('without_tests')
 without_userdb = get_option('without_userdb')
@@ -54,6 +55,7 @@ libwebfused = static_library('webfused',
 	'src/webfused/log/manager.c',
 	'src/webfused/log/stderr_logger.c',
 	'src/webfused/log/syslog_logger.c',
+    'src/webfused/util/string_list.c',
     include_directories: inc_dir,
     dependencies: [libuserdb_dep, webfuse_adapter_dep, libconfig_dep, pam_dep],
     install: false)
@@ -61,8 +63,7 @@ libwebfused = static_library('webfused',
 libwebfused_dep = declare_dependency(
     include_directories: inc_dir,
     link_with: libwebfused,
-    dependencies: [libuserdb_dep, webfuse_adapter_dep, libconfig_dep, pam_dep],
+    dependencies: [libuserdb_dep, webfuse_adapter_dep, libconfig_dep, pam_dep])
-    install: false)
 
 webfused = executable('webfused',
 	'src/webfused/main.c',
@@ -82,15 +83,15 @@ webfused_conf    = configure_file(input: 'etc/webfused.conf'    , output: 'webfu
 invalid_conf     = configure_file(input: 'test/invalid.conf'    , output: 'invalid.conf'    , copy: true)
 test_passwd_json = configure_file(input: 'test/test_passwd.json', output: 'test_passwd.json', copy: true)
 
-alltests = executable('alltests',
+alltests_sources = [
-	'test/mock/config_builder.cc',
+    'test/mock/config_builder.cc',
-	'test/mock/logger.cc',
+    'test/mock/logger.cc',
-	'test/mock/credentials.cc',
+    'test/mock/credentials.cc',
-	'test/mock/settings.cc',
+    'test/mock/settings.cc',
-	'test/mock/pam.cc',
+    'test/mock/pam.cc',
-	'test/mock/libconfig.cc',
+    'test/mock/libconfig.cc',
-	'test/mock/linux.cc',
+    'test/mock/linux.cc',
-	'test/mock/server.cc',
+    'test/mock/server.cc',
     'test/config/configfile.cc',
     'test/config/configfile_version.cc',
     'test/config/configfile_server.cc',
@@ -98,19 +99,29 @@ alltests = executable('alltests',
     'test/config/configfile_filesystem.cc',
     'test/config/configfile_log.cc',
     'test/config/configfile_user.cc',
-	'test/config/config.cc',
+    'test/config/config.cc',
-	'test/config/settings.cc',
+    'test/config/settings.cc',
-	'test/auth/factory.cc',
+    'test/auth/factory.cc',
-	'test/auth/file_authenticator.cc',
+    'test/auth/pam_authenticator.cc',
-	'test/auth/pam_authenticator.cc',
+    'test/log/log.cc',
-	'test/log/log.cc',
+    'test/log/log_manager.cc',
-	'test/log/log_manager.cc',
+    'test/log/stderr_logger.cc',
-	'test/log/stderr_logger.cc',
+    'test/log/syslog_logger.cc',
-	'test/log/syslog_logger.cc',
+    'test/util/string_list.cc',
-	'test/daemon.cc',
+    'test/daemon.cc',
-	'test/change_user.cc',
+    'test/change_user.cc',
-	'test/mountpoint_factory.cc',
+    'test/mountpoint_factory.cc'
-	'test/userdb.cc',
+]
+
+if not without_userdb
+    alltests_sources += [
+        'test/auth/file_authenticator.cc',
+        'test/userdb.cc'
+    ]
+endif
+
+alltests = executable('alltests',
+    alltests_sources,
     include_directories: ['src', 'test'],
     link_args: [
         '-Wl,--wrap=wf_credentials_type',

src/webfused/config/config.c

@@ -112,8 +112,8 @@ wfd_config_add_auth_provider(
         if (result)
         {
             wf_server_config_add_authenticator(
-                config->server, 
+                config->server,
-                wfd_authenticator_get_type(config->authenticator), 
+                wfd_authenticator_get_type(config->authenticator),
                 config->authenticator.vtable->authenticate,
                 config->authenticator.data);
 
@@ -128,10 +128,11 @@ bool
 wfd_config_add_filesystem(
     struct wfd_config * config,
     char const * name,
-    char const * mount_point)
+    char const * mount_point,
+    struct wfd_string_list const * mount_options)
 {
     return wfd_mountpoint_factory_add_filesystem(
-        config->mountpoint_factory, name, mount_point);
+        config->mountpoint_factory, name, mount_point, mount_options);
 }
 
 bool
@@ -174,4 +175,3 @@ wfd_config_get_group(
 {
     return config->group;
 }
-

src/webfused/config/config.h

@@ -13,6 +13,12 @@ extern "C"
 {
 #endif
 
+#define WFD_CONFIG_VERSION_MAJOR 1
+#define WFD_CONFIG_VERSION_MINOR 1
+
+#define WFD_CONFIG_VERSION_STR_MAJOR "1"
+#define WFD_CONFIG_VERSION_STR_MINOR "1"
+
 struct wfd_config;
 struct wf_server_config;
 

src/webfused/config/config_intern.h

@@ -12,6 +12,7 @@ extern "C"
 
 struct wfd_settings;
 struct wfd_config;
+struct wfd_string_list;
 
 extern struct wfd_config *
 wfd_config_create(void);
@@ -51,7 +52,8 @@ extern bool
 wfd_config_add_filesystem(
     struct wfd_config * config,
     char const * name,
-    char const * mount_point);
+    char const * mount_point,
+    struct wfd_string_list const * mount_options);
 
 extern bool
 wfd_config_set_logger(

src/webfused/config/factory.c

@@ -3,6 +3,7 @@
 #include "webfused/config/config.h"
 #include "webfused/config/settings_intern.h"
 #include "webfused/log/log.h"
+#include "webfused/util/string_list.h"
 
 #include <libconfig.h>
 #include <stdlib.h>
@@ -13,10 +14,6 @@
 #error "libconfig 1.5 or higher needed"
 #endif
 
-
-#define WFD_CONFIG_VERSION_MAJOR 1
-#define WFD_CONFIG_VERSION_MINOR 0
-
 static bool
 wfd_config_check_version(
     config_t * config)
@@ -217,6 +214,26 @@ wfd_config_read_authentication(
     return result;
 }
 
+static void
+wfd_config_read_mountoptions(
+    config_setting_t * filesystem,
+    struct wfd_string_list * mount_options)
+{
+    config_setting_t * list = config_setting_get_member(filesystem, "mountpoint_options");
+    if ((NULL != list) && (CONFIG_TRUE == config_setting_is_list(list)))
+    {
+        int length = config_setting_length(list);
+        for (int i = 0; i < length; i++)
+        {
+            char const * option = config_setting_get_string_elem(list, i);
+            if (NULL != option)
+            {
+                wfd_string_list_add(mount_options, option);
+            }
+        }
+    }
+}
+
 static bool
 wfd_config_read_filesystems(
     config_t * config,
@@ -255,7 +272,12 @@ wfd_config_read_filesystems(
                 break;
             }
 
-            result = wfd_config_add_filesystem(builder, name, mount_point);
+            struct wfd_string_list mount_options;
+            wfd_string_list_init(&mount_options);
+            wfd_config_read_mountoptions(fs, &mount_options);
+
+            result = wfd_config_add_filesystem(builder, name, mount_point, &mount_options);
+            wfd_string_list_cleanup(&mount_options);
             if (!result)
             {
                 break;

src/webfused/log/syslog_logger.c

@@ -118,6 +118,7 @@ wfd_syslog_logger_init(
     }
     else
     {
+        free(ident);
         WFD_ERROR("failed to init syslog logger: invalid log facility: \'%s\'", facility_str);
     }
 

src/webfused/mountpoint_factory.c

@@ -1,4 +1,5 @@
 #include "webfused/mountpoint_factory.h"
+#include "webfused/util/string_list.h"
 #include "webfused/log/log.h"
 
 #include <webfuse/mountpoint.h>
@@ -13,6 +14,7 @@ struct wfd_filesystem
 {
     char * name;
     char * mount_point;
+    struct wfd_string_list mount_options;
     bool in_use;
 };
 
@@ -40,7 +42,7 @@ wfd_mountpoint_factory_find(
     return NULL;
 }
 
-static void 
+static void
 wfd_mountpoint_factory_release_mountpoint(
     void * user_data)
 {
@@ -68,6 +70,7 @@ wfd_mountpoint_factory_dispose(
         struct wfd_filesystem * filesystem = &(factory->filesystems[i]);
         free(filesystem->name);
         free(filesystem->mount_point);
+        wfd_string_list_cleanup(&filesystem->mount_options);
     }
 
     free(factory->filesystems);
@@ -78,7 +81,8 @@ bool
 wfd_mountpoint_factory_add_filesystem(
     struct wfd_mountpoint_factory * factory,
     char const * name,
-    char const * mount_point)
+    char const * mount_point,
+    struct wfd_string_list const * mount_options)
 {
     bool result = (NULL == wfd_mountpoint_factory_find(factory, name));
     if (!result)
@@ -103,13 +107,14 @@ wfd_mountpoint_factory_add_filesystem(
         if (factory->count >= factory->capacity)
         {
             factory->capacity *= 2;
-            factory->filesystems = realloc(factory->filesystems, 
+            factory->filesystems = realloc(factory->filesystems,
                 sizeof(struct wfd_filesystem) * factory->capacity);
         }
 
         struct wfd_filesystem * actual = &(factory->filesystems[factory->count]);
         actual->name = strdup(name);
         actual->mount_point = path;
+        wfd_string_list_init_copy(&actual->mount_options, mount_options);
         actual->in_use = false;
         factory->count++;
     }
@@ -140,6 +145,10 @@ wfd_mountpoint_factory_create_mountpoint(
     struct wf_mountpoint * result = wf_mountpoint_create(fs->mount_point);
     wf_mountpoint_set_userdata(result,
         &fs->in_use, &wfd_mountpoint_factory_release_mountpoint);
+    for (size_t i = 0; i < fs->mount_options.size; i++)
+    {
+        wf_mountpoint_add_mountoption(result, fs->mount_options.items[i]);
+    }
 
     WFD_INFO("created mountpoint \'%s\' at path \'%s\'", filesystem, fs->mount_point);
     return result;

src/webfused/mountpoint_factory.h

@@ -13,6 +13,7 @@ extern "C"
 #endif
 
 struct wfd_mountpoint_factory;
+struct wfd_string_list;
 
 extern struct wfd_mountpoint_factory *
 wfd_mountpoint_factory_create(void);
@@ -25,7 +26,8 @@ extern bool
 wfd_mountpoint_factory_add_filesystem(
     struct wfd_mountpoint_factory * factory,
     char const * name,
-    char const * mount_point);
+    char const * mount_point,
+    struct wfd_string_list const * mount_options);
 
 extern struct wf_mountpoint *
 wfd_mountpoint_factory_create_mountpoint(

src/webfused/util/string_list.c

@@ -0,0 +1,59 @@
+#include "webfused/util/string_list.h"
+#include <stdlib.h>
+#include <string.h>
+
+#define WFD_STRING_LIST_INITIAL_CAPACITY 8
+
+void
+wfd_string_list_init(
+    struct wfd_string_list * list)
+{
+    list->size = 0;
+    list->capacity = WFD_STRING_LIST_INITIAL_CAPACITY;
+    list->items = malloc(sizeof(char *) * list->capacity);
+}
+
+void
+wfd_string_list_init_copy(
+    struct wfd_string_list * list,
+    struct wfd_string_list const * other)
+{
+    if (0 < other->size)
+    {
+        list->size = other->size;
+        list->capacity = other->capacity;
+        list->items = malloc(sizeof(char *) * list->capacity);
+
+        memcpy(list->items, other->items, (sizeof(char*) * list->size));
+    }
+    else
+    {
+        wfd_string_list_init(list);
+    }
+}
+
+void
+wfd_string_list_cleanup(
+    struct wfd_string_list * list)
+{
+    for (size_t i = 0; i < list->size; i++)
+    {
+        free(list->items[i]);
+    }
+    free(list->items);
+}
+
+void
+wfd_string_list_add(
+    struct wfd_string_list * list,
+    char const * item)
+{
+    if (list->size >= list->capacity)
+    {
+        list->capacity *= 2;
+        list->items = realloc(list->items, sizeof(char *) * list->capacity);
+    }
+
+    list->items[list->size] = strdup(item);
+    list->size++;
+}

src/webfused/util/string_list.h

@@ -0,0 +1,44 @@
+#ifndef WFD_UTIL_STRING_LIST_H
+#define WFD_UTIL_STRING_LIST_H
+
+#ifndef __cplusplus
+#include <stddef.h>
+#else
+#include <cstddef>
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+struct wfd_string_list
+{
+    size_t size;
+    size_t capacity;
+    char * * items;
+};
+
+extern void
+wfd_string_list_init(
+    struct wfd_string_list * list);
+
+extern void
+wfd_string_list_init_copy(
+    struct wfd_string_list * list,
+    struct wfd_string_list const * other);
+
+extern void
+wfd_string_list_cleanup(
+    struct wfd_string_list * list);
+
+extern void
+wfd_string_list_add(
+    struct wfd_string_list * list,
+    char const * item);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

test/config/config.cc

@@ -5,7 +5,9 @@
 
 #include "webfused/log/logger.h"
 #include "webfused/log/log.h"
+#include "webfused/util/string_list.h"
 #include "mock/logger.hpp"
+
 using ::webfused_test::MockLogger;
 using ::testing::_;
 
@@ -77,7 +79,8 @@ TEST(config, add_filesystem)
     wfd_config * config = wfd_config_create();
     ASSERT_NE(nullptr, config);
 
-    bool success = wfd_config_add_filesystem(config, "test", "/tmp/test");
+    struct wfd_string_list mount_options = {0, 0, nullptr};
+    bool success = wfd_config_add_filesystem(config, "test", "/tmp/test", &mount_options);
     ASSERT_TRUE(success);
 
     wfd_config_dispose(config);
@@ -104,4 +107,4 @@ TEST(config, do_set_user)
     ASSERT_STREQ("some.group", wfd_config_get_group(config));
 
     wfd_config_dispose(config);
-}
+}

test/config/configfile.cc

@@ -1,5 +1,6 @@
 #include <gtest/gtest.h>
 
+#include "webfused/config/config.h"
 #include "webfused/config/factory.h"
 #include "webfused/log/logger.h"
 #include "webfused/log/log.h"
@@ -23,7 +24,7 @@ TEST(configfile, is_loadable)
     EXPECT_CALL(builder, wfd_config_set_server_vhostname(_,StrEq("localhost"))).Times(1);
     EXPECT_CALL(builder, wfd_config_set_server_port(_,8080)).Times(1);
     EXPECT_CALL(builder, wfd_config_add_auth_provider(_,_, _)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(builder, wfd_config_add_filesystem(_,_,_)).Times(1).WillOnce(Return(true));
+    EXPECT_CALL(builder, wfd_config_add_filesystem(_,_,_,_)).Times(1).WillOnce(Return(true));
 
     struct wfd_config * config = wfd_config_load_file("webfused.conf");
     ASSERT_NE(nullptr, config);
@@ -38,7 +39,7 @@ TEST(configfile, minimal_config)
     StrictMock<MockConfigBuilder> builder;
     EXPECT_CALL(builder, wfd_config_create).Times(1).WillOnce(Return(builder.getBuilder()));
 
-    char const minimal[] = "version = { major = 1, minor = 0 }\n";
+    char const minimal[] = "version = { major = " WFD_CONFIG_VERSION_STR_MAJOR ", minor = " WFD_CONFIG_VERSION_STR_MINOR " }\n";
     struct wfd_config * config = wfd_config_load_string(minimal);
     ASSERT_NE(nullptr, config);
 }
@@ -53,10 +54,10 @@ TEST(configfile, invalid_config)
     EXPECT_CALL(builder, wfd_config_create).Times(0);
     EXPECT_CALL(builder, wfd_config_dispose(_)).Times(0);
 
-    char const syntax_error[] = "version.major = 1\n";
+    char const syntax_error[] = "version.major = " WFD_CONFIG_VERSION_STR_MAJOR "\n";
 
     wfd_config * config = wfd_config_load_string(syntax_error);
-    ASSERT_EQ(nullptr, config);    
+    ASSERT_EQ(nullptr, config);
 }
 
 TEST(configfile, invalid_config_file)

test/config/configfile_auth.cc

@@ -1,5 +1,6 @@
 #include <gtest/gtest.h>
 
+#include "webfused/config/config.h"
 #include "webfused/config/factory.h"
 #include "webfused/log/logger.h"
 #include "webfused/log/log.h"
@@ -23,10 +24,10 @@ TEST(config_auth, authentication)
 
     StrictMock<MockConfigBuilder> builder;
     EXPECT_CALL(builder, wfd_config_create).Times(1).WillOnce(Return(builder.getBuilder()));
-    EXPECT_CALL(builder, wfd_config_add_auth_provider(_,_, _)).Times(1).WillOnce(Return(true));    
+    EXPECT_CALL(builder, wfd_config_add_auth_provider(_,_, _)).Times(1).WillOnce(Return(true));
 
-    char const config_text[] = 
+    char const config_text[] =
-        "version = { major = 1, minor = 0 }\n"
+        "version = { major = " WFD_CONFIG_VERSION_STR_MAJOR ", minor = " WFD_CONFIG_VERSION_STR_MINOR " }\n"
         "authentication:\n"
         "(\n"
         "  {\n"
@@ -48,10 +49,10 @@ TEST(config_auth, failed_create_authenticator)
     StrictMock<MockConfigBuilder> builder;
     EXPECT_CALL(builder, wfd_config_create).Times(1).WillOnce(Return(builder.getBuilder()));
     EXPECT_CALL(builder, wfd_config_dispose(_)).Times(1);
-    EXPECT_CALL(builder, wfd_config_add_auth_provider(_,_, _)).Times(1).WillOnce(Return(false));    
+    EXPECT_CALL(builder, wfd_config_add_auth_provider(_,_, _)).Times(1).WillOnce(Return(false));
 
-    char const config_text[] = 
+    char const config_text[] =
-        "version = { major = 1, minor = 0 }\n"
+        "version = { major = " WFD_CONFIG_VERSION_STR_MAJOR ", minor = " WFD_CONFIG_VERSION_STR_MINOR " }\n"
         "authentication:\n"
         "(\n"
         "  {\n"
@@ -74,8 +75,8 @@ TEST(config_auth, failed_missing_auth_provider)
     EXPECT_CALL(builder, wfd_config_create).Times(1).WillOnce(Return(builder.getBuilder()));
     EXPECT_CALL(builder, wfd_config_dispose(_)).Times(1);
 
-    char const config_text[] = 
+    char const config_text[] =
-        "version = { major = 1, minor = 0 }\n"
+        "version = { major = " WFD_CONFIG_VERSION_STR_MAJOR ", minor = " WFD_CONFIG_VERSION_STR_MINOR " }\n"
         "authentication:\n"
         "(\n"
         "  {\n"
@@ -97,8 +98,8 @@ TEST(config_auth, failed_missing_auth_settings)
     EXPECT_CALL(builder, wfd_config_create).Times(1).WillOnce(Return(builder.getBuilder()));
     EXPECT_CALL(builder, wfd_config_dispose(_)).Times(1);
 
-    char const config_text[] = 
+    char const config_text[] =
-        "version = { major = 1, minor = 0 }\n"
+        "version = { major = " WFD_CONFIG_VERSION_STR_MAJOR ", minor = " WFD_CONFIG_VERSION_STR_MINOR " }\n"
         "authentication:\n"
         "(\n"
         "  {\n"
@@ -123,8 +124,8 @@ TEST(config_auth, failed_auth_settings_get_elem)
     MockLibConfig libconfig;
     EXPECT_CALL(libconfig, config_setting_get_elem(_,_)).Times(1).WillOnce(Return(nullptr));
 
-    char const config_text[] = 
+    char const config_text[] =
-        "version = { major = 1, minor = 0 }\n"
+        "version = { major = " WFD_CONFIG_VERSION_STR_MAJOR ", minor = " WFD_CONFIG_VERSION_STR_MINOR" }\n"
         "authentication:\n"
         "(\n"
         "  {\n"

test/config/configfile_filesystem.cc

@@ -1,5 +1,6 @@
 #include <gtest/gtest.h>
 
+#include "webfused/config/config.h"
 #include "webfused/config/factory.h"
 #include "webfused/log/logger.h"
 #include "webfused/log/log.h"
@@ -23,10 +24,10 @@ TEST(configfile_fs, filesystems)
 
     StrictMock<MockConfigBuilder> builder;
     EXPECT_CALL(builder, wfd_config_create).Times(1).WillOnce(Return(builder.getBuilder()));
-    EXPECT_CALL(builder, wfd_config_add_filesystem(_,_, _)).Times(1).WillOnce(Return(true));    
+    EXPECT_CALL(builder, wfd_config_add_filesystem(_,_,_,_)).Times(1).WillOnce(Return(true));
 
-    char const config_text[] = 
+    char const config_text[] =
-        "version = { major = 1, minor = 0 }\n"
+        "version = { major = " WFD_CONFIG_VERSION_STR_MAJOR ", minor = " WFD_CONFIG_VERSION_STR_MINOR " }\n"
         "filesystems:\n"
         "(\n"
         "  {name = \"foo\", mount_point = \"/tmp/test\" }\n"
@@ -44,10 +45,10 @@ TEST(configfile_fs, filesystems_empty)
 
     StrictMock<MockConfigBuilder> builder;
     EXPECT_CALL(builder, wfd_config_create).Times(1).WillOnce(Return(builder.getBuilder()));
-    EXPECT_CALL(builder, wfd_config_add_filesystem(_,_, _)).Times(0);
+    EXPECT_CALL(builder, wfd_config_add_filesystem(_,_,_,_)).Times(0);
 
-    char const config_text[] = 
+    char const config_text[] =
-        "version = { major = 1, minor = 0 }\n"
+        "version = { major = " WFD_CONFIG_VERSION_STR_MAJOR ", minor = " WFD_CONFIG_VERSION_STR_MINOR " }\n"
         "filesystems:\n"
         "(\n"
         ")\n"
@@ -65,13 +66,13 @@ TEST(configfile_fs, filesystems_failed_add)
     StrictMock<MockConfigBuilder> builder;
     EXPECT_CALL(builder, wfd_config_create).Times(1).WillOnce(Return(builder.getBuilder()));
     EXPECT_CALL(builder, wfd_config_dispose(_)).Times(1);
-    EXPECT_CALL(builder, wfd_config_add_filesystem(_,_, _)).Times(1).WillOnce(Return(false));    
+    EXPECT_CALL(builder, wfd_config_add_filesystem(_,_,_,_)).Times(1).WillOnce(Return(false));
 
-    char const config_text[] = 
+    char const config_text[] =
-        "version = { major = 1, minor = 0 }\n"
+        "version = { major = " WFD_CONFIG_VERSION_STR_MAJOR ", minor = " WFD_CONFIG_VERSION_STR_MINOR " }\n"
         "filesystems:\n"
         "(\n"
-        "  {name = \"foo\", mount_point = \"/tmp/test\" }\n"
+        "  {name = \"foo\", mount_point = \"/tmp/test\", mount_options = () }\n"
         ")\n"
         ;
     struct wfd_config * config = wfd_config_load_string(config_text);
@@ -87,10 +88,10 @@ TEST(configfile_fs, filesystems_failed_missing_name)
     StrictMock<MockConfigBuilder> builder;
     EXPECT_CALL(builder, wfd_config_create).Times(1).WillOnce(Return(builder.getBuilder()));
     EXPECT_CALL(builder, wfd_config_dispose(_)).Times(1);
-    EXPECT_CALL(builder, wfd_config_add_filesystem(_,_, _)).Times(0);
+    EXPECT_CALL(builder, wfd_config_add_filesystem(_,_,_,_)).Times(0);
 
-    char const config_text[] = 
+    char const config_text[] =
-        "version = { major = 1, minor = 0 }\n"
+        "version = { major = " WFD_CONFIG_VERSION_STR_MAJOR ", minor = " WFD_CONFIG_VERSION_STR_MINOR " }\n"
         "filesystems:\n"
         "(\n"
         "  {mount_point = \"/tmp/test\" }\n"
@@ -109,10 +110,10 @@ TEST(configfile_fs, filesystems_failed_missing_mountpoint)
     StrictMock<MockConfigBuilder> builder;
     EXPECT_CALL(builder, wfd_config_create).Times(1).WillOnce(Return(builder.getBuilder()));
     EXPECT_CALL(builder, wfd_config_dispose(_)).Times(1);
-    EXPECT_CALL(builder, wfd_config_add_filesystem(_,_, _)).Times(0);
+    EXPECT_CALL(builder, wfd_config_add_filesystem(_,_,_,_)).Times(0);
 
-    char const config_text[] = 
+    char const config_text[] =
-        "version = { major = 1, minor = 0 }\n"
+        "version = { major = " WFD_CONFIG_VERSION_STR_MAJOR ", minor = " WFD_CONFIG_VERSION_STR_MINOR " }\n"
         "filesystems:\n"
         "(\n"
         "  {name = \"foo\"}\n"
@@ -131,13 +132,13 @@ TEST(configfile_fs, filesystems_failed_missing_elem)
     StrictMock<MockConfigBuilder> builder;
     EXPECT_CALL(builder, wfd_config_create).Times(1).WillOnce(Return(builder.getBuilder()));
     EXPECT_CALL(builder, wfd_config_dispose(_)).Times(1);
-    EXPECT_CALL(builder, wfd_config_add_filesystem(_,_, _)).Times(0);
+    EXPECT_CALL(builder, wfd_config_add_filesystem(_,_,_,_)).Times(0);
 
     MockLibConfig libconfig;
     EXPECT_CALL(libconfig, config_setting_get_elem(_,_)).Times(1).WillOnce(Return(nullptr));
 
-    char const config_text[] = 
+    char const config_text[] =
-        "version = { major = 1, minor = 0 }\n"
+        "version = { major = " WFD_CONFIG_VERSION_STR_MAJOR ", minor = " WFD_CONFIG_VERSION_STR_MINOR " }\n"
         "filesystems:\n"
         "(\n"
         "  {name = \"foo\", mount_point = \"/tmp/test\" }\n"
@@ -146,3 +147,25 @@ TEST(configfile_fs, filesystems_failed_missing_elem)
     struct wfd_config * config = wfd_config_load_string(config_text);
     ASSERT_EQ(nullptr, config);
 }
+
+TEST(configfile_fs, filesystems_failed_add_options)
+{
+    MockLogger logger;
+    EXPECT_CALL(logger, log(_, _, _)).Times(0);
+    EXPECT_CALL(logger, onclose()).Times(1);
+
+    StrictMock<MockConfigBuilder> builder;
+    EXPECT_CALL(builder, wfd_config_create).Times(1).WillOnce(Return(builder.getBuilder()));
+    EXPECT_CALL(builder, wfd_config_dispose(_)).Times(1);
+    EXPECT_CALL(builder, wfd_config_add_filesystem(_,_,_,_)).Times(1).WillOnce(Return(false));
+
+    char const config_text[] =
+        "version = { major = " WFD_CONFIG_VERSION_STR_MAJOR ", minor = " WFD_CONFIG_VERSION_STR_MINOR " }\n"
+        "filesystems:\n"
+        "(\n"
+        "  {name = \"foo\", mount_point = \"/tmp/test\", mount_options = (\"-o\", \"allow_other\") }\n"
+        ")\n"
+        ;
+    struct wfd_config * config = wfd_config_load_string(config_text);
+    ASSERT_EQ(nullptr, config);
+}

test/config/configfile_log.cc

@@ -1,5 +1,6 @@
 #include <gtest/gtest.h>
 
+#include "webfused/config/config.h"
 #include "webfused/config/factory.h"
 #include "webfused/log/logger.h"
 #include "webfused/log/log.h"
@@ -23,10 +24,10 @@ TEST(configfile_log, set_logger)
 
     StrictMock<MockConfigBuilder> builder;
     EXPECT_CALL(builder, wfd_config_create).Times(1).WillOnce(Return(builder.getBuilder()));
-    EXPECT_CALL(builder, wfd_config_set_logger(_,_, _, _)).Times(1).WillOnce(Return(true));    
+    EXPECT_CALL(builder, wfd_config_set_logger(_,_, _, _)).Times(1).WillOnce(Return(true));
 
-    char const config_text[] = 
+    char const config_text[] =
-        "version = { major = 1, minor = 0 }\n"
+        "version = { major = " WFD_CONFIG_VERSION_STR_MAJOR ", minor = " WFD_CONFIG_VERSION_STR_MINOR " }\n"
         "log:\n"
         "{\n"
         "  provider = \"stderr\"\n"
@@ -46,10 +47,10 @@ TEST(configfile_log, log_fail_set_logger)
     StrictMock<MockConfigBuilder> builder;
     EXPECT_CALL(builder, wfd_config_create).Times(1).WillOnce(Return(builder.getBuilder()));
     EXPECT_CALL(builder, wfd_config_dispose(_)).Times(1);
-    EXPECT_CALL(builder, wfd_config_set_logger(_,_, _, _)).Times(1).WillOnce(Return(false));    
+    EXPECT_CALL(builder, wfd_config_set_logger(_,_, _, _)).Times(1).WillOnce(Return(false));
 
-    char const config_text[] = 
+    char const config_text[] =
-        "version = { major = 1, minor = 0 }\n"
+        "version = { major = " WFD_CONFIG_VERSION_STR_MAJOR ", minor = " WFD_CONFIG_VERSION_STR_MINOR " }\n"
         "log:\n"
         "{\n"
         "  provider = \"stderr\"\n"
@@ -71,8 +72,8 @@ TEST(configfile_log, log_fail_missing_provider)
     EXPECT_CALL(builder, wfd_config_dispose(_)).Times(1);
     EXPECT_CALL(builder, wfd_config_set_logger(_,_, _, _)).Times(0);
 
-    char const config_text[] = 
+    char const config_text[] =
-        "version = { major = 1, minor = 0 }\n"
+        "version = { major = " WFD_CONFIG_VERSION_STR_MAJOR ", minor = " WFD_CONFIG_VERSION_STR_MINOR " }\n"
         "log:\n"
         "{\n"
         "  level    = \"all\"\n"
@@ -93,8 +94,8 @@ TEST(configfile_log, log_fail_missing_level)
     EXPECT_CALL(builder, wfd_config_dispose(_)).Times(1);
     EXPECT_CALL(builder, wfd_config_set_logger(_,_, _, _)).Times(0);
 
-    char const config_text[] = 
+    char const config_text[] =
-        "version = { major = 1, minor = 0 }\n"
+        "version = { major = " WFD_CONFIG_VERSION_STR_MAJOR ", minor = " WFD_CONFIG_VERSION_STR_MINOR " }\n"
         "log:\n"
         "{\n"
         "  provider = \"stderr\"\n"
@@ -116,8 +117,8 @@ TEST(configfile_log, log_fail_invalid_level)
     EXPECT_CALL(builder, wfd_config_dispose(_)).Times(1);
     EXPECT_CALL(builder, wfd_config_set_logger(_, _, _, _)).Times(0);
 
-    char const config_text[] = 
+    char const config_text[] =
-        "version = { major = 1, minor = 0 }\n"
+        "version = { major = " WFD_CONFIG_VERSION_STR_MAJOR ", minor = " WFD_CONFIG_VERSION_STR_MINOR " }\n"
         "log:\n"
         "{\n"
         "  provider = \"stderr\"\n"

test/config/configfile_server.cc

@@ -1,5 +1,6 @@
 #include <gtest/gtest.h>
 
+#include "webfused/config/config.h"
 #include "webfused/config/factory.h"
 #include "webfused/log/logger.h"
 #include "webfused/log/log.h"
@@ -25,8 +26,8 @@ TEST(configfile_server, vhost_name)
     EXPECT_CALL(builder, wfd_config_create).Times(1).WillOnce(Return(builder.getBuilder()));
     EXPECT_CALL(builder, wfd_config_set_server_vhostname(_,StrEq("some.host"))).Times(1);
 
-    char const config_text[] = 
+    char const config_text[] =
-        "version = { major = 1, minor = 0 }\n"
+        "version = { major = " WFD_CONFIG_VERSION_STR_MAJOR ", minor = " WFD_CONFIG_VERSION_STR_MINOR " }\n"
         "server:\n"
         "{\n"
         "  vhost_name = \"some.host\"\n"
@@ -46,8 +47,8 @@ TEST(configfile_server, port)
     EXPECT_CALL(builder, wfd_config_create).Times(1).WillOnce(Return(builder.getBuilder()));
     EXPECT_CALL(builder, wfd_config_set_server_port(_,54321)).Times(1);
 
-    char const config_text[] = 
+    char const config_text[] =
-        "version = { major = 1, minor = 0 }\n"
+        "version = { major = " WFD_CONFIG_VERSION_STR_MAJOR ", minor = " WFD_CONFIG_VERSION_STR_MINOR " }\n"
         "server:\n"
         "{\n"
         "  port = 54321\n"
@@ -63,12 +64,12 @@ TEST(configfile_server, tls_certificate)
     EXPECT_CALL(logger, log(_, _, _)).Times(0);
     EXPECT_CALL(logger, onclose()).Times(1);
 
-    StrictMock<MockConfigBuilder> builder;    
+    StrictMock<MockConfigBuilder> builder;
     EXPECT_CALL(builder, wfd_config_create).Times(1).WillOnce(Return(builder.getBuilder()));
     EXPECT_CALL(builder, wfd_config_set_server_cert(_, StrEq("/path/to/cert.pem"))).Times(1);
 
-    char const config_text[] = 
+    char const config_text[] =
-        "version = { major = 1, minor = 0 }\n"
+        "version = { major = " WFD_CONFIG_VERSION_STR_MAJOR ", minor = " WFD_CONFIG_VERSION_STR_MINOR " }\n"
         "server:\n"
         "{\n"
         "  tls:\n"
@@ -87,12 +88,12 @@ TEST(configfile_server, tls_key)
     EXPECT_CALL(logger, log(_, _, _)).Times(0);
     EXPECT_CALL(logger, onclose()).Times(1);
 
-    StrictMock<MockConfigBuilder> builder;    
+    StrictMock<MockConfigBuilder> builder;
     EXPECT_CALL(builder, wfd_config_create).Times(1).WillOnce(Return(builder.getBuilder()));
     EXPECT_CALL(builder, wfd_config_set_server_key(_,StrEq("/path/to/key.pem"))).Times(1);
 
-    char const config_text[] = 
+    char const config_text[] =
-        "version = { major = 1, minor = 0 }\n"
+        "version = { major = " WFD_CONFIG_VERSION_STR_MAJOR ", minor = " WFD_CONFIG_VERSION_STR_MINOR " }\n"
         "server:\n"
         "{\n"
         "  tls:\n"
@@ -113,10 +114,10 @@ TEST(configfile_server, document_root)
 
     StrictMock<MockConfigBuilder> builder;
     EXPECT_CALL(builder, wfd_config_create).Times(1).WillOnce(Return(builder.getBuilder()));
-    EXPECT_CALL(builder, wfd_config_set_server_document_root(_,StrEq("/var/www"))).Times(1);    
+    EXPECT_CALL(builder, wfd_config_set_server_document_root(_,StrEq("/var/www"))).Times(1);
 
-    char const config_text[] = 
+    char const config_text[] =
-        "version = { major = 1, minor = 0 }\n"
+        "version = { major = " WFD_CONFIG_VERSION_STR_MAJOR ", minor = " WFD_CONFIG_VERSION_STR_MINOR " }\n"
         "server:\n"
         "{\n"
         "  document_root = \"/var/www\"\n"

test/config/configfile_user.cc

@@ -1,5 +1,6 @@
 #include <gtest/gtest.h>
 
+#include "webfused/config/config.h"
 #include "webfused/config/factory.h"
 #include "webfused/log/logger.h"
 #include "webfused/log/log.h"
@@ -23,10 +24,10 @@ TEST(configfile_user, set_user)
 
     StrictMock<MockConfigBuilder> builder;
     EXPECT_CALL(builder, wfd_config_create).Times(1).WillOnce(Return(builder.getBuilder()));
-    EXPECT_CALL(builder, wfd_config_set_user(_, _, _)).Times(1);   
+    EXPECT_CALL(builder, wfd_config_set_user(_, _, _)).Times(1);
 
-    char const config_text[] = 
+    char const config_text[] =
-        "version = { major = 1, minor = 0 }\n"
+        "version = { major = " WFD_CONFIG_VERSION_STR_MAJOR ", minor = " WFD_CONFIG_VERSION_STR_MINOR " }\n"
         "user:\n"
         "{\n"
         "  name  = \"webfused\"\n"
@@ -48,8 +49,8 @@ TEST(configfile_user, set_user_fail_missing_name)
     EXPECT_CALL(builder, wfd_config_dispose(_)).Times(1);
     EXPECT_CALL(builder, wfd_config_set_user(_, _, _)).Times(0);
 
-    char const config_text[] = 
+    char const config_text[] =
-        "version = { major = 1, minor = 0 }\n"
+        "version = { major = " WFD_CONFIG_VERSION_STR_MAJOR ", minor = " WFD_CONFIG_VERSION_STR_MINOR " }\n"
         "user:\n"
         "{\n"
         "  group = \"webfused\"\n"
@@ -70,8 +71,8 @@ TEST(configfile_user, set_user_fail_missing_group)
     EXPECT_CALL(builder, wfd_config_dispose(_)).Times(1);
     EXPECT_CALL(builder, wfd_config_set_user(_, _, _)).Times(0);
 
-    char const config_text[] = 
+    char const config_text[] =
-        "version = { major = 1, minor = 0 }\n"
+        "version = { major = " WFD_CONFIG_VERSION_STR_MAJOR ", minor = " WFD_CONFIG_VERSION_STR_MINOR " }\n"
         "user:\n"
         "{\n"
         "  name = \"webfused\"\n"

test/config/configfile_version.cc

@@ -1,5 +1,6 @@
 #include <gtest/gtest.h>
 
+#include "webfused/config/config.h"
 #include "webfused/config/factory.h"
 #include "webfused/log/logger.h"
 #include "webfused/log/log.h"
@@ -25,7 +26,7 @@ TEST(configfile_version, invalid_major_version_too_low)
     EXPECT_CALL(builder, wfd_config_create).Times(1).WillOnce(Return(builder.getBuilder()));
     EXPECT_CALL(builder, wfd_config_dispose(_)).Times(1);
 
-    char const too_low[] = "version = { major = 0, minor = 0 }\n";
+    char const too_low[] = "version = { major = 0, minor = " WFD_CONFIG_VERSION_STR_MINOR " }\n";
 
     struct wfd_config * config= wfd_config_load_string(too_low);
     ASSERT_EQ(nullptr, config);
@@ -41,7 +42,7 @@ TEST(configfile_version, invalid_major_version_too_high)
     EXPECT_CALL(builder, wfd_config_create).Times(1).WillOnce(Return(builder.getBuilder()));
     EXPECT_CALL(builder, wfd_config_dispose(_)).Times(1);
 
-    char const too_high[] = "version = { major = 2, minor = 0 }\n";
+    char const too_high[] = "version = { major = 99, minor = " WFD_CONFIG_VERSION_STR_MINOR " }\n";
 
     struct wfd_config * config = wfd_config_load_string(too_high);
     ASSERT_EQ(nullptr, config);
@@ -57,7 +58,7 @@ TEST(configfile_version, invalid_missing_major_version)
     EXPECT_CALL(builder, wfd_config_create).Times(1).WillOnce(Return(builder.getBuilder()));
     EXPECT_CALL(builder, wfd_config_dispose(_)).Times(1);
 
-    char const too_high[] = "version = { minor = 0 }\n";
+    char const too_high[] = "version = { minor = " WFD_CONFIG_VERSION_STR_MINOR " }\n";
 
     struct wfd_config * config = wfd_config_load_string(too_high);
     ASSERT_EQ(nullptr, config);
@@ -73,7 +74,7 @@ TEST(configfile_version, invalid_missing_minor_version)
     EXPECT_CALL(builder, wfd_config_create).Times(1).WillOnce(Return(builder.getBuilder()));
     EXPECT_CALL(builder, wfd_config_dispose(_)).Times(1);
 
-    char const too_high[] = "version = { major = 1 }\n";
+    char const too_high[] = "version = { major = " WFD_CONFIG_VERSION_STR_MAJOR " }\n";
 
     struct wfd_config * config = wfd_config_load_string(too_high);
     ASSERT_EQ(nullptr, config);
@@ -84,11 +85,11 @@ TEST(configfile_version, valid_older_minor)
     MockLogger logger;
     EXPECT_CALL(logger, log(WFD_LOGLEVEL_INFO, _, _)).Times(1);
     EXPECT_CALL(logger, onclose()).Times(1);
-    
+
     StrictMock<MockConfigBuilder> builder;
     EXPECT_CALL(builder, wfd_config_create).Times(1).WillOnce(Return(builder.getBuilder()));
 
-    char const valid[] = "version = { major = 1, minor = -1 }\n";
+    char const valid[] = "version = { major = " WFD_CONFIG_VERSION_STR_MAJOR ", minor = -1 }\n";
 
     struct wfd_config * config = wfd_config_load_string(valid);
     ASSERT_NE(nullptr, config);
@@ -103,7 +104,7 @@ TEST(configfile_version, valid_newer_minor)
     StrictMock<MockConfigBuilder> builder;
     EXPECT_CALL(builder, wfd_config_create).Times(1).WillOnce(Return(builder.getBuilder()));
 
-    char const valid[] = "version = { major = 1, minor = 1 }\n";
+    char const valid[] = "version = { major = " WFD_CONFIG_VERSION_STR_MAJOR ", minor = 99 }\n";
 
     struct wfd_config * config = wfd_config_load_string(valid);
     ASSERT_NE(nullptr, config);

test/mock/config_builder.cc

@@ -13,7 +13,7 @@ WFD_WRAP_FUNC2(wfd_MockConfigBuilder, void, wfd_config_set_server_key, wfd_confi
 WFD_WRAP_FUNC2(wfd_MockConfigBuilder, void, wfd_config_set_server_cert, wfd_config *, char const *);
 WFD_WRAP_FUNC2(wfd_MockConfigBuilder, void, wfd_config_set_server_document_root, wfd_config *, char const *);
 WFD_WRAP_FUNC3(wfd_MockConfigBuilder, bool, wfd_config_add_auth_provider, wfd_config *, char const *, wfd_settings *);
-WFD_WRAP_FUNC3(wfd_MockConfigBuilder, bool, wfd_config_add_filesystem, wfd_config *, char const *, char const *);
+WFD_WRAP_FUNC4(wfd_MockConfigBuilder, bool, wfd_config_add_filesystem, wfd_config *, char const *, char const *, wfd_string_list *);
 WFD_WRAP_FUNC4(wfd_MockConfigBuilder, bool, wfd_config_set_logger, wfd_config *, char const *, int, wfd_settings *);
 WFD_WRAP_FUNC3(wfd_MockConfigBuilder, void, wfd_config_set_user, wfd_config *, char const *, char const *);
 }
@@ -23,7 +23,7 @@ namespace webfused_test
 
 MockConfigBuilder::MockConfigBuilder()
 {
-    wfd_MockConfigBuilder = this;    
+    wfd_MockConfigBuilder = this;
 }
 
 MockConfigBuilder::~MockConfigBuilder()
@@ -37,4 +37,4 @@ struct wfd_config * MockConfigBuilder::getBuilder()
 
     return reinterpret_cast<wfd_config *>(config_builder);
 }
-}
+}

test/mock/config_builder.hpp

@@ -19,7 +19,7 @@ public:
     virtual void wfd_config_set_server_cert(wfd_config * config, char const * cert_path) = 0;
     virtual void wfd_config_set_server_document_root(wfd_config * config, char const * document_root) = 0;
     virtual bool wfd_config_add_auth_provider(wfd_config * config, char const * provider, wfd_settings * settings) = 0;
-    virtual bool wfd_config_add_filesystem(wfd_config * config, char const * name, char const * mountpoint) = 0;
+    virtual bool wfd_config_add_filesystem(wfd_config * config, char const * name, char const * mountpoint, wfd_string_list const * mount_options) = 0;
     virtual bool wfd_config_set_logger(wfd_config * config, char const * provider, int level, wfd_settings * settings) = 0;
     virtual void wfd_config_set_user(wfd_config * config, char const * user, char const * group) = 0;
 };
@@ -37,7 +37,7 @@ public:
     MOCK_METHOD2(wfd_config_set_server_cert, void (wfd_config * config, char const * cert_path));
     MOCK_METHOD2(wfd_config_set_server_document_root, void (wfd_config * config, char const * document_root));
     MOCK_METHOD3(wfd_config_add_auth_provider, bool (wfd_config * config, char const * provider, wfd_settings * settings));
-    MOCK_METHOD3(wfd_config_add_filesystem, bool (wfd_config * config, char const * name, char const * mountpoint));
+    MOCK_METHOD4(wfd_config_add_filesystem, bool (wfd_config * config, char const * name, char const * mountpoint, wfd_string_list const * mount_options));
     MOCK_METHOD4(wfd_config_set_logger, bool (wfd_config * config, char const * provider, int level, wfd_settings * settings));
     MOCK_METHOD3(wfd_config_set_user, void (wfd_config * config, char const * user, char const * group));
 

test/mountpoint_factory.cc

@@ -1,5 +1,6 @@
 #include <gtest/gtest.h>
 #include "webfused/mountpoint_factory.h"
+#include "webfused/util/string_list.h"
 #include <webfuse/mountpoint.h>
 
 #include <cstring>
@@ -17,7 +18,8 @@ TEST(mountpiont_factory, add_filesystem)
     wfd_mountpoint_factory * factory = wfd_mountpoint_factory_create();
     ASSERT_NE(nullptr, factory);
 
-    bool success = wfd_mountpoint_factory_add_filesystem(factory, "test", "/tmp/webfused_test");
+    struct wfd_string_list mount_options = {0, 0, nullptr};
+    bool success = wfd_mountpoint_factory_add_filesystem(factory, "test", "/tmp/webfused_test", &mount_options);
     ASSERT_TRUE(success);
 
     wfd_mountpoint_factory_dispose(factory);
@@ -28,10 +30,11 @@ TEST(mountpiont_factory, add_filesystem_fail_to_add_twice)
     wfd_mountpoint_factory * factory = wfd_mountpoint_factory_create();
     ASSERT_NE(nullptr, factory);
 
-    bool success = wfd_mountpoint_factory_add_filesystem(factory, "test", "/tmp/webfused_test");
+    struct wfd_string_list mount_options = {0, 0, nullptr};
+    bool success = wfd_mountpoint_factory_add_filesystem(factory, "test", "/tmp/webfused_test", &mount_options);
     ASSERT_TRUE(success);
 
-    success = wfd_mountpoint_factory_add_filesystem(factory, "test", "/tmp/webfused_test");
+    success = wfd_mountpoint_factory_add_filesystem(factory, "test", "/tmp/webfused_test", &mount_options);
     ASSERT_FALSE(success);
 
     wfd_mountpoint_factory_dispose(factory);
@@ -47,7 +50,8 @@ TEST(mountpiont_factory, add_filesystem_multi)
     {
         char name[10];
         snprintf(name, 10, "test_%zu", i);
-        bool success = wfd_mountpoint_factory_add_filesystem(factory, name, "/tmp/webfused_test");
+        struct wfd_string_list mount_options = {0, 0, nullptr};
+        bool success = wfd_mountpoint_factory_add_filesystem(factory, name, "/tmp/webfused_test", &mount_options);
         ASSERT_TRUE(success) << i;
     }
 
@@ -59,7 +63,8 @@ TEST(mountpiont_factory, add_filesystem_fail_invalid_path)
     wfd_mountpoint_factory * factory = wfd_mountpoint_factory_create();
     ASSERT_NE(nullptr, factory);
 
-    bool success = wfd_mountpoint_factory_add_filesystem(factory, "test", "/do/not/allow/nested/paths");
+    struct wfd_string_list mount_options = {0, 0, nullptr};
+    bool success = wfd_mountpoint_factory_add_filesystem(factory, "test", "/do/not/allow/nested/paths", &mount_options);
     ASSERT_FALSE(success);
 
     wfd_mountpoint_factory_dispose(factory);
@@ -70,7 +75,8 @@ TEST(mountpiont_factory, create_mountpoint)
     wfd_mountpoint_factory * factory = wfd_mountpoint_factory_create();
     ASSERT_NE(nullptr, factory);
 
-    bool success = wfd_mountpoint_factory_add_filesystem(factory, "test", "/tmp/webfuse_test");
+    struct wfd_string_list mount_options = {0, 0, nullptr};
+    bool success = wfd_mountpoint_factory_add_filesystem(factory, "test", "/tmp/webfuse_test", &mount_options);
     ASSERT_TRUE(success);
 
     wf_mountpoint * mountpoint = wfd_mountpoint_factory_create_mountpoint("test", factory);
@@ -86,7 +92,8 @@ TEST(mountpiont_factory, create_mountpoint_fail_already_in_use)
     wfd_mountpoint_factory * factory = wfd_mountpoint_factory_create();
     ASSERT_NE(nullptr, factory);
 
-    bool success = wfd_mountpoint_factory_add_filesystem(factory, "test", "/tmp/webfuse_test");
+    struct wfd_string_list mount_options = {0, 0, nullptr};
+    bool success = wfd_mountpoint_factory_add_filesystem(factory, "test", "/tmp/webfuse_test", &mount_options);
     ASSERT_TRUE(success);
 
     wf_mountpoint * mountpoint = wfd_mountpoint_factory_create_mountpoint("test", factory);
@@ -105,7 +112,8 @@ TEST(mountpiont_factory, create_mountpoint_fail_unknown_filesystem)
     wfd_mountpoint_factory * factory = wfd_mountpoint_factory_create();
     ASSERT_NE(nullptr, factory);
 
-    bool success = wfd_mountpoint_factory_add_filesystem(factory, "test", "/tmp/webfuse_test");
+    struct wfd_string_list mount_options = {0, 0, nullptr};
+    bool success = wfd_mountpoint_factory_add_filesystem(factory, "test", "/tmp/webfuse_test", &mount_options);
     ASSERT_TRUE(success);
 
     wf_mountpoint * mountpoint = wfd_mountpoint_factory_create_mountpoint("unkown", factory);
@@ -119,7 +127,8 @@ TEST(mountpiont_factory, create_mountpoint_multi)
     wfd_mountpoint_factory * factory = wfd_mountpoint_factory_create();
     ASSERT_NE(nullptr, factory);
 
-    bool success = wfd_mountpoint_factory_add_filesystem(factory, "test", "/tmp/webfuse_test");
+    struct wfd_string_list mount_options = {0, 0, nullptr};
+    bool success = wfd_mountpoint_factory_add_filesystem(factory, "test", "/tmp/webfuse_test", &mount_options);
     ASSERT_TRUE(success);
 
     for(int i = 0; i < 5; i++)
@@ -130,6 +139,6 @@ TEST(mountpiont_factory, create_mountpoint_multi)
 
         wf_mountpoint_dispose(mountpoint);
     }
- 
+
     wfd_mountpoint_factory_dispose(factory);
 }

test/util/string_list.cc

@@ -0,0 +1,44 @@
+#include "webfused/util/string_list.h"
+#include <gtest/gtest.h>
+
+TEST(string_list, init_cleanup)
+{
+    wfd_string_list list;
+    wfd_string_list_init(&list);
+
+    ASSERT_EQ(0, list.size);
+
+    wfd_string_list_cleanup(&list);
+}
+
+TEST(string_list, add)
+{
+    wfd_string_list list;
+    wfd_string_list_init(&list);
+    wfd_string_list_add(&list, "value");
+
+    ASSERT_EQ(1, list.size);
+    ASSERT_STREQ("value", list.items[0]);
+
+    wfd_string_list_cleanup(&list);
+}
+
+TEST(string_list, add_many)
+{
+    wfd_string_list list;
+    wfd_string_list_init(&list);
+
+    constexpr size_t count = 256;
+    for (size_t i = 0; i < count; i++)
+    {
+        wfd_string_list_add(&list, "value");
+    }
+
+    ASSERT_EQ(count, list.size);
+    for (size_t i = 0; i < count; i++)
+    {
+        ASSERT_STREQ("value", list.items[i]);
+    }
+
+    wfd_string_list_cleanup(&list);
+}