reorganized project: prepared to extract common functionality

lib/wsfs/adapter/filesystem.c

@@ -0,0 +1,83 @@
+#include "wsfs/adapter/filesystem.h"
+#include "wsfs/adapter/operations.h"
+#include "wsfs/adapter/jsonrpc/server.h"
+
+#include <stddef.h>
+#include <string.h>
+#include <errno.h>
+
+static struct fuse_lowlevel_ops const wsfs_filesystem_operations =
+{
+	.lookup = &wsfs_operation_lookup,
+	.getattr = &wsfs_operation_getattr,
+	.readdir = &wsfs_operation_readdir,
+	.open	= &wsfs_operation_open,
+	.release = &wsfs_operation_close,
+	.read	= &wsfs_operation_read
+};
+
+
+bool wsfs_filesystem_init(
+    struct wsfs_filesystem * filesystem,
+	struct wsfs_jsonrpc_server * rpc,
+    char * mount_point)
+{
+	bool result = false;
+
+	char * argv[] = {"", NULL};
+	filesystem->args.argc = 1;
+	filesystem->args.argv = argv;
+	filesystem->args.allocated = 0;
+
+	filesystem->user_data.rpc = rpc;
+	filesystem->user_data.timeout = 1.0;
+	memset(&filesystem->buffer, 0, sizeof(struct fuse_buf));
+
+	filesystem->session = fuse_session_new(
+        &filesystem->args,
+        &wsfs_filesystem_operations,
+        sizeof(wsfs_filesystem_operations),
+        &filesystem->user_data);
+	if (NULL != filesystem->session)
+	{
+		result = (0 == fuse_session_mount(filesystem->session, mount_point));
+	}
+
+	return result;
+}
+
+void wsfs_filesystem_cleanup(
+    struct wsfs_filesystem * filesystem)
+{
+	if (NULL != filesystem->session)
+	{
+		fuse_session_reset(filesystem->session);
+		fuse_session_unmount(filesystem->session);
+		fuse_session_destroy(filesystem->session);
+		filesystem->session = NULL;
+	}
+
+	free(filesystem->buffer.mem);
+	fuse_opt_free_args(&filesystem->args);    
+}
+
+int wsfs_filesystem_get_fd(
+    struct wsfs_filesystem * filesystem)
+{
+    return fuse_session_fd(filesystem->session);
+}
+
+void wsfs_filesystem_process_request(
+    struct wsfs_filesystem * filesystem)
+{
+	int const result = fuse_session_receive_buf(filesystem->session, &filesystem->buffer);
+	if (0 < result)
+	{
+		fuse_session_process_buf(filesystem->session, &filesystem->buffer);
+	}
+	else if (-EINTR != result)
+	{
+        // ToDo
+	}
+
+}

lib/wsfs/adapter/filesystem.h

@@ -0,0 +1,45 @@
+#ifndef WSFS_FILESYSTEM_H
+#define WSFS_FILESYSTEM_H
+
+#ifndef __cplusplus
+#include <stdbool.h>
+#endif
+
+#include "wsfs/adapter/fuse_wrapper.h"
+#include "wsfs/adapter/operations.h"
+
+struct wsfs_jsonrpc_server;
+
+struct wsfs_filesystem
+{
+	struct fuse_args args;
+	struct fuse_session * session;
+	struct fuse_buf buffer;
+	struct wsfs_operations_context user_data;
+};
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+extern bool wsfs_filesystem_init(
+    struct wsfs_filesystem * filesystem,
+    struct wsfs_jsonrpc_server * rpc,
+    char * mount_point);
+
+extern void wsfs_filesystem_cleanup(
+    struct wsfs_filesystem * filesystem);
+
+extern int wsfs_filesystem_get_fd(
+    struct wsfs_filesystem * filesystem);
+
+extern void wsfs_filesystem_process_request(
+    struct wsfs_filesystem * filesystem);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif

lib/wsfs/adapter/fuse_wrapper.h

@@ -0,0 +1,16 @@
+#ifndef WSFS_FUSE_H
+#define WSFS_FUSE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define FUSE_USE_VERSION 31
+#include <fuse_lowlevel.h>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+

lib/wsfs/adapter/jsonrpc/method.c

@@ -0,0 +1,28 @@
+#include "wsfs/adapter/jsonrpc/method_intern.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+struct wsfs_jsonrpc_method * wsfs_jsonrpc_method_create(
+    char const * name,
+    wsfs_jsonrpc_method_invoke_fn * invoke,
+    void * user_data)
+{
+    struct wsfs_jsonrpc_method * method = malloc(sizeof(struct wsfs_jsonrpc_method));
+    if (NULL != method)
+    {
+        method->next = NULL;
+        method->name = strdup(name);
+        method->invoke = invoke;
+        method->user_data = user_data;
+    }
+
+    return method;
+}
+
+void wsfs_jsonrpc_method_dispose(
+    struct wsfs_jsonrpc_method * method)
+{
+    free(method->name);
+    free(method);
+}

lib/wsfs/adapter/jsonrpc/method.h

@@ -0,0 +1,24 @@
+#ifndef WSFS_JSONRPC_METHOD_H
+#define WSFS_JSONRPC_METHOD_H
+
+#ifndef __cplusplus
+#include <stdbool.h>
+#endif
+
+#include <jansson.h>
+#include "wsfs/adapter/status.h"
+
+
+typedef bool wsfs_jsonrpc_method_invoke_fn(
+    void * user_data,
+    struct json_t const * method_call);
+
+typedef void wsfs_jsonrpc_method_finished_fn(
+	void * user_data,
+	wsfs_status status,
+	struct json_t const * result);
+
+
+
+
+#endif

lib/wsfs/adapter/jsonrpc/method_intern.h

@@ -0,0 +1,31 @@
+#ifndef WSFS_JSONRPC_METHOD_INTERN_H
+#define WSFS_JSONRPC_METHOD_INTERN_H
+
+#include "wsfs/adapter/jsonrpc/method.h"
+
+struct wsfs_jsonrpc_method
+{
+    struct wsfs_jsonrpc_method * next;
+    char * name;
+    wsfs_jsonrpc_method_invoke_fn * invoke;
+    void * user_data;
+};
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+extern struct wsfs_jsonrpc_method * wsfs_jsonrpc_method_create(
+    char const * name,
+    wsfs_jsonrpc_method_invoke_fn * invoke,
+    void * user_data);
+
+extern void wsfs_jsonrpc_method_dispose(
+    struct wsfs_jsonrpc_method * method);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

lib/wsfs/adapter/jsonrpc/request.c

@@ -0,0 +1,44 @@
+#include "wsfs/adapter/jsonrpc/request.h"
+
+json_t * wsfs_jsonrpc_request_create(
+	char const * method,
+	int id,
+	char const * param_info,
+	va_list args)
+{
+	json_t * request = json_object();
+	json_object_set_new(request, "method", json_string(method));
+	json_t * params = json_array();
+	
+	for (char const * param_type = param_info; '\0' != *param_type; param_type++)
+	{
+		switch(*param_type)
+		{
+			case 's':
+			{
+				char const * const value = va_arg(args, char const *);
+				json_array_append_new(params, json_string(value));
+			}
+			break;
+			case 'i':
+			{
+				int const value = va_arg(args, int);
+				json_array_append_new(params, json_integer(value));
+			}
+			break;
+			default:
+			fprintf(stderr, "fatal: unknown param_type '%c'\n", *param_type);
+			exit(EXIT_FAILURE);
+			break;
+		}
+	}
+	
+
+	json_object_set_new(request, "params", params);
+	if (0 != id)
+	{
+		json_object_set_new(request, "id", json_integer(id));
+	}
+	
+	return request;
+}

lib/wsfs/adapter/jsonrpc/request.h

@@ -0,0 +1,31 @@
+#ifndef WSFS_JSONRPC_REQUEST_H
+#define WSFS_JSONRPC_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>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+extern json_t * wsfs_jsonrpc_request_create(
+	char const * method,
+	int id,
+	char const * param_info,
+	va_list args);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

lib/wsfs/adapter/jsonrpc/response.c

@@ -0,0 +1,59 @@
+#include "wsfs/adapter/jsonrpc/response.h"
+
+void wsfs_jsonrpc_response_init(
+	struct wsfs_jsonrpc_response * result,
+    char const * buffer,
+	size_t length)
+{
+	result->status = WSFS_BAD;
+	result->id = -1;
+	result->result = NULL;
+
+	json_t * response = json_loadb(buffer, length, 0, NULL);
+	if (NULL == response)
+	{
+		result->status = WSFS_BAD_FORMAT;
+		return;
+	}
+
+	json_t * id_holder = json_object_get(response, "id");
+	if ((NULL == id_holder) || (!json_is_integer(id_holder)))
+	{
+		result->status = WSFS_BAD_FORMAT;
+		json_decref(response);
+		return;
+	}
+	
+	result->status = WSFS_GOOD;
+	result->id = json_integer_value(id_holder);
+	result->result = json_object_get(response, "result");
+	if (NULL != result->result)
+	{
+		json_incref(result->result);
+	}
+	else
+	{
+		result->status = WSFS_BAD_FORMAT;
+
+		json_t * error = json_object_get(response, "error");
+		if (NULL != error)
+		{
+			json_t * error_code = json_object_get(error, "code");
+			if ((NULL != error_code) && (json_is_integer(error_code)))
+			{
+				result->status = json_integer_value(error_code);
+			}
+		}
+	}
+	
+	json_decref(response);
+}
+
+void wsfs_jsonrpc_response_cleanup(
+	struct wsfs_jsonrpc_response * response)
+{
+    if (NULL != response->result)
+    {
+        json_decref(response->result);
+    }
+}

lib/wsfs/adapter/jsonrpc/response.h

@@ -0,0 +1,38 @@
+#ifndef WSFS_JSONRPC_RESPONSE_H
+#define WSFS_JSONRPC_RESPONSE_H
+
+#ifndef __cplusplus
+#include <stddef.h>
+#else
+#include <cstddef>
+using std::size_t;
+#endif
+
+#include <jansson.h>
+#include "wsfs/adapter/status.h"
+
+struct wsfs_jsonrpc_response
+{
+	wsfs_status status;
+	int id;
+	json_t * result;	
+};
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void wsfs_jsonrpc_response_init(
+	struct wsfs_jsonrpc_response * response,
+    char const * buffer,
+	size_t buffer_length);
+
+extern void wsfs_jsonrpc_response_cleanup(
+	struct wsfs_jsonrpc_response * response);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+

lib/wsfs/adapter/jsonrpc/server.c

@@ -0,0 +1,186 @@
+#include "wsfs/adapter/jsonrpc/server.h"
+#include <string.h>
+
+#include "wsfs/adapter/jsonrpc/method_intern.h"
+#include "wsfs/adapter/jsonrpc/request.h"
+#include "wsfs/adapter/jsonrpc/response.h"
+
+#define WSFS_DEFAULT_TIMEOUT (10 * 1000)
+
+static struct wsfs_jsonrpc_method const * wsfs_jsonrpc_server_getmethod(
+    struct wsfs_jsonrpc_server * server,
+    char const * name)
+{
+    struct wsfs_jsonrpc_method * method = server->methods;
+    while ((NULL != method) && (0 == strcmp(name, method->name)))
+    {
+        method = method->next;
+    }
+
+    return method;
+}
+
+static void wsfs_jsonrpc_server_timeout(
+    struct wsfs_timer * timer)
+{
+    struct wsfs_jsonrpc_server * server = timer->user_data;
+
+    if (server->request.is_pending)
+    {
+        wsfs_jsonrpc_method_finished_fn * finished = server->request.finished;
+        void * user_data = server->request.user_data;
+
+        server->request.is_pending = false;
+        server->request.id = 0;
+        server->request.user_data = NULL;
+        server->request.finished = NULL;
+        wsfs_timer_cancel(&server->request.timer);
+
+        finished(user_data, WSFS_BAD_TIMEOUT, NULL);
+    }
+}
+
+void wsfs_jsonrpc_server_init(
+    struct wsfs_jsonrpc_server * server,
+    struct wsfs_timeout_manager * timeout_manager)
+{
+    server->methods = NULL;
+    server->request.is_pending = false;
+    
+    wsfs_timer_init(&server->request.timer, timeout_manager);
+}
+
+void wsfs_jsonrpc_server_cleanup(
+    struct wsfs_jsonrpc_server * server)
+{
+    wsfs_timer_cleanup(&server->request.timer);
+
+    if (server->request.is_pending)
+    {
+        server->request.finished(server->request.user_data, WSFS_BAD, NULL);
+        server->request.is_pending = false;
+    }
+
+    struct wsfs_jsonrpc_method * method = server->methods;
+    while (NULL != method)
+    {
+        struct wsfs_jsonrpc_method * next = method->next;
+        method->next = NULL;
+        wsfs_jsonrpc_method_dispose(method);
+        method = next;
+    }
+    server->methods = NULL;
+}
+
+void wsfs_jsonrpc_server_add(
+    struct wsfs_jsonrpc_server * server,
+    char const * name,
+    wsfs_jsonrpc_method_invoke_fn * invoke,
+    void * user_data)
+{
+    struct wsfs_jsonrpc_method * method = wsfs_jsonrpc_method_create(name, invoke, user_data);
+    method->next = server->methods;
+    server->methods = method;
+}
+
+void wsfs_jsonrpc_server_invoke(
+	struct wsfs_jsonrpc_server * server,
+	wsfs_jsonrpc_method_finished_fn * finished,
+	void * user_data,
+	char const * method_name,
+	char const * param_info,
+	...
+)
+{
+    if (!server->request.is_pending)
+    {
+        struct wsfs_jsonrpc_method const * method = wsfs_jsonrpc_server_getmethod(server, method_name);
+        if (NULL != method)
+        {
+            server->request.is_pending = true;
+            server->request.finished = finished;
+            server->request.user_data = user_data;
+            server->request.id = 42;
+            wsfs_timer_start(&server->request.timer, wsfs_timepoint_in_msec(WSFS_DEFAULT_TIMEOUT), 
+                    &wsfs_jsonrpc_server_timeout, server);
+            
+            va_list args;
+            va_start(args, param_info);
+            json_t * request = wsfs_jsonrpc_request_create(method_name, server->request.id, param_info, args);
+            va_end(args);
+            if (NULL != request)
+            {
+                if (!method->invoke(method->user_data, request))
+                {
+                    server->request.is_pending = false;
+                    server->request.finished = NULL;
+                    server->request.user_data = NULL;
+                    server->request.id = 0;
+                    wsfs_timer_cancel(&server->request.timer);
+
+                    finished(user_data, WSFS_BAD, NULL);
+                }
+                json_decref(request);
+            }
+        }
+        else
+        {
+            finished(user_data, WSFS_BAD_NOTIMPLEMENTED, NULL);
+        }        
+    }
+    else
+    {
+        finished(user_data, WSFS_BAD_BUSY, NULL);
+    }
+}
+
+extern void wsfs_jsonrpc_server_notify(
+	struct wsfs_jsonrpc_server * server,
+	char const * method_name,
+	char const * param_info,
+	...
+)
+{
+        struct wsfs_jsonrpc_method const * method = wsfs_jsonrpc_server_getmethod(server, method_name);
+        if (NULL != method)
+        {
+            
+            va_list args;
+            va_start(args, param_info);
+            json_t * request = wsfs_jsonrpc_request_create(method_name, 0, param_info, args);
+            va_end(args);
+            if (NULL != request)
+            {
+                method->invoke(method->user_data, request);
+                json_decref(request);
+            }
+        }
+
+}
+
+
+void wsfs_jsonrpc_server_onresult(
+    struct wsfs_jsonrpc_server * server,
+    char const * message,
+    size_t length)
+{
+	struct wsfs_jsonrpc_response response;
+	wsfs_jsonrpc_response_init(&response, message, length);
+
+    if ((server->request.is_pending) && (response.id == server->request.id))
+    {
+        wsfs_jsonrpc_method_finished_fn * finished = server->request.finished;
+        void * user_data = server->request.user_data;
+
+        server->request.is_pending = false;
+        server->request.id = 0;
+        server->request.user_data = NULL;
+        server->request.finished = NULL;
+        wsfs_timer_cancel(&server->request.timer);
+
+        finished(user_data, response.status, response.result);
+    }
+
+    wsfs_jsonrpc_response_cleanup(&response);
+}
+

lib/wsfs/adapter/jsonrpc/server.h

@@ -0,0 +1,80 @@
+#ifndef WSFS_JSONRPC_SERVER_H
+#define WSFS_JSONRPC_SERVER_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 "wsfs/adapter/jsonrpc/method.h"
+#include "wsfs/adapter/time/timeout_manager.h"
+#include "wsfs/adapter/time/timer.h"
+
+
+struct wsfs_jsonrpc_request
+{
+    bool is_pending;
+    wsfs_jsonrpc_method_finished_fn * finished;
+    void * user_data;
+    int id;
+    struct wsfs_timer timer;
+};
+
+struct wsfs_jsonrpc_server
+{
+    struct wsfs_jsonrpc_method * methods;
+    struct wsfs_jsonrpc_request request;
+};
+
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+extern void wsfs_jsonrpc_server_init(
+    struct wsfs_jsonrpc_server * server,
+    struct wsfs_timeout_manager * manager);
+
+extern void wsfs_jsonrpc_server_cleanup(
+    struct wsfs_jsonrpc_server * server);
+
+extern void wsfs_jsonrpc_server_add(
+    struct wsfs_jsonrpc_server * server,
+    char const * name,
+    wsfs_jsonrpc_method_invoke_fn * invoke,
+    void * user_data );
+
+extern void wsfs_jsonrpc_server_invoke(
+	struct wsfs_jsonrpc_server * server,
+	wsfs_jsonrpc_method_finished_fn * finished,
+	void * user_data,
+	char const * method_name,
+	char const * param_info,
+	...
+);
+
+extern void wsfs_jsonrpc_server_notify(
+	struct wsfs_jsonrpc_server * server,
+	char const * method_name,
+	char const * param_info,
+	...
+);
+
+extern void wsfs_jsonrpc_server_onresult(
+    struct wsfs_jsonrpc_server * server,
+    char const * message,
+    size_t length);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif

lib/wsfs/adapter/jsonrpc/util.c

@@ -0,0 +1,14 @@
+#include "wsfs/adapter/jsonrpc/util.h"
+
+int wsfs_json_get_int(json_t const * object, char const * key, int default_value)
+{
+	int result = default_value;
+
+	json_t * holder = json_object_get(object, key);
+	if ((NULL != holder) && (json_is_integer(holder)))
+	{
+		result = json_integer_value(holder);
+	}
+
+	return result;
+}

lib/wsfs/adapter/jsonrpc/util.h

@@ -0,0 +1,17 @@
+#ifndef WSFS_JSON_UTIL_H
+#define WSFS_JSON_UTIL_H
+
+#include <jansson.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+extern int wsfs_json_get_int(json_t const * object, char const * key, int default_value);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

lib/wsfs/adapter/message.c

@@ -0,0 +1,24 @@
+#include "wsfs/adapter/message.h"
+
+#include <stdlib.h>
+#include <libwebsockets.h>
+
+struct wsfs_message * wsfs_message_create(size_t length)
+{
+    char * data = malloc(sizeof(struct wsfs_message) + LWS_PRE + length);
+    struct wsfs_message * message = (struct wsfs_message *) data;
+    if (NULL != message)
+    {
+        message->data = &data[sizeof(struct wsfs_message) + LWS_PRE];
+        message->length = length;
+        message->next = NULL;
+    }
+
+    return message;
+}
+
+void wsfs_message_dispose(
+    struct wsfs_message * message)
+{
+    free(message);    
+}

lib/wsfs/adapter/message.h

@@ -0,0 +1,32 @@
+#ifndef WSFS_MESSAGE_H
+#define WSFS_MESSAGE_H
+
+#ifndef __cplusplus
+#include <stddef.h>
+#else
+#include <cstddef>
+using std::size_t;
+#endif
+
+struct wsfs_message
+{
+    struct wsfs_message * next;
+    char * data;
+    size_t length;
+};
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+extern struct wsfs_message * wsfs_message_create(size_t length);
+
+extern void wsfs_message_dispose(
+    struct wsfs_message * message);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

lib/wsfs/adapter/message_queue.c

@@ -0,0 +1,63 @@
+#include "wsfs/adapter/message_queue.h"
+#include "wsfs/adapter/message.h"
+
+void wsfs_message_queue_init(
+    struct wsfs_message_queue * queue)
+{
+    queue->first = NULL;
+    queue->last = NULL;
+    
+}
+
+void wsfs_message_queue_cleanup(
+    struct wsfs_message_queue * queue)
+{
+    struct wsfs_message * message = queue->first;
+    while (NULL != message)
+    {
+        struct wsfs_message * next = message->next;
+        wsfs_message_dispose(message);
+        message = next;
+    }
+    wsfs_message_queue_init(queue);
+}
+
+bool wsfs_message_queue_empty(
+    struct wsfs_message_queue * queue)
+{
+    return (NULL == queue->first);
+}
+
+void wsfs_message_queue_push(
+    struct wsfs_message_queue * queue,
+    struct wsfs_message * message)
+{
+    message->next = NULL;
+
+    if (NULL != queue->last)
+    {
+        queue->last->next = message;
+        queue->last = message;
+    }
+    else
+    {
+        queue->first = message;
+        queue->last = message;
+    }
+}
+
+struct wsfs_message * wsfs_message_queue_pop(
+    struct wsfs_message_queue * queue)
+{
+    struct wsfs_message * const result = queue->first;
+    if (NULL != result)
+    {
+        queue->first = queue->first->next;
+        if (NULL == queue->first)
+        {
+            queue->last = NULL;
+        }
+    } 
+
+    return result;
+}

lib/wsfs/adapter/message_queue.h

@@ -0,0 +1,42 @@
+#ifndef WSFS_MESSAGE_QUEUE_H
+#define WSFS_MESSAGE_QUEUE_H
+
+#ifndef __cplusplus
+#include <stdbool.h>
+#endif
+
+struct wsfs_message_queue;
+struct wsfs_message;
+
+struct wsfs_message_queue
+{
+    struct wsfs_message * first;
+    struct wsfs_message * last;
+};
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+extern void wsfs_message_queue_init(
+    struct wsfs_message_queue * queue);
+
+extern void wsfs_message_queue_cleanup(
+    struct wsfs_message_queue * queue);
+
+extern bool wsfs_message_queue_empty(
+    struct wsfs_message_queue * queue);
+
+extern void wsfs_message_queue_push(
+    struct wsfs_message_queue * queue,
+    struct wsfs_message * message);
+
+extern struct wsfs_message * wsfs_message_queue_pop(
+    struct wsfs_message_queue * queue);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

lib/wsfs/adapter/operation/close.c

@@ -0,0 +1,21 @@
+#include "wsfs/adapter/operations.h"
+
+#include <limits.h>
+#include <errno.h>
+#include <jansson.h>
+
+#include "wsfs/adapter/jsonrpc/server.h"
+#include "wsfs/util.h"
+
+void wsfs_operation_close(
+	fuse_req_t request,
+	fuse_ino_t inode,
+	struct fuse_file_info * file_info)
+{
+    struct wsfs_operations_context * user_data = fuse_req_userdata(request);
+    struct wsfs_jsonrpc_server * rpc = user_data->rpc;
+
+	int handle = (int) (file_info->fh & INT_MAX);
+	wsfs_jsonrpc_server_notify(rpc, "close", "iii", inode, handle, file_info->flags);
+	fuse_reply_err(request, 0);
+}

lib/wsfs/adapter/operation/getattr.c

@@ -0,0 +1,93 @@
+#include "wsfs/adapter/operations.h"
+
+#include <errno.h>
+#include <string.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h> 
+
+#include "wsfs/adapter/jsonrpc/server.h"
+#include "wsfs/adapter/jsonrpc/util.h"
+#include "wsfs/util.h"
+
+struct wsfs_operation_getattr_context
+{
+	fuse_req_t request;
+	double timeout;
+	uid_t uid;
+	gid_t gid;
+};
+
+static void wsfs_operation_getattr_finished(
+	void * user_data,
+	wsfs_status status,
+	json_t const * data)
+{
+	struct wsfs_operation_getattr_context * context = user_data;
+
+    struct stat buffer;
+	if (NULL != data)
+	{
+		json_t * mode_holder = json_object_get(data, "mode");
+		json_t * type_holder = json_object_get(data, "type");
+		if ((NULL != mode_holder) && (json_is_integer(mode_holder)) && 
+		    (NULL != type_holder) && (json_is_string(type_holder)))
+		{
+            memset(&buffer, 0, sizeof(struct stat));
+
+			buffer.st_mode = json_integer_value(mode_holder) & 0555;
+			char const * type = json_string_value(type_holder);
+			if (0 == strcmp("file", type)) 
+			{
+				buffer.st_mode |= S_IFREG;
+			}
+			else if (0 == strcmp("dir", type))
+			{
+				buffer.st_mode |= S_IFDIR;
+			}
+
+            buffer.st_uid = context->uid;
+            buffer.st_gid = context->gid;
+            buffer.st_nlink = 1;
+			buffer.st_size = wsfs_json_get_int(data, "size", 0);
+			buffer.st_atime = wsfs_json_get_int(data, "atime", 0);
+			buffer.st_mtime = wsfs_json_get_int(data, "mtime", 0);
+			buffer.st_ctime = wsfs_json_get_int(data, "ctime", 0);
+
+		}
+		else
+		{
+	        status = WSFS_BAD_FORMAT;
+		}
+	}
+
+    if (WSFS_GOOD == status)
+    {
+        fuse_reply_attr(context->request, &buffer, context->timeout);
+    }
+    else
+    {
+	    fuse_reply_err(context->request, ENOENT);
+    }
+
+	free(context);
+}
+
+void wsfs_operation_getattr (
+	fuse_req_t request,
+	fuse_ino_t inode,
+	struct fuse_file_info * WSFS_UNUSED_PARAM(file_info))
+{
+    struct fuse_ctx const * context = fuse_req_ctx(request);
+    struct wsfs_operations_context * user_data = fuse_req_userdata(request);
+    struct wsfs_jsonrpc_server * rpc = user_data->rpc;
+
+	struct wsfs_operation_getattr_context * getattr_context = malloc(sizeof(struct wsfs_operation_getattr_context));
+	getattr_context->request = request;
+	getattr_context->uid = context->uid;
+	getattr_context->gid = context->gid;
+	getattr_context->timeout = user_data->timeout;
+
+	wsfs_jsonrpc_server_invoke(rpc, &wsfs_operation_getattr_finished, getattr_context, "getattr", "i", inode);
+}

lib/wsfs/adapter/operation/lookup.c

@@ -0,0 +1,103 @@
+#include "wsfs/adapter/operations.h"
+
+#include <limits.h>
+#include <errno.h>
+#include <string.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h> 
+
+#include <stdlib.h>
+
+#include "wsfs/adapter/jsonrpc/server.h"
+#include "wsfs/adapter/jsonrpc/util.h"
+#include "wsfs/util.h"
+
+struct wsfs_operation_lookup_context
+{
+	fuse_req_t request;
+	double timeout;
+	uid_t uid;
+	gid_t gid;
+};
+
+static void wsfs_operation_lookup_finished(
+	void * user_data,
+	wsfs_status status,
+	json_t const * data
+)
+{
+	struct wsfs_operation_lookup_context * context = user_data; 	
+    struct fuse_entry_param buffer;
+
+	if (NULL != data)
+	{
+		json_t * inode_holder = json_object_get(data, "inode"); 
+		json_t * mode_holder = json_object_get(data, "mode");
+		json_t * type_holder = json_object_get(data, "type");
+		if ((NULL != inode_holder) && (json_is_integer(inode_holder)) &&
+			(NULL != mode_holder) && (json_is_integer(mode_holder)) && 
+		    (NULL != type_holder) && (json_is_string(type_holder)))
+		{
+            memset(&buffer, 0, sizeof(struct stat));
+
+			buffer.ino = json_integer_value(inode_holder);
+			buffer.attr.st_mode = json_integer_value(mode_holder) & 0555;
+			char const * type = json_string_value(type_holder);
+			if (0 == strcmp("file", type)) 
+			{
+				buffer.attr.st_mode |= S_IFREG;
+			}
+			else if (0 == strcmp("dir", type))
+			{
+				buffer.attr.st_mode |= S_IFDIR;
+			}
+
+
+			buffer.attr_timeout = context->timeout;
+			buffer.entry_timeout = context->timeout;
+            buffer.attr.st_uid = context->uid;
+            buffer.attr.st_gid = context->gid;
+            buffer.attr.st_nlink = 1;
+			buffer.attr.st_size = wsfs_json_get_int(data, "size", 0);
+			buffer.attr.st_atime = wsfs_json_get_int(data, "atime", 0);
+			buffer.attr.st_mtime = wsfs_json_get_int(data, "mtime", 0);
+			buffer.attr.st_ctime = wsfs_json_get_int(data, "ctime", 0);
+		}
+		else
+		{
+	        status = WSFS_BAD_FORMAT;
+		}
+	}
+
+    if (WSFS_GOOD == status)
+    {
+        fuse_reply_entry(context->request, &buffer);
+    }
+    else
+    {
+	    fuse_reply_err(context->request, ENOENT);
+    }
+
+	free(context);
+}
+
+void wsfs_operation_lookup (
+	fuse_req_t request, 
+	fuse_ino_t parent, 
+	char const * name)
+{
+    struct fuse_ctx const * context = fuse_req_ctx(request);
+    struct wsfs_operations_context * user_data = fuse_req_userdata(request);
+    struct wsfs_jsonrpc_server * rpc = user_data->rpc;
+
+	struct wsfs_operation_lookup_context * lookup_context = malloc(sizeof(struct wsfs_operation_lookup_context));
+	lookup_context->request = request;
+	lookup_context->uid = context->uid;
+	lookup_context->gid = context->gid;
+	lookup_context->timeout = user_data->timeout;
+
+	wsfs_jsonrpc_server_invoke(rpc, &wsfs_operation_lookup_finished, lookup_context, "lookup", "is", (int) (parent & INT_MAX), name);
+
+}

lib/wsfs/adapter/operation/open.c

@@ -0,0 +1,53 @@
+#include "wsfs/adapter/operations.h"
+
+#include <string.h>
+#include <errno.h>
+#include <jansson.h>
+
+#include "wsfs/adapter/jsonrpc/server.h"
+#include "wsfs/util.h"
+#include "wsfs/adapter/status.h"
+
+static void wsfs_operation_open_finished(
+	void * user_data,
+	wsfs_status status,
+	json_t const * result)
+{
+	fuse_req_t request = user_data;
+	struct fuse_file_info file_info;
+	memset(&file_info, 0, sizeof(struct fuse_file_info));
+
+	if (NULL != result)
+	{
+        json_t * handle_holder = json_object_get(result, "handle");
+        if ((NULL != handle_holder) && (json_is_integer(handle_holder))) 
+        {
+            file_info.fh = json_integer_value(handle_holder);
+        }
+        else
+        {
+            status = WSFS_BAD_FORMAT;
+        }        
+	}
+
+	if (WSFS_GOOD == status)
+	{
+		fuse_reply_open(request, &file_info);		
+	}
+	else
+	{
+		fuse_reply_err(request, ENOENT);
+	}
+
+}
+
+void wsfs_operation_open(
+	fuse_req_t request,
+	fuse_ino_t inode,
+	struct fuse_file_info * file_info)
+{
+    struct wsfs_operations_context * user_data = fuse_req_userdata(request);
+    struct wsfs_jsonrpc_server * rpc = user_data->rpc;
+
+	wsfs_jsonrpc_server_invoke(rpc, &wsfs_operation_open_finished, request, "open", "ii", inode, file_info->flags);
+}

lib/wsfs/adapter/operation/read.c

@@ -0,0 +1,95 @@
+#include "wsfs/adapter/operations.h"
+
+#include <errno.h>
+#include <string.h>
+#include <limits.h>
+#include <jansson.h>
+#include <libwebsockets.h>
+
+#include "wsfs/adapter/jsonrpc/server.h"
+
+#define WSFS_MAX_READ_LENGTH 4096
+
+static wsfs_status wsfs_fill_buffer(
+	char * * buffer,
+	char const * format,
+	char const * data,
+	size_t count)
+{
+	wsfs_status status = WSFS_GOOD;
+
+	if (0 < count)
+	{
+		*buffer = malloc(count);
+		if (0 == strcmp("identity", format))
+		{
+			memcpy(*buffer, data, count); /* Flawfinder: ignore */
+		}
+		else if (0 == strcmp("base64", format))
+		{
+			lws_b64_decode_string(data, *buffer, count);
+		}
+		else
+		{
+			status = WSFS_BAD;
+		}
+	}
+
+	return status;
+}
+
+static void wsfs_operation_read_finished(void * user_data, wsfs_status status, json_t const * data)
+{
+	fuse_req_t request = user_data;
+
+	char * buffer = NULL;	
+	size_t length = 0;
+	if (NULL != data)
+	{
+		json_t * data_holder = json_object_get(data, "data");
+		json_t * format_holder = json_object_get(data, "format");
+		json_t * count_holder = json_object_get(data, "count");
+
+		if ((NULL != data_holder) && (json_is_string(data_holder)) &&
+             	    (NULL != format_holder) && (json_is_string(format_holder)) &&
+             	    (NULL != count_holder) && (json_is_integer(count_holder)))
+		{
+			char const * const data = json_string_value(data_holder);
+			char const * const format = json_string_value(format_holder);
+			length = (size_t) json_integer_value(count_holder);
+
+			status = wsfs_fill_buffer(&buffer, format, data, length);
+		}
+		else
+		{
+			status = WSFS_BAD_FORMAT;
+		}
+	}
+
+	if (WSFS_GOOD == status)
+	{
+		fuse_reply_buf(request, buffer, length);
+	}
+	else
+	{
+   		fuse_reply_err(request, ENOENT);
+	}
+	
+    free(buffer);
+
+}
+
+void wsfs_operation_read(
+	fuse_req_t request,
+	fuse_ino_t inode,
+    size_t size,
+    off_t offset,
+	struct fuse_file_info * file_info)
+{
+    struct wsfs_operations_context * user_data = fuse_req_userdata(request);
+    struct wsfs_jsonrpc_server * rpc = user_data->rpc;
+
+	int const length = (size <= WSFS_MAX_READ_LENGTH) ? (int) size : WSFS_MAX_READ_LENGTH;
+    int handle = (file_info->fh & INT_MAX);
+	wsfs_jsonrpc_server_invoke(rpc, &wsfs_operation_read_finished, request, "read", "iiii", inode, handle, (int) offset, length);
+}

lib/wsfs/adapter/operation/readdir.c

@@ -0,0 +1,147 @@
+#include "wsfs/adapter/operations.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h> 
+
+#include "wsfs/adapter/jsonrpc/server.h"
+#include "wsfs/util.h"
+
+
+#define WSFS_DIRBUFFER_INITIAL_SIZE 1024
+
+struct wsfs_operation_readdir_context
+{
+	fuse_req_t request;
+	size_t size;
+	off_t offset;
+};
+
+struct wsfs_dirbuffer
+{
+	char * data;
+	size_t position;
+	size_t capacity;
+};
+
+static void wsfs_dirbuffer_init(
+	struct wsfs_dirbuffer * buffer)
+{
+	buffer->data = malloc(WSFS_DIRBUFFER_INITIAL_SIZE);
+	buffer->position = 0;
+	buffer->capacity = WSFS_DIRBUFFER_INITIAL_SIZE;
+}
+
+static void wsfs_dirbuffer_dispose(
+	struct wsfs_dirbuffer * buffer)
+{
+	free(buffer->data);
+}
+
+static void wsfs_dirbuffer_add(
+	fuse_req_t request,
+	struct wsfs_dirbuffer * buffer,
+	char const * name,
+	fuse_ino_t inode)
+{
+	size_t const size = fuse_add_direntry(request, NULL, 0, name, NULL, 0);
+	size_t remaining = buffer->capacity - buffer->position;
+	while (remaining < size)
+	{
+		buffer->capacity *= 2;
+		buffer->data = realloc(buffer->data, buffer->capacity);
+		remaining = buffer->capacity - buffer->position;
+	}
+
+	struct stat stat_buffer;
+	memset(&stat_buffer, 0, sizeof(struct stat));
+	stat_buffer.st_ino = inode;
+	fuse_add_direntry(request, 
+		&buffer->data[buffer->position], remaining, name,
+		&stat_buffer, buffer->position + size);
+	buffer->position += size;
+}
+
+static size_t min(size_t a, size_t b)
+{
+	return (a < b) ? a : b;
+}
+
+static void wsfs_operation_readdir_finished(
+	void * user_data,
+	wsfs_status status,
+	json_t const * result)
+{
+	struct wsfs_operation_readdir_context * context = user_data;
+
+	struct wsfs_dirbuffer buffer;
+	wsfs_dirbuffer_init(&buffer);
+
+	if (NULL != result)
+	{
+		if (json_is_array(result)) 
+		{
+			bool buffer_full = false;
+			size_t const count = json_array_size(result);
+			for(size_t i = 0; (!buffer_full) && (i < count); i++)
+			{
+				json_t * entry =json_array_get(result, i);
+				if (json_is_object(entry))
+				{
+					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)) &&
+						(NULL != inode_holder) && (json_is_integer(inode_holder)))
+					{
+						char const * name = json_string_value(name_holder);
+						fuse_ino_t entry_inode = (fuse_ino_t) json_integer_value(inode_holder);
+						wsfs_dirbuffer_add(context->request, &buffer, name, entry_inode);	
+					}
+				}
+			}
+		}
+	}
+
+	if (WSFS_GOOD == status)
+	{
+		if (((size_t) context->offset) < buffer.position)
+		{
+			fuse_reply_buf(context->request, &buffer.data[context->offset],
+				min(buffer.position - context->offset, context->size));
+		}
+		else
+		{
+			fuse_reply_buf(context->request, NULL, 0);			
+		}
+		
+	}
+	else
+	{
+		fuse_reply_err(context->request, ENOENT);
+	}
+
+	wsfs_dirbuffer_dispose(&buffer);
+	free(context);
+}
+
+void wsfs_operation_readdir (
+	fuse_req_t request,
+	fuse_ino_t inode,
+	size_t size,
+	off_t offset,
+	struct fuse_file_info * WSFS_UNUSED_PARAM(file_info))
+{
+    struct wsfs_operations_context * user_data = fuse_req_userdata(request);
+    struct wsfs_jsonrpc_server * rpc = user_data->rpc;
+	struct wsfs_operation_readdir_context * readdir_context = malloc(sizeof(struct wsfs_operation_readdir_context));
+	readdir_context->request = request;
+	readdir_context->size = size;
+	readdir_context->offset = offset;
+
+	 wsfs_jsonrpc_server_invoke(rpc, &wsfs_operation_readdir_finished, readdir_context, "readdir", "i", inode);
+}

lib/wsfs/adapter/operations.h

@@ -0,0 +1,55 @@
+#ifndef WSFS_OPERATIONS
+#define WSFS_OPERATIONS
+
+#include "wsfs/adapter/fuse_wrapper.h"
+
+struct wsfs_jsonrpc_server;
+
+struct wsfs_operations_context
+{
+	struct wsfs_jsonrpc_server * rpc;
+	double timeout;
+};
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void wsfs_operation_lookup (
+	fuse_req_t req, 
+	fuse_ino_t parent, 
+	char const * name);
+
+extern void wsfs_operation_getattr (
+		fuse_req_t request,
+		fuse_ino_t inode,
+		struct fuse_file_info *file_info);
+
+extern void wsfs_operation_readdir (
+	fuse_req_t request,
+	fuse_ino_t inode,
+	size_t size,
+	off_t offset,
+	struct fuse_file_info *file_info);
+
+extern void wsfs_operation_open(
+	fuse_req_t request,
+	fuse_ino_t inode,
+	struct fuse_file_info * file_info);
+
+extern void wsfs_operation_close(
+	fuse_req_t request,
+	fuse_ino_t inode,
+	struct fuse_file_info * file_info);
+
+extern void wsfs_operation_read(
+	fuse_req_t request,
+	fuse_ino_t ino, size_t size, off_t off,
+			struct fuse_file_info *fi);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+

lib/wsfs/adapter/server.c

@@ -0,0 +1,123 @@
+#include "wsfs/adapter/server.h"
+
+#include <stdlib.h>
+#include <stdbool.h>
+#include <libwebsockets.h>
+
+#include "wsfs/adapter/server_config.h"
+#include "wsfs/adapter/server_protocol_intern.h"
+
+#define WSFS_DISABLE_LWS_LOG 0
+#define WSFS_SERVER_PROTOCOL_COUNT 3
+#define WSFS_SERVER_TIMEOUT (1 * 1000)
+
+struct wsfs_server
+{
+    struct wsfs_server_config config;
+    struct wsfs_server_protocol protocol;
+    struct lws_protocols ws_protocols[WSFS_SERVER_PROTOCOL_COUNT];
+    struct lws_context * context;
+    volatile bool shutdown_requested;
+	struct lws_http_mount mount;
+	struct lws_context_creation_info info;
+};
+
+static bool wsfs_server_tls_enabled(
+	struct wsfs_server * server)
+{
+	return ((server->config.key_path != NULL) && (server->config.cert_path != NULL));
+}
+
+static struct lws_context * wsfs_server_context_create(
+    struct wsfs_server * server)
+{
+	lws_set_log_level(WSFS_DISABLE_LWS_LOG, NULL);
+
+    memset(server->ws_protocols, 0, sizeof(struct lws_protocols) * WSFS_SERVER_PROTOCOL_COUNT);
+    server->ws_protocols[0].name = "http";
+    server->ws_protocols[0].callback = lws_callback_http_dummy;
+    server->ws_protocols[1].name = "fs";
+    wsfs_server_protocol_init_lws(&server->protocol, &server->ws_protocols[1]);
+
+	memset(&server->mount, 0, sizeof(struct lws_http_mount));
+	server->mount.mount_next = NULL,
+	server->mount.mountpoint = "/",
+	server->mount.origin = server->config.document_root,
+	server->mount.def = "index.html",
+	server->mount.origin_protocol = LWSMPRO_FILE,
+	server->mount.mountpoint_len = 1,
+
+	memset(&server->info, 0, sizeof(struct lws_context_creation_info));
+	server->info.port = server->config.port;
+	server->info.mounts = &server->mount;
+	server->info.protocols = server->ws_protocols;
+	server->info.vhost_name = server->config.vhost_name;
+	server->info.ws_ping_pong_interval = 10;
+	server->info.options = LWS_SERVER_OPTION_HTTP_HEADERS_SECURITY_BEST_PRACTICES_ENFORCE;
+
+	if (NULL == server->config.document_root)
+	{
+		// disable http
+		server->info.protocols = &server->ws_protocols[1];
+		server->info.mounts = NULL;
+	}
+
+	if (wsfs_server_tls_enabled(server))
+	{
+		server->info.options |= LWS_SERVER_OPTION_DO_SSL_GLOBAL_INIT;
+		server->info.ssl_cert_filepath = server->config.cert_path;
+		server->info.ssl_private_key_filepath = server->config.key_path;
+	}
+
+	struct lws_context * const context = lws_create_context(&server->info);
+    return context;
+
+}
+
+struct wsfs_server * wsfs_server_create(
+    struct wsfs_server_config * config)
+{
+    struct wsfs_server * server = malloc(sizeof(struct wsfs_server));
+    if (NULL != server)
+    {
+        if (wsfs_server_protocol_init(&server->protocol, config->mount_point))
+		{
+			server->shutdown_requested = false;
+			wsfs_server_config_clone(config, &server->config);
+			server->context = wsfs_server_context_create(server);
+		}
+		else
+		{
+			free(server);
+			server = NULL;
+		}
+    }   
+
+    return server; 
+}
+
+void wsfs_server_dispose(
+    struct wsfs_server * server)
+{
+    lws_context_destroy(server->context);
+    wsfs_server_protocol_cleanup(&server->protocol);
+    wsfs_server_config_cleanup(&server->config);
+    free(server);   
+}
+
+void wsfs_server_run(
+    struct wsfs_server * server)
+{
+    int n = 0;
+    while ((0 <= n) && (!server->shutdown_requested))
+    {
+        n = lws_service(server->context, WSFS_SERVER_TIMEOUT);
+    }
+}
+
+void wsfs_server_shutdown(
+    struct wsfs_server * server)
+{
+    server->shutdown_requested = true;
+}
+

lib/wsfs/adapter/server_config.c

@@ -0,0 +1,45 @@
+#include "wsfs/adapter/server_config.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+static char * wsfs_server_config_strdup(char const * value)
+{
+    char * result = NULL;
+    if (NULL != value) 
+    {
+        result = strdup(value);
+    }
+
+    return result;
+}
+
+void wsfs_server_config_init(
+    struct wsfs_server_config * config)
+{
+    memset(config, 0, sizeof(struct wsfs_server_config));
+}
+
+void wsfs_server_config_cleanup(
+    struct wsfs_server_config * config)
+{
+    free(config->mount_point);
+	free(config->document_root);
+	free(config->key_path);
+	free(config->cert_path);
+	free(config->vhost_name);
+
+    wsfs_server_config_init(config);    
+}
+
+void wsfs_server_config_clone(
+	struct wsfs_server_config * config,
+	struct wsfs_server_config * clone)
+{
+    clone->mount_point = wsfs_server_config_strdup(config->mount_point);
+	clone->document_root = wsfs_server_config_strdup(config->document_root);
+	clone->key_path = wsfs_server_config_strdup(config->key_path);
+	clone->cert_path = wsfs_server_config_strdup(config->cert_path);
+	clone->vhost_name = wsfs_server_config_strdup(config->vhost_name);
+	clone->port = config->port;
+}

lib/wsfs/adapter/server_protocol.c

@@ -0,0 +1,182 @@
+#include "wsfs/adapter/server_protocol_intern.h"
+
+#include <stdlib.h>
+#include <libwebsockets.h>
+
+#include "wsfs/adapter/message.h"
+#include "wsfs/adapter/filesystem.h"
+#include "wsfs/util.h"
+
+static int wsfs_server_protocol_callback(
+	struct lws * wsi,
+	enum lws_callback_reasons reason,
+	void * WSFS_UNUSED_PARAM(user),
+	void * in,
+	size_t len)
+{
+    struct lws_protocols const * ws_protocol = lws_get_protocol(wsi);
+    struct wsfs_server_protocol * protocol = ws_protocol->user;
+
+    wsfs_timeout_manager_check(&protocol->timeout_manager);
+
+    switch (reason)
+    {
+        case LWS_CALLBACK_PROTOCOL_INIT:
+        {            
+            lws_sock_file_fd_type fd;
+            fd.filefd = wsfs_filesystem_get_fd(&protocol->filesystem);
+            if (!lws_adopt_descriptor_vhost(lws_get_vhost(wsi), LWS_ADOPT_RAW_FILE_DESC, fd, ws_protocol->name, NULL))
+            {
+                puts("error: unable to adopt fd");
+            }
+        }
+        break;
+		case LWS_CALLBACK_ESTABLISHED:
+		{
+			if (NULL == protocol->wsi)
+			{
+                protocol->wsi = wsi;
+			}
+		}
+		break;
+		case LWS_CALLBACK_CLOSED:
+		{
+			if (wsi == protocol->wsi)
+            {
+                protocol->wsi = NULL;
+                wsfs_message_queue_cleanup(&protocol->queue);
+            }
+		}
+        break;
+		case LWS_CALLBACK_SERVER_WRITEABLE:
+		{
+			if ((wsi == protocol->wsi) && (!wsfs_message_queue_empty(&protocol->queue)))
+			{                
+				struct wsfs_message * message = wsfs_message_queue_pop(&protocol->queue);
+				lws_write(wsi, (unsigned char*) message->data, message->length, LWS_WRITE_TEXT);
+				wsfs_message_dispose(message);
+			}
+		}
+		break;
+        case LWS_CALLBACK_RECEIVE:
+        {
+            wsfs_jsonrpc_server_onresult(&protocol->rpc, in, len);
+        }
+        break;
+        case LWS_CALLBACK_RAW_RX_FILE:
+        {
+            wsfs_filesystem_process_request(&protocol->filesystem);
+        }
+        break;
+        default:
+        break;
+    }
+
+    if ((wsi == protocol->wsi) && (!wsfs_message_queue_empty(&protocol->queue)))
+    {
+        lws_callback_on_writable(wsi);
+    }
+
+    return 0;
+}
+
+static bool wsfs_server_protocol_invoke(
+    void * user_data,
+    json_t const * request)
+{
+    bool result = false;
+    struct wsfs_server_protocol * protocol = user_data;
+
+    if (NULL != protocol->wsi)
+    {
+        size_t length = json_dumpb(request, NULL, 0, JSON_COMPACT);
+        if (0 < length)
+        {	
+            struct wsfs_message * message = wsfs_message_create(length);
+            json_dumpb(request, message->data, length, JSON_COMPACT);
+
+            wsfs_message_queue_push(&protocol->queue, message);
+            lws_callback_on_writable(protocol->wsi);
+
+            // ToDo: add timeout
+
+            result = true;
+        }
+    }
+    
+
+    return result;
+}
+
+
+struct wsfs_server_protocol * wsfs_server_protocol_create(
+    char * mount_point)
+{
+    struct wsfs_server_protocol * protocol = malloc(sizeof(struct wsfs_server_protocol));
+    if (NULL != protocol)
+    {
+        if (!wsfs_server_protocol_init(protocol, mount_point))
+        {
+            free(protocol);
+            protocol = NULL;
+        }
+    }
+
+    return protocol;
+}
+
+void wsfs_server_protocol_dispose(
+    struct wsfs_server_protocol * protocol)
+{
+    wsfs_server_protocol_cleanup(protocol);
+    free(protocol);
+}
+
+void wsfs_server_protocol_init_lws(
+    struct wsfs_server_protocol * protocol,
+    struct lws_protocols * lws_protocol)
+{
+	lws_protocol->callback = &wsfs_server_protocol_callback;
+	lws_protocol->per_session_data_size = 0;
+	lws_protocol->user = protocol;
+}
+
+bool wsfs_server_protocol_init(
+    struct wsfs_server_protocol * protocol,
+    char * mount_point)
+{
+    protocol->wsi = NULL;
+    wsfs_message_queue_init(&protocol->queue);
+
+    wsfs_timeout_manager_init(&protocol->timeout_manager);
+
+    wsfs_jsonrpc_server_init(&protocol->rpc, &protocol->timeout_manager);
+    wsfs_jsonrpc_server_add(&protocol->rpc, "lookup", &wsfs_server_protocol_invoke, protocol);
+    wsfs_jsonrpc_server_add(&protocol->rpc, "getattr", &wsfs_server_protocol_invoke, protocol);
+    wsfs_jsonrpc_server_add(&protocol->rpc, "readdir", &wsfs_server_protocol_invoke, protocol);
+    wsfs_jsonrpc_server_add(&protocol->rpc, "open", &wsfs_server_protocol_invoke, protocol);
+    wsfs_jsonrpc_server_add(&protocol->rpc, "close", &wsfs_server_protocol_invoke, protocol);
+    wsfs_jsonrpc_server_add(&protocol->rpc, "read", &wsfs_server_protocol_invoke, protocol);
+
+    bool const success = wsfs_filesystem_init(&protocol->filesystem, &protocol->rpc, mount_point);
+
+    // cleanup on error
+    if (!success)
+    {
+        wsfs_jsonrpc_server_cleanup(&protocol->rpc);
+        wsfs_timeout_manager_cleanup(&protocol->timeout_manager);
+        wsfs_message_queue_cleanup(&protocol->queue);
+    }
+
+    return success;
+}
+
+void wsfs_server_protocol_cleanup(
+    struct wsfs_server_protocol * protocol)
+{
+    wsfs_filesystem_cleanup(&protocol->filesystem);
+    wsfs_jsonrpc_server_cleanup(&protocol->rpc);
+    wsfs_timeout_manager_cleanup(&protocol->timeout_manager);
+    wsfs_message_queue_cleanup(&protocol->queue);
+    protocol->wsi = NULL;
+}

lib/wsfs/adapter/server_protocol_intern.h

@@ -0,0 +1,26 @@
+#ifndef WSFS_SERVER_PROTOCOL_INTERN_H
+#define WSFS_SERVER_PROTOCOL_INTERN_H
+
+#include "wsfs/adapter/server_protocol.h"
+#include "wsfs/adapter/filesystem.h"
+#include "wsfs/adapter/message_queue.h"
+#include "wsfs/adapter/jsonrpc/server.h"
+#include "wsfs/adapter/time/timeout_manager.h"
+
+struct wsfs_server_protocol
+{
+    struct wsfs_timeout_manager timeout_manager;
+    struct wsfs_filesystem filesystem;
+    struct wsfs_jsonrpc_server rpc;
+    struct wsfs_message_queue queue;
+    struct lws * wsi;    
+};
+
+extern bool wsfs_server_protocol_init(
+    struct wsfs_server_protocol * protocol,
+    char * mount_point);
+
+extern void wsfs_server_protocol_cleanup(
+    struct wsfs_server_protocol * protocol);
+
+#endif

lib/wsfs/adapter/status.c

@@ -0,0 +1,34 @@
+#include "wsfs/adapter/status.h"
+
+#include <errno.h>
+
+ int wsfs_status_to_rc(wsfs_status status)
+{
+	switch(status)
+	{
+		case WSFS_GOOD: return 0;
+		case WSFS_BAD_NOTIMPLEMENTED: return -ENOSYS;
+		case WSFS_BAD_TIMEOUT: return -ETIMEDOUT;
+		case WSFS_BAD_BUSY: return -ENOENT;
+		case WSFS_BAD_FORMAT: return -ENOENT;
+		case WSFS_BAD_NOENTRY: return -ENOENT;
+		case WSFS_BAD_NOACCESS: return -EACCES;
+		default: return -ENOENT;
+	}
+}
+
+char const * wsfs_status_tostring(wsfs_status status)
+{
+	switch(status)
+	{
+		case WSFS_GOOD: return "Good";
+		case WSFS_BAD: return "Bad";
+		case WSFS_BAD_NOTIMPLEMENTED: return "Bad (not implelemted)";
+		case WSFS_BAD_TIMEOUT: return "Bad (timeout)";
+		case WSFS_BAD_BUSY: return "Bad (busy)";
+		case WSFS_BAD_FORMAT: return "Bad (format)";
+		case WSFS_BAD_NOENTRY: return "Bad (no entry)";
+		case WSFS_BAD_NOACCESS: return "Bad (no access)";
+		default: return "Bad (unknown)";
+	}
+}

lib/wsfs/adapter/status.h

@@ -0,0 +1,30 @@
+#ifndef WSFS_STATUS_H
+#define WSFS_STATUS_H
+
+#define WSFS_GOOD 0
+#define WSFS_BAD  1
+
+#define WSFS_BAD_NOTIMPLEMENTED 2
+#define WSFS_BAD_TIMEOUT        3
+#define WSFS_BAD_BUSY           4
+#define WSFS_BAD_FORMAT         5
+
+#define WSFS_BAD_NOENTRY 101
+#define WSFS_BAD_NOACCESS 102
+
+typedef int wsfs_status;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int wsfs_status_to_rc(wsfs_status status);
+
+extern char const * wsfs_status_tostring(wsfs_status status);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+

lib/wsfs/adapter/time/timeout_manager.c

@@ -0,0 +1,84 @@
+#include "wsfs/adapter/time/timeout_manager_intern.h"
+
+#include <stddef.h>
+#include "wsfs/adapter/time/timer_intern.h"
+#include "wsfs/adapter/time/timepoint.h"
+
+void wsfs_timeout_manager_init(
+    struct wsfs_timeout_manager * manager)
+{
+    manager->timers = NULL;
+}
+
+void wsfs_timeout_manager_cleanup(
+    struct wsfs_timeout_manager * manager)
+{
+    struct wsfs_timer * timer = manager->timers;
+    while (NULL != timer)
+    {
+        struct wsfs_timer * next = timer->next;
+
+        wsfs_timer_trigger(timer);
+
+        timer = next;
+    }
+
+    manager->timers = NULL;
+
+}
+
+void wsfs_timeout_manager_check(
+    struct wsfs_timeout_manager * manager)
+{
+    struct wsfs_timer * timer = manager->timers;
+    while (NULL != timer)
+    {
+        struct wsfs_timer * next = timer->next;
+
+        if (wsfs_timer_is_timeout(timer))
+        {
+            wsfs_timeout_manager_removetimer(manager, timer);
+            wsfs_timer_trigger(timer);
+        }
+
+        timer = next;
+    }    
+}
+
+void wsfs_timeout_manager_addtimer(
+    struct wsfs_timeout_manager * manager,
+    struct wsfs_timer * timer)
+{
+    if (NULL != manager->timers)
+    {
+        manager->timers->prev = timer;
+    }
+
+    timer->next = manager->timers;
+    timer->prev = NULL;
+    manager->timers = timer;
+}
+
+void wsfs_timeout_manager_removetimer(
+    struct wsfs_timeout_manager * manager,
+    struct wsfs_timer * timer)
+{
+    struct wsfs_timer * prev = timer->prev;
+    struct wsfs_timer * next = timer->next;
+
+    if (NULL != prev)
+    {
+        prev->next = next;
+    }
+
+    if (NULL != next)
+    {
+        next->prev = prev;
+    }
+
+    if (manager->timers == timer)
+    {
+        manager->timers = next;
+    }
+}
+

lib/wsfs/adapter/time/timeout_manager.h

@@ -0,0 +1,29 @@
+#ifndef WSFS_TIME_TIMEOUT_MANAGER_H
+#define WSFS_TIME_TIMEOUT_MANAGER_H
+
+struct wsfs_timer;
+struct wsfs_timeout_manager
+{
+    struct wsfs_timer * timers;
+};
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+extern void wsfs_timeout_manager_init(
+    struct wsfs_timeout_manager * manager);
+
+extern void wsfs_timeout_manager_cleanup(
+    struct wsfs_timeout_manager * manager);
+
+extern void wsfs_timeout_manager_check(
+    struct wsfs_timeout_manager * manager);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

lib/wsfs/adapter/time/timeout_manager_intern.h

@@ -0,0 +1,24 @@
+#ifndef WSFS_TIME_TIMEOUT_MANAGER_INTERN_H
+#define WSFS_TIME_TIMEOUT_MANAGER_INTERN_H
+
+#include "wsfs/adapter/time/timeout_manager.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+extern void wsfs_timeout_manager_addtimer(
+    struct wsfs_timeout_manager * manager,
+    struct wsfs_timer * timer);
+
+extern void wsfs_timeout_manager_removetimer(
+    struct wsfs_timeout_manager * manager,
+    struct wsfs_timer * timer);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif

lib/wsfs/adapter/time/timepoint.c

@@ -0,0 +1,31 @@
+#include "wsfs/adapter/time/timepoint.h"
+
+#include <time.h>
+
+#define WSFS_MSEC_PER_SEC  ((wsfs_timepoint) 1000) 
+#define WSFS_NSEC_PER_MSEC ((wsfs_timepoint) 1000 * 1000) 
+
+wsfs_timepoint wsfs_timepoint_now(void)
+{
+    struct timespec timepoint;
+    clock_gettime(CLOCK_MONOTONIC, &timepoint);
+
+    wsfs_timepoint const now = (timepoint.tv_sec * WSFS_MSEC_PER_SEC) + (timepoint.tv_nsec / WSFS_NSEC_PER_MSEC);
+    return now;
+}
+
+wsfs_timepoint wsfs_timepoint_in_msec(wsfs_timediff value)
+{
+    wsfs_timepoint const now = wsfs_timepoint_now();
+    wsfs_timepoint result = now + ((wsfs_timepoint) value);
+
+    return result;
+}
+
+bool wsfs_timepoint_is_elapsed(wsfs_timepoint timepoint)
+{
+    wsfs_timepoint const now = wsfs_timepoint_now();
+    wsfs_timediff const  diff = (wsfs_timediff) (timepoint - now);
+
+    return (0 > diff);
+}

lib/wsfs/adapter/time/timepoint.h

@@ -0,0 +1,31 @@
+#ifndef WSFS_TIME_TIMEPOINT_H
+#define WSFS_TIME_TIMEPOINT_H
+
+#ifndef __cplusplus
+#include <stdbool.h>
+#include <inttypes.h>
+#else
+#include <cinttypes>
+#endif
+
+typedef uint64_t wsfs_timepoint;
+typedef int64_t wsfs_timediff;
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+extern wsfs_timepoint wsfs_timepoint_now(void);
+
+extern wsfs_timepoint wsfs_timepoint_in_msec(
+    wsfs_timediff value);
+
+extern bool wsfs_timepoint_is_elapsed(
+    wsfs_timepoint timepoint);
+
+#ifdef __cplusplus
+} 
+#endif
+
+#endif

lib/wsfs/adapter/time/timer.c

@@ -0,0 +1,65 @@
+#include "wsfs/adapter/time/timer_intern.h"
+#include "wsfs/adapter/time/timeout_manager_intern.h"
+
+#include <stddef.h>
+#include <string.h>
+
+void wsfs_timer_init(
+    struct wsfs_timer * timer,
+    struct wsfs_timeout_manager * manager)
+{
+    timer->manager = manager;
+    timer->timeout = 0;
+    timer->timeout_handler = NULL;
+    timer->user_data = NULL;
+    timer->prev = NULL;
+    timer->next = NULL;
+}
+
+void wsfs_timer_cleanup(
+    struct wsfs_timer * timer)
+{
+    memset(timer, 0, sizeof(struct wsfs_timer));    
+}
+
+void wsfs_timer_start(
+    struct wsfs_timer * timer,
+    wsfs_timepoint absolute_timeout,
+    wsfs_timer_timeout_fn * handler,
+    void * user_data)
+{
+    timer->timeout = absolute_timeout;
+    timer->timeout_handler = handler;
+    timer->user_data = user_data;
+
+    wsfs_timeout_manager_addtimer(timer->manager, timer);
+}
+
+void wsfs_timer_cancel(
+    struct wsfs_timer * timer)
+{
+    wsfs_timeout_manager_removetimer(timer->manager, timer);
+
+    timer->timeout = 0;
+    timer->timeout_handler = NULL;
+    timer->user_data = NULL;
+}
+
+bool wsfs_timer_is_timeout(
+    struct wsfs_timer * timer)
+{
+    return wsfs_timepoint_is_elapsed(timer->timeout);
+}
+
+
+void wsfs_timer_trigger(
+    struct wsfs_timer * timer)
+{
+    if (NULL != timer->timeout_handler)
+    {
+        timer->prev = NULL;
+        timer->next = NULL;
+
+        timer->timeout_handler(timer);
+    }
+}

lib/wsfs/adapter/time/timer.h

@@ -0,0 +1,48 @@
+#ifndef WSFS_TIMER_H
+#define WSFS_TIMER_H
+
+#include "wsfs/adapter/time/timepoint.h"
+
+struct wsfs_timer;
+struct wsfs_timeout_manager;
+
+typedef void wsfs_timer_timeout_fn(struct wsfs_timer * timer);
+
+struct wsfs_timer
+{
+    struct wsfs_timeout_manager * manager;
+    wsfs_timepoint timeout;
+    wsfs_timer_timeout_fn * timeout_handler;
+    void * user_data;
+    struct wsfs_timer * next;
+    struct wsfs_timer * prev;
+};
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+extern void wsfs_timer_init(
+    struct wsfs_timer * timer,
+    struct wsfs_timeout_manager * manager);
+
+extern void wsfs_timer_cleanup(
+    struct wsfs_timer * timer);
+
+extern void wsfs_timer_start(
+    struct wsfs_timer * timer,
+    wsfs_timepoint absolute_timeout,
+    wsfs_timer_timeout_fn * handler,
+    void * user_data);
+
+extern void wsfs_timer_cancel(
+    struct wsfs_timer * timer);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#endif

lib/wsfs/adapter/time/timer_intern.h

@@ -0,0 +1,25 @@
+#ifndef WSFS_TIME_TIMER_INTERN_H
+#define WSFS_TIME_TIMER_INTERN_H
+
+#ifndef __cplusplus
+#include <stdbool.h>
+#endif
+
+#include "wsfs/adapter/time/timer.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+extern bool wsfs_timer_is_timeout(
+    struct wsfs_timer * timer);
+
+extern void wsfs_timer_trigger(
+    struct wsfs_timer * timer);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif