/*
- Copyright 2015 IoT.bzh
+ Copyright (C) 2015, 2016 "IoT.bzh"
author: José Bollo <jose.bollo@iot.bzh>
#include <poll.h>
#include <assert.h>
-#include <json.h>
+#include <json-c/json.h>
+#include <systemd/sd-bus.h>
+#include <systemd/sd-bus-protocol.h>
-#include "utils-sbus.h"
#include "utils-jbus.h"
/*
struct jservice {
struct jservice *next; /* link to the next service */
char *method; /* method name for the service */
- void (*oncall_s) (struct sbusmsg *, const char *, void *);
+ void (*oncall_s) (struct sd_bus_message *, const char *, void *);
/* string callback */
- void (*oncall_j) (struct sbusmsg *, struct json_object *, void *);
+ void (*oncall_j) (struct sd_bus_message *, struct json_object *, void *);
/* json callback */
void *data; /* closure data for the callbacks */
};
*/
struct jrespw {
struct jbus *jbus;
- void (*onresp) (int, struct json_object *, void *);
+ void (*onresp_s) (int, const char *, void *);
+ /* string callback */
+ void (*onresp_j) (int, struct json_object *, void *);
/* json callback */
void *data; /* closure data for the callbacks */
};
*/
struct jbus {
int refcount; /* referenced how many time */
- struct sbus *sbus;
- struct sbus_service *sservice;
- struct sbus_signal *ssignal;
+ struct sd_bus *sdbus;
+ struct sd_bus_slot *sservice;
+ struct sd_bus_slot *ssignal;
struct json_tokener *tokener; /* string to json tokenizer */
struct jservice *services; /* first service */
struct jsignal *signals; /* first signal */
/*********************** STATIC COMMON METHODS *****************/
+static int mkerrno(int rc)
+{
+ if (rc >= 0)
+ return rc;
+ errno = -rc;
+ return -1;
+}
+
/*
* Replies the error "out of memory".
* This function is intended to be used in services when an
* allocation fails. Thus, it set errno to ENOMEM and
* returns -1.
*/
-static inline int reply_out_of_memory(struct sbusmsg *smsg)
+static inline int reply_out_of_memory(struct sd_bus_message *smsg)
{
jbus_reply_error_s(smsg, out_of_memory_string);
errno = ENOMEM;
return 0;
}
-static void on_service_call(struct sbusmsg *smsg, const char *content, struct jbus *jbus)
+static int on_service_call(struct sd_bus_message *smsg, struct jbus *jbus, sd_bus_error *error)
{
struct jservice *service;
- const char *member;
+ const char *member, *content;
struct json_object *obj;
- member = sbus_member(smsg);
+ /* check the type */
+ if (!sd_bus_message_has_signature(smsg, "s")
+ || sd_bus_message_read_basic(smsg, 's', &content) < 0) {
+ sd_bus_error_set_const(error, "bad signature", "");
+ return 1;
+ }
+
+ /* dispatch */
+ member = sd_bus_message_get_member(smsg);
service = jbus->services;
while (service != NULL) {
if (!strcmp(service->method, member)) {
+ sd_bus_message_ref(smsg);
if (service->oncall_s)
service->oncall_s(smsg, content, service->data);
else if (service->oncall_j) {
service->oncall_j(smsg, obj, service->data);
json_object_put(obj);
}
+ return 1;
}
service = service->next;
}
+ return 0;
}
/*
static int add_service(
struct jbus *jbus,
const char *method,
- void (*oncall_s) (struct sbusmsg *, const char *, void *),
- void (*oncall_j) (struct sbusmsg *, struct json_object *, void *),
+ void (*oncall_s) (struct sd_bus_message *, const char *, void *),
+ void (*oncall_j) (struct sd_bus_message *, struct json_object *, void *),
void *data)
{
+ int rc;
struct jservice *srv;
/* connection of the service */
if (jbus->sservice == NULL) {
- jbus->sservice = sbus_add_service(jbus->sbus,
- NULL, jbus->path, jbus->name, NULL,
- (void*)on_service_call, jbus);
- if (jbus->sservice == NULL)
+ rc = sd_bus_add_object(jbus->sdbus, &jbus->sservice, jbus->path, (void*)on_service_call, jbus);
+ if (rc < 0) {
+ errno = -rc;
goto error;
+ }
}
/* allocation */
error2:
free(srv);
error:
- errno = ENOMEM;
return -1;
}
-static void on_signal_event(const struct sbusmsg *smsg, const char *content, struct jbus *jbus)
+static int on_signal_event(struct sd_bus_message *smsg, struct jbus *jbus, sd_bus_error *error)
{
struct jsignal *signal;
- const char *member;
+ const char *member, *content;
struct json_object *obj;
- member = sbus_member(smsg);
+ /* check the type */
+ if (!sd_bus_message_has_signature(smsg, "s")
+ || sd_bus_message_read_basic(smsg, 's', &content) < 0)
+ return 0;
+
+ /* dispatch */
+ member = sd_bus_message_get_member(smsg);
signal = jbus->signals;
while (signal != NULL) {
if (!strcmp(signal->name, member)) {
}
signal = signal->next;
}
+ return 0;
}
/*
void (*onsignal_j) (struct json_object *, void *),
void *data)
{
+ int rc;
struct jsignal *sig;
+ char *match;
/* connection of the signal */
if (jbus->ssignal == NULL) {
- jbus->ssignal = sbus_add_signal(jbus->sbus,
- NULL, jbus->path, jbus->name, NULL,
- (void*)on_signal_event, jbus);
- if (jbus->ssignal == NULL)
+ rc = asprintf(&match, "type='signal',path='%s',interface='%s'", jbus->path, jbus->name);
+ if (rc < 0) {
+ errno = ENOMEM;
goto error;
+ }
+ rc = sd_bus_add_match(jbus->sdbus, &jbus->ssignal, match, (void*)on_signal_event, jbus);
+ free(match);
+ if (rc < 0) {
+ errno = -rc;
+ goto error;
+ }
}
/* allocation */
sig = malloc(sizeof *sig);
- if (sig == NULL)
+ if (sig == NULL) {
+ errno = ENOMEM;
goto error;
+ }
sig->name = strdup(name);
- if (!sig->name)
+ if (!sig->name) {
+ errno = ENOMEM;
goto error2;
+ }
/* record the signal */
sig->onsignal_s = onsignal_s;
error2:
free(sig);
error:
- errno = ENOMEM;
return -1;
}
-static void on_reply_j(int status, const char *reply, struct jrespw *jrespw)
+static int on_reply(struct sd_bus_message *smsg, struct jrespw *jrespw, sd_bus_error *error)
{
struct json_object *obj;
+ const char *reply;
+ int iserror;
+
+ /* check the type */
+ if (!sd_bus_message_has_signature(smsg, "s")
+ || sd_bus_message_read_basic(smsg, 's', &reply) < 0) {
+ sd_bus_error_set_const(error, "bad signature", "");
+ goto end;
+ }
+ iserror = sd_bus_message_is_method_error(smsg, NULL);
+
+ /* dispatch string? */
+ if (jrespw->onresp_s != NULL) {
+ jrespw->onresp_s(iserror, reply, jrespw->data);
+ goto end;
+ }
+ /* dispatch json */
if (!jparse(jrespw->jbus, reply, &obj))
obj = json_object_new_string(reply);
- jrespw->onresp(status, obj, jrespw->data);
+ jrespw->onresp_j(iserror, obj, jrespw->data);
json_object_put(obj);
+
+ end:
free(jrespw);
+ return 1;
}
/*
void (*onresp_j) (int, struct json_object *, void *),
void *data)
{
+ int rc;
struct jrespw *resp;
- if (onresp_j == NULL)
- return sbus_call(jbus->sbus, jbus->name, jbus->path, jbus->name,
- method, query, onresp_s, data);
-
/* allocates the response structure */
resp = malloc(sizeof *resp);
- if (resp == NULL)
+ if (resp == NULL) {
+ errno = ENOMEM;
goto error;
+ }
/* fulfill the response structure */
resp->jbus = jbus;
- resp->onresp = onresp_j;
+ resp->onresp_s = onresp_s;
+ resp->onresp_j = onresp_j;
resp->data = data;
- if (sbus_call(jbus->sbus, jbus->name, jbus->path, jbus->name,
- method, query, (void*)on_reply_j, resp))
+
+ rc = sd_bus_call_method_async(jbus->sdbus, NULL, jbus->name, jbus->path, jbus->name, method, (void*)on_reply, resp, "s", query);
+ if (rc < 0) {
+ errno = -rc;
goto error2;
+ }
return 0;
error2:
free(resp);
error:
- errno = ENOMEM;
return -1;
}
*
* Returns the created jbus or NULL in case of error.
*/
-struct jbus *create_jbus(struct sbus *sbus, const char *path)
+struct jbus *create_jbus(struct sd_bus *sdbus, const char *path)
{
struct jbus *jbus;
char *name;
}
/* connect and init */
- jbus->sbus = sbus;
+ jbus->sdbus = sd_bus_ref(sdbus);
return jbus;
free(sig);
}
if (jbus->sservice != NULL)
- sbus_remove_service(jbus->sbus, jbus->sservice);
+ sd_bus_slot_unref(jbus->sservice);
if (jbus->ssignal != NULL)
- sbus_remove_signal(jbus->sbus, jbus->ssignal);
+ sd_bus_slot_unref(jbus->ssignal);
if (jbus->tokener != NULL)
json_tokener_free(jbus->tokener);
- sbus_unref(jbus->sbus);
+ sd_bus_unref(jbus->sdbus);
free(jbus->name);
free(jbus->path);
free(jbus);
*
* Returns 0 in case of success or -1 in case of error.
*/
-int jbus_reply_error_s(struct sbusmsg *smsg, const char *error)
+int jbus_reply_error_s(struct sd_bus_message *smsg, const char *error)
{
- return sbus_reply_error(smsg, error);
+ int rc = sd_bus_reply_method_errorf(smsg, SD_BUS_ERROR_FAILED, "%s", error);
+ sd_bus_message_unref(smsg);
+ return mkerrno(rc);
}
/*
*
* Returns 0 in case of success or -1 in case of error.
*/
-int jbus_reply_error_j(struct sbusmsg *smsg, struct json_object *reply)
+int jbus_reply_error_j(struct sd_bus_message *smsg, struct json_object *reply)
{
const char *str = json_object_to_json_string(reply);
return str ? jbus_reply_error_s(smsg, str) : reply_out_of_memory(smsg);
*
* Returns 0 in case of success or -1 in case of error.
*/
-int jbus_reply_s(struct sbusmsg *smsg, const char *reply)
+int jbus_reply_s(struct sd_bus_message *smsg, const char *reply)
{
- return sbus_reply(smsg, reply);
+ int rc = sd_bus_reply_method_return(smsg, "s", reply);
+ sd_bus_message_unref(smsg);
+ return mkerrno(rc);
}
/*
*
* Returns 0 in case of success or -1 in case of error.
*/
-int jbus_reply_j(struct sbusmsg *smsg, struct json_object *reply)
+int jbus_reply_j(struct sd_bus_message *smsg, struct json_object *reply)
{
const char *str = json_object_to_json_string(reply);
return str ? jbus_reply_s(smsg, str) : reply_out_of_memory(smsg);
*/
int jbus_send_signal_s(struct jbus *jbus, const char *name, const char *content)
{
- return sbus_send_signal(jbus->sbus, jbus->name, jbus->path, jbus->name, name, content);
+ return mkerrno(sd_bus_emit_signal(jbus->sdbus, jbus->path, jbus->name, name, "s", content));
}
/*
*
* The callback 'oncall' is invoked for handling incoming method
* calls. It receives 3 parameters:
- * 1. struct sbusmsg *: a handler to data to be used for replying
+ * 1. struct sd_bus_message *: a handler to data to be used for replying
* 2. const char *: the received string
* 3. void *: the closure 'data' set by this function
*
int jbus_add_service_s(
struct jbus *jbus,
const char *method,
- void (*oncall) (struct sbusmsg *, const char *, void *),
+ void (*oncall) (struct sd_bus_message *, const char *, void *),
void *data)
{
return add_service(jbus, method, oncall, NULL, data);
*
* The callback 'oncall' is invoked for handling incoming method
* calls. It receives 3 parameters:
- * 1. struct sbusmsg *: a handler to data to be used for replying
+ * 1. struct sd_bus_message *: a handler to data to be used for replying
* 2. struct json_object *: the received json
* 3. void *: the closure 'data' set by this function
*
int jbus_add_service_j(
struct jbus *jbus,
const char *method,
- void (*oncall) (struct sbusmsg *, struct json_object *, void *),
+ void (*oncall) (struct sd_bus_message *, struct json_object *, void *),
void *data)
{
return add_service(jbus, method, NULL, oncall, data);
*/
int jbus_start_serving(struct jbus *jbus)
{
- return sbus_add_name(jbus->sbus, jbus->name);
+ return mkerrno(sd_bus_request_name(jbus->sdbus, jbus->name, 0));
}
/*
const char *method,
const char *query)
{
- return sbus_call_sync(jbus->sbus, jbus->name, jbus->path, jbus->name,
- method, query);
+ sd_bus_message *smsg = NULL;
+ sd_bus_error error = SD_BUS_ERROR_NULL;
+ char *result = NULL;
+ const char *reply;
+
+ /* makes the call */
+ if (mkerrno(sd_bus_call_method(jbus->sdbus, jbus->name, jbus->path, jbus->name, method, &error, &smsg, "s", query)) < 0)
+ goto error;
+
+ /* check if error */
+ if (sd_bus_message_is_method_error(smsg, NULL))
+ goto error;
+
+ /* check the returned type */
+ if (!sd_bus_message_has_signature(smsg, "s")
+ || sd_bus_message_read_basic(smsg, 's', &reply) < 0)
+ goto error;
+
+ /* get the result */
+ result = strdup(reply);
+
+error:
+ sd_bus_message_unref(smsg);
+ sd_bus_error_free(&error);
+ return result;
}
/*
#if defined(SERVER)||defined(CLIENT)
#include <stdio.h>
#include <unistd.h>
-#include "utils-upoll.h"
-static int mwait(int timeout, void *closure)
+static struct sd_bus *msbus()
{
- upoll_wait(-1);
- return 0;
+ static struct sd_bus *r = NULL;
+ if (r == NULL) {
+ static sd_event *e;
+ sd_event_default(&e);
+ sd_bus_open_user(&r);
+ sd_bus_attach_event(r, e, 0);
+ }
+ return r;
}
-static const struct sbus_itf uitf = {
- .wait = (void*)mwait,
- .open = (void*)upoll_open,
- .on_readable = (void*)upoll_on_readable,
- .on_writable = (void*)upoll_on_writable,
- .on_hangup = (void*)upoll_on_hangup,
- .close = (void*)upoll_close
-};
-
-static struct sbus *sbus;
-static struct jbus *jbus;
+static sd_event *events()
+{
+ static sd_event *ev = NULL;
+ if (ev == NULL)
+ ev = sd_bus_get_event(msbus());
+ return ev;
+}
-static struct sbus *msbus()
+static int mwait(int timeout, void *closure)
{
- return sbus ? : (sbus = sbus_session(&uitf, NULL));
+ sd_event_run(events(), -1);
+ return 0;
}
+static struct jbus *jbus;
+
#ifdef SERVER
-void ping(struct sbusmsg *smsg, struct json_object *request, void *unused)
+void ping(struct sd_bus_message *smsg, struct json_object *request, void *unused)
{
printf("ping(%s) -> %s\n", json_object_to_json_string(request),
json_object_to_json_string(request));
json_object_put(request);
}
-void incr(struct sbusmsg *smsg, struct json_object *request, void *unused)
+void incr(struct sd_bus_message *smsg, struct json_object *request, void *unused)
{
static int counter = 0;
struct json_object *res = json_object_new_int(++counter);
int main()
{
- int i = 10;
+ int i = 1;
jbus = create_jbus(msbus(), "/bzh/iot/jdbus");
jbus_on_signal_s(jbus, "incremented", signaled, "closure-signal");
while (i--) {
Code Review / src / app-framework-binder.git / blobdiff