afm-launch.c
afm-launch-mode.c
afm-run.c
+ afm-urun.c
)
###########################################################################
--- /dev/null
+/*
+ Copyright 2015, 2016, 2017 IoT.bzh
+
+ author: José Bollo <jose.bollo@iot.bzh>
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+#define _GNU_SOURCE
+
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <errno.h>
+#include <assert.h>
+#include <stdio.h>
+#include <limits.h>
+#include <string.h>
+
+#include <json-c/json.h>
+
+#include "verbose.h"
+#include "utils-dir.h"
+#include "utils-json.h"
+#include "utils-systemd.h"
+#include "afm-udb.h"
+#include "afm-urun.h"
+
+/**************** get appli basis *********************/
+
+static int get_basis(struct json_object *appli, int *isuser, const char **dpath, int load)
+{
+ char *dp;
+ const char *uname, *uscope;
+
+ /* get the scope */
+ if (!j_read_string_at(appli, "unit-scope", &uscope)) {
+ ERROR("'unit-scope' missing in appli description %s", json_object_get_string(appli));
+ goto inval;
+ }
+ *isuser = strcmp(uscope, "system") != 0;
+
+ /* get dpath */
+ if (!j_read_string_at(appli, "-unit-dpath-", dpath)) {
+ if (!load) {
+ errno = ENOENT;
+ goto error;
+ }
+ if (!j_read_string_at(appli, "unit-name", &uname)) {
+ ERROR("'unit-name' missing in appli description %s", json_object_get_string(appli));
+ goto inval;
+ }
+ dp = systemd_unit_dpath_by_name(*isuser, uname, 1);
+ if (dp == NULL) {
+ ERROR("Can't load unit of name %s for %s: %m", uname, uscope);
+ goto error;
+ }
+ if (!j_add_string(appli, "-unit-dpath-", dp)) {
+ free(dp);
+ goto nomem;
+ }
+ free(dp);
+ j_read_string_at(appli, "-unit-dpath-", dpath);
+ }
+
+ return 0;
+
+nomem:
+ ERROR("out of memory");
+ errno = ENOMEM;
+ goto error;
+
+inval:
+ errno = EINVAL;
+error:
+ return -1;
+}
+
+static const char *wait_state_stable(int isuser, const char *dpath)
+{
+ const char *state;
+
+ for (;;) {
+ state = systemd_unit_state_of_dpath(isuser, dpath);
+ if (state == NULL || state == SysD_State_Active
+ || state == SysD_State_Failed || state == SysD_State_Inactive)
+ return state;
+ /* TODO: sleep */
+ }
+}
+
+/*
+ * Creates a json object that describes the state for:
+ * - 'id', the id of the application
+ * - 'runid', its runid
+ * - 'pid', its pid
+ * - 'state', its systemd state
+ *
+ * Returns the created object or NULL in case of error.
+ */
+static json_object *mkstate(const char *id, int runid, int pid, const char *state)
+{
+ struct json_object *result, *pids;
+
+ /* the structure */
+ result = json_object_new_object();
+ if (result == NULL)
+ goto error;
+
+ /* the runid */
+ if (!j_add_integer(result, "runid", runid))
+ goto error;
+
+ /* the pids */
+ if (pid > 0) {
+ pids = j_add_new_array(result, "pids");
+ if (!pids)
+ goto error;
+ if (!j_add_integer(pids, NULL, pid))
+ goto error;
+ }
+
+ /* the state */
+ if (!j_add_string(result, "state", state == SysD_State_Active ? "running" : "terminated"))
+ goto error;
+
+ /* the application id */
+ if (!j_add_string(result, "id", id))
+ goto error;
+
+ /* done */
+ return result;
+
+error:
+ json_object_put(result);
+ errno = ENOMEM;
+ return NULL;
+}
+
+/**************** API handling ************************/
+
+/*
+ * Starts the application described by 'appli' for the 'mode'.
+ * In case of remote start, it returns in uri the uri to
+ * connect to.
+ *
+ * A reference to 'appli' is kept during the live of the
+ * runner. This is made using json_object_get. Thus be aware
+ * that further modifications to 'appli' might create errors.
+ *
+ * Returns the runid in case of success or -1 in case of error
+ */
+int afm_urun_start(struct json_object *appli)
+{
+ return afm_urun_once(appli);
+}
+
+/*
+ * Returns the runid of a previously started application 'appli'
+ * or if none is running, starts the application described by 'appli'
+ * in local mode.
+ *
+ * A reference to 'appli' is kept during the live of the
+ * runner. This is made using json_object_get. Thus be aware
+ * that further modifications to 'appli' might create errors.
+ *
+ * Returns the runid in case of success or -1 in case of error
+ */
+int afm_urun_once(struct json_object *appli)
+{
+ const char *udpath, *state, *uscope, *uname;
+ int rc, isuser;
+
+ /* retrieve basis */
+ rc = get_basis(appli, &isuser, &udpath, 1);
+ if (rc < 0)
+ goto error;
+
+ /* start the unit */
+ rc = systemd_unit_start_dpath(isuser, udpath);
+ if (rc < 0) {
+ j_read_string_at(appli, "unit-scope", &uscope);
+ j_read_string_at(appli, "unit-name", &uname);
+ ERROR("can't start %s unit %s", uscope, uname);
+ goto error;
+ }
+
+ state = wait_state_stable(isuser, udpath);
+ if (state == NULL) {
+ j_read_string_at(appli, "unit-scope", &uscope);
+ j_read_string_at(appli, "unit-name", &uname);
+ ERROR("can't wait %s unit %s: %m", uscope, uname);
+ goto error;
+ }
+ if (state != SysD_State_Active) {
+ j_read_string_at(appli, "unit-scope", &uscope);
+ j_read_string_at(appli, "unit-name", &uname);
+ ERROR("start error %s unit %s: %s", uscope, uname, state);
+ goto error;
+ }
+
+ rc = systemd_unit_pid_of_dpath(isuser, udpath);
+ if (rc < 0) {
+ j_read_string_at(appli, "unit-scope", &uscope);
+ j_read_string_at(appli, "unit-name", &uname);
+ ERROR("can't getpid of %s unit %s: %m", uscope, uname);
+ goto error;
+ }
+
+ return rc;
+
+error:
+ return -1;
+}
+
+static int not_yet_implemented(const char *what)
+{
+ ERROR("%s isn't yet implemented", what);
+ errno = ENOTSUP;
+ return -1;
+}
+
+/*
+ * Terminates the runner of 'runid'
+ *
+ * Returns 0 in case of success or -1 in case of error
+ */
+int afm_urun_terminate(int runid)
+{
+ int rc = systemd_unit_stop_pid(1 /* TODO: isuser? */, (unsigned)runid);
+ return rc < 0 ? rc : 0;
+}
+
+/*
+ * Stops (aka pause) the runner of 'runid'
+ *
+ * Returns 0 in case of success or -1 in case of error
+ */
+int afm_urun_pause(int runid)
+{
+ return not_yet_implemented("pause");
+}
+
+/*
+ * Continue (aka resume) the runner of 'runid'
+ *
+ * Returns 0 in case of success or -1 in case of error
+ */
+int afm_urun_resume(int runid)
+{
+ return not_yet_implemented("resume");
+}
+
+/*
+ * Get the list of the runners.
+ *
+ * Returns the list or NULL in case of error.
+ */
+struct json_object *afm_urun_list(struct afm_udb *db)
+{
+ int i, n, isuser, pid;
+ const char *udpath;
+ const char *id;
+ const char *state;
+ struct json_object *desc;
+ struct json_object *appli;
+ struct json_object *apps;
+ struct json_object *result;
+
+ apps = NULL;
+ result = json_object_new_array();
+ if (result == NULL)
+ goto error;
+
+ apps = afm_udb_applications_private(db);
+ n = json_object_array_length(apps);
+ for (i = 0 ; i < n ; i++) {
+ appli = json_object_array_get_idx(apps, i);
+ if (appli && get_basis(appli, &isuser, &udpath, 0) >= 0) {
+ pid = systemd_unit_pid_of_dpath(isuser, udpath);
+ if (pid > 0 && j_read_string_at(appli, "id", &id)) {
+ state = systemd_unit_state_of_dpath(isuser, udpath);
+ desc = mkstate(id, pid, pid, state);
+ if (desc && json_object_array_add(result, desc) == -1) {
+ ERROR("can't add desc %s to result", json_object_get_string(desc));
+ json_object_put(desc);
+ }
+ }
+ }
+ }
+
+error:
+ json_object_put(apps);
+ return result;
+}
+
+/*
+ * Get the state of the runner of 'runid'.
+ *
+ * Returns the state or NULL in case of success
+ */
+struct json_object *afm_urun_state(struct afm_udb *db, int runid)
+{
+ int i, n, isuser, pid;
+ char *dpath;
+ const char *udpath;
+ const char *id;
+ const char *state;
+ struct json_object *appli;
+ struct json_object *apps;
+ struct json_object *result;
+
+ result = NULL;
+
+ /* get the dpath */
+ dpath = systemd_unit_dpath_by_pid(1 /* TODO: isuser? */, (unsigned)runid);
+ if (!dpath) {
+ result = NULL;
+ errno = EINVAL;
+ WARNING("searched runid %d not found", runid);
+ } else {
+ /* search in the base */
+ apps = afm_udb_applications_private(db);
+ n = json_object_array_length(apps);
+ for (i = 0 ; i < n ; i++) {
+ appli = json_object_array_get_idx(apps, i);
+ if (appli
+ && get_basis(appli, &isuser, &udpath, 0) >= 0
+ && !strcmp(dpath, udpath)
+ && j_read_string_at(appli, "id", &id)) {
+ pid = systemd_unit_pid_of_dpath(isuser, udpath);
+ state = systemd_unit_state_of_dpath(isuser, dpath);
+ result = mkstate(id, runid, pid, state);
+ goto end;
+ }
+ }
+ result = NULL;
+ errno = ENOENT;
+ WARNING("searched runid %d of dpath %s isn't an applications", runid, dpath);
+end:
+ json_object_put(apps);
+ free(dpath);
+ }
+
+ return result;
+}
+
--- /dev/null
+/*
+ Copyright 2015, 2016, 2017 IoT.bzh
+
+ author: José Bollo <jose.bollo@iot.bzh>
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+struct afm_udb;
+
+extern int afm_urun_start(struct json_object *appli);
+extern int afm_urun_once(struct json_object *appli);
+extern int afm_urun_terminate(int runid);
+extern int afm_urun_pause(int runid);
+extern int afm_urun_resume(int runid);
+extern struct json_object *afm_urun_list(struct afm_udb *db);
+extern struct json_object *afm_urun_state(struct afm_udb *db, int runid);
+
#include "utils-jbus.h"
#include "utils-json.h"
#include "afm.h"
+#include "afm-launch-mode.h"
#ifdef LEGACY_MODE_WITHOUT_SYSTEMD
# include "afm-db.h"
+#include "afm-run.h"
#else
# include "afm-udb.h"
+#include "afm-urun.h"
#endif
-#include "afm-launch-mode.h"
-#include "afm-run.h"
/*
* name of the application
/* launch the application */
uri = NULL;
+#ifdef LEGACY_MODE_WITHOUT_SYSTEMD
runid = afm_run_start(appli, mode, &uri);
+#else
+ runid = afm_urun_start(appli);
+#endif
if (runid <= 0) {
jbus_reply_error_s(smsg, error_cant_start);
free(uri);
&& j_add_string(resp, "uri", uri))
jbus_reply_j(smsg, resp);
else {
+#ifdef LEGACY_MODE_WITHOUT_SYSTEMD
afm_run_terminate(runid);
+#else
+ afm_urun_terminate(runid);
+#endif
jbus_reply_error_s(smsg, error_system);
}
json_object_put(resp);
}
/* launch the application */
+#ifdef LEGACY_MODE_WITHOUT_SYSTEMD
runid = afm_run_once(appli);
+#else
+ runid = afm_urun_once(appli);
+#endif
if (runid <= 0) {
jbus_reply_error_s(smsg, error_cant_start);
return;
}
/* returns the state */
+#ifdef LEGACY_MODE_WITHOUT_SYSTEMD
resp = afm_run_state(runid);
+#else
+ resp = afm_urun_state(afudb, runid);
+#endif
reply(smsg, resp, error_not_found);
json_object_put(resp);
}
{
int runid, status;
if (onrunid(smsg, obj, "pause", &runid)) {
+#ifdef LEGACY_MODE_WITHOUT_SYSTEMD
status = afm_run_pause(runid);
+#else
+ status = afm_urun_pause(runid);
+#endif
reply_status(smsg, status, error_not_found);
}
}
{
int runid, status;
if (onrunid(smsg, obj, "resume", &runid)) {
+#ifdef LEGACY_MODE_WITHOUT_SYSTEMD
status = afm_run_resume(runid);
+#else
+ status = afm_urun_resume(runid);
+#endif
reply_status(smsg, status, error_not_found);
}
}
{
int runid, status;
if (onrunid(smsg, obj, "terminate", &runid)) {
+#ifdef LEGACY_MODE_WITHOUT_SYSTEMD
status = afm_run_terminate(runid);
+#else
+ status = afm_urun_terminate(runid);
+#endif
reply_status(smsg, status, error_not_found);
}
}
{
struct json_object *resp;
INFO("method runners called");
+#ifdef LEGACY_MODE_WITHOUT_SYSTEMD
resp = afm_run_list();
+#else
+ resp = afm_urun_list(afudb);
+#endif
jbus_reply_j(smsg, resp);
json_object_put(resp);
}
int runid;
struct json_object *resp;
if (onrunid(smsg, obj, "state", &runid)) {
+#ifdef LEGACY_MODE_WITHOUT_SYSTEMD
resp = afm_run_state(runid);
+#else
+ resp = afm_urun_state(afudb, runid);
+#endif
reply(smsg, resp, error_not_found);
json_object_put(resp);
}
/* init random generator */
srandom((unsigned int)time(NULL));
+#ifdef LEGACY_MODE_WITHOUT_SYSTEMD
/* init runners */
if (afm_run_init()) {
ERROR("afm_run_init failed");
}
/* init framework */
-#ifdef LEGACY_MODE_WITHOUT_SYSTEMD
afdb = afm_db_create();
if (!afdb) {
ERROR("afm_db_create failed");
return 1;
}
#else
+ /* init database */
afudb = afm_udb_create(0, 1, "afm-appli-");
if (!afudb) {
ERROR("afm_udb_create failed");
return 0;
}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
# include <systemd/sd-bus-protocol.h>
#else
struct sd_bus;
-# define sd_bus_default_user(p) ((*(p)=NULL),(-ENOTSUP))
-# define sd_bus_default_system(p) ((*(p)=NULL),(-ENOTSUP))
-# define sd_bus_call_method(...) (-ENOTSUP)
+ struct sd_bus_message;
+ typedef struct { const char *name; const char *message; } sd_bus_error;
+# define sd_bus_default_user(p) ((*(p)=NULL),(-ENOTSUP))
+# define sd_bus_default_system(p) ((*(p)=NULL),(-ENOTSUP))
+# define sd_bus_call_method(...) (-ENOTSUP)
+# define SD_BUS_ERROR_NULL {NULL,NULL}
+# define sd_bus_message_read_basic(...) (-ENOTSUP)
+# define sd_bus_message_unref(...) (NULL)
+# define sd_bus_get_property_string(...) (-ENOTSUP)
+# define sd_bus_get_property_trivial(...) (-ENOTSUP)
#endif
#include "utils-systemd.h"
static const char sdb_path[] = "/org/freedesktop/systemd1";
static const char sdb_destination[] = "org.freedesktop.systemd1";
static const char sdbi_manager[] = "org.freedesktop.systemd1.Manager";
+static const char sdbi_unit[] = "org.freedesktop.systemd1.Unit";
+static const char sdbi_service[] = "org.freedesktop.systemd1.Service";
static const char sdbm_reload[] = "Reload";
+static const char sdbm_start_unit[] = "StartUnit";
+static const char sdbm_stop_unit[] = "StopUnit";
+static const char sdbm_start[] = "Start";
+static const char sdbm_stop[] = "Stop";
+static const char sdbm_get_unit[] = "GetUnit";
+static const char sdbm_get_unit_by_pid[] = "GetUnitByPID";
+static const char sdbm_load_unit[] = "LoadUnit";
+static const char sdbp_active_state[] = "ActiveState";
+static const char sdbp_exec_main_pid[] = "ExecMainPID";
+
+const char SysD_State_Inactive[] = "inactive";
+const char SysD_State_Activating[] = "activating";
+const char SysD_State_Active[] = "active";
+const char SysD_State_Deactivating[] = "deactivating";
+const char SysD_State_Reloading[] = "reloading";
+const char SysD_State_Failed[] = "failed";
static struct sd_bus *sysbus;
static struct sd_bus *usrbus;
struct sd_bus *bus;
bus = isuser ? usrbus : sysbus;
- if (bus) {
+ if (bus)
*ret = bus;
- rc = 0;
- } else if (isuser) {
+ else if (isuser) {
rc = sd_bus_default_user(ret);
- if (!rc)
- usrbus = *ret;
+ if (rc < 0)
+ goto error;
+ usrbus = *ret;
} else {
rc = sd_bus_default_system(ret);
- if (!rc)
- sysbus = *ret;
+ if (rc < 0)
+ goto error;
+ sysbus = *ret;
}
+ return 0;
+error:
return sderr2errno(rc);
}
+
+#if 0
+/********************************************************************
+ * routines for escaping unit names to compute dbus path of units
+ *******************************************************************/
+/*
+ * Should the char 'c' be escaped?
+ */
+static inline int should_escape_for_path(char c)
+{
+ if (c >= 'A') {
+ return c <= (c >= 'a' ? 'z' : 'Z');
+ } else {
+ return c >= '0' && c <= '9';
+ }
+}
+
+/*
+ * ascii char for the hexadecimal digit 'x'
+ */
+static inline char d2h(int x)
+{
+ return (char)(x + (x > 9 ? ('a' - 10) : '0'));
+}
+
+/*
+ * escapes in 'path' of 'pathlen' the 'unit'
+ * returns 0 in case of success or -1 in case of error
+ */
+static int unit_escape_for_path(char *path, size_t pathlen, const char *unit)
+{
+ size_t r, w;
+ char c;
+
+ c = unit[r = w = 0];
+ while (c) {
+ if (should_escape_for_path(c)) {
+ if (w + 2 >= pathlen)
+ goto toolong;
+ path[w++] = '_';
+ path[w++] = d2h((c >> 4) & 15);;
+ path[w++] = d2h(c & 15);
+ } else {
+ if (w >= pathlen)
+ goto toolong;
+ path[w++] = c;
+ }
+ c = unit[++r];
+ }
+ if (w >= pathlen)
+ goto toolong;
+ path[w] = 0;
+ return 0;
+toolong:
+ return seterrno(ENAMETOOLONG);
+}
+#endif
+
+/********************************************************************
+ * Routines for getting paths
+ *******************************************************************/
+
+static char *get_dpath(struct sd_bus_message *msg)
+{
+ int rc;
+ const char *reply;
+ char *result;
+
+ rc = sd_bus_message_read_basic(msg, 'o', &reply);
+ rc = sderr2errno(rc);
+ if (rc < 0)
+ result = NULL;
+ else {
+ result = strdup(reply);
+ if (!result)
+ errno = ENOMEM;
+ }
+ sd_bus_message_unref(msg);
+ return result;
+}
+
+static char *get_unit_dpath(struct sd_bus *bus, const char *unit, int load)
+{
+ int rc;
+ struct sd_bus_message *ret = NULL;
+ sd_bus_error err = SD_BUS_ERROR_NULL;
+
+ rc = sd_bus_call_method(bus, sdb_destination, sdb_path, sdbi_manager, load ? sdbm_load_unit : sdbm_get_unit, &err, &ret, "s", unit);
+ if (rc < 0)
+ goto error;
+
+ return get_dpath(ret);
+error:
+ sd_bus_message_unref(ret);
+ return NULL;
+}
+
+static char *get_unit_dpath_by_pid(struct sd_bus *bus, unsigned pid)
+{
+ int rc;
+ struct sd_bus_message *ret = NULL;
+ sd_bus_error err = SD_BUS_ERROR_NULL;
+
+ rc = sd_bus_call_method(bus, sdb_destination, sdb_path, sdbi_manager, sdbm_get_unit_by_pid, &err, &ret, "u", pid);
+ if (rc < 0)
+ goto error;
+
+ return get_dpath(ret);
+error:
+ sd_bus_message_unref(ret);
+ return NULL;
+}
+
+static int unit_pid(struct sd_bus *bus, const char *dpath)
+{
+ int rc;
+ unsigned u = 0;
+ sd_bus_error err = SD_BUS_ERROR_NULL;
+
+ rc = sd_bus_get_property_trivial(bus, sdb_destination, dpath, sdbi_service, sdbp_exec_main_pid, &err, 'u', &u);
+ return rc < 0 ? rc : (int)u;
+}
+
+static const char *unit_state(struct sd_bus *bus, const char *dpath)
+{
+ int rc;
+ char *st;
+ const char *resu;
+ sd_bus_error err = SD_BUS_ERROR_NULL;
+
+ rc = sd_bus_get_property_string(bus, sdb_destination, dpath, sdbi_unit, sdbp_active_state, &err, &st);
+ if (rc < 0) {
+ errno = -rc;
+ resu = NULL;
+ } else {
+ if (!strcmp(st, SysD_State_Active))
+ resu = SysD_State_Active;
+ else if (!strcmp(st, SysD_State_Reloading))
+ resu = SysD_State_Reloading;
+ else if (!strcmp(st, SysD_State_Inactive))
+ resu = SysD_State_Inactive;
+ else if (!strcmp(st, SysD_State_Failed))
+ resu = SysD_State_Failed;
+ else if (!strcmp(st, SysD_State_Activating))
+ resu = SysD_State_Activating;
+ else if (!strcmp(st, SysD_State_Deactivating))
+ resu = SysD_State_Deactivating;
+ else {
+ errno = EBADMSG;
+ resu = NULL;
+ }
+ free(st);
+ }
+ return resu;
+}
+
+static int unit_start(struct sd_bus *bus, const char *dpath)
+{
+ int rc;
+ struct sd_bus_message *ret = NULL;
+ sd_bus_error err = SD_BUS_ERROR_NULL;
+
+ rc = sd_bus_call_method(bus, sdb_destination, dpath, sdbi_unit, sdbm_start, &err, &ret, "s", "replace");
+ sd_bus_message_unref(ret);
+ return rc;
+}
+
+static int unit_stop(struct sd_bus *bus, const char *dpath)
+{
+ int rc;
+ struct sd_bus_message *ret = NULL;
+ sd_bus_error err = SD_BUS_ERROR_NULL;
+
+ rc = sd_bus_call_method(bus, sdb_destination, dpath, sdbi_unit, sdbm_stop, &err, &ret, "s", "replace");
+ sd_bus_message_unref(ret);
+ return rc;
+}
+
+static int unit_start_name(struct sd_bus *bus, const char *name)
+{
+ int rc;
+ struct sd_bus_message *ret = NULL;
+ sd_bus_error err = SD_BUS_ERROR_NULL;
+
+ rc = sd_bus_call_method(bus, sdb_destination, sdb_path, sdbi_manager, sdbm_start_unit, &err, &ret, "ss", name, "replace");
+ sd_bus_message_unref(ret);
+ return rc;
+}
+
+static int unit_stop_name(struct sd_bus *bus, const char *name)
+{
+ int rc;
+ struct sd_bus_message *ret = NULL;
+ sd_bus_error err = SD_BUS_ERROR_NULL;
+
+ rc = sd_bus_call_method(bus, sdb_destination, sdb_path, sdbi_manager, sdbm_stop_unit, &err, &ret, "ss", name, "replace");
+ sd_bus_message_unref(ret);
+ return rc;
+}
+
+/********************************************************************
+ *
+ *******************************************************************/
+
static int check_snprintf_result(int rc, size_t buflen)
{
return (rc >= 0 && (size_t)rc >= buflen) ? seterrno(ENAMETOOLONG) : rc;
int systemd_get_units_dir(char *path, size_t pathlen, int isuser)
{
- int rc = snprintf(path, pathlen, "%s/%s",
+ int rc = snprintf(path, pathlen, "%s/%s",
SYSTEMD_UNITS_ROOT,
isuser ? "user" : "system");
int systemd_get_unit_path(char *path, size_t pathlen, int isuser, const char *unit, const char *uext)
{
- int rc = snprintf(path, pathlen, "%s/%s/%s.%s",
+ int rc = snprintf(path, pathlen, "%s/%s/%s.%s",
SYSTEMD_UNITS_ROOT,
isuser ? "user" : "system",
unit,
int systemd_get_wants_path(char *path, size_t pathlen, int isuser, const char *wanter, const char *unit, const char *uext)
{
- int rc = snprintf(path, pathlen, "%s/%s/%s.wants/%s.%s",
+ int rc = snprintf(path, pathlen, "%s/%s/%s.wants/%s.%s",
SYSTEMD_UNITS_ROOT,
isuser ? "user" : "system",
wanter,
{
int rc;
struct sd_bus *bus;
+ struct sd_bus_message *ret = NULL;
+ sd_bus_error err = SD_BUS_ERROR_NULL;
rc = get_bus(isuser, &bus);
- if (!rc) {
+ if (rc >= 0) {
/* TODO: asynchronous bind... */
/* TODO: more diagnostic... */
- rc = sd_bus_call_method(bus, sdb_destination, sdb_path, sdbi_manager, sdbm_reload, NULL, NULL, NULL);
+ rc = sd_bus_call_method(bus, sdb_destination, sdb_path, sdbi_manager, sdbm_reload, &err, &ret, NULL);
+ sd_bus_message_unref(ret);
}
return rc;
}
return systemd_unit_list(1, callback, closure) ? : systemd_unit_list(0, callback, closure);
}
+char *systemd_unit_dpath_by_name(int isuser, const char *name, int load)
+{
+ struct sd_bus *bus;
+
+ return get_bus(isuser, &bus) < 0 ? NULL : get_unit_dpath(bus, name, load);
+}
+
+char *systemd_unit_dpath_by_pid(int isuser, unsigned pid)
+{
+ struct sd_bus *bus;
+
+ return get_bus(isuser, &bus) < 0 ? NULL : get_unit_dpath_by_pid(bus, pid);
+}
+
+int systemd_unit_start_dpath(int isuser, const char *dpath)
+{
+ int rc;
+ struct sd_bus *bus;
+
+ rc = get_bus(isuser, &bus);
+ return rc < 0 ? rc : unit_start(bus, dpath);
+}
+
+int systemd_unit_stop_dpath(int isuser, const char *dpath)
+{
+ int rc;
+ struct sd_bus *bus;
+
+ rc = get_bus(isuser, &bus);
+ return rc < 0 ? rc : unit_stop(bus, dpath);
+}
+
+int systemd_unit_start_name(int isuser, const char *name)
+{
+ int rc;
+ struct sd_bus *bus;
+
+ rc = get_bus(isuser, &bus);
+ if (rc >= 0)
+ rc = unit_start_name(bus, name);
+ return rc;
+}
+
+int systemd_unit_stop_name(int isuser, const char *name)
+{
+ int rc;
+ struct sd_bus *bus;
+
+ rc = get_bus(isuser, &bus);
+ if (rc >= 0)
+ rc = unit_stop_name(bus, name);
+ return rc;
+}
+
+int systemd_unit_stop_pid(int isuser, unsigned pid)
+{
+ int rc;
+ struct sd_bus *bus;
+ char *dpath;
+
+ rc = get_bus(isuser, &bus);
+ if (rc >= 0) {
+ dpath = get_unit_dpath_by_pid(bus, pid);
+ if (!dpath)
+ rc = -1;
+ else {
+ rc = unit_stop(bus, dpath);
+ free(dpath);
+ }
+ }
+ return rc;
+}
+
+int systemd_unit_pid_of_dpath(int isuser, const char *dpath)
+{
+ int rc;
+ struct sd_bus *bus;
+
+ rc = get_bus(isuser, &bus);
+ return rc < 0 ? rc : unit_pid(bus, dpath);
+}
+
+const char *systemd_unit_state_of_dpath(int isuser, const char *dpath)
+{
+ int rc;
+ struct sd_bus *bus;
+
+ rc = get_bus(isuser, &bus);
+ return rc < 0 ? NULL : unit_state(bus, dpath);
+}
+
#pragma once
+extern const char SysD_State_Inactive[];
+extern const char SysD_State_Activating[];
+extern const char SysD_State_Active[];
+extern const char SysD_State_Deactivating[];
+extern const char SysD_State_Reloading[];
+extern const char SysD_State_Failed[];
+
extern int systemd_get_units_dir(char *path, size_t pathlen, int isuser);
extern int systemd_get_unit_path(char *path, size_t pathlen, int isuser, const char *unit, const char *uext);
extern int systemd_get_wants_path(char *path, size_t pathlen, int isuser, const char *wanter, const char *unit, const char *uext);
extern int systemd_get_wants_target(char *path, size_t pathlen, const char *unit, const char *uext);
extern int systemd_daemon_reload(int isuser);
+extern char *systemd_unit_dpath_by_name(int isuser, const char *name, int load);
+extern char *systemd_unit_dpath_by_pid(int isuser, unsigned pid);
+
+extern int systemd_unit_start_dpath(int isuser, const char *dpath);
+extern int systemd_unit_stop_dpath(int isuser, const char *dpath);
+
+extern int systemd_unit_start_name(int isuser, const char *name);
+extern int systemd_unit_stop_name(int isuser, const char *name);
+extern int systemd_unit_stop_pid(int isuser, unsigned pid);
+
+extern int systemd_unit_pid_of_dpath(int isuser, const char *dpath);
+extern const char *systemd_unit_state_of_dpath(int isuser, const char *dpath);
+
extern int systemd_unit_list(int isuser, int (*callback)(void *closure, const char *name, const char *path, int isuser), void *closure);
extern int systemd_unit_list_all(int (*callback)(void *closure, const char *name, const char *path, int isuser), void *closure);
Code Review / src / app-framework-main.git / commitdiff