Merge pull request #60 from falk-werner/investigate_coverage

Investigate coverage

.travis.yml

@@ -12,18 +12,18 @@ addons:
     - qemu-user-static
 env:
   global:
-    - DISTRO=ubuntu
     - PARALLELMFLAGS="-j4"
     - PORTABLE_WORSPACE=1
   matrix:
-    - BUILDTYPE=Debug      MARCH=amd64   CHECK_TARGET=memcheck
+    - DISTRO=ubuntu BUILDTYPE=Debug      MARCH=amd64   CHECK_TARGET=memcheck
-    - BUILDTYPE=Coverage   MARCH=amd64   CHECK_TARGET=check
+    - DISTRO=ubuntu BUILDTYPE=Coverage   MARCH=amd64   CHECK_TARGET=check
-    - BUILDTYPE=Release    MARCH=amd64   CHECK_TARGET=memcheck
+    - DISTRO=ubuntu BUILDTYPE=Release    MARCH=amd64   CHECK_TARGET=memcheck
-    - BUILDTYPE=Debug      MARCH=arm32v7 CHECK_TARGET=check
+    - DISTRO=ubuntu BUILDTYPE=Debug      MARCH=arm32v7 CHECK_TARGET=check
-    - BUILDTYPE=MinSizeRel MARCH=arm32v7 CHECK_TARGET=check
+    - DISTRO=ubuntu BUILDTYPE=MinSizeRel MARCH=arm32v7 CHECK_TARGET=check
+    - DISTRO=alpine BUILDTYPE=Debug      MARCH=amd64   CHECK_TARGET=check
 before_script:
 - make BUILDTYPE=$BUILDTYPE MARCH=$MARCH
 script:
-- make BUILDTYPE=$BUILDTYPE MARCH=$MARCH $CHECK_TARGET
+- make DISTRO=$DISTRO BUILDTYPE=$BUILDTYPE MARCH=$MARCH $CHECK_TARGET
 after_success:
 - bash <(curl -s https://codecov.io/bash)

CMakeLists.txt

@@ -37,8 +37,6 @@ add_compile_options(
 	"-pthread"
 )
 
-include(wf_timer)
-include(wf_jsonrpc)
 include(webfuse_core)
 include(webfuse_adapter)
 include(webfuse_provider)

build/amd64-ubuntu-builder.dockerfile

@@ -58,6 +58,7 @@ RUN set -x \
   && mkdir -p "$builddir" \
   && cd "$builddir" \
   && meson "/usr/local/src/libfuse-fuse-$FUSE_VERSION" \
+  && meson configure -Dexamples=false \
   && ninja \
   && ninja install \
   && pip3 uninstall -y meson \

build/arm32v7-ubuntu-builder.dockerfile

@@ -61,6 +61,7 @@ RUN set -x \
   && mkdir -p "$builddir" \
   && cd "$builddir" \
   && meson "/usr/local/src/libfuse-fuse-$FUSE_VERSION" \
+  && meson configure -Dexamples=false \
   && ninja \
   && ninja install \
   && pip3 uninstall -y meson \

cmake/unit_tests.cmake

@@ -1,31 +1,42 @@
 if(NOT WITHOUT_TESTS AND NOT WITHOUT_ADAPTER AND NOT WITHOUT_PROVIDER)
 
+set(MEMORYCHECK_COMMAND_OPTIONS "--leak-check=full --error-exitcode=1")
 include (CTest)
 
+add_executable(fs_check
+	test/webfuse/tests/integration/fs_check.c
+)
+
 pkg_check_modules(GTEST gtest_main)
 include(GoogleTest)
 pkg_check_modules(GMOCK gmock)
 
 add_executable(alltests
-	lib/wf/jsonrpc/test/wf/jsonrpc/test_is_request.cc
+	test/webfuse/tests/core/jsonrpc/mock_timer_callback.cc
-	lib/wf/jsonrpc/test/wf/jsonrpc/test_request.cc
+	test/webfuse/tests/core/jsonrpc/mock_timer.cc
-	lib/wf/jsonrpc/test/wf/jsonrpc/test_is_response.cc
+	test/webfuse/tests/core/jsonrpc/test_is_request.cc
-	lib/wf/jsonrpc/test/wf/jsonrpc/test_response.cc
+	test/webfuse/tests/core/jsonrpc/test_request.cc
-	lib/wf/jsonrpc/test/wf/jsonrpc/test_server.cc
+	test/webfuse/tests/core/jsonrpc/test_is_response.cc
-	lib/wf/jsonrpc/test/wf/jsonrpc/test_proxy.cc
+	test/webfuse/tests/core/jsonrpc/test_response.cc
-	lib/wf/jsonrpc/test/wf/jsonrpc/test_response_parser.cc
+	test/webfuse/tests/core/jsonrpc/test_server.cc
-	lib/wf/timer/test/wf/timer/test_timepoint.cc
+	test/webfuse/tests/core/jsonrpc/test_proxy.cc
-	lib/wf/timer/test/wf/timer/test_timer.cc
+	test/webfuse/tests/core/jsonrpc/test_response_parser.cc
+	test/webfuse/tests/core/timer/test_timepoint.cc
+	test/webfuse/tests/core/timer/test_timer.cc
 	test/webfuse/utils/tempdir.cc
 	test/webfuse/utils/file_utils.cc
-	test/webfuse/utils/die_if.cc
 	test/webfuse/utils/timeout_watcher.cc
 	test/webfuse/utils/path.c
 	test/webfuse/utils/static_filesystem.c
 	test/webfuse/utils/ws_server.cc
+	test/webfuse/mocks/fake_invokation_context.cc
 	test/webfuse/mocks/mock_authenticator.cc
 	test/webfuse/mocks/mock_request.cc
 	test/webfuse/mocks/mock_provider_client.cc
+	test/webfuse/mocks/mock_provider.cc
+	test/webfuse/mocks/mock_fuse.cc
+	test/webfuse/mocks/mock_operation_context.cc
+	test/webfuse/mocks/mock_jsonrpc_proxy.cc
 	test/webfuse//tests/core/test_util.cc
 	test/webfuse/tests/core/test_container_of.cc
 	test/webfuse/tests/core/test_string.cc
@@ -41,31 +52,50 @@ add_executable(alltests
 	test/webfuse/tests/adapter/test_authenticators.cc
 	test/webfuse/tests/adapter/test_mountpoint.cc
 	test/webfuse/tests/adapter/test_fuse_req.cc
+	test/webfuse/tests/adapter/operation/test_context.cc
+	test/webfuse/tests/adapter/operation/test_open.cc
+	test/webfuse/tests/adapter/operation/test_close.cc
+	test/webfuse/tests/adapter/operation/test_read.cc
+	test/webfuse/tests/adapter/operation/test_readdir.cc
+	test/webfuse/tests/adapter/operation/test_getattr.cc
+	test/webfuse/tests/adapter/operation/test_lookup.cc
 	test/webfuse/tests/provider/test_url.cc
 	test/webfuse/tests/provider/test_client_protocol.cc
+	test/webfuse/tests/provider/operation/test_close.cc
+	test/webfuse/tests/provider/operation/test_getattr.cc
+	test/webfuse/tests/provider/operation/test_lookup.cc
+	test/webfuse/tests/provider/operation/test_open.cc
+	test/webfuse/tests/provider/operation/test_read.cc
+	test/webfuse/tests/provider/operation/test_readdir.cc
+	test/webfuse/tests/integration/test_lowlevel.cc
 	test/webfuse/tests/integration/test_integration.cc
+	test/webfuse/tests/integration/file.cc
 	test/webfuse/tests/integration/server.cc
 	test/webfuse/tests/integration/provider.cc
 )
 
-target_include_directories(alltests PRIVATE
-	lib/wf/jsonrpc/include
-	lib/wf/jsonrpc/src
-	lib/wf/timer/include
-	lib/wf/timer/src
-	${FUSE3_INCLUDE_DIRS} 
-)
-
-target_compile_options(alltests PUBLIC
-	${FUSE3_CFLAGS_OTHER}
-)
-
 target_link_libraries(alltests PUBLIC
+	-Wl,--wrap=wf_timer_manager_create
+	-Wl,--wrap=wf_timer_manager_dispose
+	-Wl,--wrap=wf_timer_manager_check
+	-Wl,--wrap=wf_timer_create
+	-Wl,--wrap=wf_timer_dispose
+	-Wl,--wrap=wf_timer_start
+	-Wl,--wrap=wf_timer_cancel
+	-Wl,--wrap=wf_impl_operation_context_get_proxy
+	-Wl,--wrap=wf_jsonrpc_proxy_vinvoke
+	-Wl,--wrap=wf_jsonrpc_proxy_vnotify
+	-Wl,--wrap=fuse_req_userdata
+	-Wl,--wrap=fuse_reply_open
+	-Wl,--wrap=fuse_reply_err
+	-Wl,--wrap=fuse_reply_buf
+	-Wl,--wrap=fuse_reply_attr
+	-Wl,--wrap=fuse_reply_entry
+	-Wl,--wrap=fuse_req_ctx
+
 	webfuse-adapter-static
 	webfuse-provider-static
 	webfuse-core
-	wf_jsonrpc
-	wf_timer
 	${FUSE3_LIBRARIES}
 	${LWS_LIBRARIES}
 	${JANSSON_LIBRARIES}
@@ -74,8 +104,16 @@ target_link_libraries(alltests PUBLIC
 	${GTEST_LIBRARIES}
 )
 
-target_include_directories(alltests PUBLIC test lib ${GMOCK_INCLUDE_DIRS} ${GTEST_INCLUDE_DIRS})
+target_include_directories(alltests PUBLIC test lib ${FUSE3_INCLUDE_DIRS} ${GMOCK_INCLUDE_DIRS} ${GTEST_INCLUDE_DIRS})
-target_compile_options(alltests PUBLIC ${GMOCK_CFLAGS} ${GTEST_CFLAGS})
+target_compile_options(alltests PUBLIC ${FUSE3_CFLAGS_OTHER} ${GMOCK_CFLAGS} ${GTEST_CFLAGS})
+
+add_custom_command(OUTPUT server-key.pem
+	COMMAND openssl req -x509 -newkey rsa:4096 -keyout server-key.pem -out server-cert.pem -days 365 -nodes -batch -subj '/CN=localhost'
+	COMMAND openssl req -x509 -newkey rsa:4096 -keyout client-key.pem -out client-cert.pem -days 365 -nodes -batch -subj '/CN=localhost'
+)
+
+add_custom_target(gen-tls DEPENDS server-key.pem)
+add_dependencies(alltests gen-tls)
 
 enable_testing()
 gtest_discover_tests(alltests TEST_PREFIX alltests:)
@@ -91,7 +129,7 @@ add_custom_target(coverage
 add_dependencies(coverage alltests)
 
 add_custom_target(coverage-report
-	COMMAND genhtml --branch-coverage --highlight --legend --prefix "${CMAKE_SOURCE_DIR}" coverage/lcov.info --output-directory coverage/report
+	COMMAND genhtml --branch-coverage --highlight --legend coverage/lcov.info --output-directory coverage/report
 )
 add_dependencies(coverage-report coverage)
 

cmake/webfuse_adapter.cmake

@@ -13,9 +13,9 @@ add_library(webfuse-adapter-static STATIC
 	lib/webfuse/adapter/impl/authenticator.c
 	lib/webfuse/adapter/impl/authenticators.c
 	lib/webfuse/adapter/impl/credentials.c
-	lib/webfuse/adapter/impl/operations.c
 	lib/webfuse/adapter/impl/mountpoint.c
 	lib/webfuse/adapter/impl/mountpoint_factory.c
+	lib/webfuse/adapter/impl/operation/context.c
 	lib/webfuse/adapter/impl/operation/lookup.c
 	lib/webfuse/adapter/impl/operation/getattr.c
 	lib/webfuse/adapter/impl/operation/readdir.c
@@ -26,8 +26,6 @@ add_library(webfuse-adapter-static STATIC
 
 target_include_directories(webfuse-adapter-static PRIVATE
 	lib
-	lib/wf/timer/include
-	lib/wf/jsonrpc/include
 	${FUSE3_INCLUDE_DIRS} 
 )
 
@@ -56,7 +54,7 @@ set_target_properties(webfuse-adapter PROPERTIES SOVERSION 0)
 set_target_properties(webfuse-adapter PROPERTIES C_VISIBILITY_PRESET hidden)
 set_target_properties(webfuse-adapter PROPERTIES COMPILE_DEFINITIONS "WF_API=WF_EXPORT")
 
-target_link_libraries(webfuse-adapter PRIVATE webfuse-adapter-static webfuse-core wf_jsonrpc wf_timer)
+target_link_libraries(webfuse-adapter PRIVATE webfuse-adapter-static webfuse-core)
 
 file(WRITE "${PROJECT_BINARY_DIR}/libwebfuse-adapter.pc"
 "prefix=\"${CMAKE_INSTALL_PREFIX}\"

cmake/webfuse_core.cmake

@@ -9,6 +9,17 @@ add_library(webfuse-core STATIC
 	lib/webfuse/core/base64.c
 	lib/webfuse/core/lws_log.c
 	lib/webfuse/core/json_util.c
+    lib/webfuse/core/timer/manager.c
+    lib/webfuse/core/timer/timepoint.c
+    lib/webfuse/core/timer/timer.c
+	lib/webfuse/core/jsonrpc/proxy.c
+	lib/webfuse/core/jsonrpc/proxy_variadic.c
+	lib/webfuse/core/jsonrpc/server.c
+	lib/webfuse/core/jsonrpc/method.c
+	lib/webfuse/core/jsonrpc/request.c
+	lib/webfuse/core/jsonrpc/response.c
+	lib/webfuse/core/jsonrpc/error.c
+
 )
 
 set_target_properties(webfuse-core PROPERTIES OUTPUT_NAME webfuse-core)

cmake/webfuse_provider.cmake

@@ -22,8 +22,6 @@ set_target_properties(webfuse-provider-static PROPERTIES OUTPUT_NAME webfuse-pro
 set_target_properties(webfuse-provider-static PROPERTIES C_VISIBILITY_PRESET hidden)
 target_include_directories(webfuse-provider-static PRIVATE 
 	lib
-	lib/wf/timer/include
-	lib/wf/jsonrpc/include
 )
 
 add_library(webfuse-provider SHARED 
@@ -36,7 +34,7 @@ set_target_properties(webfuse-provider PROPERTIES C_VISIBILITY_PRESET hidden)
 set_target_properties(webfuse-provider PROPERTIES COMPILE_DEFINITIONS "WFP_API=WFP_EXPORT")
 
 target_include_directories(webfuse-provider PUBLIC lib)
-target_link_libraries(webfuse-provider PRIVATE webfuse-provider-static webfuse-core wf_jsonrpc wf_timer)
+target_link_libraries(webfuse-provider PRIVATE webfuse-provider-static webfuse-core)
 
 file(WRITE "${PROJECT_BINARY_DIR}/libwebfuse-provider.pc"
 "prefix=\"${CMAKE_INSTALL_PREFIX}\"

cmake/wf_jsonrpc.cmake

@@ -1,24 +0,0 @@
-# wf_jsonrpc
-
-add_library(wf_jsonrpc STATIC
-	lib/wf/jsonrpc/src/wf/jsonrpc/api.c
-	lib/wf/jsonrpc/src/wf/jsonrpc/impl/proxy.c
-	lib/wf/jsonrpc/src/wf/jsonrpc/impl/server.c
-	lib/wf/jsonrpc/src/wf/jsonrpc/impl/method.c
-	lib/wf/jsonrpc/src/wf/jsonrpc/impl/request.c
-	lib/wf/jsonrpc/src/wf/jsonrpc/impl/response.c
-	lib/wf/jsonrpc/src/wf/jsonrpc/impl/error.c
-)
-
-target_link_libraries(wf_jsonrpc PUBLIC wf_timer)
-
-target_include_directories(wf_jsonrpc PRIVATE 
-	lib/wf/timer/include
-	lib/wf/jsonrpc/src
-)
-
-target_include_directories(wf_jsonrpc PUBLIC 
-	lib/wf/jsonrpc/include
-)
-
-set_target_properties(wf_jsonrpc PROPERTIES C_VISIBILITY_PRESET hidden)

cmake/wf_timer.cmake

@@ -1,18 +0,0 @@
-# timer
-
-add_library(wf_timer STATIC
-    lib/wf/timer/src/wf/timer/api.c
-    lib/wf/timer/src/wf/timer/impl/manager.c
-    lib/wf/timer/src/wf/timer/impl/timepoint.c
-    lib/wf/timer/src/wf/timer/impl/timer.c
-)
-
-target_include_directories(wf_timer PRIVATE 
-	lib/wf/timer/src
-)
-
-target_include_directories(wf_timer PUBLIC 
-	lib/wf/timer/include
-)
-
-set_target_properties(wf_timer PROPERTIES C_VISIBILITY_PRESET hidden)

codecov.yml

@@ -1,2 +1,12 @@
 ignore:
     - test
+    - lib/wf/timer/test
+    - lib/wf/jsonrpc/test
+
+parsers:
+    gcov:
+        branch_detection:
+            conditional: yes
+            loop: yes
+            method: yes
+            macro: yes

include/webfuse/provider/client_config.h

@@ -108,6 +108,19 @@ extern WFP_API void wfp_client_config_set_certpath(
     struct wfp_client_config * config,
     char const * cert_path);
 
+//------------------------------------------------------------------------------
+/// \brief Sets the path of ca file to verify servers.
+///
+/// \note To enable TLS both, private key and certificate, must be specified.
+///       Otherwise, TLS is not used.
+///
+/// \param config pointer to client configuration
+/// \param ca_filepath path of the ca file (pem file)
+//------------------------------------------------------------------------------
+extern WFP_API void wfp_client_config_set_ca_filepath(
+    struct wfp_client_config * config,
+    char const * ca_filepath);
+
 //------------------------------------------------------------------------------
 /// \brief Sets the onconnected handler.
 ///

lib/webfuse/adapter/impl/authenticator.c

@@ -11,13 +11,10 @@ struct wf_impl_authenticator * wf_impl_authenticator_create(
     void * user_data)
 {
     struct wf_impl_authenticator * authenticator = malloc(sizeof(struct wf_impl_authenticator));
-    if (NULL != authenticator)
+    authenticator->type = strdup(type);
-    {
+    authenticator->authenticate = authenticate;
-        authenticator->type = strdup(type);
+    authenticator->user_data = user_data;
-        authenticator->authenticate = authenticate;
+    authenticator->next = NULL;
-        authenticator->user_data = user_data;
-        authenticator->next = NULL;
-    }
 
     return authenticator;
 }

lib/webfuse/adapter/impl/filesystem.c

@@ -1,5 +1,11 @@
 #include "webfuse/adapter/impl/filesystem.h"
-#include "webfuse/adapter/impl/operations.h"
+#include "webfuse/adapter/impl/operation/context.h"
+#include "webfuse/adapter/impl/operation/open.h"
+#include "webfuse/adapter/impl/operation/close.h"
+#include "webfuse/adapter/impl/operation/read.h"
+#include "webfuse/adapter/impl/operation/readdir.h"
+#include "webfuse/adapter/impl/operation/getattr.h"
+#include "webfuse/adapter/impl/operation/lookup.h"
 #include "webfuse/adapter/impl/session.h"
 #include "webfuse/adapter/impl/mountpoint.h"
 
@@ -99,14 +105,11 @@ struct wf_impl_filesystem * wf_impl_filesystem_create(
 	struct wf_mountpoint * mountpoint)
 {
 	struct wf_impl_filesystem * filesystem = malloc(sizeof(struct wf_impl_filesystem));
-	if (NULL != filesystem)
+	bool success = wf_impl_filesystem_init(filesystem, session, name, mountpoint);
+	if (!success)
 	{
-		bool success = wf_impl_filesystem_init(filesystem, session, name, mountpoint);
+		free(filesystem);
-		if (!success)
+		filesystem = NULL;
-		{
-			free(filesystem);
-			filesystem = NULL;
-		}
 	}
 
 	return filesystem;

lib/webfuse/adapter/impl/filesystem.h

@@ -6,7 +6,7 @@
 #endif
 
 #include "webfuse/adapter/impl/fuse_wrapper.h"
-#include "webfuse/adapter/impl/operations.h"
+#include "webfuse/adapter/impl/operation/context.h"
 #include "webfuse/core/slist.h"
 
 #ifdef __cplusplus
@@ -24,7 +24,7 @@ struct wf_impl_filesystem
 	struct fuse_args args;
 	struct fuse_session * session;
 	struct fuse_buf buffer;
-	struct wf_impl_operations_context user_data;
+	struct wf_impl_operation_context user_data;
     struct lws * wsi;
     struct wf_mountpoint * mountpoint;
 };

lib/webfuse/adapter/impl/operation/close.c

@@ -1,10 +1,11 @@
-#include "webfuse/adapter/impl/operations.h"
+#include "webfuse/adapter/impl/operation/close.h"
+#include "webfuse/adapter/impl/operation/context.h"
 
 #include <limits.h>
 #include <errno.h>
 #include <jansson.h>
 
-#include "wf/jsonrpc/proxy.h"
+#include "webfuse/core/jsonrpc/proxy.h"
 #include "webfuse/core/util.h"
 
 void wf_impl_operation_close(
@@ -12,8 +13,8 @@ void wf_impl_operation_close(
 	fuse_ino_t inode,
 	struct fuse_file_info * file_info)
 {
-    struct wf_impl_operations_context * user_data = fuse_req_userdata(request);
+    struct wf_impl_operation_context * user_data = fuse_req_userdata(request);
-    struct wf_jsonrpc_proxy * rpc = wf_impl_operations_context_get_proxy(user_data);
+    struct wf_jsonrpc_proxy * rpc = wf_impl_operation_context_get_proxy(user_data);
 
 	if (NULL != rpc)
 	{

lib/webfuse/adapter/impl/operation/close.h

@@ -0,0 +1,20 @@
+#ifndef WF_ADAPTER_IMPL_OPERATION_CLOSE_H
+#define WF_ADAPTER_IMPL_OPERATION_CLOSE_H
+
+#include "webfuse/adapter/impl/fuse_wrapper.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+extern void wf_impl_operation_close(
+	fuse_req_t request,
+	fuse_ino_t inode,
+	struct fuse_file_info * file_info);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

lib/webfuse/adapter/impl/operation/context.c

@@ -1,10 +1,10 @@
-#include "webfuse/adapter/impl/operations.h"
+#include "webfuse/adapter/impl/operation/context.h"
 #include "webfuse/adapter/impl/session_manager.h"
 #include "webfuse/adapter/impl/session.h"
 #include <stddef.h>
 
-struct wf_jsonrpc_proxy * wf_impl_operations_context_get_proxy(
+struct wf_jsonrpc_proxy * wf_impl_operation_context_get_proxy(
-	struct wf_impl_operations_context * context)
+	struct wf_impl_operation_context * context)
 {
     struct wf_jsonrpc_proxy * proxy = NULL;
 

lib/webfuse/adapter/impl/operation/context.h

@@ -0,0 +1,28 @@
+#ifndef WF_ADAPTER_IMPL_OPERATION_CONTEXT_H
+#define WF_ADAPTER_IMPL_OPERATION_CONTEXT_H
+
+#include "webfuse/adapter/impl/fuse_wrapper.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct wf_impl_session;
+struct wf_jsonrpc_proxy;
+
+struct wf_impl_operation_context
+{
+	struct wf_impl_session * session;
+	double timeout;
+	char * name;
+};
+
+extern struct wf_jsonrpc_proxy * wf_impl_operation_context_get_proxy(
+	struct wf_impl_operation_context * context);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+

lib/webfuse/adapter/impl/operation/getattr.c

@@ -1,4 +1,5 @@
-#include "webfuse/adapter/impl/operations.h"
+#include "webfuse/adapter/impl/operation/getattr.h"
+#include "webfuse/adapter/impl/operation/context.h"
 
 #include <errno.h>
 #include <string.h>
@@ -7,20 +8,11 @@
 #include <sys/stat.h>
 #include <unistd.h> 
 
-#include "wf/jsonrpc/proxy.h"
+#include "webfuse/core/jsonrpc/proxy.h"
 #include "webfuse/core/json_util.h"
 #include "webfuse/core/util.h"
 
-struct wf_impl_operation_getattr_context
+void wf_impl_operation_getattr_finished(
-{
-	fuse_req_t request;
-	fuse_ino_t inode;
-	double timeout;
-	uid_t uid;
-	gid_t gid;
-};
-
-static void wf_impl_operation_getattr_finished(
 	void * user_data,
 	json_t const * result,
 	json_t const * error)
@@ -33,8 +25,7 @@ static void wf_impl_operation_getattr_finished(
 	{
 		json_t * mode_holder = json_object_get(result, "mode");
 		json_t * type_holder = json_object_get(result, "type");
-		if ((NULL != mode_holder) && (json_is_integer(mode_holder)) && 
+		if ((json_is_integer(mode_holder)) && (json_is_string(type_holder)))
-		    (NULL != type_holder) && (json_is_string(type_holder)))
 		{
             memset(&buffer, 0, sizeof(struct stat));
 
@@ -82,8 +73,8 @@ void wf_impl_operation_getattr (
 	struct fuse_file_info * WF_UNUSED_PARAM(file_info))
 {
     struct fuse_ctx const * context = fuse_req_ctx(request);
-    struct wf_impl_operations_context * user_data = fuse_req_userdata(request);
+    struct wf_impl_operation_context * user_data = fuse_req_userdata(request);
-    struct wf_jsonrpc_proxy * rpc = wf_impl_operations_context_get_proxy(user_data);
+    struct wf_jsonrpc_proxy * rpc = wf_impl_operation_context_get_proxy(user_data);
 
 	if (NULL != rpc)
 	{

lib/webfuse/adapter/impl/operation/getattr.h

@@ -0,0 +1,37 @@
+#ifndef WF_ADAPTER_IMPL_OPERATION_GETATTR_H
+#define WF_ADAPTER_IMPL_OPERATION_GETATTR_H
+
+#include "webfuse/adapter/impl/fuse_wrapper.h"
+
+#include <jansson.h>
+#include <sys/types.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+struct wf_impl_operation_getattr_context
+{
+	fuse_req_t request;
+	fuse_ino_t inode;
+	double timeout;
+	uid_t uid;
+	gid_t gid;
+};
+
+extern void wf_impl_operation_getattr_finished(
+	void * user_data,
+	json_t const * result,
+	json_t const * error);
+
+extern void wf_impl_operation_getattr (
+		fuse_req_t request,
+		fuse_ino_t inode,
+		struct fuse_file_info *file_info);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

lib/webfuse/adapter/impl/operation/lookup.c

@@ -1,4 +1,5 @@
-#include "webfuse/adapter/impl/operations.h"
+#include "webfuse/adapter/impl/operation/lookup.h"
+#include "webfuse/adapter/impl/operation/context.h"
 
 #include <limits.h>
 #include <errno.h>
@@ -10,19 +11,11 @@
 
 #include <stdlib.h>
 
-#include "wf/jsonrpc/proxy.h"
+#include "webfuse/core/jsonrpc/proxy.h"
 #include "webfuse/core/json_util.h"
 #include "webfuse/core/util.h"
 
-struct wf_impl_operation_lookup_context
+void wf_impl_operation_lookup_finished(
-{
-	fuse_req_t request;
-	double timeout;
-	uid_t uid;
-	gid_t gid;
-};
-
-static void wf_impl_operation_lookup_finished(
 	void * user_data,
 	json_t const * result,
 	json_t const * error
@@ -37,9 +30,9 @@ static void wf_impl_operation_lookup_finished(
 		json_t * inode_holder = json_object_get(result, "inode"); 
 		json_t * mode_holder = json_object_get(result, "mode");
 		json_t * type_holder = json_object_get(result, "type");
-		if ((NULL != inode_holder) && (json_is_integer(inode_holder)) &&
+		if ((json_is_integer(inode_holder)) &&
-			(NULL != mode_holder) && (json_is_integer(mode_holder)) && 
+			(json_is_integer(mode_holder)) && 
-		    (NULL != type_holder) && (json_is_string(type_holder)))
+		    (json_is_string(type_holder)))
 		{
             memset(&buffer, 0, sizeof(struct stat));
 
@@ -91,8 +84,8 @@ void wf_impl_operation_lookup (
 	char const * name)
 {
     struct fuse_ctx const * context = fuse_req_ctx(request);
-    struct wf_impl_operations_context * user_data = fuse_req_userdata(request);
+    struct wf_impl_operation_context * user_data = fuse_req_userdata(request);
-    struct wf_jsonrpc_proxy * rpc = wf_impl_operations_context_get_proxy(user_data);
+    struct wf_jsonrpc_proxy * rpc = wf_impl_operation_context_get_proxy(user_data);
 
 	if (NULL != rpc)
 	{

lib/webfuse/adapter/impl/operation/lookup.h

@@ -0,0 +1,36 @@
+#ifndef WF_ADAPTER_IMPL_OPERATION_LOOKUP_H
+#define WF_ADAPTER_IMPL_OPERATION_LOOKUP_H
+
+#include "webfuse/adapter/impl/fuse_wrapper.h"
+
+#include <jansson.h>
+#include <sys/types.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+struct wf_impl_operation_lookup_context
+{
+	fuse_req_t request;
+	double timeout;
+	uid_t uid;
+	gid_t gid;
+};
+
+extern void wf_impl_operation_lookup_finished(
+	void * user_data,
+	json_t const * result,
+	json_t const * error);
+
+extern void wf_impl_operation_lookup (
+	fuse_req_t req, 
+	fuse_ino_t parent, 
+	char const * name);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

lib/webfuse/adapter/impl/operation/open.c

@@ -1,15 +1,15 @@
-#include "webfuse/adapter/impl/operations.h"
+#include "webfuse/adapter/impl/operation/open.h"
+#include "webfuse/adapter/impl/operation/context.h"
 
-#include <string.h>
+#include "webfuse/core/jsonrpc/proxy.h"
-#include <errno.h>
-#include <jansson.h>
-
-#include "wf/jsonrpc/proxy.h"
 #include "webfuse/core/util.h"
 #include "webfuse/core/status.h"
 #include "webfuse/core/json_util.h"
 
-static void wf_impl_operation_open_finished(
+#include <string.h>
+#include <errno.h>
+
+void wf_impl_operation_open_finished(
 	void * user_data,
 	json_t const * result,
 	json_t const * error)
@@ -22,7 +22,7 @@ static void wf_impl_operation_open_finished(
 	if (NULL != result)
 	{
         json_t * handle_holder = json_object_get(result, "handle");
-        if ((NULL != handle_holder) && (json_is_integer(handle_holder))) 
+        if (json_is_integer(handle_holder))
         {
             file_info.fh = json_integer_value(handle_holder);
         }
@@ -48,8 +48,8 @@ void wf_impl_operation_open(
 	fuse_ino_t inode,
 	struct fuse_file_info * file_info)
 {
-    struct wf_impl_operations_context * user_data = fuse_req_userdata(request);
+    struct wf_impl_operation_context * user_data = fuse_req_userdata(request);
-    struct wf_jsonrpc_proxy * rpc = wf_impl_operations_context_get_proxy(user_data);
+    struct wf_jsonrpc_proxy * rpc = wf_impl_operation_context_get_proxy(user_data);
 
 	if (NULL != rpc)
 	{

lib/webfuse/adapter/impl/operation/open.h

@@ -0,0 +1,26 @@
+#ifndef WF_ADAPTER_IMPL_OPERATION_OPEN_H
+#define WF_ADAPTER_IMPL_OPERATION_OPEN_H
+
+#include "webfuse/adapter/impl/fuse_wrapper.h"
+#include <jansson.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+extern void wf_impl_operation_open(
+	fuse_req_t request,
+	fuse_ino_t inode,
+	struct fuse_file_info * file_info);
+
+extern void wf_impl_operation_open_finished(
+	void * user_data,
+	json_t const * result,
+	json_t const * error);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

lib/webfuse/adapter/impl/operation/read.c

@@ -1,18 +1,20 @@
-#include "webfuse/adapter/impl/operations.h"
+#include "webfuse/adapter/impl/operation/read.h"
+#include "webfuse/adapter/impl/operation/context.h"
 
 #include <errno.h>
 #include <string.h>
 #include <limits.h>
 #include <jansson.h>
 
-#include "wf/jsonrpc/proxy.h"
+#include "webfuse/core/jsonrpc/proxy.h"
 #include "webfuse/core/base64.h"
 #include "webfuse/core/json_util.h"
 
 #define WF_MAX_READ_LENGTH 4096
 
-static char * wf_impl_fill_buffer(
+char * wf_impl_fill_buffer(
 	char const * data,
+	size_t data_size,
 	char const * format,
 	size_t count,
 	wf_status * status)
@@ -20,15 +22,26 @@ static char * wf_impl_fill_buffer(
 	*status = WF_GOOD;
 	char * buffer = malloc(count);
 
-	if ((NULL != buffer) && (0 < count))
+	if (0 < count)
 	{
 		if (0 == strcmp("identity", format))
 		{
-			memcpy(buffer, data, count);
+			if (count == data_size)
+			{
+				memcpy(buffer, data, count);
+			}
+			else
+			{
+				*status = WF_BAD;
+			}			
 		}
 		else if (0 == strcmp("base64", format))
 		{
-			wf_base64_decode(data, strlen(data), (uint8_t *) buffer, count);
+			size_t result = wf_base64_decode(data, data_size, (uint8_t *) buffer, count);
+			if (result != count)
+			{
+				*status = WF_BAD;
+			}
 		}
 		else
 		{
@@ -36,10 +49,16 @@ static char * wf_impl_fill_buffer(
 		}
 	}
 
+	if (WF_GOOD != *status)
+	{
+		free(buffer);
+		buffer = NULL;
+	}
+
 	return buffer;
 }
 
-static void wf_impl_operation_read_finished(
+void wf_impl_operation_read_finished(
 	void * user_data, 
 	json_t const * result,
 	json_t const * error)
@@ -60,10 +79,11 @@ static void wf_impl_operation_read_finished(
             json_is_integer(count_holder))
 		{
 			char const * const data = json_string_value(data_holder);
+			size_t const data_size = json_string_length(data_holder);
 			char const * const format = json_string_value(format_holder);
 			length = (size_t) json_integer_value(count_holder);
 
-			buffer = wf_impl_fill_buffer(data, format, length, &status);
+			buffer = wf_impl_fill_buffer(data, data_size, format, length, &status);
 		}
 		else
 		{
@@ -91,8 +111,8 @@ void wf_impl_operation_read(
     off_t offset,
 	struct fuse_file_info * file_info)
 {
-    struct wf_impl_operations_context * user_data = fuse_req_userdata(request);
+    struct wf_impl_operation_context * user_data = fuse_req_userdata(request);
-    struct wf_jsonrpc_proxy * rpc = wf_impl_operations_context_get_proxy(user_data);
+    struct wf_jsonrpc_proxy * rpc = wf_impl_operation_context_get_proxy(user_data);
 
 	if (NULL != rpc)
 	{

lib/webfuse/adapter/impl/operation/read.h

@@ -0,0 +1,36 @@
+#ifndef WF_ADAPTER_IMPL_OPERATION_READ_H
+#define WF_ADAPTER_IMPL_OPERATION_READ_H
+
+#include "webfuse/adapter/impl/fuse_wrapper.h"
+#include "webfuse/core/status.h"
+
+#include <jansson.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+extern void wf_impl_operation_read(
+	fuse_req_t request,
+	fuse_ino_t ino, size_t size, off_t off,
+			struct fuse_file_info *fi);
+
+extern char * wf_impl_fill_buffer(
+	char const * data,
+	size_t data_size,
+	char const * format,
+	size_t count,
+	wf_status * status);
+
+extern void wf_impl_operation_read_finished(
+	void * user_data, 
+	json_t const * result,
+	json_t const * error);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

lib/webfuse/adapter/impl/operation/readdir.c

@@ -1,4 +1,5 @@
-#include "webfuse/adapter/impl/operations.h"
+#include "webfuse/adapter/impl/operation/readdir.h"
+#include "webfuse/adapter/impl/operation/context.h"
 
 #include <stdlib.h>
 #include <string.h>
@@ -8,20 +9,13 @@
 #include <sys/stat.h>
 #include <unistd.h> 
 
-#include "wf/jsonrpc/proxy.h"
+#include "webfuse/core/jsonrpc/proxy.h"
 #include "webfuse/core/util.h"
 #include "webfuse/core/json_util.h"
 
 
 #define WF_DIRBUFFER_INITIAL_SIZE 1024
 
-struct wf_impl_operation_readdir_context
-{
-	fuse_req_t request;
-	size_t size;
-	off_t offset;
-};
-
 struct wf_impl_dirbuffer
 {
 	char * data;
@@ -72,7 +66,7 @@ static size_t wf_impl_min(size_t a, size_t b)
 	return (a < b) ? a : b;
 }
 
-static void wf_impl_operation_readdir_finished(
+void wf_impl_operation_readdir_finished(
 	void * user_data,
 	json_t const * result,
 	json_t const * error)
@@ -83,31 +77,40 @@ static void wf_impl_operation_readdir_finished(
 	struct wf_impl_dirbuffer buffer;
 	wf_impl_dirbuffer_init(&buffer);
 
-	if (NULL != result)
+	if (json_is_array(result)) 
 	{
-		if (json_is_array(result)) 
+		size_t const count = json_array_size(result);
+		for(size_t i = 0; i < count; i++)
 		{
-			bool buffer_full = false;
+			json_t * entry =json_array_get(result, i);
-			size_t const count = json_array_size(result);
+			if (json_is_object(entry))
-			for(size_t i = 0; (!buffer_full) && (i < count); i++)
 			{
-				json_t * entry =json_array_get(result, i);
+				json_t * name_holder = json_object_get(entry, "name");
-				if (json_is_object(entry))
+				json_t * inode_holder = json_object_get(entry, "inode");
-				{
-					json_t * name_holder = json_object_get(entry, "name");
-					json_t * inode_holder = json_object_get(entry, "inode");
 
-					if ((NULL != name_holder) && (json_is_string(name_holder)) &&
+				if ((json_is_string(name_holder)) && (json_is_integer(inode_holder)))
-						(NULL != inode_holder) && (json_is_integer(inode_holder)))
+				{
-					{
+					char const * name = json_string_value(name_holder);
-						char const * name = json_string_value(name_holder);
+					fuse_ino_t entry_inode = (fuse_ino_t) json_integer_value(inode_holder);
-						fuse_ino_t entry_inode = (fuse_ino_t) json_integer_value(inode_holder);
+					wf_impl_dirbuffer_add(context->request, &buffer, name, entry_inode);	
-						wf_impl_dirbuffer_add(context->request, &buffer, name, entry_inode);	
+				}
-					}
+				else
+				{
+					status = WF_BAD_FORMAT;
+					break;
 				}
 			}
+			else
+			{
+				status = WF_BAD_FORMAT;
+				break;
+			}
 		}
 	}
+	else if (WF_GOOD == status)
+	{
+		status = WF_BAD_FORMAT;
+	}
 
 	if (WF_GOOD == status)
 	{
@@ -138,8 +141,8 @@ void wf_impl_operation_readdir (
 	off_t offset,
 	struct fuse_file_info * WF_UNUSED_PARAM(file_info))
 {
-    struct wf_impl_operations_context * user_data = fuse_req_userdata(request);
+    struct wf_impl_operation_context * user_data = fuse_req_userdata(request);
-    struct wf_jsonrpc_proxy * rpc = wf_impl_operations_context_get_proxy(user_data);
+    struct wf_jsonrpc_proxy * rpc = wf_impl_operation_context_get_proxy(user_data);
 
 	if (NULL != rpc)
 	{

lib/webfuse/adapter/impl/operation/readdir.h

@@ -0,0 +1,35 @@
+#ifndef WF_ADAPTER_IMPL_OPERATION_READDIR_H
+#define WF_ADAPTER_IMPL_OPERATION_READDIR_H
+
+#include "webfuse/adapter/impl/fuse_wrapper.h"
+#include <jansson.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+struct wf_impl_operation_readdir_context
+{
+	fuse_req_t request;
+	size_t size;
+	off_t offset;
+};
+
+extern void wf_impl_operation_readdir (
+	fuse_req_t request,
+	fuse_ino_t inode,
+	size_t size,
+	off_t offset,
+	struct fuse_file_info *file_info);
+
+extern void wf_impl_operation_readdir_finished(
+	void * user_data,
+	json_t const * result,
+	json_t const * error);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

lib/webfuse/adapter/impl/operations.h

@@ -1,60 +0,0 @@
-#ifndef WF_ADAPTER_IMPL_OPERATIONS_H
-#define WF_ADAPTER_IMPL_OPERATIONS_H
-
-#include "webfuse/adapter/impl/fuse_wrapper.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct wf_impl_session;
-struct wf_jsonrpc_proxy;
-
-struct wf_impl_operations_context
-{
-	struct wf_impl_session * session;
-	double timeout;
-	char * name;
-};
-
-extern void wf_impl_operation_lookup (
-	fuse_req_t req, 
-	fuse_ino_t parent, 
-	char const * name);
-
-extern void wf_impl_operation_getattr (
-		fuse_req_t request,
-		fuse_ino_t inode,
-		struct fuse_file_info *file_info);
-
-extern void wf_impl_operation_readdir (
-	fuse_req_t request,
-	fuse_ino_t inode,
-	size_t size,
-	off_t offset,
-	struct fuse_file_info *file_info);
-
-extern void wf_impl_operation_open(
-	fuse_req_t request,
-	fuse_ino_t inode,
-	struct fuse_file_info * file_info);
-
-extern void wf_impl_operation_close(
-	fuse_req_t request,
-	fuse_ino_t inode,
-	struct fuse_file_info * file_info);
-
-extern void wf_impl_operation_read(
-	fuse_req_t request,
-	fuse_ino_t ino, size_t size, off_t off,
-			struct fuse_file_info *fi);
-
-extern struct wf_jsonrpc_proxy * wf_impl_operations_context_get_proxy(
-	struct wf_impl_operations_context * context);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-

lib/webfuse/adapter/impl/server.c

@@ -83,13 +83,10 @@ struct wf_server * wf_impl_server_create(
 	if (wf_impl_mountpoint_factory_isvalid(&config->mountpoint_factory))
 	{
 		server = malloc(sizeof(struct wf_server));
-		if (NULL != server)
+		wf_impl_server_protocol_init(&server->protocol, &config->mountpoint_factory);
-		{
+		wf_impl_server_config_clone(config, &server->config);
-			wf_impl_server_protocol_init(&server->protocol, &config->mountpoint_factory);
+		wf_impl_authenticators_move(&server->config.authenticators, &server->protocol.authenticators);				
-			wf_impl_server_config_clone(config, &server->config);
+		server->context = wf_impl_server_context_create(server);
-			wf_impl_authenticators_move(&server->config.authenticators, &server->protocol.authenticators);				
-			server->context = wf_impl_server_context_create(server);
-		}   
 	}
 
     return server; 

lib/webfuse/adapter/impl/server_config.c

@@ -56,10 +56,7 @@ void wf_impl_server_config_clone(
 struct wf_server_config * wf_impl_server_config_create(void)
 {
     struct wf_server_config * config = malloc(sizeof(struct wf_server_config));
-    if (NULL != config)
+    wf_impl_server_config_init(config);
-    {
-        wf_impl_server_config_init(config);
-    }
 
     return config;
 }

lib/webfuse/adapter/impl/server_protocol.c

@@ -11,9 +11,9 @@
 #include "webfuse/adapter/impl/credentials.h"
 #include "webfuse/core/status_intern.h"
 
-#include "wf/jsonrpc/request.h"
+#include "webfuse/core/jsonrpc/request.h"
-#include "wf/timer/manager.h"
+#include "webfuse/core/timer/manager.h"
-#include "wf/timer/timer.h"
+#include "webfuse/core/timer/timer.h"
 
 static int wf_impl_server_protocol_callback(
 	struct lws * wsi,
@@ -23,13 +23,10 @@ static int wf_impl_server_protocol_callback(
 	size_t len)
 {
     struct lws_protocols const * ws_protocol = lws_get_protocol(wsi);
-    if (NULL == ws_protocol)
+    if (NULL == ws_protocol) { return 0; }
-    {
+    if (ws_protocol->callback != &wf_impl_server_protocol_callback) { return 0; }
-        return 0;
-    }
 
     struct wf_server_protocol * protocol = ws_protocol->user;
-
     wf_timer_manager_check(protocol->timer_manager);
     struct wf_impl_session * session = wf_impl_session_manager_get(&protocol->session_manager, wsi);
 
@@ -85,14 +82,11 @@ struct wf_server_protocol * wf_impl_server_protocol_create(
     void * create_mountpoint_context)
 {
     struct wf_server_protocol * protocol = malloc(sizeof(struct wf_server_protocol));
-    if (NULL != protocol)
+    struct wf_impl_mountpoint_factory mountpoint_factory;
-    {
+    wf_impl_mountpoint_factory_init(&mountpoint_factory,
-        struct wf_impl_mountpoint_factory mountpoint_factory;
+        create_mountpoint, create_mountpoint_context);
-        wf_impl_mountpoint_factory_init(&mountpoint_factory,
-            create_mountpoint, create_mountpoint_context);
 
-        wf_impl_server_protocol_init(protocol, &mountpoint_factory);
+    wf_impl_server_protocol_init(protocol, &mountpoint_factory);
-    }
 
     return protocol;
 

lib/webfuse/adapter/impl/server_protocol.h

@@ -4,8 +4,8 @@
 #include "webfuse/adapter/impl/authenticators.h"
 #include "webfuse/adapter/impl/mountpoint_factory.h"
 #include "webfuse/adapter/impl/session_manager.h"
-#include "wf/jsonrpc/proxy.h"
+#include "webfuse/core/jsonrpc/proxy.h"
-#include "wf/jsonrpc/server.h"
+#include "webfuse/core/jsonrpc/server.h"
 
 #ifndef __cplusplus
 #include <stdbool.h>

lib/webfuse/adapter/impl/session.c

@@ -8,9 +8,9 @@
 #include "webfuse/core/container_of.h"
 #include "webfuse/core/util.h"
 
-#include "wf/jsonrpc/proxy.h"
+#include "webfuse/core/jsonrpc/proxy.h"
-#include "wf/jsonrpc/request.h"
+#include "webfuse/core/jsonrpc/request.h"
-#include "wf/jsonrpc/response.h"
+#include "webfuse/core/jsonrpc/response.h"
 
 #include <libwebsockets.h>
 #include <stddef.h>
@@ -51,18 +51,15 @@ struct wf_impl_session * wf_impl_session_create(
 {
 
     struct wf_impl_session * session = malloc(sizeof(struct wf_impl_session));
-    if (NULL != session)
+    wf_slist_init(&session->filesystems);
-    {
-        wf_slist_init(&session->filesystems);
     
-        session->wsi = wsi;
+    session->wsi = wsi;
-        session->is_authenticated = false;
+    session->is_authenticated = false;
-        session->authenticators = authenticators;
+    session->authenticators = authenticators;
-        session->server = server;
+    session->server = server;
-        session->mountpoint_factory = mountpoint_factory;
+    session->mountpoint_factory = mountpoint_factory;
-        session->rpc = wf_jsonrpc_proxy_create(timer_manager, WF_DEFAULT_TIMEOUT, &wf_impl_session_send, session);
+    session->rpc = wf_jsonrpc_proxy_create(timer_manager, WF_DEFAULT_TIMEOUT, &wf_impl_session_send, session);
-        wf_slist_init(&session->messages);
+    wf_slist_init(&session->messages);
-    }
 
     return session;
 }

lib/webfuse/adapter/impl/session.h

@@ -13,8 +13,8 @@ using std::size_t;
 #include "webfuse/adapter/impl/filesystem.h"
 #include "webfuse/core/slist.h"
 
-#include "wf/jsonrpc/proxy.h"
+#include "webfuse/core/jsonrpc/proxy.h"
-#include "wf/jsonrpc/server.h"
+#include "webfuse/core/jsonrpc/server.h"
 
 #ifdef __cplusplus
 extern "C"

lib/webfuse/adapter/impl/session_manager.c

@@ -33,10 +33,7 @@ struct wf_impl_session * wf_impl_session_manager_add(
 {
     struct wf_impl_session * session = wf_impl_session_create(
         wsi, authenticators, timer_manager, server, mountpoint_factory); 
-    if (NULL != session)
+    wf_slist_append(&manager->sessions, &session->item);
-    {
-        wf_slist_append(&manager->sessions, &session->item);
-    }
 
     return session;
 }

lib/webfuse/core/json_util.c

@@ -1,5 +1,4 @@
 #include "webfuse/core/json_util.h"
-#include "wf/jsonrpc/status.h"
 
 int wf_impl_json_get_int(json_t const * object, char const * key, int default_value)
 {
@@ -14,25 +13,6 @@ int wf_impl_json_get_int(json_t const * object, char const * key, int default_va
 	return result;
 }
 
-static wf_status wf_impl_jsonrc_code_to_status(int code)
-{
-	switch (code)
-	{
-		case WF_JSONRPC_GOOD:
-			return WF_GOOD;
-		case WF_JSONRPC_BAD:
-			return WF_BAD;
-		case WF_JSONRPC_BAD_BUSY:
-			return WF_BAD_BUSY;
-		case WF_JSONRPC_BAD_TIMEOUT:
-			return WF_BAD_TIMEOUT;
-		case WF_JSONRPC_BAD_FORMAT:
-			return WF_BAD_FORMAT;
-		default:
-			return (wf_status) code;
-	}
-}
-
 wf_status 
 wf_impl_jsonrpc_get_status(
 	json_t const * error)
@@ -40,8 +20,7 @@ wf_impl_jsonrpc_get_status(
 	wf_status status = WF_GOOD;
 	if (NULL != error)
 	{
-		int code = wf_impl_json_get_int(error, "code", WF_BAD_FORMAT);
+		status = wf_impl_json_get_int(error, "code", WF_BAD_FORMAT);
-		status = wf_impl_jsonrc_code_to_status(code);
 	}
 
 	return status;

lib/webfuse/core/jsonrpc/error.c

@@ -1,7 +1,7 @@
-#include "wf/jsonrpc/impl/error.h"
+#include "webfuse/core/jsonrpc/error.h"
 
 json_t *
-wf_jsonrpc_impl_error(
+wf_jsonrpc_error(
     int code,
     char const * message)
 {
@@ -13,13 +13,13 @@ wf_jsonrpc_impl_error(
 }
 
 void
-wf_jsonrpc_impl_propate_error(
+wf_jsonrpc_propate_error(
     wf_jsonrpc_proxy_finished_fn * finised,
     void * user_data,
     int code,
     char const * message)
 {
-    json_t * error = wf_jsonrpc_impl_error(code, message);
+    json_t * error = wf_jsonrpc_error(code, message);
     finised(user_data, NULL, error);
 
     json_decref(error);

lib/webfuse/core/jsonrpc/error.h

@@ -1,8 +1,8 @@
-#ifndef WF_JSONRPC_IMPL_ERROR_H
+#ifndef WF_JSONRPC_ERROR_H
-#define WF_JSONRPC_IMPL_ERROR_H
+#define WF_JSONRPC_ERROR_H
 
 #include <jansson.h>
-#include "wf/jsonrpc/proxy_finished_fn.h"
+#include "webfuse/core/jsonrpc/proxy_finished_fn.h"
 
 #ifdef __cplusplus
 extern "C"
@@ -10,12 +10,12 @@ extern "C"
 #endif
 
 extern json_t *
-wf_jsonrpc_impl_error(
+wf_jsonrpc_error(
     int code,
     char const * message);
 
 extern void
-wf_jsonrpc_impl_propate_error(
+wf_jsonrpc_propate_error(
     wf_jsonrpc_proxy_finished_fn * finised,
     void * user_data,
     int code,

lib/webfuse/core/jsonrpc/method.c

@@ -1,25 +1,22 @@
-#include "wf/jsonrpc/impl/method.h"
+#include "webfuse/core/jsonrpc/method.h"
 #include <stdlib.h>
 #include <string.h>
 
-struct wf_jsonrpc_method * wf_jsonrpc_impl_method_create(
+struct wf_jsonrpc_method * wf_jsonrpc_method_create(
     char const * method_name,
     wf_jsonrpc_method_invoke_fn * invoke,
     void * user_data)
 {
     struct wf_jsonrpc_method * method = malloc(sizeof(struct wf_jsonrpc_method));
-    if (NULL != method)
+    method->next = NULL;
-    {
+    method->name = strdup(method_name);
-        method->next = NULL;
+    method->invoke = invoke;
-        method->name = strdup(method_name);
+    method->user_data = user_data;
-        method->invoke = invoke;
-        method->user_data = user_data;
-    }
 
     return method;
 }
 
-void wf_jsonrpc_impl_method_dispose(
+void wf_jsonrpc_method_dispose(
     struct wf_jsonrpc_method * method)
 {
     free(method->name);

lib/webfuse/core/jsonrpc/method.h

@@ -1,7 +1,7 @@
-#ifndef WF_JSONRPC_IMPL_METHOD_H
+#ifndef WF_JSONRPC_METHOD_H
-#define WF_JSONRPC_IMPL_METHOD_H
+#define WF_JSONRPC_METHOD_H
 
-#include "wf/jsonrpc/method_invoke_fn.h"
+#include "webfuse/core/jsonrpc/method_invoke_fn.h"
 
 #ifdef __cplusplus
 extern "C"
@@ -17,13 +17,13 @@ struct wf_jsonrpc_method
 };
 
 extern struct wf_jsonrpc_method *
-wf_jsonrpc_impl_method_create(
+wf_jsonrpc_method_create(
     char const * method_name,
     wf_jsonrpc_method_invoke_fn * invoke,
     void * user_data);
 
 extern void
-wf_jsonrpc_impl_method_dispose(
+wf_jsonrpc_method_dispose(
     struct wf_jsonrpc_method * method);
 
 #ifdef __cplusplus

lib/webfuse/core/jsonrpc/method_invoke_fn.h

@@ -1,7 +1,6 @@
 #ifndef WF_JSONRPC_METHOD_INVOKE_FN_H
 #define WF_JSONRPC_METHOD_INVOKE_FN_H
 
-#include <wf/jsonrpc/api.h>
 #include <jansson.h>
 
 #ifdef __cplusplus
@@ -17,7 +16,6 @@ typedef void wf_jsonrpc_method_invoke_fn(
     json_t * params,
     void * user_data);
 
-
 #ifdef __cplusplus
 }
 #endif

lib/webfuse/core/jsonrpc/proxy.c

@@ -1,37 +1,34 @@
-#include "wf/jsonrpc/impl/proxy.h"
+#include "webfuse/core/jsonrpc/proxy_intern.h"
-#include "wf/jsonrpc/impl/response.h"
+#include "webfuse/core/jsonrpc/response_intern.h"
-#include "wf/jsonrpc/impl/error.h"
+#include "webfuse/core/jsonrpc/error.h"
-#include "wf/jsonrpc/status.h"
+#include "webfuse/core/status.h"
 
-#include <wf/timer/timer.h>
+#include "webfuse/core/timer/timer.h"
 
 #include <stdlib.h>
 #include <string.h>
 
 struct wf_jsonrpc_proxy *
-wf_jsonrpc_impl_proxy_create(
+wf_jsonrpc_proxy_create(
     struct wf_timer_manager * manager,
     int timeout,
     wf_jsonrpc_send_fn * send,
     void * user_data)
 {
     struct wf_jsonrpc_proxy * proxy = malloc(sizeof(struct wf_jsonrpc_proxy));
-    if (NULL != proxy)
+    wf_jsonrpc_proxy_init(proxy, manager, timeout, send, user_data);
-    {
-        wf_jsonrpc_impl_proxy_init(proxy, manager, timeout, send, user_data);
-    }
 
     return proxy;
 }
 
-void wf_jsonrpc_impl_proxy_dispose(
+void wf_jsonrpc_proxy_dispose(
     struct wf_jsonrpc_proxy * proxy)
 {
-    wf_jsonrpc_impl_proxy_cleanup(proxy);
+    wf_jsonrpc_proxy_cleanup(proxy);
     free(proxy);
 }
 
-static void wf_jsonrpc_impl_proxy_on_timeout(
+static void wf_jsonrpc_proxy_on_timeout(
     struct wf_timer * timer, void * proxy_ptr)
 {
     struct wf_jsonrpc_proxy * proxy = proxy_ptr;
@@ -47,11 +44,11 @@ static void wf_jsonrpc_impl_proxy_on_timeout(
         proxy->request.finished = NULL;
         wf_timer_cancel(timer);
 
-        wf_jsonrpc_impl_propate_error(finished, user_data, WF_JSONRPC_BAD_TIMEOUT, "Timeout");
+        wf_jsonrpc_propate_error(finished, user_data, WF_BAD_TIMEOUT, "Timeout");
     }
 }
 
-static json_t * wf_jsonrpc_impl_request_create(
+static json_t * wf_jsonrpc_request_create(
 	char const * method,
 	int id,
 	char const * param_info,
@@ -101,7 +98,7 @@ static json_t * wf_jsonrpc_impl_request_create(
 	return request;
 }
 
-void wf_jsonrpc_impl_proxy_init(
+void wf_jsonrpc_proxy_init(
     struct wf_jsonrpc_proxy * proxy,
     struct wf_timer_manager * timeout_manager,
     int timeout,
@@ -113,10 +110,10 @@ void wf_jsonrpc_impl_proxy_init(
     proxy->user_data = user_data;
     proxy->request.is_pending = false;
     proxy->request.timer = wf_timer_create(timeout_manager, 
-        &wf_jsonrpc_impl_proxy_on_timeout, proxy);    
+        &wf_jsonrpc_proxy_on_timeout, proxy);    
 }
 
-void wf_jsonrpc_impl_proxy_cleanup(
+void wf_jsonrpc_proxy_cleanup(
     struct wf_jsonrpc_proxy * proxy)
 {
     if (proxy->request.is_pending)
@@ -130,20 +127,19 @@ void wf_jsonrpc_impl_proxy_cleanup(
         proxy->request.id = 0;
         wf_timer_cancel(proxy->request.timer);
 
-        wf_jsonrpc_impl_propate_error(finished, user_data, WF_JSONRPC_BAD, "Bad: cancelled pending request during shutdown");
+        wf_jsonrpc_propate_error(finished, user_data, WF_BAD, "Bad: cancelled pending request during shutdown");
     }
 
     wf_timer_dispose(proxy->request.timer);
 }
 
-void wf_jsonrpc_impl_proxy_invoke(
+void wf_jsonrpc_proxy_vinvoke(
 	struct wf_jsonrpc_proxy * proxy,
 	wf_jsonrpc_proxy_finished_fn * finished,
 	void * user_data,
 	char const * method_name,
 	char const * param_info,
-	va_list args
+	va_list args)
-)
 {
     if (!proxy->request.is_pending)
     {
@@ -153,7 +149,7 @@ void wf_jsonrpc_impl_proxy_invoke(
         proxy->request.id = 42;
         wf_timer_start(proxy->request.timer, proxy->timeout);
         
-        json_t * request = wf_jsonrpc_impl_request_create(method_name, proxy->request.id, param_info, args);
+        json_t * request = wf_jsonrpc_request_create(method_name, proxy->request.id, param_info, args);
 
         bool const is_send = ((NULL != request) && (proxy->send(request, proxy->user_data)));
         if (!is_send)
@@ -164,7 +160,7 @@ void wf_jsonrpc_impl_proxy_invoke(
             proxy->request.id = 0;
             wf_timer_cancel(proxy->request.timer);
 
-            wf_jsonrpc_impl_propate_error(finished, user_data, WF_JSONRPC_BAD, "Bad: requenst is not sent");
+            wf_jsonrpc_propate_error(finished, user_data, WF_BAD, "Bad: requenst is not sent");
         }
 
         if (NULL != request)
@@ -174,18 +170,18 @@ void wf_jsonrpc_impl_proxy_invoke(
     }
     else
     {
-        wf_jsonrpc_impl_propate_error(finished, user_data, WF_JSONRPC_BAD_BUSY, "Busy");
+        wf_jsonrpc_propate_error(finished, user_data, WF_BAD_BUSY, "Busy");
     }
 }
 
-extern void wf_jsonrpc_impl_proxy_notify(
+extern void wf_jsonrpc_proxy_vnotify(
 	struct wf_jsonrpc_proxy * proxy,
 	char const * method_name,
 	char const * param_info,
-	va_list args
+	va_list args)
-)
 {
-    json_t * request = wf_jsonrpc_impl_request_create(method_name, 0, param_info, args);
+    json_t * request = wf_jsonrpc_request_create(method_name, 0, param_info, args);
+
     if (NULL != request)
     {
         proxy->send(request, proxy->user_data);
@@ -194,12 +190,12 @@ extern void wf_jsonrpc_impl_proxy_notify(
 }
 
 
-void wf_jsonrpc_impl_proxy_onresult(
+void wf_jsonrpc_proxy_onresult(
     struct wf_jsonrpc_proxy * proxy,
     json_t * message)
 {
 	struct wf_jsonrpc_response response;
-	wf_jsonrpc_impl_response_init(&response, message);
+	wf_jsonrpc_response_init(&response, message);
 
     if ((proxy->request.is_pending) && (response.id == proxy->request.id))
     {
@@ -215,6 +211,6 @@ void wf_jsonrpc_impl_proxy_onresult(
         finished(user_data, response.result, response.error);
     }
 
-    wf_jsonrpc_impl_response_cleanup(&response);
+    wf_jsonrpc_response_cleanup(&response);
 }
 

lib/webfuse/core/jsonrpc/proxy.h

@@ -12,9 +12,8 @@ using std::size_t;
 #endif
 
 #include <jansson.h>
-#include <wf/jsonrpc/api.h>
+#include "webfuse/core/jsonrpc/send_fn.h"
-#include <wf/jsonrpc/send_fn.h>
+#include "webfuse/core/jsonrpc/proxy_finished_fn.h"
-#include <wf/jsonrpc/proxy_finished_fn.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -23,14 +22,14 @@ extern "C" {
 struct wf_jsonrpc_proxy;
 struct wf_timer_manager;
 
-extern WF_JSONRPC_API struct wf_jsonrpc_proxy *
+extern struct wf_jsonrpc_proxy *
 wf_jsonrpc_proxy_create(
     struct wf_timer_manager * manager,
     int timeout,
     wf_jsonrpc_send_fn * send,
     void * user_data);
 
-extern WF_JSONRPC_API void wf_jsonrpc_proxy_dispose(
+extern void wf_jsonrpc_proxy_dispose(
     struct wf_jsonrpc_proxy * proxy);
 
 //------------------------------------------------------------------------------
@@ -47,7 +46,7 @@ extern WF_JSONRPC_API void wf_jsonrpc_proxy_dispose(
 /// \param param_info types of the param (s = string, i = integer, j = json)
 /// \param ... params
 //------------------------------------------------------------------------------
-extern WF_JSONRPC_API void wf_jsonrpc_proxy_invoke(
+extern void wf_jsonrpc_proxy_invoke(
 	struct wf_jsonrpc_proxy * proxy,
 	wf_jsonrpc_proxy_finished_fn * finished,
 	void * user_data,
@@ -56,14 +55,14 @@ extern WF_JSONRPC_API void wf_jsonrpc_proxy_invoke(
 	...
 );
 
-extern WF_JSONRPC_API void wf_jsonrpc_proxy_notify(
+extern void wf_jsonrpc_proxy_notify(
 	struct wf_jsonrpc_proxy * proxy,
 	char const * method_name,
 	char const * param_info,
 	...
 );
 
-extern WF_JSONRPC_API void wf_jsonrpc_proxy_onresult(
+extern void wf_jsonrpc_proxy_onresult(
     struct wf_jsonrpc_proxy * proxy,
     json_t * message);
 

lib/webfuse/core/jsonrpc/proxy_intern.h

@@ -1,15 +1,15 @@
-#ifndef WF_JSONRPC_IMPL_PROXY_H
+#ifndef WF_JSONRPC_PROXY_INTERN_H
-#define WF_JSONRPC_IMPL_PROXY_H
+#define WF_JSONRPC_PROXY_INTERN_H
 
-#include "wf/jsonrpc/proxy_finished_fn.h"
+#include "webfuse/core/jsonrpc/proxy.h"
-#include "wf/jsonrpc/send_fn.h"
+#include "webfuse/core/jsonrpc/proxy_finished_fn.h"
+#include "webfuse/core/jsonrpc/send_fn.h"
 
 #ifdef __cplusplus
 extern "C"
 {
 #endif
 
-struct wf_timer_manager;
 struct wf_timer;
 
 struct wf_jsonrpc_request
@@ -30,7 +30,7 @@ struct wf_jsonrpc_proxy
 };
 
 extern void 
-wf_jsonrpc_impl_proxy_init(
+wf_jsonrpc_proxy_init(
     struct wf_jsonrpc_proxy * proxy,
     struct wf_timer_manager * manager,
     int timeout,
@@ -38,44 +38,22 @@ wf_jsonrpc_impl_proxy_init(
     void * user_data);
 
 extern void 
-wf_jsonrpc_impl_proxy_cleanup(
+wf_jsonrpc_proxy_cleanup(
     struct wf_jsonrpc_proxy * proxy);
 
-extern struct wf_jsonrpc_proxy *
+extern void wf_jsonrpc_proxy_vinvoke(
-wf_jsonrpc_impl_proxy_create(
-    struct wf_timer_manager * manager,
-    int timeout,
-    wf_jsonrpc_send_fn * send,
-    void * user_data);
-
-extern void
-wf_jsonrpc_impl_proxy_dispose(
-    struct wf_jsonrpc_proxy * proxy);
-
-
-extern void
-wf_jsonrpc_impl_proxy_invoke(
 	struct wf_jsonrpc_proxy * proxy,
 	wf_jsonrpc_proxy_finished_fn * finished,
 	void * user_data,
 	char const * method_name,
 	char const * param_info,
-	va_list args
+	va_list args);
-);
 
-extern void
+extern void wf_jsonrpc_proxy_vnotify(
-wf_jsonrpc_impl_proxy_notify(
 	struct wf_jsonrpc_proxy * proxy,
 	char const * method_name,
 	char const * param_info,
-	va_list args
+	va_list args);
-);
-
-extern void
-wf_jsonrpc_impl_proxy_onresult(
-    struct wf_jsonrpc_proxy * proxy,
-    json_t * message);
-
 
 #ifdef __cplusplus
 }

lib/webfuse/core/jsonrpc/proxy_variadic.c

@@ -0,0 +1,28 @@
+#include "webfuse/core/jsonrpc/proxy_intern.h"
+
+void wf_jsonrpc_proxy_invoke(
+	struct wf_jsonrpc_proxy * proxy,
+	wf_jsonrpc_proxy_finished_fn * finished,
+	void * user_data,
+	char const * method_name,
+	char const * param_info,
+	...)
+{
+    va_list args;
+    va_start(args, param_info);
+    wf_jsonrpc_proxy_vinvoke(proxy, finished, user_data, method_name, param_info, args);
+    va_end(args);
+}
+
+extern void wf_jsonrpc_proxy_notify(
+	struct wf_jsonrpc_proxy * proxy,
+	char const * method_name,
+	char const * param_info,
+	...
+)
+{
+    va_list args;
+    va_start(args, param_info);
+    wf_jsonrpc_proxy_vnotify(proxy, method_name, param_info, args);
+    va_end(args);
+}

lib/webfuse/core/jsonrpc/request.c

@@ -1,5 +1,5 @@
-#include "wf/jsonrpc/impl/request.h"
+#include "webfuse/core/jsonrpc/request.h"
-#include "wf/jsonrpc/impl/error.h"
+#include "webfuse/core/jsonrpc/error.h"
 #include <stdlib.h>
 
 struct wf_jsonrpc_request
@@ -10,7 +10,7 @@ struct wf_jsonrpc_request
 };
 
 bool
-wf_jsonrpc_impl_is_request(
+wf_jsonrpc_is_request(
     json_t * message)
 {
     json_t * id = json_object_get(message, "id");
@@ -23,31 +23,28 @@ wf_jsonrpc_impl_is_request(
 
 
 struct wf_jsonrpc_request *
-wf_jsonrpc_impl_request_create(
+wf_jsonrpc_request_create(
     int id,
     wf_jsonrpc_send_fn * send,
     void * user_data)
 {
     struct wf_jsonrpc_request * request = malloc(sizeof(struct wf_jsonrpc_request));
-    if (NULL != request)
+    request->id = id;
-    {
+    request->send = send;
-        request->id = id;
+    request->user_data = user_data;
-        request->send = send;
-        request->user_data = user_data;
-    }
 
     return request;
 }
 
 void
-wf_jsonrpc_impl_request_dispose(
+wf_jsonrpc_request_dispose(
     struct wf_jsonrpc_request * request)
 {
     free(request);
 }
 
 void *
-wf_jsonrpc_impl_request_get_userdata(
+wf_jsonrpc_request_get_userdata(
     struct wf_jsonrpc_request * request)
 {
     return request->user_data;
@@ -55,7 +52,7 @@ wf_jsonrpc_impl_request_get_userdata(
 
 
 void
-wf_jsonrpc_impl_respond(
+wf_jsonrpc_respond(
     struct wf_jsonrpc_request * request,
     json_t * result)
 {
@@ -65,20 +62,20 @@ wf_jsonrpc_impl_respond(
 
     request->send(response, request->user_data);
     json_decref(response);
-    wf_jsonrpc_impl_request_dispose(request);
+    wf_jsonrpc_request_dispose(request);
 }
 
-void wf_jsonrpc_impl_respond_error(
+void wf_jsonrpc_respond_error(
     struct wf_jsonrpc_request * request,
     int code,
     char const * message)
 {
     json_t * response = json_object();
-    json_object_set_new(response, "error", wf_jsonrpc_impl_error(code, message));
+    json_object_set_new(response, "error", wf_jsonrpc_error(code, message));
     json_object_set_new(response, "id", json_integer(request->id));
 
     request->send(response, request->user_data);
     json_decref(response);
-    wf_jsonrpc_impl_request_dispose(request);
+    wf_jsonrpc_request_dispose(request);
 }
 

lib/webfuse/core/jsonrpc/request.h

@@ -12,8 +12,7 @@ using std::size_t;
 #endif
 
 #include <jansson.h>
-#include <wf/jsonrpc/api.h>
+#include "webfuse/core/jsonrpc/send_fn.h"
-#include "wf/jsonrpc/send_fn.h"
 
 #ifdef __cplusplus
 extern "C"
@@ -22,26 +21,26 @@ extern "C"
 
 struct wf_jsonrpc_request;
 
-extern WF_JSONRPC_API bool wf_jsonrpc_is_request(
+extern bool wf_jsonrpc_is_request(
     json_t * message);
 
-extern WF_JSONRPC_API struct wf_jsonrpc_request *
+extern struct wf_jsonrpc_request *
 wf_jsonrpc_request_create(
     int id,
     wf_jsonrpc_send_fn * send,
     void * user_data);
 
-extern WF_JSONRPC_API void wf_jsonrpc_request_dispose(
+extern void wf_jsonrpc_request_dispose(
     struct wf_jsonrpc_request * request);
 
-extern WF_JSONRPC_API void * wf_jsonrpc_request_get_userdata(
+extern void * wf_jsonrpc_request_get_userdata(
     struct wf_jsonrpc_request * request);
 
-extern WF_JSONRPC_API void wf_jsonrpc_respond(
+extern void wf_jsonrpc_respond(
     struct wf_jsonrpc_request * request,
     json_t * result);
 
-extern WF_JSONRPC_API void wf_jsonrpc_respond_error(
+extern void wf_jsonrpc_respond_error(
     struct wf_jsonrpc_request * request,
     int code,
     char const * message);

lib/webfuse/core/jsonrpc/response.c

@@ -1,9 +1,9 @@
-#include "wf/jsonrpc/impl/response.h"
+#include "webfuse/core/jsonrpc/response_intern.h"
-#include "wf/jsonrpc/impl/error.h"
+#include "webfuse/core/jsonrpc/error.h"
-#include "wf/jsonrpc/status.h"
+#include "webfuse/core/status.h"
 
 bool
-wf_jsonrpc_impl_is_response(
+wf_jsonrpc_is_response(
     json_t * message)
 {
 	json_t * id = json_object_get(message, "id");
@@ -16,7 +16,7 @@ wf_jsonrpc_impl_is_response(
 
 
 void
-wf_jsonrpc_impl_response_init(
+wf_jsonrpc_response_init(
 	struct wf_jsonrpc_response * result,
 	json_t * response)
 {
@@ -25,9 +25,9 @@ wf_jsonrpc_impl_response_init(
 	result->error = NULL;
 
 	json_t * id_holder = json_object_get(response, "id");
-	if ((NULL == id_holder) || (!json_is_integer(id_holder)))
+	if (!json_is_integer(id_holder))
 	{
-		result->error = wf_jsonrpc_impl_error(WF_JSONRPC_BAD_FORMAT, "invalid format: missing id");
+		result->error = wf_jsonrpc_error(WF_BAD_FORMAT, "invalid format: missing id");
 		return;
 	}
 	
@@ -47,13 +47,13 @@ wf_jsonrpc_impl_response_init(
 		}
 		else
 		{
-			result->error = wf_jsonrpc_impl_error(WF_JSONRPC_BAD_FORMAT, "invalid format: invalid error object");
+			result->error = wf_jsonrpc_error(WF_BAD_FORMAT, "invalid format: invalid error object");
 		}
 	}
 }
 
 void
-wf_jsonrpc_impl_response_cleanup(
+wf_jsonrpc_response_cleanup(
 	struct wf_jsonrpc_response * response)
 {
     if (NULL != response->result)

lib/webfuse/core/jsonrpc/response.h

@@ -6,14 +6,13 @@
 #endif
 
 #include <jansson.h>
-#include <wf/jsonrpc/api.h>
 
 #ifdef __cplusplus
 extern "C"
 {
 #endif
 
-extern WF_JSONRPC_API bool wf_jsonrpc_is_response(
+extern bool wf_jsonrpc_is_response(
     json_t * message);
 
 #ifdef __cplusplus

lib/webfuse/core/jsonrpc/response_intern.h

@@ -1,16 +1,15 @@
-#ifndef WF_JSONRPC_IMPL_RESPONSE_H
+#ifndef WF_JSONRPC_RESPONSE_INTERN_H
-#define WF_JSONRPC_IMPL_RESPONSE_H
+#define WF_JSONRPC_RESPONSE_INTERN_H
+
+#include "webfuse/core/jsonrpc/response.h"
 
 #ifndef __cplusplus
-#include <stdbool.h>
 #include <stddef.h>
 #else
 #include <cstddef>
 using std::size_t;
 #endif
 
-#include <jansson.h>
-
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -22,14 +21,11 @@ struct wf_jsonrpc_response
 	int id;
 };
 
-extern bool wf_jsonrpc_impl_is_response(
+extern void wf_jsonrpc_response_init(
-    json_t * message);
-
-extern void wf_jsonrpc_impl_response_init(
 	struct wf_jsonrpc_response * response,
     json_t * message);
 
-extern void wf_jsonrpc_impl_response_cleanup(
+extern void wf_jsonrpc_response_cleanup(
 	struct wf_jsonrpc_response * response);
 
 #ifdef __cplusplus

lib/webfuse/core/jsonrpc/send_fn.h

@@ -6,7 +6,6 @@
 #endif
 
 #include <jansson.h>
-#include <wf/jsonrpc/api.h>
 
 #ifdef __cplusplus
 extern "C"

lib/webfuse/core/jsonrpc/server.c

@@ -1,8 +1,8 @@
-#include "wf/jsonrpc/impl/server.h"
+#include "webfuse/core/jsonrpc/server.h"
-#include "wf/jsonrpc/impl/method.h"
+#include "webfuse/core/jsonrpc/method.h"
-#include "wf/jsonrpc/impl/request.h"
+#include "webfuse/core/jsonrpc/request.h"
-#include "wf/jsonrpc/impl/unused_param.h"
+#include "webfuse/core/status.h"
-#include "wf/jsonrpc/status.h"
+#include "webfuse/core/util.h"
 
 #include <stdlib.h>
 #include <string.h>
@@ -13,83 +13,79 @@ struct wf_jsonrpc_server
 };
 
 static void
-wf_jsonrpc_impl_server_init(
+wf_jsonrpc_server_init(
     struct wf_jsonrpc_server * server);
 
 static void
-wf_jsonrpc_impl_server_cleanup(
+wf_jsonrpc_server_cleanup(
     struct wf_jsonrpc_server * server);
 
 struct wf_jsonrpc_server *
-wf_jsonrpc_impl_server_create(void)
+wf_jsonrpc_server_create(void)
 {
     struct wf_jsonrpc_server * server = malloc(sizeof(struct wf_jsonrpc_server));
-    if (NULL != server)
+    wf_jsonrpc_server_init(server);
-    {
-        wf_jsonrpc_impl_server_init(server);
-    }
 
     return server;
 }
 
 void
-wf_jsonrpc_impl_server_dispose(
+wf_jsonrpc_server_dispose(
     struct wf_jsonrpc_server * server)
 {
-    wf_jsonrpc_impl_server_cleanup(server);
+    wf_jsonrpc_server_cleanup(server);
     free(server);
 }
 
-
+static void wf_jsonrpc_server_init(
-static void wf_jsonrpc_impl_server_init(
     struct wf_jsonrpc_server * server)
 {
     server->methods = NULL;
 }
 
-static void wf_jsonrpc_impl_server_cleanup(
+static void wf_jsonrpc_server_cleanup(
     struct wf_jsonrpc_server * server)
 {
     struct wf_jsonrpc_method * current = server->methods;
     while (NULL != current)
     {
         struct wf_jsonrpc_method * next = current->next;
-        wf_jsonrpc_impl_method_dispose(current);
+        wf_jsonrpc_method_dispose(current);
         current = next;
     }
     server->methods = NULL;
 }
 
-void wf_jsonrpc_impl_server_add(
+void wf_jsonrpc_server_add(
     struct wf_jsonrpc_server * server,
     char const * method_name,
     wf_jsonrpc_method_invoke_fn * invoke,
     void * user_data)
 {
-    struct wf_jsonrpc_method * method = wf_jsonrpc_impl_method_create(method_name, invoke, user_data);
+    struct wf_jsonrpc_method * method = wf_jsonrpc_method_create(method_name, invoke, user_data);
     method->next = server->methods;
     server->methods = method;
 }
 
-static void wf_jsonrpc_impl_server_invalid_method_invoke(
+static void wf_jsonrpc_server_invalid_method_invoke(
     struct wf_jsonrpc_request * request,
-    char const * WF_JSONRPC_UNUSED_PARAM(method_name),
+    char const * WF_UNUSED_PARAM(method_name),
-    json_t * WF_JSONRPC_UNUSED_PARAM(params),
+    json_t * WF_UNUSED_PARAM(params),
-    void * WF_JSONRPC_UNUSED_PARAM(user_data))
+    void * WF_UNUSED_PARAM(user_data))
 {
-    wf_jsonrpc_impl_respond_error(request, WF_JSONRPC_BAD_NOTIMPLEMENTED, "not implemented");
+    wf_jsonrpc_respond_error(request, WF_BAD_NOTIMPLEMENTED, "not implemented");
 }
 
-static struct wf_jsonrpc_method const wf_jsonrpc_impl_server_invalid_method = 
+static struct wf_jsonrpc_method const wf_jsonrpc_server_invalid_method = 
 {
     .next = NULL,
     .name = "<invalid>",
-    .invoke = &wf_jsonrpc_impl_server_invalid_method_invoke,
+    .invoke = &wf_jsonrpc_server_invalid_method_invoke,
     .user_data = NULL    
 };
 
 static struct wf_jsonrpc_method const *
-wf_jsonrpc_impl_server_get_method(
+wf_jsonrpc_server_get_method(
     struct wf_jsonrpc_server * server,
     char const * method_name)
 {
@@ -104,10 +100,10 @@ wf_jsonrpc_impl_server_get_method(
         current = current->next;
     }
 
-    return &wf_jsonrpc_impl_server_invalid_method;
+    return &wf_jsonrpc_server_invalid_method;
 }
 
-void wf_jsonrpc_impl_server_process(
+void wf_jsonrpc_server_process(
     struct wf_jsonrpc_server * server,
     json_t * request_data,
     wf_jsonrpc_send_fn * send,
@@ -123,8 +119,8 @@ void wf_jsonrpc_impl_server_process(
     {
         char const * method_name = json_string_value(method_holder);
         int id = json_integer_value(id_holder);
-        struct wf_jsonrpc_request * request = wf_jsonrpc_impl_request_create(id, send, user_data);
+        struct wf_jsonrpc_request * request = wf_jsonrpc_request_create(id, send, user_data);
-        struct wf_jsonrpc_method const * method = wf_jsonrpc_impl_server_get_method(server, method_name);
+        struct wf_jsonrpc_method const * method = wf_jsonrpc_server_get_method(server, method_name);
 
         method->invoke(request, method_name, params, method->user_data);
     }

lib/webfuse/core/jsonrpc/server.h

@@ -9,9 +9,8 @@
 #endif
 
 #include <jansson.h>
-#include <wf/jsonrpc/api.h>
+#include "webfuse/core/jsonrpc/method_invoke_fn.h"
-#include <wf/jsonrpc/send_fn.h>
+#include "webfuse/core/jsonrpc/send_fn.h"
-#include <wf/jsonrpc/method_invoke_fn.h>
 
 #ifdef __cplusplus
 extern "C"
@@ -20,20 +19,20 @@ extern "C"
 
 struct wf_jsonrpc_server;
 
-extern WF_JSONRPC_API struct wf_jsonrpc_server *
+extern struct wf_jsonrpc_server *
 wf_jsonrpc_server_create(void);
 
-extern WF_JSONRPC_API void
+extern void
 wf_jsonrpc_server_dispose(
     struct wf_jsonrpc_server * server);
 
-extern WF_JSONRPC_API void wf_jsonrpc_server_add(
+extern void wf_jsonrpc_server_add(
     struct wf_jsonrpc_server * server,
     char const * method_name,
     wf_jsonrpc_method_invoke_fn * invoke,
     void * user_data);
 
-extern WF_JSONRPC_API void wf_jsonrpc_server_process(
+extern void wf_jsonrpc_server_process(
     struct wf_jsonrpc_server * server,
     json_t * request,
     wf_jsonrpc_send_fn * send,

lib/webfuse/core/message.c

@@ -12,13 +12,10 @@ extern struct wf_message * wf_message_create(json_t const * value)
     {
         char * data = malloc(sizeof(struct wf_message) + LWS_PRE + length);
         message = (struct wf_message *) data;
-        if (NULL != message)
+        message->data = &data[sizeof(struct wf_message) + LWS_PRE];
-        {
+        message->length = length;
-            message->data = &data[sizeof(struct wf_message) + LWS_PRE];
-            message->length = length;
 
-            json_dumpb(value, message->data, length, JSON_COMPACT);
+        json_dumpb(value, message->data, length, JSON_COMPACT);
-        }
     }
 
     return message;

lib/webfuse/core/string.c

@@ -16,18 +16,15 @@ char * wf_create_string(char const * format, ...)
     if (0 <= needed)
     {
         result = malloc(needed + 1);
-        if (NULL != result)
+        va_list args;
-        {
+        va_start(args, format);
-            va_list args;
+        int count = vsnprintf(result, needed + 1, format, args);
-            va_start(args, format);
+        va_end(args);
-            int count = vsnprintf(result, needed + 1, format, args);
-            va_end(args);
 
-            if ((count < 0) || (needed < count))
+        if ((count < 0) || (needed < count))
-            {
+        {
-                free(result);
+            free(result);
-                result = NULL;
+            result = NULL;
-            }
         }
     }
 

lib/webfuse/core/timer/manager.c

@@ -1,6 +1,6 @@
-#include "wf/timer/impl/manager.h"
+#include "webfuse/core/timer/manager_intern.h"
-#include "wf/timer/impl/timer.h"
+#include "webfuse/core/timer/timer_intern.h"
-#include "wf/timer/impl/timepoint.h"
+#include "webfuse/core/timer/timepoint.h"
 
 #include <stddef.h>
 #include <stdlib.h>
@@ -11,19 +11,16 @@ struct wf_timer_manager
 };
 
 struct wf_timer_manager *
-wf_timer_impl_manager_create(void)
+wf_timer_manager_create(void)
 {
     struct wf_timer_manager * manager = malloc(sizeof(struct wf_timer_manager));
-    if (NULL != manager)
+    manager->timers = NULL;
-    {
-        manager->timers = NULL;
-    }
 
     return manager;
 }
 
 void
-wf_timer_impl_manager_dispose(
+wf_timer_manager_dispose(
     struct wf_timer_manager * manager)
 {
     struct wf_timer * timer = manager->timers;
@@ -31,7 +28,7 @@ wf_timer_impl_manager_dispose(
     {
         struct wf_timer * next = timer->next;
 
-        wf_timer_impl_trigger(timer);
+        wf_timer_trigger(timer);
         timer = next;
     }
 
@@ -39,7 +36,7 @@ wf_timer_impl_manager_dispose(
 }
 
 
-void wf_timer_impl_manager_check(
+void wf_timer_manager_check(
     struct wf_timer_manager * manager)
 {
     struct wf_timer * timer = manager->timers;
@@ -47,17 +44,17 @@ void wf_timer_impl_manager_check(
     {
         struct wf_timer * next = timer->next;
 
-        if (wf_timer_impl_is_timeout(timer))
+        if (wf_timer_is_timeout(timer))
         {
-            wf_timer_impl_manager_removetimer(manager, timer);
+            wf_timer_manager_removetimer(manager, timer);
-            wf_timer_impl_trigger(timer);
+            wf_timer_trigger(timer);
         }
 
         timer = next;
     }    
 }
 
-void wf_timer_impl_manager_addtimer(
+void wf_timer_manager_addtimer(
     struct wf_timer_manager * manager,
     struct wf_timer * timer)
 {
@@ -71,7 +68,7 @@ void wf_timer_impl_manager_addtimer(
     manager->timers = timer;
 }
 
-void wf_timer_impl_manager_removetimer(
+void wf_timer_manager_removetimer(
     struct wf_timer_manager * manager,
     struct wf_timer * timer)
 {

lib/webfuse/core/timer/manager.h

@@ -1,8 +1,6 @@
 #ifndef WF_TIMER_MANAGER_H
 #define WF_TIMER_MANAGER_H
 
-#include <wf/timer/api.h>
-
 #ifdef __cplusplus
 extern "C"
 {
@@ -10,14 +8,14 @@ extern "C"
 
 struct wf_timer_manager;
 
-extern WF_TIMER_API struct wf_timer_manager * 
+extern struct wf_timer_manager * 
 wf_timer_manager_create(void);
 
-extern WF_TIMER_API void
+extern void
 wf_timer_manager_dispose(
     struct wf_timer_manager * manager);
 
-extern WF_TIMER_API void
+extern void
 wf_timer_manager_check(
     struct wf_timer_manager * manager);
 

lib/webfuse/core/timer/manager_intern.h

@@ -0,0 +1,26 @@
+#ifndef WF_TIMER_MANAGER_INTERN_H
+#define WF_TIMER_MANAGER_INTERN_H
+
+#include "webfuse/core/timer/manager.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+struct wf_timer;
+
+extern void wf_timer_manager_addtimer(
+    struct wf_timer_manager * manager,
+    struct wf_timer * timer);
+
+extern void wf_timer_manager_removetimer(
+    struct wf_timer_manager * manager,
+    struct wf_timer * timer);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif

lib/webfuse/core/timer/timepoint.c

@@ -1,11 +1,11 @@
-#include "wf/timer/impl/timepoint.h"
+#include "webfuse/core/timer/timepoint.h"
 
 #include <time.h>
 
 #define WF_TIMER_MSEC_PER_SEC  ((wf_timer_timepoint) 1000) 
 #define WF_TIMER_NSEC_PER_MSEC ((wf_timer_timepoint) 1000 * 1000) 
 
-wf_timer_timepoint wf_timer_impl_timepoint_now(void)
+wf_timer_timepoint wf_timer_timepoint_now(void)
 {
     struct timespec tp;
     clock_gettime(CLOCK_MONOTONIC, &tp);
@@ -14,17 +14,17 @@ wf_timer_timepoint wf_timer_impl_timepoint_now(void)
     return now;
 }
 
-wf_timer_timepoint wf_timer_impl_timepoint_in_msec(wf_timer_timediff value)
+wf_timer_timepoint wf_timer_timepoint_in_msec(wf_timer_timediff value)
 {
-    wf_timer_timepoint const now = wf_timer_impl_timepoint_now();
+    wf_timer_timepoint const now = wf_timer_timepoint_now();
     wf_timer_timepoint result = now + ((wf_timer_timepoint) value);
 
     return result;
 }
 
-bool wf_timer_impl_timepoint_is_elapsed(wf_timer_timepoint tp)
+bool wf_timer_timepoint_is_elapsed(wf_timer_timepoint tp)
 {
-    wf_timer_timepoint const now = wf_timer_impl_timepoint_now();
+    wf_timer_timepoint const now = wf_timer_timepoint_now();
     wf_timer_timediff const  diff = (wf_timer_timediff) (tp - now);
 
     return (0 > diff);

lib/webfuse/core/timer/timepoint.h

@@ -1,5 +1,5 @@
-#ifndef WF_TIMER_IMPL_TIMEPOINT_H
+#ifndef WF_TIMER_TIMEPOINT_H
-#define WF_TIMER_IMPL_TIMEPOINT_H
+#define WF_TIMER_TIMEPOINT_H
 
 #ifndef __cplusplus
 #include <stdbool.h>
@@ -16,12 +16,12 @@ extern "C"
 typedef uint64_t wf_timer_timepoint;
 typedef int64_t wf_timer_timediff;
 
-extern wf_timer_timepoint wf_timer_impl_timepoint_now(void);
+extern wf_timer_timepoint wf_timer_timepoint_now(void);
 
-extern wf_timer_timepoint wf_timer_impl_timepoint_in_msec(
+extern wf_timer_timepoint wf_timer_timepoint_in_msec(
     wf_timer_timediff value);
 
-extern bool wf_timer_impl_timepoint_is_elapsed(
+extern bool wf_timer_timepoint_is_elapsed(
     wf_timer_timepoint timepoint);
 
 #ifdef __cplusplus

lib/webfuse/core/timer/timer.c

@@ -1,13 +1,13 @@
-#include "wf/timer/impl/timer.h"
+#include "webfuse/core/timer/timer_intern.h"
-#include "wf/timer/impl/manager.h"
+#include "webfuse/core/timer/manager_intern.h"
-#include "wf/timer/impl/timepoint.h"
+#include "webfuse/core/timer/timepoint.h"
 
 #include <stddef.h>
 #include <stdlib.h>
 #include <string.h>
 
 struct wf_timer *
-wf_timer_impl_create(
+wf_timer_create(
     struct wf_timer_manager * manager,
     wf_timer_on_timer_fn * on_timer,
     void * user_data)
@@ -24,37 +24,37 @@ wf_timer_impl_create(
 }
 
 void
-wf_timer_impl_dispose(
+wf_timer_dispose(
     struct wf_timer * timer)
 {
     free(timer);
 }
 
-void wf_timer_impl_start(
+void wf_timer_start(
     struct wf_timer * timer,
     int timeout_ms)
 {
-    timer->timeout = wf_timer_impl_timepoint_in_msec(timeout_ms);
+    timer->timeout = wf_timer_timepoint_in_msec(timeout_ms);
 
-    wf_timer_impl_manager_addtimer(timer->manager, timer);
+    wf_timer_manager_addtimer(timer->manager, timer);
 }
 
-void wf_timer_impl_cancel(
+void wf_timer_cancel(
     struct wf_timer * timer)
 {
-    wf_timer_impl_manager_removetimer(timer->manager, timer);
+    wf_timer_manager_removetimer(timer->manager, timer);
 
     timer->timeout = 0;
 }
 
-bool wf_timer_impl_is_timeout(
+bool wf_timer_is_timeout(
     struct wf_timer * timer)
 {
-    return wf_timer_impl_timepoint_is_elapsed(timer->timeout);
+    return wf_timer_timepoint_is_elapsed(timer->timeout);
 }
 
 
-void wf_timer_impl_trigger(
+void wf_timer_trigger(
     struct wf_timer * timer)
 {
     if (0 != timer->on_timer)

lib/webfuse/core/timer/timer.h

@@ -1,8 +1,7 @@
 #ifndef WF_TIMER_TIMER_H
 #define WF_TIMER_TIMER_H
 
-#include <wf/timer/api.h>
+#include "webfuse/core/timer/on_timer_fn.h"
-#include <wf/timer/on_timer_fn.h>
 
 #ifdef __cplusplus
 extern "C"
@@ -12,22 +11,22 @@ extern "C"
 struct wf_timer;
 struct wf_timer_manager;
 
-extern WF_TIMER_API struct wf_timer *
+extern struct wf_timer *
 wf_timer_create(
     struct wf_timer_manager * manager,
     wf_timer_on_timer_fn * on_timer,
     void * user_data);
 
-extern WF_TIMER_API void
+extern void
 wf_timer_dispose(
     struct wf_timer * timer);
 
-extern WF_TIMER_API void
+extern void
 wf_timer_start(
     struct wf_timer * timer,
     int timeout_ms);
 
-extern WF_TIMER_API void
+extern void
 wf_timer_cancel(
     struct wf_timer * timer);
 

lib/webfuse/core/timer/timer_intern.h

@@ -0,0 +1,40 @@
+#ifndef WF_TIMER_TIMER_H
+#define WF_TIMER_TIMER_H
+
+#include "webfuse/core/timer/timer.h"
+#include "webfuse/core/timer/on_timer_fn.h"
+#include "webfuse/core/timer/timepoint.h"
+
+#ifndef __cplusplus
+#include <stdbool.h>
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+struct wf_timer
+{
+    struct wf_timer_manager * manager;
+    wf_timer_timepoint timeout;
+    wf_timer_on_timer_fn * on_timer;
+    void * user_data;
+    struct wf_timer * next;
+    struct wf_timer * prev;
+};
+
+extern bool wf_timer_is_timeout(
+    struct wf_timer * timer);
+
+extern void wf_timer_trigger(
+    struct wf_timer * timer);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#endif

lib/webfuse/provider/api.c

@@ -95,6 +95,13 @@ void wfp_client_config_set_certpath(
     wfp_impl_client_config_set_certpath(config, cert_path);
 }
 
+void wfp_client_config_set_ca_filepath(
+    struct wfp_client_config * config,
+    char const * ca_filepath)
+{
+    wfp_impl_client_config_set_ca_filepath(config, ca_filepath);
+}
+
 void wfp_client_config_set_onconnected(
     struct wfp_client_config * config,
     wfp_connected_fn * handler)

lib/webfuse/provider/impl/client.c

@@ -30,25 +30,32 @@ struct wfp_client * wfp_impl_client_create(
 	wf_lwslog_disable();
    
     struct wfp_client * client = malloc(sizeof(struct wfp_client));
-    if (NULL != client)
+    wfp_impl_client_protocol_init(&client->protocol, &config->provider, config->user_data);
+
+    memset(client->protocols, 0, sizeof(struct lws_protocols) * WFP_CLIENT_PROTOCOL_COUNT);
+    wfp_impl_client_protocol_init_lws(&client->protocol, &client->protocols[0]);
+
+    memset(&client->info, 0, sizeof(struct lws_context_creation_info));
+    client->info.port = CONTEXT_PORT_NO_LISTEN;
+    client->info.protocols = client->protocols;
+    client->info.uid = -1;
+    client->info.gid = -1;
+
+    if ((NULL != config->cert_path) && (NULL != config->key_path))
     {
-        wfp_impl_client_protocol_init(&client->protocol, &config->provider, config->user_data);
+		client->info.options |= LWS_SERVER_OPTION_EXPLICIT_VHOSTS;
+    }
 
-        memset(client->protocols, 0, sizeof(struct lws_protocols) * WFP_CLIENT_PROTOCOL_COUNT);
+    client->context = lws_create_context(&client->info);
-        wfp_impl_client_protocol_init_lws(&client->protocol, &client->protocols[0]);
 
-        memset(&client->info, 0, sizeof(struct lws_context_creation_info));
+    if ((NULL != config->cert_path) && (NULL != config->key_path))
-        client->info.port = CONTEXT_PORT_NO_LISTEN;
+    {
-        client->info.protocols = client->protocols;
+        struct lws_vhost * vhost = lws_create_vhost(client->context, &client->info);
-        client->info.uid = -1;
+		client->info.options |= LWS_SERVER_OPTION_DO_SSL_GLOBAL_INIT;
-        client->info.gid = -1;
+        client->info.client_ssl_cert_filepath = config->cert_path;
-
+        client->info.client_ssl_private_key_filepath = config->key_path;
-        if ((NULL != config->cert_path) && (NULL != config->key_path))
+        client->info.client_ssl_ca_filepath = config->ca_filepath;
-        {
+        lws_init_vhost_client_ssl(&client->info, vhost);
-            
-        }
-
-        client->context = lws_create_context(&client->info);
     }
 
     return client;

lib/webfuse/provider/impl/client_config.c

@@ -6,13 +6,11 @@
 struct wfp_client_config * wfp_impl_client_config_create(void)
 {
     struct wfp_client_config * config = malloc(sizeof(struct wfp_client_config));
-    if (NULL != config)
+    wfp_impl_provider_init(&config->provider);
-    {
+    config->user_data = NULL;
-        wfp_impl_provider_init(&config->provider);
+    config->key_path = NULL;
-        config->user_data = NULL;
+    config->cert_path = NULL;
-        config->key_path = NULL;
+    config->ca_filepath = NULL;
-        config->cert_path = NULL;
-    }
 
     return config;
 }
@@ -22,6 +20,7 @@ void wfp_impl_client_config_dispose(
 {
     free(config->key_path);
     free(config->cert_path);
+    free(config->ca_filepath);
     free(config);
 }
 
@@ -48,6 +47,14 @@ void wfp_impl_client_config_set_certpath(
     config->cert_path = strdup(cert_path);
 }
 
+void wfp_impl_client_config_set_ca_filepath(
+    struct wfp_client_config * config,
+    char const * ca_filepath)
+{
+    free(config->ca_filepath);
+    config->ca_filepath = strdup(ca_filepath); 
+}
+
 void wfp_impl_client_config_set_onconnected(
     struct wfp_client_config * config,
     wfp_connected_fn * handler)

lib/webfuse/provider/impl/client_config.h

@@ -15,6 +15,7 @@ struct wfp_client_config
     void * user_data;
     char * key_path;
     char * cert_path;
+    char * ca_filepath;
 };
 
 extern struct wfp_client_config * wfp_impl_client_config_create(void);
@@ -34,6 +35,10 @@ extern void wfp_impl_client_config_set_certpath(
     struct wfp_client_config * config,
     char const * cert_path);
 
+extern void wfp_impl_client_config_set_ca_filepath(
+    struct wfp_client_config * config,
+    char const * ca_filepath);
+
 extern void wfp_impl_client_config_set_onconnected(
     struct wfp_client_config * config,
     wfp_connected_fn * handler);

lib/webfuse/provider/impl/client_protocol.c

@@ -16,11 +16,11 @@
 #include "webfuse/provider/impl/url.h"
 #include "webfuse/core/protocol_names.h"
 
-#include "wf/timer/manager.h"
+#include "webfuse/core/timer/manager.h"
 
-#include "wf/jsonrpc/response.h"
+#include "webfuse/core/jsonrpc/response.h"
-#include "wf/jsonrpc/request.h"
+#include "webfuse/core/jsonrpc/request.h"
-#include "wf/jsonrpc/proxy.h"
+#include "webfuse/core/jsonrpc/proxy.h"
 
 #define WF_DEFAULT_TIMEOUT (10 * 1000)
 
@@ -270,10 +270,7 @@ struct wfp_client_protocol * wfp_impl_client_protocol_create(
     struct wfp_client_config const * config)
 {
     struct wfp_client_protocol * protocol = malloc(sizeof(struct wfp_client_protocol));
-    if (NULL != protocol)
+    wfp_impl_client_protocol_init(protocol, &config->provider, config->user_data);
-    {
-        wfp_impl_client_protocol_init(protocol, &config->provider, config->user_data);
-    }
 
     return protocol;
 }

lib/webfuse/provider/impl/dirbuffer.c

@@ -4,10 +4,7 @@
 struct wfp_dirbuffer * wfp_impl_dirbuffer_create(void)
 {
     struct wfp_dirbuffer * buffer = malloc(sizeof(struct wfp_dirbuffer));
-    if (NULL != buffer)
+    buffer->entries = json_array();
-    {
-        buffer->entries = json_array();
-    }
 
     return buffer;
 }

lib/webfuse/provider/impl/operation/read.c

@@ -56,28 +56,21 @@ void wfp_impl_respond_read(
     {
         size_t const size = wf_base64_encoded_size(length) + 1;
         char * buffer = malloc(size);
-        if (NULL != buffer)
+        wf_base64_encode((uint8_t const *) data, length, buffer, size);
-        {
-            wf_base64_encode((uint8_t const *) data, length, buffer, size);
 
-            json_t * result = json_object();
+        json_t * result = json_object();
-            json_object_set_new(result, "data", json_string(buffer));
+        json_object_set_new(result, "data", json_string(buffer));
-            json_object_set_new(result, "format", json_string("base64"));
+        json_object_set_new(result, "format", json_string("base64"));
-            json_object_set_new(result, "count", json_integer((int) length));
+        json_object_set_new(result, "count", json_integer((int) length));
 
-            wfp_impl_respond(request, result);
+        wfp_impl_respond(request, result);
-            free(buffer);
+        free(buffer);
-        }
-        else
-        {
-            wfp_impl_respond_error(request, WF_BAD);
-        }
     }
     else
     {
             json_t * result = json_object();
             json_object_set_new(result, "data", json_string(""));
-            json_object_set_new(result, "format", json_string("identitiy"));
+            json_object_set_new(result, "format", json_string("identity"));
             json_object_set_new(result, "count", json_integer(0));
 
             wfp_impl_respond(request, result);        

lib/webfuse/provider/impl/operation/readdir.c

@@ -14,7 +14,7 @@ void wfp_impl_readdir(
     {
         json_t * inode_holder = json_array_get(params, 1);
 
-        if ((NULL != inode_holder) && (json_is_integer(inode_holder)))
+        if (json_is_integer(inode_holder))
         {
             ino_t inode = (ino_t) json_integer_value(inode_holder);
             struct wfp_request * request = wfp_impl_request_create(context->request, id);

lib/webfuse/provider/impl/provider.c

@@ -94,8 +94,7 @@ void wfp_impl_provider_invoke(
     json_t * params = json_object_get(request, "params");
     json_t * id_holder = json_object_get(request, "id");
 
-    if ((NULL != method_holder) && (json_is_string(method_holder)) &&
+    if ((json_is_string(method_holder)) && (json_is_array(params)))
-        (NULL != params) && (json_is_array(params)))
     {
         char const * method = json_string_value(method_holder);
         int id = json_is_integer(id_holder) ? json_integer_value(id_holder) : 0;

lib/webfuse/provider/impl/provider.h

@@ -30,7 +30,7 @@ struct wfp_provider
 
 struct wfp_impl_invokation_context
 {
-    struct wfp_provider * provider;
+    struct wfp_provider const * provider;
     void * user_data;
     struct wfp_request * request;
 };

lib/webfuse/provider/impl/request.c

@@ -8,12 +8,9 @@ struct wfp_request * wfp_impl_request_create(
     int id)
 {
     struct wfp_request * request = malloc(sizeof(struct wfp_request));
-    if (NULL != request)
+    request->respond = prototype->respond;
-    {
+    request->user_data = prototype->user_data;
-        request->respond = prototype->respond;
+    request->id = id;
-        request->user_data = prototype->user_data;
-        request->id = id;
-    }
 
     return request;
 }

lib/wf/jsonrpc/include/wf/jsonrpc.h

@@ -1,14 +0,0 @@
-#ifndef WF_JSONRPC_H
-#define WF_JSONRPC_H
-
-#include <wf/jsonrpc/api.h>
-#include <wf/jsonrpc/method_invoke_fn.h>
-#include <wf/jsonrpc/proxy.h>
-#include <wf/jsonrpc/proxy_finished_fn.h>
-#include <wf/jsonrpc/request.h>
-#include <wf/jsonrpc/response.h>
-#include <wf/jsonrpc/send_fn.h>
-#include <wf/jsonrpc/server.h>
-#include <wf/jsonrpc/status.h>
-
-#endif

lib/wf/jsonrpc/include/wf/jsonrpc/api.h

@@ -1,8 +0,0 @@
-#ifndef WF_JSONRPC_API_H
-#define WF_JSONRPC_API_H
-
-#ifndef WF_JSONRPC_API
-#define WF_JSONRPC_API
-#endif
-
-#endif

lib/wf/jsonrpc/include/wf/jsonrpc/status.h

@@ -1,11 +0,0 @@
-#ifndef WF_JSONRPC_STATUS_H
-#define WF_JSONRPC_STATUS_H
-
-#define WF_JSONRPC_GOOD 0
-#define WF_JSONRPC_BAD  -1
-#define WF_JSONRPC_BAD_NOTIMPLEMENTED -2
-#define WF_JSONRPC_BAD_TIMEOUT -3
-#define WF_JSONRPC_BAD_BUSY -4
-#define WF_JSONRPC_BAD_FORMAT -5
-
-#endif

lib/wf/jsonrpc/src/wf/jsonrpc/api.c

@@ -1,144 +0,0 @@
-#include "wf/jsonrpc.h"
-
-#include "wf/jsonrpc/impl/proxy.h"
-#include "wf/jsonrpc/impl/request.h"
-#include "wf/jsonrpc/impl/response.h"
-#include "wf/jsonrpc/impl/server.h"
-
-// proxy
-
-struct wf_jsonrpc_proxy *
-wf_jsonrpc_proxy_create(
-    struct wf_timer_manager * manager,
-    int timeout,
-    wf_jsonrpc_send_fn * send,
-    void * user_data)
-{
-    return wf_jsonrpc_impl_proxy_create(manager, timeout, send, user_data);
-}
-
-void wf_jsonrpc_proxy_dispose(
-    struct wf_jsonrpc_proxy * proxy)
-{
-    wf_jsonrpc_impl_proxy_dispose(proxy);
-}
-
-void wf_jsonrpc_proxy_invoke(
-	struct wf_jsonrpc_proxy * proxy,
-	wf_jsonrpc_proxy_finished_fn * finished,
-	void * user_data,
-	char const * method_name,
-	char const * param_info,
-	...
-)
-{
-    va_list args;
-    va_start(args, param_info);
-    wf_jsonrpc_impl_proxy_invoke(proxy, finished, user_data, method_name, param_info, args);
-    va_end(args);
-}
-
-void wf_jsonrpc_proxy_notify(
-	struct wf_jsonrpc_proxy * proxy,
-	char const * method_name,
-	char const * param_info,
-	...
-)
-{
-    va_list args;
-    va_start(args, param_info);
-    wf_jsonrpc_impl_proxy_notify(proxy, method_name, param_info, args);
-    va_end(args);
-}
-
-void wf_jsonrpc_proxy_onresult(
-    struct wf_jsonrpc_proxy * proxy,
-    json_t * message)
-{
-    wf_jsonrpc_impl_proxy_onresult(proxy, message);    
-}
-
-
-// request
-
-bool wf_jsonrpc_is_request(
-    json_t * message)
-{
-    return wf_jsonrpc_impl_is_request(message);
-}
-
-struct wf_jsonrpc_request * wf_jsonrpc_request_create(
-    int id,
-    wf_jsonrpc_send_fn * send,
-    void * user_data)
-{
-    return wf_jsonrpc_impl_request_create(id, send, user_data);
-}
-
-void wf_jsonrpc_request_dispose(
-    struct wf_jsonrpc_request * request)
-{
-    wf_jsonrpc_impl_request_dispose(request);
-}
-
-void * wf_jsonrpc_request_get_userdata(
-    struct wf_jsonrpc_request * request)
-{
-    return wf_jsonrpc_impl_request_get_userdata(request);
-}
-
-void wf_jsonrpc_respond(
-    struct wf_jsonrpc_request * request,
-    json_t * result)
-{
-    wf_jsonrpc_impl_respond(request, result);
-}
-
-void wf_jsonrpc_respond_error(
-    struct wf_jsonrpc_request * request,
-    int code,
-    char const * message)
-{
-    wf_jsonrpc_impl_respond_error(request, code, message);
-}
-
-// response
-
-bool wf_jsonrpc_is_response(
-    json_t * message)
-{
-    return wf_jsonrpc_impl_is_response(message);
-}
-
-// server
-
-struct wf_jsonrpc_server *
-wf_jsonrpc_server_create(void)
-{
-    return wf_jsonrpc_impl_server_create();
-}
-
-void
-wf_jsonrpc_server_dispose(
-    struct wf_jsonrpc_server * server)
-{
-    wf_jsonrpc_impl_server_dispose(server);
-}
-
-void wf_jsonrpc_server_add(
-    struct wf_jsonrpc_server * server,
-    char const * method_name,
-    wf_jsonrpc_method_invoke_fn * invoke,
-    void * user_data)
-{
-    wf_jsonrpc_impl_server_add(server, method_name, invoke, user_data);
-}
-
-void wf_jsonrpc_server_process(
-    struct wf_jsonrpc_server * server,
-    json_t * request,
-    wf_jsonrpc_send_fn * send,
-    void * user_data)
-{
-    wf_jsonrpc_impl_server_process(server, request, send, user_data);
-}

lib/wf/jsonrpc/src/wf/jsonrpc/impl/request.h

@@ -1,53 +0,0 @@
-#ifndef WF_JSONRPC_IMPL_REQUEST_H
-#define WF_JSONRPC_IMPL_REQUEST_H
-
-#ifndef __cplusplus
-#include <stdarg.h>
-#include <stddef.h>
-#include <stdbool.h>
-#else
-#include <cstdarg>
-#include <cstddef>
-using std::size_t;
-#endif
-
-#include <jansson.h>
-#include <wf/jsonrpc/api.h>
-#include "wf/jsonrpc/send_fn.h"
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-struct wf_jsonrpc_request;
-
-extern bool wf_jsonrpc_impl_is_request(
-    json_t * message);
-
-extern struct wf_jsonrpc_request * wf_jsonrpc_impl_request_create(
-    int id,
-    wf_jsonrpc_send_fn * send,
-    void * user_data);
-
-extern void wf_jsonrpc_impl_request_dispose(
-    struct wf_jsonrpc_request * request);
-
-extern void * wf_jsonrpc_impl_request_get_userdata(
-    struct wf_jsonrpc_request * request);
-
-extern void wf_jsonrpc_impl_respond(
-    struct wf_jsonrpc_request * request,
-    json_t * result);
-
-extern void wf_jsonrpc_impl_respond_error(
-    struct wf_jsonrpc_request * request,
-    int code,
-    char const * message);
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

lib/wf/jsonrpc/src/wf/jsonrpc/impl/server.h

@@ -1,41 +0,0 @@
-#ifndef WF_JSONRPC_IMPL_SERVER_H
-#define WF_JSONRPC_IMPL_SERVER_H
-
-#include <jansson.h>
-#include "wf/jsonrpc/method_invoke_fn.h"
-#include "wf/jsonrpc/send_fn.h"
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-struct wf_jsonrpc_server;
-
-extern struct wf_jsonrpc_server *
-wf_jsonrpc_impl_server_create(void);
-
-extern void
-wf_jsonrpc_impl_server_dispose(
-    struct wf_jsonrpc_server * server);
-
-extern void
-wf_jsonrpc_impl_server_add(
-    struct wf_jsonrpc_server * server,
-    char const * method_name,
-    wf_jsonrpc_method_invoke_fn * invoke,
-    void * user_data);
-
-extern void
-wf_jsonrpc_impl_server_process(
-    struct wf_jsonrpc_server * server,
-    json_t * request,
-    wf_jsonrpc_send_fn * send,
-    void * user_data);
-
-#ifdef __cplusplus
-}
-#endif
-
-
-#endif

lib/wf/jsonrpc/src/wf/jsonrpc/impl/unused_param.h

@@ -1,10 +0,0 @@
-#ifndef WF_JSONRPC_UTIL_H
-#define WF_JSONRPC_UTIL_H
-
-#ifdef __GNUC__
-#define WF_JSONRPC_UNUSED_PARAM(param) param __attribute__((unused))
-#else
-#define WF_JSONRPC_UNUSED_PARAM(param)
-#endif
-
-#endif

lib/wf/jsonrpc/test/wf/jsonrpc/test_response.cc

@@ -1,58 +0,0 @@
-#include <gtest/gtest.h>
-#include "wf/jsonrpc/impl/response.h"
-#include "wf/jsonrpc/status.h"
-
-TEST(wf_json_response, init_result)
-{
-    json_t * message = json_object();
-    json_object_set_new(message, "result", json_integer(47));
-    json_object_set_new(message, "id", json_integer(11));
-
-    struct wf_jsonrpc_response response;
-    wf_jsonrpc_impl_response_init(&response, message);
-
-    ASSERT_EQ(nullptr, response.error);
-    ASSERT_TRUE(json_is_integer(response.result));
-    ASSERT_EQ(47, json_integer_value(response.result));
-    ASSERT_EQ(11, response.id);
-
-    wf_jsonrpc_impl_response_cleanup(&response);
-    json_decref(message);
-}
-
-TEST(wf_json_response, init_error)
-{
-    json_t * message = json_object();
-    json_t * err = json_object();
-    json_object_set_new(err, "code", json_integer(42));
-    json_object_set_new(err, "message", json_string("Don't Panic!"));
-    json_object_set_new(message, "error", err);
-    json_object_set_new(message, "id", json_integer(23));
-
-    struct wf_jsonrpc_response response;
-    wf_jsonrpc_impl_response_init(&response, message);
-
-    ASSERT_EQ(42, json_integer_value(json_object_get(response.error, "code")));
-    ASSERT_STREQ("Don't Panic!", json_string_value(json_object_get(response.error, "message")));
-    ASSERT_EQ(nullptr, response.result);
-    ASSERT_EQ(23, response.id);
-
-    wf_jsonrpc_impl_response_cleanup(&response);
-    json_decref(message);
-}
-
-TEST(wf_json_response, init_format_error)
-{
-    json_t * message = json_object();
-    json_object_set_new(message, "id", json_integer(12));
-
-    struct wf_jsonrpc_response response;
-    wf_jsonrpc_impl_response_init(&response, message);
-
-    ASSERT_EQ(WF_JSONRPC_BAD_FORMAT, json_integer_value(json_object_get(response.error, "code")));
-    ASSERT_EQ(nullptr, response.result);
-    ASSERT_EQ(12, response.id);
-
-    wf_jsonrpc_impl_response_cleanup(&response);
-    json_decref(message);
-}

lib/wf/jsonrpc/test/wf/jsonrpc/test_server.cc

@@ -1,123 +0,0 @@
-#include <gtest/gtest.h>
-#include "wf/jsonrpc/server.h"
-#include "wf/jsonrpc/request.h"
-#include "wf/jsonrpc/status.h"
-
-namespace
-{
-    struct Context
-    {
-        json_t * response;
-        bool is_called;
-    };
-
-    bool jsonrpc_send(
-	    json_t * request,
-        void * user_data)
-    {
-        Context * context = reinterpret_cast<Context*>(user_data);
-        context->is_called = true;
-        context->response = request;
-        json_incref(request);
-
-        return true;
-    }
-
-    void sayHello(
-        struct wf_jsonrpc_request * request,
-        char const * method_name,
-        json_t * params,
-        void * user_data)
-    {
-        (void) method_name;
-        (void) params;
-        (void) user_data;
-
-        json_t * result = json_string("Hello");
-        wf_jsonrpc_respond(request, result);
-    }
-
-}
-
-TEST(wf_jsonrpc_server, process_request)
-{
-    struct wf_jsonrpc_server * server = wf_jsonrpc_server_create();
-    wf_jsonrpc_server_add(server, "sayHello", &sayHello, nullptr);
-
-    Context context{nullptr, false};
-    void * user_data = reinterpret_cast<void*>(&context);
-    json_t * request = json_object();
-    json_object_set_new(request, "method", json_string("sayHello"));
-    json_object_set_new(request, "params", json_array());
-    json_object_set_new(request, "id", json_integer(23));   
-    wf_jsonrpc_server_process(server, request, &jsonrpc_send, user_data);
-
-    ASSERT_TRUE(context.is_called);
-    ASSERT_NE(nullptr, context.response);
-    ASSERT_TRUE(json_is_object(context.response));
-
-    json_t * id = json_object_get(context.response, "id");
-    ASSERT_TRUE(json_is_integer(id));
-    ASSERT_EQ(23, json_integer_value(id));
-
-    json_t * result = json_object_get(context.response, "result");
-    ASSERT_TRUE(json_is_string(result));
-    ASSERT_STREQ("Hello", json_string_value(result));
-
-    json_decref(context.response);
-    json_decref(request);
-    wf_jsonrpc_server_dispose(server); 
-}
-
-TEST(wf_jsonrpc_server, invoke_unknown_method)
-{
-    struct wf_jsonrpc_server * server = wf_jsonrpc_server_create();
-    wf_jsonrpc_server_add(server, "sayHello", &sayHello, nullptr);
-
-    Context context{nullptr, false};
-    void * user_data = reinterpret_cast<void*>(&context);
-    json_t * request = json_object();
-    json_object_set_new(request, "method", json_string("greet"));
-    json_object_set_new(request, "params", json_array());
-    json_object_set_new(request, "id", json_integer(42));   
-    wf_jsonrpc_server_process(server, request, &jsonrpc_send, user_data);
-
-    ASSERT_TRUE(context.is_called);
-    ASSERT_NE(nullptr, context.response);
-    ASSERT_TRUE(json_is_object(context.response));
-
-    json_t * id = json_object_get(context.response, "id");
-    ASSERT_TRUE(json_is_integer(id));
-    ASSERT_EQ(42, json_integer_value(id));
-
-    json_t * err = json_object_get(context.response, "error");
-    ASSERT_TRUE(json_is_object(err));
-
-    json_t * err_code = json_object_get(err, "code");
-    ASSERT_TRUE(json_is_integer(err_code));
-    ASSERT_EQ(WF_JSONRPC_BAD_NOTIMPLEMENTED, json_integer_value(err_code));
-
-    json_t * err_message = json_object_get(err, "message");
-    ASSERT_TRUE(json_is_string(err_message));
-
-    json_decref(context.response);
-    json_decref(request);
-    wf_jsonrpc_server_dispose(server); 
-}
-
-TEST(wf_jsonrpc_server, skip_invalid_request)
-{
-    struct wf_jsonrpc_server * server = wf_jsonrpc_server_create();
-
-    Context context{nullptr, false};
-    void * user_data = reinterpret_cast<void*>(&context);
-    json_t * request = json_object();
-    json_object_set_new(request, "method", json_string("sayHello"));
-    json_object_set_new(request, "params", json_array());
-    wf_jsonrpc_server_process(server, request, &jsonrpc_send, user_data);
-
-    ASSERT_FALSE(context.is_called);
-
-    json_decref(request);
-    wf_jsonrpc_server_dispose(server); 
-}

lib/wf/timer/include/wf/timer.h

@@ -1,9 +0,0 @@
-#ifndef WF_TIMER_H
-#define WF_TIMER_H
-
-#include <wf/timer/api.h>
-#include <wf/timer/on_timer_fn.h>
-#include <wf/timer/timer.h>
-#include <wf/timer/manager.h>
-
-#endif

lib/wf/timer/include/wf/timer/api.h

@@ -1,8 +0,0 @@
-#ifndef WF_TIMER_API_H
-#define WF_TIMER_API_H
-
-#ifndef WF_TIMER_API
-#define WF_TIMER_API
-#endif
-
-#endif

lib/wf/timer/src/wf/timer/api.c

@@ -1,59 +0,0 @@
-#include "wf/timer.h"
-
-#include "wf/timer/impl/manager.h"
-#include "wf/timer/impl/timer.h"
-
-// manager
-
-struct wf_timer_manager * 
-wf_timer_manager_create(void)
-{
-    return wf_timer_impl_manager_create();
-}
-
-void
-wf_timer_manager_dispose(
-    struct wf_timer_manager * manager)
-{
-    wf_timer_impl_manager_dispose(manager);
-}
-
-void
-wf_timer_manager_check(
-    struct wf_timer_manager * manager)
-{
-    wf_timer_impl_manager_check(manager);
-}
-
-// timer
-
-struct wf_timer *
-wf_timer_create(
-    struct wf_timer_manager * manager,
-    wf_timer_on_timer_fn * on_timer,
-    void * user_data)
-{
-    return wf_timer_impl_create(manager, on_timer, user_data);
-}
-
-void
-wf_timer_dispose(
-    struct wf_timer * timer)
-{
-    wf_timer_impl_dispose(timer);
-}
-
-void
-wf_timer_start(
-    struct wf_timer * timer,
-    int timeout_ms)
-{
-    wf_timer_impl_start(timer, timeout_ms);
-}
-
-void
-wf_timer_cancel(
-    struct wf_timer * timer)
-{
-    wf_timer_impl_cancel(timer);
-}

lib/wf/timer/src/wf/timer/impl/manager.h

@@ -1,36 +0,0 @@
-#ifndef WF_TIMER_IMPL_MANAGER_H
-#define WF_TIMER_IMPL_MANAGER_H
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-struct wf_timer;
-struct wf_timer_manager;
-
-extern struct wf_timer_manager *
-wf_timer_impl_manager_create(void);
-
-extern void
-wf_timer_impl_manager_dispose(
-    struct wf_timer_manager * manager);
-
-extern void
-wf_timer_impl_manager_check(
-    struct wf_timer_manager * manager);
-
-extern void wf_timer_impl_manager_addtimer(
-    struct wf_timer_manager * manager,
-    struct wf_timer * timer);
-
-extern void wf_timer_impl_manager_removetimer(
-    struct wf_timer_manager * manager,
-    struct wf_timer * timer);
-
-#ifdef __cplusplus
-}
-#endif
-
-
-#endif

lib/wf/timer/src/wf/timer/impl/timer.h

@@ -1,59 +0,0 @@
-#ifndef WF_ADAPTER_IMPL_TIME_TIMER_H
-#define WF_ADAPTER_IMPL_TIME_TIMER_H
-
-#include "wf/timer/on_timer_fn.h"
-#include "wf/timer/impl/timepoint.h"
-
-#ifndef __cplusplus
-#include <stdbool.h>
-#endif
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-struct wf_timer_manager;
-
-struct wf_timer
-{
-    struct wf_timer_manager * manager;
-    wf_timer_timepoint timeout;
-    wf_timer_on_timer_fn * on_timer;
-    void * user_data;
-    struct wf_timer * next;
-    struct wf_timer * prev;
-};
-
-
-struct wf_timer *
-wf_timer_impl_create(
-    struct wf_timer_manager * manager,
-    wf_timer_on_timer_fn * on_timer,
-    void * user_data);
-
-void
-wf_timer_impl_dispose(
-    struct wf_timer * timer);
-
-extern void wf_timer_impl_start(
-    struct wf_timer * timer,
-    int timeout_ms);
-
-extern void wf_timer_impl_cancel(
-    struct wf_timer * timer);
-
-extern bool wf_timer_impl_is_timeout(
-    struct wf_timer * timer);
-
-extern void wf_timer_impl_trigger(
-    struct wf_timer * timer);
-
-
-#ifdef __cplusplus
-}
-#endif
-
-
-
-#endif

lib/wf/timer/test/wf/timer/test_timepoint.cc

@@ -1,38 +0,0 @@
-#include <gtest/gtest.h>
-
-#include "wf/timer/impl/timepoint.h"
-
-#include <thread>
-#include <chrono>
-
-using namespace std::chrono_literals;
-
-TEST(wf_timer_timepoint, now)
-{
-    wf_timer_timepoint start = wf_timer_impl_timepoint_now();
-    std::this_thread::sleep_for(42ms);
-    wf_timer_timepoint end = wf_timer_impl_timepoint_now();
-
-    ASSERT_LT(start, end);
-    ASSERT_LT(end, start + 500);
-}
-
-TEST(wf_timer_timepoint, in_msec)
-{
-    wf_timer_timepoint now = wf_timer_impl_timepoint_now();
-    wf_timer_timepoint later = wf_timer_impl_timepoint_in_msec(42);
-
-    ASSERT_LT(now, later);
-    ASSERT_LT(later, now + 500);
-}
-
-TEST(wf_timer_timepoint, elapsed)
-{
-    wf_timer_timepoint now;
-    
-    now = wf_timer_impl_timepoint_now();
-    ASSERT_TRUE(wf_timer_impl_timepoint_is_elapsed(now - 1));
-
-    now = wf_timer_impl_timepoint_now();
-    ASSERT_FALSE(wf_timer_impl_timepoint_is_elapsed(now + 500));
-}

test/webfuse/mocks/fake_invokation_context.cc

@@ -0,0 +1,17 @@
+#include "webfuse/mocks/fake_invokation_context.hpp"
+
+namespace webfuse_test
+{
+
+wfp_impl_invokation_context create_context(MockProvider& provider, wfp_request * request)
+{
+    wfp_impl_invokation_context context =
+    {
+        provider.get_provider(),
+        provider.get_userdata(),
+        request
+    };
+    return context;
+}
+
+}

test/webfuse/mocks/fake_invokation_context.hpp

@@ -0,0 +1,16 @@
+#ifndef FAKE_INVOCATION_CONTEXT_HPP
+#define FAKE_INVOCATION_CONTEXT_HPP
+
+#include "webfuse/provider/impl/provider.h"
+#include "webfuse/mocks/mock_provider.hpp"
+
+namespace webfuse_test
+{
+
+wfp_impl_invokation_context create_context(
+    MockProvider& provider,
+    wfp_request * request = nullptr);
+
+}
+
+#endif

test/webfuse/mocks/mock_fuse.cc

@@ -0,0 +1,31 @@
+#include "webfuse/mocks/mock_fuse.hpp"
+#include "webfuse/utils/wrap.hpp"
+
+extern "C"
+{
+static webfuse_test::FuseMock * webfuse_test_FuseMock = nullptr;
+
+WF_WRAP_FUNC1(webfuse_test_FuseMock, void*, fuse_req_userdata, fuse_req_t);
+WF_WRAP_FUNC2(webfuse_test_FuseMock, int, fuse_reply_open, fuse_req_t, const struct fuse_file_info *);
+WF_WRAP_FUNC2(webfuse_test_FuseMock, int, fuse_reply_err, fuse_req_t, int);
+WF_WRAP_FUNC3(webfuse_test_FuseMock, int,  fuse_reply_buf, fuse_req_t, const char *, size_t);
+WF_WRAP_FUNC3(webfuse_test_FuseMock, int, fuse_reply_attr, fuse_req_t, const struct stat *, double);
+WF_WRAP_FUNC1(webfuse_test_FuseMock, const struct fuse_ctx *, fuse_req_ctx, fuse_req_t);
+WF_WRAP_FUNC2(webfuse_test_FuseMock, int, fuse_reply_entry, fuse_req_t, const struct fuse_entry_param *);
+}
+
+namespace webfuse_test
+{
+
+FuseMock::FuseMock()
+{
+    webfuse_test_FuseMock = this;
+}
+
+FuseMock::~FuseMock()
+{
+    webfuse_test_FuseMock = nullptr;
+}
+
+
+}

test/webfuse/mocks/mock_fuse.hpp

@@ -0,0 +1,27 @@
+#ifndef MOCK_FUSE_HPP
+#define MOCK_FUSE_HPP
+
+#include "webfuse/adapter/impl/fuse_wrapper.h"
+#include <gmock/gmock.h>
+
+namespace webfuse_test
+{
+
+class FuseMock
+{
+public:
+    FuseMock();
+    virtual ~FuseMock();
+
+    MOCK_METHOD1(fuse_req_userdata, void *(fuse_req_t req));
+    MOCK_METHOD2(fuse_reply_open, int (fuse_req_t req, const struct fuse_file_info *fi));
+    MOCK_METHOD2(fuse_reply_err, int (fuse_req_t req, int err));
+    MOCK_METHOD3(fuse_reply_buf, int (fuse_req_t req, const char *buf, size_t size));
+    MOCK_METHOD3(fuse_reply_attr, int (fuse_req_t req, const struct stat *attr, double attr_timeout));
+    MOCK_METHOD1(fuse_req_ctx, const struct fuse_ctx *(fuse_req_t req));
+    MOCK_METHOD2(fuse_reply_entry, int (fuse_req_t req, const struct fuse_entry_param *e));
+};
+
+}
+
+#endif

test/webfuse/mocks/mock_jsonrpc_proxy.cc

@@ -0,0 +1,34 @@
+#include "webfuse/mocks/mock_jsonrpc_proxy.hpp"
+#include "webfuse/utils/wrap.hpp"
+
+extern "C"
+{
+static webfuse_test::MockJsonRpcProxy * webfuse_test_MockJsonRpcProxy = nullptr;
+
+WF_WRAP_VFUNC5(webfuse_test_MockJsonRpcProxy, void, wf_jsonrpc_proxy_vinvoke,
+	struct wf_jsonrpc_proxy *,
+	wf_jsonrpc_proxy_finished_fn *,
+	void *,
+	char const *,
+	char const *);
+
+WF_WRAP_VFUNC3(webfuse_test_MockJsonRpcProxy, void, wf_jsonrpc_proxy_vnotify,
+	struct wf_jsonrpc_proxy *,
+	char const *,
+	char const *);
+}
+
+namespace webfuse_test
+{
+
+MockJsonRpcProxy::MockJsonRpcProxy()
+{
+    webfuse_test_MockJsonRpcProxy = this;
+}
+
+MockJsonRpcProxy::~MockJsonRpcProxy()
+{
+    webfuse_test_MockJsonRpcProxy = nullptr;
+}
+
+}

test/webfuse/mocks/mock_jsonrpc_proxy.hpp

@@ -0,0 +1,30 @@
+#ifndef MOCK_JSONRPC_PROXY_HPP
+#define MOCK_JSONRPC_PROXY_HPP
+
+#include "webfuse/core/jsonrpc/proxy_intern.h"
+#include <gmock/gmock.h>
+
+namespace webfuse_test
+{
+
+class MockJsonRpcProxy
+{
+public:
+    MockJsonRpcProxy();
+    virtual ~MockJsonRpcProxy();
+    MOCK_METHOD5(wf_jsonrpc_proxy_vinvoke, void (
+        struct wf_jsonrpc_proxy * proxy,
+        wf_jsonrpc_proxy_finished_fn * finished,
+        void * user_data,
+        char const * method_name,
+        char const * param_info));
+    MOCK_METHOD3(wf_jsonrpc_proxy_vnotify, void (
+        struct wf_jsonrpc_proxy * proxy,
+        char const * method_name,
+        char const * param_info));
+
+};
+
+}
+
+#endif

test/webfuse/mocks/mock_operation_context.cc

@@ -0,0 +1,27 @@
+#include "webfuse/mocks/mock_operation_context.hpp"
+#include "webfuse/utils/wrap.hpp"
+
+extern "C"
+{
+static webfuse_test::MockOperationContext * webfuse_test_MockOperationContext = nullptr;
+
+WF_WRAP_FUNC1(webfuse_test_MockOperationContext, 
+    struct wf_jsonrpc_proxy *,  wf_impl_operation_context_get_proxy,
+	struct wf_impl_operation_context *);
+
+}
+
+namespace webfuse_test
+{
+
+MockOperationContext::MockOperationContext()
+{
+    webfuse_test_MockOperationContext = this;
+}
+
+MockOperationContext::~MockOperationContext()
+{
+    webfuse_test_MockOperationContext = nullptr;
+}
+
+}