json: add the lib prefix to wrapper functions

It makes it easier to audit for non-wrapped json-c usage.

1 files changed, 51 insertions, 51 deletions

diff --git a/src/json_rpc.c b/src/json_rpc.c
index 4a8879a..b81a5a0 100644
--- a/src/json_rpc.c
+++ b/src/json_rpc.c
@@ -36,7 +36,7 @@ static int jsonrpc_check_version(struct json_object *obj)
 	const char *key = jsonrpc_key_version;
 	const char *version = NULL;
 
-	int ret = json_get_string(obj, key, &version);
+	int ret = libjson_get_string(obj, key, &version);
 	if (ret < 0)
 		return ret;
 
@@ -50,7 +50,7 @@ static int jsonrpc_check_version(struct json_object *obj)
 
 static int jsonrpc_set_version(struct json_object *obj)
 {
-	return json_set_string_const_key(obj, jsonrpc_key_version, jsonrpc_value_version);
+	return libjson_set_string_const_key(obj, jsonrpc_key_version, jsonrpc_value_version);
 }
 
 static _Atomic int jsonrpc_id_counter = 1;
@@ -74,7 +74,7 @@ static int jsonrpc_check_id(struct json_object *obj, int required)
 {
 	const char *key = jsonrpc_key_id;
 
-	if (!json_has(obj, key)) {
+	if (!libjson_has(obj, key)) {
 		if (!required)
 			return 0;
 		log_err("JSON-RPC: key is missing: %s\n", key);
@@ -83,7 +83,7 @@ static int jsonrpc_check_id(struct json_object *obj, int required)
 
 	struct json_object *id = NULL;
 
-	int ret = json_get(obj, key, &id);
+	int ret = libjson_get(obj, key, &id);
 	if (ret < 0)
 		return ret;
 	return jsonrpc_check_id_type(id);
@@ -91,19 +91,19 @@ static int jsonrpc_check_id(struct json_object *obj, int required)
 
 static int jsonrpc_set_id(struct json_object *obj, int id)
 {
-	return json_set_int_const_key(obj, jsonrpc_key_id, id);
+	return libjson_set_int_const_key(obj, jsonrpc_key_id, id);
 }
 
 static int jsonrpc_check_method(struct json_object *obj)
 {
 	const char *key = jsonrpc_key_method;
 	const char *method = NULL;
-	return json_get_string(obj, key, &method);
+	return libjson_get_string(obj, key, &method);
 }
 
 static int jsonrpc_set_method(struct json_object *obj, const char *method)
 {
-	return json_set_string_const_key(obj, jsonrpc_key_method, method);
+	return libjson_set_string_const_key(obj, jsonrpc_key_method, method);
 }
 
 static int jsonrpc_check_params_type(struct json_object *params)
@@ -121,12 +121,12 @@ static int jsonrpc_check_params(struct json_object *obj)
 {
 	const char *key = jsonrpc_key_params;
 
-	if (!json_has(obj, key))
+	if (!libjson_has(obj, key))
 		return 0;
 
 	struct json_object *params = NULL;
 
-	int ret = json_get(obj, key, &params);
+	int ret = libjson_get(obj, key, &params);
 	if (ret < 0)
 		return ret;
 	return jsonrpc_check_params_type(params);
@@ -139,7 +139,7 @@ static int jsonrpc_set_params(struct json_object *obj, struct json_object *param
 	int ret = jsonrpc_check_params_type(params);
 	if (ret < 0)
 		return ret;
-	return json_set_const_key(obj, key, params);
+	return libjson_set_const_key(obj, key, params);
 }
 
 static const char *const jsonrpc_key_result = "result";
@@ -153,13 +153,13 @@ static int jsonrpc_check_error(struct json_object *obj)
 	const char *key = jsonrpc_key_error;
 	struct json_object *error = NULL;
 
-	int ret = json_get(obj, key, &error);
+	int ret = libjson_get(obj, key, &error);
 	if (ret < 0)
 		return ret;
 
 	int64_t code = -1;
 
-	ret = json_get_int(error, jsonrpc_key_code, &code);
+	ret = libjson_get_int(error, jsonrpc_key_code, &code);
 	if (ret < 0) {
 		log_err("JSON-RPC: key is missing or not an integer: %s\n", jsonrpc_key_code);
 		return -1;
@@ -167,7 +167,7 @@ static int jsonrpc_check_error(struct json_object *obj)
 
 	const char *message = NULL;
 
-	ret = json_get_string(error, jsonrpc_key_message, &message);
+	ret = libjson_get_string(error, jsonrpc_key_message, &message);
 	if (ret < 0) {
 		log_err("JSON-RPC: key is missing or not a string: %s\n", jsonrpc_key_message);
 		return -1;
@@ -181,12 +181,12 @@ static int jsonrpc_check_result_or_error(struct json_object *obj)
 	const char *key_result = jsonrpc_key_result;
 	const char *key_error = jsonrpc_key_error;
 
-	if (!json_has(obj, key_result) && !json_has(obj, key_error)) {
+	if (!libjson_has(obj, key_result) && !libjson_has(obj, key_error)) {
 		log_err("JSON-RPC: either '%s' or '%s' must be present\n", key_result, key_error);
 		return -1;
 	}
 
-	if (json_has(obj, key_result))
+	if (libjson_has(obj, key_result))
 		return 0;
 
 	return jsonrpc_check_error(obj);
@@ -204,7 +204,7 @@ static int jsonrpc_request_create_internal(struct jsonrpc_request **_request, in
 		goto exit;
 	}
 
-	ret = json_new_object(&request->impl);
+	ret = libjson_new_object(&request->impl);
 	if (ret < 0)
 		goto free;
 
@@ -232,7 +232,7 @@ static int jsonrpc_request_create_internal(struct jsonrpc_request **_request, in
 	goto exit;
 
 free_impl:
-	json_free(request->impl);
+	libjson_free(request->impl);
 free:
 	free(request);
 exit:
@@ -247,7 +247,7 @@ int jsonrpc_request_create(struct jsonrpc_request **_request, int id, const char
 
 void jsonrpc_request_destroy(struct jsonrpc_request *request)
 {
-	json_free(request->impl);
+	libjson_free(request->impl);
 	free(request);
 }
 
@@ -259,7 +259,7 @@ int jsonrpc_notification_create(struct jsonrpc_request **_request, const char *m
 
 int jsonrpc_request_is_notification(const struct jsonrpc_request *request)
 {
-	return !json_has(request->impl, jsonrpc_key_id);
+	return !libjson_has(request->impl, jsonrpc_key_id);
 }
 
 static int jsonrpc_request_from_json(struct jsonrpc_request **_request, struct json_object *impl)
@@ -292,12 +292,12 @@ static int jsonrpc_request_from_json(struct jsonrpc_request **_request, struct j
 
 int jsonrpc_request_send(const struct jsonrpc_request *request, int fd)
 {
-	return json_send(request->impl, fd);
+	return libjson_send(request->impl, fd);
 }
 
 int jsonrpc_request_recv(struct jsonrpc_request **request, int fd)
 {
-	struct json_object *impl = json_recv(fd);
+	struct json_object *impl = libjson_recv(fd);
 	if (!impl) {
 		log_err("JSON-RPC: failed to receive request\n");
 		return -1;
@@ -310,7 +310,7 @@ int jsonrpc_request_recv(struct jsonrpc_request **request, int fd)
 	return ret;
 
 free_impl:
-	json_free(impl);
+	libjson_free(impl);
 
 	return ret;
 }
@@ -318,7 +318,7 @@ free_impl:
 const char *jsonrpc_request_get_method(const struct jsonrpc_request *request)
 {
 	const char *method = NULL;
-	int ret = json_get_string(request->impl, jsonrpc_key_method, &method);
+	int ret = libjson_get_string(request->impl, jsonrpc_key_method, &method);
 	if (ret < 0) {
 		/* Should never happen. */
 		return NULL;
@@ -331,23 +331,23 @@ static struct json_object *jsonrpc_request_create_params(struct jsonrpc_request
 	int ret = 0;
 	const char *const key = jsonrpc_key_params;
 
-	if (!json_has(request->impl, key)) {
+	if (!libjson_has(request->impl, key)) {
 		struct json_object *params = NULL;
 
-		ret = json_new_object(&params);
+		ret = libjson_new_object(&params);
 		if (ret < 0)
 			return NULL;
 
-		ret = json_set(request->impl, key, params);
+		ret = libjson_set(request->impl, key, params);
 		if (ret < 0) {
-			json_free(params);
+			libjson_free(params);
 			return NULL;
 		}
 		return params;
 	}
 
 	struct json_object *params = NULL;
-	ret = json_get(request->impl, key, &params);
+	ret = libjson_get(request->impl, key, &params);
 	if (ret < 0)
 		return NULL;
 	return params;
@@ -357,10 +357,10 @@ int jsonrpc_request_get_param_string(const struct jsonrpc_request *request, cons
                                      const char **value)
 {
 	struct json_object *params = NULL;
-	int ret = json_get(request->impl, jsonrpc_key_params, &params);
+	int ret = libjson_get(request->impl, jsonrpc_key_params, &params);
 	if (ret < 0)
 		return ret;
-	return json_get_string(params, name, value);
+	return libjson_get_string(params, name, value);
 }
 
 int jsonrpc_request_set_param_string(struct jsonrpc_request *request, const char *name,
@@ -369,17 +369,17 @@ int jsonrpc_request_set_param_string(struct jsonrpc_request *request, const char
 	struct json_object *params = jsonrpc_request_create_params(request);
 	if (!params)
 		return -1;
-	return json_set_string(params, name, value);
+	return libjson_set_string(params, name, value);
 }
 
 int jsonrpc_request_get_param_int(const struct jsonrpc_request *request, const char *name,
                                   int64_t *value)
 {
 	struct json_object *params = NULL;
-	int ret = json_get(request->impl, jsonrpc_key_params, &params);
+	int ret = libjson_get(request->impl, jsonrpc_key_params, &params);
 	if (ret < 0)
 		return ret;
-	return json_get_int(params, name, value);
+	return libjson_get_int(params, name, value);
 }
 
 int jsonrpc_request_set_param_int(struct jsonrpc_request *request, const char *name, int64_t value)
@@ -387,12 +387,12 @@ int jsonrpc_request_set_param_int(struct jsonrpc_request *request, const char *n
 	struct json_object *params = jsonrpc_request_create_params(request);
 	if (!params)
 		return -1;
-	return json_set_int(params, name, value);
+	return libjson_set_int(params, name, value);
 }
 
 const char *jsonrpc_response_to_string(const struct jsonrpc_response *response)
 {
-	return json_to_string_pretty(response->impl);
+	return libjson_to_string_pretty(response->impl);
 }
 
 int jsonrpc_response_create_internal(struct jsonrpc_response **_response,
@@ -408,7 +408,7 @@ int jsonrpc_response_create_internal(struct jsonrpc_response **_response,
 		goto exit;
 	}
 
-	ret = json_new_object(&response->impl);
+	ret = libjson_new_object(&response->impl);
 	if (ret < 0)
 		goto free;
 
@@ -417,22 +417,22 @@ int jsonrpc_response_create_internal(struct jsonrpc_response **_response,
 		goto free_impl;
 
 	struct json_object *id = NULL;
-	ret = json_clone(request->impl, jsonrpc_key_id, &id);
+	ret = libjson_clone(request->impl, jsonrpc_key_id, &id);
 	if (ret < 0)
 		goto free_impl;
 
-	ret = json_set(response->impl, jsonrpc_key_id, id);
+	ret = libjson_set(response->impl, jsonrpc_key_id, id);
 	if (ret < 0) {
-		json_free(id);
+		libjson_free(id);
 		goto free_impl;
 	}
 
 	if (error) {
-		ret = json_set_const_key(response->impl, jsonrpc_key_error, error);
+		ret = libjson_set_const_key(response->impl, jsonrpc_key_error, error);
 		if (ret < 0)
 			goto free_impl;
 	} else {
-		ret = json_set_const_key(response->impl, jsonrpc_key_result, result);
+		ret = libjson_set_const_key(response->impl, jsonrpc_key_result, result);
 		if (ret < 0)
 			goto free_impl;
 	}
@@ -441,7 +441,7 @@ int jsonrpc_response_create_internal(struct jsonrpc_response **_response,
 	goto exit;
 
 free_impl:
-	json_free(response->impl);
+	libjson_free(response->impl);
 free:
 	free(response);
 exit:
@@ -456,7 +456,7 @@ int jsonrpc_response_create(struct jsonrpc_response **response,
 
 void jsonrpc_response_destroy(struct jsonrpc_response *response)
 {
-	json_free(response->impl);
+	libjson_free(response->impl);
 	free(response);
 }
 
@@ -466,14 +466,14 @@ int jsonrpc_error_create(struct jsonrpc_response **response, struct jsonrpc_requ
 	int ret = 0;
 	struct json_object *error = NULL;
 
-	ret = json_new_object(&error);
+	ret = libjson_new_object(&error);
 	if (ret < 0)
 		return ret;
 
-	ret = json_set_int_const_key(error, jsonrpc_key_code, code);
+	ret = libjson_set_int_const_key(error, jsonrpc_key_code, code);
 	if (ret < 0)
 		goto free;
-	ret = json_set_string_const_key(error, jsonrpc_key_message, message);
+	ret = libjson_set_string_const_key(error, jsonrpc_key_message, message);
 	if (ret < 0)
 		goto free;
 
@@ -484,14 +484,14 @@ int jsonrpc_error_create(struct jsonrpc_response **response, struct jsonrpc_requ
 	return ret;
 
 free:
-	json_free(error);
+	libjson_free(error);
 
 	return ret;
 }
 
 int jsonrpc_response_is_error(const struct jsonrpc_response *response)
 {
-	return json_has(response->impl, jsonrpc_key_error);
+	return libjson_has(response->impl, jsonrpc_key_error);
 }
 
 static int jsonrpc_response_from_json(struct jsonrpc_response **_response, struct json_object *impl)
@@ -521,12 +521,12 @@ static int jsonrpc_response_from_json(struct jsonrpc_response **_response, struc
 
 int jsonrpc_response_send(const struct jsonrpc_response *response, int fd)
 {
-	return json_send(response->impl, fd);
+	return libjson_send(response->impl, fd);
 }
 
 int jsonrpc_response_recv(struct jsonrpc_response **response, int fd)
 {
-	struct json_object *impl = json_recv(fd);
+	struct json_object *impl = libjson_recv(fd);
 	if (!impl) {
 		log_err("JSON-RPC: failed to receive response\n");
 		return -1;
@@ -539,7 +539,7 @@ int jsonrpc_response_recv(struct jsonrpc_response **response, int fd)
 	return ret;
 
 free_impl:
-	json_free(impl);
+	libjson_free(impl);
 
 	return ret;
 }