project structure changed

lib/wsfs/jsonrpc/method.c

@@ -0,0 +1,28 @@
+#include "wsfs/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/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/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/jsonrpc/method_intern.h

@@ -0,0 +1,31 @@
+#ifndef _WSFS_JSONRPC_METHOD_INTERN_H
+#define _WSFS_JSONRPC_METHOD_INTERN_H
+
+#include "wsfs/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/jsonrpc/request.c

@@ -0,0 +1,44 @@
+#include "wsfs/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/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/jsonrpc/response.c

@@ -0,0 +1,59 @@
+#include "wsfs/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/jsonrpc/response.h

@@ -0,0 +1,38 @@
+#ifndef _WSFS_JSONRPC_RESPONSE_H
+#define _WFSF_JSONRPC_RESPONSE_H
+
+#ifndef __cplusplus
+#include <stddef.h>
+#else
+#include <cstddef>
+using std::size_t;
+#endif
+
+#include <jansson.h>
+#include "wsfs/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/jsonrpc/server.c

@@ -0,0 +1,186 @@
+#include "wsfs/jsonrpc/server.h"
+#include <string.h>
+
+#include "wsfs/jsonrpc/method_intern.h"
+#include "wsfs/jsonrpc/request.h"
+#include "wsfs/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/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/jsonrpc/method.h"
+#include "wsfs/time/timeout_manager.h"
+#include "wsfs/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/jsonrpc/util.c

@@ -0,0 +1,14 @@
+#include "wsfs/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/jsonrpc/util.h

@@ -0,0 +1,17 @@
+#ifndef _WSFS_JSON_UTIL_H
+#define _WFSF_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