Archives/falk-werner_webfuse-provider
1
0
Fork 0
mirror of https://github.com/falk-werner/webfuse-provider synced 2026-03-02 04:09:18 +00:00
Code Issues Releases Wiki Activity

refactor: made jsonrpc an independent library

Browse Source
This commit is contained in:
Falk Werner
2020-02-28 23:17:41 +01:00
parent c6ca2e14bd
commit e3a3427ca8
54 changed files with 882 additions and 707 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
lib/webfuse/adapter/impl/jsonrpc/method.c
View File

@@ -1,27 +0,0 @@
#include "webfuse/adapter/impl/jsonrpc/method.h"
#include <stdlib.h>
#include <string.h>
struct wf_impl_jsonrpc_method * wf_impl_jsonrpc_method_create(
char const * method_name,
wf_impl_jsonrpc_method_invoke_fn * invoke,
void * user_data)
{
struct wf_impl_jsonrpc_method * method = malloc(sizeof(struct wf_impl_jsonrpc_method));
if (NULL != method)
{
method->next = NULL;
method->name = strdup(method_name);
method->invoke = invoke;
method->user_data = user_data;
}
return method;
}
void wf_impl_jsonrpc_method_dispose(
struct wf_impl_jsonrpc_method * method)
{
free(method->name);
free(method);
}

40
lib/webfuse/adapter/impl/jsonrpc/method.h
View File

@@ -1,40 +0,0 @@
#ifndef WF_ADAPTER_IMPL_JSONRPC_METHOD_H
#define WF_ADAPTER_IMPL_JSONRPC_METHOD_H
#include <jansson.h>
#ifdef __cplusplus
extern "C"
{
#endif
struct wf_impl_jsonrpc_request;
typedef void wf_impl_jsonrpc_method_invoke_fn(
struct wf_impl_jsonrpc_request * request,
char const * method_name,
json_t * params,
void * user_data);
struct wf_impl_jsonrpc_method
{
struct wf_impl_jsonrpc_method * next;
char * name;
wf_impl_jsonrpc_method_invoke_fn * invoke;
void * user_data;
};
extern struct wf_impl_jsonrpc_method * wf_impl_jsonrpc_method_create(
char const * method_name,
wf_impl_jsonrpc_method_invoke_fn * invoke,
void * user_data);
extern void wf_impl_jsonrpc_method_dispose(
struct wf_impl_jsonrpc_method * method);
#ifdef __cplusplus
}
#endif
#endif

194
lib/webfuse/adapter/impl/jsonrpc/proxy.c
View File

@@ -1,194 +0,0 @@
#include "webfuse/adapter/impl/jsonrpc/proxy.h"
#include <string.h>
#include "webfuse/adapter/impl/jsonrpc/response.h"
static void wf_impl_jsonrpc_proxy_timeout(
struct wf_impl_timer * timer)
{
struct wf_impl_jsonrpc_proxy * proxy = timer->user_data;
if (proxy->request.is_pending)
{
wf_impl_jsonrpc_proxy_finished_fn * finished = proxy->request.finished;
void * user_data = proxy->request.user_data;
proxy->request.is_pending = false;
proxy->request.id = 0;
proxy->request.user_data = NULL;
proxy->request.finished = NULL;
wf_impl_timer_cancel(&proxy->request.timer);
finished(user_data, WF_BAD_TIMEOUT, NULL);
}
}
static json_t * wf_impl_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);
json_decref(params);
json_decref(request);
return NULL;
}
}
json_object_set_new(request, "params", params);
if (0 != id)
{
json_object_set_new(request, "id", json_integer(id));
}
return request;
}
void wf_impl_jsonrpc_proxy_init(
struct wf_impl_jsonrpc_proxy * proxy,
struct wf_impl_timeout_manager * timeout_manager,
int timeout,
wf_impl_jsonrpc_send_fn * send,
void * user_data)
{
proxy->send = send;
proxy->timeout = timeout;
proxy->user_data = user_data;
proxy->request.is_pending = false;
wf_impl_timer_init(&proxy->request.timer, timeout_manager);
}
void wf_impl_jsonrpc_proxy_cleanup(
struct wf_impl_jsonrpc_proxy * proxy)
{
if (proxy->request.is_pending)
{
void * user_data = proxy->request.user_data;
wf_impl_jsonrpc_proxy_finished_fn * finished = proxy->request.finished;
proxy->request.is_pending = false;
proxy->request.finished = NULL;
proxy->request.user_data = NULL;
proxy->request.id = 0;
wf_impl_timer_cancel(&proxy->request.timer);
finished(user_data, WF_BAD, NULL);
}
wf_impl_timer_cleanup(&proxy->request.timer);
}
void wf_impl_jsonrpc_proxy_invoke(
struct wf_impl_jsonrpc_proxy * proxy,
wf_impl_jsonrpc_proxy_finished_fn * finished,
void * user_data,
char const * method_name,
char const * param_info,
...
)
{
if (!proxy->request.is_pending)
{
proxy->request.is_pending = true;
proxy->request.finished = finished;
proxy->request.user_data = user_data;
proxy->request.id = 42;
wf_impl_timer_start(&proxy->request.timer, wf_impl_timepoint_in_msec(proxy->timeout),
&wf_impl_jsonrpc_proxy_timeout, proxy);
va_list args;
va_start(args, param_info);
json_t * request = wf_impl_jsonrpc_request_create(method_name, proxy->request.id, param_info, args);
va_end(args);
bool const is_send = ((NULL != request) && (proxy->send(request, proxy->user_data)));
if (!is_send)
{
proxy->request.is_pending = false;
proxy->request.finished = NULL;
proxy->request.user_data = NULL;
proxy->request.id = 0;
wf_impl_timer_cancel(&proxy->request.timer);
finished(user_data, WF_BAD, NULL);
}
if (NULL != request)
{
json_decref(request);
}
}
else
{
finished(user_data, WF_BAD_BUSY, NULL);
}
}
extern void wf_impl_jsonrpc_proxy_notify(
struct wf_impl_jsonrpc_proxy * proxy,
char const * method_name,
char const * param_info,
...
)
{
va_list args;
va_start(args, param_info);
json_t * request = wf_impl_jsonrpc_request_create(method_name, 0, param_info, args);
va_end(args);
if (NULL != request)
{
proxy->send(request, proxy->user_data);
json_decref(request);
}
}
void wf_impl_jsonrpc_proxy_onresult(
struct wf_impl_jsonrpc_proxy * proxy,
json_t * message)
{
struct wf_impl_jsonrpc_response response;
wf_impl_jsonrpc_response_init(&response, message);
if ((proxy->request.is_pending) && (response.id == proxy->request.id))
{
wf_impl_jsonrpc_proxy_finished_fn * finished = proxy->request.finished;
void * user_data = proxy->request.user_data;
proxy->request.is_pending = false;
proxy->request.id = 0;
proxy->request.user_data = NULL;
proxy->request.finished = NULL;
wf_impl_timer_cancel(&proxy->request.timer);
finished(user_data, response.status, response.result);
}
wf_impl_jsonrpc_response_cleanup(&response);
}

82
lib/webfuse/adapter/impl/jsonrpc/proxy.h
View File

@@ -1,82 +0,0 @@
#ifndef WF_ADAPTER_IMPL_JSONRPC_PROXY_H
#define WF_ADAPTER_IMPL_JSONRPC_PROXY_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 "webfuse/adapter/impl/jsonrpc/send_fn.h"
#include "webfuse/adapter/impl/time/timeout_manager.h"
#include "webfuse/adapter/impl/time/timer.h"
#include "webfuse/core/status.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef void wf_impl_jsonrpc_proxy_finished_fn(
void * user_data,
wf_status status,
struct json_t const * result);
struct wf_impl_jsonrpc_request
{
bool is_pending;
wf_impl_jsonrpc_proxy_finished_fn * finished;
void * user_data;
int id;
struct wf_impl_timer timer;
};
struct wf_impl_jsonrpc_proxy
{
struct wf_impl_jsonrpc_request request;
int timeout;
wf_impl_jsonrpc_send_fn * send;
void * user_data;
};
extern void wf_impl_jsonrpc_proxy_init(
struct wf_impl_jsonrpc_proxy * proxy,
struct wf_impl_timeout_manager * manager,
int timeout,
wf_impl_jsonrpc_send_fn * send,
void * user_data);
extern void wf_impl_jsonrpc_proxy_cleanup(
struct wf_impl_jsonrpc_proxy * proxy);
extern void wf_impl_jsonrpc_proxy_invoke(
struct wf_impl_jsonrpc_proxy * proxy,
wf_impl_jsonrpc_proxy_finished_fn * finished,
void * user_data,
char const * method_name,
char const * param_info,
...
);
extern void wf_impl_jsonrpc_proxy_notify(
struct wf_impl_jsonrpc_proxy * proxy,
char const * method_name,
char const * param_info,
...
);
extern void wf_impl_jsonrpc_proxy_onresult(
struct wf_impl_jsonrpc_proxy * proxy,
json_t * message);
#ifdef __cplusplus
}
#endif
#endif

82
lib/webfuse/adapter/impl/jsonrpc/request.c
View File

@@ -1,82 +0,0 @@
#include "webfuse/adapter/impl/jsonrpc/request.h"
#include "webfuse/core/status_intern.h"
#include <stdlib.h>
struct wf_impl_jsonrpc_request
{
int id;
wf_impl_jsonrpc_send_fn * send;
void * user_data;
};
bool wf_impl_jsonrpc_is_request(
json_t * message)
{
json_t * id = json_object_get(message, "id");
json_t * method = json_object_get(message, "method");
json_t * params = json_object_get(message, "params");
return (json_is_integer(id) && json_is_string(method) &&
(json_is_array(params) || json_is_object(params)));
}
struct wf_impl_jsonrpc_request * wf_impl_jsonrpc_request_create(
int id,
wf_impl_jsonrpc_send_fn * send,
void * user_data)
{
struct wf_impl_jsonrpc_request * request = malloc(sizeof(struct wf_impl_jsonrpc_request));
if (NULL != request)
{
request->id = id;
request->send = send;
request->user_data = user_data;
}
return request;
}
void wf_impl_jsonrpc_request_dispose(
struct wf_impl_jsonrpc_request * request)
{
free(request);
}
void * wf_impl_jsonrpc_request_get_userdata(
struct wf_impl_jsonrpc_request * request)
{
return request->user_data;
}
void wf_impl_jsonrpc_respond(
struct wf_impl_jsonrpc_request * request,
json_t * result)
{
json_t * response = json_object();
json_object_set_new(response, "result", result);
json_object_set_new(response, "id", json_integer(request->id));
request->send(response, request->user_data);
json_decref(response);
wf_impl_jsonrpc_request_dispose(request);
}
void wf_impl_jsonrpc_respond_error(
struct wf_impl_jsonrpc_request * request,
wf_status status)
{
json_t * err = json_object();
json_object_set_new(err, "code", json_integer(status));
json_object_set_new(err, "message", json_string(wf_status_tostring(status)));
json_t * response = json_object();
json_object_set_new(response, "error", err);
json_object_set_new(response, "id", json_integer(request->id));
request->send(response, request->user_data);
json_decref(response);
wf_impl_jsonrpc_request_dispose(request);
}

52
lib/webfuse/adapter/impl/jsonrpc/request.h
View File

@@ -1,52 +0,0 @@
#ifndef WF_ADAPTER_IMPL_JSONRPC_REQUEST_H
#define WF_ADAPTER_IMPL_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>
#include "webfuse/core/status.h"
#include "webfuse/adapter/impl/jsonrpc/send_fn.h"
#ifdef __cplusplus
extern "C"
{
#endif
struct wf_impl_jsonrpc_request;
extern bool wf_impl_jsonrpc_is_request(
json_t * message);
extern struct wf_impl_jsonrpc_request * wf_impl_jsonrpc_request_create(
int id,
wf_impl_jsonrpc_send_fn * send,
void * user_data);
extern void wf_impl_jsonrpc_request_dispose(
struct wf_impl_jsonrpc_request * request);
extern void * wf_impl_jsonrpc_request_get_userdata(
struct wf_impl_jsonrpc_request * request);
extern void wf_impl_jsonrpc_respond(
struct wf_impl_jsonrpc_request * request,
json_t * result);
extern void wf_impl_jsonrpc_respond_error(
struct wf_impl_jsonrpc_request * request,
wf_status status);
#ifdef __cplusplus
}
#endif
#endif

60
lib/webfuse/adapter/impl/jsonrpc/response.c
View File

@@ -1,60 +0,0 @@
#include "webfuse/adapter/impl/jsonrpc/response.h"
extern bool wf_impl_jsonrpc_is_response(
json_t * message)
{
json_t * id = json_object_get(message, "id");
json_t * err = json_object_get(message, "error");
json_t * result = json_object_get(message, "result");
return (json_is_integer(id) &&
(json_is_object(err) || (NULL != result)));
}
void wf_impl_jsonrpc_response_init(
struct wf_impl_jsonrpc_response * result,
json_t * response)
{
result->status = WF_BAD;
result->id = -1;
result->result = NULL;
json_t * id_holder = json_object_get(response, "id");
if ((NULL == id_holder) || (!json_is_integer(id_holder)))
{
result->status = WF_BAD_FORMAT;
return;
}
result->status = WF_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 = WF_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);
}
}
}
}
void wf_impl_jsonrpc_response_cleanup(
struct wf_impl_jsonrpc_response * response)
{
if (NULL != response->result)
{
json_decref(response->result);
}
}

41
lib/webfuse/adapter/impl/jsonrpc/response.h
View File

@@ -1,41 +0,0 @@
#ifndef WF_ADAPTER_IMPL_JSONRPC_RESPONSE_H
#define WF_ADAPTER_IMPL_JSONRPC_RESPONSE_H
#ifndef __cplusplus
#include <stdbool.h>
#include <stddef.h>
#else
#include <cstddef>
using std::size_t;
#endif
#include <jansson.h>
#include "webfuse/core/status.h"
#ifdef __cplusplus
extern "C" {
#endif
struct wf_impl_jsonrpc_response
{
wf_status status;
int id;
json_t * result;
};
extern bool wf_impl_jsonrpc_is_response(
json_t * message);
extern void wf_impl_jsonrpc_response_init(
struct wf_impl_jsonrpc_response * response,
json_t * message);
extern void wf_impl_jsonrpc_response_cleanup(
struct wf_impl_jsonrpc_response * response);
#ifdef __cplusplus
}
#endif
#endif

23
lib/webfuse/adapter/impl/jsonrpc/send_fn.h
View File

@@ -1,23 +0,0 @@
#ifndef WF_ADAPTER_IMPL_JSONRPC_SEND_FN_H
#define WF_ADAPTER_IMPL_JSONRPC_SEND_FN_H
#ifndef __cplusplus
#include <stdbool.h>
#endif
#include <jansson.h>
#ifdef __cplusplus
extern "C"
{
#endif
typedef bool wf_impl_jsonrpc_send_fn(
json_t * request,
void * user_data);
#ifdef __cplusplus
}
#endif
#endif

95
lib/webfuse/adapter/impl/jsonrpc/server.c
View File

@@ -1,95 +0,0 @@
#include "webfuse/adapter/impl/jsonrpc/server.h"
#include "webfuse/adapter/impl/jsonrpc/method.h"
#include "webfuse/adapter/impl/jsonrpc/request.h"
#include "webfuse/core/util.h"
#include <string.h>
void wf_impl_jsonrpc_server_init(
struct wf_impl_jsonrpc_server * server)
{
server->methods = NULL;
}
void wf_impl_jsonrpc_server_cleanup(
struct wf_impl_jsonrpc_server * server)
{
struct wf_impl_jsonrpc_method * current = server->methods;
while (NULL != current)
{
struct wf_impl_jsonrpc_method * next = current->next;
wf_impl_jsonrpc_method_dispose(current);
current = next;
}
server->methods = NULL;
}
void wf_impl_jsonrpc_server_add(
struct wf_impl_jsonrpc_server * server,
char const * method_name,
wf_impl_jsonrpc_method_invoke_fn * invoke,
void * user_data)
{
struct wf_impl_jsonrpc_method * method = wf_impl_jsonrpc_method_create(method_name, invoke, user_data);
method->next = server->methods;
server->methods = method;
}
static void wf_impl_jsonrpc_server_invalid_method_invoke(
struct wf_impl_jsonrpc_request * request,
char const * WF_UNUSED_PARAM(method_name),
json_t * WF_UNUSED_PARAM(params),
void * WF_UNUSED_PARAM(user_data))
{
wf_impl_jsonrpc_respond_error(request, WF_BAD_NOTIMPLEMENTED);
}
static struct wf_impl_jsonrpc_method const wf_impl_jsonrpc_server_invalid_method =
{
.next = NULL,
.name = "<invalid>",
.invoke = &wf_impl_jsonrpc_server_invalid_method_invoke,
.user_data = NULL
};
static struct wf_impl_jsonrpc_method const * wf_impl_jsonrpc_server_get_method(
struct wf_impl_jsonrpc_server * server,
char const * method_name)
{
struct wf_impl_jsonrpc_method const * current = server->methods;
while (NULL != current)
{
if (0 == strcmp(method_name, current->name))
{
return current;
}
current = current->next;
}
return &wf_impl_jsonrpc_server_invalid_method;
}
void wf_impl_jsonrpc_server_process(
struct wf_impl_jsonrpc_server * server,
json_t * request_data,
wf_impl_jsonrpc_send_fn * send,
void * user_data)
{
json_t * method_holder = json_object_get(request_data, "method");
json_t * params = json_object_get(request_data, "params");
json_t * id_holder = json_object_get(request_data, "id");
if (json_is_string(method_holder) &&
(json_is_array(params) || (json_is_object(params))) &&
json_is_integer(id_holder))
{
char const * method_name = json_string_value(method_holder);
int id = json_integer_value(id_holder);
struct wf_impl_jsonrpc_request * request = wf_impl_jsonrpc_request_create(id, send, user_data);
struct wf_impl_jsonrpc_method const * method = wf_impl_jsonrpc_server_get_method(server, method_name);
method->invoke(request, method_name, params, method->user_data);
}
}

48
lib/webfuse/adapter/impl/jsonrpc/server.h
View File

@@ -1,48 +0,0 @@
#ifndef WF_ADAPTER_IMPL_JSONRPC_SERVER_H
#define WF_ADAPTER_IMPL_JSONRPC_SERVER_H
#ifndef __cplusplus
#include <stdarg.h>
#include <stdbool.h>
#else
#include <cstdarg>
#endif
#include <jansson.h>
#include "webfuse/core/status.h"
#include "webfuse/adapter/impl/jsonrpc/send_fn.h"
#include "webfuse/adapter/impl/jsonrpc/method.h"
#ifdef __cplusplus
extern "C"
{
#endif
struct wf_impl_jsonrpc_server
{
struct wf_impl_jsonrpc_method * methods;
};
extern void wf_impl_jsonrpc_server_init(
struct wf_impl_jsonrpc_server * server);
extern void wf_impl_jsonrpc_server_cleanup(
struct wf_impl_jsonrpc_server * server);
extern void wf_impl_jsonrpc_server_add(
struct wf_impl_jsonrpc_server * server,
char const * method_name,
wf_impl_jsonrpc_method_invoke_fn * invoke,
void * user_data);
extern void wf_impl_jsonrpc_server_process(
struct wf_impl_jsonrpc_server * server,
json_t * request,
wf_impl_jsonrpc_send_fn * send,
void * user_data);
#ifdef __cplusplus
}
#endif
#endif

14
lib/webfuse/adapter/impl/jsonrpc/util.c
View File

@@ -1,14 +0,0 @@
#include "webfuse/adapter/impl/jsonrpc/util.h"
int wf_impl_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;
}

17
lib/webfuse/adapter/impl/jsonrpc/util.h
View File

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

6
lib/webfuse/adapter/impl/operation/close.c
View File

@@ -4,7 +4,7 @@
#include <errno.h>
#include <jansson.h>
#include "webfuse/adapter/impl/jsonrpc/proxy.h"
#include "jsonrpc/proxy.h"
#include "webfuse/core/util.h"
void wf_impl_operation_close(
@@ -13,12 +13,12 @@ void wf_impl_operation_close(
struct fuse_file_info * file_info)
{
struct wf_impl_operations_context * user_data = fuse_req_userdata(request);
struct wf_impl_jsonrpc_proxy * rpc = wf_impl_operations_context_get_proxy(user_data);
struct jsonrpc_proxy * rpc = wf_impl_operations_context_get_proxy(user_data);
if (NULL != rpc)
{
int handle = (int) (file_info->fh & INT_MAX);
wf_impl_jsonrpc_proxy_notify(rpc, "close", "siii", user_data->name, inode, handle, file_info->flags);
jsonrpc_proxy_notify(rpc, "close", "siii", user_data->name, inode, handle, file_info->flags);
}
fuse_reply_err(request, 0);

27
lib/webfuse/adapter/impl/operation/getattr.c
View File

@@ -7,8 +7,8 @@
#include <sys/stat.h>
#include <unistd.h>
#include "webfuse/adapter/impl/jsonrpc/proxy.h"
#include "webfuse/adapter/impl/jsonrpc/util.h"
#include "jsonrpc/proxy.h"
#include "webfuse/core/json_util.h"
#include "webfuse/core/util.h"
struct wf_impl_operation_getattr_context
@@ -22,16 +22,17 @@ struct wf_impl_operation_getattr_context
static void wf_impl_operation_getattr_finished(
void * user_data,
wf_status status,
json_t const * data)
json_t const * result,
json_t const * error)
{
wf_status status = wf_impl_jsonrpc_get_status(error);
struct wf_impl_operation_getattr_context * context = user_data;
struct stat buffer;
if (NULL != data)
if (NULL != result)
{
json_t * mode_holder = json_object_get(data, "mode");
json_t * type_holder = json_object_get(data, "type");
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)) &&
(NULL != type_holder) && (json_is_string(type_holder)))
{
@@ -52,10 +53,10 @@ static void wf_impl_operation_getattr_finished(
buffer.st_uid = context->uid;
buffer.st_gid = context->gid;
buffer.st_nlink = 1;
buffer.st_size = wf_impl_json_get_int(data, "size", 0);
buffer.st_atime = wf_impl_json_get_int(data, "atime", 0);
buffer.st_mtime = wf_impl_json_get_int(data, "mtime", 0);
buffer.st_ctime = wf_impl_json_get_int(data, "ctime", 0);
buffer.st_size = wf_impl_json_get_int(result, "size", 0);
buffer.st_atime = wf_impl_json_get_int(result, "atime", 0);
buffer.st_mtime = wf_impl_json_get_int(result, "mtime", 0);
buffer.st_ctime = wf_impl_json_get_int(result, "ctime", 0);
}
else
{
@@ -82,7 +83,7 @@ void wf_impl_operation_getattr (
{
struct fuse_ctx const * context = fuse_req_ctx(request);
struct wf_impl_operations_context * user_data = fuse_req_userdata(request);
struct wf_impl_jsonrpc_proxy * rpc = wf_impl_operations_context_get_proxy(user_data);
struct jsonrpc_proxy * rpc = wf_impl_operations_context_get_proxy(user_data);
if (NULL != rpc)
{
@@ -93,7 +94,7 @@ void wf_impl_operation_getattr (
getattr_context->gid = context->gid;
getattr_context->timeout = user_data->timeout;
wf_impl_jsonrpc_proxy_invoke(rpc, &wf_impl_operation_getattr_finished, getattr_context, "getattr", "si", user_data->name, inode);
jsonrpc_proxy_invoke(rpc, &wf_impl_operation_getattr_finished, getattr_context, "getattr", "si", user_data->name, inode);
}
else
{

29
lib/webfuse/adapter/impl/operation/lookup.c
View File

@@ -10,8 +10,8 @@
#include <stdlib.h>
#include "webfuse/adapter/impl/jsonrpc/proxy.h"
#include "webfuse/adapter/impl/jsonrpc/util.h"
#include "jsonrpc/proxy.h"
#include "webfuse/core/json_util.h"
#include "webfuse/core/util.h"
struct wf_impl_operation_lookup_context
@@ -24,18 +24,19 @@ struct wf_impl_operation_lookup_context
static void wf_impl_operation_lookup_finished(
void * user_data,
wf_status status,
json_t const * data
json_t const * result,
json_t const * error
)
{
wf_status status = wf_impl_jsonrpc_get_status(error);
struct wf_impl_operation_lookup_context * context = user_data;
struct fuse_entry_param buffer;
if (NULL != data)
if (NULL != result)
{
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");
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)) &&
(NULL != mode_holder) && (json_is_integer(mode_holder)) &&
(NULL != type_holder) && (json_is_string(type_holder)))
@@ -61,10 +62,10 @@ static void wf_impl_operation_lookup_finished(
buffer.attr.st_uid = context->uid;
buffer.attr.st_gid = context->gid;
buffer.attr.st_nlink = 1;
buffer.attr.st_size = wf_impl_json_get_int(data, "size", 0);
buffer.attr.st_atime = wf_impl_json_get_int(data, "atime", 0);
buffer.attr.st_mtime = wf_impl_json_get_int(data, "mtime", 0);
buffer.attr.st_ctime = wf_impl_json_get_int(data, "ctime", 0);
buffer.attr.st_size = wf_impl_json_get_int(result, "size", 0);
buffer.attr.st_atime = wf_impl_json_get_int(result, "atime", 0);
buffer.attr.st_mtime = wf_impl_json_get_int(result, "mtime", 0);
buffer.attr.st_ctime = wf_impl_json_get_int(result, "ctime", 0);
}
else
{
@@ -91,7 +92,7 @@ void wf_impl_operation_lookup (
{
struct fuse_ctx const * context = fuse_req_ctx(request);
struct wf_impl_operations_context * user_data = fuse_req_userdata(request);
struct wf_impl_jsonrpc_proxy * rpc = wf_impl_operations_context_get_proxy(user_data);
struct jsonrpc_proxy * rpc = wf_impl_operations_context_get_proxy(user_data);
if (NULL != rpc)
{
@@ -101,7 +102,7 @@ void wf_impl_operation_lookup (
lookup_context->gid = context->gid;
lookup_context->timeout = user_data->timeout;
wf_impl_jsonrpc_proxy_invoke(rpc, &wf_impl_operation_lookup_finished, lookup_context, "lookup", "sis", user_data->name, (int) (parent & INT_MAX), name);
jsonrpc_proxy_invoke(rpc, &wf_impl_operation_lookup_finished, lookup_context, "lookup", "sis", user_data->name, (int) (parent & INT_MAX), name);
}
else
{

12
lib/webfuse/adapter/impl/operation/open.c
View File

@@ -4,15 +4,17 @@
#include <errno.h>
#include <jansson.h>
#include "webfuse/adapter/impl/jsonrpc/proxy.h"
#include "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(
void * user_data,
wf_status status,
json_t const * result)
json_t const * result,
json_t const * error)
{
wf_status status = wf_impl_jsonrpc_get_status(error);
fuse_req_t request = user_data;
struct fuse_file_info file_info;
memset(&file_info, 0, sizeof(struct fuse_file_info));
@@ -47,11 +49,11 @@ void wf_impl_operation_open(
struct fuse_file_info * file_info)
{
struct wf_impl_operations_context * user_data = fuse_req_userdata(request);
struct wf_impl_jsonrpc_proxy * rpc = wf_impl_operations_context_get_proxy(user_data);
struct jsonrpc_proxy * rpc = wf_impl_operations_context_get_proxy(user_data);
if (NULL != rpc)
{
wf_impl_jsonrpc_proxy_invoke(rpc, &wf_impl_operation_open_finished, request, "open", "sii", user_data->name, inode, file_info->flags);
jsonrpc_proxy_invoke(rpc, &wf_impl_operation_open_finished, request, "open", "sii", user_data->name, inode, file_info->flags);
}
else
{

21
lib/webfuse/adapter/impl/operation/read.c
View File

@@ -5,8 +5,9 @@
#include <limits.h>
#include <jansson.h>
#include "webfuse/adapter/impl/jsonrpc/proxy.h"
#include "jsonrpc/proxy.h"
#include "webfuse/core/base64.h"
#include "webfuse/core/json_util.h"
#define WF_MAX_READ_LENGTH 4096
@@ -38,17 +39,21 @@ static char * wf_impl_fill_buffer(
return buffer;
}
static void wf_impl_operation_read_finished(void * user_data, wf_status status, json_t const * data)
static void wf_impl_operation_read_finished(
void * user_data,
json_t const * result,
json_t const * error)
{
wf_status status = wf_impl_jsonrpc_get_status(error);
fuse_req_t request = user_data;
char * buffer = NULL;
size_t length = 0;
if (NULL != data)
if (NULL != result)
{
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");
json_t * data_holder = json_object_get(result, "data");
json_t * format_holder = json_object_get(result, "format");
json_t * count_holder = json_object_get(result, "count");
if (json_is_string(data_holder) &&
json_is_string(format_holder) &&
@@ -87,13 +92,13 @@ void wf_impl_operation_read(
struct fuse_file_info * file_info)
{
struct wf_impl_operations_context * user_data = fuse_req_userdata(request);
struct wf_impl_jsonrpc_proxy * rpc = wf_impl_operations_context_get_proxy(user_data);
struct jsonrpc_proxy * rpc = wf_impl_operations_context_get_proxy(user_data);
if (NULL != rpc)
{
int const length = (size <= WF_MAX_READ_LENGTH) ? (int) size : WF_MAX_READ_LENGTH;
int handle = (file_info->fh & INT_MAX);
wf_impl_jsonrpc_proxy_invoke(rpc, &wf_impl_operation_read_finished, request, "read", "siiii", user_data->name, (int) inode, handle, (int) offset, length);
jsonrpc_proxy_invoke(rpc, &wf_impl_operation_read_finished, request, "read", "siiii", user_data->name, (int) inode, handle, (int) offset, length);
}
else
{

12
lib/webfuse/adapter/impl/operation/readdir.c
View File

@@ -8,8 +8,9 @@
#include <sys/stat.h>
#include <unistd.h>
#include "webfuse/adapter/impl/jsonrpc/proxy.h"
#include "jsonrpc/proxy.h"
#include "webfuse/core/util.h"
#include "webfuse/core/json_util.h"
#define WF_DIRBUFFER_INITIAL_SIZE 1024
@@ -73,9 +74,10 @@ static size_t wf_impl_min(size_t a, size_t b)
static void wf_impl_operation_readdir_finished(
void * user_data,
wf_status status,
json_t const * result)
json_t const * result,
json_t const * error)
{
wf_status status = wf_impl_jsonrpc_get_status(error);
struct wf_impl_operation_readdir_context * context = user_data;
struct wf_impl_dirbuffer buffer;
@@ -137,7 +139,7 @@ void wf_impl_operation_readdir (
struct fuse_file_info * WF_UNUSED_PARAM(file_info))
{
struct wf_impl_operations_context * user_data = fuse_req_userdata(request);
struct wf_impl_jsonrpc_proxy * rpc = wf_impl_operations_context_get_proxy(user_data);
struct jsonrpc_proxy * rpc = wf_impl_operations_context_get_proxy(user_data);
if (NULL != rpc)
{
@@ -146,7 +148,7 @@ void wf_impl_operation_readdir (
readdir_context->size = size;
readdir_context->offset = offset;
wf_impl_jsonrpc_proxy_invoke(rpc, &wf_impl_operation_readdir_finished, readdir_context, "readdir", "si", user_data->name, inode);
jsonrpc_proxy_invoke(rpc, &wf_impl_operation_readdir_finished, readdir_context, "readdir", "si", user_data->name, inode);
}
else
{

4
lib/webfuse/adapter/impl/operations.c
View File

@@ -3,10 +3,10 @@
#include "webfuse/adapter/impl/session.h"
#include <stddef.h>
struct wf_impl_jsonrpc_proxy * wf_impl_operations_context_get_proxy(
struct jsonrpc_proxy * wf_impl_operations_context_get_proxy(
struct wf_impl_operations_context * context)
{
struct wf_impl_jsonrpc_proxy * proxy = NULL;
struct jsonrpc_proxy * proxy = NULL;
struct wf_impl_session * session = context->session;
if (NULL != session)

4
lib/webfuse/adapter/impl/operations.h
View File

@@ -8,7 +8,7 @@ extern "C" {
#endif
struct wf_impl_session;
struct wf_impl_jsonrpc_proxy;
struct jsonrpc_proxy;
struct wf_impl_operations_context
{
@@ -49,7 +49,7 @@ extern void wf_impl_operation_read(
fuse_ino_t ino, size_t size, off_t off,
struct fuse_file_info *fi);
extern struct wf_impl_jsonrpc_proxy * wf_impl_operations_context_get_proxy(
extern struct jsonrpc_proxy * wf_impl_operations_context_get_proxy(
struct wf_impl_operations_context * context);
#ifdef __cplusplus

26
lib/webfuse/adapter/impl/server_protocol.c
View File

@@ -9,7 +9,7 @@
#include "webfuse/core/protocol_names.h"
#include "webfuse/adapter/impl/credentials.h"
#include "webfuse/adapter/impl/jsonrpc/request.h"
#include "jsonrpc/request.h"
#include "webfuse/adapter/impl/uuid_mountpoint_factory.h"
static int wf_impl_server_protocol_callback(
@@ -129,7 +129,7 @@ void wf_impl_server_protocol_init_lws(
}
static void wf_impl_server_protocol_authenticate(
struct wf_impl_jsonrpc_request * request,
struct jsonrpc_request * request,
char const * WF_UNUSED_PARAM(method_name),
json_t * params,
void * WF_UNUSED_PARAM(user_data))
@@ -145,7 +145,7 @@ static void wf_impl_server_protocol_authenticate(
struct wf_credentials creds;
wf_impl_credentials_init(&creds, type, creds_holder);
struct wf_impl_session * session = wf_impl_jsonrpc_request_get_userdata(request);
struct wf_impl_session * session = jsonrpc_request_get_userdata(request);
result = wf_impl_session_authenticate(session, &creds);
wf_impl_credentials_cleanup(&creds);
@@ -155,11 +155,11 @@ static void wf_impl_server_protocol_authenticate(
if (result)
{
json_t * result = json_object();
wf_impl_jsonrpc_respond(request, result);
jsonrpc_respond(request, result);
}
else
{
wf_impl_jsonrpc_respond_error(request, WF_BAD_ACCESS_DENIED);
jsonrpc_respond_error(request, WF_BAD_ACCESS_DENIED);
}
}
@@ -179,12 +179,12 @@ static bool wf_impl_server_protocol_check_name(char const * value)
}
static void wf_impl_server_protocol_add_filesystem(
struct wf_impl_jsonrpc_request * request,
struct jsonrpc_request * request,
char const * WF_UNUSED_PARAM(method_name),
json_t * params,
void * WF_UNUSED_PARAM(user_data))
{
struct wf_impl_session * session = wf_impl_jsonrpc_request_get_userdata(request);
struct wf_impl_session * session = jsonrpc_request_get_userdata(request);
wf_status status = (session->is_authenticated) ? WF_GOOD : WF_BAD_ACCESS_DENIED;
char const * name = NULL;
@@ -218,11 +218,11 @@ static void wf_impl_server_protocol_add_filesystem(
{
json_t * result = json_object();
json_object_set_new(result, "id", json_string(name));
wf_impl_jsonrpc_respond(request, result);
jsonrpc_respond(request, result);
}
else
{
wf_impl_jsonrpc_respond_error(request, status);
jsonrpc_respond_error(request, status);
}
@@ -240,9 +240,9 @@ void wf_impl_server_protocol_init(
wf_impl_session_manager_init(&protocol->session_manager);
wf_impl_authenticators_init(&protocol->authenticators);
wf_impl_jsonrpc_server_init(&protocol->server);
wf_impl_jsonrpc_server_add(&protocol->server, "authenticate", &wf_impl_server_protocol_authenticate, protocol);
wf_impl_jsonrpc_server_add(&protocol->server, "add_filesystem", &wf_impl_server_protocol_add_filesystem, protocol);
jsonrpc_server_init(&protocol->server);
jsonrpc_server_add(&protocol->server, "authenticate", &wf_impl_server_protocol_authenticate, protocol);
jsonrpc_server_add(&protocol->server, "add_filesystem", &wf_impl_server_protocol_add_filesystem, protocol);
}
void wf_impl_server_protocol_cleanup(
@@ -250,7 +250,7 @@ void wf_impl_server_protocol_cleanup(
{
protocol->is_operational = false;
wf_impl_jsonrpc_server_cleanup(&protocol->server);
jsonrpc_server_cleanup(&protocol->server);
wf_impl_timeout_manager_cleanup(&protocol->timeout_manager);
wf_impl_authenticators_cleanup(&protocol->authenticators);
wf_impl_session_manager_cleanup(&protocol->session_manager);

6
lib/webfuse/adapter/impl/server_protocol.h
View File

@@ -1,12 +1,12 @@
#ifndef WF_ADAPTER_IMPL_SERVER_PROTOCOL_H
#define WF_ADAPTER_IMPL_SERVER_PROTOCOL_H
#include "webfuse/adapter/impl/jsonrpc/proxy.h"
#include "jsonrpc/proxy.h"
#include "webfuse/adapter/impl/time/timeout_manager.h"
#include "webfuse/adapter/impl/authenticators.h"
#include "webfuse/adapter/impl/mountpoint_factory.h"
#include "webfuse/adapter/impl/session_manager.h"
#include "webfuse/adapter/impl/jsonrpc/server.h"
#include "jsonrpc/server.h"
#ifndef __cplusplus
#include <stdbool.h>
@@ -25,7 +25,7 @@ struct wf_server_protocol
struct wf_impl_authenticators authenticators;
struct wf_impl_mountpoint_factory mountpoint_factory;
struct wf_impl_session_manager session_manager;
struct wf_impl_jsonrpc_server server;
struct jsonrpc_server server;
bool is_operational;
};

22
lib/webfuse/adapter/impl/session.c
View File

@@ -2,9 +2,9 @@
#include "webfuse/adapter/impl/authenticators.h"
#include "webfuse/core/message_queue.h"
#include "webfuse/core/message.h"
#include "webfuse/adapter/impl/jsonrpc/proxy.h"
#include "webfuse/adapter/impl/jsonrpc/request.h"
#include "webfuse/adapter/impl/jsonrpc/response.h"
#include "jsonrpc/proxy.h"
#include "jsonrpc/request.h"
#include "jsonrpc/response.h"
#include "webfuse/adapter/impl/mountpoint_factory.h"
#include "webfuse/adapter/impl/mountpoint.h"
@@ -24,7 +24,7 @@ static bool wf_impl_session_send(
struct wf_impl_session * session = user_data;
struct wf_message * message = wf_message_create(request);
bool result = (session->is_authenticated || wf_impl_jsonrpc_is_response(request)) && (NULL != session->wsi);
bool result = (session->is_authenticated || jsonrpc_is_response(request)) && (NULL != session->wsi);
if (result)
{
@@ -45,7 +45,7 @@ struct wf_impl_session * wf_impl_session_create(
struct lws * wsi,
struct wf_impl_authenticators * authenticators,
struct wf_impl_timeout_manager * timeout_manager,
struct wf_impl_jsonrpc_server * server,
struct jsonrpc_server * server,
struct wf_impl_mountpoint_factory * mountpoint_factory)
{
@@ -59,7 +59,7 @@ struct wf_impl_session * wf_impl_session_create(
session->authenticators = authenticators;
session->server = server;
session->mountpoint_factory = mountpoint_factory;
wf_impl_jsonrpc_proxy_init(&session->rpc, timeout_manager, WF_DEFAULT_TIMEOUT, &wf_impl_session_send, session);
jsonrpc_proxy_init(&session->rpc, timeout_manager, WF_DEFAULT_TIMEOUT, &wf_impl_session_send, session);
wf_slist_init(&session->messages);
}
@@ -83,7 +83,7 @@ static void wf_impl_session_dispose_filesystems(
void wf_impl_session_dispose(
struct wf_impl_session * session)
{
wf_impl_jsonrpc_proxy_cleanup(&session->rpc);
jsonrpc_proxy_cleanup(&session->rpc);
wf_message_queue_cleanup(&session->messages);
wf_impl_session_dispose_filesystems(&session->filesystems);
@@ -159,13 +159,13 @@ void wf_impl_session_receive(
json_t * message = json_loadb(data, length, 0, NULL);
if (NULL != message)
{
if (wf_impl_jsonrpc_is_response(message))
if (jsonrpc_is_response(message))
{
wf_impl_jsonrpc_proxy_onresult(&session->rpc, message);
jsonrpc_proxy_onresult(&session->rpc, message);
}
else if (wf_impl_jsonrpc_is_request(message))
else if (jsonrpc_is_request(message))
{
wf_impl_jsonrpc_server_process(session->server, message, &wf_impl_session_send, session);
jsonrpc_server_process(session->server, message, &wf_impl_session_send, session);
}
json_decref(message);

10
lib/webfuse/adapter/impl/session.h
View File

@@ -10,8 +10,8 @@ using std::size_t;
#endif
#include "webfuse/core/message_queue.h"
#include "webfuse/adapter/impl/jsonrpc/proxy.h"
#include "webfuse/adapter/impl/jsonrpc/server.h"
#include "jsonrpc/proxy.h"
#include "jsonrpc/server.h"
#include "webfuse/adapter/impl/filesystem.h"
#include "webfuse/core/slist.h"
@@ -35,8 +35,8 @@ struct wf_impl_session
struct wf_slist messages;
struct wf_impl_authenticators * authenticators;
struct wf_impl_mountpoint_factory * mountpoint_factory;
struct wf_impl_jsonrpc_server * server;
struct wf_impl_jsonrpc_proxy rpc;
struct jsonrpc_server * server;
struct jsonrpc_proxy rpc;
struct wf_slist filesystems;
};
@@ -44,7 +44,7 @@ extern struct wf_impl_session * wf_impl_session_create(
struct lws * wsi,
struct wf_impl_authenticators * authenticators,
struct wf_impl_timeout_manager * timeout_manager,
struct wf_impl_jsonrpc_server * server,
struct jsonrpc_server * server,
struct wf_impl_mountpoint_factory * mountpoint_factory);
extern void wf_impl_session_dispose(

2
lib/webfuse/adapter/impl/session_manager.c
View File

@@ -29,7 +29,7 @@ struct wf_impl_session * wf_impl_session_manager_add(
struct wf_impl_authenticators * authenticators,
struct wf_impl_mountpoint_factory * mountpoint_factory,
struct wf_impl_timeout_manager * timeout_manager,
struct wf_impl_jsonrpc_server * server)
struct jsonrpc_server * server)
{
struct wf_impl_session * session = wf_impl_session_create(
wsi, authenticators, timeout_manager, server, mountpoint_factory);

4
lib/webfuse/adapter/impl/session_manager.h
View File

@@ -16,7 +16,7 @@ extern "C"
struct lws;
struct wf_impl_timeout_manager;
struct wf_impl_jsonrpc_server;
struct jsonrpc_server;
struct wf_impl_session_manager
{
@@ -35,7 +35,7 @@ extern struct wf_impl_session * wf_impl_session_manager_add(
struct wf_impl_authenticators * authenticators,
struct wf_impl_mountpoint_factory * mountpoint_factory,
struct wf_impl_timeout_manager * timeout_manager,
struct wf_impl_jsonrpc_server * server);
struct jsonrpc_server * server);
extern struct wf_impl_session * wf_impl_session_manager_get(
struct wf_impl_session_manager * manager,

48
lib/webfuse/core/json_util.c Normal file
View File

@@ -0,0 +1,48 @@
#include "webfuse/core/json_util.h"
#include "jsonrpc/status.h"
int wf_impl_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;
}
static wf_status wf_impl_jsonrc_code_to_status(int code)
{
switch (code)
{
case JSONRPC_GOOD:
return WF_GOOD;
case JSONRPC_BAD:
return WF_BAD;
case JSONRPC_BAD_BUSY:
return WF_BAD_BUSY;
case JSONRPC_BAD_TIMEOUT:
return WF_BAD_TIMEOUT;
case JSONRPC_BAD_FORMAT:
return WF_BAD_FORMAT;
default:
return (wf_status) code;
}
}
wf_status
wf_impl_jsonrpc_get_status(
json_t const * error)
{
wf_status status = WF_GOOD;
if (NULL != error)
{
int code = wf_impl_json_get_int(error, "code", WF_BAD_FORMAT);
status = wf_impl_jsonrc_code_to_status(code);
}
return status;
}

26
lib/webfuse/core/json_util.h Normal file
View File

@@ -0,0 +1,26 @@
#ifndef WF_JSON_UTIL_H
#define WF_JSON_UTIL_H
#include <jansson.h>
#include "webfuse/core/status.h"
#ifdef __cplusplus
extern "C"
{
#endif
extern int
wf_impl_json_get_int(
json_t const * object,
char const * key,
int default_value);
extern wf_status
wf_impl_jsonrpc_get_status(
json_t const * error);
#ifdef __cplusplus
}
#endif
#endif