/*
- Copyright 2015 IoT.bzh
+ Copyright 2015, 2016, 2017 IoT.bzh
author: José Bollo <jose.bollo@iot.bzh>
#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"
" -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";
{ "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' },
/*
* retrieves the 'runid' in 'obj' parameters received with the
- * request 'jreq' for the 'method'.
+ * 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 'jreq' and 0 is returned.
+ * the bad request is replied for 'smsg' and 0 is returned.
*/
-static int onrunid(struct jreq *jreq, struct json_object *obj,
+static int onrunid(struct sd_bus_message *smsg, struct json_object *obj,
const char *method, int *runid)
{
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(jreq, error_bad_request);
+ jbus_reply_error_s(smsg, error_bad_request);
return 0;
}
}
/*
- * Sends the reply 'resp' to the request 'jreq' if 'resp' is not NULL.
+ * 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 jreq *jreq, struct json_object *resp,
+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);
}
/*
- * Sends the reply "true" to the request 'jreq' if 'status' is zero.
+ * 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 jreq *jreq, int status, const char *errstr)
+static void reply_status(struct sd_bus_message *smsg, int status, const char *errstr)
{
if (status)
- jbus_reply_error_s(jreq, errstr);
+ jbus_reply_error_s(smsg, errstr);
else
- jbus_reply_s(jreq, "true");
+ jbus_reply_s(smsg, "true");
}
/*
- * On query "runnables" from 'jreq' with parameters of 'obj'.
+ * On query "runnables" from 'smsg' with parameters of 'obj'.
*
* Nothing is expected in 'obj' that can be anything.
*/
-static void on_runnables(struct jreq *jreq, struct json_object *obj, void *unused)
+static void on_runnables(struct sd_bus_message *smsg, struct json_object *obj, void *unused)
{
struct json_object *resp;
INFO("method runnables called");
resp = afm_db_application_list(afdb);
- jbus_reply_j(jreq, resp);
+ jbus_reply_j(smsg, resp);
json_object_put(resp);
}
/*
- * On query "detail" from 'jreq' with parameters of 'obj'.
+ * On query "detail" from 'smsg' with parameters of 'obj'.
*/
-static void on_detail(struct jreq *jreq, struct json_object *obj, void *unused)
+static void on_detail(struct sd_bus_message *smsg, struct json_object *obj, void *unused)
{
const char *appid;
struct json_object *resp;
; /* appid as obj.id string */
else {
INFO("method detail called but bad request!");
- jbus_reply_error_s(jreq, error_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(jreq, resp, error_not_found);
+ reply(smsg, resp, error_not_found);
json_object_put(resp);
}
-
/*
- * On query "start" from 'jreq' with parameters of 'obj'.
+ * On query "start" from 'smsg' with parameters of 'obj'.
*/
-static void on_start(struct jreq *jreq, struct json_object *obj, void *unused)
+static void on_start(struct sd_bus_message *smsg, struct json_object *obj, void *unused)
{
const char *appid, *modestr;
char *uri;
}
}
if (!is_valid_launch_mode(mode)) {
- jbus_reply_error_s(jreq, error_bad_request);
+ jbus_reply_error_s(smsg, error_bad_request);
return;
}
name_of_launch_mode(mode));
appli = afm_db_get_application(afdb, appid);
if (appli == NULL) {
- jbus_reply_error_s(jreq, error_not_found);
+ jbus_reply_error_s(smsg, error_not_found);
return;
}
uri = NULL;
runid = afm_run_start(appli, mode, &uri);
if (runid <= 0) {
- jbus_reply_error_s(jreq, error_cant_start);
+ jbus_reply_error_s(smsg, error_cant_start);
free(uri);
return;
}
/* returns only the runid */
snprintf(runidstr, sizeof runidstr, "%d", runid);
runidstr[sizeof runidstr - 1] = 0;
- jbus_reply_s(jreq, runidstr);
+ jbus_reply_s(smsg, runidstr);
return;
}
resp = json_object_new_object();
if (resp != NULL && j_add_integer(resp, "runid", runid)
&& j_add_string(resp, "uri", uri))
- jbus_reply_j(jreq, resp);
+ jbus_reply_j(smsg, resp);
else {
- afm_run_stop(runid);
- jbus_reply_error_s(jreq, error_system);
+ afm_run_terminate(runid);
+ jbus_reply_error_s(smsg, error_system);
}
json_object_put(resp);
free(uri);
}
/*
- * On query "stop" from 'jreq' with parameters of 'obj'.
+ * 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_stop(struct jreq *jreq, struct json_object *obj, void *unused)
+static void on_pause(struct sd_bus_message *smsg, struct json_object *obj, void *unused)
{
int runid, status;
- if (onrunid(jreq, obj, "stop", &runid)) {
- status = afm_run_stop(runid);
- reply_status(jreq, status, error_not_found);
+ if (onrunid(smsg, obj, "pause", &runid)) {
+ status = afm_run_pause(runid);
+ reply_status(smsg, status, error_not_found);
}
}
/*
- * On query "continue" from 'jreq' with parameters of 'obj'.
+ * On query "resume" from 'smsg' with parameters of 'obj'.
*/
-static void on_continue(struct jreq *jreq, struct json_object *obj, void *unused)
+static void on_resume(struct sd_bus_message *smsg, struct json_object *obj, void *unused)
{
int runid, status;
- if (onrunid(jreq, obj, "continue", &runid)) {
- status = afm_run_continue(runid);
- reply_status(jreq, status, error_not_found);
+ if (onrunid(smsg, obj, "resume", &runid)) {
+ status = afm_run_resume(runid);
+ reply_status(smsg, status, error_not_found);
}
}
/*
- * On query "terminate" from 'jreq' with parameters of '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)
+{
+ NOTICE("call to obsolete 'stop'");
+ on_pause(smsg, obj, unused);
+}
+
+/*
+ * On query "continue" from 'smsg' with parameters of 'obj'.
+ */
+static void on_continue(struct sd_bus_message *smsg, struct json_object *obj, void *unused)
+{
+ NOTICE("call to obsolete 'continue'");
+ on_resume(smsg, obj, unused);
+}
+
+/*
+ * On query "terminate" from 'smsg' with parameters of 'obj'.
*/
-static void on_terminate(struct jreq *jreq, struct json_object *obj, void *unused)
+static void on_terminate(struct sd_bus_message *smsg, struct json_object *obj, void *unused)
{
int runid, status;
- if (onrunid(jreq, obj, "terminate", &runid)) {
+ if (onrunid(smsg, obj, "terminate", &runid)) {
status = afm_run_terminate(runid);
- reply_status(jreq, status, error_not_found);
+ reply_status(smsg, status, error_not_found);
}
}
/*
- * On query "runners" from 'jreq' with parameters of 'obj'.
+ * On query "runners" from 'smsg' with parameters of 'obj'.
*/
-static void on_runners(struct jreq *jreq, struct json_object *obj, void *unused)
+static void on_runners(struct sd_bus_message *smsg, struct json_object *obj, void *unused)
{
struct json_object *resp;
INFO("method runners called");
resp = afm_run_list();
- jbus_reply_j(jreq, resp);
+ jbus_reply_j(smsg, resp);
json_object_put(resp);
}
/*
- * On query "state" from 'jreq' with parameters of 'obj'.
+ * On query "state" from 'smsg' with parameters of 'obj'.
*/
-static void on_state(struct jreq *jreq, struct json_object *obj, void *unused)
+static void on_state(struct sd_bus_message *smsg, struct json_object *obj, void *unused)
{
int runid;
struct json_object *resp;
- if (onrunid(jreq, obj, "state", &runid)) {
+ if (onrunid(smsg, obj, "state", &runid)) {
resp = afm_run_state(runid);
- reply(jreq, resp, error_not_found);
+ reply(smsg, resp, error_not_found);
json_object_put(resp);
}
}
/*
* Calls the system daemon to achieve application management of
- * the 'method' gotten from 'jreq' with the parameter's string 'msg'.
+ * 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, jreq)
+ * jbus_call_ss(system_bus, method, msg, callback, smsg)
*/
-static void propagate(struct jreq *jreq, const char *msg, const char *method)
+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(jreq, reply);
+ jbus_reply_s(smsg, reply);
free(reply);
}
else
- jbus_reply_error_s(jreq, error_system);
+ jbus_reply_error_s(smsg, error_system);
}
#if defined(EXPLICIT_CALL)
/*
- * On query "install" from 'jreq' with parameters of 'msg'.
+ * On query "install" from 'smsg' with parameters of 'msg'.
*/
-static void on_install(struct jreq *jreq, const char *msg, void *unused)
+static void on_install(struct sd_bus_message *smsg, const char *msg, void *unused)
{
- return propagate(jreq, msg, "install");
+ return propagate(smsg, msg, "install");
}
/*
- * On query "uninstall" from 'jreq' with parameters of 'msg'.
+ * On query "uninstall" from 'smsg' with parameters of 'msg'.
*/
-static void on_uninstall(struct jreq *jreq, const char *msg, void *unused)
+static void on_uninstall(struct sd_bus_message *smsg, const char *msg, void *unused)
{
- return propagate(jreq, msg, "uninstall");
+ return propagate(smsg, msg, "uninstall");
}
#endif
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 */
+ sys_bus_addr = NULL;
+ usr_bus_addr = NULL;
while ((i = getopt_long(ac, av, options_s, options_l, NULL)) >= 0) {
switch (i) {
case 'h':
}
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;
return 1;
}
+ /* 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_system(AFM_SYSTEM_DBUS_PATH);
+ system_bus = create_jbus(sysbus, AFM_SYSTEM_DBUS_PATH);
if (!system_bus) {
ERROR("create_jbus failed for system");
return 1;
}
/* connect to the session bus */
- user_bus = create_jbus_session(AFM_USER_DBUS_PATH);
+ user_bus = create_jbus(usrbus, AFM_USER_DBUS_PATH);
if (!user_bus) {
ERROR("create_jbus failed");
return 1;
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)) {
+ || jbus_add_service_s(user_bus, "uninstall", on_uninstall, NULL)
#else
- || jbus_add_service_s(user_bus, "install", (void (*)(struct jreq *, const char *, void *))propagate, "install")
- || jbus_add_service_s(user_bus, "uninstall", (void (*)(struct jreq *, const char *, void *))propagate, "uninstall")) {
+ || 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 servicing */
- if (jbus_start_serving(user_bus)) {
+ if (jbus_start_serving(user_bus) < 0) {
ERROR("can't start server");
return 1;
}
/* run until error */
- while (jbus_read_write_dispatch_multiple(jbuses, 2, -1, 20) >= 0);
+ for(;;)
+ sd_event_run(evloop, (uint64_t)-1);
return 0;
}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Code Review / src / app-framework-main.git / blobdiff