summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--lib/client.c6
-rw-r--r--lib/client.h7
-rw-r--r--lib/data.h209
-rw-r--r--lib/meson.build3
-rw-r--r--lib/protocol.c161
-rw-r--r--lib/protocol.h19
-rw-r--r--lib/server.c5
-rw-r--r--lib/server.h7
-rw-r--r--meson.build1
-rw-r--r--src/icipc-client.c35
-rw-r--r--tests/client-server.c45
-rw-r--r--tests/protocol.c58
12 files changed, 368 insertions, 188 deletions
diff --git a/lib/client.c b/lib/client.c
index 4186ce4..f1c4da1 100644
--- a/lib/client.c
+++ b/lib/client.c
@@ -40,7 +40,7 @@ void icipc_client_free(struct icipc_client *self) {
bool icipc_client_send_request(
struct icipc_client *self,
const char *name,
- const struct spa_pod *args,
+ const struct icipc_data *args,
icipc_sender_reply_func_t reply,
void *data) {
struct icipc_sender *base = icipc_client_to_sender(self);
@@ -55,7 +55,7 @@ bool icipc_client_send_request(
return icipc_sender_send(base, buffer, size, reply, data);
}
-const struct spa_pod *icipc_client_send_request_finish(
+const struct icipc_data *icipc_client_send_request_finish(
struct icipc_sender *self,
const uint8_t * buffer,
size_t size,
@@ -68,7 +68,7 @@ const struct spa_pod *icipc_client_send_request_finish(
/* ok */
if (icipc_protocol_is_reply_ok(buffer, size)) {
- const struct spa_pod *value = NULL;
+ const struct icipc_data *value = NULL;
if (icipc_protocol_parse_reply_ok(buffer, size, &value))
return value;
}
diff --git a/lib/client.h b/lib/client.h
index 597552c..226d87a 100644
--- a/lib/client.h
+++ b/lib/client.h
@@ -9,8 +9,6 @@
#ifndef __ICIPC_CLIENT_H__
#define __ICIPC_CLIENT_H__
-#include <spa/pod/pod.h>
-
#include <stddef.h>
#include "sender.h"
@@ -23,6 +21,7 @@ extern "C" {
#define icipc_client_to_sender(self) ((struct icipc_sender *)(self))
struct icipc_client;
+struct icipc_data;
ICIPC_API
struct icipc_client *icipc_client_new(const char *path, bool connect);
@@ -34,14 +33,14 @@ ICIPC_API
bool icipc_client_send_request(
struct icipc_client *self,
const char *name,
- const struct spa_pod *args,
+ const struct icipc_data *args,
icipc_sender_reply_func_t reply,
void *data);
/* for reply handlers only */
ICIPC_API
-const struct spa_pod *icipc_client_send_request_finish(
+const struct icipc_data *icipc_client_send_request_finish(
struct icipc_sender *self,
const uint8_t *buffer,
size_t size,
diff --git a/lib/data.h b/lib/data.h
new file mode 100644
index 0000000..7072ba9
--- /dev/null
+++ b/lib/data.h
@@ -0,0 +1,209 @@
+/* PipeWire AGL Cluster IPC
+ *
+ * Copyright © 2018 Wim Taymans
+ * Copyright © 2021 Collabora Ltd.
+ * @author George Kiagiadakis <george.kiagiadakis@collabora.com>
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+
+/* Trimmed down version of struct spa_pod from PipeWire's Simple Plugin API
+ * This aims to be compatible with spa_pod, so you can cast icipc_data
+ * to spa_pod and still be able to use it */
+
+struct icipc_data {
+ uint32_t size; /* size of the body */
+ uint32_t type; /* type of the body */
+ /* type-specific body follows */
+};
+
+#define ICIPC_DATA_BODY_SIZE(d) (((const struct icipc_data*)(d))->size)
+#define ICIPC_DATA_TYPE(d) (((const struct icipc_data*)(d))->type)
+#define ICIPC_DATA_SIZE(d) (sizeof(struct icipc_data) + ICIPC_DATA_BODY_SIZE(d))
+#define ICIPC_DATA_BODY(d) ((void*)(((uint8_t *) d) + sizeof(struct icipc_data)))
+#define ICIPC_DATA_BODY_CONST(d) ((const void*)(((const uint8_t *) d) + sizeof(struct icipc_data)))
+
+enum {
+ DATA_TYPE_NONE = 1, /* SPA_TYPE_None */
+ DATA_TYPE_ID = 3, /* SPA_TYPE_Id */
+ DATA_TYPE_INT = 4, /* SPA_TYPE_Int */
+ DATA_TYPE_STRING = 8, /* SPA_TYPE_String */
+ DATA_TYPE_STRUCT = 14, /* SPA_TYPE_Struct */
+};
+
+#define PTR_ALIGNMENT 8
+#define ROUND_UP_TO_ALIGN(num) (((num) + (PTR_ALIGNMENT - 1)) & ~((PTR_ALIGNMENT) - 1))
+#define PTR_IS_ALIGNED(p) (((intptr_t)(p) & (PTR_ALIGNMENT-1)) == 0)
+
+typedef struct DataBuilder {
+ union {
+ uint8_t *buffer;
+ struct icipc_data *data;
+ };
+ union {
+ uint8_t *ptr;
+ struct icipc_data *ptr_as_data;
+ };
+ size_t buf_size;
+} DataBuilder;
+
+typedef struct DataParser {
+ union {
+ const uint8_t *buffer;
+ const struct icipc_data *data;
+ };
+ union {
+ const uint8_t *ptr;
+ const struct icipc_data *ptr_as_data;
+ };
+ size_t buf_size;
+} DataParser;
+
+static inline void data_builder_init(
+ DataBuilder *b,
+ uint8_t *buffer,
+ size_t size) {
+ assert(size >= sizeof(struct icipc_data));
+ memset(buffer, 0, size);
+ b->buffer = buffer;
+ b->buf_size = size;
+ b->data->type = DATA_TYPE_STRUCT;
+ b->ptr = ICIPC_DATA_BODY(b->data);
+ assert(PTR_IS_ALIGNED(b->ptr));
+}
+
+static inline size_t data_type_id_calc_size(void) {
+ return sizeof(struct icipc_data) + ROUND_UP_TO_ALIGN(sizeof(uint32_t));
+}
+
+static inline void data_builder_push_id(DataBuilder *b, uint32_t id) {
+
+ const size_t body_size = ROUND_UP_TO_ALIGN(sizeof(uint32_t));
+ const size_t additional_size = sizeof(struct icipc_data) + body_size;
+ assert(b->buf_size >= ICIPC_DATA_SIZE(b->data) + additional_size);
+
+ b->ptr_as_data->size = body_size;
+ b->ptr_as_data->type = DATA_TYPE_ID;
+ *((uint32_t *) ICIPC_DATA_BODY(b->ptr)) = id;
+
+ b->data->size += additional_size;
+ b->ptr += additional_size;
+ assert(PTR_IS_ALIGNED(b->ptr));
+}
+
+static inline size_t data_type_string_calc_size(const char *str) {
+ size_t str_size = strlen(str) + 1;
+ return sizeof(struct icipc_data) + ROUND_UP_TO_ALIGN(str_size);
+}
+
+static inline void data_builder_push_string(DataBuilder *b, const char *str) {
+
+ size_t str_size = strlen(str) + 1;
+ const size_t body_size = ROUND_UP_TO_ALIGN(str_size);
+ const size_t additional_size = sizeof(struct icipc_data) + body_size;
+ assert(b->buf_size >= ICIPC_DATA_SIZE(b->data) + additional_size);
+
+ b->ptr_as_data->size = body_size;
+ b->ptr_as_data->type = DATA_TYPE_STRING;
+ strncpy((char *) ICIPC_DATA_BODY(b->ptr), str, str_size);
+
+ b->data->size += additional_size;
+ b->ptr += additional_size;
+ assert(PTR_IS_ALIGNED(b->ptr));
+}
+
+static inline size_t data_type_raw_calc_size(const struct icipc_data *raw) {
+ return sizeof(struct icipc_data) +
+ ROUND_UP_TO_ALIGN(ICIPC_DATA_BODY_SIZE(raw));
+}
+
+static inline void data_builder_push_raw(
+ DataBuilder *b,
+ const struct icipc_data *raw) {
+
+ const size_t body_size = ROUND_UP_TO_ALIGN(ICIPC_DATA_BODY_SIZE(raw));
+ const size_t additional_size = sizeof(struct icipc_data) + body_size;
+ assert(b->buf_size >= ICIPC_DATA_SIZE(b->data) + additional_size);
+
+ b->ptr_as_data->size = body_size;
+ b->ptr_as_data->type = raw->type;
+ memcpy(ICIPC_DATA_BODY(b->ptr),
+ ICIPC_DATA_BODY(raw),
+ ICIPC_DATA_BODY_SIZE(raw));
+
+ b->data->size += additional_size;
+ b->ptr += additional_size;
+ assert(PTR_IS_ALIGNED(b->ptr));
+}
+
+static inline bool data_parser_init(
+ DataParser *p,
+ const uint8_t *buffer,
+ size_t size) {
+ assert(size >= sizeof(struct icipc_data));
+ p->buffer = buffer;
+ p->buf_size = size;
+
+ if (p->data->type != DATA_TYPE_STRUCT ||
+ ICIPC_DATA_SIZE(p->data) > size)
+ return false;
+
+ p->ptr = ICIPC_DATA_BODY(p->data);
+ assert(PTR_IS_ALIGNED(p->ptr));
+ return true;
+}
+
+static inline bool data_parser_get_id(DataParser *p, uint32_t *id) {
+
+ if (p->ptr_as_data->type != DATA_TYPE_ID ||
+ ICIPC_DATA_BODY_SIZE(p->ptr) != ROUND_UP_TO_ALIGN(sizeof(uint32_t)))
+ return false;
+
+ *id = *((const uint32_t *) ICIPC_DATA_BODY_CONST(p->ptr));
+
+ p->ptr += ICIPC_DATA_SIZE(p->ptr);
+ assert(PTR_IS_ALIGNED(p->ptr));
+ return true;
+}
+
+static inline bool data_parser_get_string(DataParser *p, const char **str) {
+
+ if (p->ptr_as_data->type != DATA_TYPE_STRING ||
+ ICIPC_DATA_BODY_SIZE(p->ptr) == 0 ||
+ ICIPC_DATA_BODY_SIZE(p->ptr) !=
+ ROUND_UP_TO_ALIGN(ICIPC_DATA_BODY_SIZE(p->ptr)) ||
+ (p->ptr - p->buffer) + ICIPC_DATA_SIZE(p->ptr) > p->buf_size)
+ return false;
+
+ *str = (const char *) ICIPC_DATA_BODY_CONST(p->ptr);
+
+ /* check that the string has a terminating null character */
+ if (strnlen(*str, ICIPC_DATA_BODY_SIZE(p->ptr)) ==
+ ICIPC_DATA_BODY_SIZE(p->ptr))
+ return false;
+
+ p->ptr += ICIPC_DATA_SIZE(p->ptr);
+ assert(PTR_IS_ALIGNED(p->ptr));
+ return true;
+}
+
+static inline bool data_parser_get_raw(
+ DataParser *p,
+ const struct icipc_data **raw) {
+ if (ICIPC_DATA_BODY_SIZE(p->ptr) !=
+ ROUND_UP_TO_ALIGN(ICIPC_DATA_BODY_SIZE(p->ptr)) ||
+ (p->ptr - p->buffer) + ICIPC_DATA_SIZE(p->ptr) > p->buf_size)
+ return false;
+
+ *raw = p->ptr_as_data;
+
+ p->ptr += ICIPC_DATA_SIZE(p->ptr);
+ assert(PTR_IS_ALIGNED(p->ptr));
+ return true;
+}
diff --git a/lib/meson.build b/lib/meson.build
index dc19c1f..7b8a21b 100644
--- a/lib/meson.build
+++ b/lib/meson.build
@@ -33,7 +33,7 @@ icipc_lib = library('icipc-' + icipc_api_version,
'-DG_LOG_DOMAIN="icipc"',
],
install: true,
- dependencies : [threads_dep, spa_dep],
+ dependencies : [threads_dep],
soversion: icipc_so_version,
version: meson.project_version(),
)
@@ -41,7 +41,6 @@ icipc_lib = library('icipc-' + icipc_api_version,
icipc_dep = declare_dependency(
link_with: icipc_lib,
include_directories: include_directories('.'),
- dependencies: [spa_dep],
)
pkgconfig.generate(icipc_lib,
diff --git a/lib/protocol.c b/lib/protocol.c
index 35a9485..ac53d2b 100644
--- a/lib/protocol.c
+++ b/lib/protocol.c
@@ -6,35 +6,22 @@
* SPDX-License-Identifier: MIT
*/
-#include <assert.h>
-
-#include <spa/pod/builder.h>
-#include <spa/pod/parser.h>
-
+#include "data.h"
#include "protocol.h"
-#define SIZE_PADDING 128
-
enum {
REPLY_CODE_ERROR = 0,
REPLY_CODE_OK,
};
-static bool is_reply(const uint8_t *buffer, size_t size, int code) {
- const struct spa_pod *pod = (const struct spa_pod *)buffer;
- struct spa_pod_parser p;
- struct spa_pod_frame f;
- int parsed_code = 0;
+static bool is_reply(const uint8_t *buffer, size_t size, uint32_t code) {
+ DataParser p;
+ uint32_t parsed_code = 0;
- /* check if struct */
- if (!spa_pod_is_struct(pod))
+ if (!data_parser_init(&p, buffer, size) ||
+ !data_parser_get_id(&p, &parsed_code))
return false;
- /* parse */
- spa_pod_parser_pod(&p, pod);
- spa_pod_parser_push_struct(&p, &f);
- spa_pod_parser_get_int(&p, &parsed_code);
-
return parsed_code == code;
}
@@ -42,56 +29,40 @@ static bool is_reply(const uint8_t *buffer, size_t size, int code) {
size_t icipc_protocol_calculate_request_size(
const char *name,
- const struct spa_pod *args) {
+ const struct icipc_data *args) {
assert (name);
- return strlen(name) + (args ? SPA_POD_SIZE(args) : 8) + SIZE_PADDING;
+ return sizeof(struct icipc_data) +
+ data_type_string_calc_size(name) +
+ (args ? data_type_raw_calc_size(args) : sizeof(struct icipc_data));
}
void icipc_protocol_build_request(
uint8_t *buffer,
size_t size,
const char *name,
- const struct spa_pod *args) {
- const struct spa_pod none = SPA_POD_INIT_None();
- struct spa_pod_builder b;
- struct spa_pod_frame f;
-
- memset(buffer, 0, size);
-
+ const struct icipc_data *args) {
+ DataBuilder b;
+ const struct icipc_data none = { 0, DATA_TYPE_NONE };
if (args == NULL)
args = &none;
- spa_pod_builder_init(&b, buffer, size);
- spa_pod_builder_push_struct(&b, &f);
- spa_pod_builder_string(&b, name);
- spa_pod_builder_primitive (&b, args);
- spa_pod_builder_pop(&b, &f);
+ data_builder_init(&b, buffer, size);
+ data_builder_push_string(&b, name);
+ data_builder_push_raw(&b, args);
}
bool icipc_protocol_parse_request(
const uint8_t *buffer,
size_t size,
const char **name,
- const struct spa_pod **args) {
- const struct spa_pod *pod = (const struct spa_pod *)buffer;
- struct spa_pod_parser p;
- struct spa_pod_frame f;
+ const struct icipc_data **args) {
+ DataParser p;
const char *parsed_name = NULL;
- struct spa_pod *parsed_args = NULL;
+ const struct icipc_data *parsed_args = NULL;
- /* check if struct */
- if (!spa_pod_is_struct(pod))
- return false;
-
- /* parse */
- spa_pod_parser_pod(&p, pod);
- spa_pod_parser_push_struct(&p, &f);
- spa_pod_parser_get_string(&p, &parsed_name);
- spa_pod_parser_get_pod(&p, &parsed_args);
- spa_pod_parser_pop(&p, &f);
-
- /* check name and args */
- if (name == NULL || args == NULL)
+ if (!data_parser_init(&p, buffer, size) ||
+ !data_parser_get_string(&p, &parsed_name) ||
+ !data_parser_get_raw(&p, &parsed_args))
return false;
if (name != NULL)
@@ -101,49 +72,41 @@ bool icipc_protocol_parse_request(
return true;
}
-size_t icipc_protocol_calculate_reply_ok_size(const struct spa_pod *value) {
- return (value ? SPA_POD_SIZE(value) : 8) + SIZE_PADDING;
+size_t icipc_protocol_calculate_reply_ok_size(const struct icipc_data *value) {
+ return sizeof(struct icipc_data) +
+ data_type_id_calc_size() +
+ (value ? data_type_raw_calc_size(value) : sizeof(struct icipc_data));
}
size_t icipc_protocol_calculate_reply_error_size(const char *msg) {
assert (msg);
- return strlen(msg) + SIZE_PADDING;
+ return sizeof(struct icipc_data) +
+ data_type_id_calc_size() +
+ data_type_string_calc_size(msg);
}
void icipc_protocol_build_reply_ok(
uint8_t *buffer,
size_t size,
- const struct spa_pod *value) {
- const struct spa_pod none = SPA_POD_INIT_None();
- struct spa_pod_builder b;
- struct spa_pod_frame f;
-
- memset(buffer, 0, size);
-
+ const struct icipc_data *value) {
+ DataBuilder b;
+ const struct icipc_data none = { 0, DATA_TYPE_NONE };
if (value == NULL)
value = &none;
- spa_pod_builder_init(&b, buffer, size);
- spa_pod_builder_push_struct(&b, &f);
- spa_pod_builder_int(&b, REPLY_CODE_OK);
- spa_pod_builder_primitive(&b, value);
- spa_pod_builder_pop(&b, &f);
+ data_builder_init(&b, buffer, size);
+ data_builder_push_id(&b, REPLY_CODE_OK);
+ data_builder_push_raw(&b, value);
}
void icipc_protocol_build_reply_error(
uint8_t *buffer,
size_t size,
const char *msg) {
- struct spa_pod_builder b;
- struct spa_pod_frame f;
-
- memset(buffer, 0, size);
-
- spa_pod_builder_init(&b, buffer, size);
- spa_pod_builder_push_struct(&b, &f);
- spa_pod_builder_int(&b, REPLY_CODE_ERROR);
- spa_pod_builder_string (&b, msg);
- spa_pod_builder_pop(&b, &f);
+ DataBuilder b;
+ data_builder_init(&b, buffer, size);
+ data_builder_push_id(&b, REPLY_CODE_ERROR);
+ data_builder_push_string(&b, msg);
}
bool icipc_protocol_is_reply_ok(const uint8_t *buffer, size_t size) {
@@ -154,53 +117,37 @@ bool icipc_protocol_is_reply_error(const uint8_t *buffer, size_t size) {
return is_reply (buffer, size, REPLY_CODE_ERROR);
}
-bool icipc_protocol_parse_reply_ok (
+bool icipc_protocol_parse_reply_ok(
const uint8_t *buffer,
size_t size,
- const struct spa_pod **value) {
- const struct spa_pod *pod = (const struct spa_pod *)buffer;
- struct spa_pod_parser p;
- struct spa_pod_frame f;
- int parsed_code = 0;
- struct spa_pod *parsed_value = NULL;
-
- /* check if struct */
- if (!spa_pod_is_struct(pod))
+ const struct icipc_data **value) {
+ DataParser p;
+ uint32_t parsed_code = 0;
+ const struct icipc_data *parsed_value = NULL;
+
+ if (!data_parser_init(&p, buffer, size) ||
+ !data_parser_get_id(&p, &parsed_code) ||
+ !data_parser_get_raw(&p, &parsed_value))
return false;
- /* parse */
- spa_pod_parser_pod(&p, pod);
- spa_pod_parser_push_struct(&p, &f);
- spa_pod_parser_get_int(&p, &parsed_code);
- spa_pod_parser_get_pod(&p, &parsed_value);
- spa_pod_parser_pop(&p, &f);
-
if (value != NULL)
*value = parsed_value;
return true;
}
-bool icipc_protocol_parse_reply_error (
+bool icipc_protocol_parse_reply_error(
const uint8_t *buffer,
size_t size,
const char **msg) {
- const struct spa_pod *pod = (const struct spa_pod *)buffer;
- struct spa_pod_parser p;
- struct spa_pod_frame f;
- int parsed_code = 0;
+ DataParser p;
+ uint32_t parsed_code = 0;
const char *parsed_msg = NULL;
- /* check if struct */
- if (!spa_pod_is_struct(pod))
+ if (!data_parser_init(&p, buffer, size) ||
+ !data_parser_get_id(&p, &parsed_code) ||
+ !data_parser_get_string(&p, &parsed_msg))
return false;
- /* parse */
- spa_pod_parser_pod(&p, pod);
- spa_pod_parser_push_struct(&p, &f);
- spa_pod_parser_get_int(&p, &parsed_code);
- spa_pod_parser_get_string(&p, &parsed_msg);
- spa_pod_parser_pop(&p, &f);
-
if (msg != NULL)
*msg = parsed_msg;
return true;
diff --git a/lib/protocol.h b/lib/protocol.h
index 34a92a0..821edf2 100644
--- a/lib/protocol.h
+++ b/lib/protocol.h
@@ -9,39 +9,42 @@
#ifndef __ICIPC_PROTOCOL_H__
#define __ICIPC_PROTOCOL_H__
-#include <spa/pod/pod.h>
-
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
#include "defs.h"
#ifdef __cplusplus
extern "C" {
#endif
+struct icipc_data;
+
/* request */
ICIPC_API
size_t icipc_protocol_calculate_request_size(
const char *name,
- const struct spa_pod *args);
+ const struct icipc_data *args);
ICIPC_API
void icipc_protocol_build_request(
uint8_t *buffer,
size_t size,
const char *name,
- const struct spa_pod *args);
+ const struct icipc_data *args);
ICIPC_API
bool icipc_protocol_parse_request(
const uint8_t *buffer,
size_t size,
const char **name,
- const struct spa_pod **args);
+ const struct icipc_data **args);
/* reply */
ICIPC_API
-size_t icipc_protocol_calculate_reply_ok_size(const struct spa_pod *value);
+size_t icipc_protocol_calculate_reply_ok_size(const struct icipc_data *value);
ICIPC_API
size_t icipc_protocol_calculate_reply_error_size(const char *msg);
@@ -50,7 +53,7 @@ ICIPC_API
void icipc_protocol_build_reply_ok(
uint8_t *buffer,
size_t size,
- const struct spa_pod *value);
+ const struct icipc_data *value);
ICIPC_API
void icipc_protocol_build_reply_error(
@@ -68,7 +71,7 @@ ICIPC_API
bool icipc_protocol_parse_reply_ok(
const uint8_t *buffer,
size_t size,
- const struct spa_pod **value);
+ const struct icipc_data **value);
ICIPC_API
bool icipc_protocol_parse_reply_error(
diff --git a/lib/server.c b/lib/server.c
index 747b829..6229ecd 100644
--- a/lib/server.c
+++ b/lib/server.c
@@ -7,6 +7,7 @@
*/
#include <pthread.h>
+#include <string.h>
#include "private.h"
#include "protocol.h"
@@ -60,7 +61,7 @@ static bool handle_message(
void *data) {
ServerPriv *priv = icipc_receiver_get_user_data(base);
const char *name = NULL;
- const struct spa_pod *args = NULL;
+ const struct icipc_data *args = NULL;
icipc_log_info("server: message from client %d received", sender_fd);
@@ -231,7 +232,7 @@ void icipc_server_clear_request_handler(
bool icipc_server_reply_ok(
struct icipc_server *self,
int client_fd,
- const struct spa_pod *value) {
+ const struct icipc_data *value) {
const size_t s = icipc_protocol_calculate_reply_ok_size(value);
uint8_t b[s];
icipc_protocol_build_reply_ok(b, s, value);
diff --git a/lib/server.h b/lib/server.h
index 6345035..cacb095 100644
--- a/lib/server.h
+++ b/lib/server.h
@@ -9,8 +9,6 @@
#ifndef __ICIPC_SERVER_H__
#define __ICIPC_SERVER_H__
-#include <spa/pod/pod.h>
-
#include "defs.h"
#include "receiver.h"
@@ -21,6 +19,7 @@ extern "C" {
#define icipc_server_to_receiver(self) ((struct icipc_receiver *)(self))
struct icipc_server;
+struct icipc_data;
typedef void (*icipc_server_client_handler_func_t)(
struct icipc_server *self,
@@ -32,7 +31,7 @@ typedef bool (*icipc_server_request_handler_func_t)(
struct icipc_server *self,
int client_fd,
const char *name,
- const struct spa_pod *args,
+ const struct icipc_data *args,
void *data);
ICIPC_API
@@ -68,7 +67,7 @@ ICIPC_API
bool icipc_server_reply_ok(
struct icipc_server *self,
int client_fd,
- const struct spa_pod *value);
+ const struct icipc_data *value);
ICIPC_API
bool icipc_server_reply_error(
diff --git a/meson.build b/meson.build
index 3aac10f..246196b 100644
--- a/meson.build
+++ b/meson.build
@@ -9,7 +9,6 @@ project('icipc', ['c'],
)
threads_dep = dependency('threads', required: true)
-spa_dep = dependency('libspa-0.2', version: '>= 0.2', required: true)
pkgconfig = import('pkgconfig')
cc = meson.get_compiler('c')
diff --git a/src/icipc-client.c b/src/icipc-client.c
index c1d2de7..9f47ba4 100644
--- a/src/icipc-client.c
+++ b/src/icipc-client.c
@@ -6,10 +6,10 @@
* SPDX-License-Identifier: MIT
*/
+#include <stdio.h>
+#include <string.h>
#include <pthread.h>
#include <assert.h>
-
-#include <spa/pod/builder.h>
#include <icipc.h>
typedef struct ClientData {
@@ -28,9 +28,9 @@ static void reply_handler(
const char *error = NULL;
if (buffer) {
- const struct spa_pod *pod =
+ const struct icipc_data *data =
icipc_client_send_request_finish(self, buffer, size, &error);
- if (!pod)
+ if (!data)
printf("error: %s\n", error ? error : "unknown");
else
printf("success!\n");
@@ -68,36 +68,21 @@ int main(int argc, char *argv[]) {
if (strncmp(str, "help", 4) == 0) {
printf("help\tprints this message\n");
printf("quit\texits the client\n");
- printf("send\tsends a request, usage: send <request-name> [args]\n");
+ printf("send\tsends a request, usage: send <request-name>\n");
} else if (strncmp(str, "quit", 4) == 0) {
printf("exiting...\n");
break;
} else if (strncmp(str, "send", 4) == 0) {
- char request_name[128];
- char request_args[1024];
+ char request_name[1024];
int n =
- sscanf(str, "send %s %s", request_name,
- request_args);
+ sscanf(str, "send %s", request_name);
if (n <= 0)
continue;
/* send request */
- if (n >= 2) {
- /* TODO: for now we always create a string pod for args */
- struct {
- struct spa_pod_string pod;
- char str[1024];
- } args;
- args.pod = SPA_POD_INIT_String(1024);
- strncpy(args.str, request_args, 1024);
- icipc_client_send_request(data.c, request_name,
- (const struct spa_pod *)&args,
- reply_handler, &data);
- } else {
- icipc_client_send_request(data.c, request_name,
- NULL, reply_handler,
- &data);
- }
+ icipc_client_send_request(data.c, request_name,
+ NULL, reply_handler,
+ &data);
/* wait for reply */
pthread_mutex_lock(&data.mutex);
diff --git a/tests/client-server.c b/tests/client-server.c
index 9954b86..f6e8fa5 100644
--- a/tests/client-server.c
+++ b/tests/client-server.c
@@ -8,12 +8,16 @@
#define _GNU_SOURCE
#include "test.h"
-#include <spa/pod/builder.h>
-#include <spa/pod/parser.h>
+#include "data.h"
#include <icipc.h>
#include <unistd.h>
#include <pthread.h>
+typedef struct DataInt {
+ struct icipc_data hdr;
+ int value;
+} DataInt;
+
static inline char *new_address() {
char *address = NULL;
(void)asprintf(&address, "icipc-test-%d-%d", getpid(), rand());
@@ -25,20 +29,27 @@ static bool increment_request_handler(
struct icipc_server *self,
int client_fd,
const char *name,
- const struct spa_pod *args,
+ const struct icipc_data *args,
void *data) {
int32_t val = 0;
- test_bool_true(spa_pod_is_int(args));
- test_bool_true(spa_pod_get_int(args, &val) == 0);
- struct spa_pod_int res = SPA_POD_INIT_Int(val + 1);
- return icipc_server_reply_ok(self, client_fd, (struct spa_pod *)&res);
+ test_cmpint(args->type, ==, (uint32_t) DATA_TYPE_INT);
+ test_cmpint(ICIPC_DATA_BODY_SIZE(args), ==,
+ ROUND_UP_TO_ALIGN(sizeof(int)));
+ val = *((const int*)ICIPC_DATA_BODY_CONST(args));
+
+ DataInt res = {
+ .hdr.size = sizeof(int),
+ .hdr.type = DATA_TYPE_INT,
+ .value = val + 1,
+ };
+ return icipc_server_reply_ok(self, client_fd, (struct icipc_data *)&res);
}
static bool error_request_handler(
struct icipc_server *self,
int client_fd,
const char *name,
- const struct spa_pod *args,
+ const struct icipc_data *args,
void *data) {
return icipc_server_reply_error(self, client_fd, "error message");
}
@@ -68,11 +79,13 @@ static void reply_handler(
pthread_mutex_lock(&data->mutex);
- const struct spa_pod *pod =
+ const struct icipc_data *args =
icipc_client_send_request_finish(self, buffer, size, &data->error);
- if (pod) {
- test_bool_true(spa_pod_is_int(pod));
- test_bool_true(spa_pod_get_int(pod, &data->incremented) == 0);
+ if (args) {
+ test_cmpint(args->type, ==, (uint32_t) DATA_TYPE_INT);
+ test_cmpint(ICIPC_DATA_BODY_SIZE(args), ==,
+ ROUND_UP_TO_ALIGN(sizeof(int)));
+ data->incremented = *((const int*)ICIPC_DATA_BODY_CONST(args));
}
data->n_replies++;
pthread_cond_signal(&data->cond);
@@ -100,9 +113,13 @@ static void test_icipc_server_client() {
data.incremented = -1;
data.error = NULL;
data.n_replies = 0;
- struct spa_pod_int i = SPA_POD_INIT_Int(3);
+ DataInt i = {
+ .hdr.size = sizeof(int),
+ .hdr.type = DATA_TYPE_INT,
+ .value = 3,
+ };
test_bool_true(icipc_client_send_request
- (c, "INCREMENT", (struct spa_pod *)&i, reply_handler,
+ (c, "INCREMENT", (struct icipc_data *)&i, reply_handler,
&data));
wait_for_reply(&data, 1);
test_ptr_null(data.error);
diff --git a/tests/protocol.c b/tests/protocol.c
index 1d29db3..c0d28e7 100644
--- a/tests/protocol.c
+++ b/tests/protocol.c
@@ -7,36 +7,49 @@
*/
#include "test.h"
-#include <spa/pod/builder.h>
-#include <spa/pod/parser.h>
+#include "data.h"
#include <icipc.h>
+typedef struct DataInt {
+ struct icipc_data hdr;
+ int value;
+} DataInt;
+
static void test_icipc_protocol() {
uint8_t b[1024];
/* request null value */
{
- icipc_protocol_build_request(b, sizeof(b), "name", NULL);
const char *name = NULL;
- const struct spa_pod *value = NULL;
+ const struct icipc_data *value = NULL;
+
+ icipc_protocol_build_request(b, sizeof(b), "name", NULL);
test_bool_true(icipc_protocol_parse_request
(b, sizeof(b), &name, &value));
test_str_eq(name, "name");
- test_bool_true(spa_pod_is_none(value));
+ test_cmpint(value->type, ==, (uint32_t) DATA_TYPE_NONE);
}
/* request */
{
- struct spa_pod_int i = SPA_POD_INIT_Int(8);
- icipc_protocol_build_request(b, sizeof(b), "name",
- (struct spa_pod *)&i);
+ DataInt i = {
+ .hdr.size = sizeof(int),
+ .hdr.type = DATA_TYPE_INT,
+ .value = 8,
+ };
const char *name = NULL;
- const struct spa_pod_int *value = NULL;
+ const struct icipc_data *value = NULL;
+
+ icipc_protocol_build_request(b, sizeof(b), "name",
+ (struct icipc_data *)&i);
test_bool_true(icipc_protocol_parse_request
(b, sizeof(b), &name,
- (const struct spa_pod **)&value));
+ (const struct icipc_data **)&value));
test_str_eq(name, "name");
- test_cmpint(value->value, ==, 8);
+ test_cmpint(ICIPC_DATA_BODY_SIZE(value), ==,
+ ROUND_UP_TO_ALIGN(sizeof(int)));
+ test_cmpint(value->type, ==, (uint32_t) DATA_TYPE_INT);
+ test_cmpint(*((const int*)ICIPC_DATA_BODY_CONST(value)), ==, 8);
}
/* reply error */
@@ -51,25 +64,34 @@ static void test_icipc_protocol() {
/* reply ok null value */
{
+ const struct icipc_data *value = NULL;
+
icipc_protocol_build_reply_ok(b, sizeof(b), NULL);
test_bool_true(icipc_protocol_is_reply_ok(b, sizeof(b)));
- const struct spa_pod *value = NULL;
test_bool_true(icipc_protocol_parse_reply_ok
(b, sizeof(b), &value));
test_ptr_notnull(value);
- test_bool_true(spa_pod_is_none(value));
+ test_cmpint(value->type, ==, (uint32_t) DATA_TYPE_NONE);
}
/* reply ok */
{
- struct spa_pod_int i = SPA_POD_INIT_Int(3);
+ DataInt i = {
+ .hdr.size = sizeof(int),
+ .hdr.type = DATA_TYPE_INT,
+ .value = 3,
+ };
+ const struct icipc_data *value = NULL;
+
icipc_protocol_build_reply_ok(b, sizeof(b),
- (struct spa_pod *)&i);
+ (struct icipc_data *)&i);
test_bool_true(icipc_protocol_is_reply_ok(b, sizeof(b)));
- const struct spa_pod_int *value = NULL;
test_bool_true(icipc_protocol_parse_reply_ok
- (b, sizeof(b), (const struct spa_pod **)&value));
- test_cmpint(value->value, ==, 3);
+ (b, sizeof(b), (const struct icipc_data **)&value));
+ test_cmpint(ICIPC_DATA_BODY_SIZE(value), ==,
+ ROUND_UP_TO_ALIGN(sizeof(int)));
+ test_cmpint(value->type, ==, (uint32_t) DATA_TYPE_INT);
+ test_cmpint(*((const int*)ICIPC_DATA_BODY_CONST(value)), ==, 3);
}
}