X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=src%2Fafm-user-daemon.c;h=f9d74e9f65931f6c3675493894e5aa29312a16f5;hb=3a6e947bef1b2942e24d2fdee1a76dbf3305b508;hp=87d7e7124905297aa2933bfe6df4be96a1d2c4f1;hpb=189415eece11c543e1ccb95dff32695ddc383565;p=src%2Fapp-framework-main.git

diff --git a/src/afm-user-daemon.c b/src/afm-user-daemon.c
index 87d7e71..f9d74e9 100644
--- a/src/afm-user-daemon.c
+++ b/src/afm-user-daemon.c
@@ -1,5 +1,5 @@
 /*
- Copyright 2015 IoT.bzh
+ Copyright 2015, 2016, 2017 IoT.bzh
 
  author: José Bollo <jose.bollo@iot.bzh>
 
@@ -20,35 +20,51 @@
 #include <stdio.h>
 #include <time.h>
 #include <getopt.h>
+#include <string.h>
 
-#include <json.h>
+#include <systemd/sd-bus.h>
+#include <systemd/sd-event.h>
+#include <json-c/json.h>
 
 #include "verbose.h"
 #include "utils-jbus.h"
+#include "utils-json.h"
 #include "afm.h"
 #include "afm-db.h"
+#include "afm-launch-mode.h"
 #include "afm-run.h"
 
+/*
+ * name of the application
+ */
 static const char appname[] = "afm-user-daemon";
 
-static void usage()
-{
-	printf(
-		"usage: %s [-q] [-v] [-r rootdir]... [-a appdir]...\n"
-		"\n"
-		"   -a appdir    adds an application directory\n"
-		"   -r rootdir   adds a root directory of applications\n"
-		"   -d           run as a daemon\n"
-		"   -q           quiet\n"
-		"   -v           verbose\n"
-		"\n",
-		appname
-	);
-}
+/*
+ * string for printing usage
+ */
+static const char usagestr[] =
+	"usage: %s [-q] [-v] [-m mode] [-r rootdir]... [-a appdir]...\n"
+	"\n"
+	"   -a appdir    adds an application directory\n"
+	"   -r rootdir   adds a root directory of applications\n"
+	"   -m mode      set default launch mode (local or remote)\n"
+	"   -d           run as a daemon\n"
+	"   -u addr      address of user D-Bus to use\n"
+	"   -s addr      address of system D-Bus to use\n"
+	"   -q           quiet\n"
+	"   -v           verbose\n"
+	"\n";
 
-static struct option options[] = {
+/*
+ * Option definition for getopt_long
+ */
+static const char options_s[] = "hdqvr:a:m:";
+static struct option options_l[] = {
 	{ "root",        required_argument, NULL, 'r' },
 	{ "application", required_argument, NULL, 'a' },
+	{ "mode",        required_argument, NULL, 'm' },
+	{ "user-dbus",   required_argument, NULL, 'u' },
+	{ "system-dbus", required_argument, NULL, 's' },
 	{ "daemon",      no_argument,       NULL, 'd' },
 	{ "quiet",       no_argument,       NULL, 'q' },
 	{ "verbose",     no_argument,       NULL, 'v' },
@@ -56,127 +72,360 @@ static struct option options[] = {
 	{ NULL, 0, NULL, 0 }
 };
 
-static struct jbus *jbus;
-static struct jbus *jbusys;
+/*
+ * Connections to D-Bus
+ * This is an array for using the function
+ *    jbus_read_write_dispatch_multiple
+ * directly without transformations.
+ */
+static struct jbus *jbuses[2];
+#define system_bus  jbuses[0]
+#define user_bus    jbuses[1]
+
+/*
+ * Handle to the database of applications
+ */
 static struct afm_db *afdb;
 
+/*
+ * Returned error strings
+ */
 const char error_nothing[] = "[]";
 const char error_bad_request[] = "\"bad request\"";
 const char error_not_found[] = "\"not found\"";
 const char error_cant_start[] = "\"can't start\"";
+const char error_system[] = "\"system error\"";
 
-static const char *getappid(struct json_object *obj)
-{
-	return json_type_string == json_object_get_type(obj) ? json_object_get_string(obj) : NULL;
-}
 
-static int getrunid(struct json_object *obj)
+/*
+ * retrieves the 'runid' in 'obj' parameters received with the
+ * request 'smsg' for the 'method'.
+ *
+ * Returns 1 in case of success.
+ * Otherwise, if the 'runid' can't be retrived, an error stating
+ * the bad request is replied for 'smsg' and 0 is returned.
+ */
+static int onrunid(struct sd_bus_message *smsg, struct json_object *obj,
+						const char *method, int *runid)
 {
-	return json_type_int == json_object_get_type(obj) ? json_object_get_int(obj) : 0;
+	if (!j_read_integer(obj, runid)
+				&& !j_read_integer_at(obj, "runid", runid)) {
+		INFO("bad request method %s: %s", method,
+					json_object_to_json_string(obj));
+		jbus_reply_error_s(smsg, error_bad_request);
+		return 0;
+	}
+
+	INFO("method %s called for %d", method, *runid);
+	return 1;
 }
 
-static void reply(struct jreq *jreq, struct json_object *resp, const char *errstr)
+/*
+ * Sends the reply 'resp' to the request 'smsg' if 'resp' is not NULL.
+ * Otherwise, when 'resp' is NULL replies the error string 'errstr'.
+ */
+static void reply(struct sd_bus_message *smsg, struct json_object *resp,
+						const char *errstr)
 {
 	if (resp)
-		jbus_reply_j(jreq, resp);
+		jbus_reply_j(smsg, resp);
 	else
-		jbus_reply_error_s(jreq, errstr);
+		jbus_reply_error_s(smsg, errstr);
 }
 
-static void reply_status(struct jreq *jreq, int status)
+/*
+ * Sends the reply "true" to the request 'smsg' if 'status' is zero.
+ * Otherwise, when 'status' is not zero replies the error string 'errstr'.
+ */
+static void reply_status(struct sd_bus_message *smsg, int status, const char *errstr)
 {
 	if (status)
-		jbus_reply_error_s(jreq, error_not_found);
+		jbus_reply_error_s(smsg, errstr);
 	else
-		jbus_reply_s(jreq, "true");
+		jbus_reply_s(smsg, "true");
 }
 
-static void on_runnables(struct jreq *jreq, struct json_object *obj)
+/*
+ * On query "runnables" from 'smsg' with parameters of 'obj'.
+ *
+ * Nothing is expected in 'obj' that can be anything.
+ */
+static void on_runnables(struct sd_bus_message *smsg, struct json_object *obj, void *unused)
 {
-	struct json_object *resp = afm_db_application_list(afdb);
-	jbus_reply_j(jreq, resp);
+	struct json_object *resp;
+	INFO("method runnables called");
+	resp = afm_db_application_list(afdb);
+	jbus_reply_j(smsg, resp);
 	json_object_put(resp);
 }
 
-static void on_detail(struct jreq *jreq, struct json_object *obj)
+/*
+ * On query "detail" from 'smsg' with parameters of 'obj'.
+ */
+static void on_detail(struct sd_bus_message *smsg, struct json_object *obj, void *unused)
 {
-	const char *appid = getappid(obj);
-	struct json_object *resp = afm_db_get_application_public(afdb, appid);
-	reply(jreq, resp, error_not_found);
+	const char *appid;
+	struct json_object *resp;
+
+	/* get the parameters */
+	if (j_read_string(obj, &appid))
+		; /* appid as a string */
+	else if (j_read_string_at(obj, "id", &appid))
+		; /* appid as obj.id string */
+	else {
+		INFO("method detail called but bad request!");
+		jbus_reply_error_s(smsg, error_bad_request);
+		return;
+	}
+
+	/* wants details for appid */
+	INFO("method detail called for %s", appid);
+	resp = afm_db_get_application_public(afdb, appid);
+	reply(smsg, resp, error_not_found);
 	json_object_put(resp);
 }
 
-static void on_start(struct jreq *jreq, struct json_object *obj)
+/*
+ * On query "start" from 'smsg' with parameters of 'obj'.
+ */
+static void on_start(struct sd_bus_message *smsg, struct json_object *obj, void *unused)
 {
-	const char *appid;
-	struct json_object *appli;
+	const char *appid, *modestr;
+	char *uri;
+	struct json_object *appli, *resp;
 	int runid;
 	char runidstr[20];
+	enum afm_launch_mode mode;
+
+	/* get the parameters */
+	mode = invalid_launch_mode;
+	if (j_read_string(obj, &appid)) {
+		mode = get_default_launch_mode();
+	} else if (j_read_string_at(obj, "id", &appid)) {
+		if (j_read_string_at(obj, "mode", &modestr)) {
+			mode = launch_mode_of_name(modestr);
+		} else {
+			mode = get_default_launch_mode();
+		}
+	}
+	if (!is_valid_launch_mode(mode)) {
+		jbus_reply_error_s(smsg, error_bad_request);
+		return;
+	}
+
+	/* get the application */
+	INFO("method start called for %s mode=%s", appid,
+						name_of_launch_mode(mode));
+	appli = afm_db_get_application(afdb, appid);
+	if (appli == NULL) {
+		jbus_reply_error_s(smsg, error_not_found);
+		return;
+	}
+
+	/* launch the application */
+	uri = NULL;
+	runid = afm_run_start(appli, mode, &uri);
+	if (runid <= 0) {
+		jbus_reply_error_s(smsg, error_cant_start);
+		free(uri);
+		return;
+	}
+
+	if (uri == NULL) {
+		/* returns only the runid */
+		snprintf(runidstr, sizeof runidstr, "%d", runid);
+		runidstr[sizeof runidstr - 1] = 0;
+		jbus_reply_s(smsg, runidstr);
+		return;
+	}
 
-	appid = getappid(obj);
-	if (appid == NULL)
-		jbus_reply_error_s(jreq, error_bad_request);
+	/* returns the runid and its uri */
+	resp = json_object_new_object();
+	if (resp != NULL && j_add_integer(resp, "runid", runid)
+					&& j_add_string(resp, "uri", uri))
+		jbus_reply_j(smsg, resp);
 	else {
-		appli = afm_db_get_application(afdb, appid);
-		if (appli == NULL)
-			jbus_reply_error_s(jreq, error_not_found);
-		else {
-			runid = afm_run_start(appli);
-			if (runid <= 0)
-				jbus_reply_error_s(jreq, error_cant_start);
-			else {
-				snprintf(runidstr, sizeof runidstr, "%d", runid);
-				runidstr[sizeof runidstr - 1] = 0;
-				jbus_reply_s(jreq, runidstr);
-			}
-		}
+		afm_run_terminate(runid);
+		jbus_reply_error_s(smsg, error_system);
+	}
+	json_object_put(resp);
+	free(uri);
+}
+
+/*
+ * On query "once" from 'smsg' with parameters of 'obj'.
+ */
+static void on_once(struct sd_bus_message *smsg, struct json_object *obj, void *unused)
+{
+	const char *appid;
+	struct json_object *appli, *resp;
+	int runid;
+
+	/* get the parameters */
+	if (!j_read_string(obj, &appid) && !j_read_string_at(obj, "id", &appid)) {
+		jbus_reply_error_s(smsg, error_bad_request);
+		return;
+	}
+
+	/* get the application */
+	INFO("method once called for %s", appid);
+	appli = afm_db_get_application(afdb, appid);
+	if (appli == NULL) {
+		jbus_reply_error_s(smsg, error_not_found);
+		return;
+	}
+
+	/* launch the application */
+	runid = afm_run_once(appli);
+	if (runid <= 0) {
+		jbus_reply_error_s(smsg, error_cant_start);
+		return;
+	}
+
+	/* returns the state */
+	resp = afm_run_state(runid);
+	reply(smsg, resp, error_not_found);
+	json_object_put(resp);
+}
+
+/*
+ * On query "pause" from 'smsg' with parameters of 'obj'.
+ */
+static void on_pause(struct sd_bus_message *smsg, struct json_object *obj, void *unused)
+{
+	int runid, status;
+	if (onrunid(smsg, obj, "pause", &runid)) {
+		status = afm_run_pause(runid);
+		reply_status(smsg, status, error_not_found);
 	}
 }
 
-static void on_stop(struct jreq *jreq, struct json_object *obj)
+/*
+ * On query "resume" from 'smsg' with parameters of 'obj'.
+ */
+static void on_resume(struct sd_bus_message *smsg, struct json_object *obj, void *unused)
 {
-	int runid = getrunid(obj);
-	int status = afm_run_stop(runid);
-	reply_status(jreq, status);
+	int runid, status;
+	if (onrunid(smsg, obj, "resume", &runid)) {
+		status = afm_run_resume(runid);
+		reply_status(smsg, status, error_not_found);
+	}
 }
 
-static void on_continue(struct jreq *jreq, struct json_object *obj)
+/*
+ * On query "stop" from 'smsg' with parameters of 'obj'.
+ */
+static void on_stop(struct sd_bus_message *smsg, struct json_object *obj, void *unused)
 {
-	int runid = getrunid(obj);
-	int status = afm_run_continue(runid);
-	reply_status(jreq, status);
+	NOTICE("call to obsolete 'stop'");
+	on_pause(smsg, obj, unused);
 }
 
-static void on_terminate(struct jreq *jreq, struct json_object *obj)
+/*
+ * On query "continue" from 'smsg' with parameters of 'obj'.
+ */
+static void on_continue(struct sd_bus_message *smsg, struct json_object *obj, void *unused)
 {
-	int runid = getrunid(obj);
-	int status = afm_run_terminate(runid);
-	reply_status(jreq, status);
+	NOTICE("call to obsolete 'continue'");
+	on_resume(smsg, obj, unused);
 }
 
-static void on_runners(struct jreq *jreq, struct json_object *obj)
+/*
+ * On query "terminate" from 'smsg' with parameters of 'obj'.
+ */
+static void on_terminate(struct sd_bus_message *smsg, struct json_object *obj, void *unused)
 {
-	struct json_object *resp = afm_run_list();
-	jbus_reply_j(jreq, resp);
-	json_object_put(resp);
+	int runid, status;
+	if (onrunid(smsg, obj, "terminate", &runid)) {
+		status = afm_run_terminate(runid);
+		reply_status(smsg, status, error_not_found);
+	}
 }
 
-static void on_state(struct jreq *jreq, struct json_object *obj)
+/*
+ * On query "runners" from 'smsg' with parameters of 'obj'.
+ */
+static void on_runners(struct sd_bus_message *smsg, struct json_object *obj, void *unused)
 {
-	int runid = getrunid(obj);
-	struct json_object *resp = afm_run_state(runid);
-	reply(jreq, resp, error_not_found);
+	struct json_object *resp;
+	INFO("method runners called");
+	resp = afm_run_list();
+	jbus_reply_j(smsg, resp);
 	json_object_put(resp);
 }
 
-static void on_signal_changed(struct json_object *obj)
+/*
+ * On query "state" from 'smsg' with parameters of 'obj'.
+ */
+static void on_state(struct sd_bus_message *smsg, struct json_object *obj, void *unused)
+{
+	int runid;
+	struct json_object *resp;
+	if (onrunid(smsg, obj, "state", &runid)) {
+		resp = afm_run_state(runid);
+		reply(smsg, resp, error_not_found);
+		json_object_put(resp);
+	}
+}
+
+/*
+ * Calls the system daemon to achieve application management of
+ * the 'method' gotten from 'smsg' with the parameter's string 'msg'.
+ *
+ * The principle is very simple: call the corresponding system method
+ * and reply its response to the caller.
+ *
+ * The request and reply is synchronous and is blocking.
+ * It is possible to implment it in an asynchrounous way but it
+ * would brake the common behaviour. It would be a call like
+ * jbus_call_ss(system_bus, method, msg, callback, smsg)
+ */
+static void propagate(struct sd_bus_message *smsg, const char *msg, const char *method)
+{
+	char *reply;
+	INFO("method %s propagated with %s", method, msg);
+	reply = jbus_call_ss_sync(system_bus, method, msg);
+	if (reply) {
+		jbus_reply_s(smsg, reply);
+		free(reply);
+	}
+	else
+		jbus_reply_error_s(smsg, error_system);
+}
+
+#if defined(EXPLICIT_CALL)
+/*
+ * On query "install" from 'smsg' with parameters of 'msg'.
+ */
+static void on_install(struct sd_bus_message *smsg, const char *msg, void *unused)
+{
+	return propagate(smsg, msg, "install");
+}
+
+/*
+ * On query "uninstall" from 'smsg' with parameters of 'msg'.
+ */
+static void on_uninstall(struct sd_bus_message *smsg, const char *msg, void *unused)
+{
+	return propagate(smsg, msg, "uninstall");
+}
+#endif
+
+/*
+ * On system signaling that applications list changed
+ */
+static void on_signal_changed(struct json_object *obj, void *unused)
 {
 	/* update the database */
 	afm_db_update_applications(afdb);
-	/* propagate now */
-	jbus_send_signal_j(jbus, "changed", obj);
+	/* re-propagate now */
+	jbus_send_signal_j(user_bus, "changed", obj);
 }
 
+/*
+ * Tiny routine to daemonize the program
+ * Return 0 on success or -1 on failure.
+ */
 static int daemonize()
 {
 	int rc = fork();
@@ -187,17 +436,65 @@ static int daemonize()
 	return 0;
 }
 
+/*
+ * Opens a sd-bus connection and returns it in 'ret'.
+ * The sd-bus connexion is intended to be for user if 'isuser'
+ * is not null. The adress is the default address when 'address'
+ * is NULL or, otherwise, the given address.
+ * It might be necessary to pass the address as an argument because
+ * library systemd uses secure_getenv to retrieves the default
+ * addresses and secure_getenv might return NULL in some cases.
+ */
+static int open_bus(sd_bus **ret, int isuser, const char *address)
+{
+	sd_bus *b;
+	int rc;
+
+	if (address == NULL)
+		return (isuser ? sd_bus_open_user : sd_bus_open_system)(ret);
+
+	rc = sd_bus_new(&b);
+	if (rc < 0)
+		return rc;
+
+	rc = sd_bus_set_address(b, address);
+	if (rc < 0)
+		goto fail;
+
+	sd_bus_set_bus_client(b, 1);
+
+	rc = sd_bus_start(b);
+	if (rc < 0)
+		goto fail;
+
+	*ret = b;
+	return 0;
+
+fail:
+	sd_bus_unref(b);
+	return rc;
+}
+
+/*
+ * ENTRY POINT OF AFM-USER-DAEMON
+ */
 int main(int ac, char **av)
 {
-	int i, daemon = 0;
+	int i, daemon = 0, rc;
+	enum afm_launch_mode mode;
+	struct sd_event *evloop;
+	struct sd_bus *sysbus, *usrbus;
+	const char *sys_bus_addr, *usr_bus_addr;
 
 	LOGAUTH(appname);
 
 	/* first interpretation of arguments */
-	while ((i = getopt_long(ac, av, "hdqvr:a:", options, NULL)) >= 0) {
+	sys_bus_addr = NULL;
+	usr_bus_addr = NULL;
+	while ((i = getopt_long(ac, av, options_s, options_l, NULL)) >= 0) {
 		switch (i) {
 		case 'h':
-			usage();
+			printf(usagestr, appname);
 			return 0;
 		case 'q':
 			if (verbosity)
@@ -213,6 +510,20 @@ int main(int ac, char **av)
 			break;
 		case 'a':
 			break;
+		case 'm':
+			mode = launch_mode_of_name(optarg);
+			if (!is_valid_launch_mode(mode)) {
+				ERROR("invalid mode '%s'", optarg);
+				return 1;
+			}
+			set_default_launch_mode(mode);
+			break;
+		case 'u':
+			usr_bus_addr = optarg;
+			break;
+		case 's':
+			sys_bus_addr = optarg;
+			break;
 		case ':':
 			ERROR("missing argument value");
 			return 1;
@@ -244,7 +555,7 @@ int main(int ac, char **av)
 
 	/* second interpretation of arguments */
 	optind = 1;
-	while ((i = getopt_long(ac, av, "hdqvr:a:", options, NULL)) >= 0) {
+	while ((i = getopt_long(ac, av, options_s, options_l, NULL)) >= 0) {
 		switch (i) {
 		case 'r':
 			if (afm_db_add_root(afdb, optarg)) {
@@ -254,9 +565,9 @@ int main(int ac, char **av)
 			break;
 		case 'a':
 			if (afm_db_add_application(afdb, optarg)) {
-                                ERROR("can't add application %s", optarg);
-                                return 1;
-                        }
+				ERROR("can't add application %s", optarg);
+				return 1;
+			}
 			break;
 		}
 	}
@@ -267,46 +578,106 @@ int main(int ac, char **av)
 		return 1;
 	}
 
+	/* daemonize if requested */
 	if (daemon && daemonize()) {
 		ERROR("daemonization failed");
 		return 1;
 	}
 
-	/* init observers */
-	jbusys = create_jbus(0, AFM_SYSTEM_DBUS_PATH);
-	if (!jbusys) {
+	/* get systemd objects */
+	rc = sd_event_new(&evloop);
+	if (rc < 0) {
+		ERROR("can't create event loop");
+		return 1;
+	}
+	rc = open_bus(&sysbus, 0, sys_bus_addr);
+	if (rc < 0) {
+		ERROR("can't create system bus");
+		return 1;
+	}
+	rc = sd_bus_attach_event(sysbus, evloop, 0);
+	if (rc < 0) {
+		ERROR("can't attach system bus to event loop");
+		return 1;
+	}
+	rc = open_bus(&usrbus, 1, usr_bus_addr);
+	if (rc < 0) {
+		ERROR("can't create user bus");
+		return 1;
+	}
+	rc = sd_bus_attach_event(usrbus, evloop, 0);
+	if (rc < 0) {
+		ERROR("can't attach user bus to event loop");
+		return 1;
+	}
+
+	/* connects to the system bus */
+	system_bus = create_jbus(sysbus, AFM_SYSTEM_DBUS_PATH);
+	if (!system_bus) {
 		ERROR("create_jbus failed for system");
 		return 1;
 	}
-	if(jbus_on_signal_j(jbusys, "changed", on_signal_changed)) {
+
+	/* observe signals of system */
+	if(jbus_on_signal_j(system_bus, "changed", on_signal_changed, NULL)) {
 		ERROR("adding signal observer failed");
 		return 1;
 	}
 
-	/* init service	*/
-	jbus = create_jbus(1, AFM_USER_DBUS_PATH);
-	if (!jbus) {
+	/* connect to the session bus */
+	user_bus = create_jbus(usrbus, AFM_USER_DBUS_PATH);
+	if (!user_bus) {
 		ERROR("create_jbus failed");
 		return 1;
 	}
-	if(jbus_add_service_j(jbus, "runnables", on_runnables)
-	|| jbus_add_service_j(jbus, "detail", on_detail)
-	|| jbus_add_service_j(jbus, "start", on_start)
-	|| jbus_add_service_j(jbus, "terminate", on_terminate)
-	|| jbus_add_service_j(jbus, "stop", on_stop)
-	|| jbus_add_service_j(jbus, "continue", on_continue)
-	|| jbus_add_service_j(jbus, "runners", on_runners)
-	|| jbus_add_service_j(jbus, "state", on_state)) {
+
+	/* init services */
+	if (jbus_add_service_j(user_bus, "runnables", on_runnables, NULL)
+	 || jbus_add_service_j(user_bus, "detail",    on_detail, NULL)
+	 || jbus_add_service_j(user_bus, "start",     on_start, NULL)
+	 || jbus_add_service_j(user_bus, "once",      on_once, NULL)
+	 || jbus_add_service_j(user_bus, "terminate", on_terminate, NULL)
+	 || jbus_add_service_j(user_bus, "pause",     on_pause, NULL)
+	 || jbus_add_service_j(user_bus, "resume",    on_resume, NULL)
+	 || jbus_add_service_j(user_bus, "stop",      on_stop, NULL)
+	 || jbus_add_service_j(user_bus, "continue",  on_continue, NULL)
+	 || jbus_add_service_j(user_bus, "runners",   on_runners, NULL)
+	 || jbus_add_service_j(user_bus, "state",     on_state, NULL)
+#if defined(EXPLICIT_CALL)
+	 || jbus_add_service_s(user_bus, "install",   on_install, NULL)
+	 || jbus_add_service_s(user_bus, "uninstall", on_uninstall, NULL)
+#else
+	 || jbus_add_service_s(user_bus, "install",   (void (*)(struct sd_bus_message *, const char *, void *))propagate, "install")
+	 || jbus_add_service_s(user_bus, "uninstall", (void (*)(struct sd_bus_message *, const char *, void *))propagate, "uninstall")
+#endif
+	 ) {
 		ERROR("adding services failed");
 		return 1;
 	}
 
-	/* start and run */
-	if (jbus_start_serving(jbus)) {
+	/* start servicing */
+	if (jbus_start_serving(user_bus) < 0) {
 		ERROR("can't start server");
 		return 1;
 	}
-	while (!jbus_read_write_dispatch(jbus, -1));
+
+	/* run until error */
+	for(;;)
+		sd_event_run(evloop, (uint64_t)-1);
 	return 0;
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+