* limitations under the License.
*/
+#if defined(WITH_DBUS_TRANSPARENCY)
+
#define _GNU_SOURCE
-#define NO_PLUGIN_VERBOSE_MACRO
#include <stdlib.h>
#include <stdio.h>
#include <systemd/sd-bus.h>
#include <json-c/json.h>
+#if !defined(JSON_C_TO_STRING_NOSLASHESCAPE)
+#define JSON_C_TO_STRING_NOSLASHESCAPE 0
+#endif
-#include <afb/afb-event.h>
+#include <afb/afb-event-x2.h>
#include "afb-systemd.h"
#include "afb-xreq.h"
#include "verbose.h"
+
static const char DEFAULT_PATH_PREFIX[] = "/org/agl/afb/api/";
struct dbus_memo;
};
};
-#define RETOK 1
-#define RETERR 2
-
/******************* common part **********************************/
/*
goto error2;
}
api->api++;
- if (!afb_api_is_valid_name(api->api, 1)) {
+ if (!afb_api_is_valid_name(api->api)) {
errno = EINVAL;
goto error2;
}
struct dbus_event
{
struct dbus_event *next;
- struct afb_eventid *eventid;
+ struct afb_event_x2 *event;
int id;
int refcount;
};
{
int rc;
struct dbus_memo *memo;
- const char *first, *second;
- uint8_t type;
- uint32_t flags;
+ const char *json, *error, *info;
+ struct json_object *object;
+ enum json_tokener_error jerr;
/* retrieve the recorded data */
memo = userdata;
/* get the answer */
- rc = sd_bus_message_read(message, "yssu", &type, &first, &second, &flags);
+ rc = sd_bus_message_read(message, "sss", &json, &error, &info);
if (rc < 0) {
/* failing to have the answer */
- afb_xreq_fail(memo->xreq, "error", "dbus error");
+ afb_xreq_reply(memo->xreq, NULL, "error", "dbus error");
} else {
/* report the answer */
- memo->xreq->context.flags = (unsigned)flags;
- switch(type) {
- case RETOK:
- afb_xreq_success(memo->xreq, json_tokener_parse(first), *second ? second : NULL);
- break;
- case RETERR:
- afb_xreq_fail(memo->xreq, first, *second ? second : NULL);
- break;
- default:
- afb_xreq_fail(memo->xreq, "error", "dbus link broken");
- break;
+ if (!*json)
+ object = NULL;
+ else {
+ object = json_tokener_parse_verbose(json, &jerr);
+ if (jerr != json_tokener_success)
+ object = json_object_new_string(json);
}
+ afb_xreq_reply(memo->xreq, object, *error ? error : NULL, *info ? info : NULL);
}
api_dbus_client_memo_destroy(memo);
return 1;
int rc;
struct dbus_memo *memo;
struct sd_bus_message *msg;
+ const char *creds;
/* create the recording data */
memo = api_dbus_client_memo_make(api, xreq);
if (memo == NULL) {
- afb_xreq_fail(xreq, "error", "out of memory");
+ afb_xreq_reply(memo->xreq, NULL, "error", "out of memory");
return;
}
/* creates the message */
msg = NULL;
- rc = sd_bus_message_new_method_call(api->sdbus, &msg, api->name, api->path, api->name, xreq->request.verb);
+ rc = sd_bus_message_new_method_call(api->sdbus, &msg, api->name, api->path, api->name, xreq->request.called_verb);
if (rc < 0)
goto error;
- rc = sd_bus_message_append(msg, "ssu",
+ creds = xreq_on_behalf_cred_export(xreq);
+ rc = sd_bus_message_append(msg, "ssus",
afb_xreq_raw(xreq, &size),
afb_session_uuid(xreq->context.session),
- (uint32_t)xreq->context.flags);
+ (uint32_t)xreq->context.flags,
+ creds ?: "");
if (rc < 0)
goto error;
error:
/* if there was an error report it directly */
errno = -rc;
- afb_xreq_fail(xreq, "error", "dbus error");
+ afb_xreq_reply(memo->xreq, NULL, "error", "dbus error");
api_dbus_client_memo_destroy(memo);
end:
sd_bus_message_unref(msg);
{
struct json_object *object;
const char *event, *data;
+ enum json_tokener_error jerr;
int rc = sd_bus_message_read(m, "ss", &event, &data);
if (rc < 0)
ERROR("unreadable broadcasted event");
else {
- object = json_tokener_parse(data);
+ object = json_tokener_parse_verbose(data, &jerr);
+ if (jerr != json_tokener_success)
+ object = json_object_new_string(data);
afb_evt_broadcast(event, object);
}
return 1;
struct dbus_event *ev;
ev = api->client.events;
- while (ev != NULL && (ev->id != id || 0 != strcmp(afb_evt_eventid_fullname(ev->eventid), name)))
+ while (ev != NULL && (ev->id != id || 0 != strcmp(afb_evt_event_x2_fullname(ev->event), name)))
ev = ev->next;
return ev;
/* no conflict, try to add it */
ev = malloc(sizeof *ev);
if (ev != NULL) {
- ev->eventid = afb_evt_eventid_create(name);
- if (ev->eventid == NULL)
+ ev->event = afb_evt_event_x2_create(name);
+ if (ev->event == NULL)
free(ev);
else {
ev->refcount = 1;
*prv = ev->next;
/* destroys the event */
- afb_evt_eventid_unref(ev->eventid);
+ afb_evt_event_x2_unref(ev->event);
free(ev);
}
{
struct json_object *object;
struct dbus_event *ev;
+ enum json_tokener_error jerr;
/* retrieves the event */
ev = api_dbus_client_event_search(api, id, name);
}
/* destroys the event */
- object = json_tokener_parse(data);
- afb_evt_eventid_push(ev->eventid, object);
+ object = json_tokener_parse_verbose(data, &jerr);
+ if (jerr != json_tokener_success)
+ object = json_object_new_string(data);
+ afb_evt_event_x2_push(ev->event, object);
}
/* subscribes an event */
}
/* subscribe the request to the event */
- rc = afb_xreq_subscribe(memo->xreq, ev->eventid);
+ rc = afb_xreq_subscribe(memo->xreq, ev->event);
if (rc < 0)
ERROR("can't subscribe: %m");
}
}
/* unsubscribe the request from the event */
- rc = afb_xreq_unsubscribe(memo->xreq, ev->eventid);
+ rc = afb_xreq_unsubscribe(memo->xreq, ev->event);
if (rc < 0)
ERROR("can't unsubscribe: %m");
}
};
/* adds a afb-dbus-service client api */
-int afb_api_dbus_add_client(const char *path, struct afb_apiset *apiset)
+int afb_api_dbus_add_client(const char *path, struct afb_apiset *declare_set, struct afb_apiset *call_set)
{
int rc;
struct api_dbus *api;
- struct afb_api afb_api;
+ struct afb_api_item afb_api;
char *match;
/* create the dbus client api */
afb_api.closure = api;
afb_api.itf = &dbus_api_itf;
afb_api.group = NULL;
- if (afb_apiset_add(apiset, api->api, afb_api) < 0)
+ if (afb_apiset_add(declare_set, api->api, afb_api) < 0)
goto error2;
return 0;
return dreq->json;
}
-/* get the argument of the request of 'name' */
-static void dbus_req_reply(struct dbus_req *dreq, uint8_t type, const char *first, const char *second)
+void dbus_req_raw_reply(struct afb_xreq *xreq, struct json_object *obj, const char *error, const char *info)
{
+ struct dbus_req *dreq = CONTAINER_OF_XREQ(struct dbus_req, xreq);
int rc;
- rc = sd_bus_reply_method_return(dreq->message,
- "yssu", type, first ? : "", second ? : "", (uint32_t)dreq->xreq.context.flags);
+
+ rc = sd_bus_reply_method_return(dreq->message, "sss",
+ obj ? json_object_to_json_string_ext(obj, JSON_C_TO_STRING_PLAIN|JSON_C_TO_STRING_NOSLASHESCAPE) : "",
+ error ? : "",
+ info ? : "");
if (rc < 0)
ERROR("sending the reply failed");
}
-static void dbus_req_success(struct afb_xreq *xreq, struct json_object *obj, const char *info)
-{
- struct dbus_req *dreq = CONTAINER_OF_XREQ(struct dbus_req, xreq);
-
- dbus_req_reply(dreq, RETOK, json_object_to_json_string_ext(obj, JSON_C_TO_STRING_PLAIN), info);
-}
-
-static void dbus_req_fail(struct afb_xreq *xreq, const char *status, const char *info)
-{
- struct dbus_req *dreq = CONTAINER_OF_XREQ(struct dbus_req, xreq);
-
- dbus_req_reply(dreq, RETERR, status, info);
-}
-
static void afb_api_dbus_server_event_send(struct origin *origin, char order, const char *event, int eventid, const char *data, uint64_t msgid);
-static int dbus_req_subscribe(struct afb_xreq *xreq, struct afb_eventid *eventid)
+static int dbus_req_subscribe(struct afb_xreq *xreq, struct afb_event_x2 *event)
{
struct dbus_req *dreq = CONTAINER_OF_XREQ(struct dbus_req, xreq);
uint64_t msgid;
int rc;
- rc = afb_evt_eventid_add_watch(dreq->listener->listener, eventid);
+ rc = afb_evt_event_x2_add_watch(dreq->listener->listener, event);
sd_bus_message_get_cookie(dreq->message, &msgid);
- afb_api_dbus_server_event_send(dreq->listener->origin, 'S', afb_evt_eventid_fullname(eventid), afb_evt_eventid_id(eventid), "", msgid);
+ afb_api_dbus_server_event_send(dreq->listener->origin, 'S', afb_evt_event_x2_fullname(event), afb_evt_event_x2_id(event), "", msgid);
return rc;
}
-static int dbus_req_unsubscribe(struct afb_xreq *xreq, struct afb_eventid *eventid)
+static int dbus_req_unsubscribe(struct afb_xreq *xreq, struct afb_event_x2 *event)
{
struct dbus_req *dreq = CONTAINER_OF_XREQ(struct dbus_req, xreq);
uint64_t msgid;
int rc;
sd_bus_message_get_cookie(dreq->message, &msgid);
- afb_api_dbus_server_event_send(dreq->listener->origin, 'U', afb_evt_eventid_fullname(eventid), afb_evt_eventid_id(eventid), "", msgid);
- rc = afb_evt_eventid_remove_watch(dreq->listener->listener, eventid);
+ afb_api_dbus_server_event_send(dreq->listener->origin, 'U', afb_evt_event_x2_fullname(event), afb_evt_event_x2_id(event), "", msgid);
+ rc = afb_evt_event_x2_remove_watch(dreq->listener->listener, event);
return rc;
}
-static void dbus_req_subcall(
- struct afb_xreq *xreq,
- const char *api,
- const char *verb,
- struct json_object *args,
- void (*callback)(void*, int, struct json_object*),
- void *cb_closure)
-{
- ERROR("DBUS API doesn't support subcalls, info: %s/%s(%s)", api, verb, json_object_to_json_string(args));
- callback(cb_closure, 1, afb_msg_json_reply_error("error", "subcall isn't supported", NULL, NULL));
- json_object_put(args);
-}
-
const struct afb_xreq_query_itf afb_api_dbus_xreq_itf = {
.json = dbus_req_json,
- .success = dbus_req_success,
- .fail = dbus_req_fail,
+ .reply = dbus_req_raw_reply,
.unref = dbus_req_destroy,
.subscribe = dbus_req_subscribe,
.unsubscribe = dbus_req_unsubscribe,
- .subcall = dbus_req_subcall
};
/******************* server part **********************************/
static void afb_api_dbus_server_event_push(void *closure, const char *event, int eventid, struct json_object *object)
{
- const char *data = json_object_to_json_string_ext(object, JSON_C_TO_STRING_PLAIN);
+ const char *data = json_object_to_json_string_ext(object, JSON_C_TO_STRING_PLAIN|JSON_C_TO_STRING_NOSLASHESCAPE);
afb_api_dbus_server_event_send(closure, '!', event, eventid, data, 0);
json_object_put(object);
}
api = closure;
rc = sd_bus_emit_signal(api->sdbus, api->path, api->name, "broadcast",
- "ss", event, json_object_to_json_string_ext(object, JSON_C_TO_STRING_PLAIN));
+ "ss", event, json_object_to_json_string_ext(object, JSON_C_TO_STRING_PLAIN|JSON_C_TO_STRING_NOSLASHESCAPE));
if (rc < 0)
ERROR("error while broadcasting event %s", event);
json_object_put(object);
int rc;
const char *method;
const char *uuid;
+ const char *creds;
struct dbus_req *dreq;
struct api_dbus *api = userdata;
uint32_t flags;
struct afb_session *session;
struct listener *listener;
+ enum json_tokener_error jerr;
/* check the interface */
if (strcmp(sd_bus_message_get_interface(message), api->name) != 0)
goto out_of_memory;
/* get the data */
- rc = sd_bus_message_read(message, "ssu", &dreq->request, &uuid, &flags);
+ rc = sd_bus_message_read(message, "ssus", &dreq->request, &uuid, &flags, &creds);
if (rc < 0) {
sd_bus_reply_method_errorf(message, SD_BUS_ERROR_INVALID_SIGNATURE, "invalid signature");
goto error;
/* fulfill the request and emit it */
dreq->xreq.context.flags = flags;
+ dreq->xreq.cred = afb_cred_mixed_on_behalf_import(listener->origin->cred, uuid, creds && creds[0] ? creds : NULL);
dreq->message = sd_bus_message_ref(message);
- dreq->json = json_tokener_parse(dreq->request);
- if (dreq->json == NULL && strcmp(dreq->request, "null")) {
+ dreq->json = json_tokener_parse_verbose(dreq->request, &jerr);
+ if (jerr != json_tokener_success) {
/* lazy error detection of json request. Is it to improve? */
dreq->json = json_object_new_string(dreq->request);
}
dreq->listener = listener;
- dreq->xreq.request.api = api->api;
- dreq->xreq.request.verb = method;
+ dreq->xreq.request.called_api = api->api;
+ dreq->xreq.request.called_verb = method;
afb_xreq_process(&dreq->xreq, api->server.apiset);
return 1;
}
/* create the service */
-int afb_api_dbus_add_server(const char *path, struct afb_apiset *apiset)
+int afb_api_dbus_add_server(const char *path, struct afb_apiset *declare_set, struct afb_apiset *call_set)
{
int rc;
struct api_dbus *api;
INFO("afb service over dbus installed, name %s, path %s", api->name, api->path);
api->server.listener = afb_evt_listener_create(&evt_broadcast_itf, api);
- api->server.apiset = afb_apiset_addref(apiset);
+ api->server.apiset = afb_apiset_addref(call_set);
return 0;
error3:
sd_bus_release_name(api->sdbus, api->name);
return -1;
}
+#endif