Archives/falk-werner_webfuse-provider
1
0
Fork 0
mirror of https://github.com/falk-werner/webfuse-provider synced 2024-10-27 20:44:10 +00:00
Code Issues Releases Wiki Activity

switched prefix to wfp for old wf stuff

Browse Source
This commit is contained in:
Falk Werner 2020-06-16 23:57:41 +02:00
parent 2f80ebffcc
commit 83b76a1a5a
133 changed files with 1324 additions and 1324 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
examples/provider/main.c
View File

@ -193,7 +193,7 @@ static void fs_lookup(
}
else
{
wfp_respond_error(request, WF_BAD_NOENTRY);
wfp_respond_error(request, WFP_BAD_NOENTRY);
}
}
@ -215,7 +215,7 @@ static void fs_getattr(
}
else
{
wfp_respond_error(request, WF_BAD_NOENTRY);
wfp_respond_error(request, WFP_BAD_NOENTRY);
}
}
@ -247,7 +247,7 @@ static void fs_readdir(
}
else
{
wfp_respond_error(request, WF_BAD_NOENTRY);
wfp_respond_error(request, WFP_BAD_NOENTRY);
}
}
@ -268,12 +268,12 @@ static void fs_open(
}
else
{
wfp_respond_error(request, WF_BAD_ACCESS_DENIED);
wfp_respond_error(request, WFP_BAD_ACCESS_DENIED);
}
}
else
{
wfp_respond_error(request, WF_BAD_NOENTRY);
wfp_respond_error(request, WFP_BAD_NOENTRY);
}
}
@ -305,12 +305,12 @@ static void fs_read(
}
else
{
wfp_respond_error(request, WF_BAD);
wfp_respond_error(request, WFP_BAD);
}
}
else
{
wfp_respond_error(request, WF_BAD_NOENTRY);
wfp_respond_error(request, WFP_BAD_NOENTRY);
}
}

12
examples/static_filesystem/static_filesystem.c
View File

@ -255,7 +255,7 @@ static void static_filesystem_lookup(
}
else
{
wfp_respond_error(request, WF_BAD_NOENTRY);
wfp_respond_error(request, WFP_BAD_NOENTRY);
}
}
@ -276,7 +276,7 @@ static void static_filesystem_getattr(
}
else
{
wfp_respond_error(request, WF_BAD_NOENTRY);
wfp_respond_error(request, WFP_BAD_NOENTRY);
}
}
@ -308,7 +308,7 @@ static void static_filesystem_readdir(
}
else
{
wfp_respond_error(request, WF_BAD_NOENTRY);
wfp_respond_error(request, WFP_BAD_NOENTRY);
}
}
@ -329,12 +329,12 @@ static void static_filesystem_open(
}
else
{
wfp_respond_error(request, WF_BAD_ACCESS_DENIED);
wfp_respond_error(request, WFP_BAD_ACCESS_DENIED);
}
}
else
{
wfp_respond_error(request, WF_BAD_NOENTRY);
wfp_respond_error(request, WFP_BAD_NOENTRY);
}
}
@ -361,7 +361,7 @@ static void static_filesystem_read(
}
else
{
wfp_respond_error(request, WF_BAD_NOENTRY);
wfp_respond_error(request, WFP_BAD_NOENTRY);
}
}

4
include/webfuse_provider/client.h
View File

@ -3,8 +3,8 @@
/// \brief Webfuse provider client.
////////////////////////////////////////////////////////////////////////////////
#ifndef WF_PROVIDER_CLIENT_H
#define WF_PROVIDER_CLIENT_H
#ifndef WFP_PROVIDER_CLIENT_H
#define WFP_PROVIDER_CLIENT_H
#include "webfuse_provider/api.h"

4
include/webfuse_provider/client_config.h
View File

@ -3,8 +3,8 @@
/// \brief Client configuration of webfuse provider.
////////////////////////////////////////////////////////////////////////////////
#ifndef WF_PROVIDER_CLIENT_CONFIG_H
#define WF_PROVIDER_CLIENT_CONFIG_H
#ifndef WFP_PROVIDER_CLIENT_CONFIG_H
#define WFP_PROVIDER_CLIENT_CONFIG_H
#include <webfuse_provider/api.h>

4
include/webfuse_provider/client_protocol.h
View File

@ -8,8 +8,8 @@
/// libwebsockets applications.
////////////////////////////////////////////////////////////////////////////////
#ifndef WF_PROVIDER_CLIENT_PROTOCOL_H
#define WF_PROVIDER_CLIENT_PROTOCOL_H
#ifndef WFP_PROVIDER_CLIENT_PROTOCOL_H
#define WFP_PROVIDER_CLIENT_PROTOCOL_H
#include "webfuse_provider/api.h"

4
include/webfuse_provider/credentials.h
View File

@ -1,5 +1,5 @@
#ifndef WF_PROVIDER_CREDENTIALS_H
#define WF_PROVIDER_CREDENTIALS_H
#ifndef WFP_PROVIDER_CREDENTIALS_H
#define WFP_PROVIDER_CREDENTIALS_H
#include <webfuse_provider/api.h>

4
include/webfuse_provider/dirbuffer.h
View File

@ -3,8 +3,8 @@
/// \brief Buffer used for directory listing.
////////////////////////////////////////////////////////////////////////////////
#ifndef WF_PROVIDER_DIRBUFFER_H
#define WF_PROVIDER_DIRBUFFER_H
#ifndef WFP_PROVIDER_DIRBUFFER_H
#define WFP_PROVIDER_DIRBUFFER_H
#include <sys/types.h>
#include <sys/stat.h>

2
include/webfuse_provider/operation/error.h
View File

@ -27,7 +27,7 @@ struct wfp_request;
//------------------------------------------------------------------------------
extern WFP_API void wfp_respond_error(
struct wfp_request * request,
wf_status status);
wfp_status status);
#ifdef __cplusplus
}

20
include/webfuse_provider/protocol_names.h
View File

@ -2,32 +2,32 @@
/// \file protocol_names.h
/// \brief Names of websocket protocol.
////////////////////////////////////////////////////////////////////////////////
#ifndef WF_PROTOCOL_NAMES_H
#define WF_PROTOCOL_NAMES_H
#ifndef WFP_PROTOCOL_NAMES_H
#define WFP_PROTOCOL_NAMES_H
//------------------------------------------------------------------------------
/// \def WF_PROTOCOL_NAME_ADAPTER_SERVER
/// \def WFP_PROTOCOL_NAME_ADAPTER_SERVER
/// \brief Name of the websocket protocol an adapter server is running.
//------------------------------------------------------------------------------
#define WF_PROTOCOL_NAME_ADAPTER_SERVER ("webfuse-adapter-server")
#define WFP_PROTOCOL_NAME_ADAPTER_SERVER ("webfuse-adapter-server")
//------------------------------------------------------------------------------
/// \def WF_PROTOCOL_NAME_ADAPTER_CLIENT
/// \def WFP_PROTOCOL_NAME_ADAPTER_CLIENT
/// \brief Name of the websocket protocol an adapter client is running.
//------------------------------------------------------------------------------
#define WF_PROTOCOL_NAME_ADAPTER_CLIENT ("webfuse-adapter-client")
#define WFP_PROTOCOL_NAME_ADAPTER_CLIENT ("webfuse-adapter-client")
//------------------------------------------------------------------------------
/// \def WF_PROTOCOL_NAME_PROVIDER_CLIENT
/// \def WFP_PROTOCOL_NAME_PROVIDER_CLIENT
/// \brief Name of the websocket protocol an provider client is running.
//------------------------------------------------------------------------------
#define WF_PROTOCOL_NAME_PROVIDER_CLIENT ("webfuse-provider-client")
#define WFP_PROTOCOL_NAME_PROVIDER_CLIENT ("webfuse-provider-client")
//------------------------------------------------------------------------------
/// \def WF_PROTOCOL_NAME_PROVIDER_SERVER
/// \def WFP_PROTOCOL_NAME_PROVIDER_SERVER
/// \brief Name of the websocket protocol an provider server is running.
//------------------------------------------------------------------------------
#define WF_PROTOCOL_NAME_PROVIDER_SERVER ("webfuse-provider-server")
#define WFP_PROTOCOL_NAME_PROVIDER_SERVER ("webfuse-provider-server")
#endif

22
include/webfuse_provider/status.h
View File

@ -3,21 +3,21 @@
/// \brief Generic status code.
////////////////////////////////////////////////////////////////////////////////
#ifndef WF_STATUS_H
#define WF_STATUS_H
#ifndef WFP_STATUS_H
#define WFP_STATUS_H
#define WF_GOOD 0 ///< Positive status code.
#define WF_BAD 1 ///< Generic negative status code.
#define WFP_GOOD 0 ///< Positive status code.
#define WFP_BAD 1 ///< Generic negative status code.
#define WF_BAD_NOTIMPLEMENTED 2 ///< The called function is not implemented (yet).
#define WF_BAD_TIMEOUT 3 ///< A timeout occured.
#define WF_BAD_BUSY 4 ///< Resource is busy, try again later.
#define WF_BAD_FORMAT 5 ///< Invalid format.
#define WFP_BAD_NOTIMPLEMENTED 2 ///< The called function is not implemented (yet).
#define WFP_BAD_TIMEOUT 3 ///< A timeout occured.
#define WFP_BAD_BUSY 4 ///< Resource is busy, try again later.
#define WFP_BAD_FORMAT 5 ///< Invalid format.
#define WF_BAD_NOENTRY 101 ///< Entry not found.
#define WF_BAD_ACCESS_DENIED 102 ///< Access is denied.
#define WFP_BAD_NOENTRY 101 ///< Entry not found.
#define WFP_BAD_ACCESS_DENIED 102 ///< Access is denied.
/// Status code.
typedef int wf_status;
typedef int wfp_status;
#endif

4
include/webfuse_provider/webfuse_provider.h
View File

@ -3,8 +3,8 @@
/// \brief Convenience header to include all functionality of libfuse_provider.
////////////////////////////////////////////////////////////////////////////////
#ifndef WF_PROVIDER_H
#define WF_PROVIDER_H
#ifndef WFP_PROVIDER_H
#define WFP_PROVIDER_H
#include <webfuse_provider/status.h>
#include <webfuse_provider/protocol_names.h>

2
lib/webfuse_provider/api.c
View File

@ -19,7 +19,7 @@
void wfp_respond_error(
struct wfp_request * request,
wf_status status)
wfp_status status)
{
wfp_impl_respond_error(request, status);
}

20
lib/webfuse_provider/impl/base64.c
View File

@ -1,6 +1,6 @@
#include "webfuse_provider/impl/base64.h"
static const uint8_t wf_base64_decode_table[256] = {
static const uint8_t wfp_base64_decode_table[256] = {
// 0 1 2 3 4 5 6 7 8 9 A B C D E F
0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0
0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 1
@ -22,12 +22,12 @@ static const uint8_t wf_base64_decode_table[256] = {
size_t wf_base64_encoded_size(size_t length)
size_t wfp_base64_encoded_size(size_t length)
{
return ((length + 2) / 3) * 4;
}
size_t wf_base64_encode(
size_t wfp_base64_encode(
uint8_t const * data,
size_t length,
char * buffer,
@ -36,7 +36,7 @@ size_t wf_base64_encode(
// 0 1 2 3 4 5 6
// 0123456789012345678901234567890123456789012345678901234567890123
static char const table[64] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
size_t const length_needed = wf_base64_encoded_size(length);
size_t const length_needed = wfp_base64_encoded_size(length);
if (buffer_size < length_needed)
{
return 0;
@ -78,7 +78,7 @@ size_t wf_base64_encode(
return out_pos;
}
size_t wf_base64_decoded_size(char const * data, size_t length)
size_t wfp_base64_decoded_size(char const * data, size_t length)
{
size_t result = 0;
if ((length > 0) && ((length % 4) == 0))
@ -98,14 +98,14 @@ size_t wf_base64_decoded_size(char const * data, size_t length)
return result;
}
size_t wf_base64_decode(
size_t wfp_base64_decode(
char const * data,
size_t length,
uint8_t * buffer,
size_t buffer_size)
{
uint8_t const * table = wf_base64_decode_table;
size_t needed_size = wf_base64_decoded_size(data, length);
uint8_t const * table = wfp_base64_decode_table;
size_t needed_size = wfp_base64_decoded_size(data, length);
if ((0 == needed_size) || (buffer_size < needed_size))
{
return 0;
@ -146,9 +146,9 @@ size_t wf_base64_decode(
return out_pos;
}
extern bool wf_base64_isvalid(char const * data, size_t length)
extern bool wfp_base64_isvalid(char const * data, size_t length)
{
uint8_t const * table = wf_base64_decode_table;
uint8_t const * table = wfp_base64_decode_table;
if ((length == 0) || ((length % 4) != 0))
{

14
lib/webfuse_provider/impl/base64.h
View File

@ -1,5 +1,5 @@
#ifndef WF_BASE64_H
#define WF_BASE64_H
#ifndef WFP_BASE64_H
#define WFP_BASE64_H
#ifndef __cplusplus
#include <inttypes.h>
@ -15,23 +15,23 @@ extern "C"
{
#endif
extern size_t wf_base64_encoded_size(size_t length);
extern size_t wfp_base64_encoded_size(size_t length);
extern size_t wf_base64_encode(
extern size_t wfp_base64_encode(
uint8_t const * data,
size_t length,
char * buffer,
size_t buffer_size);
extern size_t wf_base64_decoded_size(char const * data, size_t length);
extern size_t wfp_base64_decoded_size(char const * data, size_t length);
extern size_t wf_base64_decode(
extern size_t wfp_base64_decode(
char const * data,
size_t length,
uint8_t * buffer,
size_t buffer_size);
extern bool wf_base64_isvalid(char const * data, size_t length);
extern bool wfp_base64_isvalid(char const * data, size_t length);
#ifdef __cplusplus
}

2
lib/webfuse_provider/impl/client.c
View File

@ -27,7 +27,7 @@ struct wfp_client
struct wfp_client * wfp_impl_client_create(
struct wfp_client_config * config)
{
wf_lwslog_disable();
wfp_lwslog_disable();
struct wfp_client * client = malloc(sizeof(struct wfp_client));
wfp_impl_client_protocol_init(&client->protocol, &config->provider, config->user_data);

4
lib/webfuse_provider/impl/client.h
View File

@ -1,5 +1,5 @@
#ifndef WF_PROVIDER_IMPL_CLIENT_H
#define WF_PROVIDER_IMPL_CLIENT_H
#ifndef WFP_PROVIDER_IMPL_CLIENT_H
#define WFP_PROVIDER_IMPL_CLIENT_H
#ifndef __cplusplus
#include <stdbool.h>

4
lib/webfuse_provider/impl/client_config.h
View File

@ -1,5 +1,5 @@
#ifndef WF_PROVIDER_IMPL_CLIENT_CONFIG_H
#define WF_PROVIDER_IMPL_CLIENT_CONFIG_H
#ifndef WFP_PROVIDER_IMPL_CLIENT_CONFIG_H
#define WFP_PROVIDER_IMPL_CLIENT_CONFIG_H
#include "webfuse_provider/client_config.h"
#include "webfuse_provider/impl/provider.h"

62
lib/webfuse_provider/impl/client_protocol.c
View File

@ -22,7 +22,7 @@
#include "webfuse_provider/impl/jsonrpc/request.h"
#include "webfuse_provider/impl/jsonrpc/proxy.h"
#define WF_DEFAULT_TIMEOUT (10 * 1000)
#define WFP_DEFAULT_TIMEOUT (10 * 1000)
static void wfp_impl_client_protocol_respond(
json_t * response,
@ -30,10 +30,10 @@ static void wfp_impl_client_protocol_respond(
{
struct wfp_client_protocol * protocol = (struct wfp_client_protocol *) user_data;
struct wf_message * message = wf_message_create(response);
struct wfp_message * message = wfp_message_create(response);
if (NULL != message)
{
wf_slist_append(&protocol->messages, &message->item);
wfp_slist_append(&protocol->messages, &message->item);
lws_callback_on_writable(protocol->wsi);
}
}
@ -46,12 +46,12 @@ static void wfp_impl_client_protocol_process(
json_t * message = json_loadb(data, length, 0, NULL);
if (NULL != message)
{
if (wf_jsonrpc_is_response(message))
if (wfp_jsonrpc_is_response(message))
{
wf_jsonrpc_proxy_onresult(protocol->proxy, message);
wfp_jsonrpc_proxy_onresult(protocol->proxy, message);
}
if (wf_jsonrpc_is_request(message))
if (wfp_jsonrpc_is_request(message))
{
struct wfp_impl_invokation_context context =
{
@ -71,7 +71,7 @@ static void
wfp_impl_client_protocol_on_add_filesystem_finished(
void * user_data,
json_t const * result,
json_t const * WF_UNUSED_PARAM(error))
json_t const * WFP_UNUSED_PARAM(error))
{
struct wfp_client_protocol * protocol = user_data;
if (NULL == protocol->wsi) { return; }
@ -91,7 +91,7 @@ wfp_impl_client_protocol_on_add_filesystem_finished(
static void wfp_impl_client_protocol_add_filesystem(
struct wfp_client_protocol * protocol)
{
wf_jsonrpc_proxy_invoke(
wfp_jsonrpc_proxy_invoke(
protocol->proxy,
&wfp_impl_client_protocol_on_add_filesystem_finished,
protocol,
@ -104,7 +104,7 @@ static void
wfp_impl_client_protocol_on_authenticate_finished(
void * user_data,
json_t const * result,
json_t const * WF_UNUSED_PARAM(error))
json_t const * WFP_UNUSED_PARAM(error))
{
struct wfp_client_protocol * protocol = user_data;
if (NULL == protocol->wsi) { return; }
@ -132,7 +132,7 @@ static void wfp_impl_client_protocol_authenticate(
json_t * creds = wfp_impl_credentials_get(&credentials);
json_incref(creds);
wf_jsonrpc_proxy_invoke(
wfp_jsonrpc_proxy_invoke(
protocol->proxy,
&wfp_impl_client_protocol_on_authenticate_finished,
protocol,
@ -159,7 +159,7 @@ static void wfp_impl_client_protocol_handshake(
static int wfp_impl_client_protocol_callback(
struct lws * wsi,
enum lws_callback_reasons reason,
void * WF_UNUSED_PARAM(user),
void * WFP_UNUSED_PARAM(user),
void * in,
size_t len)
{
@ -169,7 +169,7 @@ static int wfp_impl_client_protocol_callback(
if (NULL != protocol)
{
wf_timer_manager_check(protocol->timer_manager);
wfp_timer_manager_check(protocol->timer_manager);
switch (reason)
{
@ -197,14 +197,14 @@ static int wfp_impl_client_protocol_callback(
{
result = 1;
}
else if (!wf_slist_empty(&protocol->messages))
else if (!wfp_slist_empty(&protocol->messages))
{
struct wf_slist_item * item = wf_slist_remove_first(&protocol->messages);
struct wf_message * message = wf_container_of(item, struct wf_message, item);
struct wfp_slist_item * item = wfp_slist_remove_first(&protocol->messages);
struct wfp_message * message = wfp_container_of(item, struct wfp_message, item);
lws_write(wsi, (unsigned char*) message->data, message->length, LWS_WRITE_TEXT);
wf_message_dispose(message);
wfp_message_dispose(message);
if (!wf_slist_empty(&protocol->messages))
if (!wfp_slist_empty(&protocol->messages))
{
lws_callback_on_writable(wsi);
}
@ -226,10 +226,10 @@ static bool wfp_impl_client_protocol_send(
bool result = false;
struct wfp_client_protocol * protocol = user_data;
struct wf_message * message = wf_message_create(request);
struct wfp_message * message = wfp_message_create(request);
if (NULL != message)
{
wf_slist_append(&protocol->messages, &message->item);
wfp_slist_append(&protocol->messages, &message->item);
lws_callback_on_writable(protocol->wsi);
result = true;
}
@ -244,15 +244,15 @@ void wfp_impl_client_protocol_init(
{
protocol->is_connected = false;
protocol->is_shutdown_requested = false;
wf_slist_init(&protocol->messages);
wfp_slist_init(&protocol->messages);
protocol->wsi = NULL;
protocol->request.respond = &wfp_impl_client_protocol_respond;
protocol->request.user_data = protocol;
protocol->timer_manager = wf_timer_manager_create();
protocol->proxy = wf_jsonrpc_proxy_create(protocol->timer_manager, WF_DEFAULT_TIMEOUT, &wfp_impl_client_protocol_send, protocol);
protocol->timer_manager = wfp_timer_manager_create();
protocol->proxy = wfp_jsonrpc_proxy_create(protocol->timer_manager, WFP_DEFAULT_TIMEOUT, &wfp_impl_client_protocol_send, protocol);
protocol->user_data = user_data;
wfp_impl_provider_init_from_prototype(&protocol->provider, provider);
@ -261,9 +261,9 @@ void wfp_impl_client_protocol_init(
void wfp_impl_client_protocol_cleanup(
struct wfp_client_protocol * protocol)
{
wf_jsonrpc_proxy_dispose(protocol->proxy);
wf_timer_manager_dispose(protocol->timer_manager);
wf_message_queue_cleanup(&protocol->messages);
wfp_jsonrpc_proxy_dispose(protocol->proxy);
wfp_timer_manager_dispose(protocol->timer_manager);
wfp_message_queue_cleanup(&protocol->messages);
}
struct wfp_client_protocol * wfp_impl_client_protocol_create(
@ -286,7 +286,7 @@ void wfp_impl_client_protocol_init_lws(
struct wfp_client_protocol * protocol,
struct lws_protocols * lws_protocol)
{
lws_protocol->name = WF_PROTOCOL_NAME_PROVIDER_CLIENT;
lws_protocol->name = WFP_PROTOCOL_NAME_PROVIDER_CLIENT;
lws_protocol->callback = &wfp_impl_client_protocol_callback;
lws_protocol->per_session_data_size = 0;
lws_protocol->user = protocol;
@ -297,8 +297,8 @@ void wfp_impl_client_protocol_connect(
struct lws_context * context,
char const * url)
{
struct wf_url url_data;
bool const success = wf_url_init(&url_data, url);
struct wfp_url url_data;
bool const success = wfp_url_init(&url_data, url);
if (success)
{
struct lws_client_connect_info info;
@ -310,13 +310,13 @@ void wfp_impl_client_protocol_connect(
info.host = info.address;
info.origin = info.address;
info.ssl_connection = (url_data.use_tls) ? LCCSCF_USE_SSL : 0;
info.protocol = WF_PROTOCOL_NAME_ADAPTER_SERVER;
info.local_protocol_name = WF_PROTOCOL_NAME_PROVIDER_CLIENT;
info.protocol = WFP_PROTOCOL_NAME_ADAPTER_SERVER;
info.local_protocol_name = WFP_PROTOCOL_NAME_PROVIDER_CLIENT;
info.pwsi = &protocol->wsi;
lws_client_connect_via_info(&info);
wf_url_cleanup(&url_data);
wfp_url_cleanup(&url_data);
}
else
{

14
lib/webfuse_provider/impl/client_protocol.h
View File

@ -1,5 +1,5 @@
#ifndef WF_PROVIDER_IMPL_CLIENT_PROTOCOL_H
#define WF_PROVIDER_IMPL_CLIENT_PROTOCOL_H
#ifndef WFP_PROVIDER_IMPL_CLIENT_PROTOCOL_H
#define WFP_PROVIDER_IMPL_CLIENT_PROTOCOL_H
#include "webfuse_provider/impl/provider.h"
#include "webfuse_provider/impl/request.h"
@ -14,8 +14,8 @@ extern "C"
struct wfp_client_config;
struct lws_protocols;
struct lws_context;
struct wf_jsonrpc_proxy;
struct wf_timer_manager;
struct wfp_jsonrpc_proxy;
struct wfp_timer_manager;
struct wfp_client_protocol
{
@ -25,9 +25,9 @@ struct wfp_client_protocol
struct wfp_provider provider;
void * user_data;
struct lws * wsi;
struct wf_timer_manager * timer_manager;
struct wf_jsonrpc_proxy * proxy;
struct wf_slist messages;
struct wfp_timer_manager * timer_manager;
struct wfp_jsonrpc_proxy * proxy;
struct wfp_slist messages;
};
extern void wfp_impl_client_protocol_init(

8
lib/webfuse_provider/impl/container_of.h
View File

@ -1,5 +1,5 @@
#ifndef WF_CONTAINER_OF_H
#define WF_CONTAINER_OF_H
#ifndef WFP_CONTAINER_OF_H
#define WFP_CONTAINER_OF_H
#ifndef __cplusplus
#include <stddef.h>
@ -8,13 +8,13 @@
#endif
#ifdef __GNUC__
#define wf_container_of(pointer, type, member) \
#define wfp_container_of(pointer, type, member) \
({ \
const typeof( ((type *)0)->member ) * __member = (pointer); \
(type *)( (char *)__member - offsetof(type, member) ); \
})
#else
#define wf_container_of(pointer, type, member) \
#define wfp_container_of(pointer, type, member) \
(type *) (((char *) pointer) - offsetof(type, member))
#endif

4
lib/webfuse_provider/impl/credentials.h
View File

@ -1,5 +1,5 @@
#ifndef WF_PROVIDER_IMPL_CREDENTIALS_H
#define WF_PROVIDER_IMPL_CREDENTIALS_H
#ifndef WFP_PROVIDER_IMPL_CREDENTIALS_H
#define WFP_PROVIDER_IMPL_CREDENTIALS_H
#include "webfuse_provider/credentials.h"
#include <jansson.h>

4
lib/webfuse_provider/impl/dirbuffer.h
View File

@ -1,5 +1,5 @@
#ifndef WF_PROVIDER_IMPL_DIRBUFFER_H
#define WF_PROVIDER_IMPL_DIRBUFFER_H
#ifndef WFP_PROVIDER_IMPL_DIRBUFFER_H
#define WFP_PROVIDER_IMPL_DIRBUFFER_H
#include <sys/types.h>
#include <sys/stat.h>

10
lib/webfuse_provider/impl/json_util.c
View File

@ -1,6 +1,6 @@
#include "webfuse_provider/impl/json_util.h"
int wf_impl_json_get_int(json_t const * object, char const * key, int default_value)
int wfp_impl_json_get_int(json_t const * object, char const * key, int default_value)
{
int result = default_value;
@ -13,14 +13,14 @@ int wf_impl_json_get_int(json_t const * object, char const * key, int default_va
return result;
}
wf_status
wf_impl_jsonrpc_get_status(
wfp_status
wfp_impl_jsonrpc_get_status(
json_t const * error)
{
wf_status status = WF_GOOD;
wfp_status status = WFP_GOOD;
if (NULL != error)
{
status = wf_impl_json_get_int(error, "code", WF_BAD_FORMAT);
status = wfp_impl_json_get_int(error, "code", WFP_BAD_FORMAT);
}
return status;

10
lib/webfuse_provider/impl/json_util.h
View File

@ -1,5 +1,5 @@
#ifndef WF_JSON_UTIL_H
#define WF_JSON_UTIL_H
#ifndef WFP_JSON_UTIL_H
#define WFP_JSON_UTIL_H
#include <jansson.h>
#include "webfuse_provider/status.h"
@ -10,13 +10,13 @@ extern "C"
#endif
extern int
wf_impl_json_get_int(
wfp_impl_json_get_int(
json_t const * object,
char const * key,
int default_value);
extern wf_status
wf_impl_jsonrpc_get_status(
extern wfp_status
wfp_impl_jsonrpc_get_status(
json_t const * error);
#ifdef __cplusplus

8
lib/webfuse_provider/impl/jsonrpc/error.c
View File

@ -1,7 +1,7 @@
#include "webfuse_provider/impl/jsonrpc/error.h"
json_t *
wf_jsonrpc_error(
wfp_jsonrpc_error(
int code,
char const * message)
{
@ -13,13 +13,13 @@ wf_jsonrpc_error(
}
void
wf_jsonrpc_propate_error(
wf_jsonrpc_proxy_finished_fn * finised,
wfp_jsonrpc_propate_error(
wfp_jsonrpc_proxy_finished_fn * finised,
void * user_data,
int code,
char const * message)
{
json_t * error = wf_jsonrpc_error(code, message);
json_t * error = wfp_jsonrpc_error(code, message);
finised(user_data, NULL, error);
json_decref(error);

10
lib/webfuse_provider/impl/jsonrpc/error.h
View File

@ -1,5 +1,5 @@
#ifndef WF_JSONRPC_ERROR_H
#define WF_JSONRPC_ERROR_H
#ifndef WFP_JSONRPC_ERROR_H
#define WFP_JSONRPC_ERROR_H
#include <jansson.h>
#include "webfuse_provider/impl/jsonrpc/proxy_finished_fn.h"
@ -10,13 +10,13 @@ extern "C"
#endif
extern json_t *
wf_jsonrpc_error(
wfp_jsonrpc_error(
int code,
char const * message);
extern void
wf_jsonrpc_propate_error(
wf_jsonrpc_proxy_finished_fn * finised,
wfp_jsonrpc_propate_error(
wfp_jsonrpc_proxy_finished_fn * finised,
void * user_data,
int code,
char const * message);

10
lib/webfuse_provider/impl/jsonrpc/method.c
View File

@ -2,12 +2,12 @@
#include <stdlib.h>
#include <string.h>
struct wf_jsonrpc_method * wf_jsonrpc_method_create(
struct wfp_jsonrpc_method * wfp_jsonrpc_method_create(
char const * method_name,
wf_jsonrpc_method_invoke_fn * invoke,
wfp_jsonrpc_method_invoke_fn * invoke,
void * user_data)
{
struct wf_jsonrpc_method * method = malloc(sizeof(struct wf_jsonrpc_method));
struct wfp_jsonrpc_method * method = malloc(sizeof(struct wfp_jsonrpc_method));
method->next = NULL;
method->name = strdup(method_name);
method->invoke = invoke;
@ -16,8 +16,8 @@ struct wf_jsonrpc_method * wf_jsonrpc_method_create(
return method;
}
void wf_jsonrpc_method_dispose(
struct wf_jsonrpc_method * method)
void wfp_jsonrpc_method_dispose(
struct wfp_jsonrpc_method * method)
{
free(method->name);
free(method);

20
lib/webfuse_provider/impl/jsonrpc/method.h
View File

@ -1,5 +1,5 @@
#ifndef WF_JSONRPC_METHOD_H
#define WF_JSONRPC_METHOD_H
#ifndef WFP_JSONRPC_METHOD_H
#define WFP_JSONRPC_METHOD_H
#include "webfuse_provider/impl/jsonrpc/method_invoke_fn.h"
@ -8,23 +8,23 @@ extern "C"
{
#endif
struct wf_jsonrpc_method
struct wfp_jsonrpc_method
{
struct wf_jsonrpc_method * next;
struct wfp_jsonrpc_method * next;
char * name;
wf_jsonrpc_method_invoke_fn * invoke;
wfp_jsonrpc_method_invoke_fn * invoke;
void * user_data;
};
extern struct wf_jsonrpc_method *
wf_jsonrpc_method_create(
extern struct wfp_jsonrpc_method *
wfp_jsonrpc_method_create(
char const * method_name,
wf_jsonrpc_method_invoke_fn * invoke,
wfp_jsonrpc_method_invoke_fn * invoke,
void * user_data);
extern void
wf_jsonrpc_method_dispose(
struct wf_jsonrpc_method * method);
wfp_jsonrpc_method_dispose(
struct wfp_jsonrpc_method * method);
#ifdef __cplusplus
}

10
lib/webfuse_provider/impl/jsonrpc/method_invoke_fn.h
View File

@ -1,5 +1,5 @@
#ifndef WF_JSONRPC_METHOD_INVOKE_FN_H
#define WF_JSONRPC_METHOD_INVOKE_FN_H
#ifndef WFP_JSONRPC_METHOD_INVOKE_FN_H
#define WFP_JSONRPC_METHOD_INVOKE_FN_H
#include <jansson.h>
@ -8,10 +8,10 @@ extern "C"
{
#endif
struct wf_jsonrpc_request;
struct wfp_jsonrpc_request;
typedef void wf_jsonrpc_method_invoke_fn(
struct wf_jsonrpc_request * request,
typedef void wfp_jsonrpc_method_invoke_fn(
struct wfp_jsonrpc_request * request,
char const * method_name,
json_t * params,
void * user_data);

92
lib/webfuse_provider/impl/jsonrpc/proxy.c
View File

@ -8,47 +8,47 @@
#include <stdlib.h>
#include <string.h>
struct wf_jsonrpc_proxy *
wf_jsonrpc_proxy_create(
struct wf_timer_manager * manager,
struct wfp_jsonrpc_proxy *
wfp_jsonrpc_proxy_create(
struct wfp_timer_manager * manager,
int timeout,
wf_jsonrpc_send_fn * send,
wfp_jsonrpc_send_fn * send,
void * user_data)
{
struct wf_jsonrpc_proxy * proxy = malloc(sizeof(struct wf_jsonrpc_proxy));
wf_jsonrpc_proxy_init(proxy, manager, timeout, send, user_data);
struct wfp_jsonrpc_proxy * proxy = malloc(sizeof(struct wfp_jsonrpc_proxy));
wfp_jsonrpc_proxy_init(proxy, manager, timeout, send, user_data);
return proxy;
}
void wf_jsonrpc_proxy_dispose(
struct wf_jsonrpc_proxy * proxy)
void wfp_jsonrpc_proxy_dispose(
struct wfp_jsonrpc_proxy * proxy)
{
wf_jsonrpc_proxy_cleanup(proxy);
wfp_jsonrpc_proxy_cleanup(proxy);
free(proxy);
}
static void wf_jsonrpc_proxy_on_timeout(
struct wf_timer * timer, void * proxy_ptr)
static void wfp_jsonrpc_proxy_on_timeout(
struct wfp_timer * timer, void * proxy_ptr)
{
struct wf_jsonrpc_proxy * proxy = proxy_ptr;
struct wfp_jsonrpc_proxy * proxy = proxy_ptr;
if (proxy->request.is_pending)
{
wf_jsonrpc_proxy_finished_fn * finished = proxy->request.finished;
wfp_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);
wfp_timer_cancel(timer);
wf_jsonrpc_propate_error(finished, user_data, WF_BAD_TIMEOUT, "Timeout");
wfp_jsonrpc_propate_error(finished, user_data, WFP_BAD_TIMEOUT, "Timeout");
}
}
static json_t * wf_jsonrpc_request_create(
static json_t * wfp_jsonrpc_request_create(
char const * method,
int id,
char const * param_info,
@ -98,44 +98,44 @@ static json_t * wf_jsonrpc_request_create(
return request;
}
void wf_jsonrpc_proxy_init(
struct wf_jsonrpc_proxy * proxy,
struct wf_timer_manager * timeout_manager,
void wfp_jsonrpc_proxy_init(
struct wfp_jsonrpc_proxy * proxy,
struct wfp_timer_manager * timeout_manager,
int timeout,
wf_jsonrpc_send_fn * send,
wfp_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_proxy_on_timeout, proxy);
proxy->request.timer = wfp_timer_create(timeout_manager,
&wfp_jsonrpc_proxy_on_timeout, proxy);
}
void wf_jsonrpc_proxy_cleanup(
struct wf_jsonrpc_proxy * proxy)
void wfp_jsonrpc_proxy_cleanup(
struct wfp_jsonrpc_proxy * proxy)
{
if (proxy->request.is_pending)
{
void * user_data = proxy->request.user_data;
wf_jsonrpc_proxy_finished_fn * finished = proxy->request.finished;
wfp_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);
wfp_timer_cancel(proxy->request.timer);
wf_jsonrpc_propate_error(finished, user_data, WF_BAD, "Bad: cancelled pending request during shutdown");
wfp_jsonrpc_propate_error(finished, user_data, WFP_BAD, "Bad: cancelled pending request during shutdown");
}
wf_timer_dispose(proxy->request.timer);
wfp_timer_dispose(proxy->request.timer);
}
void wf_jsonrpc_proxy_vinvoke(
struct wf_jsonrpc_proxy * proxy,
wf_jsonrpc_proxy_finished_fn * finished,
void wfp_jsonrpc_proxy_vinvoke(
struct wfp_jsonrpc_proxy * proxy,
wfp_jsonrpc_proxy_finished_fn * finished,
void * user_data,
char const * method_name,
char const * param_info,
@ -147,9 +147,9 @@ void wf_jsonrpc_proxy_vinvoke(
proxy->request.finished = finished;
proxy->request.user_data = user_data;
proxy->request.id = 42;
wf_timer_start(proxy->request.timer, proxy->timeout);
wfp_timer_start(proxy->request.timer, proxy->timeout);
json_t * request = wf_jsonrpc_request_create(method_name, proxy->request.id, param_info, args);
json_t * request = wfp_jsonrpc_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)
@ -158,9 +158,9 @@ void wf_jsonrpc_proxy_vinvoke(
proxy->request.finished = NULL;
proxy->request.user_data = NULL;
proxy->request.id = 0;
wf_timer_cancel(proxy->request.timer);
wfp_timer_cancel(proxy->request.timer);
wf_jsonrpc_propate_error(finished, user_data, WF_BAD, "Bad: requenst is not sent");
wfp_jsonrpc_propate_error(finished, user_data, WFP_BAD, "Bad: requenst is not sent");
}
if (NULL != request)
@ -170,17 +170,17 @@ void wf_jsonrpc_proxy_vinvoke(
}
else
{
wf_jsonrpc_propate_error(finished, user_data, WF_BAD_BUSY, "Busy");
wfp_jsonrpc_propate_error(finished, user_data, WFP_BAD_BUSY, "Busy");
}
}
extern void wf_jsonrpc_proxy_vnotify(
struct wf_jsonrpc_proxy * proxy,
extern void wfp_jsonrpc_proxy_vnotify(
struct wfp_jsonrpc_proxy * proxy,
char const * method_name,
char const * param_info,
va_list args)
{
json_t * request = wf_jsonrpc_request_create(method_name, 0, param_info, args);
json_t * request = wfp_jsonrpc_request_create(method_name, 0, param_info, args);
if (NULL != request)
{
@ -190,27 +190,27 @@ extern void wf_jsonrpc_proxy_vnotify(
}
void wf_jsonrpc_proxy_onresult(
struct wf_jsonrpc_proxy * proxy,
void wfp_jsonrpc_proxy_onresult(
struct wfp_jsonrpc_proxy * proxy,
json_t * message)
{
struct wf_jsonrpc_response response;
wf_jsonrpc_response_init(&response, message);
struct wfp_jsonrpc_response response;
wfp_jsonrpc_response_init(&response, message);
if ((proxy->request.is_pending) && (response.id == proxy->request.id))
{
wf_jsonrpc_proxy_finished_fn * finished = proxy->request.finished;
wfp_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);
wfp_timer_cancel(proxy->request.timer);
finished(user_data, response.result, response.error);
}
wf_jsonrpc_response_cleanup(&response);
wfp_jsonrpc_response_cleanup(&response);
}

34
lib/webfuse_provider/impl/jsonrpc/proxy.h
View File

@ -1,5 +1,5 @@
#ifndef WF_JSONRPC_PROXY_H
#define WF_JSONRPC_PROXY_H
#ifndef WFP_JSONRPC_PROXY_H
#define WFP_JSONRPC_PROXY_H
#ifndef __cplusplus
#include <stdarg.h>
@ -19,18 +19,18 @@ using std::size_t;
extern "C" {
#endif
struct wf_jsonrpc_proxy;
struct wf_timer_manager;
struct wfp_jsonrpc_proxy;
struct wfp_timer_manager;
extern struct wf_jsonrpc_proxy *
wf_jsonrpc_proxy_create(
struct wf_timer_manager * manager,
extern struct wfp_jsonrpc_proxy *
wfp_jsonrpc_proxy_create(
struct wfp_timer_manager * manager,
int timeout,
wf_jsonrpc_send_fn * send,
wfp_jsonrpc_send_fn * send,
void * user_data);
extern void wf_jsonrpc_proxy_dispose(
struct wf_jsonrpc_proxy * proxy);
extern void wfp_jsonrpc_proxy_dispose(
struct wfp_jsonrpc_proxy * proxy);
//------------------------------------------------------------------------------
/// \brief Invokes a method.
@ -46,24 +46,24 @@ extern void wf_jsonrpc_proxy_dispose(
/// \param param_info types of the param (s = string, i = integer, j = json)
/// \param ... params
//------------------------------------------------------------------------------
extern void wf_jsonrpc_proxy_invoke(
struct wf_jsonrpc_proxy * proxy,
wf_jsonrpc_proxy_finished_fn * finished,
extern void wfp_jsonrpc_proxy_invoke(
struct wfp_jsonrpc_proxy * proxy,
wfp_jsonrpc_proxy_finished_fn * finished,
void * user_data,
char const * method_name,
char const * param_info,
...
);
extern void wf_jsonrpc_proxy_notify(
struct wf_jsonrpc_proxy * proxy,
extern void wfp_jsonrpc_proxy_notify(
struct wfp_jsonrpc_proxy * proxy,
char const * method_name,
char const * param_info,
...
);
extern void wf_jsonrpc_proxy_onresult(
struct wf_jsonrpc_proxy * proxy,
extern void wfp_jsonrpc_proxy_onresult(
struct wfp_jsonrpc_proxy * proxy,
json_t * message);
#ifdef __cplusplus

6
lib/webfuse_provider/impl/jsonrpc/proxy_finished_fn.h
View File

@ -1,5 +1,5 @@
#ifndef WF_JSONRPC_PROXY_FINISHED_FN_H
#define WF_JSONRPC_PROXY_FINISHED_FN_H
#ifndef WFP_JSONRPC_PROXY_FINISHED_FN_H
#define WFP_JSONRPC_PROXY_FINISHED_FN_H
#include <jansson.h>
@ -8,7 +8,7 @@ extern "C"
{
#endif
typedef void wf_jsonrpc_proxy_finished_fn(
typedef void wfp_jsonrpc_proxy_finished_fn(
void * user_data,
json_t const * result,
json_t const * error);

40
lib/webfuse_provider/impl/jsonrpc/proxy_intern.h
View File

@ -1,5 +1,5 @@
#ifndef WF_JSONRPC_PROXY_INTERN_H
#define WF_JSONRPC_PROXY_INTERN_H
#ifndef WFP_JSONRPC_PROXY_INTERN_H
#define WFP_JSONRPC_PROXY_INTERN_H
#include "webfuse_provider/impl/jsonrpc/proxy.h"
#include "webfuse_provider/impl/jsonrpc/proxy_finished_fn.h"
@ -10,47 +10,47 @@ extern "C"
{
#endif
struct wf_timer;
struct wfp_timer;
struct wf_jsonrpc_request
struct wfp_jsonrpc_request
{
bool is_pending;
wf_jsonrpc_proxy_finished_fn * finished;
wfp_jsonrpc_proxy_finished_fn * finished;
void * user_data;
int id;
struct wf_timer * timer;
struct wfp_timer * timer;
};
struct wf_jsonrpc_proxy
struct wfp_jsonrpc_proxy
{
struct wf_jsonrpc_request request;
struct wfp_jsonrpc_request request;
int timeout;
wf_jsonrpc_send_fn * send;
wfp_jsonrpc_send_fn * send;
void * user_data;
};
extern void
wf_jsonrpc_proxy_init(
struct wf_jsonrpc_proxy * proxy,
struct wf_timer_manager * manager,
wfp_jsonrpc_proxy_init(
struct wfp_jsonrpc_proxy * proxy,
struct wfp_timer_manager * manager,
int timeout,
wf_jsonrpc_send_fn * send,
wfp_jsonrpc_send_fn * send,
void * user_data);
extern void
wf_jsonrpc_proxy_cleanup(
struct wf_jsonrpc_proxy * proxy);
wfp_jsonrpc_proxy_cleanup(
struct wfp_jsonrpc_proxy * proxy);
extern void wf_jsonrpc_proxy_vinvoke(
struct wf_jsonrpc_proxy * proxy,
wf_jsonrpc_proxy_finished_fn * finished,
extern void wfp_jsonrpc_proxy_vinvoke(
struct wfp_jsonrpc_proxy * proxy,
wfp_jsonrpc_proxy_finished_fn * finished,
void * user_data,
char const * method_name,
char const * param_info,
va_list args);
extern void wf_jsonrpc_proxy_vnotify(
struct wf_jsonrpc_proxy * proxy,
extern void wfp_jsonrpc_proxy_vnotify(
struct wfp_jsonrpc_proxy * proxy,
char const * method_name,
char const * param_info,
va_list args);

14
lib/webfuse_provider/impl/jsonrpc/proxy_variadic.c
View File

@ -1,8 +1,8 @@
#include "webfuse_provider/impl/jsonrpc/proxy_intern.h"
void wf_jsonrpc_proxy_invoke(
struct wf_jsonrpc_proxy * proxy,
wf_jsonrpc_proxy_finished_fn * finished,
void wfp_jsonrpc_proxy_invoke(
struct wfp_jsonrpc_proxy * proxy,
wfp_jsonrpc_proxy_finished_fn * finished,
void * user_data,
char const * method_name,
char const * param_info,
@ -10,12 +10,12 @@ void wf_jsonrpc_proxy_invoke(
{
va_list args;
va_start(args, param_info);
wf_jsonrpc_proxy_vinvoke(proxy, finished, user_data, method_name, param_info, args);
wfp_jsonrpc_proxy_vinvoke(proxy, finished, user_data, method_name, param_info, args);
va_end(args);
}
extern void wf_jsonrpc_proxy_notify(
struct wf_jsonrpc_proxy * proxy,
extern void wfp_jsonrpc_proxy_notify(
struct wfp_jsonrpc_proxy * proxy,
char const * method_name,
char const * param_info,
...
@ -23,6 +23,6 @@ extern void wf_jsonrpc_proxy_notify(
{
va_list args;
va_start(args, param_info);
wf_jsonrpc_proxy_vnotify(proxy, method_name, param_info, args);
wfp_jsonrpc_proxy_vnotify(proxy, method_name, param_info, args);
va_end(args);
}

36
lib/webfuse_provider/impl/jsonrpc/request.c
View File

@ -2,15 +2,15 @@
#include "webfuse_provider/impl/jsonrpc/error.h"
#include <stdlib.h>
struct wf_jsonrpc_request
struct wfp_jsonrpc_request
{
int id;
wf_jsonrpc_send_fn * send;
wfp_jsonrpc_send_fn * send;
void * user_data;
};
bool
wf_jsonrpc_is_request(
wfp_jsonrpc_is_request(
json_t * message)
{
json_t * id = json_object_get(message, "id");
@ -22,13 +22,13 @@ wf_jsonrpc_is_request(
}
struct wf_jsonrpc_request *
wf_jsonrpc_request_create(
struct wfp_jsonrpc_request *
wfp_jsonrpc_request_create(
int id,
wf_jsonrpc_send_fn * send,
wfp_jsonrpc_send_fn * send,
void * user_data)
{
struct wf_jsonrpc_request * request = malloc(sizeof(struct wf_jsonrpc_request));
struct wfp_jsonrpc_request * request = malloc(sizeof(struct wfp_jsonrpc_request));
request->id = id;
request->send = send;
request->user_data = user_data;
@ -37,23 +37,23 @@ wf_jsonrpc_request_create(
}
void
wf_jsonrpc_request_dispose(
struct wf_jsonrpc_request * request)
wfp_jsonrpc_request_dispose(
struct wfp_jsonrpc_request * request)
{
free(request);
}
void *
wf_jsonrpc_request_get_userdata(
struct wf_jsonrpc_request * request)
wfp_jsonrpc_request_get_userdata(
struct wfp_jsonrpc_request * request)
{
return request->user_data;
}
void
wf_jsonrpc_respond(
struct wf_jsonrpc_request * request,
wfp_jsonrpc_respond(
struct wfp_jsonrpc_request * request,
json_t * result)
{
json_t * response = json_object();
@ -62,20 +62,20 @@ wf_jsonrpc_respond(
request->send(response, request->user_data);
json_decref(response);
wf_jsonrpc_request_dispose(request);
wfp_jsonrpc_request_dispose(request);
}
void wf_jsonrpc_respond_error(
struct wf_jsonrpc_request * request,
void wfp_jsonrpc_respond_error(
struct wfp_jsonrpc_request * request,
int code,
char const * message)
{
json_t * response = json_object();
json_object_set_new(response, "error", wf_jsonrpc_error(code, message));
json_object_set_new(response, "error", wfp_jsonrpc_error(code, message));
json_object_set_new(response, "id", json_integer(request->id));
request->send(response, request->user_data);
json_decref(response);
wf_jsonrpc_request_dispose(request);
wfp_jsonrpc_request_dispose(request);
}

30
lib/webfuse_provider/impl/jsonrpc/request.h
View File

@ -1,5 +1,5 @@
#ifndef WF_JSONRPC_REQUEST_H
#define WF_JSONRPC_REQUEST_H
#ifndef WFP_JSONRPC_REQUEST_H
#define WFP_JSONRPC_REQUEST_H
#ifndef __cplusplus
#include <stdarg.h>
@ -19,29 +19,29 @@ extern "C"
{
#endif
struct wf_jsonrpc_request;
struct wfp_jsonrpc_request;
extern bool wf_jsonrpc_is_request(
extern bool wfp_jsonrpc_is_request(
json_t * message);
extern struct wf_jsonrpc_request *
wf_jsonrpc_request_create(
extern struct wfp_jsonrpc_request *
wfp_jsonrpc_request_create(
int id,
wf_jsonrpc_send_fn * send,
wfp_jsonrpc_send_fn * send,
void * user_data);
extern void wf_jsonrpc_request_dispose(
struct wf_jsonrpc_request * request);
extern void wfp_jsonrpc_request_dispose(
struct wfp_jsonrpc_request * request);
extern void * wf_jsonrpc_request_get_userdata(
struct wf_jsonrpc_request * request);
extern void * wfp_jsonrpc_request_get_userdata(
struct wfp_jsonrpc_request * request);
extern void wf_jsonrpc_respond(
struct wf_jsonrpc_request * request,
extern void wfp_jsonrpc_respond(
struct wfp_jsonrpc_request * request,
json_t * result);
extern void wf_jsonrpc_respond_error(
struct wf_jsonrpc_request * request,
extern void wfp_jsonrpc_respond_error(
struct wfp_jsonrpc_request * request,
int code,
char const * message);

14
lib/webfuse_provider/impl/jsonrpc/response.c
View File

@ -3,7 +3,7 @@
#include "webfuse_provider/status.h"
bool
wf_jsonrpc_is_response(
wfp_jsonrpc_is_response(
json_t * message)
{
json_t * id = json_object_get(message, "id");
@ -16,8 +16,8 @@ wf_jsonrpc_is_response(
void
wf_jsonrpc_response_init(
struct wf_jsonrpc_response * result,
wfp_jsonrpc_response_init(
struct wfp_jsonrpc_response * result,
json_t * response)
{
result->id = -1;
@ -27,7 +27,7 @@ wf_jsonrpc_response_init(
json_t * id_holder = json_object_get(response, "id");
if (!json_is_integer(id_holder))
{
result->error = wf_jsonrpc_error(WF_BAD_FORMAT, "invalid format: missing id");
result->error = wfp_jsonrpc_error(WFP_BAD_FORMAT, "invalid format: missing id");
return;
}
@ -47,14 +47,14 @@ wf_jsonrpc_response_init(
}
else
{
result->error = wf_jsonrpc_error(WF_BAD_FORMAT, "invalid format: invalid error object");
result->error = wfp_jsonrpc_error(WFP_BAD_FORMAT, "invalid format: invalid error object");
}
}
}
void
wf_jsonrpc_response_cleanup(
struct wf_jsonrpc_response * response)
wfp_jsonrpc_response_cleanup(
struct wfp_jsonrpc_response * response)
{
if (NULL != response->result)
{

6
lib/webfuse_provider/impl/jsonrpc/response.h
View File

@ -1,5 +1,5 @@
#ifndef WF_JSONRPC_RESPONSE_H
#define WF_JSONRPC_RESPONSE_H
#ifndef WFP_JSONRPC_RESPONSE_H
#define WFP_JSONRPC_RESPONSE_H
#ifndef __cplusplus
#include <stdbool.h>
@ -12,7 +12,7 @@ extern "C"
{
#endif
extern bool wf_jsonrpc_is_response(
extern bool wfp_jsonrpc_is_response(
json_t * message);
#ifdef __cplusplus

14
lib/webfuse_provider/impl/jsonrpc/response_intern.h
View File

@ -1,5 +1,5 @@
#ifndef WF_JSONRPC_RESPONSE_INTERN_H
#define WF_JSONRPC_RESPONSE_INTERN_H
#ifndef WFP_JSONRPC_RESPONSE_INTERN_H
#define WFP_JSONRPC_RESPONSE_INTERN_H
#include "webfuse_provider/impl/jsonrpc/response.h"
@ -14,19 +14,19 @@ using std::size_t;
extern "C" {
#endif
struct wf_jsonrpc_response
struct wfp_jsonrpc_response
{
json_t * result;
json_t * error;
int id;
};
extern void wf_jsonrpc_response_init(
struct wf_jsonrpc_response * response,
extern void wfp_jsonrpc_response_init(
struct wfp_jsonrpc_response * response,
json_t * message);
extern void wf_jsonrpc_response_cleanup(
struct wf_jsonrpc_response * response);
extern void wfp_jsonrpc_response_cleanup(
struct wfp_jsonrpc_response * response);
#ifdef __cplusplus
}

6
lib/webfuse_provider/impl/jsonrpc/send_fn.h
View File

@ -1,5 +1,5 @@
#ifndef WF_JSONRPC_SEND_FN_H
#define WF_JSONRPC_SEND_FN_H
#ifndef WFP_JSONRPC_SEND_FN_H
#define WFP_JSONRPC_SEND_FN_H
#ifndef __cplusplus
#include <stdbool.h>
@ -12,7 +12,7 @@ extern "C"
{
#endif
typedef bool wf_jsonrpc_send_fn(
typedef bool wfp_jsonrpc_send_fn(
json_t * request,
void * user_data);

84
lib/webfuse_provider/impl/jsonrpc/server.c
View File

@ -7,89 +7,89 @@
#include <stdlib.h>
#include <string.h>
struct wf_jsonrpc_server
struct wfp_jsonrpc_server
{
struct wf_jsonrpc_method * methods;
struct wfp_jsonrpc_method * methods;
};
static void
wf_jsonrpc_server_init(
struct wf_jsonrpc_server * server);
wfp_jsonrpc_server_init(
struct wfp_jsonrpc_server * server);
static void
wf_jsonrpc_server_cleanup(
struct wf_jsonrpc_server * server);
wfp_jsonrpc_server_cleanup(
struct wfp_jsonrpc_server * server);
struct wf_jsonrpc_server *
wf_jsonrpc_server_create(void)
struct wfp_jsonrpc_server *
wfp_jsonrpc_server_create(void)
{
struct wf_jsonrpc_server * server = malloc(sizeof(struct wf_jsonrpc_server));
wf_jsonrpc_server_init(server);
struct wfp_jsonrpc_server * server = malloc(sizeof(struct wfp_jsonrpc_server));
wfp_jsonrpc_server_init(server);
return server;
}
void
wf_jsonrpc_server_dispose(
struct wf_jsonrpc_server * server)
wfp_jsonrpc_server_dispose(
struct wfp_jsonrpc_server * server)
{
wf_jsonrpc_server_cleanup(server);
wfp_jsonrpc_server_cleanup(server);
free(server);
}
static void wf_jsonrpc_server_init(
struct wf_jsonrpc_server * server)
static void wfp_jsonrpc_server_init(
struct wfp_jsonrpc_server * server)
{
server->methods = NULL;
}
static void wf_jsonrpc_server_cleanup(
struct wf_jsonrpc_server * server)
static void wfp_jsonrpc_server_cleanup(
struct wfp_jsonrpc_server * server)
{
struct wf_jsonrpc_method * current = server->methods;
struct wfp_jsonrpc_method * current = server->methods;
while (NULL != current)
{
struct wf_jsonrpc_method * next = current->next;
wf_jsonrpc_method_dispose(current);
struct wfp_jsonrpc_method * next = current->next;
wfp_jsonrpc_method_dispose(current);
current = next;
}
server->methods = NULL;
}
void wf_jsonrpc_server_add(
struct wf_jsonrpc_server * server,
void wfp_jsonrpc_server_add(
struct wfp_jsonrpc_server * server,
char const * method_name,
wf_jsonrpc_method_invoke_fn * invoke,
wfp_jsonrpc_method_invoke_fn * invoke,
void * user_data)
{
struct wf_jsonrpc_method * method = wf_jsonrpc_method_create(method_name, invoke, user_data);
struct wfp_jsonrpc_method * method = wfp_jsonrpc_method_create(method_name, invoke, user_data);
method->next = server->methods;
server->methods = method;
}
static void wf_jsonrpc_server_invalid_method_invoke(
struct wf_jsonrpc_request * request,
char const * WF_UNUSED_PARAM(method_name),
json_t * WF_UNUSED_PARAM(params),
void * WF_UNUSED_PARAM(user_data))
static void wfp_jsonrpc_server_invalid_method_invoke(
struct wfp_jsonrpc_request * request,
char const * WFP_UNUSED_PARAM(method_name),
json_t * WFP_UNUSED_PARAM(params),
void * WFP_UNUSED_PARAM(user_data))
{
wf_jsonrpc_respond_error(request, WF_BAD_NOTIMPLEMENTED, "not implemented");
wfp_jsonrpc_respond_error(request, WFP_BAD_NOTIMPLEMENTED, "not implemented");
}
static struct wf_jsonrpc_method const wf_jsonrpc_server_invalid_method =
static struct wfp_jsonrpc_method const wfp_jsonrpc_server_invalid_method =
{
.next = NULL,
.name = "<invalid>",
.invoke = &wf_jsonrpc_server_invalid_method_invoke,
.invoke = &wfp_jsonrpc_server_invalid_method_invoke,
.user_data = NULL
};
static struct wf_jsonrpc_method const *
wf_jsonrpc_server_get_method(
struct wf_jsonrpc_server * server,
static struct wfp_jsonrpc_method const *
wfp_jsonrpc_server_get_method(
struct wfp_jsonrpc_server * server,
char const * method_name)
{
struct wf_jsonrpc_method const * current = server->methods;
struct wfp_jsonrpc_method const * current = server->methods;
while (NULL != current)
{
if (0 == strcmp(method_name, current->name))
@ -100,13 +100,13 @@ wf_jsonrpc_server_get_method(
current = current->next;
}
return &wf_jsonrpc_server_invalid_method;
return &wfp_jsonrpc_server_invalid_method;
}
void wf_jsonrpc_server_process(
struct wf_jsonrpc_server * server,
void wfp_jsonrpc_server_process(
struct wfp_jsonrpc_server * server,
json_t * request_data,
wf_jsonrpc_send_fn * send,
wfp_jsonrpc_send_fn * send,
void * user_data)
{
json_t * method_holder = json_object_get(request_data, "method");
@ -119,8 +119,8 @@ void wf_jsonrpc_server_process(
{
char const * method_name = json_string_value(method_holder);
int id = json_integer_value(id_holder);
struct wf_jsonrpc_request * request = wf_jsonrpc_request_create(id, send, user_data);
struct wf_jsonrpc_method const * method = wf_jsonrpc_server_get_method(server, method_name);
struct wfp_jsonrpc_request * request = wfp_jsonrpc_request_create(id, send, user_data);
struct wfp_jsonrpc_method const * method = wfp_jsonrpc_server_get_method(server, method_name);
method->invoke(request, method_name, params, method->user_data);
}

26
lib/webfuse_provider/impl/jsonrpc/server.h
View File

@ -1,5 +1,5 @@
#ifndef WF_JSONRPC_SERVER_H
#define WF_JSONRPC_SERVER_H
#ifndef WFP_JSONRPC_SERVER_H
#define WFP_JSONRPC_SERVER_H
#ifndef __cplusplus
#include <stdarg.h>
@ -17,25 +17,25 @@ extern "C"
{
#endif
struct wf_jsonrpc_server;
struct wfp_jsonrpc_server;
extern struct wf_jsonrpc_server *
wf_jsonrpc_server_create(void);
extern struct wfp_jsonrpc_server *
wfp_jsonrpc_server_create(void);
extern void
wf_jsonrpc_server_dispose(
struct wf_jsonrpc_server * server);
wfp_jsonrpc_server_dispose(
struct wfp_jsonrpc_server * server);
extern void wf_jsonrpc_server_add(
struct wf_jsonrpc_server * server,
extern void wfp_jsonrpc_server_add(
struct wfp_jsonrpc_server * server,
char const * method_name,
wf_jsonrpc_method_invoke_fn * invoke,
wfp_jsonrpc_method_invoke_fn * invoke,
void * user_data);
extern void wf_jsonrpc_server_process(
struct wf_jsonrpc_server * server,
extern void wfp_jsonrpc_server_process(
struct wfp_jsonrpc_server * server,
json_t * request,
wf_jsonrpc_send_fn * send,
wfp_jsonrpc_send_fn * send,
void * user_data);
#ifdef __cplusplus

12
lib/webfuse_provider/impl/lws_log.c
View File

@ -2,16 +2,16 @@
#include <stdbool.h>
#include <libwebsockets.h>
#define WF_LWSLOG_DISABLE 0
#define WFP_LWSLOG_DISABLE 0
static bool wf_lwslog_is_diabled = false;
static bool wfp_lwslog_is_diabled = false;
void wf_lwslog_disable(void)
void wfp_lwslog_disable(void)
{
if (!wf_lwslog_is_diabled)
if (!wfp_lwslog_is_diabled)
{
lws_set_log_level(WF_LWSLOG_DISABLE, NULL);
wf_lwslog_is_diabled = true;
lws_set_log_level(WFP_LWSLOG_DISABLE, NULL);
wfp_lwslog_is_diabled = true;
}
}

6
lib/webfuse_provider/impl/lws_log.h
View File

@ -1,12 +1,12 @@
#ifndef WF_LWS_LOG_H
#define WF_LWS_LOG_H
#ifndef WFP_LWS_LOG_H
#define WFP_LWS_LOG_H
#ifdef __cplusplus
extern "C"
{
#endif
extern void wf_lwslog_disable(void);
extern void wfp_lwslog_disable(void);
#ifdef __cplusplus
}

14
lib/webfuse_provider/impl/message.c
View File

@ -3,16 +3,16 @@
#include <stdlib.h>
#include <libwebsockets.h>
extern struct wf_message * wf_message_create(json_t const * value)
extern struct wfp_message * wfp_message_create(json_t const * value)
{
struct wf_message * message = NULL;
struct wfp_message * message = NULL;
size_t const length = json_dumpb(value, NULL, 0, JSON_COMPACT);
if (0 < length)
{
char * data = malloc(sizeof(struct wf_message) + LWS_PRE + length);
message = (struct wf_message *) data;
message->data = &data[sizeof(struct wf_message) + LWS_PRE];
char * data = malloc(sizeof(struct wfp_message) + LWS_PRE + length);
message = (struct wfp_message *) data;
message->data = &data[sizeof(struct wfp_message) + LWS_PRE];
message->length = length;
json_dumpb(value, message->data, length, JSON_COMPACT);
@ -21,8 +21,8 @@ extern struct wf_message * wf_message_create(json_t const * value)
return message;
}
void wf_message_dispose(
struct wf_message * message)
void wfp_message_dispose(
struct wfp_message * message)
{
free(message);
}

14
lib/webfuse_provider/impl/message.h
View File

@ -1,5 +1,5 @@
#ifndef WF_MESSAGE_H
#define WF_MESSAGE_H
#ifndef WFP_MESSAGE_H
#define WFP_MESSAGE_H
#ifndef __cplusplus
#include <stddef.h>
@ -11,9 +11,9 @@ using std::size_t;
#include <jansson.h>
#include "webfuse_provider/impl/slist.h"
struct wf_message
struct wfp_message
{
struct wf_slist_item item;
struct wfp_slist_item item;
char * data;
size_t length;
};
@ -23,11 +23,11 @@ extern "C"
{
#endif
extern struct wf_message * wf_message_create(
extern struct wfp_message * wfp_message_create(
json_t const * value);
extern void wf_message_dispose(
struct wf_message * message);
extern void wfp_message_dispose(
struct wfp_message * message);
#ifdef __cplusplus
}

14
lib/webfuse_provider/impl/message_queue.c
View File

@ -2,16 +2,16 @@
#include "webfuse_provider/impl/message.h"
#include "webfuse_provider/impl/container_of.h"
void wf_message_queue_cleanup(
struct wf_slist * queue)
void wfp_message_queue_cleanup(
struct wfp_slist * queue)
{
struct wf_slist_item * item = wf_slist_first(queue);
struct wfp_slist_item * item = wfp_slist_first(queue);
while (NULL != item)
{
struct wf_slist_item * next = item->next;
struct wf_message * message = wf_container_of(item, struct wf_message, item);
wf_message_dispose(message);
struct wfp_slist_item * next = item->next;
struct wfp_message * message = wfp_container_of(item, struct wfp_message, item);
wfp_message_dispose(message);
item = next;
}
wf_slist_init(queue);
wfp_slist_init(queue);
}

10
lib/webfuse_provider/impl/message_queue.h
View File

@ -1,15 +1,15 @@
#ifndef WF_MESSAGE_QUEUE_H
#define WF_MESSAGE_QUEUE_H
#ifndef WFP_MESSAGE_QUEUE_H
#define WFP_MESSAGE_QUEUE_H
#ifdef __cplusplus
extern "C"
{
#endif
struct wf_slist;
struct wfp_slist;
extern void wf_message_queue_cleanup(
struct wf_slist * queue);
extern void wfp_message_queue_cleanup(
struct wfp_slist * queue);
#ifdef __cplusplus

10
lib/webfuse_provider/impl/operation/close.c
View File

@ -5,7 +5,7 @@
void wfp_impl_close(
struct wfp_impl_invokation_context * context,
json_t * params,
int WF_UNUSED_PARAM(id))
int WFP_UNUSED_PARAM(id))
{
size_t const param_count = json_array_size(params);
if (4 == param_count)
@ -29,10 +29,10 @@ void wfp_impl_close(
}
void wfp_impl_close_default(
ino_t WF_UNUSED_PARAM(inode),
uint32_t WF_UNUSED_PARAM(handle),
int WF_UNUSED_PARAM(flags),
void * WF_UNUSED_PARAM(user_data))
ino_t WFP_UNUSED_PARAM(inode),
uint32_t WFP_UNUSED_PARAM(handle),
int WFP_UNUSED_PARAM(flags),
void * WFP_UNUSED_PARAM(user_data))
{
// empty
}

4
lib/webfuse_provider/impl/operation/close.h
View File

@ -1,5 +1,5 @@
#ifndef WF_PROVIDER_IMPL_OPERATION_CLOSE_H
#define WF_PROVIDER_IMPL_OPERATION_CLOSE_H
#ifndef WFP_PROVIDER_IMPL_OPERATION_CLOSE_H
#define WFP_PROVIDER_IMPL_OPERATION_CLOSE_H
#include "webfuse_provider/impl/provider.h"

2
lib/webfuse_provider/impl/operation/error.h
View File

@ -13,7 +13,7 @@ struct wfp_request;
extern WFP_API void wfp_impl_respond_error(
struct wfp_request * request,
wf_status status);
wfp_status status);
#ifdef __cplusplus
}

6
lib/webfuse_provider/impl/operation/getattr.c
View File

@ -29,10 +29,10 @@ void wfp_impl_getattr(
void wfp_impl_getattr_default(
struct wfp_request * request,
ino_t WF_UNUSED_PARAM(inode),
void * WF_UNUSED_PARAM(user_data))
ino_t WFP_UNUSED_PARAM(inode),
void * WFP_UNUSED_PARAM(user_data))
{
wfp_impl_respond_error(request, WF_BAD_NOENTRY);
wfp_impl_respond_error(request, WFP_BAD_NOENTRY);
}
void wfp_impl_respond_getattr(

4
lib/webfuse_provider/impl/operation/getattr.h
View File

@ -1,5 +1,5 @@
#ifndef WF_PROVIDER_IMPL_OPERATION_GETATTR_H
#define WF_PROVIDER_IMPL_OPERATION_GETATTR_H
#ifndef WFP_PROVIDER_IMPL_OPERATION_GETATTR_H
#define WFP_PROVIDER_IMPL_OPERATION_GETATTR_H
#include "webfuse_provider/impl/provider.h"

8
lib/webfuse_provider/impl/operation/lookup.c
View File

@ -59,10 +59,10 @@ void wfp_impl_respond_lookup(
void wfp_impl_lookup_default(
struct wfp_request * request,
ino_t WF_UNUSED_PARAM(parent),
char const * WF_UNUSED_PARAM(name),
void * WF_UNUSED_PARAM(user_data))
ino_t WFP_UNUSED_PARAM(parent),
char const * WFP_UNUSED_PARAM(name),
void * WFP_UNUSED_PARAM(user_data))
{
wfp_impl_respond_error(request, WF_BAD_NOENTRY);
wfp_impl_respond_error(request, WFP_BAD_NOENTRY);
}

4
lib/webfuse_provider/impl/operation/lookup.h
View File

@ -1,5 +1,5 @@
#ifndef WF_PROVIDER_IMPL_OPERATION_LOOKUP_H
#define WF_PROVIDER_IMPL_OPERATION_LOOKUP_H
#ifndef WFP_PROVIDER_IMPL_OPERATION_LOOKUP_H
#define WFP_PROVIDER_IMPL_OPERATION_LOOKUP_H
#include "webfuse_provider/impl/provider.h"

8
lib/webfuse_provider/impl/operation/open.c
View File

@ -29,11 +29,11 @@ void wfp_impl_open(
void wfp_impl_open_default(
struct wfp_request * request,
ino_t WF_UNUSED_PARAM(inode),
int WF_UNUSED_PARAM(flags),
void * WF_UNUSED_PARAM(user_data))
ino_t WFP_UNUSED_PARAM(inode),
int WFP_UNUSED_PARAM(flags),
void * WFP_UNUSED_PARAM(user_data))
{
wfp_impl_respond_error(request, WF_BAD_NOENTRY);
wfp_impl_respond_error(request, WFP_BAD_NOENTRY);
}
void wfp_impl_respond_open(

4
lib/webfuse_provider/impl/operation/open.h
View File

@ -1,5 +1,5 @@
#ifndef WF_PROVIDER_IMPL_OPERATION_OPEN_H
#define WF_PROVIDER_IMPL_OPERATION_OPEN_H
#ifndef WFP_PROVIDER_IMPL_OPERATION_OPEN_H
#define WFP_PROVIDER_IMPL_OPERATION_OPEN_H
#include "webfuse_provider/impl/provider.h"

16
lib/webfuse_provider/impl/operation/read.c
View File

@ -38,13 +38,13 @@ void wfp_impl_read(
void wfp_impl_read_default(
struct wfp_request * request,
ino_t WF_UNUSED_PARAM(inode),
uint32_t WF_UNUSED_PARAM(handle),
size_t WF_UNUSED_PARAM(offset),
size_t WF_UNUSED_PARAM(length),
void * WF_UNUSED_PARAM(user_data))
ino_t WFP_UNUSED_PARAM(inode),
uint32_t WFP_UNUSED_PARAM(handle),
size_t WFP_UNUSED_PARAM(offset),
size_t WFP_UNUSED_PARAM(length),
void * WFP_UNUSED_PARAM(user_data))
{
wfp_impl_respond_error(request, WF_BAD_NOENTRY);
wfp_impl_respond_error(request, WFP_BAD_NOENTRY);
}
void wfp_impl_respond_read(
@ -54,9 +54,9 @@ void wfp_impl_respond_read(
{
if (0 < length)
{
size_t const size = wf_base64_encoded_size(length) + 1;
size_t const size = wfp_base64_encoded_size(length) + 1;
char * buffer = malloc(size);
wf_base64_encode((uint8_t const *) data, length, buffer, size);
wfp_base64_encode((uint8_t const *) data, length, buffer, size);
json_t * result = json_object();
json_object_set_new(result, "data", json_string(buffer));

4
lib/webfuse_provider/impl/operation/read.h
View File

@ -1,5 +1,5 @@
#ifndef WF_PROVIDER_IMPL_OPERATION_READ_H
#define WF_PROVIDER_IMPL_OPERATION_READ_H
#ifndef WFP_PROVIDER_IMPL_OPERATION_READ_H
#define WFP_PROVIDER_IMPL_OPERATION_READ_H
#include "webfuse_provider/impl/provider.h"

6
lib/webfuse_provider/impl/operation/readdir.c
View File

@ -26,10 +26,10 @@ void wfp_impl_readdir(
void wfp_impl_readdir_default(
struct wfp_request * request,
ino_t WF_UNUSED_PARAM(directory),
void * WF_UNUSED_PARAM(user_data))
ino_t WFP_UNUSED_PARAM(directory),
void * WFP_UNUSED_PARAM(user_data))
{
wfp_impl_respond_error(request, WF_BAD_NOENTRY);
wfp_impl_respond_error(request, WFP_BAD_NOENTRY);
}
void wfp_impl_respond_readdir(

4
lib/webfuse_provider/impl/operation/readdir.h
View File

@ -1,5 +1,5 @@
#ifndef WF_PROVIDER_IMPL_OPERATION_READDIR_H
#define WF_PROVIDER_IMPL_OPERATION_READDIR_H
#ifndef WFP_PROVIDER_IMPL_OPERATION_READDIR_H
#define WFP_PROVIDER_IMPL_OPERATION_READDIR_H
#include "webfuse_provider/impl/provider.h"

4
lib/webfuse_provider/impl/provider.h
View File

@ -1,5 +1,5 @@
#ifndef WF_PROVIDER_IMPL_PROVIDER_H
#define WF_PROVIDER_IMPL_PROVIDER_H
#ifndef WFP_PROVIDER_IMPL_PROVIDER_H
#define WFP_PROVIDER_IMPL_PROVIDER_H
#ifndef __cplusplus
#include <stdbool.h>

2
lib/webfuse_provider/impl/request.c
View File

@ -37,7 +37,7 @@ extern void wfp_impl_respond(
void wfp_impl_respond_error(
struct wfp_request * request,
wf_status status)
wfp_status status)
{
json_t * response = json_object();
json_t * error = json_object();

6
lib/webfuse_provider/impl/request.h
View File

@ -1,5 +1,5 @@
#ifndef WF_PROVIDER_IMPL_REQUEST_H
#define WF_PROVIDER_IMPL_REQUEST_H
#ifndef WFP_PROVIDER_IMPL_REQUEST_H
#define WFP_PROVIDER_IMPL_REQUEST_H
#include <jansson.h>
#include "webfuse_provider/impl/provider.h"
@ -23,7 +23,7 @@ struct wfp_request
extern void wfp_impl_respond_error(
struct wfp_request * request,
wf_status status);
wfp_status status);
extern struct wfp_request * wfp_impl_request_create(
struct wfp_request * prototype,

32
lib/webfuse_provider/impl/slist.c
View File

@ -1,46 +1,46 @@
#include "webfuse_provider/impl/slist.h"
#include <stddef.h>
void wf_slist_init(
struct wf_slist * list)
void wfp_slist_init(
struct wfp_slist * list)
{
list->head.next = NULL;
list->last = &list->head;
}
bool wf_slist_empty(
struct wf_slist * list)
bool wfp_slist_empty(
struct wfp_slist * list)
{
return (list->last == &list->head);
}
struct wf_slist_item * wf_slist_first(
struct wf_slist * list)
struct wfp_slist_item * wfp_slist_first(
struct wfp_slist * list)
{
return list->head.next;
}
void wf_slist_append(
struct wf_slist * list,
struct wf_slist_item * item)
void wfp_slist_append(
struct wfp_slist * list,
struct wfp_slist_item * item)
{
item->next = NULL;
list->last->next = item;
list->last = item;
}
struct wf_slist_item * wf_slist_remove_first(
struct wf_slist * list)
struct wfp_slist_item * wfp_slist_remove_first(
struct wfp_slist * list)
{
return wf_slist_remove_after(list, &list->head);
return wfp_slist_remove_after(list, &list->head);
}
struct wf_slist_item * wf_slist_remove_after(
struct wf_slist * list,
struct wf_slist_item * prev)
struct wfp_slist_item * wfp_slist_remove_after(
struct wfp_slist * list,
struct wfp_slist_item * prev)
{
struct wf_slist_item * result = prev->next;
struct wfp_slist_item * result = prev->next;
if (NULL != result)
{

42
lib/webfuse_provider/impl/slist.h
View File

@ -1,5 +1,5 @@
#ifndef WF_SLIST_H
#define WF_SLIST_H
#ifndef WFP_SLIST_H
#define WFP_SLIST_H
#ifndef __cplusplus
#include <stdbool.h>
@ -10,36 +10,36 @@ extern "C"
{
#endif
struct wf_slist_item
struct wfp_slist_item
{
struct wf_slist_item * next;
struct wfp_slist_item * next;
};
struct wf_slist
struct wfp_slist
{
struct wf_slist_item head;
struct wf_slist_item * last;
struct wfp_slist_item head;
struct wfp_slist_item * last;
};
extern void wf_slist_init(
struct wf_slist * list);
extern void wfp_slist_init(
struct wfp_slist * list);
extern bool wf_slist_empty(
struct wf_slist * list);
extern bool wfp_slist_empty(
struct wfp_slist * list);
extern struct wf_slist_item * wf_slist_first(
struct wf_slist * list);
extern struct wfp_slist_item * wfp_slist_first(
struct wfp_slist * list);
extern void wf_slist_append(
struct wf_slist * list,
struct wf_slist_item * item);
extern void wfp_slist_append(
struct wfp_slist * list,
struct wfp_slist_item * item);
extern struct wf_slist_item * wf_slist_remove_first(
struct wf_slist * list);
extern struct wfp_slist_item * wfp_slist_remove_first(
struct wfp_slist * list);
extern struct wf_slist_item * wf_slist_remove_after(
struct wf_slist * list,
struct wf_slist_item * prev);
extern struct wfp_slist_item * wfp_slist_remove_after(
struct wfp_slist * list,
struct wfp_slist_item * prev);
#ifdef __cplusplus
}

34
lib/webfuse_provider/impl/status.c
View File

@ -2,33 +2,33 @@
#include <errno.h>
int wf_status_to_rc(wf_status status)
int wfp_status_to_rc(wfp_status status)
{
switch(status)
{
case WF_GOOD: return 0;
case WF_BAD_NOTIMPLEMENTED: return -ENOSYS;
case WF_BAD_TIMEOUT: return -ETIMEDOUT;
case WF_BAD_BUSY: return -ENOENT;
case WF_BAD_FORMAT: return -ENOENT;
case WF_BAD_NOENTRY: return -ENOENT;
case WF_BAD_ACCESS_DENIED: return -EACCES;
case WFP_GOOD: return 0;
case WFP_BAD_NOTIMPLEMENTED: return -ENOSYS;
case WFP_BAD_TIMEOUT: return -ETIMEDOUT;
case WFP_BAD_BUSY: return -ENOENT;
case WFP_BAD_FORMAT: return -ENOENT;
case WFP_BAD_NOENTRY: return -ENOENT;
case WFP_BAD_ACCESS_DENIED: return -EACCES;
default: return -ENOENT;
}
}
char const * wf_status_tostring(wf_status status)
char const * wfp_status_tostring(wfp_status status)
{
switch(status)
{
case WF_GOOD: return "Good";
case WF_BAD: return "Bad";
case WF_BAD_NOTIMPLEMENTED: return "Bad (not implemented)";
case WF_BAD_TIMEOUT: return "Bad (timeout)";
case WF_BAD_BUSY: return "Bad (busy)";
case WF_BAD_FORMAT: return "Bad (format)";
case WF_BAD_NOENTRY: return "Bad (no entry)";
case WF_BAD_ACCESS_DENIED: return "Bad (access denied)";
case WFP_GOOD: return "Good";
case WFP_BAD: return "Bad";
case WFP_BAD_NOTIMPLEMENTED: return "Bad (not implemented)";
case WFP_BAD_TIMEOUT: return "Bad (timeout)";
case WFP_BAD_BUSY: return "Bad (busy)";
case WFP_BAD_FORMAT: return "Bad (format)";
case WFP_BAD_NOENTRY: return "Bad (no entry)";
case WFP_BAD_ACCESS_DENIED: return "Bad (access denied)";
default: return "Bad (unknown)";
}
}

8
lib/webfuse_provider/impl/status_intern.h
View File

@ -1,5 +1,5 @@
#ifndef WF_STATUS_INTERN_H
#define WF_STATUS_INTERN_H
#ifndef WFP_STATUS_INTERN_H
#define WFP_STATUS_INTERN_H
#include "webfuse_provider/status.h"
@ -7,9 +7,9 @@
extern "C" {
#endif
extern int wf_status_to_rc(wf_status status);
extern int wfp_status_to_rc(wfp_status status);
extern char const * wf_status_tostring(wf_status status);
extern char const * wfp_status_tostring(wfp_status status);
#ifdef __cplusplus
}

50
lib/webfuse_provider/impl/timer/manager.c
View File

@ -5,30 +5,30 @@
#include <stddef.h>
#include <stdlib.h>
struct wf_timer_manager
struct wfp_timer_manager
{
struct wf_timer * timers;
struct wfp_timer * timers;
};
struct wf_timer_manager *
wf_timer_manager_create(void)
struct wfp_timer_manager *
wfp_timer_manager_create(void)
{
struct wf_timer_manager * manager = malloc(sizeof(struct wf_timer_manager));
struct wfp_timer_manager * manager = malloc(sizeof(struct wfp_timer_manager));
manager->timers = NULL;
return manager;
}
void
wf_timer_manager_dispose(
struct wf_timer_manager * manager)
wfp_timer_manager_dispose(
struct wfp_timer_manager * manager)
{
struct wf_timer * timer = manager->timers;
struct wfp_timer * timer = manager->timers;
while (NULL != timer)
{
struct wf_timer * next = timer->next;
struct wfp_timer * next = timer->next;
wf_timer_trigger(timer);
wfp_timer_trigger(timer);
timer = next;
}
@ -36,27 +36,27 @@ wf_timer_manager_dispose(
}
void wf_timer_manager_check(
struct wf_timer_manager * manager)
void wfp_timer_manager_check(
struct wfp_timer_manager * manager)
{
struct wf_timer * timer = manager->timers;
struct wfp_timer * timer = manager->timers;
while (NULL != timer)
{
struct wf_timer * next = timer->next;
struct wfp_timer * next = timer->next;
if (wf_timer_is_timeout(timer))
if (wfp_timer_is_timeout(timer))
{
wf_timer_manager_removetimer(manager, timer);
wf_timer_trigger(timer);
wfp_timer_manager_removetimer(manager, timer);
wfp_timer_trigger(timer);
}
timer = next;
}
}
void wf_timer_manager_addtimer(
struct wf_timer_manager * manager,
struct wf_timer * timer)
void wfp_timer_manager_addtimer(
struct wfp_timer_manager * manager,
struct wfp_timer * timer)
{
if (NULL != manager->timers)
{
@ -68,12 +68,12 @@ void wf_timer_manager_addtimer(
manager->timers = timer;
}
void wf_timer_manager_removetimer(
struct wf_timer_manager * manager,
struct wf_timer * timer)
void wfp_timer_manager_removetimer(
struct wfp_timer_manager * manager,
struct wfp_timer * timer)
{
struct wf_timer * prev = timer->prev;
struct wf_timer * next = timer->next;
struct wfp_timer * prev = timer->prev;
struct wfp_timer * next = timer->next;
if (NULL != prev)
{

18
lib/webfuse_provider/impl/timer/manager.h
View File

@ -1,23 +1,23 @@
#ifndef WF_TIMER_MANAGER_H
#define WF_TIMER_MANAGER_H
#ifndef WFP_TIMER_MANAGER_H
#define WFP_TIMER_MANAGER_H
#ifdef __cplusplus
extern "C"
{
#endif
struct wf_timer_manager;
struct wfp_timer_manager;
extern struct wf_timer_manager *
wf_timer_manager_create(void);
extern struct wfp_timer_manager *
wfp_timer_manager_create(void);
extern void
wf_timer_manager_dispose(
struct wf_timer_manager * manager);
wfp_timer_manager_dispose(
struct wfp_timer_manager * manager);
extern void
wf_timer_manager_check(
struct wf_timer_manager * manager);
wfp_timer_manager_check(
struct wfp_timer_manager * manager);
#ifdef __cplusplus
}

18
lib/webfuse_provider/impl/timer/manager_intern.h
View File

@ -1,5 +1,5 @@
#ifndef WF_TIMER_MANAGER_INTERN_H
#define WF_TIMER_MANAGER_INTERN_H
#ifndef WFP_TIMER_MANAGER_INTERN_H
#define WFP_TIMER_MANAGER_INTERN_H
#include "webfuse_provider/impl/timer/manager.h"
@ -8,15 +8,15 @@ extern "C"
{
#endif
struct wf_timer;
struct wfp_timer;
extern void wf_timer_manager_addtimer(
struct wf_timer_manager * manager,
struct wf_timer * timer);
extern void wfp_timer_manager_addtimer(
struct wfp_timer_manager * manager,
struct wfp_timer * timer);
extern void wf_timer_manager_removetimer(
struct wf_timer_manager * manager,
struct wf_timer * timer);
extern void wfp_timer_manager_removetimer(
struct wfp_timer_manager * manager,
struct wfp_timer * timer);
#ifdef __cplusplus
}

10
lib/webfuse_provider/impl/timer/on_timer_fn.h
View File

@ -1,15 +1,15 @@
#ifndef WF_TIMER_ON_TIMER_FN_H
#define WF_TIMER_ON_TIMER_FN_H
#ifndef WFP_TIMER_ON_TIMER_FN_H
#define WFP_TIMER_ON_TIMER_FN_H
#ifdef __cplusplus
extern "C"
{
#endif
struct wf_timer;
struct wfp_timer;
typedef void wf_timer_on_timer_fn(
struct wf_timer * timer,
typedef void wfp_timer_on_timer_fn(
struct wfp_timer * timer,
void * user_data);
#ifdef __cplusplus

20
lib/webfuse_provider/impl/timer/timepoint.c
View File

@ -2,30 +2,30 @@
#include <time.h>
#define WF_TIMER_MSEC_PER_SEC ((wf_timer_timepoint) 1000)
#define WF_TIMER_NSEC_PER_MSEC ((wf_timer_timepoint) 1000 * 1000)
#define WFP_TIMER_MSEC_PER_SEC ((wfp_timer_timepoint) 1000)
#define WFP_TIMER_NSEC_PER_MSEC ((wfp_timer_timepoint) 1000 * 1000)
wf_timer_timepoint wf_timer_timepoint_now(void)
wfp_timer_timepoint wfp_timer_timepoint_now(void)
{
struct timespec tp;
clock_gettime(CLOCK_MONOTONIC, &tp);
wf_timer_timepoint const now = (tp.tv_sec * WF_TIMER_MSEC_PER_SEC) + (tp.tv_nsec / WF_TIMER_NSEC_PER_MSEC);
wfp_timer_timepoint const now = (tp.tv_sec * WFP_TIMER_MSEC_PER_SEC) + (tp.tv_nsec / WFP_TIMER_NSEC_PER_MSEC);
return now;
}
wf_timer_timepoint wf_timer_timepoint_in_msec(wf_timer_timediff value)
wfp_timer_timepoint wfp_timer_timepoint_in_msec(wfp_timer_timediff value)
{
wf_timer_timepoint const now = wf_timer_timepoint_now();
wf_timer_timepoint result = now + ((wf_timer_timepoint) value);
wfp_timer_timepoint const now = wfp_timer_timepoint_now();
wfp_timer_timepoint result = now + ((wfp_timer_timepoint) value);
return result;
}
bool wf_timer_timepoint_is_elapsed(wf_timer_timepoint tp)
bool wfp_timer_timepoint_is_elapsed(wfp_timer_timepoint tp)
{
wf_timer_timepoint const now = wf_timer_timepoint_now();
wf_timer_timediff const diff = (wf_timer_timediff) (tp - now);
wfp_timer_timepoint const now = wfp_timer_timepoint_now();
wfp_timer_timediff const diff = (wfp_timer_timediff) (tp - now);
return (0 > diff);
}

18
lib/webfuse_provider/impl/timer/timepoint.h
View File

@ -1,5 +1,5 @@
#ifndef WF_TIMER_TIMEPOINT_H
#define WF_TIMER_TIMEPOINT_H
#ifndef WFP_TIMER_TIMEPOINT_H
#define WFP_TIMER_TIMEPOINT_H
#ifndef __cplusplus
#include <stdbool.h>
@ -13,16 +13,16 @@ extern "C"
{
#endif
typedef uint64_t wf_timer_timepoint;
typedef int64_t wf_timer_timediff;
typedef uint64_t wfp_timer_timepoint;
typedef int64_t wfp_timer_timediff;
extern wf_timer_timepoint wf_timer_timepoint_now(void);
extern wfp_timer_timepoint wfp_timer_timepoint_now(void);
extern wf_timer_timepoint wf_timer_timepoint_in_msec(
wf_timer_timediff value);
extern wfp_timer_timepoint wfp_timer_timepoint_in_msec(
wfp_timer_timediff value);
extern bool wf_timer_timepoint_is_elapsed(
wf_timer_timepoint timepoint);
extern bool wfp_timer_timepoint_is_elapsed(
wfp_timer_timepoint timepoint);
#ifdef __cplusplus
}

38
lib/webfuse_provider/impl/timer/timer.c
View File

@ -6,13 +6,13 @@
#include <stdlib.h>
#include <string.h>
struct wf_timer *
wf_timer_create(
struct wf_timer_manager * manager,
wf_timer_on_timer_fn * on_timer,
struct wfp_timer *
wfp_timer_create(
struct wfp_timer_manager * manager,
wfp_timer_on_timer_fn * on_timer,
void * user_data)
{
struct wf_timer * timer = malloc(sizeof(struct wf_timer));
struct wfp_timer * timer = malloc(sizeof(struct wfp_timer));
timer->manager = manager;
timer->timeout = 0;
timer->on_timer = on_timer;
@ -24,38 +24,38 @@ wf_timer_create(
}
void
wf_timer_dispose(
struct wf_timer * timer)
wfp_timer_dispose(
struct wfp_timer * timer)
{
free(timer);
}
void wf_timer_start(
struct wf_timer * timer,
void wfp_timer_start(
struct wfp_timer * timer,
int timeout_ms)
{
timer->timeout = wf_timer_timepoint_in_msec(timeout_ms);
timer->timeout = wfp_timer_timepoint_in_msec(timeout_ms);
wf_timer_manager_addtimer(timer->manager, timer);
wfp_timer_manager_addtimer(timer->manager, timer);
}
void wf_timer_cancel(
struct wf_timer * timer)
void wfp_timer_cancel(
struct wfp_timer * timer)
{
wf_timer_manager_removetimer(timer->manager, timer);
wfp_timer_manager_removetimer(timer->manager, timer);
timer->timeout = 0;
}
bool wf_timer_is_timeout(
struct wf_timer * timer)
bool wfp_timer_is_timeout(
struct wfp_timer * timer)
{
return wf_timer_timepoint_is_elapsed(timer->timeout);
return wfp_timer_timepoint_is_elapsed(timer->timeout);
}
void wf_timer_trigger(
struct wf_timer * timer)
void wfp_timer_trigger(
struct wfp_timer * timer)
{
if (0 != timer->on_timer)
{

28
lib/webfuse_provider/impl/timer/timer.h
View File

@ -1,5 +1,5 @@
#ifndef WF_TIMER_TIMER_H
#define WF_TIMER_TIMER_H
#ifndef WFP_TIMER_TIMER_H
#define WFP_TIMER_TIMER_H
#include "webfuse_provider/impl/timer/on_timer_fn.h"
@ -8,27 +8,27 @@ extern "C"
{
#endif
struct wf_timer;
struct wf_timer_manager;
struct wfp_timer;
struct wfp_timer_manager;
extern struct wf_timer *
wf_timer_create(
struct wf_timer_manager * manager,
wf_timer_on_timer_fn * on_timer,
extern struct wfp_timer *
wfp_timer_create(
struct wfp_timer_manager * manager,
wfp_timer_on_timer_fn * on_timer,
void * user_data);
extern void
wf_timer_dispose(
struct wf_timer * timer);
wfp_timer_dispose(
struct wfp_timer * timer);
extern void
wf_timer_start(
struct wf_timer * timer,
wfp_timer_start(
struct wfp_timer * timer,
int timeout_ms);
extern void
wf_timer_cancel(
struct wf_timer * timer);
wfp_timer_cancel(
struct wfp_timer * timer);
#ifdef __cplusplus
}

24
lib/webfuse_provider/impl/timer/timer_intern.h
View File

@ -1,5 +1,5 @@
#ifndef WF_TIMER_TIMER_H
#define WF_TIMER_TIMER_H
#ifndef WFP_TIMER_TIMER_H
#define WFP_TIMER_TIMER_H
#include "webfuse_provider/impl/timer/timer.h"
#include "webfuse_provider/impl/timer/on_timer_fn.h"
@ -14,21 +14,21 @@ extern "C"
{
#endif
struct wf_timer
struct wfp_timer
{
struct wf_timer_manager * manager;
wf_timer_timepoint timeout;
wf_timer_on_timer_fn * on_timer;
struct wfp_timer_manager * manager;
wfp_timer_timepoint timeout;
wfp_timer_on_timer_fn * on_timer;
void * user_data;
struct wf_timer * next;
struct wf_timer * prev;
struct wfp_timer * next;
struct wfp_timer * prev;
};
extern bool wf_timer_is_timeout(
struct wf_timer * timer);
extern bool wfp_timer_is_timeout(
struct wfp_timer * timer);
extern void wf_timer_trigger(
struct wf_timer * timer);
extern void wfp_timer_trigger(
struct wfp_timer * timer);
#ifdef __cplusplus

44
lib/webfuse_provider/impl/url.c
View File

@ -3,7 +3,7 @@
#include <stdlib.h>
#include <string.h>
struct wf_url_protocol
struct wfp_url_protocol
{
char const * name;
size_t name_length;
@ -11,11 +11,11 @@ struct wf_url_protocol
bool use_tls;
};
static bool wf_url_readprotocol(
struct wf_url * url,
static bool wfp_url_readprotocol(
struct wfp_url * url,
char const * * data)
{
static struct wf_url_protocol const known_protocols[] =
static struct wfp_url_protocol const known_protocols[] =
{
{"ws://", 5, 80, false},
{"wss://", 6, 443, true}
@ -25,7 +25,7 @@ static bool wf_url_readprotocol(
bool found = false;
for(size_t i = 0; (!found) && (i < count); i++)
{
struct wf_url_protocol const * protocol = &known_protocols[i];
struct wfp_url_protocol const * protocol = &known_protocols[i];
if (0 == strncmp(*data, protocol->name, protocol->name_length))
{
url->port = protocol->default_port;
@ -38,8 +38,8 @@ static bool wf_url_readprotocol(
return found;
}
static bool wf_url_readhost(
struct wf_url * url,
static bool wfp_url_readhost(
struct wfp_url * url,
char const * * data)
{
char * end = strpbrk(*data, ":/");
@ -55,8 +55,8 @@ static bool wf_url_readhost(
return result;
}
static bool wf_url_readport(
struct wf_url * url,
static bool wfp_url_readport(
struct wfp_url * url,
char const * * data)
{
bool result;
@ -81,8 +81,8 @@ static bool wf_url_readport(
return result;
}
static bool wf_url_readpath(
struct wf_url * url,
static bool wfp_url_readpath(
struct wfp_url * url,
char const * * data)
{
bool const result = ('/' == **data);
@ -93,33 +93,33 @@ static bool wf_url_readpath(
}
bool wf_url_init(
struct wf_url * url,
bool wfp_url_init(
struct wfp_url * url,
char const * value)
{
memset(url, 0, sizeof(struct wf_url));
memset(url, 0, sizeof(struct wfp_url));
char const * data = value;
bool const result =
wf_url_readprotocol(url, &data) &&
wf_url_readhost(url, &data) &&
wf_url_readport(url, &data) &&
wf_url_readpath(url, &data)
wfp_url_readprotocol(url, &data) &&
wfp_url_readhost(url, &data) &&
wfp_url_readport(url, &data) &&
wfp_url_readpath(url, &data)
;
if (!result)
{
wf_url_cleanup(url);
wfp_url_cleanup(url);
}
return result;
}
void wf_url_cleanup(
struct wf_url * url)
void wfp_url_cleanup(
struct wfp_url * url)
{
free(url->host);
free(url->path);
memset(url, 0, sizeof(struct wf_url));
memset(url, 0, sizeof(struct wfp_url));
}

14
lib/webfuse_provider/impl/url.h
View File

@ -1,5 +1,5 @@
#ifndef WF_URL_H
#define WF_URL_H
#ifndef WFP_URL_H
#define WFP_URL_H
#ifndef __cplusplus
#include <stdbool.h>
@ -9,7 +9,7 @@
extern "C"
{
#endif
struct wf_url
struct wfp_url
{
char * host;
int port;
@ -17,12 +17,12 @@ struct wf_url
bool use_tls;
};
extern bool wf_url_init(
struct wf_url * url,
extern bool wfp_url_init(
struct wfp_url * url,
char const * value);
extern void wf_url_cleanup(
struct wf_url * url);
extern void wfp_url_cleanup(
struct wfp_url * url);
#ifdef __cplusplus

8
lib/webfuse_provider/impl/util.h
View File

@ -1,10 +1,10 @@
#ifndef WF_UTIL_H
#define WF_UTIL_H
#ifndef WFP_UTIL_H
#define WFP_UTIL_H
#ifdef __GNUC__
#define WF_UNUSED_PARAM(param) param __attribute__((unused))
#define WFP_UNUSED_PARAM(param) param __attribute__((unused))
#else
#define WF_UNUSED_PARAM(param)
#define WFP_UNUSED_PARAM(param)
#endif
#endif

20
meson.build
View File

@ -146,16 +146,16 @@ alltests = executable('alltests',
'test/webfuse_provider/tests/provider/operation/test_read.cc',
'test/webfuse_provider/tests/provider/operation/test_readdir.cc',
link_args: [
'-Wl,--wrap=wf_timer_manager_create',
'-Wl,--wrap=wf_timer_manager_dispose',
'-Wl,--wrap=wf_timer_manager_check',
'-Wl,--wrap=wf_timer_create',
'-Wl,--wrap=wf_timer_dispose',
'-Wl,--wrap=wf_timer_start',
'-Wl,--wrap=wf_timer_cancel',
'-Wl,--wrap=wf_impl_operation_context_get_proxy',
'-Wl,--wrap=wf_jsonrpc_proxy_vinvoke',
'-Wl,--wrap=wf_jsonrpc_proxy_vnotify',
'-Wl,--wrap=wfp_timer_manager_create',
'-Wl,--wrap=wfp_timer_manager_dispose',
'-Wl,--wrap=wfp_timer_manager_check',
'-Wl,--wrap=wfp_timer_create',
'-Wl,--wrap=wfp_timer_dispose',
'-Wl,--wrap=wfp_timer_start',
'-Wl,--wrap=wfp_timer_cancel',
'-Wl,--wrap=wfp_impl_operation_context_get_proxy',
'-Wl,--wrap=wfp_jsonrpc_proxy_vinvoke',
'-Wl,--wrap=wfp_jsonrpc_proxy_vnotify',
],
include_directories: ['include', 'lib', 'test'],
dependencies: [

2
test/webfuse_provider/json_matcher.hpp
View File

@ -1,4 +1,4 @@
#ifndef WF_JSON_MATCHER_HPP
#ifndef WFP_JSON_MATCHER_HPP
#define FW_JSON_MATCHER_HPP
#include <gtest/gtest.h>

4
test/webfuse_provider/mocks/lookup_matcher.hpp
View File

@ -1,5 +1,5 @@
#ifndef WF_LOOKUP_MATCHER_HPP
#define WF_LOOKUP_MATCHER_HPP
#ifndef WFP_LOOKUP_MATCHER_HPP
#define WFP_LOOKUP_MATCHER_HPP
#include <gmock/gmock.h>
#include <jansson.h>

4
test/webfuse_provider/mocks/mock_invokation_handler.hpp
View File

@ -1,5 +1,5 @@
#ifndef WF_MOCK_INVOKATION_HANDLER_HPP
#define WF_MOCK_INVOKATION_HANDLER_HPP
#ifndef WFP_MOCK_INVOKATION_HANDLER_HPP
#define WFP_MOCK_INVOKATION_HANDLER_HPP
#include "webfuse/utils/ws_server2.hpp"
#include <gtest/gtest.h>

10
test/webfuse_provider/mocks/mock_jsonrpc_proxy.cc
View File

@ -5,15 +5,15 @@ extern "C"
{
static webfuse_test::MockJsonRpcProxy * webfuse_test_MockJsonRpcProxy = nullptr;
WF_WRAP_VFUNC5(webfuse_test_MockJsonRpcProxy, void, wf_jsonrpc_proxy_vinvoke,
struct wf_jsonrpc_proxy *,
wf_jsonrpc_proxy_finished_fn *,
WFP_WRAP_VFUNC5(webfuse_test_MockJsonRpcProxy, void, wfp_jsonrpc_proxy_vinvoke,
struct wfp_jsonrpc_proxy *,
wfp_jsonrpc_proxy_finished_fn *,
void *,
char const *,
char const *);
WF_WRAP_VFUNC3(webfuse_test_MockJsonRpcProxy, void, wf_jsonrpc_proxy_vnotify,
struct wf_jsonrpc_proxy *,
WFP_WRAP_VFUNC3(webfuse_test_MockJsonRpcProxy, void, wfp_jsonrpc_proxy_vnotify,
struct wfp_jsonrpc_proxy *,
char const *,
char const *);
}

10
test/webfuse_provider/mocks/mock_jsonrpc_proxy.hpp
View File

@ -12,14 +12,14 @@ class MockJsonRpcProxy
public:
MockJsonRpcProxy();
virtual ~MockJsonRpcProxy();
MOCK_METHOD5(wf_jsonrpc_proxy_vinvoke, void (
struct wf_jsonrpc_proxy * proxy,
wf_jsonrpc_proxy_finished_fn * finished,
MOCK_METHOD5(wfp_jsonrpc_proxy_vinvoke, void (
struct wfp_jsonrpc_proxy * proxy,
wfp_jsonrpc_proxy_finished_fn * finished,
void * user_data,
char const * method_name,
char const * param_info));
MOCK_METHOD3(wf_jsonrpc_proxy_vnotify, void (
struct wf_jsonrpc_proxy * proxy,
MOCK_METHOD3(wfp_jsonrpc_proxy_vnotify, void (
struct wfp_jsonrpc_proxy * proxy,
char const * method_name,
char const * param_info));

6
test/webfuse_provider/mocks/mock_operation_context.cc
View File

@ -5,9 +5,9 @@ extern "C"
{
static webfuse_test::MockOperationContext * webfuse_test_MockOperationContext = nullptr;
WF_WRAP_FUNC1(webfuse_test_MockOperationContext,
struct wf_jsonrpc_proxy *, wf_impl_operation_context_get_proxy,
struct wf_impl_operation_context *);
WFP_WRAP_FUNC1(webfuse_test_MockOperationContext,
struct wfp_jsonrpc_proxy *, wfp_impl_operation_context_get_proxy,
struct wfp_impl_operation_context *);
}

4
test/webfuse_provider/mocks/mock_operation_context.hpp
View File

@ -12,8 +12,8 @@ class MockOperationContext
public:
MockOperationContext();
virtual ~MockOperationContext();
MOCK_METHOD1(wf_impl_operation_context_get_proxy, wf_jsonrpc_proxy * (
struct wf_impl_operation_context * context));
MOCK_METHOD1(wfp_impl_operation_context_get_proxy, wfp_jsonrpc_proxy * (
struct wfp_impl_operation_context * context));
};

4
test/webfuse_provider/mocks/mock_provider.hpp
View File

@ -1,5 +1,5 @@
#ifndef WF_MOCK_PROVIDER_HPP
#define WF_MOCK_PROVIDER_HPP
#ifndef WFP_MOCK_PROVIDER_HPP
#define WFP_MOCK_PROVIDER_HPP
#include "webfuse_provider/impl/provider.h"
#include <gmock/gmock.h>

14
test/webfuse_provider/mocks/mock_provider_client.cc
View File

@ -41,7 +41,7 @@ static void webfuse_test_iproviderclient_onlookup(
}
catch (...)
{
wfp_respond_error(request, WF_BAD);
wfp_respond_error(request, WFP_BAD);
}
}
@ -65,7 +65,7 @@ static void webfuse_test_iproviderclient_ongetattr(
}
catch (...)
{
wfp_respond_error(request, WF_BAD);
wfp_respond_error(request, WFP_BAD);
}
}
@ -89,7 +89,7 @@ static void webfuse_test_iproviderclient_onreaddir(
}
catch (...)
{
wfp_respond_error(request, WF_BAD);
wfp_respond_error(request, WFP_BAD);
}
wfp_dirbuffer_dispose(buffer);
@ -116,7 +116,7 @@ static void webfuse_test_iproviderclient_onopen(
}
catch (...)
{
wfp_respond_error(request, WF_BAD);
wfp_respond_error(request, WFP_BAD);
}
}
@ -154,7 +154,7 @@ static void webfuse_test_iproviderclient_onread(
}
catch (...)
{
wfp_respond_error(request, WF_BAD);
wfp_respond_error(request, WFP_BAD);
}
delete[] data;
@ -181,14 +181,14 @@ static void webfuse_test_iproviderclient_get_credentials(
namespace webfuse_test
{
ProviderClientException::ProviderClientException(wf_status error_code)
ProviderClientException::ProviderClientException(wfp_status error_code)
: runtime_error("ProviderClientException")
, error_code_(error_code)
{
}
wf_status ProviderClientException::GetErrorCode()
wfp_status ProviderClientException::GetErrorCode()
{
return error_code_;
}

10
test/webfuse_provider/mocks/mock_provider_client.hpp
View File

@ -1,5 +1,5 @@
#ifndef WF_MOCK_PROVIDER_CLIENT_HPP
#define WF_MOCK_PROVIDER_CLIENT_HPP
#ifndef WFP_MOCK_PROVIDER_CLIENT_HPP
#define WFP_MOCK_PROVIDER_CLIENT_HPP
#include <gmock/gmock.h>
#include "webfuse_provider/client_config.h"
@ -11,10 +11,10 @@ namespace webfuse_test
class ProviderClientException: public std::runtime_error
{
public:
explicit ProviderClientException(wf_status error_code);
wf_status GetErrorCode();
explicit ProviderClientException(wfp_status error_code);
wfp_status GetErrorCode();
private:
wf_status error_code_;
wfp_status error_code_;
};
class IProviderClient

4
test/webfuse_provider/mocks/mock_request.hpp
View File

@ -1,5 +1,5 @@
#ifndef WF_MOCK_REQUEST_HPP
#define WF_MOCK_REQUEST_HPP
#ifndef WFP_MOCK_REQUEST_HPP
#define WFP_MOCK_REQUEST_HPP
#include <gmock/gmock.h>
#include <jansson.h>

22
test/webfuse_provider/tests/core/jsonrpc/mock_timer.cc
View File

@ -3,29 +3,29 @@
extern "C"
{
static wf_jsonrpc_test::ITimer * wf_jsonrpc_MockTimer = nullptr;
static wfp_jsonrpc_test::ITimer * wfp_jsonrpc_MockTimer = nullptr;
WF_WRAP_FUNC0(wf_jsonrpc_MockTimer, wf_timer_manager *, wf_timer_manager_create);
WF_WRAP_FUNC1(wf_jsonrpc_MockTimer, void, wf_timer_manager_dispose, wf_timer_manager *);
WF_WRAP_FUNC1(wf_jsonrpc_MockTimer, void, wf_timer_manager_check, wf_timer_manager *);
WFP_WRAP_FUNC0(wfp_jsonrpc_MockTimer, wfp_timer_manager *, wfp_timer_manager_create);
WFP_WRAP_FUNC1(wfp_jsonrpc_MockTimer, void, wfp_timer_manager_dispose, wfp_timer_manager *);
WFP_WRAP_FUNC1(wfp_jsonrpc_MockTimer, void, wfp_timer_manager_check, wfp_timer_manager *);
WF_WRAP_FUNC3(wf_jsonrpc_MockTimer, wf_timer *, wf_timer_create, wf_timer_manager *, wf_timer_on_timer_fn *, void *);
WF_WRAP_FUNC1(wf_jsonrpc_MockTimer, void, wf_timer_dispose, wf_timer *);
WF_WRAP_FUNC2(wf_jsonrpc_MockTimer, void, wf_timer_start, wf_timer *, int);
WF_WRAP_FUNC1(wf_jsonrpc_MockTimer, void, wf_timer_cancel, wf_timer *);
WFP_WRAP_FUNC3(wfp_jsonrpc_MockTimer, wfp_timer *, wfp_timer_create, wfp_timer_manager *, wfp_timer_on_timer_fn *, void *);
WFP_WRAP_FUNC1(wfp_jsonrpc_MockTimer, void, wfp_timer_dispose, wfp_timer *);
WFP_WRAP_FUNC2(wfp_jsonrpc_MockTimer, void, wfp_timer_start, wfp_timer *, int);
WFP_WRAP_FUNC1(wfp_jsonrpc_MockTimer, void, wfp_timer_cancel, wfp_timer *);
}
namespace wf_jsonrpc_test
namespace wfp_jsonrpc_test
{
MockTimer::MockTimer()
{
wf_jsonrpc_MockTimer = this;
wfp_jsonrpc_MockTimer = this;
}
MockTimer::~MockTimer()
{
wf_jsonrpc_MockTimer = nullptr;
wfp_jsonrpc_MockTimer = nullptr;
}
}

42
test/webfuse_provider/tests/core/jsonrpc/mock_timer.hpp
View File

@ -1,27 +1,27 @@
#ifndef WF_JSONRPC_MOCK_TIMERMANAGER_HPP
#define WF_JSONRPC_MOCK_TIMERMANAGER_HPP
#ifndef WFP_JSONRPC_MOCK_TIMERMANAGER_HPP
#define WFP_JSONRPC_MOCK_TIMERMANAGER_HPP
#include "webfuse_provider/impl/timer/timer.h"
#include "webfuse_provider/impl/timer/manager.h"
#include <gmock/gmock.h>
namespace wf_jsonrpc_test
namespace wfp_jsonrpc_test
{
class ITimer
{
public:
virtual ~ITimer() = default;
virtual wf_timer_manager * wf_timer_manager_create() = 0;
virtual void wf_timer_manager_dispose(wf_timer_manager * manager) = 0;
virtual void wf_timer_manager_check(wf_timer_manager * manager) = 0;
virtual wf_timer * wf_timer_create(
wf_timer_manager * manager,
wf_timer_on_timer_fn * on_timer,
virtual wfp_timer_manager * wfp_timer_manager_create() = 0;
virtual void wfp_timer_manager_dispose(wfp_timer_manager * manager) = 0;
virtual void wfp_timer_manager_check(wfp_timer_manager * manager) = 0;
virtual wfp_timer * wfp_timer_create(
wfp_timer_manager * manager,
wfp_timer_on_timer_fn * on_timer,
void * user_data) = 0;
virtual void wf_timer_dispose(wf_timer * timer) = 0;
virtual void wf_timer_start(wf_timer * timer, int timeout_ms) = 0;
virtual void wf_timer_cancel(wf_timer * timer) = 0;
virtual void wfp_timer_dispose(wfp_timer * timer) = 0;
virtual void wfp_timer_start(wfp_timer * timer, int timeout_ms) = 0;
virtual void wfp_timer_cancel(wfp_timer * timer) = 0;
};
class MockTimer: public ITimer
@ -29,16 +29,16 @@ class MockTimer: public ITimer
public:
MockTimer();
~MockTimer() override;
MOCK_METHOD0(wf_timer_manager_create, wf_timer_manager * ());
MOCK_METHOD1(wf_timer_manager_dispose, void(wf_timer_manager * manager));
MOCK_METHOD1(wf_timer_manager_check, void (wf_timer_manager * manager));
MOCK_METHOD3(wf_timer_create, wf_timer *(
wf_timer_manager * manager,
wf_timer_on_timer_fn * on_timer,
MOCK_METHOD0(wfp_timer_manager_create, wfp_timer_manager * ());
MOCK_METHOD1(wfp_timer_manager_dispose, void(wfp_timer_manager * manager));
MOCK_METHOD1(wfp_timer_manager_check, void (wfp_timer_manager * manager));
MOCK_METHOD3(wfp_timer_create, wfp_timer *(
wfp_timer_manager * manager,
wfp_timer_on_timer_fn * on_timer,
void * user_data));
MOCK_METHOD1(wf_timer_dispose, void (wf_timer * timer));
MOCK_METHOD2(wf_timer_start, void (wf_timer * timer, int timeout_ms));
MOCK_METHOD1(wf_timer_cancel, void (wf_timer * timer));
MOCK_METHOD1(wfp_timer_dispose, void (wfp_timer * timer));
MOCK_METHOD2(wfp_timer_start, void (wfp_timer * timer, int timeout_ms));
MOCK_METHOD1(wfp_timer_cancel, void (wfp_timer * timer));
};

12
test/webfuse_provider/tests/core/jsonrpc/mock_timer_callback.cc
View File

@ -2,10 +2,10 @@
extern "C"
{
using wf_jsonrpc_test::MockTimerCallback;
using wfp_jsonrpc_test::MockTimerCallback;
static void wf_jsonrpc_test_MockTimerCallback_on_timer(
wf_timer * timer,
static void wfp_jsonrpc_test_MockTimerCallback_on_timer(
wfp_timer * timer,
void * user_data)
{
auto * self = reinterpret_cast<MockTimerCallback*>(user_data);
@ -14,7 +14,7 @@ static void wf_jsonrpc_test_MockTimerCallback_on_timer(
}
namespace wf_jsonrpc_test
namespace wfp_jsonrpc_test
{
MockTimerCallback::MockTimerCallback()
@ -27,9 +27,9 @@ MockTimerCallback::~MockTimerCallback()
}
wf_timer_on_timer_fn * MockTimerCallback::on_timer_fn()
wfp_timer_on_timer_fn * MockTimerCallback::on_timer_fn()
{
return &wf_jsonrpc_test_MockTimerCallback_on_timer;
return &wfp_jsonrpc_test_MockTimerCallback_on_timer;
}
void * MockTimerCallback::user_data()

10
test/webfuse_provider/tests/core/jsonrpc/mock_timer_callback.hpp
View File

@ -1,20 +1,20 @@
#ifndef WF_JSONRPC_MOCK_TIMERCALLBACK_HPP
#define WF_JSONRPC_MOCK_TIMERCALLBACK_HPP
#ifndef WFP_JSONRPC_MOCK_TIMERCALLBACK_HPP
#define WFP_JSONRPC_MOCK_TIMERCALLBACK_HPP
#include "webfuse_provider/impl/timer/on_timer_fn.h"
#include <gmock/gmock.h>
namespace wf_jsonrpc_test
namespace wfp_jsonrpc_test
{
class MockTimerCallback
{
public:
MockTimerCallback();
virtual ~MockTimerCallback();
wf_timer_on_timer_fn * on_timer_fn();
wfp_timer_on_timer_fn * on_timer_fn();
void * user_data();
MOCK_METHOD2(on_timer, void (wf_timer * timer, void * user_data));
MOCK_METHOD2(on_timer, void (wfp_timer * timer, void * user_data));
};

40
test/webfuse_provider/tests/core/jsonrpc/test_is_request.cc
View File

@ -1,112 +1,112 @@
#include <gtest/gtest.h>
#include "webfuse_provider/impl/jsonrpc/request.h"
TEST(wf_jsonrpc_is_request, request_with_object_params)
TEST(wfp_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));
ASSERT_TRUE(wfp_jsonrpc_is_request(request));
json_decref(request);
}
TEST(wf_jsonrpc_is_request, request_with_array_params)
TEST(wfp_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));
ASSERT_TRUE(wfp_jsonrpc_is_request(request));
json_decref(request);
}
TEST(wf_jsonrpc_is_request, null_request)
TEST(wfp_jsonrpc_is_request, null_request)
{
ASSERT_FALSE(wf_jsonrpc_is_request(nullptr));
ASSERT_FALSE(wfp_jsonrpc_is_request(nullptr));
}
TEST(wf_jsonrpc_is_request, invalid_request)
TEST(wfp_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));
ASSERT_FALSE(wfp_jsonrpc_is_request(request));
json_decref(request);
}
TEST(wf_jsonrpc_is_request, invalid_request_without_id)
TEST(wfp_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));
ASSERT_FALSE(wfp_jsonrpc_is_request(request));
json_decref(request);
}
TEST(wf_jsonrpc_is_request, invalid_request_due_to_invalid_id)
TEST(wfp_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));
ASSERT_FALSE(wfp_jsonrpc_is_request(request));
json_decref(request);
}
TEST(wf_jsonrpc_is_request, invalid_request_without_method)
TEST(wfp_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));
ASSERT_FALSE(wfp_jsonrpc_is_request(request));
json_decref(request);
}
TEST(wf_jsonrpc_is_request, invalid_request_due_to_invalid_method)
TEST(wfp_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));
ASSERT_FALSE(wfp_jsonrpc_is_request(request));
json_decref(request);
}
TEST(wf_jsonrpc_is_request, invalid_request_without_params)
TEST(wfp_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));
ASSERT_FALSE(wfp_jsonrpc_is_request(request));
json_decref(request);
}
TEST(wf_jsonrpc_is_request, invalid_request_due_to_invalid_params)
TEST(wfp_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));
ASSERT_FALSE(wfp_jsonrpc_is_request(request));
json_decref(request);
}

36
test/webfuse_provider/tests/core/jsonrpc/test_is_response.cc
View File

@ -1,94 +1,94 @@
#include <gtest/gtest.h>
#include "webfuse_provider/impl/jsonrpc/response.h"
TEST(wf_jsonrpc_is_response, valid_result)
TEST(wfp_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));
ASSERT_TRUE(wfp_jsonrpc_is_response(message));
json_decref(message);
}
TEST(wf_jsonrpc_is_response, valid_result_string)
TEST(wfp_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));
ASSERT_TRUE(wfp_jsonrpc_is_response(message));
json_decref(message);
}
TEST(wf_jsonrpc_is_response, valid_error)
TEST(wfp_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));
ASSERT_TRUE(wfp_jsonrpc_is_response(message));
json_decref(message);
}
TEST(wf_jsonrpc_is_response, invalid_null)
TEST(wfp_jsonrpc_is_response, invalid_null)
{
ASSERT_FALSE(wf_jsonrpc_is_response(nullptr));
ASSERT_FALSE(wfp_jsonrpc_is_response(nullptr));
}
TEST(wf_jsonrpc_is_response, invalid_message)
TEST(wfp_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));
ASSERT_FALSE(wfp_jsonrpc_is_response(message));
json_decref(message);
}
TEST(wf_jsonrpc_is_response, invalid_missing_id)
TEST(wfp_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));
ASSERT_FALSE(wfp_jsonrpc_is_response(message));
json_decref(message);
}
TEST(wf_jsonrpc_is_response, invalid_id_wrong_type)
TEST(wfp_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));
ASSERT_FALSE(wfp_jsonrpc_is_response(message));
json_decref(message);
}
TEST(wf_jsonrpc_is_response, invalid_missing_result_and_error)
TEST(wfp_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));
ASSERT_FALSE(wfp_jsonrpc_is_response(message));
json_decref(message);
}
TEST(wf_jsonrpc_is_response, invalid_error_wrong_type)
TEST(wfp_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));
ASSERT_FALSE(wfp_jsonrpc_is_response(message));
json_decref(message);
}

174
test/webfuse_provider/tests/core/jsonrpc/test_proxy.cc
View File

@ -9,20 +9,20 @@
#include <chrono>
using namespace std::chrono_literals;
using wf_jsonrpc_test::MockTimer;
using wfp_jsonrpc_test::MockTimer;
using testing::Return;
using testing::_;
using testing::DoAll;
using testing::SaveArg;
#define WF_DEFAULT_TIMEOUT (10 * 1000)
#define WFP_DEFAULT_TIMEOUT (10 * 1000)
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;
return (json_is_integer(code)) ? json_integer_value(code) : WFP_BAD_FORMAT;
}
struct SendContext
@ -99,31 +99,31 @@ namespace
}
}
TEST(wf_jsonrpc_proxy, init)
TEST(wfp_jsonrpc_proxy, init)
{
struct wf_timer_manager * timer_manager = wf_timer_manager_create();
struct wfp_timer_manager * timer_manager = wfp_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);
struct wfp_jsonrpc_proxy * proxy = wfp_jsonrpc_proxy_create(timer_manager, WFP_DEFAULT_TIMEOUT, &jsonrpc_send, user_data);
wf_jsonrpc_proxy_dispose(proxy);
wf_timer_manager_dispose(timer_manager);
wfp_jsonrpc_proxy_dispose(proxy);
wfp_timer_manager_dispose(timer_manager);
ASSERT_FALSE(context.is_called);
}
TEST(wf_jsonrpc_proxy, invoke)
TEST(wfp_jsonrpc_proxy, invoke)
{
struct wf_timer_manager * timer_manager = wf_timer_manager_create();
struct wfp_timer_manager * timer_manager = wfp_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);
struct wfp_jsonrpc_proxy * proxy = wfp_jsonrpc_proxy_create(timer_manager, WFP_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);
wfp_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));
@ -145,24 +145,24 @@ TEST(wf_jsonrpc_proxy, invoke)
ASSERT_FALSE(finished_context.is_called);
wf_jsonrpc_proxy_dispose(proxy);
wf_timer_manager_dispose(timer_manager);
wfp_jsonrpc_proxy_dispose(proxy);
wfp_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)
TEST(wfp_jsonrpc_proxy, invoke_calls_finish_if_send_fails)
{
struct wf_timer_manager * timer_manager = wf_timer_manager_create();
struct wfp_timer_manager * timer_manager = wfp_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);
struct wfp_jsonrpc_proxy * proxy = wfp_jsonrpc_proxy_create(timer_manager, WFP_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);
wfp_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));
@ -170,25 +170,25 @@ TEST(wf_jsonrpc_proxy, invoke_calls_finish_if_send_fails)
ASSERT_TRUE(finished_context.is_called);
ASSERT_FALSE(nullptr == finished_context.error);
wf_jsonrpc_proxy_dispose(proxy);
wf_timer_manager_dispose(timer_manager);
wfp_jsonrpc_proxy_dispose(proxy);
wfp_timer_manager_dispose(timer_manager);
}
TEST(wf_jsonrpc_proxy, invoke_fails_if_another_request_is_pending)
TEST(wfp_jsonrpc_proxy, invoke_fails_if_another_request_is_pending)
{
struct wf_timer_manager * timer_manager = wf_timer_manager_create();
struct wfp_timer_manager * timer_manager = wfp_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);
struct wfp_jsonrpc_proxy * proxy = wfp_jsonrpc_proxy_create(timer_manager, WFP_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);
wfp_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", "");
wfp_jsonrpc_proxy_invoke(proxy, &jsonrpc_finished, finished_data2, "foo", "");
ASSERT_TRUE(send_context.is_called);
ASSERT_TRUE(json_is_object(send_context.response));
@ -196,44 +196,44 @@ TEST(wf_jsonrpc_proxy, invoke_fails_if_another_request_is_pending)
ASSERT_FALSE(finished_context.is_called);
ASSERT_TRUE(finished_context2.is_called);
ASSERT_EQ(WF_BAD_BUSY, jsonrpc_get_status(finished_context2.error));
ASSERT_EQ(WFP_BAD_BUSY, jsonrpc_get_status(finished_context2.error));
wf_jsonrpc_proxy_dispose(proxy);
wf_timer_manager_dispose(timer_manager);
wfp_jsonrpc_proxy_dispose(proxy);
wfp_timer_manager_dispose(timer_manager);
}
TEST(wf_jsonrpc_proxy, invoke_fails_if_request_is_invalid)
TEST(wfp_jsonrpc_proxy, invoke_fails_if_request_is_invalid)
{
struct wf_timer_manager * timer_manager = wf_timer_manager_create();
struct wfp_timer_manager * timer_manager = wfp_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);
struct wfp_jsonrpc_proxy * proxy = wfp_jsonrpc_proxy_create(timer_manager, WFP_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");
wfp_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, jsonrpc_get_status(finished_context.error));
ASSERT_EQ(WFP_BAD, jsonrpc_get_status(finished_context.error));
wf_jsonrpc_proxy_dispose(proxy);
wf_timer_manager_dispose(timer_manager);
wfp_jsonrpc_proxy_dispose(proxy);
wfp_timer_manager_dispose(timer_manager);
}
TEST(wf_jsonrpc_proxy, on_result)
TEST(wfp_jsonrpc_proxy, on_result)
{
struct wf_timer_manager * timer_manager = wf_timer_manager_create();
struct wfp_timer_manager * timer_manager = wfp_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);
struct wfp_jsonrpc_proxy * proxy = wfp_jsonrpc_proxy_create(timer_manager, WFP_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);
wfp_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));
@ -245,7 +245,7 @@ TEST(wf_jsonrpc_proxy, on_result)
json_object_set_new(response, "result", json_string("okay"));
json_object_set(response, "id", id);
wf_jsonrpc_proxy_onresult(proxy, response);
wfp_jsonrpc_proxy_onresult(proxy, response);
json_decref(response);
ASSERT_TRUE(finished_context.is_called);
@ -253,21 +253,21 @@ TEST(wf_jsonrpc_proxy, on_result)
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);
wfp_jsonrpc_proxy_dispose(proxy);
wfp_timer_manager_dispose(timer_manager);
}
TEST(wf_jsonrpc_proxy, on_result_reject_response_with_unknown_id)
TEST(wfp_jsonrpc_proxy, on_result_reject_response_with_unknown_id)
{
struct wf_timer_manager * timer_manager = wf_timer_manager_create();
struct wfp_timer_manager * timer_manager = wfp_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);
struct wfp_jsonrpc_proxy * proxy = wfp_jsonrpc_proxy_create(timer_manager, WFP_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);
wfp_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));
@ -279,75 +279,75 @@ TEST(wf_jsonrpc_proxy, on_result_reject_response_with_unknown_id)
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);
wfp_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);
wfp_jsonrpc_proxy_dispose(proxy);
wfp_timer_manager_dispose(timer_manager);
}
TEST(wf_jsonrpc_proxy, timeout)
TEST(wfp_jsonrpc_proxy, timeout)
{
struct wf_timer_manager * timer_manager = wf_timer_manager_create();
struct wfp_timer_manager * timer_manager = wfp_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);
struct wfp_jsonrpc_proxy * proxy = wfp_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);
wfp_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));
std::this_thread::sleep_for(10ms);
wf_timer_manager_check(timer_manager);
wfp_timer_manager_check(timer_manager);
ASSERT_TRUE(finished_context.is_called);
ASSERT_EQ(WF_BAD_TIMEOUT, jsonrpc_get_status(finished_context.error));
ASSERT_EQ(WFP_BAD_TIMEOUT, jsonrpc_get_status(finished_context.error));
wf_jsonrpc_proxy_dispose(proxy);
wf_timer_manager_dispose(timer_manager);
wfp_jsonrpc_proxy_dispose(proxy);
wfp_timer_manager_dispose(timer_manager);
}
TEST(wf_jsonrpc_proxy, cleanup_pending_request)
TEST(wfp_jsonrpc_proxy, cleanup_pending_request)
{
struct wf_timer_manager * timer_manager = wf_timer_manager_create();
struct wfp_timer_manager * timer_manager = wfp_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);
struct wfp_jsonrpc_proxy * proxy = wfp_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);
wfp_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);
wfp_jsonrpc_proxy_dispose(proxy);
ASSERT_TRUE(finished_context.is_called);
wf_timer_manager_dispose(timer_manager);
wfp_timer_manager_dispose(timer_manager);
}
TEST(wf_jsonrpc_proxy, notify)
TEST(wfp_jsonrpc_proxy, notify)
{
struct wf_timer_manager * timer_manager = wf_timer_manager_create();
struct wfp_timer_manager * timer_manager = wfp_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);
struct wfp_jsonrpc_proxy * proxy = wfp_jsonrpc_proxy_create(timer_manager, WFP_DEFAULT_TIMEOUT, &jsonrpc_send, send_data);
wf_jsonrpc_proxy_notify(proxy, "foo", "si", "bar", 42);
wfp_jsonrpc_proxy_notify(proxy, "foo", "si", "bar", 42);
ASSERT_TRUE(send_context.is_called);
ASSERT_TRUE(json_is_object(send_context.response));
@ -367,64 +367,64 @@ TEST(wf_jsonrpc_proxy, notify)
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);
wfp_jsonrpc_proxy_dispose(proxy);
wfp_timer_manager_dispose(timer_manager);
}
TEST(wf_jsonrpc_proxy, notify_dont_send_invalid_request)
TEST(wfp_jsonrpc_proxy, notify_dont_send_invalid_request)
{
struct wf_timer_manager * timer_manager = wf_timer_manager_create();
struct wfp_timer_manager * timer_manager = wfp_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);
struct wfp_jsonrpc_proxy * proxy = wfp_jsonrpc_proxy_create(timer_manager, WFP_DEFAULT_TIMEOUT, &jsonrpc_send, send_data);
wf_jsonrpc_proxy_notify(proxy, "foo", "?");
wfp_jsonrpc_proxy_notify(proxy, "foo", "?");
ASSERT_FALSE(send_context.is_called);
wf_jsonrpc_proxy_dispose(proxy);
wf_timer_manager_dispose(timer_manager);
wfp_jsonrpc_proxy_dispose(proxy);
wfp_timer_manager_dispose(timer_manager);
}
TEST(wf_jsonrpc_proxy, swallow_timeout_if_no_request_pending)
TEST(wfp_jsonrpc_proxy, swallow_timeout_if_no_request_pending)
{
MockTimer timer_api;
wf_timer_on_timer_fn * on_timer = nullptr;
wfp_timer_on_timer_fn * on_timer = nullptr;
void * timer_context = nullptr;
EXPECT_CALL(timer_api, wf_timer_create(_, _, _))
EXPECT_CALL(timer_api, wfp_timer_create(_, _, _))
.Times(1)
.WillOnce(DoAll(SaveArg<1>(&on_timer), SaveArg<2>(&timer_context), Return(nullptr)));
EXPECT_CALL(timer_api, wf_timer_dispose(_)).Times(1);
EXPECT_CALL(timer_api, wfp_timer_dispose(_)).Times(1);
SendContext send_context;
void * send_data = reinterpret_cast<void*>(&send_context);
struct wf_jsonrpc_proxy * proxy = wf_jsonrpc_proxy_create(nullptr, 1, &jsonrpc_send, send_data);
struct wfp_jsonrpc_proxy * proxy = wfp_jsonrpc_proxy_create(nullptr, 1, &jsonrpc_send, send_data);
on_timer(nullptr, timer_context);
ASSERT_FALSE(send_context.is_called);
wf_jsonrpc_proxy_dispose(proxy);
wfp_jsonrpc_proxy_dispose(proxy);
}
TEST(wf_jsonrpc_proxy, on_result_swallow_if_no_request_pending)
TEST(wfp_jsonrpc_proxy, on_result_swallow_if_no_request_pending)
{
struct wf_timer_manager * timer_manager = wf_timer_manager_create();
struct wfp_timer_manager * timer_manager = wfp_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);
struct wfp_jsonrpc_proxy * proxy = wfp_jsonrpc_proxy_create(timer_manager, WFP_DEFAULT_TIMEOUT, &jsonrpc_send, send_data);
json_t * response = json_object();
json_object_set_new(response, "result", json_string("okay"));
json_object_set_new(response, "id", json_integer(42));
wf_jsonrpc_proxy_onresult(proxy, response);
wfp_jsonrpc_proxy_onresult(proxy, response);
json_decref(response);
wf_jsonrpc_proxy_dispose(proxy);
wf_timer_manager_dispose(timer_manager);
wfp_jsonrpc_proxy_dispose(proxy);
wfp_timer_manager_dispose(timer_manager);
}

40
test/webfuse_provider/tests/core/jsonrpc/test_request.cc
View File

@ -23,29 +23,29 @@ bool jsonrpc_send(
}
TEST(wf_jsonrpc_request, create_dispose)
TEST(wfp_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);
struct wfp_jsonrpc_request * request =
wfp_jsonrpc_request_create(42, &jsonrpc_send, user_data);
ASSERT_NE(nullptr, request);
ASSERT_EQ(user_data, wf_jsonrpc_request_get_userdata(request));
ASSERT_EQ(user_data, wfp_jsonrpc_request_get_userdata(request));
wf_jsonrpc_request_dispose(request);
wfp_jsonrpc_request_dispose(request);
}
TEST(wf_jsonrpc_request, respond)
TEST(wfp_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);
struct wfp_jsonrpc_request * request =
wfp_jsonrpc_request_create(42, &jsonrpc_send, user_data);
wf_jsonrpc_respond(request, json_string("okay"));
wfp_jsonrpc_respond(request, json_string("okay"));
ASSERT_NE(nullptr, context.response);
@ -66,15 +66,15 @@ TEST(wf_jsonrpc_request, respond)
json_decref(response);
}
TEST(wf_jsonrpc_request, respond_error)
TEST(wfp_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);
struct wfp_jsonrpc_request * request =
wfp_jsonrpc_request_create(42, &jsonrpc_send, user_data);
wf_jsonrpc_respond_error(request, WF_BAD, "Bad");
wfp_jsonrpc_respond_error(request, WFP_BAD, "Bad");
ASSERT_NE(nullptr, context.response);
@ -93,7 +93,7 @@ TEST(wf_jsonrpc_request, respond_error)
json_t * err_code = json_object_get(err, "code");
ASSERT_TRUE(json_is_integer(err_code));
ASSERT_EQ(WF_BAD, json_integer_value(err_code));
ASSERT_EQ(WFP_BAD, json_integer_value(err_code));
json_t * err_message = json_object_get(err, "message");
ASSERT_TRUE(json_is_string(err_message));
@ -102,37 +102,37 @@ TEST(wf_jsonrpc_request, respond_error)
json_decref(response);
}
TEST(wf_jsonrpc_request, is_request_object_params)
TEST(wfp_jsonrpc_request, is_request_object_params)
{
json_t * request = json_object();
json_object_set_new(request, "method", json_string("some_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));
ASSERT_TRUE(wfp_jsonrpc_is_request(request));
json_decref(request);
}
TEST(wf_jsonrpc_request, is_request_fail_missing_params)
TEST(wfp_jsonrpc_request, is_request_fail_missing_params)
{
json_t * request = json_object();
json_object_set_new(request, "method", json_string("some_method"));
json_object_set_new(request, "id", json_integer(42));
ASSERT_FALSE(wf_jsonrpc_is_request(request));
ASSERT_FALSE(wfp_jsonrpc_is_request(request));
json_decref(request);
}
TEST(wf_jsonrpc_request, is_request_fail_params_wrong_type)
TEST(wfp_jsonrpc_request, is_request_fail_params_wrong_type)
{
json_t * request = json_object();
json_object_set_new(request, "method", json_string("some_method"));
json_object_set_new(request, "params", json_string("invalid_params"));
json_object_set_new(request, "id", json_integer(42));
ASSERT_FALSE(wf_jsonrpc_is_request(request));
ASSERT_FALSE(wfp_jsonrpc_is_request(request));
json_decref(request);
}

Some files were not shown because too many files have changed in this diff Show More