reorganized project: prepared to extract common functionality

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);
+}