chore: prefixed jsonrpc by wf_

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

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

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

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

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

@@ -0,0 +1,26 @@
+#ifndef WF_JSONRPC_METHOD_INVOKE_FN_H
+#define WF_JSONRPC_METHOD_INVOKE_FN_H
+
+#include <wf/jsonrpc/api.h>
+#include <jansson.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+struct wf_jsonrpc_request;
+
+typedef void wf_jsonrpc_method_invoke_fn(
+    struct wf_jsonrpc_request * request,
+    char const * method_name,
+    json_t * params,
+    void * user_data);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif

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

@@ -0,0 +1,75 @@
+#ifndef WF_JSONRPC_PROXY_H
+#define WF_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 <wf/jsonrpc/api.h>
+#include <wf/jsonrpc/send_fn.h>
+#include <wf/jsonrpc/proxy_finished_fn.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct wf_jsonrpc_proxy;
+struct wf_timer_manager;
+
+extern WF_JSONRPC_API struct wf_jsonrpc_proxy *
+wf_jsonrpc_proxy_create(
+    struct wf_timer_manager * manager,
+    int timeout,
+    wf_jsonrpc_send_fn * send,
+    void * user_data);
+
+extern WF_JSONRPC_API void wf_jsonrpc_proxy_dispose(
+    struct wf_jsonrpc_proxy * proxy);
+
+//------------------------------------------------------------------------------
+/// \brief Invokes a method.
+///
+/// Creates a method an sends it using the send function.
+/// Proxy keeps track of method invokation. If no response is returned within
+/// timeout, an error is propagated.
+///
+/// \param proxy pointer to proxy instance
+/// \param finished function which is called exactly once, either on success or
+///                 on failure.
+/// \param method_name name of the method to invoke
+/// \param param_info types of the param (s = string, i = integer, j = json)
+/// \param ... params
+//------------------------------------------------------------------------------
+extern WF_JSONRPC_API void wf_jsonrpc_proxy_invoke(
+	struct wf_jsonrpc_proxy * proxy,
+	wf_jsonrpc_proxy_finished_fn * finished,
+	void * user_data,
+	char const * method_name,
+	char const * param_info,
+	...
+);
+
+extern WF_JSONRPC_API void wf_jsonrpc_proxy_notify(
+	struct wf_jsonrpc_proxy * proxy,
+	char const * method_name,
+	char const * param_info,
+	...
+);
+
+extern WF_JSONRPC_API void wf_jsonrpc_proxy_onresult(
+    struct wf_jsonrpc_proxy * proxy,
+    json_t * message);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif

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

@@ -0,0 +1,20 @@
+#ifndef WF_JSONRPC_PROXY_FINISHED_FN_H
+#define WF_JSONRPC_PROXY_FINISHED_FN_H
+
+#include <jansson.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+typedef void wf_jsonrpc_proxy_finished_fn(
+	void * user_data,
+	json_t const * result,
+    json_t const * error);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

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

@@ -0,0 +1,54 @@
+#ifndef WF_JSONRPC_REQUEST_H
+#define WF_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 <wf/jsonrpc/api.h>
+#include "wf/jsonrpc/send_fn.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+struct wf_jsonrpc_request;
+
+extern WF_JSONRPC_API bool wf_jsonrpc_is_request(
+    json_t * message);
+
+extern WF_JSONRPC_API struct wf_jsonrpc_request *
+wf_jsonrpc_request_create(
+    int id,
+    wf_jsonrpc_send_fn * send,
+    void * user_data);
+
+extern WF_JSONRPC_API void wf_jsonrpc_request_dispose(
+    struct wf_jsonrpc_request * request);
+
+extern WF_JSONRPC_API void * wf_jsonrpc_request_get_userdata(
+    struct wf_jsonrpc_request * request);
+
+extern WF_JSONRPC_API void wf_jsonrpc_respond(
+    struct wf_jsonrpc_request * request,
+    json_t * result);
+
+extern WF_JSONRPC_API void wf_jsonrpc_respond_error(
+    struct wf_jsonrpc_request * request,
+    int code,
+    char const * message);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

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

@@ -0,0 +1,23 @@
+#ifndef WF_JSONRPC_RESPONSE_H
+#define WF_JSONRPC_RESPONSE_H
+
+#ifndef __cplusplus
+#include <stdbool.h>
+#endif
+
+#include <jansson.h>
+#include <wf/jsonrpc/api.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+extern WF_JSONRPC_API bool wf_jsonrpc_is_response(
+    json_t * message);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

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

@@ -0,0 +1,24 @@
+#ifndef WF_JSONRPC_SEND_FN_H
+#define WF_JSONRPC_SEND_FN_H
+
+#ifndef __cplusplus
+#include <stdbool.h>
+#endif
+
+#include <jansson.h>
+#include <wf/jsonrpc/api.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+typedef bool wf_jsonrpc_send_fn(
+	json_t * request,
+    void * user_data);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

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

@@ -0,0 +1,46 @@
+#ifndef WF_JSONRPC_SERVER_H
+#define WF_JSONRPC_SERVER_H
+
+#ifndef __cplusplus
+#include <stdarg.h>
+#include <stdbool.h>
+#else
+#include <cstdarg>
+#endif
+
+#include <jansson.h>
+#include <wf/jsonrpc/api.h>
+#include <wf/jsonrpc/send_fn.h>
+#include <wf/jsonrpc/method_invoke_fn.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+struct wf_jsonrpc_server;
+
+extern WF_JSONRPC_API struct wf_jsonrpc_server *
+wf_jsonrpc_server_create(void);
+
+extern WF_JSONRPC_API void
+wf_jsonrpc_server_dispose(
+    struct wf_jsonrpc_server * server);
+
+extern WF_JSONRPC_API void wf_jsonrpc_server_add(
+    struct wf_jsonrpc_server * server,
+    char const * method_name,
+    wf_jsonrpc_method_invoke_fn * invoke,
+    void * user_data);
+
+extern WF_JSONRPC_API void wf_jsonrpc_server_process(
+    struct wf_jsonrpc_server * server,
+    json_t * request,
+    wf_jsonrpc_send_fn * send,
+    void * user_data);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

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

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

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

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

lib/wf/jsonrpc/src/wf/jsonrpc/impl/error.c

@@ -0,0 +1,27 @@
+#include "wf/jsonrpc/impl/error.h"
+
+json_t *
+wf_jsonrpc_impl_error(
+    int code,
+    char const * message)
+{
+    json_t * error = json_object();
+    json_object_set_new(error, "code", json_integer(code));
+    json_object_set_new(error, "message", json_string(message));
+
+    return error;
+}
+
+void
+wf_jsonrpc_impl_propate_error(
+    wf_jsonrpc_proxy_finished_fn * finised,
+    void * user_data,
+    int code,
+    char const * message)
+{
+    json_t * error = wf_jsonrpc_impl_error(code, message);
+    finised(user_data, NULL, error);
+
+    json_decref(error);
+}
+

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

@@ -0,0 +1,29 @@
+#ifndef WF_JSONRPC_IMPL_ERROR_H
+#define WF_JSONRPC_IMPL_ERROR_H
+
+#include <jansson.h>
+#include "wf/jsonrpc/proxy_finished_fn.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+extern json_t *
+wf_jsonrpc_impl_error(
+    int code,
+    char const * message);
+
+extern void
+wf_jsonrpc_impl_propate_error(
+    wf_jsonrpc_proxy_finished_fn * finised,
+    void * user_data,
+    int code,
+    char const * message);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif

lib/wf/jsonrpc/src/wf/jsonrpc/impl/method.c

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

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

@@ -0,0 +1,34 @@
+#ifndef WF_JSONRPC_IMPL_METHOD_H
+#define WF_JSONRPC_IMPL_METHOD_H
+
+#include "wf/jsonrpc/method_invoke_fn.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+struct wf_jsonrpc_method
+{
+    struct wf_jsonrpc_method * next;
+    char * name;
+    wf_jsonrpc_method_invoke_fn * invoke;
+    void * user_data;
+};
+
+extern struct wf_jsonrpc_method *
+wf_jsonrpc_impl_method_create(
+    char const * method_name,
+    wf_jsonrpc_method_invoke_fn * invoke,
+    void * user_data);
+
+extern void
+wf_jsonrpc_impl_method_dispose(
+    struct wf_jsonrpc_method * method);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif

lib/wf/jsonrpc/src/wf/jsonrpc/impl/proxy.c

@@ -0,0 +1,220 @@
+#include "wf/jsonrpc/impl/proxy.h"
+#include "wf/jsonrpc/impl/response.h"
+#include "wf/jsonrpc/impl/error.h"
+#include "wf/jsonrpc/status.h"
+
+#include <wf/timer/timer.h>
+
+#include <stdlib.h>
+#include <string.h>
+
+struct wf_jsonrpc_proxy *
+wf_jsonrpc_impl_proxy_create(
+    struct wf_timer_manager * manager,
+    int timeout,
+    wf_jsonrpc_send_fn * send,
+    void * user_data)
+{
+    struct wf_jsonrpc_proxy * proxy = malloc(sizeof(struct wf_jsonrpc_proxy));
+    if (NULL != proxy)
+    {
+        wf_jsonrpc_impl_proxy_init(proxy, manager, timeout, send, user_data);
+    }
+
+    return proxy;
+}
+
+void wf_jsonrpc_impl_proxy_dispose(
+    struct wf_jsonrpc_proxy * proxy)
+{
+    wf_jsonrpc_impl_proxy_cleanup(proxy);
+    free(proxy);
+}
+
+static void wf_jsonrpc_impl_proxy_on_timeout(
+    struct wf_timer * timer, void * proxy_ptr)
+{
+    struct wf_jsonrpc_proxy * proxy = proxy_ptr;
+
+    if (proxy->request.is_pending)
+    {
+        wf_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_timer_cancel(timer);
+
+        wf_jsonrpc_impl_propate_error(finished, user_data, WF_JSONRPC_BAD_TIMEOUT, "Timeout");
+    }
+}
+
+static json_t * wf_jsonrpc_impl_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;
+            case 'j':
+            {
+                json_t * const value = va_arg(args, json_t *);
+                json_array_append_new(params, 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_jsonrpc_impl_proxy_init(
+    struct wf_jsonrpc_proxy * proxy,
+    struct wf_timer_manager * timeout_manager,
+    int timeout,
+    wf_jsonrpc_send_fn * send,
+    void * user_data)
+{
+    proxy->send = send;
+    proxy->timeout = timeout;
+    proxy->user_data = user_data;
+    proxy->request.is_pending = false;
+    proxy->request.timer = wf_timer_create(timeout_manager, 
+        &wf_jsonrpc_impl_proxy_on_timeout, proxy);    
+}
+
+void wf_jsonrpc_impl_proxy_cleanup(
+    struct wf_jsonrpc_proxy * proxy)
+{
+    if (proxy->request.is_pending)
+    {
+        void * user_data = proxy->request.user_data;
+        wf_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_timer_cancel(proxy->request.timer);
+
+        wf_jsonrpc_impl_propate_error(finished, user_data, WF_JSONRPC_BAD, "Bad: cancelled pending request during shutdown");
+    }
+
+    wf_timer_dispose(proxy->request.timer);
+}
+
+void wf_jsonrpc_impl_proxy_invoke(
+	struct wf_jsonrpc_proxy * proxy,
+	wf_jsonrpc_proxy_finished_fn * finished,
+	void * user_data,
+	char const * method_name,
+	char const * param_info,
+	va_list args
+)
+{
+    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_timer_start(proxy->request.timer, proxy->timeout);
+        
+        json_t * request = wf_jsonrpc_impl_request_create(method_name, proxy->request.id, param_info, args);
+
+        bool const is_send = ((NULL != request) && (proxy->send(request, proxy->user_data)));
+        if (!is_send)
+        {
+            proxy->request.is_pending = false;
+            proxy->request.finished = NULL;
+            proxy->request.user_data = NULL;
+            proxy->request.id = 0;
+            wf_timer_cancel(proxy->request.timer);
+
+            wf_jsonrpc_impl_propate_error(finished, user_data, WF_JSONRPC_BAD, "Bad: requenst is not sent");
+        }
+
+        if (NULL != request)
+        {
+            json_decref(request);
+        }
+    }
+    else
+    {
+        wf_jsonrpc_impl_propate_error(finished, user_data, WF_JSONRPC_BAD_BUSY, "Busy");
+    }
+}
+
+extern void wf_jsonrpc_impl_proxy_notify(
+	struct wf_jsonrpc_proxy * proxy,
+	char const * method_name,
+	char const * param_info,
+	va_list args
+)
+{            
+    json_t * request = wf_jsonrpc_impl_request_create(method_name, 0, param_info, args);
+    if (NULL != request)
+    {
+        proxy->send(request, proxy->user_data);
+        json_decref(request);
+    }
+}
+
+
+void wf_jsonrpc_impl_proxy_onresult(
+    struct wf_jsonrpc_proxy * proxy,
+    json_t * message)
+{
+	struct wf_jsonrpc_response response;
+	wf_jsonrpc_impl_response_init(&response, message);
+
+    if ((proxy->request.is_pending) && (response.id == proxy->request.id))
+    {
+        wf_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_timer_cancel(proxy->request.timer);
+
+        finished(user_data, response.result, response.error);
+    }
+
+    wf_jsonrpc_impl_response_cleanup(&response);
+}
+

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

@@ -0,0 +1,84 @@
+#ifndef WF_JSONRPC_IMPL_PROXY_H
+#define WF_JSONRPC_IMPL_PROXY_H
+
+#include "wf/jsonrpc/proxy_finished_fn.h"
+#include "wf/jsonrpc/send_fn.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+struct wf_timer_manager;
+struct wf_timer;
+
+struct wf_jsonrpc_request
+{
+    bool is_pending;
+    wf_jsonrpc_proxy_finished_fn * finished;
+    void * user_data;
+    int id;
+    struct wf_timer * timer;
+};
+
+struct wf_jsonrpc_proxy
+{
+    struct wf_jsonrpc_request request;
+    int timeout;
+    wf_jsonrpc_send_fn * send;
+    void * user_data;
+};
+
+extern void 
+wf_jsonrpc_impl_proxy_init(
+    struct wf_jsonrpc_proxy * proxy,
+    struct wf_timer_manager * manager,
+    int timeout,
+    wf_jsonrpc_send_fn * send,
+    void * user_data);
+
+extern void 
+wf_jsonrpc_impl_proxy_cleanup(
+    struct wf_jsonrpc_proxy * proxy);
+
+extern struct wf_jsonrpc_proxy *
+wf_jsonrpc_impl_proxy_create(
+    struct wf_timer_manager * manager,
+    int timeout,
+    wf_jsonrpc_send_fn * send,
+    void * user_data);
+
+extern void
+wf_jsonrpc_impl_proxy_dispose(
+    struct wf_jsonrpc_proxy * proxy);
+
+
+extern void
+wf_jsonrpc_impl_proxy_invoke(
+	struct wf_jsonrpc_proxy * proxy,
+	wf_jsonrpc_proxy_finished_fn * finished,
+	void * user_data,
+	char const * method_name,
+	char const * param_info,
+	va_list args
+);
+
+extern void
+wf_jsonrpc_impl_proxy_notify(
+	struct wf_jsonrpc_proxy * proxy,
+	char const * method_name,
+	char const * param_info,
+	va_list args
+);
+
+extern void
+wf_jsonrpc_impl_proxy_onresult(
+    struct wf_jsonrpc_proxy * proxy,
+    json_t * message);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

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

@@ -0,0 +1,84 @@
+#include "wf/jsonrpc/impl/request.h"
+#include "wf/jsonrpc/impl/error.h"
+#include <stdlib.h>
+
+struct wf_jsonrpc_request
+{
+    int id;
+    wf_jsonrpc_send_fn * send;
+    void * user_data;
+};
+
+bool
+wf_jsonrpc_impl_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_jsonrpc_request *
+wf_jsonrpc_impl_request_create(
+    int id,
+    wf_jsonrpc_send_fn * send,
+    void * user_data)
+{
+    struct wf_jsonrpc_request * request = malloc(sizeof(struct wf_jsonrpc_request));
+    if (NULL != request)
+    {
+        request->id = id;
+        request->send = send;
+        request->user_data = user_data;
+    }
+
+    return request;
+}
+
+void
+wf_jsonrpc_impl_request_dispose(
+    struct wf_jsonrpc_request * request)
+{
+    free(request);
+}
+
+void *
+wf_jsonrpc_impl_request_get_userdata(
+    struct wf_jsonrpc_request * request)
+{
+    return request->user_data;
+}
+
+
+void
+wf_jsonrpc_impl_respond(
+    struct wf_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_jsonrpc_impl_request_dispose(request);
+}
+
+void wf_jsonrpc_impl_respond_error(
+    struct wf_jsonrpc_request * request,
+    int code,
+    char const * message)
+{
+    json_t * response = json_object();
+    json_object_set_new(response, "error", wf_jsonrpc_impl_error(code, message));
+    json_object_set_new(response, "id", json_integer(request->id));
+
+    request->send(response, request->user_data);
+    json_decref(response);
+    wf_jsonrpc_impl_request_dispose(request);
+}
+

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

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

lib/wf/jsonrpc/src/wf/jsonrpc/impl/response.c

@@ -0,0 +1,68 @@
+#include "wf/jsonrpc/impl/response.h"
+#include "wf/jsonrpc/impl/error.h"
+#include "wf/jsonrpc/status.h"
+
+bool
+wf_jsonrpc_impl_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_jsonrpc_impl_response_init(
+	struct wf_jsonrpc_response * result,
+	json_t * response)
+{
+	result->id = -1;
+	result->result = NULL;
+	result->error = NULL;
+
+	json_t * id_holder = json_object_get(response, "id");
+	if ((NULL == id_holder) || (!json_is_integer(id_holder)))
+	{
+		result->error = wf_jsonrpc_impl_error(WF_JSONRPC_BAD_FORMAT, "invalid format: missing id");
+		return;
+	}
+	
+	result->id = json_integer_value(id_holder);
+	result->result = json_object_get(response, "result");
+	if (NULL != result->result)
+	{
+		json_incref(result->result);
+	}
+	else
+	{
+		json_t * error = json_object_get(response, "error");
+		if ((json_is_object(error)) && (json_is_integer(json_object_get(error, "code"))))
+		{
+			result->error = error;
+			json_incref(result->error);
+		}
+		else
+		{
+			result->error = wf_jsonrpc_impl_error(WF_JSONRPC_BAD_FORMAT, "invalid format: invalid error object");
+		}
+	}
+}
+
+void
+wf_jsonrpc_impl_response_cleanup(
+	struct wf_jsonrpc_response * response)
+{
+    if (NULL != response->result)
+    {
+        json_decref(response->result);
+    }
+
+    if (NULL != response->error)
+    {
+        json_decref(response->error);
+    }
+}

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

@@ -0,0 +1,40 @@
+#ifndef WF_JSONRPC_IMPL_RESPONSE_H
+#define WF_JSONRPC_IMPL_RESPONSE_H
+
+#ifndef __cplusplus
+#include <stdbool.h>
+#include <stddef.h>
+#else
+#include <cstddef>
+using std::size_t;
+#endif
+
+#include <jansson.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct wf_jsonrpc_response
+{
+	json_t * result;	
+	json_t * error;
+	int id;
+};
+
+extern bool wf_jsonrpc_impl_is_response(
+    json_t * message);
+
+extern void wf_jsonrpc_impl_response_init(
+	struct wf_jsonrpc_response * response,
+    json_t * message);
+
+extern void wf_jsonrpc_impl_response_cleanup(
+	struct wf_jsonrpc_response * response);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+

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

@@ -0,0 +1,132 @@
+#include "wf/jsonrpc/impl/server.h"
+#include "wf/jsonrpc/impl/method.h"
+#include "wf/jsonrpc/impl/request.h"
+#include "wf/jsonrpc/impl/unused_param.h"
+#include "wf/jsonrpc/status.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+struct wf_jsonrpc_server
+{
+    struct wf_jsonrpc_method * methods;
+};
+
+static void
+wf_jsonrpc_impl_server_init(
+    struct wf_jsonrpc_server * server);
+
+static void
+wf_jsonrpc_impl_server_cleanup(
+    struct wf_jsonrpc_server * server);
+
+struct wf_jsonrpc_server *
+wf_jsonrpc_impl_server_create(void)
+{
+    struct wf_jsonrpc_server * server = malloc(sizeof(struct wf_jsonrpc_server));
+    if (NULL != server)
+    {
+        wf_jsonrpc_impl_server_init(server);
+    }
+
+    return server;
+}
+
+void
+wf_jsonrpc_impl_server_dispose(
+    struct wf_jsonrpc_server * server)
+{
+    wf_jsonrpc_impl_server_cleanup(server);
+    free(server);
+}
+
+
+static void wf_jsonrpc_impl_server_init(
+    struct wf_jsonrpc_server * server)
+{
+    server->methods = NULL;
+}
+
+static void wf_jsonrpc_impl_server_cleanup(
+    struct wf_jsonrpc_server * server)
+{
+    struct wf_jsonrpc_method * current = server->methods;
+    while (NULL != current)
+    {
+        struct wf_jsonrpc_method * next = current->next;
+        wf_jsonrpc_impl_method_dispose(current);
+        current = next;
+    }
+    server->methods = NULL;
+}
+
+void wf_jsonrpc_impl_server_add(
+    struct wf_jsonrpc_server * server,
+    char const * method_name,
+    wf_jsonrpc_method_invoke_fn * invoke,
+    void * user_data)
+{
+    struct wf_jsonrpc_method * method = wf_jsonrpc_impl_method_create(method_name, invoke, user_data);
+    method->next = server->methods;
+    server->methods = method;
+}
+
+static void wf_jsonrpc_impl_server_invalid_method_invoke(
+    struct wf_jsonrpc_request * request,
+    char const * WF_JSONRPC_UNUSED_PARAM(method_name),
+    json_t * WF_JSONRPC_UNUSED_PARAM(params),
+    void * WF_JSONRPC_UNUSED_PARAM(user_data))
+{
+    wf_jsonrpc_impl_respond_error(request, WF_JSONRPC_BAD_NOTIMPLEMENTED, "not implemented");
+}
+
+static struct wf_jsonrpc_method const wf_jsonrpc_impl_server_invalid_method = 
+{
+    .next = NULL,
+    .name = "<invalid>",
+    .invoke = &wf_jsonrpc_impl_server_invalid_method_invoke,
+    .user_data = NULL    
+};
+
+static struct wf_jsonrpc_method const *
+wf_jsonrpc_impl_server_get_method(
+    struct wf_jsonrpc_server * server,
+    char const * method_name)
+{
+    struct wf_jsonrpc_method const * current = server->methods;
+    while (NULL != current) 
+    {
+        if (0 == strcmp(method_name, current->name))
+        {
+            return current;
+        }
+
+        current = current->next;
+    }
+
+    return &wf_jsonrpc_impl_server_invalid_method;
+}
+
+void wf_jsonrpc_impl_server_process(
+    struct wf_jsonrpc_server * server,
+    json_t * request_data,
+    wf_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_jsonrpc_request * request = wf_jsonrpc_impl_request_create(id, send, user_data);
+        struct wf_jsonrpc_method const * method = wf_jsonrpc_impl_server_get_method(server, method_name);
+
+        method->invoke(request, method_name, params, method->user_data);
+    }
+}
+

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

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

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

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

lib/wf/jsonrpc/test/wf/jsonrpc/test_is_request.cc

@@ -0,0 +1,112 @@
+#include <gtest/gtest.h>
+#include "wf/jsonrpc/request.h"
+
+TEST(wf_jsonrpc_is_request, request_with_object_params)
+{
+    json_t * request = json_object();
+    json_object_set_new(request, "method", json_string("method"));
+    json_object_set_new(request, "params", json_object());
+    json_object_set_new(request, "id", json_integer(42));
+
+    ASSERT_TRUE(wf_jsonrpc_is_request(request));
+
+    json_decref(request);
+}
+
+TEST(wf_jsonrpc_is_request, request_with_array_params)
+{
+    json_t * request = json_object();
+    json_object_set_new(request, "method", json_string("method"));
+    json_object_set_new(request, "params", json_array());
+    json_object_set_new(request, "id", json_integer(42));
+
+    ASSERT_TRUE(wf_jsonrpc_is_request(request));
+
+    json_decref(request);
+}
+
+TEST(wf_jsonrpc_is_request, null_request)
+{
+    ASSERT_FALSE(wf_jsonrpc_is_request(nullptr));
+}
+
+TEST(wf_jsonrpc_is_request, invalid_request)
+{
+    json_t * request = json_array();
+    json_array_append_new(request, json_string("method"));
+    json_array_append_new(request, json_object());
+    json_array_append_new(request, json_integer(42));
+
+    ASSERT_FALSE(wf_jsonrpc_is_request(request));
+
+    json_decref(request);
+}
+
+TEST(wf_jsonrpc_is_request, invalid_request_without_id)
+{
+    json_t * request = json_object();
+    json_object_set_new(request, "method", json_string("method"));
+    json_object_set_new(request, "params", json_object());
+
+    ASSERT_FALSE(wf_jsonrpc_is_request(request));
+
+    json_decref(request);
+}
+
+TEST(wf_jsonrpc_is_request, invalid_request_due_to_invalid_id)
+{
+    json_t * request = json_object();
+    json_object_set_new(request, "method", json_string("method"));
+    json_object_set_new(request, "params", json_object());
+    json_object_set_new(request, "id", json_string("42"));
+
+    ASSERT_FALSE(wf_jsonrpc_is_request(request));
+
+    json_decref(request);
+}
+
+TEST(wf_jsonrpc_is_request, invalid_request_without_method)
+{
+    json_t * request = json_object();
+    json_object_set_new(request, "params", json_object());
+    json_object_set_new(request, "id", json_integer(42));
+
+    ASSERT_FALSE(wf_jsonrpc_is_request(request));
+
+    json_decref(request);
+}
+
+TEST(wf_jsonrpc_is_request, invalid_request_due_to_invalid_method)
+{
+    json_t * request = json_object();
+    json_object_set_new(request, "method", json_integer(42));
+    json_object_set_new(request, "params", json_object());
+    json_object_set_new(request, "id", json_integer(42));
+
+    ASSERT_FALSE(wf_jsonrpc_is_request(request));
+
+    json_decref(request);
+}
+
+TEST(wf_jsonrpc_is_request, invalid_request_without_params)
+{
+    json_t * request = json_object();
+    json_object_set_new(request, "method", json_string("method"));
+    json_object_set_new(request, "id", json_integer(42));
+
+    ASSERT_FALSE(wf_jsonrpc_is_request(request));
+
+    json_decref(request);
+}
+
+TEST(wf_jsonrpc_is_request, invalid_request_due_to_invalid_params)
+{
+    json_t * request = json_object();
+    json_object_set_new(request, "methdo", json_string("method"));
+    json_object_set_new(request, "params", json_string("params"));
+    json_object_set_new(request, "id", json_integer(42));
+
+    ASSERT_FALSE(wf_jsonrpc_is_request(request));
+
+    json_decref(request);
+}

lib/wf/jsonrpc/test/wf/jsonrpc/test_is_response.cc

@@ -0,0 +1,94 @@
+#include <gtest/gtest.h>
+#include "wf/jsonrpc/response.h"
+
+TEST(wf_jsonrpc_is_response, valid_result)
+{
+    json_t * message = json_object();
+    json_object_set_new(message, "result", json_object());
+    json_object_set_new(message, "id", json_integer(42));
+
+    ASSERT_TRUE(wf_jsonrpc_is_response(message));
+
+    json_decref(message);
+}
+
+TEST(wf_jsonrpc_is_response, valid_result_string)
+{
+    json_t * message = json_object();
+    json_object_set_new(message, "result", json_string("also valid"));
+    json_object_set_new(message, "id", json_integer(42));
+
+    ASSERT_TRUE(wf_jsonrpc_is_response(message));
+
+    json_decref(message);
+}
+
+TEST(wf_jsonrpc_is_response, valid_error)
+{
+    json_t * message = json_object();
+    json_object_set_new(message, "error", json_object());
+    json_object_set_new(message, "id", json_integer(42));
+
+    ASSERT_TRUE(wf_jsonrpc_is_response(message));
+
+    json_decref(message);
+}
+
+TEST(wf_jsonrpc_is_response, invalid_null)
+{
+    ASSERT_FALSE(wf_jsonrpc_is_response(nullptr));
+}
+
+TEST(wf_jsonrpc_is_response, invalid_message)
+{
+    json_t * message = json_array();
+    json_array_append_new(message, json_object());
+    json_array_append_new(message, json_integer(42));
+
+    ASSERT_FALSE(wf_jsonrpc_is_response(message));
+
+    json_decref(message);
+}
+
+TEST(wf_jsonrpc_is_response, invalid_missing_id)
+{
+    json_t * message = json_object();
+    json_object_set_new(message, "result", json_object());
+
+    ASSERT_FALSE(wf_jsonrpc_is_response(message));
+
+    json_decref(message);
+}
+
+TEST(wf_jsonrpc_is_response, invalid_id_wrong_type)
+{
+    json_t * message = json_object();
+    json_object_set_new(message, "result", json_object());
+    json_object_set_new(message, "id", json_string("42"));
+
+    ASSERT_FALSE(wf_jsonrpc_is_response(message));
+
+    json_decref(message);
+}
+
+
+TEST(wf_jsonrpc_is_response, invalid_missing_result_and_error)
+{
+    json_t * message = json_object();
+    json_object_set_new(message, "id", json_integer(42));
+
+    ASSERT_FALSE(wf_jsonrpc_is_response(message));
+
+    json_decref(message);
+}
+
+TEST(wf_jsonrpc_is_response, invalid_error_wrong_type)
+{
+    json_t * message = json_object();
+    json_object_set_new(message, "error", json_array());
+    json_object_set_new(message, "id", json_integer(42));
+
+    ASSERT_FALSE(wf_jsonrpc_is_response(message));
+
+    json_decref(message);
+}

lib/wf/jsonrpc/test/wf/jsonrpc/test_proxy.cc

@@ -0,0 +1,374 @@
+#include <gtest/gtest.h>
+#include "wf/jsonrpc/proxy.h"
+#include "wf/timer/manager.h"
+#include "webfuse/utils/msleep.hpp"
+#include "webfuse/core/json_util.h"
+
+using webfuse_test::msleep;
+
+#define WF_DEFAULT_TIMEOUT (10 * 1000)
+
+namespace
+{
+
+    struct SendContext
+    {
+        json_t * response;
+        bool result;
+        bool is_called;
+
+        explicit SendContext(bool result_ = true)
+        : response(nullptr)
+        , result(result_)
+        , is_called(false)
+        {
+        }
+
+        ~SendContext() 
+        {
+            if (nullptr != response)
+            {
+                json_decref(response);
+            }
+        }
+    };
+
+    bool jsonrpc_send(
+        json_t * request,
+        void * user_data)
+    {
+        SendContext * context = reinterpret_cast<SendContext*>(user_data);
+        context->is_called = true;
+        context->response = request;
+        json_incref(request);
+
+        return context->result;
+    }
+
+    struct FinishedContext
+    {
+        bool is_called;
+        json_t * result;
+        json_t * error;
+
+        FinishedContext()
+        : is_called(false)
+        , result(nullptr)
+        , error(nullptr)
+        {
+
+        }
+
+        ~FinishedContext()
+        {
+            if (nullptr != result)
+            {
+                json_decref(result);
+            }
+
+            if (nullptr != error)
+            {
+                json_decref(error);
+            }
+        }
+    };
+
+    void jsonrpc_finished(
+        void * user_data,
+        json_t const * result,
+        json_t const * error)
+    {
+        FinishedContext * context = reinterpret_cast<FinishedContext*>(user_data);
+        context->is_called = true;
+        context->result = json_deep_copy(result);
+        context->error = json_deep_copy(error);
+    }
+}
+
+TEST(wf_jsonrpc_proxy, init)
+{
+    struct wf_timer_manager * timer_manager = wf_timer_manager_create();
+
+    SendContext context;
+    void * user_data = reinterpret_cast<void*>(&context);
+    struct wf_jsonrpc_proxy * proxy = wf_jsonrpc_proxy_create(timer_manager, WF_DEFAULT_TIMEOUT, &jsonrpc_send, user_data);
+
+    wf_jsonrpc_proxy_dispose(proxy);
+    wf_timer_manager_dispose(timer_manager);
+
+    ASSERT_FALSE(context.is_called);
+}
+
+TEST(wf_jsonrpc_proxy, invoke)
+{
+    struct wf_timer_manager * timer_manager = wf_timer_manager_create();
+
+    SendContext send_context;
+    void * send_data = reinterpret_cast<void*>(&send_context);
+    struct wf_jsonrpc_proxy * proxy = wf_jsonrpc_proxy_create(timer_manager, WF_DEFAULT_TIMEOUT, &jsonrpc_send, send_data);
+
+    FinishedContext finished_context;
+    void * finished_data = reinterpret_cast<void*>(&finished_context);
+    wf_jsonrpc_proxy_invoke(proxy, &jsonrpc_finished, finished_data, "foo", "si", "bar", 42);
+
+    ASSERT_TRUE(send_context.is_called);
+    ASSERT_TRUE(json_is_object(send_context.response));
+
+    json_t * method = json_object_get(send_context.response, "method");
+    ASSERT_TRUE(json_is_string(method));
+    ASSERT_STREQ("foo", json_string_value(method));
+
+    json_t * params = json_object_get(send_context.response, "params");
+    ASSERT_TRUE(json_is_array(params));
+    ASSERT_EQ(2, json_array_size(params));
+    ASSERT_TRUE(json_is_string(json_array_get(params, 0)));
+    ASSERT_STREQ("bar", json_string_value(json_array_get(params, 0)));
+    ASSERT_TRUE(json_is_integer(json_array_get(params, 1)));
+    ASSERT_EQ(42, json_integer_value(json_array_get(params, 1)));
+
+    json_t * id = json_object_get(send_context.response, "id");
+    ASSERT_TRUE(json_is_integer(id));
+
+    ASSERT_FALSE(finished_context.is_called);
+
+    wf_jsonrpc_proxy_dispose(proxy);
+    wf_timer_manager_dispose(timer_manager);
+
+    ASSERT_TRUE(finished_context.is_called);
+    ASSERT_FALSE(nullptr == finished_context.error);
+}
+
+TEST(wf_jsonrpc_proxy, invoke_calls_finish_if_send_fails)
+{
+    struct wf_timer_manager * timer_manager = wf_timer_manager_create();
+
+    SendContext send_context(false);
+    void * send_data = reinterpret_cast<void*>(&send_context);
+    struct wf_jsonrpc_proxy * proxy = wf_jsonrpc_proxy_create(timer_manager, WF_DEFAULT_TIMEOUT, &jsonrpc_send, send_data);
+
+    FinishedContext finished_context;
+    void * finished_data = reinterpret_cast<void*>(&finished_context);
+    wf_jsonrpc_proxy_invoke(proxy, &jsonrpc_finished, finished_data, "foo", "si", "bar", 42);
+
+    ASSERT_TRUE(send_context.is_called);
+    ASSERT_TRUE(json_is_object(send_context.response));
+
+    ASSERT_TRUE(finished_context.is_called);
+    ASSERT_FALSE(nullptr == finished_context.error);
+
+    wf_jsonrpc_proxy_dispose(proxy);
+    wf_timer_manager_dispose(timer_manager);
+}
+
+TEST(wf_jsonrpc_proxy, invoke_fails_if_another_request_is_pending)
+{
+    struct wf_timer_manager * timer_manager = wf_timer_manager_create();
+
+    SendContext send_context;
+    void * send_data = reinterpret_cast<void*>(&send_context);
+    struct wf_jsonrpc_proxy * proxy = wf_jsonrpc_proxy_create(timer_manager, WF_DEFAULT_TIMEOUT, &jsonrpc_send, send_data);
+
+    FinishedContext finished_context;
+    void * finished_data = reinterpret_cast<void*>(&finished_context);
+    wf_jsonrpc_proxy_invoke(proxy, &jsonrpc_finished, finished_data, "foo", "si", "bar", 42);
+
+    FinishedContext finished_context2;
+    void * finished_data2 = reinterpret_cast<void*>(&finished_context2);
+    wf_jsonrpc_proxy_invoke(proxy, &jsonrpc_finished, finished_data2, "foo", "");
+
+    ASSERT_TRUE(send_context.is_called);
+    ASSERT_TRUE(json_is_object(send_context.response));
+
+    ASSERT_FALSE(finished_context.is_called);
+
+    ASSERT_TRUE(finished_context2.is_called);
+    ASSERT_EQ(WF_BAD_BUSY, wf_impl_jsonrpc_get_status(finished_context2.error));
+
+    wf_jsonrpc_proxy_dispose(proxy);
+    wf_timer_manager_dispose(timer_manager);
+}
+
+TEST(wf_jsonrpc_proxy, invoke_fails_if_request_is_invalid)
+{
+    struct wf_timer_manager * timer_manager = wf_timer_manager_create();
+
+    SendContext send_context;
+    void * send_data = reinterpret_cast<void*>(&send_context);
+    struct wf_jsonrpc_proxy * proxy = wf_jsonrpc_proxy_create(timer_manager, WF_DEFAULT_TIMEOUT, &jsonrpc_send, send_data);
+
+    FinishedContext finished_context;
+    void * finished_data = reinterpret_cast<void*>(&finished_context);
+    wf_jsonrpc_proxy_invoke(proxy, &jsonrpc_finished, finished_data, "foo", "?", "error");
+
+    ASSERT_FALSE(send_context.is_called);
+
+    ASSERT_TRUE(finished_context.is_called);
+    ASSERT_EQ(WF_BAD, wf_impl_jsonrpc_get_status(finished_context.error));
+
+    wf_jsonrpc_proxy_dispose(proxy);
+    wf_timer_manager_dispose(timer_manager);
+}
+
+TEST(wf_jsonrpc_proxy, on_result)
+{
+    struct wf_timer_manager * timer_manager = wf_timer_manager_create();
+
+    SendContext send_context;
+    void * send_data = reinterpret_cast<void*>(&send_context);
+    struct wf_jsonrpc_proxy * proxy = wf_jsonrpc_proxy_create(timer_manager, WF_DEFAULT_TIMEOUT, &jsonrpc_send, send_data);
+
+    FinishedContext finished_context;
+    void * finished_data = reinterpret_cast<void*>(&finished_context);
+    wf_jsonrpc_proxy_invoke(proxy, &jsonrpc_finished, finished_data, "foo", "si", "bar", 42);
+
+    ASSERT_TRUE(send_context.is_called);
+    ASSERT_TRUE(json_is_object(send_context.response));
+
+    json_t * id = json_object_get(send_context.response, "id");
+    ASSERT_TRUE(json_is_number(id));
+
+    json_t * response = json_object();
+    json_object_set_new(response, "result", json_string("okay"));
+    json_object_set(response, "id", id);
+
+    wf_jsonrpc_proxy_onresult(proxy, response);
+    json_decref(response);
+
+    ASSERT_TRUE(finished_context.is_called);
+    ASSERT_EQ(nullptr, finished_context.error);
+    ASSERT_TRUE(json_is_string(finished_context.result));
+    ASSERT_STREQ("okay", json_string_value(finished_context.result));
+
+    wf_jsonrpc_proxy_dispose(proxy);
+    wf_timer_manager_dispose(timer_manager);
+}
+
+TEST(wf_jsonrpc_proxy, on_result_reject_response_with_unknown_id)
+{
+    struct wf_timer_manager * timer_manager = wf_timer_manager_create();
+
+    SendContext send_context;
+    void * send_data = reinterpret_cast<void*>(&send_context);
+    struct wf_jsonrpc_proxy * proxy = wf_jsonrpc_proxy_create(timer_manager, WF_DEFAULT_TIMEOUT, &jsonrpc_send, send_data);
+
+    FinishedContext finished_context;
+    void * finished_data = reinterpret_cast<void*>(&finished_context);
+    wf_jsonrpc_proxy_invoke(proxy, &jsonrpc_finished, finished_data, "foo", "si", "bar", 42);
+
+    ASSERT_TRUE(send_context.is_called);
+    ASSERT_TRUE(json_is_object(send_context.response));
+
+    json_t * id = json_object_get(send_context.response, "id");
+    ASSERT_TRUE(json_is_number(id));
+
+    json_t * response = json_object();
+    json_object_set_new(response, "result", json_string("okay"));
+    json_object_set_new(response, "id", json_integer(1 + json_integer_value(id)));
+
+    wf_jsonrpc_proxy_onresult(proxy, response);
+    json_decref(response);
+
+    ASSERT_FALSE(finished_context.is_called);
+
+    wf_jsonrpc_proxy_dispose(proxy);
+    wf_timer_manager_dispose(timer_manager);
+}
+
+TEST(wf_jsonrpc_proxy, timeout)
+{
+    struct wf_timer_manager * timer_manager = wf_timer_manager_create();
+
+    SendContext send_context;
+    void * send_data = reinterpret_cast<void*>(&send_context);
+    struct wf_jsonrpc_proxy * proxy = wf_jsonrpc_proxy_create(timer_manager, 0, &jsonrpc_send, send_data);
+
+    FinishedContext finished_context;
+    void * finished_data = reinterpret_cast<void*>(&finished_context);
+    wf_jsonrpc_proxy_invoke(proxy, &jsonrpc_finished, finished_data, "foo", "si", "bar", 42);
+
+    ASSERT_TRUE(send_context.is_called);
+    ASSERT_TRUE(json_is_object(send_context.response));
+
+    msleep(10);
+    wf_timer_manager_check(timer_manager);
+
+    ASSERT_TRUE(finished_context.is_called);
+    ASSERT_EQ(WF_BAD_TIMEOUT, wf_impl_jsonrpc_get_status(finished_context.error));
+
+    wf_jsonrpc_proxy_dispose(proxy);
+    wf_timer_manager_dispose(timer_manager);
+}
+
+TEST(wf_jsonrpc_proxy, cleanup_pending_request)
+{
+    struct wf_timer_manager * timer_manager = wf_timer_manager_create();
+
+    SendContext send_context;
+    void * send_data = reinterpret_cast<void*>(&send_context);
+    struct wf_jsonrpc_proxy * proxy = wf_jsonrpc_proxy_create(timer_manager, 10, &jsonrpc_send, send_data);
+
+    FinishedContext finished_context;
+    void * finished_data = reinterpret_cast<void*>(&finished_context);
+    wf_jsonrpc_proxy_invoke(proxy, &jsonrpc_finished, finished_data, "foo", "si", "bar", 42);
+
+    ASSERT_TRUE(send_context.is_called);
+    ASSERT_TRUE(json_is_object(send_context.response));
+
+    ASSERT_FALSE(finished_context.is_called);
+
+    wf_jsonrpc_proxy_dispose(proxy);
+
+    ASSERT_TRUE(finished_context.is_called);
+
+    wf_timer_manager_dispose(timer_manager);
+}
+
+
+
+TEST(wf_jsonrpc_proxy, notify)
+{
+    struct wf_timer_manager * timer_manager = wf_timer_manager_create();
+
+    SendContext send_context;
+    void * send_data = reinterpret_cast<void*>(&send_context);
+    struct wf_jsonrpc_proxy * proxy = wf_jsonrpc_proxy_create(timer_manager, WF_DEFAULT_TIMEOUT, &jsonrpc_send, send_data);
+
+    wf_jsonrpc_proxy_notify(proxy, "foo", "si", "bar", 42);
+
+    ASSERT_TRUE(send_context.is_called);
+    ASSERT_TRUE(json_is_object(send_context.response));
+
+    json_t * method = json_object_get(send_context.response, "method");
+    ASSERT_TRUE(json_is_string(method));
+    ASSERT_STREQ("foo", json_string_value(method));
+
+    json_t * params = json_object_get(send_context.response, "params");
+    ASSERT_TRUE(json_is_array(params));
+    ASSERT_EQ(2, json_array_size(params));
+    ASSERT_TRUE(json_is_string(json_array_get(params, 0)));
+    ASSERT_STREQ("bar", json_string_value(json_array_get(params, 0)));
+    ASSERT_TRUE(json_is_integer(json_array_get(params, 1)));
+    ASSERT_EQ(42, json_integer_value(json_array_get(params, 1)));
+
+    json_t * id = json_object_get(send_context.response, "id");
+    ASSERT_EQ(nullptr, id);
+
+    wf_jsonrpc_proxy_dispose(proxy);
+    wf_timer_manager_dispose(timer_manager);
+}
+
+TEST(wf_jsonrpc_proxy, notify_dont_send_invalid_request)
+{
+    struct wf_timer_manager * timer_manager = wf_timer_manager_create();
+
+    SendContext send_context;
+    void * send_data = reinterpret_cast<void*>(&send_context);
+    struct wf_jsonrpc_proxy * proxy = wf_jsonrpc_proxy_create(timer_manager, WF_DEFAULT_TIMEOUT, &jsonrpc_send, send_data);
+
+    wf_jsonrpc_proxy_notify(proxy, "foo", "?");
+
+    ASSERT_FALSE(send_context.is_called);
+
+    wf_jsonrpc_proxy_dispose(proxy);
+    wf_timer_manager_dispose(timer_manager);
+}

lib/wf/jsonrpc/test/wf/jsonrpc/test_request.cc

@@ -0,0 +1,103 @@
+#include <gtest/gtest.h>
+#include "wf/jsonrpc/request.h"
+#include "wf/jsonrpc/status.h"
+
+namespace
+{
+
+struct Context
+{
+    json_t * response;
+};
+
+bool jsonrpc_send(
+	json_t * request,
+    void * user_data)
+{
+   Context * context = reinterpret_cast<Context*>(user_data);
+   context->response = request;
+   json_incref(request);
+
+   return true;
+}
+
+}
+
+TEST(wf_jsonrpc_request, create_dispose)
+{
+    Context context{nullptr};
+    void * user_data = reinterpret_cast<void*>(&context);
+
+    struct  wf_jsonrpc_request * request = 
+            wf_jsonrpc_request_create(42, &jsonrpc_send, user_data);
+
+    ASSERT_NE(nullptr, request);
+    ASSERT_EQ(user_data, wf_jsonrpc_request_get_userdata(request));
+
+    wf_jsonrpc_request_dispose(request);
+}
+
+TEST(wf_jsonrpc_request, respond)
+{
+    Context context{nullptr};
+    void * user_data = reinterpret_cast<void*>(&context);
+
+    struct  wf_jsonrpc_request * request = 
+            wf_jsonrpc_request_create(42, &jsonrpc_send, user_data);
+
+    wf_jsonrpc_respond(request, json_string("okay"));
+
+    ASSERT_NE(nullptr, context.response);
+
+
+    json_t * response = reinterpret_cast<json_t*>(context.response);
+    ASSERT_TRUE(json_is_object(response));
+    
+    json_t * id = json_object_get(response, "id");
+    ASSERT_TRUE(json_is_integer(id));
+    ASSERT_EQ(42, json_integer_value(id));
+
+    json_t * result = json_object_get(response, "result");
+    ASSERT_TRUE(json_is_string(result));
+    ASSERT_STREQ("okay", json_string_value(result));
+
+    ASSERT_EQ(nullptr, json_object_get(response, "error"));
+
+    json_decref(response);
+}
+
+TEST(wf_jsonrpc_request, respond_error)
+{
+    Context context{nullptr};
+    void * user_data = reinterpret_cast<void*>(&context);
+
+    struct  wf_jsonrpc_request * request = 
+            wf_jsonrpc_request_create(42, &jsonrpc_send, user_data);
+
+    wf_jsonrpc_respond_error(request, WF_JSONRPC_BAD, "Bad");
+
+    ASSERT_NE(nullptr, context.response);
+
+
+    json_t * response = reinterpret_cast<json_t*>(context.response);
+    ASSERT_TRUE(json_is_object(response));
+    
+    json_t * id = json_object_get(response, "id");
+    ASSERT_TRUE(json_is_integer(id));
+    ASSERT_EQ(42, json_integer_value(id));
+
+    ASSERT_EQ(nullptr, json_object_get(response, "result"));
+
+    json_t * err = json_object_get(response, "error");
+    ASSERT_TRUE(json_is_object(err));
+
+    json_t * err_code = json_object_get(err, "code");
+    ASSERT_TRUE(json_is_integer(err_code));
+    ASSERT_EQ(WF_JSONRPC_BAD, json_integer_value(err_code));
+
+    json_t * err_message = json_object_get(err, "message");
+    ASSERT_TRUE(json_is_string(err_message));
+    ASSERT_STREQ("Bad", json_string_value(err_message));
+
+    json_decref(response);
+}

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

@@ -0,0 +1,58 @@
+#include <gtest/gtest.h>
+#include "wf/jsonrpc/impl/response.h"
+#include "webfuse/core/status.h"
+#include "webfuse/core/json_util.h"
+
+TEST(wf_json_response, init_result)
+{
+    json_t * message = json_object();
+    json_object_set_new(message, "result", json_integer(47));
+    json_object_set_new(message, "id", json_integer(11));
+
+    struct wf_jsonrpc_response response;
+    wf_jsonrpc_impl_response_init(&response, message);
+
+    ASSERT_EQ(nullptr, response.error);
+    ASSERT_TRUE(json_is_integer(response.result));
+    ASSERT_EQ(47, json_integer_value(response.result));
+    ASSERT_EQ(11, response.id);
+
+    wf_jsonrpc_impl_response_cleanup(&response);
+    json_decref(message);
+}
+
+TEST(wf_json_response, init_error)
+{
+    json_t * message = json_object();
+    json_t * err = json_object();
+    json_object_set_new(err, "code", json_integer(WF_BAD_ACCESS_DENIED));
+    json_object_set_new(err, "message", json_string("access denied"));
+    json_object_set_new(message, "error", err);
+    json_object_set_new(message, "id", json_integer(23));
+
+    struct wf_jsonrpc_response response;
+    wf_jsonrpc_impl_response_init(&response, message);
+
+    ASSERT_EQ(WF_BAD_ACCESS_DENIED, wf_impl_jsonrpc_get_status(response.error)) << json_string_value(json_object_get(response.error, "message"));
+    ASSERT_EQ(nullptr, response.result);
+    ASSERT_EQ(23, response.id);
+
+    wf_jsonrpc_impl_response_cleanup(&response);
+    json_decref(message);
+}
+
+TEST(wf_json_response, init_format_error)
+{
+    json_t * message = json_object();
+    json_object_set_new(message, "id", json_integer(12));
+
+    struct wf_jsonrpc_response response;
+    wf_jsonrpc_impl_response_init(&response, message);
+
+    ASSERT_EQ(WF_BAD_FORMAT, wf_impl_jsonrpc_get_status(response.error));
+    ASSERT_EQ(nullptr, response.result);
+    ASSERT_EQ(12, response.id);
+
+    wf_jsonrpc_impl_response_cleanup(&response);
+    json_decref(message);
+}

lib/wf/jsonrpc/test/wf/jsonrpc/test_response_parser.cc

@@ -0,0 +1,59 @@
+#include <string>
+#include <gtest/gtest.h>
+
+#include "wf/jsonrpc/impl/response.h"
+#include "webfuse/core/json_util.h"
+
+
+static void response_parse_str(
+	std::string const & buffer,
+	struct wf_jsonrpc_response * response)
+{
+	json_t * message = json_loadb(buffer.c_str(), buffer.size(), 0, nullptr);
+	if (nullptr != message)
+	{
+		wf_jsonrpc_impl_response_init(response, message);
+		json_decref(message);
+	}
+}
+
+TEST(response_parser, test)
+{
+	struct wf_jsonrpc_response response;
+
+	// no object
+	response_parse_str("[]", &response);
+	ASSERT_NE(nullptr, response.error);
+	ASSERT_EQ(-1, response.id);
+	ASSERT_EQ(nullptr, response.result);
+	wf_jsonrpc_impl_response_cleanup(&response);
+
+	// empty
+	response_parse_str("{}", &response);
+	ASSERT_NE(nullptr, response.error);
+	ASSERT_EQ(-1, response.id);
+	ASSERT_EQ(nullptr, response.result);
+	wf_jsonrpc_impl_response_cleanup(&response);
+
+	// no data
+	response_parse_str("{\"id\":42}", &response);
+	ASSERT_NE(nullptr, response.error);
+	ASSERT_EQ(42, response.id);
+	ASSERT_EQ(nullptr, response.result);
+	wf_jsonrpc_impl_response_cleanup(&response);
+
+	// custom error code
+	response_parse_str("{\"error\":{\"code\": 42}, \"id\": 42}", &response);
+	ASSERT_NE(nullptr, response.error);
+	ASSERT_EQ(42, json_integer_value(json_object_get(response.error, "code")));
+	ASSERT_EQ(42, response.id);
+	ASSERT_EQ(nullptr, response.result);
+	wf_jsonrpc_impl_response_cleanup(&response);
+
+	// valid response
+	response_parse_str("{\"result\": true, \"id\": 42}", &response);
+	ASSERT_EQ(WF_GOOD, response.error);
+	ASSERT_EQ(42, response.id);
+	ASSERT_NE(nullptr, response.result);
+	wf_jsonrpc_impl_response_cleanup(&response);
+}

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

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