2 * Copyright (C) 2015-2019 "IoT.bzh"
3 * Author José Bollo <jose.bollo@iot.bzh>
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
9 * http://www.apache.org/licenses/LICENSE-2.0
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
18 #if WITH_DBUS_TRANSPARENCY
28 #include <systemd/sd-bus.h>
29 #include <json-c/json.h>
30 #if !defined(JSON_C_TO_STRING_NOSLASHESCAPE)
31 #define JSON_C_TO_STRING_NOSLASHESCAPE 0
34 #include <afb/afb-event-x2.h>
36 #include "afb-session.h"
37 #include "afb-msg-json.h"
39 #include "afb-apiset.h"
40 #include "afb-api-dbus.h"
41 #include "afb-context.h"
50 static const char DEFAULT_PATH_PREFIX[] = "/org/agl/afb/api/";
57 * The path given are of the form
58 * system:/org/agl/afb/api/...
60 * user:/org/agl/afb/api/...
64 struct sd_bus *sdbus; /* the bus */
65 char *path; /* path of the object for the API */
66 char *name; /* name/interface of the object */
67 char *api; /* api name of the interface */
70 struct sd_bus_slot *slot_broadcast;
71 struct sd_bus_slot *slot_event;
72 struct dbus_event *events;
73 struct dbus_memo *memos;
76 struct sd_bus_slot *slot_call;
77 struct afb_evt_listener *listener; /* listener for broadcasted events */
78 struct origin *origins;
79 struct afb_apiset *apiset;
84 /******************* common part **********************************/
87 * create a structure api_dbus connected on either the system
88 * bus if 'system' is not null or on the user bus. The connection
89 * is established for either emiting/receiving on 'path' being of length
92 static struct api_dbus *make_api_dbus_3(int system, const char *path, size_t pathlen)
98 /* allocates the structure */
99 api = calloc(1, sizeof *api + 1 + pathlen + pathlen);
105 /* init the structure's strings */
107 /* path is copied after the struct */
108 api->path = (void*)(api+1);
109 strcpy(api->path, path);
111 /* api name is at the end of the path */
112 api->api = strrchr(api->path, '/');
113 if (api->api == NULL) {
118 if (!afb_api_is_valid_name(api->api)) {
123 /* the name/interface is copied after the path */
124 api->name = &api->path[pathlen + 1];
125 strcpy(api->name, &path[1]);
126 ptr = strchr(api->name, '/');
129 ptr = strchr(ptr, '/');
133 jobs_acquire_event_manager();
134 sdbus = (system ? systemd_get_system_bus : systemd_get_user_bus)();
148 * create a structure api_dbus connected on either the system
149 * bus if 'system' is not null or on the user bus. The connection
150 * is established for either emiting/receiving on 'path'.
151 * If 'path' is not absolute, it is prefixed with DEFAULT_PATH_PREFIX.
153 static struct api_dbus *make_api_dbus_2(int system, const char *path)
158 /* check the length of the path */
165 /* if the path is absolute, creation now */
167 return make_api_dbus_3(system, path, len);
169 /* compute the path prefixed with DEFAULT_PATH_PREFIX */
170 assert(strlen(DEFAULT_PATH_PREFIX) > 0);
171 assert(DEFAULT_PATH_PREFIX[strlen(DEFAULT_PATH_PREFIX) - 1] == '/');
172 len += strlen(DEFAULT_PATH_PREFIX);
173 ptr = alloca(len + 1);
174 strcpy(stpcpy(ptr, DEFAULT_PATH_PREFIX), path);
176 /* creation for prefixed path */
177 return make_api_dbus_3(system, ptr, len);
181 * create a structure api_dbus connected either emiting/receiving
183 * The path can be prefixed with "system:" or "user:" to select
184 * either the user or the system D-Bus. If none is set then user's
186 * If remaining 'path' is not absolute, it is prefixed with
187 * DEFAULT_PATH_PREFIX.
189 static struct api_dbus *make_api_dbus(const char *path)
194 /* retrieves the prefix "scheme-like" part */
195 ptr = strchr(path, ':');
197 return make_api_dbus_2(0, path);
199 /* check the prefix part */
200 preflen = (size_t)(ptr - path);
201 if (strncmp(path, "system", preflen) == 0)
202 return make_api_dbus_2(1, ptr + 1);
204 if (strncmp(path, "user", preflen) == 0)
205 return make_api_dbus_2(0, ptr + 1);
207 /* TODO: connect to a foreign D-Bus? */
212 static void destroy_api_dbus(struct api_dbus *api)
217 /******************* client part **********************************/
220 * structure for recording query data
223 struct dbus_memo *next; /* the next memo */
224 struct api_dbus *api; /* the dbus api */
225 struct afb_xreq *xreq; /* the request */
226 uint64_t msgid; /* the message identifier */
231 struct dbus_event *next;
232 struct afb_event_x2 *event;
237 /* allocates and init the memorizing data */
238 static struct dbus_memo *api_dbus_client_memo_make(struct api_dbus *api, struct afb_xreq *xreq)
240 struct dbus_memo *memo;
242 memo = malloc(sizeof *memo);
244 afb_xreq_unhooked_addref(xreq);
248 memo->next = api->client.memos;
249 api->client.memos = memo;
254 /* free and release the memorizing data */
255 static void api_dbus_client_memo_destroy(struct dbus_memo *memo)
257 struct dbus_memo **prv;
259 prv = &memo->api->client.memos;
260 while (*prv != NULL) {
268 afb_xreq_unhooked_unref(memo->xreq);
272 /* search a memorized request */
273 static struct dbus_memo *api_dbus_client_memo_search(struct api_dbus *api, uint64_t msgid)
275 struct dbus_memo *memo;
277 memo = api->client.memos;
278 while (memo != NULL && memo->msgid != msgid)
284 /* callback when received answer */
285 static int api_dbus_client_on_reply(sd_bus_message *message, void *userdata, sd_bus_error *ret_error)
288 struct dbus_memo *memo;
289 const char *json, *error, *info;
290 struct json_object *object;
291 enum json_tokener_error jerr;
293 /* retrieve the recorded data */
297 rc = sd_bus_message_read(message, "sss", &json, &error, &info);
299 /* failing to have the answer */
300 afb_xreq_reply(memo->xreq, NULL, "error", "dbus error");
302 /* report the answer */
306 object = json_tokener_parse_verbose(json, &jerr);
307 if (jerr != json_tokener_success)
308 object = json_object_new_string(json);
310 afb_xreq_reply(memo->xreq, object, *error ? error : NULL, *info ? info : NULL);
312 api_dbus_client_memo_destroy(memo);
316 /* on call, propagate it to the dbus service */
317 static void api_dbus_client_call(void *closure, struct afb_xreq *xreq)
319 struct api_dbus *api = closure;
322 struct dbus_memo *memo;
323 struct sd_bus_message *msg;
326 /* create the recording data */
327 memo = api_dbus_client_memo_make(api, xreq);
329 afb_xreq_reply(memo->xreq, NULL, "error", "out of memory");
333 /* creates the message */
335 rc = sd_bus_message_new_method_call(api->sdbus, &msg, api->name, api->path, api->name, xreq->request.called_verb);
339 creds = xreq_on_behalf_cred_export(xreq);
340 rc = sd_bus_message_append(msg, "ssus",
341 afb_xreq_raw(xreq, &size),
342 afb_session_uuid(xreq->context.session),
343 (uint32_t)xreq->context.flags,
349 rc = sd_bus_call_async(api->sdbus, NULL, msg, api_dbus_client_on_reply, memo, (uint64_t)-1);
353 rc = sd_bus_message_get_cookie(msg, &memo->msgid);
358 /* if there was an error report it directly */
360 afb_xreq_reply(memo->xreq, NULL, "error", "dbus error");
361 api_dbus_client_memo_destroy(memo);
363 sd_bus_message_unref(msg);
366 /* receives broadcasted events */
367 static int api_dbus_client_on_broadcast_event(sd_bus_message *m, void *userdata, sd_bus_error *ret_error)
369 struct json_object *object;
370 const char *event, *data;
371 const unsigned char *uuid;
374 enum json_tokener_error jerr;
376 int rc = sd_bus_message_read(m, "ssayy", &event, &data, &uuid, &szuuid, &hop);
378 ERROR("unreadable broadcasted event");
380 object = json_tokener_parse_verbose(data, &jerr);
381 if (jerr != json_tokener_success)
382 object = json_object_new_string(data);
383 afb_evt_rebroadcast(event, object, uuid, hop);
388 /* search the eventid */
389 static struct dbus_event *api_dbus_client_event_search(struct api_dbus *api, int id, const char *name)
391 struct dbus_event *ev;
393 ev = api->client.events;
394 while (ev != NULL && (ev->id != id || 0 != strcmp(afb_evt_event_x2_fullname(ev->event), name)))
400 /* adds an eventid */
401 static void api_dbus_client_event_create(struct api_dbus *api, int id, const char *name)
403 struct dbus_event *ev;
405 /* check conflicts */
406 ev = api_dbus_client_event_search(api, id, name);
412 /* no conflict, try to add it */
413 ev = malloc(sizeof *ev);
415 ev->event = afb_evt_event_x2_create(name);
416 if (ev->event == NULL)
421 ev->next = api->client.events;
422 api->client.events = ev;
426 ERROR("can't create event %s, out of memory", name);
429 /* removes an eventid */
430 static void api_dbus_client_event_drop(struct api_dbus *api, int id, const char *name)
432 struct dbus_event *ev, **prv;
434 /* retrieves the event */
435 ev = api_dbus_client_event_search(api, id, name);
437 ERROR("event %s not found", name);
441 /* decrease the reference count */
445 /* unlinks the event */
446 prv = &api->client.events;
451 /* destroys the event */
452 afb_evt_event_x2_unref(ev->event);
457 static void api_dbus_client_event_push(struct api_dbus *api, int id, const char *name, const char *data)
459 struct json_object *object;
460 struct dbus_event *ev;
461 enum json_tokener_error jerr;
463 /* retrieves the event */
464 ev = api_dbus_client_event_search(api, id, name);
466 ERROR("event %s not found", name);
470 /* destroys the event */
471 object = json_tokener_parse_verbose(data, &jerr);
472 if (jerr != json_tokener_success)
473 object = json_object_new_string(data);
474 afb_evt_event_x2_push(ev->event, object);
477 /* subscribes an event */
478 static void api_dbus_client_event_subscribe(struct api_dbus *api, int id, const char *name, uint64_t msgid)
481 struct dbus_event *ev;
482 struct dbus_memo *memo;
484 /* retrieves the event */
485 ev = api_dbus_client_event_search(api, id, name);
487 ERROR("event %s not found", name);
491 /* retrieves the memo */
492 memo = api_dbus_client_memo_search(api, msgid);
494 ERROR("message not found");
498 /* subscribe the request to the event */
499 rc = afb_xreq_subscribe(memo->xreq, ev->event);
501 ERROR("can't subscribe: %m");
504 /* unsubscribes an event */
505 static void api_dbus_client_event_unsubscribe(struct api_dbus *api, int id, const char *name, uint64_t msgid)
508 struct dbus_event *ev;
509 struct dbus_memo *memo;
511 /* retrieves the event */
512 ev = api_dbus_client_event_search(api, id, name);
514 ERROR("event %s not found", name);
518 /* retrieves the memo */
519 memo = api_dbus_client_memo_search(api, msgid);
521 ERROR("message not found");
525 /* unsubscribe the request from the event */
526 rc = afb_xreq_unsubscribe(memo->xreq, ev->event);
528 ERROR("can't unsubscribe: %m");
531 /* receives calls for event */
532 static int api_dbus_client_on_manage_event(sd_bus_message *m, void *userdata, sd_bus_error *ret_error)
534 const char *eventname, *data;
538 struct api_dbus *api;
541 /* check if expected message */
543 if (0 != strcmp(api->name, sd_bus_message_get_interface(m)))
544 return 0; /* not the expected interface */
545 if (0 != strcmp("event", sd_bus_message_get_member(m)))
546 return 0; /* not the expected member */
547 if (sd_bus_message_get_expect_reply(m))
548 return 0; /* not the expected type of message */
550 /* reads the message */
551 rc = sd_bus_message_read(m, "yisst", &order, &eventid, &eventname, &data, &msgid);
553 ERROR("unreadable event");
557 /* what is the order ? */
558 switch ((char)order) {
559 case '+': /* creates the event */
560 api_dbus_client_event_create(api, eventid, eventname);
562 case '-': /* drops the event */
563 api_dbus_client_event_drop(api, eventid, eventname);
565 case '!': /* pushs the event */
566 api_dbus_client_event_push(api, eventid, eventname, data);
568 case 'S': /* subscribe event for a request */
569 api_dbus_client_event_subscribe(api, eventid, eventname, msgid);
571 case 'U': /* unsubscribe event for a request */
572 api_dbus_client_event_unsubscribe(api, eventid, eventname, msgid);
575 /* unexpected order */
576 ERROR("unexpected order '%c' received", (char)order);
582 static struct afb_api_itf dbus_api_itf = {
583 .call = api_dbus_client_call
586 /* adds a afb-dbus-service client api */
587 int afb_api_dbus_add_client(const char *path, struct afb_apiset *declare_set, struct afb_apiset *call_set)
590 struct api_dbus *api;
591 struct afb_api_item afb_api;
594 /* create the dbus client api */
595 api = make_api_dbus(path);
599 /* connect to broadcasted events */
600 rc = asprintf(&match, "type='signal',path='%s',interface='%s',member='broadcast'", api->path, api->name);
603 ERROR("out of memory");
606 rc = sd_bus_add_match(api->sdbus, &api->client.slot_broadcast, match, api_dbus_client_on_broadcast_event, api);
610 ERROR("can't add dbus match %s for %s", api->path, api->name);
614 /* connect to event management */
615 rc = sd_bus_add_object(api->sdbus, &api->client.slot_event, api->path, api_dbus_client_on_manage_event, api);
618 ERROR("can't add dbus object %s for %s", api->path, api->name);
622 /* record it as an API */
623 afb_api.closure = api;
624 afb_api.itf = &dbus_api_itf;
625 afb_api.group = NULL;
626 if (afb_apiset_add(declare_set, api->api, afb_api) < 0)
632 destroy_api_dbus(api);
637 /******************* event structures for server part **********************************/
639 static void afb_api_dbus_server_event_add(void *closure, const char *event, uint16_t eventid);
640 static void afb_api_dbus_server_event_remove(void *closure, const char *event, uint16_t eventid);
641 static void afb_api_dbus_server_event_push(void *closure, const char *event, uint16_t eventid, struct json_object *object);
642 static void afb_api_dbus_server_event_broadcast(void *closure, const char *event, struct json_object *object, const uuid_binary_t uuid, uint8_t hop);
644 /* the interface for events broadcasting */
645 static const struct afb_evt_itf evt_broadcast_itf = {
646 .broadcast = afb_api_dbus_server_event_broadcast,
649 /* the interface for events pushing */
650 static const struct afb_evt_itf evt_push_itf = {
651 .push = afb_api_dbus_server_event_push,
652 .add = afb_api_dbus_server_event_add,
653 .remove = afb_api_dbus_server_event_remove
656 /******************* origin description part for server *****************************/
660 /* link to next different origin */
663 /* the server dbus-api */
664 struct api_dbus *api;
666 /* count of references */
669 /* credentials of the origin */
670 struct afb_cred *cred;
676 /* get the credentials for the message */
677 static void init_origin_creds(struct origin *origin)
685 struct afb_cred *ocred;
687 rc = sd_bus_get_name_creds(origin->api->sdbus, origin->name,
688 SD_BUS_CREDS_PID|SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_SELINUX_CONTEXT,
693 sd_bus_creds_get_uid(c, &uid);
694 sd_bus_creds_get_gid(c, &gid);
695 sd_bus_creds_get_pid(c, &pid);
696 sd_bus_creds_get_selinux_context(c, &context);
697 ocred = origin->cred;
698 origin->cred = afb_cred_create(uid, gid, pid, context);
699 sd_bus_creds_unref(c);
700 afb_cred_unref(ocred);
704 static struct origin *afb_api_dbus_server_origin_get(struct api_dbus *api, const char *sender)
706 struct origin *origin;
708 /* searchs for an existing origin */
709 origin = api->server.origins;
710 while (origin != NULL) {
711 if (0 == strcmp(origin->name, sender)) {
715 origin = origin->next;
718 /* not found, create it */
719 origin = malloc(strlen(sender) + 1 + sizeof *origin);
724 origin->refcount = 1;
725 strcpy(origin->name, sender);
726 init_origin_creds(origin);
727 origin->next = api->server.origins;
728 api->server.origins = origin;
733 static void afb_api_dbus_server_origin_unref(struct origin *origin)
735 if (!--origin->refcount) {
738 prv = &origin->api->server.origins;
739 while(*prv != origin)
742 afb_cred_unref(origin->cred);
749 /* link to next different origin */
750 struct origin *origin;
752 /* the listener of events */
753 struct afb_evt_listener *listener;
756 static void afb_api_dbus_server_listener_free(struct listener *listener)
758 afb_evt_listener_unref(listener->listener);
759 afb_api_dbus_server_origin_unref(listener->origin);
763 static struct listener *afb_api_dbus_server_listener_get(struct api_dbus *api, const char *sender, struct afb_session *session)
766 struct listener *listener;
767 struct origin *origin;
770 origin = afb_api_dbus_server_origin_get(api, sender);
774 /* retrieves the stored listener */
775 listener = afb_session_get_cookie(session, origin);
776 if (listener != NULL) {
778 afb_api_dbus_server_origin_unref(origin);
782 /* creates the listener */
783 listener = malloc(sizeof *listener);
784 if (listener == NULL)
787 listener->origin = origin;
788 listener->listener = afb_evt_listener_create(&evt_push_itf, origin);
789 if (listener->listener != NULL) {
790 rc = afb_session_set_cookie(session, origin, listener, (void*)afb_api_dbus_server_listener_free);
793 afb_evt_listener_unref(listener->listener);
797 afb_api_dbus_server_origin_unref(origin);
801 /******************* dbus request part for server *****************/
804 * Structure for a dbus request
807 struct afb_xreq xreq; /**< the xreq of the request */
808 sd_bus_message *message; /**< the incoming request message */
809 const char *request; /**< the readen request as string */
810 struct json_object *json; /**< the readen request as object */
811 struct listener *listener; /**< the listener for events */
814 /* decrement the reference count of the request and free/release it on falling to null */
815 static void dbus_req_destroy(struct afb_xreq *xreq)
817 struct dbus_req *dreq = CONTAINER_OF_XREQ(struct dbus_req, xreq);
819 afb_context_disconnect(&dreq->xreq.context);
820 json_object_put(dreq->json);
821 sd_bus_message_unref(dreq->message);
825 /* get the object of the request */
826 static struct json_object *dbus_req_json(struct afb_xreq *xreq)
828 struct dbus_req *dreq = CONTAINER_OF_XREQ(struct dbus_req, xreq);
833 void dbus_req_raw_reply(struct afb_xreq *xreq, struct json_object *obj, const char *error, const char *info)
835 struct dbus_req *dreq = CONTAINER_OF_XREQ(struct dbus_req, xreq);
838 rc = sd_bus_reply_method_return(dreq->message, "sss",
839 obj ? json_object_to_json_string_ext(obj, JSON_C_TO_STRING_PLAIN|JSON_C_TO_STRING_NOSLASHESCAPE) : "",
843 ERROR("sending the reply failed");
846 static void afb_api_dbus_server_event_send(struct origin *origin, char order, const char *event, int eventid, const char *data, uint64_t msgid);
848 static int dbus_req_subscribe(struct afb_xreq *xreq, struct afb_event_x2 *event)
850 struct dbus_req *dreq = CONTAINER_OF_XREQ(struct dbus_req, xreq);
854 rc = afb_evt_event_x2_add_watch(dreq->listener->listener, event);
855 sd_bus_message_get_cookie(dreq->message, &msgid);
856 afb_api_dbus_server_event_send(dreq->listener->origin, 'S', afb_evt_event_x2_fullname(event), afb_evt_event_x2_id(event), "", msgid);
860 static int dbus_req_unsubscribe(struct afb_xreq *xreq, struct afb_event_x2 *event)
862 struct dbus_req *dreq = CONTAINER_OF_XREQ(struct dbus_req, xreq);
866 sd_bus_message_get_cookie(dreq->message, &msgid);
867 afb_api_dbus_server_event_send(dreq->listener->origin, 'U', afb_evt_event_x2_fullname(event), afb_evt_event_x2_id(event), "", msgid);
868 rc = afb_evt_event_x2_remove_watch(dreq->listener->listener, event);
872 const struct afb_xreq_query_itf afb_api_dbus_xreq_itf = {
873 .json = dbus_req_json,
874 .reply = dbus_req_raw_reply,
875 .unref = dbus_req_destroy,
876 .subscribe = dbus_req_subscribe,
877 .unsubscribe = dbus_req_unsubscribe,
880 /******************* server part **********************************/
882 static void afb_api_dbus_server_event_send(struct origin *origin, char order, const char *event, int eventid, const char *data, uint64_t msgid)
885 struct api_dbus *api;
886 struct sd_bus_message *msg;
891 rc = sd_bus_message_new_method_call(api->sdbus, &msg, origin->name, api->path, api->name, "event");
895 rc = sd_bus_message_append(msg, "yisst", (uint8_t)order, (int32_t)eventid, event, data, msgid);
899 rc = sd_bus_send(api->sdbus, msg, NULL); /* NULL for cookie implies no expected reply */
904 ERROR("error while send event %c%s(%d) to %s", order, event, eventid, origin->name);
906 sd_bus_message_unref(msg);
909 static void afb_api_dbus_server_event_add(void *closure, const char *event, uint16_t eventid)
911 afb_api_dbus_server_event_send(closure, '+', event, eventid, "", 0);
914 static void afb_api_dbus_server_event_remove(void *closure, const char *event, uint16_t eventid)
916 afb_api_dbus_server_event_send(closure, '-', event, eventid, "", 0);
919 static void afb_api_dbus_server_event_push(void *closure, const char *event, uint16_t eventid, struct json_object *object)
921 const char *data = json_object_to_json_string_ext(object, JSON_C_TO_STRING_PLAIN|JSON_C_TO_STRING_NOSLASHESCAPE);
922 afb_api_dbus_server_event_send(closure, '!', event, eventid, data, 0);
923 json_object_put(object);
926 static void afb_api_dbus_server_event_broadcast(void *closure, const char *event, struct json_object *object, const uuid_binary_t uuid, uint8_t hop)
929 struct api_dbus *api;
932 rc = sd_bus_emit_signal(api->sdbus, api->path, api->name, "broadcast",
933 "ssayy", event, json_object_to_json_string_ext(object, JSON_C_TO_STRING_PLAIN|JSON_C_TO_STRING_NOSLASHESCAPE),
934 uuid, UUID_BINARY_LENGTH, hop);
936 ERROR("error while broadcasting event %s", event);
937 json_object_put(object);
940 /* called when the object for the service is called */
941 static int api_dbus_server_on_object_called(sd_bus_message *message, void *userdata, sd_bus_error *ret_error)
947 struct dbus_req *dreq;
948 struct api_dbus *api = userdata;
950 struct afb_session *session;
951 struct listener *listener;
952 enum json_tokener_error jerr;
954 /* check the interface */
955 if (strcmp(sd_bus_message_get_interface(message), api->name) != 0)
959 method = sd_bus_message_get_member(message);
961 /* create the request */
962 dreq = calloc(1 , sizeof *dreq);
967 rc = sd_bus_message_read(message, "ssus", &dreq->request, &uuid, &flags, &creds);
969 sd_bus_reply_method_errorf(message, SD_BUS_ERROR_INVALID_SIGNATURE, "invalid signature");
973 /* connect to the context */
974 afb_xreq_init(&dreq->xreq, &afb_api_dbus_xreq_itf);
975 if (afb_context_connect(&dreq->xreq.context, uuid, NULL, NULL) < 0)
977 session = dreq->xreq.context.session;
979 /* get the listener */
980 listener = afb_api_dbus_server_listener_get(api, sd_bus_message_get_sender(message), session);
981 if (listener == NULL)
984 /* fulfill the request and emit it */
985 afb_context_change_cred(&dreq->xreq.context, listener->origin->cred);
986 afb_context_on_behalf_import(&dreq->xreq.context, creds);
987 dreq->message = sd_bus_message_ref(message);
988 dreq->json = json_tokener_parse_verbose(dreq->request, &jerr);
989 if (jerr != json_tokener_success) {
990 /* lazy error detection of json request. Is it to improve? */
991 dreq->json = json_object_new_string(dreq->request);
993 dreq->listener = listener;
994 dreq->xreq.request.called_api = api->api;
995 dreq->xreq.request.called_verb = method;
996 afb_xreq_process(&dreq->xreq, api->server.apiset);
1000 sd_bus_reply_method_errorf(message, SD_BUS_ERROR_NO_MEMORY, "out of memory");
1006 /* create the service */
1007 int afb_api_dbus_add_server(const char *path, struct afb_apiset *declare_set, struct afb_apiset *call_set)
1010 struct api_dbus *api;
1012 /* get the dbus api object connected */
1013 api = make_api_dbus(path);
1017 /* request the service object name */
1018 rc = sd_bus_request_name(api->sdbus, api->name, 0);
1021 ERROR("can't register name %s", api->name);
1025 /* connect the service to the dbus object */
1026 rc = sd_bus_add_object(api->sdbus, &api->server.slot_call, api->path, api_dbus_server_on_object_called, api);
1029 ERROR("can't add dbus object %s for %s", api->path, api->name);
1032 INFO("afb service over dbus installed, name %s, path %s", api->name, api->path);
1034 api->server.listener = afb_evt_listener_create(&evt_broadcast_itf, api);
1035 api->server.apiset = afb_apiset_addref(call_set);
1038 sd_bus_release_name(api->sdbus, api->name);
1040 destroy_api_dbus(api);