Merge pull request #1 from falk-werner/config_file
feature: provide settings in a config filepull/2/head
Falk Werner
4 years ago
committed by
GitHub
commit
d252fd7411
@ -1,2 +1,3 @@
|
||||
/build/
|
||||
/.deps/
|
||||
/.deps/
|
||||
/.vscode/
|
||||
@ -0,0 +1,30 @@
|
||||
set(CMAKE_C_FLAGS_COVERAGE
|
||||
"${CMAKE_C_FLAGS_DEBUG} -pg --coverage -fprofile-arcs -ftest-coverage"
|
||||
CACHE STRING "Flags used by the C compiler during coverage builds"
|
||||
FORCE
|
||||
)
|
||||
|
||||
set(CMAKE_CXX_FLAGS_COVERAGE
|
||||
"${CMAKE_CXX_FLAGS_DEBUG} -pg --coverage -fprofile-arcs -ftest-coverage"
|
||||
CACHE STRING "Flags used by the C++ compiler during coverage builds."
|
||||
FORCE
|
||||
)
|
||||
|
||||
set(CMAKE_EXE_LINKER_FLAGS_COVERAGE
|
||||
""
|
||||
CACHE STRING "Flags used for linking binaries during coverage builds."
|
||||
FORCE
|
||||
)
|
||||
|
||||
set(CMAKE_SHARED_LINKER_FLAGS_COVERAGE
|
||||
""
|
||||
CACHE STRING "Flags used by the shared libraries linker during coverage builds."
|
||||
FORCE
|
||||
)
|
||||
|
||||
mark_as_advanced(
|
||||
CMAKE_C_FLAGS_COVERAGE
|
||||
CMAKE_CXX_FLAGS_COVERAGE
|
||||
CMAKE_EXE_LINKER_FLAGS_COVERAGE
|
||||
CMAKE_SHARED_LINKER_FLAGS_COVERAGE
|
||||
)
|
||||
@ -0,0 +1,2 @@
|
||||
ignore:
|
||||
- "test/**/*"
|
||||
@ -0,0 +1,45 @@
|
||||
# Webfuse deamon configuration file
|
||||
|
||||
version = { major = 1, minor = 0 }
|
||||
|
||||
server:
|
||||
{
|
||||
vhost_name = "localhost"
|
||||
port = 8080
|
||||
|
||||
# tls:
|
||||
# {
|
||||
# certificate = "/etc/webfused/cert.pem"
|
||||
# key = "/etc/webfused/key.pem"
|
||||
# }
|
||||
|
||||
# document_root = "/var/www"
|
||||
}
|
||||
|
||||
authentication:
|
||||
(
|
||||
{
|
||||
provider = "file"
|
||||
settings:
|
||||
{
|
||||
file = "/etc/webfused/passwd"
|
||||
}
|
||||
}
|
||||
)
|
||||
|
||||
filesystems:
|
||||
(
|
||||
{name = "test", mount_point = "/tmp/webfused" }
|
||||
)
|
||||
|
||||
log:
|
||||
{
|
||||
provider: "syslog"
|
||||
level: "warning"
|
||||
settings:
|
||||
{
|
||||
ident = "webfused"
|
||||
facility = "daemon"
|
||||
log_pid = true
|
||||
}
|
||||
}
|
||||
@ -1,196 +0,0 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stddef.h>
|
||||
#include <stdbool.h>
|
||||
#include <signal.h>
|
||||
|
||||
#include <unistd.h>
|
||||
#include <getopt.h>
|
||||
|
||||
#include <webfuse_adapter.h>
|
||||
#include <userdb/userdb.h>
|
||||
|
||||
#define SERVICE_TIMEOUT (1 * 1000)
|
||||
|
||||
struct args
|
||||
{
|
||||
struct wf_server_config * config;
|
||||
char * passwd_path;
|
||||
bool show_help;
|
||||
};
|
||||
|
||||
static bool shutdown_requested = false;
|
||||
|
||||
static void show_help(void)
|
||||
{
|
||||
printf(
|
||||
"webfused, Copyright (c) 2019, webfused authors <https://github.com/falk-werner/webfused>\n"
|
||||
"Websocket file system daemon\n"
|
||||
"\n"
|
||||
"Usage: webfused [m <mount_point>] [-d <document_root] [-n <vhost_name>] [-p <port>]\n"
|
||||
" [-c <server_cert_path>] [-k <server_key_path>] [-P <passwd_path>]\n"
|
||||
"\n"
|
||||
"Options:\n"
|
||||
"\t-m, --mount_point Path of mount point (required)\n"
|
||||
"\t-d, --document_root Path of www directory (default: not set, www disabled)\n"
|
||||
"\t-c, --server_cert_path Path of servers own certificate (default: not set, TLS disabled)\n"
|
||||
"\t-k, --server_key_path Path of servers private key (default: not set, TLS disabled)\n"
|
||||
"\t-n, --vhost_name Name of virtual host (default: \"localhost\")\n"
|
||||
"\t-p, --port Number of servers port (default: 8080)\n"
|
||||
"\t-P, --passwd_path Path to password file (default: not set, authentication disabled)\n"
|
||||
"\n");
|
||||
}
|
||||
|
||||
static bool authenticate(struct wf_credentials * creds, void * user_data)
|
||||
{
|
||||
bool result = false;
|
||||
struct args * args = user_data;
|
||||
|
||||
char const * username = wf_credentials_get(creds, "username");
|
||||
char const * password = wf_credentials_get(creds, "password");
|
||||
if ((NULL != username) && (NULL != password))
|
||||
{
|
||||
struct userdb * db = userdb_create("");
|
||||
result = userdb_load(db, args->passwd_path);
|
||||
if (result)
|
||||
{
|
||||
result = userdb_check(db, username, password);
|
||||
}
|
||||
|
||||
userdb_dispose(db);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static int parse_arguments(int argc, char * argv[], struct args * args)
|
||||
{
|
||||
static struct option const options[] =
|
||||
{
|
||||
{"mount_point", required_argument, NULL, 'm'},
|
||||
{"document_root", required_argument, NULL, 'd'},
|
||||
{"server_cert_path", required_argument, NULL, 'c'},
|
||||
{"server_key_path", required_argument, NULL, 'k'},
|
||||
{"vhost_name", required_argument, NULL, 'n'},
|
||||
{"port", required_argument, NULL, 'p'},
|
||||
{"passwd_path", required_argument, NULL, 'P'},
|
||||
{"help", no_argument, NULL, 'h'},
|
||||
{NULL, 0, NULL, 0}
|
||||
};
|
||||
|
||||
bool result = EXIT_SUCCESS;
|
||||
bool finished = false;
|
||||
bool has_mountpoint = false;
|
||||
while ((!finished) && (EXIT_SUCCESS == result))
|
||||
{
|
||||
int option_index = 0;
|
||||
int const c = getopt_long(argc, argv, "m:d:c:k:n:p:P:h", options, &option_index);
|
||||
|
||||
switch (c)
|
||||
{
|
||||
case -1:
|
||||
finished = true;
|
||||
break;
|
||||
case 'h':
|
||||
args->show_help = true;
|
||||
finished = true;
|
||||
break;
|
||||
case 'm':
|
||||
wf_server_config_set_mountpoint(args->config, optarg);
|
||||
has_mountpoint = true;
|
||||
break;
|
||||
case 'd':
|
||||
wf_server_config_set_documentroot(args->config, optarg);
|
||||
break;
|
||||
case 'c':
|
||||
wf_server_config_set_certpath(args->config, optarg);
|
||||
break;
|
||||
case 'k':
|
||||
wf_server_config_set_keypath(args->config, optarg);
|
||||
break;
|
||||
case 'n':
|
||||
wf_server_config_set_vhostname(args->config, optarg);
|
||||
break;
|
||||
case 'p':
|
||||
wf_server_config_set_port(args->config, atoi(optarg));
|
||||
break;
|
||||
case 'P':
|
||||
free(args->passwd_path);
|
||||
args->passwd_path = strdup(optarg);
|
||||
wf_server_config_add_authenticator(args->config,
|
||||
"username",
|
||||
&authenticate,
|
||||
args);
|
||||
break;
|
||||
default:
|
||||
fprintf(stderr, "error: unknown argument\n");
|
||||
result = EXIT_FAILURE;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if ((EXIT_SUCCESS == result) && (!args->show_help))
|
||||
{
|
||||
if (!has_mountpoint)
|
||||
{
|
||||
fprintf(stderr, "error: missing mount point\n");
|
||||
result = EXIT_FAILURE;
|
||||
}
|
||||
}
|
||||
|
||||
if (EXIT_SUCCESS != result)
|
||||
{
|
||||
args->show_help = true;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static void on_interrupt(int signal_id)
|
||||
{
|
||||
(void) signal_id;
|
||||
|
||||
shutdown_requested = true;
|
||||
}
|
||||
|
||||
int main(int argc, char * argv[])
|
||||
{
|
||||
struct args args;
|
||||
args.config = wf_server_config_create();
|
||||
wf_server_config_set_vhostname(args.config, "localhost");
|
||||
wf_server_config_set_port(args.config, 8080);
|
||||
args.passwd_path = NULL;
|
||||
args.show_help = false;
|
||||
|
||||
int result = parse_arguments(argc, argv, &args);
|
||||
|
||||
if (!args.show_help)
|
||||
{
|
||||
signal(SIGINT, on_interrupt);
|
||||
struct wf_server * server = wf_server_create(args.config);
|
||||
if (NULL != server)
|
||||
{
|
||||
while (!shutdown_requested)
|
||||
{
|
||||
wf_server_service(server, SERVICE_TIMEOUT);
|
||||
}
|
||||
|
||||
wf_server_dispose(server);
|
||||
}
|
||||
else
|
||||
{
|
||||
fprintf(stderr, "fatal: unable start server\n");
|
||||
result = EXIT_FAILURE;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
show_help();
|
||||
}
|
||||
|
||||
free(args.passwd_path);
|
||||
wf_server_config_dispose(args.config);
|
||||
return result;
|
||||
}
|
||||
|
||||
@ -0,0 +1,24 @@
|
||||
#include "webfused/auth/authenticator.h"
|
||||
|
||||
void
|
||||
wfd_authenticator_dispose(
|
||||
struct wfd_authenticator authenticator)
|
||||
{
|
||||
authenticator.vtable->dispose(authenticator.data);
|
||||
}
|
||||
|
||||
extern bool
|
||||
wfd_authenticator_authenticate(
|
||||
struct wfd_authenticator authenticator,
|
||||
struct wf_credentials * credentials)
|
||||
{
|
||||
return authenticator.vtable->authenticate(
|
||||
credentials, authenticator.data);
|
||||
}
|
||||
|
||||
char const *
|
||||
wfd_authenticator_get_type(
|
||||
struct wfd_authenticator authenticator)
|
||||
{
|
||||
return authenticator.vtable->get_type(authenticator.data);
|
||||
}
|
||||
@ -0,0 +1,49 @@
|
||||
#ifndef WFD_AUTH_AUTHENTICATOR_H
|
||||
#define WFD_AUTH_AUTHENTICATOR_H
|
||||
|
||||
#include "webfuse/adapter/authenticate.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
typedef void
|
||||
wfd_authenticator_dispose_fn(
|
||||
void * data);
|
||||
|
||||
typedef char const *
|
||||
wfd_authenticator_get_type_fn(
|
||||
void * data);
|
||||
|
||||
struct wfd_authenticator_vtable
|
||||
{
|
||||
wfd_authenticator_dispose_fn * dispose;
|
||||
wf_authenticate_fn * authenticate;
|
||||
wfd_authenticator_get_type_fn * get_type;
|
||||
};
|
||||
|
||||
struct wfd_authenticator
|
||||
{
|
||||
struct wfd_authenticator_vtable const * vtable;
|
||||
void * data;
|
||||
};
|
||||
|
||||
extern void
|
||||
wfd_authenticator_dispose(
|
||||
struct wfd_authenticator authenticator);
|
||||
|
||||
extern bool
|
||||
wfd_authenticator_authenticate(
|
||||
struct wfd_authenticator authenticator,
|
||||
struct wf_credentials * credentials);
|
||||
|
||||
extern char const *
|
||||
wfd_authenticator_get_type(
|
||||
struct wfd_authenticator authenticator);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,25 @@
|
||||
#include "webfused/auth/factory.h"
|
||||
#include "webfused/auth/file_authenticator.h"
|
||||
#include "webfused/config/settings.h"
|
||||
#include "webfused/log/log.h"
|
||||
|
||||
#include <string.h>
|
||||
|
||||
bool
|
||||
wfd_authenticator_create(
|
||||
char const * provider,
|
||||
struct wfd_settings * settings,
|
||||
struct wfd_authenticator * authenticator)
|
||||
{
|
||||
bool result = false;
|
||||
if (0 == strcmp("file", provider))
|
||||
{
|
||||
result = wfd_file_authenticator_create(settings, authenticator);
|
||||
}
|
||||
else
|
||||
{
|
||||
WFD_ERROR("failed to create authenticator: unknown type \"%s\"", provider);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
@ -0,0 +1,26 @@
|
||||
#ifndef WFD_AUTHENTICATION_FACTORY_H
|
||||
#define WFD_AUTHENTICATION_FACTORY_H
|
||||
|
||||
#ifndef __cplusplus
|
||||
#include <stdbool.h>
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
struct wfd_authenticator;
|
||||
struct wfd_settings;
|
||||
|
||||
extern bool
|
||||
wfd_authenticator_create(
|
||||
char const * provider,
|
||||
struct wfd_settings * settings,
|
||||
struct wfd_authenticator * authenticator);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,91 @@
|
||||
#include "webfused/auth/file_authenticator.h"
|
||||
#include "webfused/auth/authenticator.h"
|
||||
#include "webfused/config/settings.h"
|
||||
#include "userdb/userdb.h"
|
||||
#include "webfused/log/log.h"
|
||||
|
||||
#include <webfuse/adapter/credentials.h>
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
struct wfd_file_authenticator
|
||||
{
|
||||
char * filename;
|
||||
};
|
||||
|
||||
static void
|
||||
wfd_file_authenticator_dispose(
|
||||
void * data)
|
||||
{
|
||||
struct wfd_file_authenticator * authenticator = data;
|
||||
|
||||
free(authenticator->filename);
|
||||
free(authenticator);
|
||||
}
|
||||
|
||||
static bool
|
||||
wfd_file_authenticator_authenticate(
|
||||
struct wf_credentials * credentials,
|
||||
void * user_data)
|
||||
{
|
||||
bool result = false;
|
||||
struct wfd_file_authenticator * authenticator = user_data;
|
||||
|
||||
char const * username = wf_credentials_get(credentials, "username");
|
||||
char const * password = wf_credentials_get(credentials, "password");
|
||||
if ((NULL != username) && (NULL != password))
|
||||
{
|
||||
struct userdb * db = userdb_create("");
|
||||
result = userdb_load(db, authenticator->filename);
|
||||
if (result)
|
||||
{
|
||||
result = userdb_check(db, username, password);
|
||||
}
|
||||
|
||||
userdb_dispose(db);
|
||||
}
|
||||
|
||||
WFD_INFO("authenticate user \'%s\': %s",
|
||||
(NULL != username) ? username : "<unknown>",
|
||||
result ? "success" : "failure");
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static char const *
|
||||
wfd_file_authenticator_get_type(
|
||||
void * data)
|
||||
{
|
||||
(void) data;
|
||||
return "username";
|
||||
}
|
||||
|
||||
static struct wfd_authenticator_vtable
|
||||
wfd_file_authenticator_vtable =
|
||||
{
|
||||
.dispose = &wfd_file_authenticator_dispose,
|
||||
.authenticate = &wfd_file_authenticator_authenticate,
|
||||
.get_type = &wfd_file_authenticator_get_type
|
||||
};
|
||||
|
||||
bool
|
||||
wfd_file_authenticator_create(
|
||||
struct wfd_settings * settings,
|
||||
struct wfd_authenticator * authenticator)
|
||||
{
|
||||
bool result = false;
|
||||
|
||||
char const * filename = wfd_settings_get_string(settings, "file");
|
||||
if (NULL != filename)
|
||||
{
|
||||
struct wfd_file_authenticator * data = malloc(sizeof(struct wfd_file_authenticator));
|
||||
data->filename = strdup(filename);
|
||||
|
||||
authenticator->vtable = &wfd_file_authenticator_vtable;
|
||||
authenticator->data = data;
|
||||
result = true;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
@ -0,0 +1,26 @@
|
||||
#ifndef WFD_AUTH_FILE_AUTHENTICATOR_H
|
||||
#define WFD_AUTH_FILE_AUTHENTICATOR_H
|
||||
|
||||
#ifndef __cplusplus
|
||||
#include <stdbool.h>
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
struct wfd_authenticator;
|
||||
struct wfd_settings;
|
||||
|
||||
extern bool
|
||||
wfd_file_authenticator_create(
|
||||
struct wfd_settings * settings,
|
||||
struct wfd_authenticator * authenticator);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,72 @@
|
||||
#include "webfused/config/builder.h"
|
||||
|
||||
void
|
||||
wfd_config_builder_set_server_vhostname(
|
||||
struct wfd_config_builder builder,
|
||||
char const * vhost_name)
|
||||
{
|
||||
builder.vtable->set_server_vhostname(builder.data, vhost_name);
|
||||
}
|
||||
|
||||
void
|
||||
wfd_config_builder_set_server_port(
|
||||
struct wfd_config_builder builder,
|
||||
int port)
|
||||
{
|
||||
builder.vtable->set_server_port(builder.data, port);
|
||||
}
|
||||
|
||||
void
|
||||
wfd_config_builder_set_server_key(
|
||||
struct wfd_config_builder builder,
|
||||
char const * key_path)
|
||||
{
|
||||
builder.vtable->set_server_key(builder.data, key_path);
|
||||
}
|
||||
|
||||
void
|
||||
wfd_config_builder_set_server_cert(
|
||||
struct wfd_config_builder builder,
|
||||
char const * cert_path)
|
||||
{
|
||||
builder.vtable->set_server_cert(builder.data, cert_path);
|
||||
}
|
||||
|
||||
void
|
||||
wfd_config_builder_set_server_document_root(
|
||||
struct wfd_config_builder builder,
|
||||
char const * document_root)
|
||||
{
|
||||
builder.vtable->set_server_document_root(builder.data, document_root);
|
||||
}
|
||||
|
||||
bool
|
||||
wfd_config_builder_add_auth_provider(
|
||||
struct wfd_config_builder builder,
|
||||
char const * provider,
|
||||
struct wfd_settings * settings)
|
||||
{
|
||||
return builder.vtable->add_auth_provider(builder.data, provider, settings);
|
||||
}
|
||||
|
||||
bool
|
||||
wfd_config_builder_add_filesystem(
|
||||
struct wfd_config_builder builder,
|
||||
char const * name,
|
||||
char const * mount_point)
|
||||
{
|
||||
return builder.vtable->add_filesystem(builder.data, name, mount_point);
|
||||
}
|
||||
|
||||
bool
|
||||
wfd_config_builder_set_logger(
|
||||
struct wfd_config_builder builder,
|
||||
char const * provider,
|
||||
int level,
|
||||
struct wfd_settings * settings)
|
||||
{
|
||||
return builder.vtable->set_logger(builder.data, provider, level, settings);
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -0,0 +1,125 @@
|
||||
#ifndef WFD_CONFIG_BUILDER_H
|
||||
#define WFD_CONFIG_BUILDER_H
|
||||
|
||||
#ifndef __cplusplus
|
||||
#include <stdbool.h>
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
struct wfd_settings;
|
||||
|
||||
typedef void
|
||||
wfd_config_builder_set_server_vhostname_fn(
|
||||
void * data,
|
||||
char const * vhost_name);
|
||||
|
||||
typedef void
|
||||
wfd_config_builder_set_server_port_fn(
|
||||
void * data,
|
||||
int port);
|
||||
|
||||
typedef void
|
||||
wfd_config_builder_set_server_key_fn(
|
||||
void * data,
|
||||
char const * key_path);
|
||||
|
||||
typedef void
|
||||
wfd_config_builder_set_server_cert_fn(
|
||||
void * data,
|
||||
char const * cert_path);
|
||||
|
||||
typedef void
|
||||
wfd_config_builder_set_server_document_root_fn(
|
||||
void * data,
|
||||
char const * document_root);
|
||||
|
||||
typedef bool
|
||||
wfd_config_builder_add_auth_provider_fn(
|
||||
void * data,
|
||||
char const * provider,
|
||||
struct wfd_settings * settings);
|
||||
|
||||
typedef bool
|
||||
wfd_config_builder_add_filesystem_fn(
|
||||
void * data,
|
||||
char const * name,
|
||||
char const * mount_point);
|
||||
|
||||
typedef bool
|
||||
wfd_config_builder_set_logger_fn(
|
||||
void * data,
|
||||
char const * provider,
|
||||
int level,
|
||||
struct wfd_settings * settings);
|
||||
|
||||
struct wfd_config_builder_vtable
|
||||
{
|
||||
wfd_config_builder_set_server_vhostname_fn * set_server_vhostname;
|
||||
wfd_config_builder_set_server_port_fn * set_server_port;
|
||||
wfd_config_builder_set_server_key_fn * set_server_key;
|
||||
wfd_config_builder_set_server_cert_fn * set_server_cert;
|
||||
wfd_config_builder_set_server_document_root_fn * set_server_document_root;
|
||||
wfd_config_builder_add_auth_provider_fn * add_auth_provider;
|
||||
wfd_config_builder_add_filesystem_fn * add_filesystem;
|
||||
wfd_config_builder_set_logger_fn * set_logger;
|
||||
};
|
||||
|
||||
struct wfd_config_builder
|
||||
{
|
||||
struct wfd_config_builder_vtable const * vtable;
|
||||
void * data;
|
||||
};
|
||||
|
||||
extern void
|
||||
wfd_config_builder_set_server_vhostname(
|
||||
struct wfd_config_builder builder,
|
||||
char const * vhost_name);
|
||||
|
||||
extern void
|
||||
wfd_config_builder_set_server_port(
|
||||
struct wfd_config_builder builder,
|
||||
int port);
|
||||
|
||||
extern void
|
||||
wfd_config_builder_set_server_key(
|
||||
struct wfd_config_builder builder,
|
||||
char const * key_path);
|
||||
|
||||
extern void
|
||||
wfd_config_builder_set_server_cert(
|
||||
struct wfd_config_builder builder,
|
||||
char const * cert_path);
|
||||
|
||||
extern void
|
||||
wfd_config_builder_set_server_document_root(
|
||||
struct wfd_config_builder builder,
|
||||
char const * document_root);
|
||||
|
||||
extern bool
|
||||
wfd_config_builder_add_auth_provider(
|
||||
struct wfd_config_builder builder,
|
||||
char const * provider,
|
||||
struct wfd_settings * settings);
|
||||
|
||||
extern bool
|
||||
wfd_config_builder_add_filesystem(
|
||||
struct wfd_config_builder builder,
|
||||
char const * name,
|
||||
char const * mount_point);
|
||||
|
||||
extern bool
|
||||
wfd_config_builder_set_logger(
|
||||
struct wfd_config_builder builder,
|
||||
char const * provider,
|
||||
int level,
|
||||
struct wfd_settings * settings);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,178 @@
|
||||
#include "webfused/config/config.h"
|
||||
#include "webfuse/adapter/server_config.h"
|
||||
#include "webfused/auth/factory.h"
|
||||
#include "webfused/auth/authenticator.h"
|
||||
#include "webfused/mountpoint_factory.h"
|
||||
#include "webfused/log/manager.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#define WFD_CONFIG_DEFAULT_PORT (8080)
|
||||
#define WFD_CONFIG_DEFAULT_VHOSTNAME ("localhost")
|
||||
|
||||
struct wfd_config
|
||||
{
|
||||
struct wf_server_config * server;
|
||||
bool has_authenticator;
|
||||
struct wfd_authenticator authenticator;
|
||||
struct wfd_mountpoint_factory * mountpoint_factory;
|
||||
};
|
||||
|
||||
static void
|
||||
wfd_config_set_server_vhostname(
|
||||
void * data,
|
||||
char const * vhost_name)
|
||||
{
|
||||
struct wfd_config * config = data;
|
||||
wf_server_config_set_vhostname(config->server, vhost_name);
|
||||
}
|
||||
|
||||
static void
|
||||
wfd_config_set_server_port(
|
||||
void * data,
|
||||
int port)
|
||||
{
|
||||
struct wfd_config * config = data;
|
||||
wf_server_config_set_port(config->server, port);
|
||||
}
|
||||
|
||||
static void
|
||||
wfd_config_set_server_key(
|
||||
void * data,
|
||||
char const * key_path)
|
||||
{
|
||||
struct wfd_config * config = data;
|
||||
wf_server_config_set_keypath(config->server, key_path);
|
||||
}
|
||||
|
||||
static void
|
||||
wfd_config_set_server_cert(
|
||||
void * data,
|
||||
char const * cert_path)
|
||||
{
|
||||
struct wfd_config * config = data;
|
||||
wf_server_config_set_certpath(config->server, cert_path);
|
||||
}
|
||||
|
||||
static void
|
||||
wfd_config_set_server_document_root(
|
||||
void * data,
|
||||
char const * document_root)
|
||||
{
|
||||
struct wfd_config * config = data;
|
||||
wf_server_config_set_documentroot(config->server, document_root);
|
||||
}
|
||||
|
||||
static bool
|
||||
wfd_config_add_auth_provider(
|
||||
void * data,
|
||||
char const * provider,
|
||||
struct wfd_settings * settings)
|
||||
{
|
||||
bool result = false;
|
||||
struct wfd_config * config = data;
|
||||
|
||||
if (!config->has_authenticator)
|
||||
{
|
||||
result = wfd_authenticator_create(provider, settings, &config->authenticator);
|
||||
if (result)
|
||||
{
|
||||
wf_server_config_add_authenticator(
|
||||
config->server,
|
||||
wfd_authenticator_get_type(config->authenticator),
|
||||
config->authenticator.vtable->authenticate,
|
||||
config->authenticator.data);
|
||||
|
||||
config->has_authenticator = true;
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static bool
|
||||
wfd_config_add_filesystem(
|
||||
void * data,
|
||||
char const * name,
|
||||
char const * mount_point)
|
||||
{
|
||||
struct wfd_config * config = data;
|
||||
return wfd_mountpoint_factory_add_filesystem(
|
||||
config->mountpoint_factory, name, mount_point);
|
||||
}
|
||||
|
||||
static bool
|
||||
wfd_config_set_logger(
|
||||
void * data,
|
||||
char const * provider,
|
||||
int level,
|
||||
struct wfd_settings * settings)
|
||||
{
|
||||
struct wfd_config * config = data;
|
||||
return wfd_log_manager_set_logger(provider, level, settings);
|
||||
}
|
||||
|
||||
static const struct wfd_config_builder_vtable
|
||||
wfd_config_vtable_config_builder =
|
||||
{
|
||||
.set_server_vhostname = &wfd_config_set_server_vhostname,
|
||||
.set_server_port = &wfd_config_set_server_port,
|
||||
.set_server_key = &wfd_config_set_server_key,
|
||||
.set_server_cert = &wfd_config_set_server_cert,
|
||||
.set_server_document_root = &wfd_config_set_server_document_root,
|
||||
.add_auth_provider = &wfd_config_add_auth_provider,
|
||||
.add_filesystem = &wfd_config_add_filesystem,
|
||||
.set_logger = &wfd_config_set_logger
|
||||
};
|
||||
|
||||
struct wfd_config *
|
||||
wfd_config_create(void)
|
||||
{
|
||||
struct wfd_config * config = malloc(sizeof(struct wfd_config));
|
||||
|
||||
config->mountpoint_factory = wfd_mountpoint_factory_create();
|
||||
config->has_authenticator = false;
|
||||
config->server = wf_server_config_create();
|
||||
wf_server_config_set_vhostname(config->server, WFD_CONFIG_DEFAULT_VHOSTNAME);
|
||||
wf_server_config_set_port(config->server, WFD_CONFIG_DEFAULT_PORT);
|
||||
wf_server_config_set_mountpoint_factory(config->server,
|
||||
wfd_mountpoint_factory_create_mountpoint,
|
||||
config->mountpoint_factory);
|
||||
|
||||
return config;
|
||||
}
|
||||
|
||||
void
|
||||
wfd_config_dispose(
|
||||
struct wfd_config * config)
|
||||
{
|
||||
wf_server_config_dispose(config->server);
|
||||
if (config->has_authenticator)
|
||||
{
|
||||
wfd_authenticator_dispose(config->authenticator);
|
||||
}
|
||||
wfd_mountpoint_factory_dispose(config->mountpoint_factory);
|
||||
|
||||
free(config);
|
||||
}
|
||||
|
||||
struct wfd_config_builder
|
||||
wfd_config_get_builder(
|
||||
struct wfd_config * config)
|
||||
{
|
||||
struct wfd_config_builder builder =
|
||||
{
|
||||
&wfd_config_vtable_config_builder,
|
||||
config
|
||||
};
|
||||
|
||||
return builder;
|
||||
}
|
||||
|
||||
struct wf_server_config *
|
||||
wfd_config_get_server_config(
|
||||
struct wfd_config * config)
|
||||
{
|
||||
return config->server;
|
||||
}
|
||||
|
||||
@ -0,0 +1,40 @@
|
||||
#ifndef WFD_CONFIG_H
|
||||
#define WFD_CONFIG_H
|
||||
|
||||
#include "webfused/config/builder.h"
|
||||
|
||||
#ifndef __cplusplus
|
||||
#include <stdbool.h>
|
||||
#include <stddef.h>
|
||||
#else
|
||||
#include <cstddef>
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
struct wfd_config;
|
||||
struct wf_server_config;
|
||||
|
||||
extern struct wfd_config *
|
||||
wfd_config_create(void);
|
||||
|
||||
extern void
|
||||
wfd_config_dispose(
|
||||
struct wfd_config * config);
|
||||
|
||||
extern struct wfd_config_builder
|
||||
wfd_config_get_builder(
|
||||
struct wfd_config * config);
|
||||
|
||||
extern struct wf_server_config *
|
||||
wfd_config_get_server_config(
|
||||
struct wfd_config * config);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,332 @@
|
||||
#include "webfused/config/factory.h"
|
||||
#include "webfused/config/settings_intern.h"
|
||||
#include "webfused/log/log.h"
|
||||
|
||||
#include <libconfig.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
|
||||
#if ((LIBCONFIG_VER_MAJOR != 1) || (LIBCONFIG_VER_MINOR < 5))
|
||||
#error "linconfig 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)
|
||||
{
|
||||
int version_major;
|
||||
int rc = config_lookup_int(config, "version.major", &version_major);
|
||||
if (CONFIG_TRUE != rc)
|
||||
{
|
||||
WFD_ERROR("failed to load config: missing version.major");
|
||||
return false;
|
||||
}
|
||||
|
||||
if (WFD_CONFIG_VERSION_MAJOR != version_major)
|
||||
{
|
||||
WFD_ERROR("failed to load config: "
|
||||
"incompatible versions: expected %d, but war %d",
|
||||
WFD_CONFIG_VERSION_MAJOR, version_major);
|
||||
return false;
|
||||
}
|
||||
|
||||
int version_minor;
|
||||
rc = config_lookup_int(config, "version.minor", &version_minor);
|
||||
if (CONFIG_TRUE != rc)
|
||||
{
|
||||
WFD_ERROR("failed to load config: missing version.minor");
|
||||
return false;
|
||||
}
|
||||
|
||||
if (WFD_CONFIG_VERSION_MINOR < version_minor)
|
||||
{
|
||||
WFD_WARN("newer config detected: some features might be disabled");
|
||||
}
|
||||
else if (WFD_CONFIG_VERSION_MINOR > version_minor)
|
||||
{
|
||||
WFD_INFO("old config detected: some features might use default values");
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool
|
||||
wfd_config_read_logger(
|
||||
config_t * config,
|
||||
struct wfd_config_builder builder)
|
||||
{
|
||||
bool result = true;
|
||||
|
||||
bool hasLogger = (NULL != config_lookup(config, "log"));
|
||||
if (hasLogger)
|
||||
{
|
||||
char const * provider;
|
||||
int rc = config_lookup_string(config, "log.provider", &provider);
|
||||
if (CONFIG_TRUE != rc)
|
||||
{
|
||||
WFD_ERROR("missing log provider");
|
||||
result = false;
|
||||
}
|
||||
|
||||
char const * level_str;
|
||||
if (result)
|
||||
{
|
||||
rc = config_lookup_string(config, "log.level", &level_str);
|
||||
if (CONFIG_TRUE != rc)
|
||||
{
|
||||
WFD_ERROR("missing log level");
|
||||
result = false;
|
||||
}
|
||||
}
|
||||
|
||||
int level;
|
||||
if (result)
|
||||
{
|
||||
bool success = wfd_log_level_parse(level_str, &level);
|
||||
if (!success)
|
||||
{
|
||||
WFD_ERROR("failed to parse log level: unknown valuie \'%s\'", level_str);
|
||||
result = false;
|
||||
}
|
||||
}
|
||||
|
||||
if (result)
|
||||
{
|
||||
config_setting_t * setting = config_lookup(config, "log.settings");
|
||||
struct wfd_settings settings;
|
||||
wfd_settings_init(&settings, setting);
|
||||
result = wfd_config_builder_set_logger(builder, provider, level, &settings);
|
||||
wfd_settings_cleanup(&settings);
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static bool
|
||||
wfd_config_read_server(
|
||||
config_t * config,
|
||||
struct wfd_config_builder builder)
|
||||
{
|
||||
char const * vhost_name;
|
||||
int rc = config_lookup_string(config, "server.vhost_name", &vhost_name);
|
||||
if (CONFIG_TRUE == rc)
|
||||
{
|
||||
wfd_config_builder_set_server_vhostname(builder, vhost_name);
|
||||
}
|
||||
|
||||
int port;
|
||||
rc = config_lookup_int(config, "server.port", &port);
|
||||
if (CONFIG_TRUE == rc)
|
||||
{
|
||||
wfd_config_builder_set_server_port(builder, port);
|
||||
}
|
||||
|
||||
char const * cert;
|
||||
rc = config_lookup_string(config, "server.tls.certificate", &cert);
|
||||
if (CONFIG_TRUE == rc)
|
||||
{
|
||||
wfd_config_builder_set_server_cert(builder, cert);
|
||||
}
|
||||
|
||||
char const * key;
|
||||
rc = config_lookup_string(config, "server.tls.key", &key);
|
||||
if (CONFIG_TRUE == rc)
|
||||
{
|
||||
wfd_config_builder_set_server_key(builder, key);
|
||||
}
|
||||
|
||||
char const * doc_root;
|
||||
rc = config_lookup_string(config, "server.document_root", &doc_root);
|
||||
if (CONFIG_TRUE == rc)
|
||||
{
|
||||
wfd_config_builder_set_server_document_root(builder, doc_root);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool
|
||||
wfd_config_read_authenticator(
|
||||
config_setting_t * authenticator,
|
||||
struct wfd_config_builder builder)
|
||||
{
|
||||
bool result = (NULL != authenticator);
|
||||
|
||||
char const * provider_name = NULL;
|
||||
if (result)
|
||||
{
|
||||
int rc = config_setting_lookup_string(authenticator, "provider", &provider_name);
|
||||
if (CONFIG_TRUE != rc)
|
||||
{
|
||||
WFD_ERROR("missing authentication provider");
|
||||
result = false;
|
||||
}
|
||||
}
|
||||
|
||||
struct config_setting_t * settings = NULL;
|
||||
if (result)
|
||||
{
|
||||
settings = config_setting_lookup(authenticator, "settings");
|
||||
if (NULL == settings)
|
||||
{
|
||||
WFD_ERROR("missing authentication settings");
|
||||
result = false;
|
||||
}
|
||||
}
|
||||
|
||||
if (result)
|
||||
{
|
||||
struct wfd_settings auth_settings;
|
||||
wfd_settings_init(&auth_settings, settings);
|
||||
|
||||
result = wfd_config_builder_add_auth_provider(builder, provider_name, &auth_settings);
|
||||
wfd_settings_cleanup(&auth_settings);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static bool
|
||||
wfd_config_read_authentication(
|
||||
config_t * config,
|
||||
struct wfd_config_builder builder)
|
||||
{
|
||||
bool result = true;
|
||||
|
||||
config_setting_t * authentication = config_lookup(config, "authentication");
|
||||
if (NULL != authentication)
|
||||
{
|
||||
int length = config_setting_length(authentication);
|
||||
for (int i = 0; (result) && (i < length); i++)
|
||||
{
|
||||
config_setting_t * authenticator = config_setting_get_elem(authentication, i);
|
||||
result = wfd_config_read_authenticator(authenticator, builder);
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static bool
|
||||
wfd_config_read_filesystems(
|
||||
config_t * config,
|
||||
struct wfd_config_builder builder)
|
||||
{
|
||||
bool result = true;
|
||||
config_setting_t * filesystems = config_lookup(config, "filesystems");
|
||||
if (NULL != filesystems)
|
||||
{
|
||||
int length = config_setting_length(filesystems);
|
||||
for (int i = 0; i < length; i++)
|
||||
{
|
||||
config_setting_t * fs = config_setting_get_elem(filesystems, i);
|
||||
if (NULL == fs)
|
||||
{
|
||||
WFD_ERROR("failed to load config: invalid filesystem section");
|
||||
result = false;
|
||||
break;
|
||||
}
|
||||
|
||||
char const * name;
|
||||
int rc = config_setting_lookup_string(fs, "name", &name);
|
||||
if (rc != CONFIG_TRUE)
|
||||
{
|
||||
WFD_ERROR("failed to load config: missing required filesystem property \'name\'");
|
||||
result = false;
|
||||
break;
|
||||
}
|
||||
|
||||
char const * mount_point;
|
||||
rc = config_setting_lookup_string(fs, "mount_point", &mount_point);
|
||||
if (rc != CONFIG_TRUE)
|
||||
{
|
||||
WFD_ERROR("failed to load config: missing required filesystem property \'mount_point\'");
|
||||
result = false;
|
||||
break;
|
||||
}
|
||||
|
||||
result = wfd_config_builder_add_filesystem(builder, name, mount_point);
|
||||
if (!result)
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static bool
|
||||
wfd_config_load(
|
||||
struct wfd_config_builder builder,
|
||||
config_t * config)
|
||||
{
|
||||
|
||||
bool result = wfd_config_check_version(config)
|
||||
&& wfd_config_read_logger(config, builder)
|
||||
&& wfd_config_read_server(config, builder)
|
||||
&& wfd_config_read_authentication(config, builder)
|
||||
&& wfd_config_read_filesystems(config, builder)
|
||||
;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
bool
|
||||
wfd_config_load_file(
|
||||
struct wfd_config_builder builder,
|
||||
char const * filename)
|
||||
{
|
||||
bool result = false;
|
||||
|
||||
config_t config;
|
||||
config_init(&config);
|
||||
int rc = config_read_file(&config, filename);
|
||||
if (CONFIG_TRUE == rc)
|
||||
{
|
||||
result = wfd_config_load(builder, &config);
|
||||
}
|
||||
else
|
||||
{
|
||||
WFD_ERROR("failed to load config: %s: %d: %s",
|
||||
config_error_file(&config),
|
||||
config_error_line(&config),
|
||||
config_error_text(&config));
|
||||
}
|
||||
config_destroy(&config);
|
||||
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
bool
|
||||
wfd_config_load_string(
|
||||
struct wfd_config_builder builder,
|
||||
char const * contents)
|
||||
{
|
||||
bool result = false;
|
||||
|
||||
config_t config;
|
||||
config_init(&config);
|
||||
int rc = config_read_string(&config, contents);
|
||||
if (CONFIG_TRUE == rc)
|
||||
{
|
||||
result = wfd_config_load(builder, &config);
|
||||
}
|
||||
else
|
||||
{
|
||||
WFD_ERROR("failed to load config: %d: %s",
|
||||
config_error_line(&config),
|
||||
config_error_text(&config));
|
||||
}
|
||||
config_destroy(&config);
|
||||
|
||||
|
||||
return result;
|
||||
}
|
||||
@ -0,0 +1,29 @@
|
||||
#ifndef WFD_CONFIG_FACTORY_H
|
||||
#define WFD_CONFIG_FACTORY_H
|
||||
|
||||
#ifndef __cplusplus
|
||||
#include <stdbool.h>
|
||||
#endif
|
||||
|
||||
#include "webfused/config/builder.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
extern bool
|
||||
wfd_config_load_file(
|
||||
struct wfd_config_builder builder,
|
||||
char const * filename);
|
||||
|
||||
extern bool
|
||||
wfd_config_load_string(
|
||||
struct wfd_config_builder builder,
|
||||
char const * contents);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,60 @@
|
||||
#include "webfused/config/settings.h"
|
||||
#include "webfused/config/settings_intern.h"
|
||||
|
||||
#include <libconfig.h>
|
||||
#include <stddef.h>
|
||||
|
||||
void
|
||||
wfd_settings_init(
|
||||
struct wfd_settings * settings,
|
||||
struct config_setting_t * setting)
|
||||
{
|
||||
settings->setting = setting;
|
||||
}
|
||||
|
||||
void
|
||||
wfd_settings_cleanup(
|
||||
struct wfd_settings * settings)
|
||||
{
|
||||
settings->setting = NULL;
|
||||
}
|
||||
|
||||
char const *
|
||||
wfd_settings_get_string(
|
||||
struct wfd_settings * settings,
|
||||
char const * key)
|
||||
{
|
||||
if (NULL == settings) {return NULL; }
|
||||
|
||||
char const * result;
|
||||
int rc = config_setting_lookup_string(settings->setting, key, &result);
|
||||
|
||||
return (CONFIG_TRUE == rc) ? result : NULL;
|
||||
}
|
||||
|
||||
char const *
|
||||
wfd_settings_get_string_or_default(
|
||||
struct wfd_settings * settings,
|
||||
char const * key,
|
||||
char const * default_value)
|
||||
{
|
||||
if (NULL == settings) {return default_value; }
|
||||
|
||||
char const * result;
|
||||
int rc = config_setting_lookup_string(settings->setting, key, &result);
|
||||
|
||||
return (CONFIG_TRUE == rc) ? result : default_value;
|
||||
}
|
||||
|
||||
bool
|
||||
wfd_settings_get_bool(
|
||||
struct wfd_settings * settings,
|
||||
char const * key)
|
||||
{
|
||||
if (NULL == settings) {return false; }
|
||||
|
||||
int result;
|
||||
int rc = config_setting_lookup_bool(settings->setting, key, &result);
|
||||
|
||||
return ((CONFIG_TRUE == rc) && (CONFIG_TRUE == result));
|
||||
}
|
||||
@ -0,0 +1,37 @@
|
||||
#ifndef WFD_CONFIG_SETTINGS_H
|
||||
#define WFD_CONFIG_SETTINGS_H
|
||||
|
||||
#ifndef __cplusplus
|
||||
#include <stdbool.h>
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
struct wfd_settings;
|
||||
|
||||
|
||||
extern char const *
|
||||
wfd_settings_get_string(
|
||||
struct wfd_settings * settings,
|
||||
char const * key);
|
||||
|
||||
extern char const *
|
||||
wfd_settings_get_string_or_default(
|
||||
struct wfd_settings * settings,
|
||||
char const * key,
|
||||
char const * default_value);
|
||||
|
||||
extern bool
|
||||
wfd_settings_get_bool(
|
||||
struct wfd_settings * settings,
|
||||
char const * key);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,30 @@
|
||||
#ifndef WFD_CONFIG_SETTINGS_INTERN_H
|
||||
#define WFD_CONFIG_SETTINGS_INTERN_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
struct config_setting_t;
|
||||
|
||||
struct wfd_settings
|
||||
{
|
||||
struct config_setting_t * setting;
|
||||
};
|
||||
|
||||
|
||||
extern void
|
||||
wfd_settings_init(
|
||||
struct wfd_settings * settings,
|
||||
struct config_setting_t * setting);
|
||||
|
||||
extern void
|
||||
wfd_settings_cleanup(
|
||||
struct wfd_settings * settings);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,151 @@
|
||||
#include "webfused/daemon.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stddef.h>
|
||||
#include <stdbool.h>
|
||||
#include <signal.h>
|
||||
|
||||
#include <unistd.h>
|
||||
#include <getopt.h>
|
||||
|
||||
#include <webfuse_adapter.h>
|
||||
#include "webfused/config/config.h"
|
||||
#include "webfused/config/factory.h"
|
||||
#include "webfused/log/log.h"
|
||||
#include "webfused/log/logger.h"
|
||||
#include "webfused/log/stderr_logger.h"
|
||||
|
||||
#define WFD_SERVICE_TIMEOUT (1 * 1000)
|
||||
#define WFD_DEFAULT_CONFIG_FILE ("/etc/webfuse.conf")
|
||||
|
||||
struct args
|
||||
{
|
||||
char * config_file;
|
||||
bool show_help;
|
||||
};
|
||||
|
||||
static bool shutdown_requested = false;
|
||||
|
||||
static void show_help(void)
|
||||
{
|
||||
printf(
|
||||
"webfused, Copyright (c) 2019-2020, webfused authors <https://github.com/falk-werner/webfused>\n"
|
||||
"Websocket file system daemon\n"
|
||||
"\n"
|
||||
"Usage: webfused [-f <config file>] | -h\n"
|
||||
"\n"
|
||||
"Options:\n"
|
||||
"\t-f, --config-file Path to config file (default: /etc/webfuse.conf)\n"
|
||||
"\t-h, --help Print this message and terminate\n"
|
||||
"\n");
|
||||
}
|
||||
|
||||
static int parse_arguments(int argc, char * argv[], struct args * args)
|
||||
{
|
||||
static struct option const options[] =
|
||||
{
|
||||
{"config-file", required_argument, NULL, 'f'},
|
||||
{"help", no_argument, NULL, 'h'},
|
||||
{NULL, 0, NULL, 0}
|
||||
};
|
||||
|
||||
args->config_file = strdup(WFD_DEFAULT_CONFIG_FILE);
|
||||
args->show_help = false;
|
||||
|
||||
bool result = EXIT_SUCCESS;
|
||||
bool finished = false;
|
||||
optind = 0;
|
||||
while ((!finished) && (EXIT_SUCCESS == result))
|
||||
{
|
||||
int option_index = 0;
|
||||
int const c = getopt_long(argc, argv, "f:h", options, &option_index);
|
||||
|
||||
switch (c)
|
||||
{
|
||||
case -1:
|
||||
finished = true;
|
||||
break;
|
||||
case 'h':
|
||||
args->show_help = true;
|
||||
finished = true;
|
||||
break;
|
||||
case 'f':
|
||||
free(args->config_file);
|
||||
args->config_file = strdup(optarg);
|
||||
break;
|
||||
default:
|
||||
fprintf(stderr, "error: unknown argument\n");
|
||||
result = EXIT_FAILURE;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (EXIT_SUCCESS != result)
|
||||
{
|
||||
args->show_help = true;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static void on_interrupt(int signal_id)
|
||||
{
|
||||
(void) signal_id;
|
||||
|
||||
shutdown_requested = true;
|
||||
}
|
||||
|
||||
int wfd_daemon_run(int argc, char * argv[])
|
||||
{
|
||||
wfd_stderr_logger_init(WFD_LOGLEVEL_ALL, NULL);
|
||||
|
||||
struct args args;
|
||||
int result = parse_arguments(argc, argv, &args);
|
||||
|
||||
if (!args.show_help)
|
||||
{
|
||||
signal(SIGINT, on_interrupt);
|
||||
|
||||
struct wfd_config * config = wfd_config_create();
|
||||
struct wfd_config_builder builder = wfd_config_get_builder(config);
|
||||
bool success = wfd_config_load_file(builder, args.config_file);
|
||||
if (success)
|
||||
{
|
||||
struct wf_server_config * server_config = wfd_config_get_server_config(config);
|
||||
struct wf_server * server = wf_server_create(server_config);
|
||||
if (NULL != server)
|
||||
{
|
||||
while (!shutdown_requested)
|
||||
{
|
||||
wf_server_service(server, WFD_SERVICE_TIMEOUT);
|
||||
}
|
||||
|
||||
wf_server_dispose(server);
|
||||
}
|
||||
else
|
||||
{
|
||||
fprintf(stderr, "fatal: unable start server\n");
|
||||
result = EXIT_FAILURE;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
fprintf(stderr, "fatal: failed to load server config\n");
|
||||
result = EXIT_FAILURE;
|
||||
}
|
||||
|
||||
wfd_config_dispose(config);
|
||||
}
|
||||
else
|
||||
{
|
||||
show_help();
|
||||
}
|
||||
|
||||
wfd_logger_close();
|
||||
free(args.config_file);
|
||||
shutdown_requested = false;
|
||||
return result;
|
||||
}
|
||||
|
||||
@ -0,0 +1,15 @@
|
||||
#ifndef WFD_DAEMON_H
|
||||
#define WFD_DAEMON_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
extern int wfd_daemon_run(int argc, char * argv[]);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,62 @@
|
||||
#include "webfused/log/log.h"
|
||||
#include <strings.h>
|
||||
|
||||
char const *
|
||||
wfd_log_level_tostring(int level)
|
||||
{
|
||||
switch (level)
|
||||
{
|
||||
case WFD_LOGLEVEL_NONE: return "none";
|
||||
case WFD_LOGLEVEL_FATAL: return "fatal";
|
||||
case WFD_LOGLEVEL_ERROR: return "error";
|
||||
case WFD_LOGLEVEL_WARN: return "warn";
|
||||
case WFD_LOGLEVEL_INFO: return "info";
|
||||
case WFD_LOGLEVEL_DEBUG: return "debug";
|
||||
case WFD_LOGLEVEL_ALL: return "all";
|
||||
default: return "<unknown>";
|
||||
}
|
||||
}
|
||||
|
||||
bool
|
||||
wfd_log_level_parse(
|
||||
char const * level,
|
||||
int * result)
|
||||
{
|
||||
bool success = true;
|
||||
|
||||
if (0 == strcasecmp("all", level))
|
||||
{
|
||||
*result = WFD_LOGLEVEL_ALL;
|
||||
}
|
||||
else if (0 == strcasecmp("none", level))
|
||||
{
|
||||
*result = WFD_LOGLEVEL_NONE;
|
||||
}
|
||||
else if (0 == strcasecmp("fatal", level))
|
||||
{
|
||||
*result = WFD_LOGLEVEL_FATAL;
|
||||
}
|
||||
else if (0 == strcasecmp("error", level))
|
||||
{
|
||||
*result = WFD_LOGLEVEL_ERROR;
|
||||
}
|
||||
else if ((0 == strcasecmp("warn", level)) ||
|
||||
(0 == strcasecmp("warning", level)))
|
||||
{
|
||||
*result = WFD_LOGLEVEL_WARN;
|
||||
}
|
||||
else if (0 == strcasecmp("info", level))
|
||||
{
|
||||
*result = WFD_LOGLEVEL_INFO;
|
||||
}
|
||||
else if (0 == strcasecmp("debug", level))
|
||||
{
|
||||
*result = WFD_LOGLEVEL_DEBUG;
|
||||
}
|
||||
else
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
return success;
|
||||
}
|
||||
@ -0,0 +1,68 @@
|
||||
#ifndef WFD_LOG_H
|
||||
#define WFD_LOG_H
|
||||
|
||||
#ifndef __cplusplus
|
||||
#include <stdbool.h>
|
||||
#include <stdarg.h>
|
||||
#else
|
||||
#include <cstdarg>
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
#ifndef WFD_LOGLEVEL
|
||||
#define WFD_LOGLEVEL WFD_LOGLEVEL_ALL
|
||||
#endif
|
||||
|
||||
#define WFD_LOGLEVEL_NONE -1
|
||||
#define WFD_LOGLEVEL_FATAL 1
|
||||
#define WFD_LOGLEVEL_ERROR 3
|
||||
#define WFD_LOGLEVEL_WARN 4
|
||||
#define WFD_LOGLEVEL_INFO 5
|
||||
#define WFD_LOGLEVEL_DEBUG 7
|
||||
#define WFD_LOGLEVEL_ALL 8
|
||||
|
||||
#define WFD_FATAL(...) \
|
||||
WFD_LOG(WFD_LOGLEVEL_FATAL, __VA_ARGS__)
|
||||
|
||||
#define WFD_ERROR(...) \
|
||||
WFD_LOG(WFD_LOGLEVEL_ERROR, __VA_ARGS__)
|
||||
|
||||
#define WFD_WARN(...) \
|
||||
WFD_LOG(WFD_LOGLEVEL_WARN, __VA_ARGS__)
|
||||
|
||||
#define WFD_INFO(...) \
|
||||
WFD_LOG(WFD_LOGLEVEL_INFO, __VA_ARGS__)
|
||||
|
||||
#define WFD_DEBUG(...) \
|
||||
WFD_LOG(WFD_LOGLEVEL_DEBUG, __VA_ARGS__)
|
||||
|
||||
#define WFD_LOG(level, ...) \
|
||||
do { \
|
||||
if (WFD_LOGLEVEL >= (level)) { \
|
||||
wfd_log((level), __VA_ARGS__); \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
extern void
|
||||
wfd_log(
|
||||
int level,
|
||||
char const * format,
|
||||
...);
|
||||
|
||||
extern char const *
|
||||
wfd_log_level_tostring(int level);
|
||||
|
||||
extern bool
|
||||
wfd_log_level_parse(
|
||||
char const * level,
|
||||
int * result);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,86 @@
|
||||
#include "webfused/log/logger.h"
|
||||
#include "webfused/log/log.h"
|
||||
|
||||
#include <stddef.h>
|
||||
|
||||
struct wfd_logger
|
||||
{
|
||||
int level;
|
||||
wfd_logger_log_fn * log;
|
||||
wfd_logger_onclose_fn * onclose;
|
||||
void * user_data;
|
||||
};
|
||||
|
||||
static void wfd_logger_default_log(
|
||||
void * user_data,
|
||||
int level,
|
||||
char const * format,
|
||||
va_list args);
|
||||
|
||||
static struct wfd_logger g_wfd_logger =
|
||||
{
|
||||
.level = WFD_LOGLEVEL_ALL,
|
||||
.log = &wfd_logger_default_log,
|
||||
.onclose = NULL,
|
||||
.user_data = NULL
|
||||
};
|
||||
|
||||
void
|
||||
wfd_logger_init(
|
||||
int level,
|
||||
wfd_logger_log_fn * log,
|
||||
wfd_logger_onclose_fn * onclose,
|
||||
void * user_data)
|
||||
{
|
||||
wfd_logger_close();
|
||||
|
||||
g_wfd_logger.level = level;
|
||||
g_wfd_logger.log = log;
|
||||
g_wfd_logger.onclose = onclose;
|
||||
g_wfd_logger.user_data = user_data;
|
||||
}
|
||||
|
||||
void
|
||||
wfd_logger_close(void)
|
||||
{
|
||||
if (NULL != g_wfd_logger.onclose)
|
||||
{
|
||||
g_wfd_logger.onclose(g_wfd_logger.user_data);
|
||||
}
|
||||
|
||||
g_wfd_logger.level = WFD_LOGLEVEL_ALL;
|
||||
g_wfd_logger.log = &wfd_logger_default_log;
|
||||
g_wfd_logger.onclose = NULL;
|
||||
g_wfd_logger.user_data = NULL;
|
||||
}
|
||||
|
||||
void
|
||||
wfd_log(
|
||||
int level,
|
||||
char const * format,
|
||||
...)
|
||||
{
|
||||
if (g_wfd_logger.level >= level)
|
||||
{
|
||||
va_list args;
|
||||
va_start(args, format);
|
||||
g_wfd_logger.log(
|
||||
g_wfd_logger.user_data,
|
||||
level,
|
||||
format,
|
||||
args);
|
||||
va_end(args);
|
||||
}
|
||||
}
|
||||
|
||||
static void wfd_logger_default_log(
|
||||
void * user_data,
|
||||
int level,
|
||||
char const * format,
|
||||
va_list args)
|
||||
{
|
||||
(void) user_data;
|
||||
(void) level;
|
||||
(void) format;
|
||||
(void) args;
|
||||
}
|
||||
@ -0,0 +1,40 @@
|
||||
#ifndef WFD_LOGGER_H
|
||||
#define WFD_LOGGER_H
|
||||
|
||||
#ifndef __cplusplus
|
||||
#include <stdarg.h>
|
||||
#else
|
||||
#include <cstdarg>
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
typedef void
|
||||
wfd_logger_log_fn(
|
||||
void * user_data,
|
||||
int level,
|
||||
char const * format,
|
||||
va_list args);
|
||||
|
||||
typedef void
|
||||
wfd_logger_onclose_fn(
|
||||
void * user_data);
|
||||
|
||||
extern void
|
||||
wfd_logger_init(
|
||||
int level,
|
||||
wfd_logger_log_fn * log,
|
||||
wfd_logger_onclose_fn * onclose,
|
||||
void * user_data);
|
||||
|
||||
extern void
|
||||
wfd_logger_close(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,30 @@
|
||||
#include "webfused/log/manager.h"
|
||||
#include "webfused/log/log.h"
|
||||
#include "webfused/log/stderr_logger.h"
|
||||
#include "webfused/log/syslog_logger.h"
|
||||
|
||||
#include <string.h>
|
||||
|
||||
bool
|
||||
wfd_log_manager_set_logger(
|
||||
char const * provider,
|
||||
int level,
|
||||
struct wfd_settings * settings)
|
||||
{
|
||||
bool result = false;
|
||||
|
||||
if (0 == strcmp("syslog", provider))
|
||||
{
|
||||
result = wfd_syslog_logger_init(level, settings);
|
||||
}
|
||||
else if (0 == strcmp("stderr", provider))
|
||||
{
|
||||
result = wfd_stderr_logger_init(level, settings);
|
||||
}
|
||||
else
|
||||
{
|
||||
WFD_ERROR("failed to init log: unknown provider \'%s\'", provider);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
@ -0,0 +1,25 @@
|
||||
#ifndef WFD_LOG_MANAGER_H
|
||||
#define WFD_LOG_MANAGER_H
|
||||
|
||||
#ifndef __cplusplus
|
||||
#include <stdbool.h>
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
struct wfd_settings;
|
||||
|
||||
extern bool
|
||||
wfd_log_manager_set_logger(
|
||||
char const * provider,
|
||||
int level,
|
||||
struct wfd_settings * settings);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,29 @@
|
||||
#include "webfused/log/stderr_logger.h"
|
||||
#include "webfused/log/logger.h"
|
||||
#include "webfused/log/log.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
static void
|
||||
wfd_stderr_logger_log(
|
||||
void * user_data,
|
||||
int level,
|
||||
char const * format,
|
||||
va_list args)
|
||||
{
|
||||
fprintf(stderr, "%s: ", wfd_log_level_tostring(level));
|
||||
vfprintf(stderr, format, args);
|
||||
fprintf(stderr, "\n");
|
||||
}
|
||||
|
||||
bool
|
||||
wfd_stderr_logger_init(
|
||||
int level,
|
||||
struct wfd_settings * settings)
|
||||
{
|
||||
(void) settings;
|
||||
|
||||
wfd_logger_init(level, &wfd_stderr_logger_log, NULL, NULL);
|
||||
return true;
|
||||
}
|
||||
@ -0,0 +1,24 @@
|
||||
#ifndef WFD_LOG_STDERR_LOGGER_H
|
||||
#define WFD_LOG_STDERR_LOGGER_H
|
||||
|
||||
#ifndef __cplusplus
|
||||
#include <stdbool.h>
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
struct wfd_settings;
|
||||
|
||||
extern bool
|
||||
wfd_stderr_logger_init(
|
||||
int level,
|
||||
struct wfd_settings * settings);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,122 @@
|
||||
#include "webfused/log/syslog_logger.h"
|
||||
#include "webfused/log/logger.h"
|
||||
#include "webfused/log/log.h"
|
||||
#include "webfused/config/settings.h"
|
||||
|
||||
#include <syslog.h>
|
||||
#include <strings.h>
|
||||
|
||||
#include <stddef.h>
|
||||
|
||||
static int
|
||||
wfd_syslog_logger_to_priority(
|
||||
int level)
|
||||
{
|
||||
switch (level)
|
||||
{
|
||||
case WFD_LOGLEVEL_FATAL: return LOG_CRIT;
|
||||
case WFD_LOGLEVEL_ERROR: return LOG_ERR;
|
||||
case WFD_LOGLEVEL_WARN: return LOG_WARNING;
|
||||
case WFD_LOGLEVEL_INFO: return LOG_INFO;
|
||||
case WFD_LOGLEVEL_DEBUG: return LOG_DEBUG;
|
||||
default: return LOG_NOTICE;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
wfd_syslog_logger_log(
|
||||
void * user_data,
|
||||
int level,
|
||||
char const * format,
|
||||
va_list args)
|
||||
{
|
||||
(void) user_data;
|
||||
|
||||
int prio = wfd_syslog_logger_to_priority(level);
|
||||
vsyslog(prio, format, args);
|
||||
}
|
||||
|
||||
static void
|
||||
wfd_syslog_logger_close(
|
||||
void * user_data)
|
||||
{
|
||||
closelog();
|
||||
}
|
||||
|
||||
struct wfd_syslog_facility
|
||||
{
|
||||
char const * name;
|
||||
int value;
|
||||
};
|
||||
|
||||
static bool
|
||||
wfd_syslog_logger_parse_facility(
|
||||
char const * facility,
|
||||
int * result)
|
||||
{
|
||||
static struct wfd_syslog_facility const facilities[] =
|
||||
{
|
||||
{"auth", LOG_AUTH},
|
||||
{"authpriv", LOG_AUTHPRIV},
|
||||
{"cron", LOG_CRON},
|
||||
{"daemon", LOG_DAEMON},
|
||||
{"fpt", LOG_FTP},
|
||||
{"kern", LOG_KERN},
|
||||
{"local0", LOG_LOCAL0},
|
||||
{"local1", LOG_LOCAL1},
|
||||
{"local2", LOG_LOCAL2},
|
||||
{"local3", LOG_LOCAL3},
|
||||
{"local4", LOG_LOCAL4},
|
||||
{"local5", LOG_LOCAL5},
|
||||
{"local6", LOG_LOCAL6},
|
||||
{"local7", LOG_LOCAL7},
|
||||
{"lpr", LOG_LPR},
|
||||
{"mail", LOG_MAIL},
|
||||
{"news", LOG_NEWS},
|
||||
{"syslog", LOG_SYSLOG},
|
||||
{"user", LOG_USER},
|
||||
{"uucp", LOG_UUCP}
|
||||
};
|
||||
static size_t const facilites_count = sizeof(facilities) / sizeof(facilities[0]);
|
||||
|
||||
for (size_t i = 0; i < facilites_count; i++)
|
||||
{
|
||||
if (0 == strcasecmp(facility, facilities[i].name))
|
||||
{
|
||||
*result = facilities[i].value;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
bool
|
||||
wfd_syslog_logger_init(
|
||||
int level,
|
||||
struct wfd_settings * settings)
|
||||
{
|
||||
char const * ident = wfd_settings_get_string_or_default(settings, "ident", "webfused");
|
||||
char const * facility_str = wfd_settings_get_string_or_default(settings, "facility", "daemon");
|
||||
bool log_pid = wfd_settings_get_bool(settings, "log_pid");
|
||||
|
||||
int facility;
|
||||
bool result = wfd_syslog_logger_parse_facility(facility_str, &facility);
|
||||
if (result)
|
||||
{
|
||||
int options = (log_pid) ? LOG_PID : 0;
|
||||
wfd_logger_init(level,
|
||||
&wfd_syslog_logger_log,
|
||||
&wfd_syslog_logger_close,
|
||||
NULL);
|
||||
|
||||
openlog(ident, options, facility);
|
||||
}
|
||||
else
|
||||
{
|
||||
WFD_ERROR("failed to init syslog logger: invalid log facility: \'%s\'", facility_str);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
@ -0,0 +1,24 @@
|
||||
#ifndef WFD_LOG_SYSLOG_LOGGER_H
|
||||
#define WFD_LOG_SYSLOG_LOGGER_H
|
||||
|
||||
#ifndef __cplusplus
|
||||
#include <stdbool.h>
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
struct wfd_settings;
|
||||
|
||||
extern bool
|
||||
wfd_syslog_logger_init(
|
||||
int level,
|
||||
struct wfd_settings * settings);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,6 @@
|
||||
#include "webfused/daemon.h"
|
||||
|
||||
int main(int argc, char * argv[])
|
||||
{
|
||||
return wfd_daemon_run(argc, argv);
|
||||
}
|
||||
@ -0,0 +1,150 @@
|
||||
#include "webfused/mountpoint_factory.h"
|
||||
#include "webfused/log/log.h"
|
||||
|
||||
#include <webfuse/adapter/mountpoint.h>
|
||||
|
||||
#include <sys/stat.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#define WFD_FILESYSTEM_DEFAULT_CAPACITY 16
|
||||
|
||||
struct wfd_filesystem
|
||||
{
|
||||
char * name;
|
||||
char * mount_point;
|
||||
bool in_use;
|
||||
};
|
||||
|
||||
struct wfd_mountpoint_factory
|
||||
{
|
||||
struct wfd_filesystem * filesystems;
|
||||
size_t capacity;
|
||||
size_t count;
|
||||
};
|
||||
|
||||
static struct wfd_filesystem *
|
||||
wfd_mountpoint_factory_find(
|
||||
struct wfd_mountpoint_factory * factory,
|
||||
char const * name)
|
||||
{
|
||||
for (size_t i = 0; i < factory->count; i++)
|
||||
{
|
||||
struct wfd_filesystem * filesystem = &(factory->filesystems[i]);
|
||||
if (0 == strcmp(name, filesystem->name))
|
||||
{
|
||||
return filesystem;
|
||||
}
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void
|
||||
wfd_mountpoint_factory_release_mountpoint(
|
||||
void * user_data)
|
||||
{
|
||||
bool * in_use = user_data;
|
||||
*in_use = false;
|
||||
}
|
||||
|
||||
struct wfd_mountpoint_factory *
|
||||
wfd_mountpoint_factory_create(void)
|
||||
{
|
||||
struct wfd_mountpoint_factory * factory = malloc(sizeof(struct wfd_mountpoint_factory));
|
||||
factory->filesystems = malloc(sizeof(struct wfd_filesystem) * WFD_FILESYSTEM_DEFAULT_CAPACITY);
|
||||
factory->count = 0;
|
||||
factory->capacity = WFD_FILESYSTEM_DEFAULT_CAPACITY;
|
||||
|
||||
return factory;
|
||||
}
|
||||
|
||||
void
|
||||
wfd_mountpoint_factory_dispose(
|
||||
struct wfd_mountpoint_factory * factory)
|
||||
{
|
||||
for(size_t i = 0; i < factory->count; i++)
|
||||
{
|
||||
struct wfd_filesystem * filesystem = &(factory->filesystems[i]);
|
||||
free(filesystem->name);
|
||||
free(filesystem->mount_point);
|
||||
}
|
||||
|
||||
free(factory->filesystems);
|
||||
free(factory);
|
||||
}
|
||||
|
||||
bool
|
||||
wfd_mountpoint_factory_add_filesystem(
|
||||
struct wfd_mountpoint_factory * factory,
|
||||
char const * name,
|
||||
char const * mount_point)
|
||||
{
|
||||
bool result = (NULL == wfd_mountpoint_factory_find(factory, name));
|
||||
if (!result)
|
||||
{
|
||||
WFD_ERROR("mount_point already defined: \'%s\'", mount_point);
|
||||
}
|
||||
|
||||
char * path = NULL;
|
||||
if (result)
|
||||
{
|
||||
mkdir(mount_point, 0755);
|
||||
path = realpath(mount_point, NULL);
|
||||
if (NULL == path)
|
||||
{
|
||||
WFD_ERROR("invalid mount_point: \'%s\'", mount_point);
|
||||
result = false;
|
||||
}
|
||||
}
|
||||
|
||||
if (result)
|
||||
{
|
||||
if (factory->count >= factory->capacity)
|
||||
{
|
||||
factory->capacity *= 2;
|
||||
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;
|
||||
actual->in_use = false;
|
||||
factory->count++;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
extern struct wf_mountpoint *
|
||||
wfd_mountpoint_factory_create_mountpoint(
|
||||
char const * filesystem,
|
||||
void * user_data)
|
||||
{
|
||||
struct wfd_mountpoint_factory * factory = user_data;
|
||||
struct wfd_filesystem * fs = wfd_mountpoint_factory_find(factory, filesystem);
|
||||
if (NULL == fs)
|
||||
{
|
||||
WFD_INFO("failed to create mountpoint: filesystem \'%s\' not found", filesystem);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (fs->in_use)
|
||||
{
|
||||
WFD_INFO("failed to create mountpoint: filesystem \'%s\' already in use", filesystem);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
fs->in_use = true;
|
||||
struct wf_mountpoint * result = wf_mountpoint_create(fs->mount_point);
|
||||
wf_mountpoint_set_userdata(result,
|
||||
&fs->in_use, &wfd_mountpoint_factory_release_mountpoint);
|
||||
|
||||
WFD_INFO("create mountpoint \'%s\' at path \'%s\': %s",
|
||||
filesystem,
|
||||
fs->mount_point,
|
||||
result ? "success" : "failure");
|
||||
|
||||
return result;
|
||||
}
|
||||
@ -0,0 +1,39 @@
|
||||
#ifndef WFD_MOUNTPOINT_FACTORY_H
|
||||
#define WFD_MOUNTPOINT_FACTORY_H
|
||||
|
||||
#include "webfuse/adapter/mountpoint_factory.h"
|
||||
|
||||
#ifndef __cplusplus
|
||||
#include <stdbool.h>
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
struct wfd_mountpoint_factory;
|
||||
|
||||
extern struct wfd_mountpoint_factory *
|
||||
wfd_mountpoint_factory_create(void);
|
||||
|
||||
extern void
|
||||
wfd_mountpoint_factory_dispose(
|
||||
struct wfd_mountpoint_factory * factory);
|
||||
|
||||
extern bool
|
||||
wfd_mountpoint_factory_add_filesystem(
|
||||
struct wfd_mountpoint_factory * factory,
|
||||
char const * name,
|
||||
char const * mount_point);
|
||||
|
||||
extern struct wf_mountpoint *
|
||||
wfd_mountpoint_factory_create_mountpoint(
|
||||
char const * filesystem,
|
||||
void * user_data);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,4 @@
|
||||
# This config file is invalid,
|
||||
# since "." is not allowed as separator
|
||||
|
||||
version.major = 1
|
||||
@ -0,0 +1,111 @@
|
||||
#include "mock_config_builder.hpp"
|
||||
|
||||
extern "C"
|
||||
{
|
||||
using webfused_test::IConfigBuilder;
|
||||
|
||||
static void
|
||||
wfd_MockConfigBuilder_set_server_vhostname(
|
||||
void * data,
|
||||
char const * vhost_name)
|
||||
{
|
||||
auto * builder = reinterpret_cast<IConfigBuilder*>(data);
|
||||
builder->setServerVhostname(vhost_name);
|
||||
}
|
||||
|
||||
static void
|
||||
wfd_MockConfigBuilder_set_server_port(
|
||||
void * data,
|
||||
int port)
|
||||
{
|
||||
auto * builder = reinterpret_cast<IConfigBuilder*>(data);
|
||||
builder->setServerPort(port);
|
||||
}
|
||||
|
||||
static void
|
||||
wfd_MockConfigBuilder_set_server_key(
|
||||
void * data,
|
||||
char const * key_path)
|
||||
{
|
||||
auto * builder = reinterpret_cast<IConfigBuilder*>(data);
|
||||
builder->setServerKey(key_path);
|
||||
}
|
||||
|
||||
static void
|
||||
wfd_MockConfigBuilder_set_server_cert(
|
||||
void * data,
|
||||
char const * cert_path)
|
||||
{
|
||||
auto * builder = reinterpret_cast<IConfigBuilder*>(data);
|
||||
builder->setServerCert(cert_path);
|
||||
}
|
||||
|
||||
static void
|
||||
wfd_MockConfigBuilder_set_server_document_root(
|
||||
void * data,
|
||||
char const * document_root)
|
||||
{
|
||||
auto * builder = reinterpret_cast<IConfigBuilder*>(data);
|
||||
builder->setServerDocumentRoot(document_root);
|
||||
}
|
||||
|
||||
static bool
|
||||
wfd_MockConfigBuilder_add_auth_provider(
|
||||
void * data,
|
||||
char const * provider,
|
||||
struct wfd_settings * settings)
|
||||
{
|
||||
auto * builder = reinterpret_cast<IConfigBuilder*>(data);
|
||||
return builder->addAuthProvider(provider, settings);
|
||||
}
|
||||
|
||||
static bool
|
||||
wfd_MockConfigBuilder_add_filesystem(
|
||||
void * data,
|
||||
char const * name,
|
||||
char const * mountpoint)
|
||||
{
|
||||
auto * builder = reinterpret_cast<IConfigBuilder*>(data);
|
||||
return builder->addFilesystem(name, mountpoint);
|
||||
}
|
||||
|
||||
static bool
|
||||
wfd_MockConfigBuilder_set_logger(
|
||||
void * data,
|
||||
char const * provider,
|
||||
int level,
|
||||
struct wfd_settings * settings)
|
||||
{
|
||||
auto * builder = reinterpret_cast<IConfigBuilder*>(data);
|
||||
return builder->setLogger(provider, level, settings);
|
||||
}
|
||||
|
||||
|
||||
static const wfd_config_builder_vtable wfd_MockConfigBuilder_vtable =
|
||||
{
|
||||
&wfd_MockConfigBuilder_set_server_vhostname,
|
||||
&wfd_MockConfigBuilder_set_server_port,
|
||||
&wfd_MockConfigBuilder_set_server_key,
|
||||
&wfd_MockConfigBuilder_set_server_cert,
|
||||
&wfd_MockConfigBuilder_set_server_document_root,
|
||||
&wfd_MockConfigBuilder_add_auth_provider,
|
||||
&wfd_MockConfigBuilder_add_filesystem,
|
||||
&wfd_MockConfigBuilder_set_logger
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
namespace webfused_test
|
||||
{
|
||||
struct wfd_config_builder MockConfigBuilder::getBuilder()
|
||||
{
|
||||
IConfigBuilder * config_builder = this;
|
||||
|
||||
wfd_config_builder builder = {
|
||||
&wfd_MockConfigBuilder_vtable,
|
||||
reinterpret_cast<void*>(config_builder)
|
||||
};
|
||||
|
||||
return builder;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,42 @@
|
||||
#ifndef WFD_MOCK_CONFIG_BUILDER_HPP
|
||||
#define WFD_MOCK_CONFIG_BUILDER_HPP
|
||||
|
||||
#include <gmock/gmock.h>
|
||||
#include "webfused/config/builder.h"
|
||||
|
||||
namespace webfused_test
|
||||
{
|
||||
|
||||
class IConfigBuilder
|
||||
{
|
||||
public:
|
||||
virtual ~IConfigBuilder() = default;
|
||||
virtual void setServerVhostname(char const * vhostname) = 0;
|
||||
virtual void setServerPort(int port) = 0;
|
||||
virtual void setServerKey(char const * key_path) = 0;
|
||||
virtual void setServerCert(char const * cert_path) = 0;
|
||||
virtual void setServerDocumentRoot(char const * document_root) = 0;
|
||||
virtual bool addAuthProvider(char const * provider, wfd_settings * settings) = 0;
|
||||
virtual bool addFilesystem(char const * name, char const * mountpoint) = 0;
|
||||
virtual bool setLogger(char const * provider, int level, wfd_settings * settings) = 0;
|
||||
};
|
||||
|
||||
class MockConfigBuilder: public IConfigBuilder
|
||||
{
|
||||
public:
|
||||
~MockConfigBuilder() override = default;
|
||||
MOCK_METHOD1(setServerVhostname, void (char const * vhostname));
|
||||
MOCK_METHOD1(setServerPort, void (int port));
|
||||
MOCK_METHOD1(setServerKey, void (char const * key_path));
|
||||
MOCK_METHOD1(setServerCert, void (char const * cert_path));
|
||||
MOCK_METHOD1(setServerDocumentRoot, void (char const * document_root));
|
||||
MOCK_METHOD2(addAuthProvider, bool (char const * provider, wfd_settings * settings));
|
||||
MOCK_METHOD2(addFilesystem, bool (char const * name, char const * mountpoint));
|
||||
MOCK_METHOD3(setLogger, bool (char const * provider, int level, wfd_settings * settings));
|
||||
|
||||
struct wfd_config_builder getBuilder();
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,64 @@
|
||||
#include "mock_credentials.hpp"
|
||||
|
||||
|
||||
extern "C"
|
||||
{
|
||||
using webfused_test::ICredentials;
|
||||
|
||||
static ICredentials * wfd_mock_credentials = nullptr;
|
||||
|
||||
extern char const *
|
||||
__real_wf_credentials_type(
|
||||
struct wf_credentials const * credentials);
|
||||
|
||||
char const *
|
||||
__wrap_wf_credentials_type(
|
||||
struct wf_credentials const * credentials)
|
||||
{
|
||||
if (nullptr == wfd_mock_credentials)
|
||||
{
|
||||
return __real_wf_credentials_type(credentials);
|
||||
}
|
||||
else
|
||||
{
|
||||
return wfd_mock_credentials->type();
|
||||
}
|
||||
}
|
||||
|
||||
extern char const * __real_wf_credentials_get(
|
||||
struct wf_credentials const * credentials,
|
||||
char const * key);
|
||||
|
||||
|
||||
char const * __wrap_wf_credentials_get(
|
||||
struct wf_credentials const * credentials,
|
||||
char const * key)
|
||||
{
|
||||
if (nullptr == wfd_mock_credentials)
|
||||
{
|
||||
return __real_wf_credentials_get(credentials, key);
|
||||
}
|
||||
else
|
||||
{
|
||||
return wfd_mock_credentials->get(key);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
namespace webfused_test
|
||||
{
|
||||
|
||||
MockCredentials::MockCredentials()
|
||||
{
|
||||
wfd_mock_credentials = this;
|
||||
}
|
||||
|
||||
MockCredentials::~MockCredentials()
|
||||
{
|
||||
wfd_mock_credentials = nullptr;
|
||||
}
|
||||
|
||||
}
|
||||
@ -0,0 +1,29 @@
|
||||
#ifndef WFD_MOCK_CREDENTIALS_HPP
|
||||
#define WFD_MOCK_CREDENTIALS_HPP
|
||||
|
||||
#include <gmock/gmock.h>
|
||||
#include "webfuse/adapter/credentials.h"
|
||||
|
||||
namespace webfused_test
|
||||
{
|
||||
|
||||
class ICredentials
|
||||
{
|
||||
public:
|
||||
virtual ~ICredentials() = default;
|
||||
virtual char const * type() = 0;
|
||||
virtual char const * get(char const * key) = 0;
|
||||
};
|
||||
|
||||
class MockCredentials: public ICredentials
|
||||
{
|
||||
public:
|
||||
MockCredentials();
|
||||
virtual ~MockCredentials();
|
||||
MOCK_METHOD0(type, char const*());
|
||||
MOCK_METHOD1(get, char const *(char const * key));
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,58 @@
|
||||
#include "mock_logger.hpp"
|
||||
#include "webfused/log/logger.h"
|
||||
#include "webfused/log/log.h"
|
||||
|
||||
namespace webfused_test
|
||||
{
|
||||
|
||||
MockLogger::MockLogger(bool omit_init)
|
||||
: close_on_destruct(!omit_init)
|
||||
{
|
||||
if (!omit_init)
|
||||
{
|
||||
wfd_logger_init(
|
||||
WFD_LOGLEVEL_ALL,
|
||||
&wfd_MockLogger_log,
|
||||
&wfd_MockLogger_onclose,
|
||||
getUserData());
|
||||
}
|
||||
}
|
||||
|
||||
MockLogger::~MockLogger()
|
||||
{
|
||||
if (close_on_destruct)
|
||||
{
|
||||
wfd_logger_close();
|
||||
}
|
||||
}
|
||||
|
||||
void * MockLogger::getUserData()
|
||||
{
|
||||
ILogger * logger = this;
|
||||
return reinterpret_cast<void*>(logger);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
extern "C"
|
||||
{
|
||||
using webfused_test::ILogger;
|
||||
|
||||
void wfd_MockLogger_log(
|
||||
void * user_data,
|
||||
int level,
|
||||
char const * format,
|
||||
va_list args)
|
||||
{
|
||||
ILogger * logger = reinterpret_cast<ILogger*>(user_data);
|
||||
logger->log(level, format, args);
|
||||
}
|
||||
|
||||
void wfd_MockLogger_onclose(
|
||||
void * user_data)
|
||||
{
|
||||
ILogger * logger = reinterpret_cast<ILogger*>(user_data);
|
||||
logger->onclose();
|
||||
}
|
||||
|
||||
}
|
||||
@ -0,0 +1,47 @@
|
||||
#ifndef WFD_MOCK_LOGGER_HPP
|
||||
#define WFD_MOCK_LOGGER_HPP
|
||||
|
||||
#include <gmock/gmock.h>
|
||||
#include <cstdarg>
|
||||
|
||||
namespace webfused_test
|
||||
{
|
||||
|
||||
class ILogger
|
||||
{
|
||||
public:
|
||||
virtual ~ILogger() = default;
|
||||
virtual void log(int level, char const * format, va_list args) = 0;
|
||||
virtual void onclose() = 0;
|
||||
};
|
||||
|
||||
class MockLogger: public ILogger
|
||||
{
|
||||
public:
|
||||
explicit MockLogger(bool omit_init = false);
|
||||
~MockLogger() override;
|
||||
MOCK_METHOD3(log, void(int level, char const * format, va_list args));
|
||||
MOCK_METHOD0(onclose, void(void));
|
||||
|
||||
void * getUserData();
|
||||
private:
|
||||
bool close_on_destruct;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
extern "C"
|
||||
{
|
||||
|
||||
extern void wfd_MockLogger_log(
|
||||
void * user_data,
|
||||
int level,
|
||||
char const * format,
|
||||
va_list args);
|
||||
|
||||
extern void wfd_MockLogger_onclose(
|
||||
void * user_data);
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,87 @@
|
||||
#include "mock_settings.hpp"
|
||||
|
||||
extern "C"
|
||||
{
|
||||
using webfused_test::ISettings;
|
||||
|
||||
static ISettings * wfd_mock_settings = nullptr;
|
||||
|
||||
extern char const *
|
||||
__real_wfd_settings_get_string(
|
||||
struct wfd_settings * settings,
|
||||
char const * key);
|
||||
|
||||
extern char const *
|
||||
__real_wfd_settings_get_string_or_default(
|
||||
struct wfd_settings * settings,
|
||||
char const * key,
|
||||
char const * default_value);
|
||||
|
||||
extern bool
|
||||
__real_wfd_settings_get_bool(
|
||||
struct wfd_settings * settings,
|
||||
char const * key);
|
||||
|
||||
char const *
|
||||
__wrap_wfd_settings_get_string(
|
||||
struct wfd_settings * settings,
|
||||
char const * key)
|
||||
{
|
||||
if (nullptr == wfd_mock_settings)
|
||||
{
|
||||
return __real_wfd_settings_get_string(settings, key);
|
||||
}
|
||||
else
|
||||
{
|
||||
return wfd_mock_settings->getString(key);
|
||||
}
|
||||
}
|
||||
|
||||
char const *
|
||||
__wrap_wfd_settings_get_string_or_default(
|
||||
struct wfd_settings * settings,
|
||||
char const * key,
|
||||
char const * default_value)
|
||||
{
|
||||
if (nullptr == wfd_mock_settings)
|
||||
{
|
||||
return __real_wfd_settings_get_string_or_default(
|
||||
settings, key, default_value);
|
||||
}
|
||||
else
|
||||
{
|
||||
return wfd_mock_settings->getStringOrDefault(key, default_value);
|
||||
}
|
||||
}
|
||||
|
||||
bool
|
||||
__wrap_wfd_settings_get_bool(
|
||||
struct wfd_settings * settings,
|
||||
char const * key)
|
||||
{
|
||||
if (nullptr == wfd_mock_settings)
|
||||
{
|
||||
return __real_wfd_settings_get_bool(settings, key);
|
||||
}
|
||||
else
|
||||
{
|
||||
return wfd_mock_settings->getBool(key);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
namespace webfused_test
|
||||
{
|
||||
|
||||
MockSettings::MockSettings()
|
||||
{
|
||||
wfd_mock_settings = this;
|
||||
}
|
||||
|
||||
MockSettings::~MockSettings()
|
||||
{
|
||||
wfd_mock_settings = nullptr;
|
||||
}
|
||||
|
||||
}
|
||||
@ -0,0 +1,33 @@
|
||||
#ifndef WFD_MOCK_AUTH_SETTINGS_HPP
|
||||
#define WFD_MOCK_AUTH_SETTINGS_HPP
|
||||
|
||||
#include <gmock/gmock.h>
|
||||
#include "webfused/config/settings.h"
|
||||
|
||||
namespace webfused_test
|
||||
{
|
||||
|
||||
class ISettings
|
||||
{
|
||||
public:
|
||||
virtual ~ISettings() = default;
|
||||
virtual char const * getString(char const * key) = 0;
|
||||
virtual char const * getStringOrDefault(char const * key, char const * default_value) = 0;
|
||||
virtual bool getBool(char const * key) = 0;
|
||||
};
|
||||
|
||||
class MockSettings: public ISettings
|
||||
{
|
||||
public:
|
||||
MockSettings();
|
||||
~MockSettings() override;
|
||||
MOCK_METHOD1(getString, char const * (char const * key));
|
||||
MOCK_METHOD2(getStringOrDefault, char const * (char const * key, char const * default_value));
|
||||
MOCK_METHOD1(getBool, bool (char const * key));
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,20 @@
|
||||
#include <gtest/gtest.h>
|
||||
#include "webfused/auth/factory.h"
|
||||
#include "webfused/auth/authenticator.h"
|
||||
#include "webfused/log/log.h"
|
||||
#include "mock_logger.hpp"
|
||||
|
||||
using ::testing::_;
|
||||
using ::webfused_test::MockLogger;
|
||||
|
||||
|
||||
TEST(auth_factory, fail_unknown_provider)
|
||||
{
|
||||
MockLogger logger;
|
||||
EXPECT_CALL(logger, log(WFD_LOGLEVEL_ERROR, _, _)).Times(1);
|
||||
EXPECT_CALL(logger, onclose()).Times(1);
|
||||
|
||||
wfd_authenticator authenticator;
|
||||
bool result = wfd_authenticator_create("unknown", NULL, &authenticator);
|
||||
ASSERT_FALSE(result);
|
||||
}
|
||||
@ -0,0 +1,105 @@
|
||||
#include <gtest/gtest.h>
|
||||
#include "webfused/config/config.h"
|
||||
#include "mock_settings.hpp"
|
||||
|
||||
#include "webfused/log/logger.h"
|
||||
#include "webfused/log/log.h"
|
||||
#include "mock_logger.hpp"
|
||||
using ::webfused_test::MockLogger;
|
||||
using ::testing::_;
|
||||
|
||||
using ::webfused_test::MockSettings;
|
||||
using ::testing::Return;
|
||||
using ::testing::StrEq;
|
||||
|
||||
TEST(config, server_config)
|
||||
{
|
||||
wfd_config * config = wfd_config_create();
|
||||
ASSERT_NE(nullptr, config);
|
||||
|
||||
wfd_config_builder builder = wfd_config_get_builder(config);
|
||||
wfd_config_builder_set_server_vhostname(builder, "localhost");
|
||||
wfd_config_builder_set_server_port(builder, 8443);
|
||||
wfd_config_builder_set_server_key(builder, "/path/to/key.pem");
|
||||
wfd_config_builder_set_server_cert(builder, "/path/to/cert.pem");
|
||||
wfd_config_builder_set_server_document_root(builder, "/var/www");
|
||||
|
||||
wf_server_config * server_config = wfd_config_get_server_config(config);
|
||||
ASSERT_NE(nullptr, server_config);
|
||||
|
||||
wfd_config_dispose(config);
|
||||
}
|
||||
|
||||
TEST(config, auth_config)
|
||||
{
|
||||
wfd_config * config = wfd_config_create();
|
||||
ASSERT_NE(nullptr, config);
|
||||
|
||||
wfd_config_builder builder = wfd_config_get_builder(config);
|
||||
|
||||
MockSettings settings;
|
||||
EXPECT_CALL(settings, getString(StrEq("file"))).Times(1).WillOnce(Return("/any/path"));
|
||||
|
||||
bool success = wfd_config_builder_add_auth_provider(builder, "file", nullptr);
|
||||
ASSERT_TRUE(success);
|
||||
|
||||
wfd_config_dispose(config);
|
||||
}
|
||||
|
||||
TEST(config, auth_config_failed_to_add_second_provider)
|
||||
{
|
||||
wfd_config * config = wfd_config_create();
|
||||
ASSERT_NE(nullptr, config);
|
||||
|
||||
wfd_config_builder builder = wfd_config_get_builder(config);
|
||||
|
||||
MockSettings settings;
|
||||
EXPECT_CALL(settings, getString(StrEq("file"))).Times(1).WillOnce(Return("/any/path"));
|
||||
|
||||
bool success = wfd_config_builder_add_auth_provider(builder, "file", nullptr);
|
||||
ASSERT_TRUE(success);
|
||||
|
||||
success = wfd_config_builder_add_auth_provider(builder, "file", nullptr);
|
||||
ASSERT_FALSE(success);
|
||||
|
||||
wfd_config_dispose(config);
|
||||
}
|
||||
|
||||
TEST(config, auth_config_failed_to_add_unknown_provider)
|
||||
{
|
||||
wfd_config * config = wfd_config_create();
|
||||
ASSERT_NE(nullptr, config);
|
||||
|
||||
wfd_config_builder builder = wfd_config_get_builder(config);
|
||||
|
||||
bool success = wfd_config_builder_add_auth_provider(builder, "unknown", nullptr);
|
||||
ASSERT_FALSE(success);
|
||||
|
||||
wfd_config_dispose(config);
|
||||
}
|
||||
|
||||
TEST(config, add_filesystem)
|
||||
{
|
||||
wfd_config * config = wfd_config_create();
|
||||
ASSERT_NE(nullptr, config);
|
||||
|
||||
wfd_config_builder builder = wfd_config_get_builder(config);
|
||||
|
||||
bool success = wfd_config_builder_add_filesystem(builder, "test", "/tmp/test");
|
||||
ASSERT_TRUE(success);
|
||||
|
||||
wfd_config_dispose(config);
|
||||
}
|
||||
|
||||
TEST(config, set_logger)
|
||||
{
|
||||
wfd_config * config = wfd_config_create();
|
||||
ASSERT_NE(nullptr, config);
|
||||
|
||||
wfd_config_builder builder = wfd_config_get_builder(config);
|
||||
|
||||
bool success = wfd_config_builder_set_logger(builder, "stderr", WFD_LOGLEVEL_ALL, nullptr);
|
||||
ASSERT_TRUE(success);
|
||||
|
||||
wfd_config_dispose(config);
|
||||
}
|
||||
@ -0,0 +1,548 @@
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
#include "webfused/config/factory.h"
|
||||
#include "webfused/log/logger.h"
|
||||
#include "webfused/log/log.h"
|
||||
#include "mock_logger.hpp"
|
||||
#include "mock_config_builder.hpp"
|
||||
|
||||
|
||||
using ::testing::_;
|
||||
using ::testing::Return;
|
||||
using ::testing::StrictMock;
|
||||
using ::testing::StrEq;
|
||||
using ::webfused_test::MockLogger;
|
||||
using ::webfused_test::MockConfigBuilder;
|
||||
|
||||
TEST(config, is_loadable)
|
||||
{
|
||||
StrictMock<MockConfigBuilder> builder;
|
||||
EXPECT_CALL(builder, setLogger(_,_,_)).Times(1).WillOnce(Return(true));
|
||||
EXPECT_CALL(builder, setServerVhostname(StrEq("localhost"))).Times(1);
|
||||
EXPECT_CALL(builder, setServerPort(8080)).Times(1);
|
||||
EXPECT_CALL(builder, addAuthProvider(_, _)).Times(1).WillOnce(Return(true));
|
||||
EXPECT_CALL(builder, addFilesystem(_,_)).Times(1).WillOnce(Return(true));
|
||||
|
||||
bool result = wfd_config_load_file(builder.getBuilder(), "webfused.conf");
|
||||
ASSERT_TRUE(result);
|
||||
}
|
||||
|
||||
TEST(config, minimal_config)
|
||||
{
|
||||
MockLogger logger;
|
||||
EXPECT_CALL(logger, log(_, _, _)).Times(0);
|
||||
EXPECT_CALL(logger, onclose()).Times(1);
|
||||
|
||||
StrictMock<MockConfigBuilder> builder;
|
||||
|
||||
char const minimal[] = "version = { major = 1, minor = 0 }\n";
|
||||
bool result = wfd_config_load_string(builder.getBuilder(), minimal);
|
||||
ASSERT_TRUE(result);
|
||||
}
|
||||
|
||||
TEST(config, invalid_config)
|
||||
{
|
||||
MockLogger logger;
|
||||
EXPECT_CALL(logger, log(WFD_LOGLEVEL_ERROR, _, _)).Times(1);
|
||||
EXPECT_CALL(logger, onclose()).Times(1);
|
||||
|
||||
StrictMock<MockConfigBuilder> builder;
|
||||
|
||||
char const syntax_error[] = "version.major = 1\n";
|
||||
|
||||
bool result = wfd_config_load_string(builder.getBuilder(), syntax_error);
|
||||
ASSERT_FALSE(result);
|
||||
}
|
||||
|
||||
TEST(config, invalid_config_file)
|
||||
{
|
||||
MockLogger logger;
|
||||
EXPECT_CALL(logger, log(WFD_LOGLEVEL_ERROR, _, _)).Times(1);
|
||||
EXPECT_CALL(logger, onclose()).Times(1);
|
||||
|
||||
StrictMock<MockConfigBuilder> builder;
|
||||
|
||||
bool result = wfd_config_load_file(builder.getBuilder(), "invalid.conf");
|
||||
ASSERT_FALSE(result);
|
||||
}
|
||||
|
||||
TEST(config, invalid_major_version_too_low)
|
||||
{
|
||||
MockLogger logger;
|
||||
EXPECT_CALL(logger, log(WFD_LOGLEVEL_ERROR, _, _)).Times(1);
|
||||
EXPECT_CALL(logger, onclose()).Times(1);
|
||||
|
||||
StrictMock<MockConfigBuilder> builder;
|
||||
|
||||
char const too_low[] = "version = { major = 0, minor = 0 }\n";
|
||||
|
||||
bool result = wfd_config_load_string(builder.getBuilder(), too_low);
|
||||
ASSERT_FALSE(result);
|
||||
}
|
||||
|
||||
TEST(config, invalid_major_version_too_high)
|
||||
{
|
||||
MockLogger logger;
|
||||
EXPECT_CALL(logger, log(WFD_LOGLEVEL_ERROR, _, _)).Times(1);
|
||||
EXPECT_CALL(logger, onclose()).Times(1);
|
||||
|
||||
StrictMock<MockConfigBuilder> builder;
|
||||
|
||||
char const too_high[] = "version = { major = 2, minor = 0 }\n";
|
||||
|
||||
bool result = wfd_config_load_string(builder.getBuilder(), too_high);
|
||||
ASSERT_FALSE(result);
|
||||
}
|
||||
|
||||
TEST(config, invalid_missing_major_version)
|
||||
{
|
||||
MockLogger logger;
|
||||
EXPECT_CALL(logger, log(WFD_LOGLEVEL_ERROR, _, _)).Times(1);
|
||||
EXPECT_CALL(logger, onclose()).Times(1);
|
||||
|
||||
StrictMock<MockConfigBuilder> builder;
|
||||
|
||||
char const too_high[] = "version = { minor = 0 }\n";
|
||||
|
||||
bool result = wfd_config_load_string(builder.getBuilder(), too_high);
|
||||
ASSERT_FALSE(result);
|
||||
}
|
||||
|
||||
TEST(config, invalid_missing_minor_version)
|
||||
{
|
||||
MockLogger logger;
|
||||
EXPECT_CALL(logger, log(WFD_LOGLEVEL_ERROR, _, _)).Times(1);
|
||||
EXPECT_CALL(logger, onclose()).Times(1);
|
||||
|
||||
StrictMock<MockConfigBuilder> builder;
|
||||
|
||||
char const too_high[] = "version = { major = 1 }\n";
|
||||
|
||||
bool result = wfd_config_load_string(builder.getBuilder(), too_high);
|
||||
ASSERT_FALSE(result);
|
||||
}
|
||||
|
||||
TEST(config, valid_older_minor)
|
||||
{
|
||||
MockLogger logger;
|
||||
EXPECT_CALL(logger, log(WFD_LOGLEVEL_INFO, _, _)).Times(1);
|
||||
EXPECT_CALL(logger, onclose()).Times(1);
|
||||
|
||||
StrictMock<MockConfigBuilder> builder;
|
||||
|
||||
char const valid[] = "version = { major = 1, minor = -1 }\n";
|
||||
|
||||
bool result = wfd_config_load_string(builder.getBuilder(), valid);
|
||||
ASSERT_TRUE(result);
|
||||
}
|
||||
|
||||
TEST(config, valid_newer_minor)
|
||||
{
|
||||
MockLogger logger;
|
||||
EXPECT_CALL(logger, log(WFD_LOGLEVEL_WARN, _, _)).Times(1);
|
||||
EXPECT_CALL(logger, onclose()).Times(1);
|
||||
|
||||
StrictMock<MockConfigBuilder> builder;
|
||||
|
||||
char const valid[] = "version = { major = 1, minor = 1 }\n";
|
||||
|
||||
bool result = wfd_config_load_string(builder.getBuilder(), valid);
|
||||
ASSERT_TRUE(result);
|
||||
}
|
||||
|
||||
TEST(config, vhost_name)
|
||||
{
|
||||
MockLogger logger;
|
||||
EXPECT_CALL(logger, log(_, _, _)).Times(0);
|
||||
EXPECT_CALL(logger, onclose()).Times(1);
|
||||
|
||||
StrictMock<MockConfigBuilder> builder;
|
||||
EXPECT_CALL(builder, setServerVhostname(StrEq("some.host"))).Times(1);
|
||||
|
||||
char const config_text[] =
|
||||
"version = { major = 1, minor = 0 }\n"
|
||||
"server:\n"
|
||||
"{\n"
|
||||
" vhost_name = \"some.host\"\n"
|
||||
"}\n"
|
||||
;
|
||||
bool result = wfd_config_load_string(builder.getBuilder(), config_text);
|
||||
ASSERT_TRUE(result);
|
||||
}
|
||||
|
||||
TEST(config, port)
|
||||
{
|
||||
MockLogger logger;
|
||||
EXPECT_CALL(logger, log(_, _, _)).Times(0);
|
||||
EXPECT_CALL(logger, onclose()).Times(1);
|
||||
|
||||
StrictMock<MockConfigBuilder> builder;
|
||||
EXPECT_CALL(builder, setServerPort(54321)).Times(1);
|
||||
|
||||
char const config_text[] =
|
||||
"version = { major = 1, minor = 0 }\n"
|
||||
"server:\n"
|
||||
"{\n"
|
||||
" port = 54321\n"
|
||||
"}\n"
|
||||
;
|
||||
bool result = wfd_config_load_string(builder.getBuilder(), config_text);
|
||||
ASSERT_TRUE(result);
|
||||
}
|
||||
|
||||
TEST(config, tls_certificate)
|
||||
{
|
||||
MockLogger logger;
|
||||
EXPECT_CALL(logger, log(_, _, _)).Times(0);
|
||||
EXPECT_CALL(logger, onclose()).Times(1);
|
||||
|
||||
StrictMock<MockConfigBuilder> builder;
|
||||
EXPECT_CALL(builder, setServerCert(StrEq("/path/to/cert.pem"))).Times(1);
|
||||
|
||||
char const config_text[] =
|
||||
"version = { major = 1, minor = 0 }\n"
|
||||
"server:\n"
|
||||
"{\n"
|
||||
" tls:\n"
|
||||
" {\n"
|
||||
" certificate = \"/path/to/cert.pem\"\n"
|
||||
" }\n"
|
||||
"}\n"
|
||||
;
|
||||
bool result = wfd_config_load_string(builder.getBuilder(), config_text);
|
||||
ASSERT_TRUE(result);
|
||||
}
|
||||
|
||||
TEST(config, tls_key)
|
||||
{
|
||||
MockLogger logger;
|
||||
EXPECT_CALL(logger, log(_, _, _)).Times(0);
|
||||
EXPECT_CALL(logger, onclose()).Times(1);
|
||||
|
||||
StrictMock<MockConfigBuilder> builder;
|
||||
EXPECT_CALL(builder, setServerKey(StrEq("/path/to/key.pem"))).Times(1);
|
||||
|
||||
char const config_text[] =
|
||||
"version = { major = 1, minor = 0 }\n"
|
||||
"server:\n"
|
||||
"{\n"
|
||||
" tls:\n"
|
||||
" {\n"
|
||||
" key = \"/path/to/key.pem\"\n"
|
||||
" }\n"
|
||||
"}\n"
|
||||
;
|
||||
bool result = wfd_config_load_string(builder.getBuilder(), config_text);
|
||||
ASSERT_TRUE(result);
|
||||
}
|
||||
|
||||
TEST(config, document_root)
|
||||
{
|
||||
MockLogger logger;
|
||||
EXPECT_CALL(logger, log(_, _, _)).Times(0);
|
||||
EXPECT_CALL(logger, onclose()).Times(1);
|
||||
|
||||
StrictMock<MockConfigBuilder> builder;
|
||||
EXPECT_CALL(builder, setServerDocumentRoot(StrEq("/var/www"))).Times(1);
|
||||
|
||||
char const config_text[] =
|
||||
"version = { major = 1, minor = 0 }\n"
|
||||
"server:\n"
|
||||
"{\n"
|
||||
" document_root = \"/var/www\"\n"
|
||||
"}\n"
|
||||
;
|
||||
bool result = wfd_config_load_string(builder.getBuilder(), config_text);
|
||||
ASSERT_TRUE(result);
|
||||
}
|
||||
|
||||
TEST(config, authentication)
|
||||
{
|
||||
MockLogger logger;
|
||||
EXPECT_CALL(logger, log(_, _, _)).Times(0);
|
||||
EXPECT_CALL(logger, onclose()).Times(1);
|
||||
|
||||
StrictMock<MockConfigBuilder> builder;
|
||||
EXPECT_CALL(builder, addAuthProvider(_, _)).Times(1).WillOnce(Return(true));
|
||||
|
||||
char const config_text[] =
|
||||
"version = { major = 1, minor = 0 }\n"
|
||||
"authentication:\n"
|
||||
"(\n"
|
||||
" {\n"
|
||||
" provider = \"test\"\n"
|
||||
" settings: { }\n"
|
||||
" }\n"
|
||||
")\n"
|
||||
;
|
||||
bool result = wfd_config_load_string(builder.getBuilder(), config_text);
|
||||
ASSERT_TRUE(result);
|
||||
}
|
||||
|
||||
TEST(config, failed_create_authenticator)
|
||||
{
|
||||
MockLogger logger;
|
||||
EXPECT_CALL(logger, log(_, _, _)).Times(0);
|
||||
EXPECT_CALL(logger, onclose()).Times(1);
|
||||
|
||||
StrictMock<MockConfigBuilder> builder;
|
||||
EXPECT_CALL(builder, addAuthProvider(_, _)).Times(1).WillOnce(Return(false));
|
||||
|
||||
char const config_text[] =
|
||||
"version = { major = 1, minor = 0 }\n"
|
||||
"authentication:\n"
|
||||
"(\n"
|
||||
" {\n"
|
||||
" provider = \"test\"\n"
|
||||
" settings: { }\n"
|
||||
" }\n"
|
||||
")\n"
|
||||
;
|
||||
bool result = wfd_config_load_string(builder.getBuilder(), config_text);
|
||||
ASSERT_FALSE(result);
|
||||
}
|
||||
|
||||
TEST(config, failed_missing_auth_provider)
|
||||
{
|
||||
MockLogger logger;
|
||||
EXPECT_CALL(logger, log(WFD_LOGLEVEL_ERROR, _, _)).Times(1);
|
||||
EXPECT_CALL(logger, onclose()).Times(1);
|
||||
|
||||
StrictMock<MockConfigBuilder> builder;
|
||||
|
||||
char const config_text[] =
|
||||
"version = { major = 1, minor = 0 }\n"
|
||||
"authentication:\n"
|
||||
"(\n"
|
||||
" {\n"
|
||||
" settings: { }\n"
|
||||
" }\n"
|
||||
")\n"
|
||||
;
|
||||
bool result = wfd_config_load_string(builder.getBuilder(), config_text);
|
||||
ASSERT_FALSE(result);
|
||||
}
|
||||
|
||||
TEST(config, failed_missing_auth_settings)
|
||||
{
|
||||
MockLogger logger;
|
||||
EXPECT_CALL(logger, log(WFD_LOGLEVEL_ERROR, _, _)).Times(1);
|
||||
EXPECT_CALL(logger, onclose()).Times(1);
|
||||
|
||||
StrictMock<MockConfigBuilder> builder;
|
||||
|
||||
char const config_text[] =
|
||||
"version = { major = 1, minor = 0 }\n"
|
||||
"authentication:\n"
|
||||
"(\n"
|
||||
" {\n"
|
||||
" provider = \"test\"\n"
|
||||
" }\n"
|
||||
")\n"
|
||||
;
|
||||
bool result = wfd_config_load_string(builder.getBuilder(), config_text);
|
||||
ASSERT_FALSE(result);
|
||||
}
|
||||
|
||||
TEST(config, filesystems)
|
||||
{
|
||||
MockLogger logger;
|
||||
EXPECT_CALL(logger, log(_, _, _)).Times(0);
|
||||
EXPECT_CALL(logger, onclose()).Times(1);
|
||||
|
||||
StrictMock<MockConfigBuilder> builder;
|
||||
EXPECT_CALL(builder, addFilesystem(_, _)).Times(1).WillOnce(Return(true));
|
||||
|
||||
char const config_text[] =
|
||||
"version = { major = 1, minor = 0 }\n"
|
||||
"filesystems:\n"
|
||||
"(\n"
|
||||
" {name = \"foo\", mount_point = \"/tmp/test\" }\n"
|
||||
")\n"
|
||||
;
|
||||
bool result = wfd_config_load_string(builder.getBuilder(), config_text);
|
||||
ASSERT_TRUE(result);
|
||||
}
|
||||
|
||||
TEST(config, filesystems_empty)
|
||||
{
|
||||
MockLogger logger;
|
||||
EXPECT_CALL(logger, log(_, _, _)).Times(0);
|
||||
EXPECT_CALL(logger, onclose()).Times(1);
|
||||
|
||||
StrictMock<MockConfigBuilder> builder;
|
||||
EXPECT_CALL(builder, addFilesystem(_, _)).Times(0);
|
||||
|
||||
char const config_text[] =
|
||||
"version = { major = 1, minor = 0 }\n"
|
||||
"filesystems:\n"
|
||||
"(\n"
|
||||
")\n"
|
||||
;
|
||||
bool result = wfd_config_load_string(builder.getBuilder(), config_text);
|
||||
ASSERT_TRUE(result);
|
||||
}
|
||||
|
||||
TEST(config, filesystems_failed_add)
|
||||
{
|
||||
MockLogger logger;
|
||||
EXPECT_CALL(logger, log(_, _, _)).Times(0);
|
||||
EXPECT_CALL(logger, onclose()).Times(1);
|
||||
|
||||
StrictMock<MockConfigBuilder> builder;
|
||||
EXPECT_CALL(builder, addFilesystem(_, _)).Times(1).WillOnce(Return(false));
|
||||
|
||||
char const config_text[] =
|
||||
"version = { major = 1, minor = 0 }\n"
|
||||
"filesystems:\n"
|
||||
"(\n"
|
||||
" {name = \"foo\", mount_point = \"/tmp/test\" }\n"
|
||||
")\n"
|
||||
;
|
||||
bool result = wfd_config_load_string(builder.getBuilder(), config_text);
|
||||
ASSERT_FALSE(result);
|
||||
}
|
||||
|
||||
TEST(config, filesystems_failed_missing_name)
|
||||
{
|
||||
MockLogger logger;
|
||||
EXPECT_CALL(logger, log(WFD_LOGLEVEL_ERROR, _, _)).Times(1);
|
||||
EXPECT_CALL(logger, onclose()).Times(1);
|
||||
|
||||
StrictMock<MockConfigBuilder> builder;
|
||||
EXPECT_CALL(builder, addFilesystem(_, _)).Times(0);
|
||||
|
||||
char const config_text[] =
|
||||
"version = { major = 1, minor = 0 }\n"
|
||||
"filesystems:\n"
|
||||
"(\n"
|
||||
" {mount_point = \"/tmp/test\" }\n"
|
||||
")\n"
|
||||
;
|
||||
bool result = wfd_config_load_string(builder.getBuilder(), config_text);
|
||||
ASSERT_FALSE(result);
|
||||
}
|
||||
|
||||
TEST(config, filesystems_failed_missing_mountpoint)
|
||||
{
|
||||
MockLogger logger;
|
||||
EXPECT_CALL(logger, log(WFD_LOGLEVEL_ERROR, _, _)).Times(1);
|
||||
EXPECT_CALL(logger, onclose()).Times(1);
|
||||
|
||||
StrictMock<MockConfigBuilder> builder;
|
||||
EXPECT_CALL(builder, addFilesystem(_, _)).Times(0);
|
||||
|
||||
char const config_text[] =
|
||||
"version = { major = 1, minor = 0 }\n"
|
||||
"filesystems:\n"
|
||||
"(\n"
|
||||
" {name = \"foo\"}\n"
|
||||
")\n"
|
||||
;
|
||||
bool result = wfd_config_load_string(builder.getBuilder(), config_text);
|
||||
ASSERT_FALSE(result);
|
||||
}
|
||||
|
||||
TEST(config, log)
|
||||
{
|
||||
MockLogger logger;
|
||||
EXPECT_CALL(logger, log(_, _, _)).Times(0);
|
||||
EXPECT_CALL(logger, onclose()).Times(1);
|
||||
|
||||
StrictMock<MockConfigBuilder> builder;
|
||||
EXPECT_CALL(builder, setLogger(_, _, _)).Times(1).WillOnce(Return(true));
|
||||
|
||||
char const config_text[] =
|
||||
"version = { major = 1, minor = 0 }\n"
|
||||
"log:\n"
|
||||
"{\n"
|
||||
" provider = \"stderr\"\n"
|
||||
" level = \"all\"\n"
|
||||
"}\n"
|
||||
;
|
||||
bool result = wfd_config_load_string(builder.getBuilder(), config_text);
|
||||
ASSERT_TRUE(result);
|
||||
}
|
||||
|
||||
TEST(config, log_fail_set_logger)
|
||||
{
|
||||
MockLogger logger;
|
||||
EXPECT_CALL(logger, log(_, _, _)).Times(0);
|
||||
EXPECT_CALL(logger, onclose()).Times(1);
|
||||
|
||||
StrictMock<MockConfigBuilder> builder;
|
||||
EXPECT_CALL(builder, setLogger(_, _, _)).Times(1).WillOnce(Return(false));
|
||||
|
||||
char const config_text[] =
|
||||
"version = { major = 1, minor = 0 }\n"
|
||||
"log:\n"
|
||||
"{\n"
|
||||
" provider = \"stderr\"\n"
|
||||
" level = \"all\"\n"
|
||||
"}\n"
|
||||
;
|
||||
bool result = wfd_config_load_string(builder.getBuilder(), config_text);
|
||||
ASSERT_FALSE(result);
|
||||
}
|
||||
|
||||
TEST(config, log_fail_missing_provider)
|
||||
{
|
||||
MockLogger logger;
|
||||
EXPECT_CALL(logger, log(WFD_LOGLEVEL_ERROR, _, _)).Times(1);
|
||||
EXPECT_CALL(logger, onclose()).Times(1);
|
||||
|
||||
StrictMock<MockConfigBuilder> builder;
|
||||
EXPECT_CALL(builder, setLogger(_, _, _)).Times(0);
|
||||
|
||||
char const config_text[] =
|
||||
"version = { major = 1, minor = 0 }\n"
|
||||
"log:\n"
|
||||
"{\n"
|
||||
" level = \"all\"\n"
|
||||
"}\n"
|
||||
;
|
||||
bool result = wfd_config_load_string(builder.getBuilder(), config_text);
|
||||
ASSERT_FALSE(result);
|
||||
}
|
||||
|
||||
TEST(config, log_fail_missing_level)
|
||||
{
|
||||
MockLogger logger;
|
||||
EXPECT_CALL(logger, log(WFD_LOGLEVEL_ERROR, _, _)).Times(1);
|
||||
EXPECT_CALL(logger, onclose()).Times(1);
|
||||
|
||||
StrictMock<MockConfigBuilder> builder;
|
||||
EXPECT_CALL(builder, setLogger(_, _, _)).Times(0);
|
||||
|
||||
char const config_text[] =
|
||||
"version = { major = 1, minor = 0 }\n"
|
||||
"log:\n"
|
||||
"{\n"
|
||||
" provider = \"stderr\"\n"
|
||||
" level = \"fancy\"\n"
|
||||
"}\n"
|
||||
;
|
||||
bool result = wfd_config_load_string(builder.getBuilder(), config_text);
|
||||
ASSERT_FALSE(result);
|
||||
}
|
||||
|
||||
TEST(config, log_fail_invalid_level)
|
||||
{
|
||||
MockLogger logger;
|
||||
EXPECT_CALL(logger, log(WFD_LOGLEVEL_ERROR, _, _)).Times(1);
|
||||
EXPECT_CALL(logger, onclose()).Times(1);
|
||||
|
||||
StrictMock<MockConfigBuilder> builder;
|
||||
EXPECT_CALL(builder, setLogger(_, _, _)).Times(0);
|
||||
|
||||
char const config_text[] =
|
||||
"version = { major = 1, minor = 0 }\n"
|
||||
"log:\n"
|
||||
"{\n"
|
||||
" provider = \"stderr\"\n"
|
||||
"}\n"
|
||||
;
|
||||
bool result = wfd_config_load_string(builder.getBuilder(), config_text);
|
||||
ASSERT_FALSE(result);
|
||||
}
|
||||
|
||||
@ -0,0 +1,68 @@
|
||||
#include "webfused/daemon.h"
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
#include <cstdlib>
|
||||
#include <chrono>
|
||||
#include <thread>
|
||||
|
||||
TEST(daemon, print_usage)
|
||||
{
|
||||
char argv0[] = "daemon";
|
||||
char argv1[] = "--help";
|
||||
char * argv[] = { argv0, argv1, NULL};
|
||||
|
||||
int exit_code = wfd_daemon_run(2, argv);
|
||||
ASSERT_EQ(EXIT_SUCCESS, exit_code);
|
||||
}
|
||||
|
||||
TEST(daemon, print_usage_short)
|
||||
{
|
||||
char argv0[] = "daemon";
|
||||
char argv1[] = "-h";
|
||||
char * argv[] = { argv0, argv1, NULL};
|
||||
|
||||
int exit_code = wfd_daemon_run(2, argv);
|
||||
ASSERT_EQ(EXIT_SUCCESS, exit_code);
|
||||
}
|
||||
|
||||
TEST(daemon, fail_invalid_argument)
|
||||
{
|
||||
char argv0[] = "daemon";
|
||||
char argv1[] = "-x";
|
||||
char * argv[] = { argv0, argv1, NULL};
|
||||
|
||||
int exit_code = wfd_daemon_run(2, argv);
|
||||
ASSERT_EQ(EXIT_FAILURE, exit_code);
|
||||
}
|
||||
|
||||
TEST(daemon, fail_invalid_config_file)
|
||||
{
|
||||
char argv0[] = "daemon";
|
||||
char argv1[] = "-f";
|
||||
char argv2[] = "invalid.conf";
|
||||
char * argv[] = { argv0, argv1, argv2, NULL};
|
||||
|
||||
int exit_code = wfd_daemon_run(3, argv);
|
||||
ASSERT_EQ(EXIT_FAILURE, exit_code);
|
||||
}
|
||||
|
||||
void defered_raise()
|
||||
{
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds(50));
|
||||
raise(SIGINT);
|
||||
}
|
||||
|
||||
TEST(daemon, run)
|
||||
{
|
||||
char argv0[] = "daemon";
|
||||
char argv1[] = "-f";
|
||||
char argv2[] = "webfused.conf";
|
||||
char * argv[] = { argv0, argv1, argv2, NULL};
|
||||
|
||||
std::thread thread(defered_raise);
|
||||
|
||||
int exit_code = wfd_daemon_run(3, argv);
|
||||
ASSERT_EQ(EXIT_SUCCESS, exit_code);
|
||||
|
||||
thread.join();
|
||||
}
|
||||
@ -0,0 +1,158 @@
|
||||
#include "webfused/auth/file_authenticator.h"
|
||||
#include "webfused/auth/authenticator.h"
|
||||
#include "webfused/config/settings.h"
|
||||
#include "webfused/auth/factory.h"
|
||||
|
||||
#include "mock_credentials.hpp"
|
||||
#include "mock_settings.hpp"
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
#include <libconfig.h>
|
||||
|
||||
using ::webfused_test::MockSettings;
|
||||
using ::webfused_test::MockCredentials;
|
||||
using ::testing::Return;
|
||||
using ::testing::StrEq;
|
||||
|
||||
TEST(file_authenticator, create)
|
||||
{
|
||||
MockSettings settings;
|
||||
EXPECT_CALL(settings, getString(StrEq("file"))).Times(1).WillOnce(Return("test_passwd.json"));
|
||||
|
||||
wfd_authenticator authenticator;
|
||||
bool success = wfd_file_authenticator_create(nullptr, &authenticator);
|
||||
ASSERT_TRUE(success);
|
||||
|
||||
wfd_authenticator_dispose(authenticator);
|
||||
}
|
||||
|
||||
TEST(file_authenticator, create_fail_missing_file)
|
||||
{
|
||||
MockSettings settings;
|
||||
EXPECT_CALL(settings, getString(StrEq("file"))).Times(1).WillOnce(Return(nullptr));
|
||||
|
||||
wfd_authenticator authenticator;
|
||||
bool success = wfd_file_authenticator_create(nullptr, &authenticator);
|
||||
ASSERT_FALSE(success);
|
||||
}
|
||||
|
||||
TEST(file_authenticator, create_via_factory)
|
||||
{
|
||||
MockSettings settings;
|
||||
EXPECT_CALL(settings, getString(StrEq("file"))).Times(1).WillOnce(Return("test_passwd.json"));
|
||||
|
||||
wfd_authenticator authenticator;
|
||||
bool success = wfd_authenticator_create("file", nullptr, &authenticator);
|
||||
ASSERT_TRUE(success);
|
||||
|
||||
wfd_authenticator_dispose(authenticator);
|
||||
}
|
||||
|
||||
TEST(file_authenticator, authenticate)
|
||||
{
|
||||
MockSettings settings;
|
||||
EXPECT_CALL(settings, getString(StrEq("file"))).Times(1).WillOnce(Return("test_passwd.json"));
|
||||
|
||||
wfd_authenticator authenticator;
|
||||
bool success = wfd_file_authenticator_create(nullptr, &authenticator);
|
||||
ASSERT_TRUE(success);
|
||||
|
||||
MockCredentials creds;
|
||||
EXPECT_CALL(creds, get(StrEq("username"))).Times(1).WillOnce(Return("bob"));
|
||||
EXPECT_CALL(creds, get(StrEq("password"))).Times(1).WillOnce(Return("secret"));
|
||||
|
||||
bool is_authenticated = wfd_authenticator_authenticate(authenticator, nullptr);
|
||||
ASSERT_TRUE(is_authenticated);
|
||||
|
||||
wfd_authenticator_dispose(authenticator);
|
||||
}
|
||||
|
||||
TEST(file_authenticator, authenticate_fail_wrong_passwd)
|
||||
{
|
||||
MockSettings settings;
|
||||
EXPECT_CALL(settings, getString(StrEq("file"))).Times(1).WillOnce(Return("test_passwd.json"));
|
||||
|
||||
wfd_authenticator authenticator;
|
||||
bool success = wfd_file_authenticator_create(nullptr, &authenticator);
|
||||
ASSERT_TRUE(success);
|
||||
|
||||
MockCredentials creds;
|
||||
EXPECT_CALL(creds, get(StrEq("username"))).Times(1).WillOnce(Return("bob"));
|
||||
EXPECT_CALL(creds, get(StrEq("password"))).Times(1).WillOnce(Return("unkown"));
|
||||
|
||||
bool is_authenticated = wfd_authenticator_authenticate(authenticator, nullptr);
|
||||
ASSERT_FALSE(is_authenticated);
|
||||
|
||||
wfd_authenticator_dispose(authenticator);
|
||||
}
|
||||
|
||||
TEST(file_authenticator, authenticate_fail_no_passwd_file)
|
||||
{
|
||||
MockSettings settings;
|
||||
EXPECT_CALL(settings, getString(StrEq("file"))).Times(1).WillOnce(Return("unknown_passwd.json"));
|
||||
|
||||
wfd_authenticator authenticator;
|
||||
bool success = wfd_file_authenticator_create(nullptr, &authenticator);
|
||||
ASSERT_TRUE(success);
|
||||
|
||||
MockCredentials creds;
|
||||
EXPECT_CALL(creds, get(StrEq("username"))).Times(1).WillOnce(Return("bob"));
|
||||
EXPECT_CALL(creds, get(StrEq("password"))).Times(1).WillOnce(Return("secred"));
|
||||
|
||||
bool is_authenticated = wfd_authenticator_authenticate(authenticator, nullptr);
|
||||
ASSERT_FALSE(is_authenticated);
|
||||
|
||||
wfd_authenticator_dispose(authenticator);
|
||||
}
|
||||
|
||||
TEST(file_authenticator, authenticate_fail_missing_username)
|
||||
{
|
||||
MockSettings settings;
|
||||
EXPECT_CALL(settings, getString(StrEq("file"))).Times(1).WillOnce(Return("test_passwd.json"));
|
||||
|
||||
wfd_authenticator authenticator;
|
||||
bool success = wfd_file_authenticator_create(nullptr, &authenticator);
|
||||
ASSERT_TRUE(success);
|
||||
|
||||
MockCredentials creds;
|
||||
EXPECT_CALL(creds, get(StrEq("username"))).Times(1).WillOnce(Return(nullptr));
|
||||
EXPECT_CALL(creds, get(StrEq("password"))).Times(1).WillOnce(Return("unkown"));
|
||||
|
||||
bool is_authenticated = wfd_authenticator_authenticate(authenticator, nullptr);
|
||||
ASSERT_FALSE(is_authenticated);
|
||||
|
||||
wfd_authenticator_dispose(authenticator);
|
||||
}
|
||||
|
||||
TEST(file_authenticator, authenticate_fail_missing_password)
|
||||
{
|
||||
MockSettings settings;
|
||||
EXPECT_CALL(settings, getString(StrEq("file"))).Times(1).WillOnce(Return("test_passwd.json"));
|
||||
|
||||
wfd_authenticator authenticator;
|
||||
bool success = wfd_file_authenticator_create(nullptr, &authenticator);
|
||||
ASSERT_TRUE(success);
|
||||
|
||||
MockCredentials creds;
|
||||
EXPECT_CALL(creds, get(StrEq("username"))).Times(1).WillOnce(Return("bob"));
|
||||
EXPECT_CALL(creds, get(StrEq("password"))).Times(1).WillOnce(Return(nullptr));
|
||||
|
||||
bool is_authenticated = wfd_authenticator_authenticate(authenticator, nullptr);
|
||||
ASSERT_FALSE(is_authenticated);
|
||||
|
||||
wfd_authenticator_dispose(authenticator);
|
||||
}
|
||||
|
||||
TEST(file_authenticator, get_type)
|
||||
{
|
||||
MockSettings settings;
|
||||
EXPECT_CALL(settings, getString(StrEq("file"))).Times(1).WillOnce(Return("/any/path"));
|
||||
|
||||
wfd_authenticator authenticator;
|
||||
bool success = wfd_file_authenticator_create(nullptr, &authenticator);
|
||||
ASSERT_TRUE(success);
|
||||
|
||||
ASSERT_STREQ("username", wfd_authenticator_get_type(authenticator));
|
||||
|
||||
wfd_authenticator_dispose(authenticator);
|
||||
}
|
||||
@ -0,0 +1,170 @@
|
||||
#include <gtest/gtest.h>
|
||||
#include <gmock/gmock.h>
|
||||
|
||||
#include "webfused/log/logger.h"
|
||||
#include "webfused/log/log.h"
|
||||
#include "mock_logger.hpp"
|
||||
|
||||
using ::testing::_;
|
||||
using ::testing::StrEq;
|
||||
using ::webfused_test::MockLogger;
|
||||
|
||||
TEST(log, fatal)
|
||||
{
|
||||
MockLogger logger(true);
|
||||
|
||||
EXPECT_CALL(logger, log(WFD_LOGLEVEL_FATAL, StrEq("too bad"), _)).Times(1);
|
||||
EXPECT_CALL(logger, onclose()).Times(1);
|
||||
|
||||
wfd_logger_init(WFD_LOGLEVEL_ALL, &wfd_MockLogger_log, &wfd_MockLogger_onclose, logger.getUserData());
|
||||
WFD_FATAL("too bad");
|
||||
wfd_logger_close();
|
||||
}
|
||||
|
||||
TEST(log, error)
|
||||
{
|
||||
MockLogger logger(true);
|
||||
|
||||
EXPECT_CALL(logger, log(WFD_LOGLEVEL_ERROR, StrEq("too bad"), _)).Times(1);
|
||||
EXPECT_CALL(logger, onclose()).Times(1);
|
||||
|
||||
wfd_logger_init(WFD_LOGLEVEL_ALL, &wfd_MockLogger_log, &wfd_MockLogger_onclose, logger.getUserData());
|
||||
WFD_ERROR("too bad");
|
||||
wfd_logger_close();
|
||||
}
|
||||
|
||||
TEST(log, warn)
|
||||
{
|
||||
MockLogger logger(true);
|
||||
|
||||
EXPECT_CALL(logger, log(WFD_LOGLEVEL_WARN, StrEq("too bad"), _)).Times(1);
|
||||
EXPECT_CALL(logger, onclose()).Times(1);
|
||||
|
||||
wfd_logger_init(WFD_LOGLEVEL_ALL, &wfd_MockLogger_log, &wfd_MockLogger_onclose, logger.getUserData());
|
||||
WFD_WARN("too bad");
|
||||
wfd_logger_close();
|
||||
}
|
||||
|
||||
TEST(log, info)
|
||||
{
|
||||
MockLogger logger(true);
|
||||
|
||||
EXPECT_CALL(logger, log(WFD_LOGLEVEL_INFO, StrEq("too bad"), _)).Times(1);
|
||||
EXPECT_CALL(logger, onclose()).Times(1);
|
||||
|
||||
wfd_logger_init(WFD_LOGLEVEL_ALL, &wfd_MockLogger_log, &wfd_MockLogger_onclose, logger.getUserData());
|
||||
WFD_INFO("too bad");
|
||||
wfd_logger_close();
|
||||
}
|
||||
|
||||
TEST(log, debug)
|
||||
{
|
||||
MockLogger logger(true);
|
||||
|
||||
EXPECT_CALL(logger, log(WFD_LOGLEVEL_DEBUG, StrEq("too bad"), _)).Times(1);
|
||||
EXPECT_CALL(logger, onclose()).Times(1);
|
||||
|
||||
wfd_logger_init(WFD_LOGLEVEL_ALL, &wfd_MockLogger_log, &wfd_MockLogger_onclose, logger.getUserData());
|
||||
WFD_DEBUG("too bad");
|
||||
wfd_logger_close();
|
||||
}
|
||||
|
||||
TEST(log, respect_loglevel)
|
||||
{
|
||||
MockLogger logger(true);
|
||||
|
||||
EXPECT_CALL(logger, log(_, _, _)).Times(0);
|
||||
EXPECT_CALL(logger, onclose()).Times(1);
|
||||
|
||||
wfd_logger_init(WFD_LOGLEVEL_WARN, &wfd_MockLogger_log, &wfd_MockLogger_onclose, logger.getUserData());
|
||||
WFD_DEBUG("too bad");
|
||||
wfd_logger_close();
|
||||
}
|
||||
|
||||
TEST(log, log_same_loglevel)
|
||||
{
|
||||
MockLogger logger(true);
|
||||
|
||||
EXPECT_CALL(logger, log(WFD_LOGLEVEL_WARN, StrEq("too bad"), _)).Times(1);
|
||||
EXPECT_CALL(logger, onclose()).Times(1);
|
||||
|
||||
wfd_logger_init(WFD_LOGLEVEL_WARN, &wfd_MockLogger_log, &wfd_MockLogger_onclose, logger.getUserData());
|
||||
WFD_WARN("too bad");
|
||||
wfd_logger_close();
|
||||
}
|
||||
|
||||
TEST(log, omit_onclose_if_nullptr)
|
||||
{
|
||||
MockLogger logger(true);
|
||||
|
||||
EXPECT_CALL(logger, log(WFD_LOGLEVEL_WARN, StrEq("too bad"), _)).Times(1);
|
||||
EXPECT_CALL(logger, onclose()).Times(0);
|
||||
|
||||
wfd_logger_init(WFD_LOGLEVEL_WARN, &wfd_MockLogger_log, nullptr, logger.getUserData());
|
||||
WFD_WARN("too bad");
|
||||
wfd_logger_close();
|
||||
}
|
||||
|
||||
TEST(log, default_log)
|
||||
{
|
||||
WFD_ERROR("trigger log");
|
||||
}
|
||||
|
||||
TEST(log, loglevel_parse)
|
||||
{
|
||||
int level;
|
||||
|
||||
ASSERT_TRUE(wfd_log_level_parse("fatal", &level));
|
||||
ASSERT_EQ(WFD_LOGLEVEL_FATAL, level);
|
||||
ASSERT_TRUE(wfd_log_level_parse("FATAL", &level));
|
||||
ASSERT_EQ(WFD_LOGLEVEL_FATAL, level);
|
||||
|
||||
ASSERT_TRUE(wfd_log_level_parse("error", &level));
|
||||
ASSERT_EQ(WFD_LOGLEVEL_ERROR, level);
|
||||
ASSERT_TRUE(wfd_log_level_parse("ERROR", &level));
|
||||
ASSERT_EQ(WFD_LOGLEVEL_ERROR, level);
|
||||
|
||||
ASSERT_TRUE(wfd_log_level_parse("warn", &level));
|
||||
ASSERT_EQ(WFD_LOGLEVEL_WARN, level);
|
||||
ASSERT_TRUE(wfd_log_level_parse("WARN", &level));
|
||||
ASSERT_EQ(WFD_LOGLEVEL_WARN, level);
|
||||
ASSERT_TRUE(wfd_log_level_parse("warning", &level));
|
||||
ASSERT_EQ(WFD_LOGLEVEL_WARN, level);
|
||||
ASSERT_TRUE(wfd_log_level_parse("WARNING", &level));
|
||||
ASSERT_EQ(WFD_LOGLEVEL_WARN, level);
|
||||
|
||||
ASSERT_TRUE(wfd_log_level_parse("info", &level));
|
||||
ASSERT_EQ(WFD_LOGLEVEL_INFO, level);
|
||||
ASSERT_TRUE(wfd_log_level_parse("INFO", &level));
|
||||
ASSERT_EQ(WFD_LOGLEVEL_INFO, level);
|
||||
|
||||
ASSERT_TRUE(wfd_log_level_parse("debug", &level));
|
||||
ASSERT_EQ(WFD_LOGLEVEL_DEBUG, level);
|
||||
ASSERT_TRUE(wfd_log_level_parse("DEBUG", &level));
|
||||
ASSERT_EQ(WFD_LOGLEVEL_DEBUG, level);
|
||||
|
||||
ASSERT_FALSE(wfd_log_level_parse("<invalid>", &level));
|
||||
|
||||
ASSERT_TRUE(wfd_log_level_parse("all", &level));
|
||||
ASSERT_EQ(WFD_LOGLEVEL_ALL, level);
|
||||
ASSERT_TRUE(wfd_log_level_parse("ALL", &level));
|
||||
ASSERT_EQ(WFD_LOGLEVEL_ALL, level);
|
||||
|
||||
ASSERT_TRUE(wfd_log_level_parse("none", &level));
|
||||
ASSERT_EQ(WFD_LOGLEVEL_NONE, level);
|
||||
ASSERT_TRUE(wfd_log_level_parse("NONE", &level));
|
||||
ASSERT_EQ(WFD_LOGLEVEL_NONE, level);
|
||||
|
||||
}
|
||||
|
||||
TEST(log, log_level_tostring)
|
||||
{
|
||||
ASSERT_STREQ("none", wfd_log_level_tostring(WFD_LOGLEVEL_NONE));
|
||||
ASSERT_STREQ("fatal", wfd_log_level_tostring(WFD_LOGLEVEL_FATAL));
|
||||
ASSERT_STREQ("error", wfd_log_level_tostring(WFD_LOGLEVEL_ERROR));
|
||||
ASSERT_STREQ("warn", wfd_log_level_tostring(WFD_LOGLEVEL_WARN));
|
||||
ASSERT_STREQ("info", wfd_log_level_tostring(WFD_LOGLEVEL_INFO));
|
||||
ASSERT_STREQ("debug", wfd_log_level_tostring(WFD_LOGLEVEL_DEBUG));
|
||||
ASSERT_STREQ("all", wfd_log_level_tostring(WFD_LOGLEVEL_ALL));
|
||||
ASSERT_STREQ("<unknown>", wfd_log_level_tostring(42));
|
||||
}
|
||||
@ -0,0 +1,10 @@
|
||||
#include "webfused/log/manager.h"
|
||||
#include "webfused/log/log.h"
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
#include <stddef.h>
|
||||
|
||||
TEST(log_manager, set_logger_fail_unknown_provider)
|
||||
{
|
||||
ASSERT_FALSE(wfd_log_manager_set_logger("unknown", WFD_LOGLEVEL_ALL, NULL));
|
||||
}
|
||||
@ -0,0 +1,135 @@
|
||||
#include <gtest/gtest.h>
|
||||
#include "webfused/mountpoint_factory.h"
|
||||
#include <webfuse/adapter/mountpoint.h>
|
||||
|
||||
#include <cstring>
|
||||
|
||||
TEST(mountpoint_factory, create)
|
||||
{
|
||||
wfd_mountpoint_factory * factory = wfd_mountpoint_factory_create();
|
||||
ASSERT_NE(nullptr, factory);
|
||||
|
||||
wfd_mountpoint_factory_dispose(factory);
|
||||
}
|
||||
|
||||
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");
|
||||
ASSERT_TRUE(success);
|
||||
|
||||
wfd_mountpoint_factory_dispose(factory);
|
||||
}
|
||||
|
||||
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");
|
||||
ASSERT_TRUE(success);
|
||||
|
||||
success = wfd_mountpoint_factory_add_filesystem(factory, "test", "/tmp/webfused_test");
|
||||
ASSERT_FALSE(success);
|
||||
|
||||
wfd_mountpoint_factory_dispose(factory);
|
||||
}
|
||||
|
||||
TEST(mountpiont_factory, add_filesystem_multi)
|
||||
{
|
||||
wfd_mountpoint_factory * factory = wfd_mountpoint_factory_create();
|
||||
ASSERT_NE(nullptr, factory);
|
||||
|
||||
|
||||
for (size_t i = 0; i < 24; i++)
|
||||
{
|
||||
char name[10];
|
||||
snprintf(name, 10, "test_%zu", i);
|
||||
bool success = wfd_mountpoint_factory_add_filesystem(factory, name, "/tmp/webfused_test");
|
||||
ASSERT_TRUE(success) << i;
|
||||
}
|
||||
|
||||
wfd_mountpoint_factory_dispose(factory);
|
||||
}
|
||||
|
||||
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");
|
||||
ASSERT_FALSE(success);
|
||||
|
||||
wfd_mountpoint_factory_dispose(factory);
|
||||
}
|
||||
|
||||
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");
|
||||
ASSERT_TRUE(success);
|
||||
|
||||
wf_mountpoint * mountpoint = wfd_mountpoint_factory_create_mountpoint("test", factory);
|
||||
ASSERT_NE(nullptr, mountpoint);
|
||||
ASSERT_STREQ("/tmp/webfuse_test", wf_mountpoint_get_path(mountpoint));
|
||||
|
||||
wf_mountpoint_dispose(mountpoint);
|
||||
wfd_mountpoint_factory_dispose(factory);
|
||||
}
|
||||
|
||||
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");
|
||||
ASSERT_TRUE(success);
|
||||
|
||||
wf_mountpoint * mountpoint = wfd_mountpoint_factory_create_mountpoint("test", factory);
|
||||
ASSERT_NE(nullptr, mountpoint);
|
||||
ASSERT_STREQ("/tmp/webfuse_test", wf_mountpoint_get_path(mountpoint));
|
||||
|
||||
wf_mountpoint * mountpoint2 = wfd_mountpoint_factory_create_mountpoint("test", factory);
|
||||
ASSERT_EQ(nullptr, mountpoint2);
|
||||
|
||||
wf_mountpoint_dispose(mountpoint);
|
||||
wfd_mountpoint_factory_dispose(factory);
|
||||
}
|
||||
|
||||
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");
|
||||
ASSERT_TRUE(success);
|
||||
|
||||
wf_mountpoint * mountpoint = wfd_mountpoint_factory_create_mountpoint("unkown", factory);
|
||||
ASSERT_EQ(nullptr, mountpoint);
|
||||
|
||||
wfd_mountpoint_factory_dispose(factory);
|
||||
}
|
||||
|
||||
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");
|
||||
ASSERT_TRUE(success);
|
||||
|
||||
for(int i = 0; i < 5; i++)
|
||||
{
|
||||
wf_mountpoint * mountpoint = wfd_mountpoint_factory_create_mountpoint("test", factory);
|
||||
ASSERT_NE(nullptr, mountpoint) << i;
|
||||
ASSERT_STREQ("/tmp/webfuse_test", wf_mountpoint_get_path(mountpoint)) << i;
|
||||
|
||||
wf_mountpoint_dispose(mountpoint);
|
||||
}
|
||||
|
||||
wfd_mountpoint_factory_dispose(factory);
|
||||
}
|
||||
@ -0,0 +1,14 @@
|
||||
{
|
||||
"meta": {
|
||||
"type": "wf-userdb",
|
||||
"major": 1,
|
||||
"minor": 0,
|
||||
"hash_algorithm": "sha512"
|
||||
},
|
||||
"users": {
|
||||
"bob": {
|
||||
"password_hash": "e51e27ce47054feead3d83068d47f2a07307d4877ac67da668ef43e0e466fe8c7b66651af14fdb8d48c51592ef5afa0c63f874d20861c6b9ef8e6513bfcaa330",
|
||||
"salt": "b3be6979921edecfea88c50d0d1ec40b7f8c383831b2276c65969ead18e47c03"
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,90 @@
|
||||
#include <gtest/gtest.h>
|
||||
#include "webfused/config/settings_intern.h"
|
||||
#include "webfused/config/settings.h"
|
||||
#include <libconfig.h>
|
||||
|
||||
TEST(settings, get_string)
|
||||
{
|
||||
char const settings_text[] =
|
||||
"settings:\n"
|
||||
"{\n"
|
||||
" string_value = \"some.string\"\n"
|
||||
" int_value = 42\n"
|
||||
"}\n"
|
||||
;
|
||||
config_t config;
|
||||
config_init(&config);
|
||||
int rc = config_read_string(&config, settings_text);
|
||||
ASSERT_TRUE(CONFIG_TRUE == rc);
|
||||
|
||||
config_setting_t * setting = config_lookup(&config, "settings");
|
||||
ASSERT_NE(nullptr, setting);
|
||||
|
||||
wfd_settings settings;
|
||||
wfd_settings_init(&settings, setting);
|
||||
ASSERT_STREQ("some.string", wfd_settings_get_string(&settings, "string_value"));
|
||||
ASSERT_EQ(nullptr, wfd_settings_get_string(&settings, "int_value"));
|
||||
ASSERT_EQ(nullptr, wfd_settings_get_string(&settings, "invalid_value"));
|
||||
ASSERT_EQ(nullptr, wfd_settings_get_string(NULL, "invalid_value"));
|
||||
|
||||
wfd_settings_cleanup(&settings);
|
||||
config_destroy(&config);
|
||||
}
|
||||
|
||||
TEST(settings, get_string_or_default)
|
||||
{
|
||||
char const settings_text[] =
|
||||
"settings:\n"
|
||||
"{\n"
|
||||
" string_value = \"some.string\"\n"
|
||||
" int_value = 42\n"
|
||||
"}\n"
|
||||
;
|
||||
config_t config;
|
||||
config_init(&config);
|
||||
int rc = config_read_string(&config, settings_text);
|
||||
ASSERT_TRUE(CONFIG_TRUE == rc);
|
||||
|
||||
config_setting_t * setting = config_lookup(&config, "settings");
|
||||
ASSERT_NE(nullptr, setting);
|
||||
|
||||
wfd_settings settings;
|
||||
wfd_settings_init(&settings, setting);
|
||||
ASSERT_STREQ("some.string", wfd_settings_get_string_or_default(&settings, "string_value", "default"));
|
||||
ASSERT_STREQ("default", wfd_settings_get_string_or_default(&settings, "int_value", "default"));
|
||||
ASSERT_STREQ("default", wfd_settings_get_string_or_default(&settings, "invalid_value", "default"));
|
||||
ASSERT_STREQ("default", wfd_settings_get_string_or_default(NULL, "invalid_value", "default"));
|
||||
|
||||
wfd_settings_cleanup(&settings);
|
||||
config_destroy(&config);
|
||||
}
|
||||
|
||||
TEST(settings, get_bool)
|
||||
{
|
||||
char const settings_text[] =
|
||||
"settings:\n"
|
||||
"{\n"
|
||||
" true_value = true\n"
|
||||
" false_value = false\n"
|
||||
" int_value = 42\n"
|
||||
"}\n"
|
||||
;
|
||||
config_t config;
|
||||
config_init(&config);
|
||||
int rc = config_read_string(&config, settings_text);
|
||||
ASSERT_TRUE(CONFIG_TRUE == rc);
|
||||
|
||||
config_setting_t * setting = config_lookup(&config, "settings");
|
||||
ASSERT_NE(nullptr, setting);
|
||||
|
||||
wfd_settings settings;
|
||||
wfd_settings_init(&settings, setting);
|
||||
ASSERT_TRUE(wfd_settings_get_bool(&settings, "true_value"));
|
||||
ASSERT_FALSE(wfd_settings_get_bool(&settings, "false_value"));
|
||||
ASSERT_FALSE(wfd_settings_get_bool(&settings, "int_value"));
|
||||
ASSERT_FALSE(wfd_settings_get_bool(&settings, "invalid_value"));
|
||||
ASSERT_FALSE(wfd_settings_get_bool(NULL, "invalid_value"));
|
||||
|
||||
wfd_settings_cleanup(&settings);
|
||||
config_destroy(&config);
|
||||
}
|
||||
@ -0,0 +1,27 @@
|
||||
#include "webfused/log/stderr_logger.h"
|
||||
#include "webfused/log/manager.h"
|
||||
#include "webfused/log/logger.h"
|
||||
#include "webfused/log/log.h"
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
#include <stddef.h>
|
||||
|
||||
TEST(stderr_logger, init)
|
||||
{
|
||||
ASSERT_TRUE(wfd_stderr_logger_init(WFD_LOGLEVEL_ALL, NULL));
|
||||
wfd_logger_close();
|
||||
}
|
||||
|
||||
TEST(stderr_logger, init_via_manager)
|
||||
{
|
||||
ASSERT_TRUE(wfd_log_manager_set_logger("stderr", WFD_LOGLEVEL_ALL, NULL));
|
||||
wfd_logger_close();
|
||||
}
|
||||
|
||||
TEST(stderr_logger, log)
|
||||
{
|
||||
ASSERT_TRUE(wfd_stderr_logger_init(WFD_LOGLEVEL_ALL, NULL));
|
||||
WFD_INFO("some information");
|
||||
|
||||
wfd_logger_close();
|
||||
}
|
||||
@ -0,0 +1,45 @@
|
||||
#include "webfused/log/syslog_logger.h"
|
||||
#include "webfused/log/manager.h"
|
||||
#include "webfused/log/logger.h"
|
||||
#include "webfused/log/log.h"
|
||||
|
||||
#include "mock_settings.hpp"
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
#include <stddef.h>
|
||||
|
||||
using ::webfused_test::MockSettings;
|
||||
using ::testing::StrEq;
|
||||
using ::testing::_;
|
||||
using ::testing::Return;
|
||||
|
||||
TEST(syslog_logger, init)
|
||||
{
|
||||
ASSERT_TRUE(wfd_syslog_logger_init(WFD_LOGLEVEL_ALL, NULL));
|
||||
wfd_logger_close();
|
||||
}
|
||||
|
||||
TEST(syslog_logger, init_fail_invalid_facility)
|
||||
{
|
||||
MockSettings settings;
|
||||
EXPECT_CALL(settings, getStringOrDefault(StrEq("ident"), _)).Times(1).WillOnce(Return("webfused_test"));
|
||||
EXPECT_CALL(settings, getStringOrDefault(StrEq("facility"), _)).Times(1).WillOnce(Return("invalid"));
|
||||
EXPECT_CALL(settings, getBool(StrEq("log_pid"))).Times(1).WillOnce(Return(false));
|
||||
|
||||
wfd_settings * fake_settings = reinterpret_cast<wfd_settings*>(0xDEADBEEF);
|
||||
ASSERT_FALSE(wfd_syslog_logger_init(WFD_LOGLEVEL_ALL, fake_settings));
|
||||
}
|
||||
|
||||
TEST(syslog_logger, init_via_manager)
|
||||
{
|
||||
ASSERT_TRUE(wfd_log_manager_set_logger("syslog", WFD_LOGLEVEL_ALL, NULL));
|
||||
wfd_logger_close();
|
||||
}
|
||||
|
||||
TEST(syslog_logger, log)
|
||||
{
|
||||
ASSERT_TRUE(wfd_syslog_logger_init(WFD_LOGLEVEL_ALL, NULL));
|
||||
WFD_INFO("some information");
|
||||
|
||||
wfd_logger_close();
|
||||
}
|
||||
Loading…
Reference in new issue