refactor: use wf_jsonrpc_error struct instead of json_t to express errors

lib/webfuse/impl/client_protocol.c

@@ -102,7 +102,7 @@ static void
 wf_impl_client_protocol_on_authenticate_finished(
 	void * user_data,
 	json_t const * result,
-	json_t const * WF_UNUSED_PARAM(error))    
+	struct wf_jsonrpc_error const * WF_UNUSED_PARAM(error))    
 {
     struct wf_client_protocol * protocol = user_data;
     int const reason = (NULL != result) ? WF_CLIENT_AUTHENTICATED : WF_CLIENT_AUTHENTICATION_FAILED;
@@ -114,7 +114,7 @@ static void
 wf_impl_client_protocol_on_add_filesystem_finished(
 	void * user_data,
 	json_t const * result,
-	json_t const * WF_UNUSED_PARAM(error))
+	struct wf_jsonrpc_error const * WF_UNUSED_PARAM(error))
 {
     struct wf_impl_client_protocol_add_filesystem_context * context = user_data;
     struct wf_client_protocol * protocol = context->protocol;

lib/webfuse/impl/jsonrpc/error.c

@@ -1,17 +1,51 @@
 #include "webfuse/impl/jsonrpc/error.h"
 
-json_t *
+#include <stdlib.h>
+#include <string.h>
+
+struct wf_jsonrpc_error
+{
+    int code;
+    char * message;
+};
+
+struct wf_jsonrpc_error *
 wf_impl_jsonrpc_error(
     int code,
     char const * message)
 {
-    json_t * error = json_object();
+    struct wf_jsonrpc_error * error = malloc(sizeof(struct wf_jsonrpc_error));
-    json_object_set_new(error, "code", json_integer(code));
+    error->code = code;
-    json_object_set_new(error, "message", json_string(message));
+    error->message = strdup(message);
 
     return error;
 }
 
+void
+wf_impl_jsonrpc_error_dispose(
+    struct wf_jsonrpc_error * error)
+{
+    if (NULL != error)
+    {
+        free(error->message);
+        free(error);
+    }
+}
+
+int
+wf_impl_jsonrpc_error_code(
+    struct wf_jsonrpc_error const * error)
+{
+    return error->code;
+}
+
+char const *
+wf_impl_jsonrpc_error_message(
+    struct wf_jsonrpc_error const * error)
+{
+    return error->message;
+}
+
 void
 wf_impl_jsonrpc_propate_error(
     wf_jsonrpc_proxy_finished_fn * finised,
@@ -19,9 +53,12 @@ wf_impl_jsonrpc_propate_error(
     int code,
     char const * message)
 {
-    json_t * error = wf_impl_jsonrpc_error(code, message);
+    struct wf_jsonrpc_error error =
-    finised(user_data, NULL, error);
+    {
+        .code = code,
+        .message = (char*) message        
+    };
 
-    json_decref(error);
+    finised(user_data, NULL, &error);
 }
 

lib/webfuse/impl/jsonrpc/error.h

@@ -9,11 +9,25 @@ extern "C"
 {
 #endif
 
-extern json_t *
+struct wf_jsonrpc_error;
+
+extern struct wf_jsonrpc_error *
 wf_impl_jsonrpc_error(
     int code,
     char const * message);
 
+extern void
+wf_impl_jsonrpc_error_dispose(
+    struct wf_jsonrpc_error * error);
+
+extern int
+wf_impl_jsonrpc_error_code(
+    struct wf_jsonrpc_error const * error);
+
+extern char const *
+wf_impl_jsonrpc_error_message(
+    struct wf_jsonrpc_error const * error);
+
 extern void
 wf_impl_jsonrpc_propate_error(
     wf_jsonrpc_proxy_finished_fn * finised,

lib/webfuse/impl/jsonrpc/proxy_finished_fn.h

@@ -8,10 +8,12 @@ extern "C"
 {
 #endif
 
+struct wf_jsonrpc_error;
+
 typedef void wf_jsonrpc_proxy_finished_fn(
 	void * user_data,
 	json_t const * result,
-    json_t const * error);
+    struct wf_jsonrpc_error const * error);
 
 #ifdef __cplusplus
 }

lib/webfuse/impl/jsonrpc/response.c

@@ -39,16 +39,19 @@ wf_impl_jsonrpc_response_init(
 	}
 	else
 	{
+		int code = WF_BAD_FORMAT;
+		char const * message = "invalid format: invalid error object";
+
 		json_t * error = json_object_get(response, "error");
-		if ((json_is_object(error)) && (json_is_integer(json_object_get(error, "code"))))
+		json_t * code_holder = json_object_get(error, "code");
+		if (json_is_integer(code_holder))
 		{
-			result->error = error;
+			code = json_integer_value(json_object_get(error, "code"));
-			json_incref(result->error);
+			json_t * message_holder = json_object_get(error, "message");
-		}
+			message = json_is_string(message_holder) ? json_string_value(message_holder) : "";
-		else
-		{
-			result->error = wf_impl_jsonrpc_error(WF_BAD_FORMAT, "invalid format: invalid error object");
 		}
+
+		result->error = wf_impl_jsonrpc_error(code, message);
 	}
 }
 
@@ -61,8 +64,5 @@ wf_impl_jsonrpc_response_cleanup(
         json_decref(response->result);
     }
 
-    if (NULL != response->error)
+	wf_impl_jsonrpc_error_dispose(response->error);
-    {
-        json_decref(response->error);
-    }
 }

lib/webfuse/impl/jsonrpc/response_intern.h

@@ -14,10 +14,12 @@ using std::size_t;
 extern "C" {
 #endif
 
+struct wf_jsonrpc_error;
+
 struct wf_jsonrpc_response
 {
 	json_t * result;	
-	json_t * error;
+	struct wf_jsonrpc_error * error;
 	int id;
 };
 

lib/webfuse/impl/operation/getattr.c

@@ -15,7 +15,7 @@
 void wf_impl_operation_getattr_finished(
 	void * user_data,
 	json_t const * result,
-	json_t const * error)
+	struct wf_jsonrpc_error const * error)
 {
 	wf_status status = wf_impl_jsonrpc_get_status(error);
 	struct wf_impl_operation_getattr_context * context = user_data;

lib/webfuse/impl/operation/getattr.h

@@ -11,6 +11,8 @@ extern "C"
 {
 #endif
 
+struct wf_jsonrpc_error;
+
 struct wf_impl_operation_getattr_context
 {
 	fuse_req_t request;
@@ -23,7 +25,7 @@ struct wf_impl_operation_getattr_context
 extern void wf_impl_operation_getattr_finished(
 	void * user_data,
 	json_t const * result,
-	json_t const * error);
+	struct wf_jsonrpc_error const * error);
 
 extern void wf_impl_operation_getattr (
 		fuse_req_t request,

lib/webfuse/impl/operation/lookup.c

@@ -18,7 +18,7 @@
 void wf_impl_operation_lookup_finished(
 	void * user_data,
 	json_t const * result,
-	json_t const * error
+	struct wf_jsonrpc_error const * error
 )
 {
 	wf_status status = wf_impl_jsonrpc_get_status(error);

lib/webfuse/impl/operation/lookup.h

@@ -11,6 +11,8 @@ extern "C"
 {
 #endif
 
+struct wf_jsonrpc_error;
+
 struct wf_impl_operation_lookup_context
 {
 	fuse_req_t request;
@@ -22,7 +24,7 @@ struct wf_impl_operation_lookup_context
 extern void wf_impl_operation_lookup_finished(
 	void * user_data,
 	json_t const * result,
-	json_t const * error);
+	struct wf_jsonrpc_error const * error);
 
 extern void wf_impl_operation_lookup (
 	fuse_req_t req, 

lib/webfuse/impl/operation/open.c

@@ -12,7 +12,7 @@
 void wf_impl_operation_open_finished(
 	void * user_data,
 	json_t const * result,
-	json_t const * error)
+	struct wf_jsonrpc_error const * error)
 {
 	wf_status status = wf_impl_jsonrpc_get_status(error);
 	fuse_req_t request = user_data;

lib/webfuse/impl/operation/open.h

@@ -9,6 +9,8 @@ extern "C"
 {
 #endif
 
+struct wf_jsonrpc_error;
+
 extern void wf_impl_operation_open(
 	fuse_req_t request,
 	fuse_ino_t inode,
@@ -17,7 +19,7 @@ extern void wf_impl_operation_open(
 extern void wf_impl_operation_open_finished(
 	void * user_data,
 	json_t const * result,
-	json_t const * error);
+	struct wf_jsonrpc_error const * error);
 
 #ifdef __cplusplus
 }

lib/webfuse/impl/operation/read.c

@@ -62,7 +62,7 @@ char * wf_impl_fill_buffer(
 void wf_impl_operation_read_finished(
 	void * user_data, 
 	json_t const * result,
-	json_t const * error)
+	struct wf_jsonrpc_error const * error)
 {
 	wf_status status = wf_impl_jsonrpc_get_status(error);
 	fuse_req_t request = user_data;

lib/webfuse/impl/operation/read.h

@@ -11,6 +11,8 @@ extern "C"
 {
 #endif
 
+struct wf_jsonrpc_error;
+
 extern void wf_impl_operation_read(
 	fuse_req_t request,
 	fuse_ino_t ino, size_t size, off_t off,
@@ -26,7 +28,7 @@ extern char * wf_impl_fill_buffer(
 extern void wf_impl_operation_read_finished(
 	void * user_data, 
 	json_t const * result,
-	json_t const * error);
+	struct wf_jsonrpc_error const * error);
 
 
 #ifdef __cplusplus

lib/webfuse/impl/operation/readdir.c

@@ -69,7 +69,7 @@ static size_t wf_impl_min(size_t a, size_t b)
 void wf_impl_operation_readdir_finished(
 	void * user_data,
 	json_t const * result,
-	json_t const * error)
+	struct wf_jsonrpc_error const * error)
 {
 	wf_status status = wf_impl_jsonrpc_get_status(error);
 	struct wf_impl_operation_readdir_context * context = user_data;

lib/webfuse/impl/operation/readdir.h

@@ -9,6 +9,8 @@ extern "C"
 {
 #endif
 
+struct wf_jsonrpc_error;
+
 struct wf_impl_operation_readdir_context
 {
 	fuse_req_t request;
@@ -26,7 +28,7 @@ extern void wf_impl_operation_readdir (
 extern void wf_impl_operation_readdir_finished(
 	void * user_data,
 	json_t const * result,
-	json_t const * error);
+	struct wf_jsonrpc_error const * error);
 
 #ifdef __cplusplus
 }

lib/webfuse/impl/util/json_util.c

@@ -1,4 +1,5 @@
 #include "webfuse/impl/util/json_util.h"
+#include "webfuse/impl/jsonrpc/error.h"
 
 int wf_impl_json_get_int(json_t const * object, char const * key, int default_value)
 {
@@ -15,12 +16,12 @@ int wf_impl_json_get_int(json_t const * object, char const * key, int default_va
 
 wf_status 
 wf_impl_jsonrpc_get_status(
-	json_t const * error)
+	struct wf_jsonrpc_error const * error)
 {
 	wf_status status = WF_GOOD;
 	if (NULL != error)
 	{
-		status = wf_impl_json_get_int(error, "code", WF_BAD_FORMAT);
+		status = wf_impl_jsonrpc_error_code(error);
 	}
 
 	return status;

lib/webfuse/impl/util/json_util.h

@@ -9,6 +9,8 @@ extern "C"
 {
 #endif
 
+struct wf_jsonrpc_error;
+
 extern int
 wf_impl_json_get_int(
     json_t const * object,
@@ -17,7 +19,7 @@ wf_impl_json_get_int(
 
 extern wf_status 
 wf_impl_jsonrpc_get_status(
-    json_t const * error);
+    struct wf_jsonrpc_error const * error);
 
 #ifdef __cplusplus
 }

test/webfuse/jsonrpc/test_proxy.cc

@@ -1,5 +1,6 @@
 #include <gtest/gtest.h>
 #include "webfuse/impl/jsonrpc/proxy.h"
+#include "webfuse/impl/jsonrpc/error.h"
 #include "webfuse/impl/message.h"
 #include "webfuse/status.h"
 #include "webfuse/impl/timer/manager.h"
@@ -20,12 +21,6 @@ using testing::SaveArg;
 
 namespace
 {
-    int jsonrpc_get_status(json_t * error)
-    {
-        json_t * code = json_object_get(error, "code");
-        return (json_is_integer(code)) ? json_integer_value(code) : WF_BAD_FORMAT;
-    }
-
     struct SendContext
     {
         json_t * response;
@@ -65,7 +60,7 @@ namespace
     {
         bool is_called;
         json_t * result;
-        json_t * error;
+        wf_jsonrpc_error * error;
 
         FinishedContext()
         : is_called(false)
@@ -82,22 +77,24 @@ namespace
                 json_decref(result);
             }
 
-            if (nullptr != error)
+            wf_impl_jsonrpc_error_dispose(error);
-            {
-                json_decref(error);
-            }
         }
     };
 
     void jsonrpc_finished(
         void * user_data,
         json_t const * result,
-        json_t const * error)
+        wf_jsonrpc_error 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);
+
+        if (nullptr != error)
+        {
+            context->error = wf_impl_jsonrpc_error(wf_impl_jsonrpc_error_code(error),
+                wf_impl_jsonrpc_error_message(error));
+        }
     }
 }
 
@@ -305,7 +302,7 @@ TEST(wf_jsonrpc_proxy, timeout)
     wf_impl_timer_manager_check(timer_manager);
 
     ASSERT_TRUE(finished_context.is_called);
-    ASSERT_EQ(WF_BAD_TIMEOUT, jsonrpc_get_status(finished_context.error));
+    ASSERT_EQ(WF_BAD_TIMEOUT, wf_impl_jsonrpc_error_code(finished_context.error));
 
     wf_impl_jsonrpc_proxy_dispose(proxy);
     wf_impl_timer_manager_dispose(timer_manager);

test/webfuse/jsonrpc/test_response.cc

@@ -1,5 +1,6 @@
 #include <gtest/gtest.h>
 #include "webfuse/impl/jsonrpc/response_intern.h"
+#include "webfuse/impl/jsonrpc/error.h"
 #include "webfuse/status.h"
 
 TEST(wf_json_response, init_result)
@@ -32,8 +33,8 @@ TEST(wf_json_response, init_error)
     struct wf_jsonrpc_response response;
     wf_impl_jsonrpc_response_init(&response, message);
 
-    ASSERT_EQ(42, json_integer_value(json_object_get(response.error, "code")));
+    ASSERT_EQ(42, wf_impl_jsonrpc_error_code(response.error));
-    ASSERT_STREQ("Don't Panic!", json_string_value(json_object_get(response.error, "message")));
+    ASSERT_STREQ("Don't Panic!", wf_impl_jsonrpc_error_message(response.error));
     ASSERT_EQ(nullptr, response.result);
     ASSERT_EQ(23, response.id);
 
@@ -49,7 +50,7 @@ TEST(wf_json_response, init_fail_missing_result_and_error)
     struct wf_jsonrpc_response response;
     wf_impl_jsonrpc_response_init(&response, message);
 
-    ASSERT_EQ(WF_BAD_FORMAT, json_integer_value(json_object_get(response.error, "code")));
+    ASSERT_EQ(WF_BAD_FORMAT, wf_impl_jsonrpc_error_code(response.error));
     ASSERT_EQ(nullptr, response.result);
     ASSERT_EQ(12, response.id);
 
@@ -65,7 +66,7 @@ TEST(wf_json_response, init_fail_missing_id)
     struct wf_jsonrpc_response response;
     wf_impl_jsonrpc_response_init(&response, message);
 
-    ASSERT_EQ(WF_BAD_FORMAT, json_integer_value(json_object_get(response.error, "code")));
+    ASSERT_EQ(WF_BAD_FORMAT, wf_impl_jsonrpc_error_code(response.error));
     ASSERT_EQ(nullptr, response.result);
     ASSERT_EQ(-1, response.id);
 
@@ -82,7 +83,7 @@ TEST(wf_json_response, init_fail_wrong_id_type)
     struct wf_jsonrpc_response response;
     wf_impl_jsonrpc_response_init(&response, message);
 
-    ASSERT_EQ(WF_BAD_FORMAT, json_integer_value(json_object_get(response.error, "code")));
+    ASSERT_EQ(WF_BAD_FORMAT, wf_impl_jsonrpc_error_code(response.error));
     ASSERT_EQ(nullptr, response.result);
     ASSERT_EQ(-1, response.id);
 
@@ -101,7 +102,7 @@ TEST(wf_json_response, init_fail_error_missing_code)
     struct wf_jsonrpc_response response;
     wf_impl_jsonrpc_response_init(&response, message);
 
-    ASSERT_EQ(WF_BAD_FORMAT, json_integer_value(json_object_get(response.error, "code")));
+    ASSERT_EQ(WF_BAD_FORMAT, wf_impl_jsonrpc_error_code(response.error));
     ASSERT_EQ(nullptr, response.result);
     ASSERT_EQ(23, response.id);
 
@@ -121,7 +122,7 @@ TEST(wf_json_response, init_fail_error_wrong_code_type)
     struct wf_jsonrpc_response response;
     wf_impl_jsonrpc_response_init(&response, message);
 
-    ASSERT_EQ(WF_BAD_FORMAT, json_integer_value(json_object_get(response.error, "code")));
+    ASSERT_EQ(WF_BAD_FORMAT, wf_impl_jsonrpc_error_code(response.error));
     ASSERT_EQ(nullptr, response.result);
     ASSERT_EQ(23, response.id);
 
@@ -138,7 +139,7 @@ TEST(wf_json_response, init_fail_error_wrong_type)
     struct wf_jsonrpc_response response;
     wf_impl_jsonrpc_response_init(&response, message);
 
-    ASSERT_EQ(WF_BAD_FORMAT, json_integer_value(json_object_get(response.error, "code")));
+    ASSERT_EQ(WF_BAD_FORMAT, wf_impl_jsonrpc_error_code(response.error));
     ASSERT_EQ(nullptr, response.result);
     ASSERT_EQ(23, response.id);
 

test/webfuse/jsonrpc/test_response_parser.cc

@@ -2,6 +2,7 @@
 #include <gtest/gtest.h>
 
 #include "webfuse/impl/jsonrpc/response_intern.h"
+#include "webfuse/impl/jsonrpc/error.h"
 
 
 static void response_parse_str(
@@ -44,7 +45,7 @@ TEST(response_parser, test)
 	// 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, wf_impl_jsonrpc_error_code(response.error));
 	ASSERT_EQ(42, response.id);
 	ASSERT_EQ(nullptr, response.result);
 	wf_impl_jsonrpc_response_cleanup(&response);

test/webfuse/operation/test_getattr.cc

@@ -1,4 +1,5 @@
 #include "webfuse/impl/operation/getattr.h"
+#include "webfuse/impl/jsonrpc/error.h"
 
 #include "webfuse/status.h"
 
@@ -201,13 +202,12 @@ TEST(wf_impl_operation_getattr, finished_error)
     EXPECT_CALL(fuse, fuse_reply_open(_,_)).Times(0);
     EXPECT_CALL(fuse, fuse_reply_err(_, ENOENT)).Times(1).WillOnce(Return(0));
 
-    json_t * error = json_object();
+    wf_jsonrpc_error * error = wf_impl_jsonrpc_error(WF_BAD, "");
-    json_object_set_new(error, "code", json_integer(WF_BAD));
 
     auto * context = reinterpret_cast<wf_impl_operation_getattr_context*>(malloc(sizeof(wf_impl_operation_getattr_context)));
     context->inode = 1;
     context->gid = 0;
     context->uid = 0;
     wf_impl_operation_getattr_finished(context, nullptr, error);
-    json_decref(error);
+    wf_impl_jsonrpc_error_dispose(error);
 }

test/webfuse/operation/test_lookup.cc

@@ -1,4 +1,5 @@
 #include "webfuse/impl/operation/lookup.h"
+#include "webfuse/impl/jsonrpc/error.h"
 
 #include "webfuse/status.h"
 
@@ -243,13 +244,12 @@ TEST(wf_impl_operation_lookup, finished_error)
     EXPECT_CALL(fuse, fuse_reply_open(_,_)).Times(0);
     EXPECT_CALL(fuse, fuse_reply_err(_, ENOENT)).Times(1).WillOnce(Return(0));
 
-    json_t * error = json_object();
+    struct wf_jsonrpc_error * error = wf_impl_jsonrpc_error(WF_BAD, "");
-    json_object_set_new(error, "code", json_integer(WF_BAD));
 
     auto * context = reinterpret_cast<wf_impl_operation_lookup_context*>(malloc(sizeof(wf_impl_operation_lookup_context)));
     context->timeout = 1.0;
     context->gid = 0;
     context->uid = 0;
     wf_impl_operation_lookup_finished(context, nullptr, error);
-    json_decref(error);
+    wf_impl_jsonrpc_error_dispose(error);
 }

test/webfuse/operation/test_open.cc

@@ -1,4 +1,5 @@
 #include "webfuse/impl/operation/open.h"
+#include "webfuse/impl/jsonrpc/error.h"
 
 #include "webfuse/status.h"
 
@@ -70,10 +71,9 @@ TEST(wf_impl_operation_open, finished_fail_error)
     EXPECT_CALL(fuse, fuse_reply_open(_,_)).Times(0);
     EXPECT_CALL(fuse, fuse_reply_err(_, ENOENT)).Times(1).WillOnce(Return(0));
 
-    json_t * error = json_object();
+    struct wf_jsonrpc_error * error = wf_impl_jsonrpc_error(WF_BAD, "");
-    json_object_set_new(error, "code", json_integer(WF_BAD));
     wf_impl_operation_open_finished(nullptr, nullptr, error);
-    json_decref(error);
+    wf_impl_jsonrpc_error_dispose(error);
 }
 
 TEST(wf_impl_operation_open, finished_fail_no_handle)

test/webfuse/operation/test_read.cc

@@ -1,4 +1,5 @@
 #include "webfuse/impl/operation/read.h"
+#include "webfuse/impl/jsonrpc/error.h"
 
 #include "webfuse/mocks/mock_fuse.hpp"
 #include "webfuse/mocks/mock_operation_context.hpp"
@@ -230,8 +231,7 @@ TEST(wf_impl_operation_read, finished_fail_error)
     EXPECT_CALL(fuse, fuse_reply_buf(_,_,_)).Times(0);
     EXPECT_CALL(fuse, fuse_reply_err(_, _)).Times(1).WillOnce(Return(0));
 
-    json_t * error = json_object();
+    struct wf_jsonrpc_error * error = wf_impl_jsonrpc_error(WF_BAD, "");
-    json_object_set_new(error, "code", json_integer(WF_BAD));
     wf_impl_operation_read_finished(nullptr, nullptr, error);
-    json_decref(error);
+    wf_impl_jsonrpc_error_dispose(error);
 }

test/webfuse/operation/test_readdir.cc

@@ -1,4 +1,5 @@
 #include "webfuse/impl/operation/readdir.h"
+#include "webfuse/impl/jsonrpc/error.h"
 
 #include "webfuse/status.h"
 
@@ -142,15 +143,14 @@ TEST(wf_impl_operation_readdir, finished_fail_error)
     EXPECT_CALL(fuse, fuse_reply_buf(_,_,_)).Times(0);
     EXPECT_CALL(fuse, fuse_reply_err(_, ENOENT)).Times(1).WillOnce(Return(0));
 
-    json_t * error = json_array();
+    struct wf_jsonrpc_error * error = wf_impl_jsonrpc_error(WF_BAD, "");
-    json_object_set_new(error, "code", json_integer(WF_BAD));
 
     auto * context = reinterpret_cast<wf_impl_operation_readdir_context*>(malloc(sizeof(wf_impl_operation_readdir_context)));
     context->request = nullptr;
     context->size = 1;
     context->offset = 0;
     wf_impl_operation_readdir_finished(reinterpret_cast<void*>(context), nullptr, error);
-    json_decref(error);
+    wf_impl_jsonrpc_error_dispose(error);
 }
 
 TEST(wf_impl_operation_readdir, finished_fail_invalid_result_type)