static void test_strv_env_merge(void) {
_cleanup_strv_free_ char **a = NULL, **b = NULL, **r = NULL;
a = strv_new("FOO=BAR", "WALDO=WALDO", "WALDO=", "PIEP", "SCHLUMPF=SMURF", NULL);
assert_se(a);
b = strv_new("FOO=KKK", "FOO=", "PIEP=", "SCHLUMPF=SMURFF", "NANANANA=YES", NULL);
assert_se(b);
r = strv_env_merge(2, a, b);
assert_se(r);
assert_se(streq(r[0], "FOO="));
assert_se(streq(r[1], "WALDO="));
assert_se(streq(r[2], "PIEP"));
assert_se(streq(r[3], "SCHLUMPF=SMURFF"));
assert_se(streq(r[4], "PIEP="));
assert_se(streq(r[5], "NANANANA=YES"));
assert_se(strv_length(r) == 6);
assert_se(strv_env_clean(r) == r);
assert_se(streq(r[0], "FOO="));
assert_se(streq(r[1], "WALDO="));
assert_se(streq(r[2], "SCHLUMPF=SMURFF"));
assert_se(streq(r[3], "PIEP="));
assert_se(streq(r[4], "NANANANA=YES"));
assert_se(strv_length(r) == 5);
}
static void test_sleep(void) {
_cleanup_strv_free_ char
**standby = strv_new("standby", NULL),
**mem = strv_new("mem", NULL),
**disk = strv_new("disk", NULL),
**suspend = strv_new("suspend", NULL),
**reboot = strv_new("reboot", NULL),
**platform = strv_new("platform", NULL),
**shutdown = strv_new("shutdown", NULL),
**freez = strv_new("freeze", NULL);
int r;
log_info("/* configuration */");
log_info("Standby configured: %s", yes_no(can_sleep_state(standby) > 0));
log_info("Suspend configured: %s", yes_no(can_sleep_state(mem) > 0));
log_info("Hibernate configured: %s", yes_no(can_sleep_state(disk) > 0));
log_info("Hibernate+Suspend (Hybrid-Sleep) configured: %s", yes_no(can_sleep_disk(suspend) > 0));
log_info("Hibernate+Reboot configured: %s", yes_no(can_sleep_disk(reboot) > 0));
log_info("Hibernate+Platform configured: %s", yes_no(can_sleep_disk(platform) > 0));
log_info("Hibernate+Shutdown configured: %s", yes_no(can_sleep_disk(shutdown) > 0));
log_info("Freeze configured: %s", yes_no(can_sleep_state(freez) > 0));
log_info("/* running system */");
r = can_sleep("suspend");
log_info("Suspend configured and possible: %s", r >= 0 ? yes_no(r) : strerror(-r));
r = can_sleep("hibernate");
log_info("Hibernation configured and possible: %s", r >= 0 ? yes_no(r) : strerror(-r));
r = can_sleep("hybrid-sleep");
log_info("Hybrid-sleep configured and possible: %s", r >= 0 ? yes_no(r) : strerror(-r));
r = can_sleep("suspend-then-hibernate");
log_info("Suspend-then-Hibernate configured and possible: %s", r >= 0 ? yes_no(r) : strerror(-r));
}
int main(int argc, char* argv[]) {
_cleanup_strv_free_ char
**standby = strv_new("standby", NULL),
**mem = strv_new("mem", NULL),
**disk = strv_new("disk", NULL),
**suspend = strv_new("suspend", NULL),
**reboot = strv_new("reboot", NULL),
**platform = strv_new("platform", NULL),
**shutdown = strv_new("shutdown", NULL),
**freez = strv_new("freeze", NULL);
log_info("Can Standby: %s", yes_no(can_sleep_state(standby) > 0));
log_info("Can Suspend: %s", yes_no(can_sleep_state(mem) > 0));
log_info("Can Hibernate: %s", yes_no(can_sleep_state(disk) > 0));
log_info("Can Hibernate+Suspend (Hybrid-Sleep): %s", yes_no(can_sleep_disk(suspend) > 0));
log_info("Can Hibernate+Reboot: %s", yes_no(can_sleep_disk(reboot) > 0));
log_info("Can Hibernate+Platform: %s", yes_no(can_sleep_disk(platform) > 0));
log_info("Can Hibernate+Shutdown: %s", yes_no(can_sleep_disk(shutdown) > 0));
log_info("Can Freeze: %s", yes_no(can_sleep_disk(freez) > 0));
log_info("Suspend configured and possible: %s", yes_no(can_sleep("suspend") > 0));
log_info("Hibernation configured and possible: %s", yes_no(can_sleep("hibernate") > 0));
log_info("Hybrid-sleep configured and possible: %s", yes_no(can_sleep("hybrid-sleep") > 0));
return 0;
}
static void test_env_clean(void) {
_cleanup_strv_free_ char **e;
e = strv_new("FOOBAR=WALDO",
"FOOBAR=WALDO",
"FOOBAR",
"F",
"X=",
"F=F",
"=",
"=F",
"",
"0000=000",
"äöüß=abcd",
"abcd=äöüß",
"xyz\n=xyz",
"xyz=xyz\n",
"another=one",
"another=final one",
NULL);
assert_se(e);
assert_se(!strv_env_is_valid(e));
assert_se(strv_env_clean(e) == e);
assert_se(strv_env_is_valid(e));
assert_se(streq(e[0], "FOOBAR=WALDO"));
assert_se(streq(e[1], "X="));
assert_se(streq(e[2], "F=F"));
assert_se(streq(e[3], "abcd=äöüß"));
assert_se(streq(e[4], "another=final one"));
assert_se(e[5] == NULL);
}
static int enumerator2_callback(sd_bus *bus, const char *path, void *userdata, char ***nodes, sd_bus_error *error) {
if (object_path_startswith("/value/a", path))
assert_se(*nodes = strv_new("/value/a/x", "/value/a/y", "/value/a/z", NULL));
return 1;
}
static int enumerator_callback(sd_bus *b, const char *path, char ***nodes, void *userdata) {
if (object_path_startswith("/value", path))
assert_se(*nodes = strv_new("/value/a", "/value/b", "/value/c", NULL));
return 1;
}
int xdg_user_dirs(char ***ret_config_dirs, char ***ret_data_dirs) {
/* Implement the mechanisms defined in
*
* http://standards.freedesktop.org/basedir-spec/basedir-spec-0.6.html
*
* We look in both the config and the data dirs because we
* want to encourage that distributors ship their unit files
* as data, and allow overriding as configuration.
*/
const char *e;
_cleanup_strv_free_ char **config_dirs = NULL, **data_dirs = NULL;
e = getenv("XDG_CONFIG_DIRS");
if (e) {
config_dirs = strv_split(e, ":");
if (!config_dirs)
return -ENOMEM;
}
e = getenv("XDG_DATA_DIRS");
if (e)
data_dirs = strv_split(e, ":");
else
data_dirs = strv_new("/usr/local/share",
"/usr/share",
NULL);
if (!data_dirs)
return -ENOMEM;
*ret_config_dirs = config_dirs;
*ret_data_dirs = data_dirs;
config_dirs = data_dirs = NULL;
return 0;
}
int get_timezones(char ***ret) {
_cleanup_fclose_ FILE *f = NULL;
_cleanup_strv_free_ char **zones = NULL;
size_t n_zones = 0, n_allocated = 0;
assert(ret);
zones = strv_new("UTC", NULL);
if (!zones)
return -ENOMEM;
n_allocated = 2;
n_zones = 1;
f = fopen("/usr/share/zoneinfo/zone.tab", "re");
if (f) {
char l[LINE_MAX];
FOREACH_LINE(l, f, return -errno) {
char *p, *w;
size_t k;
p = strstrip(l);
if (isempty(p) || *p == '#')
continue;
/* Skip over country code */
p += strcspn(p, WHITESPACE);
p += strspn(p, WHITESPACE);
/* Skip over coordinates */
p += strcspn(p, WHITESPACE);
p += strspn(p, WHITESPACE);
/* Found timezone name */
k = strcspn(p, WHITESPACE);
if (k <= 0)
continue;
w = strndup(p, k);
if (!w)
return -ENOMEM;
if (!GREEDY_REALLOC(zones, n_allocated, n_zones + 2)) {
free(w);
return -ENOMEM;
}
zones[n_zones++] = w;
zones[n_zones] = NULL;
}
strv_sort(zones);
} else if (errno != ENOENT)
static void test_strv_env_delete(void) {
_cleanup_strv_free_ char **a = NULL, **b = NULL, **c = NULL, **d = NULL;
a = strv_new("FOO=BAR", "WALDO=WALDO", "WALDO=", "PIEP", "SCHLUMPF=SMURF", NULL);
assert_se(a);
b = strv_new("PIEP", "FOO", NULL);
assert_se(b);
c = strv_new("SCHLUMPF", NULL);
assert_se(c);
d = strv_env_delete(a, 2, b, c);
assert_se(d);
assert_se(streq(d[0], "WALDO=WALDO"));
assert_se(streq(d[1], "WALDO="));
assert_se(strv_length(d) == 2);
}
int manager_new(Manager **ret) {
_cleanup_manager_free_ Manager *m = NULL;
int r;
m = new0(Manager, 1);
if (!m)
return -ENOMEM;
r = sd_event_default(&m->event);
if (r < 0)
return r;
sd_event_set_watchdog(m->event, true);
r = sd_rtnl_open(RTMGRP_LINK | RTMGRP_IPV4_IFADDR, &m->rtnl);
if (r < 0)
return r;
m->udev = udev_new();
if (!m->udev)
return -ENOMEM;
m->udev_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
if (!m->udev_monitor)
return -ENOMEM;
m->links = hashmap_new(uint64_hash_func, uint64_compare_func);
if (!m->links)
return -ENOMEM;
m->bridges = hashmap_new(string_hash_func, string_compare_func);
if (!m->bridges)
return -ENOMEM;
LIST_HEAD_INIT(m->networks);
m->network_dirs = strv_new("/etc/systemd/network/",
"/run/systemd/network/",
"/usr/lib/systemd/network",
#ifdef HAVE_SPLIT_USER
"/lib/systemd/network",
#endif
NULL);
if (!m->network_dirs)
return -ENOMEM;
if (!path_strv_canonicalize_uniq(m->network_dirs))
return -ENOMEM;
*ret = m;
m = NULL;
return 0;
}
int config_parse_strv(const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
char *** sv = data, *w, *state;
size_t l;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
assert(data);
if (isempty(rvalue)) {
char **empty;
/* Empty assignment resets the list. As a special rule
* we actually fill in a real empty array here rather
* than NULL, since some code wants to know if
* something was set at all... */
empty = strv_new(NULL, NULL);
if (!empty)
return log_oom();
strv_free(*sv);
*sv = empty;
return 0;
}
FOREACH_WORD_QUOTED(w, l, rvalue, state) {
_cleanup_free_ char *n;
n = cunescape_length(w, l);
if (!n)
return log_oom();
if (!utf8_is_valid(n)) {
log_syntax(unit, LOG_ERR, filename, line, EINVAL,
"String is not UTF-8 clean, ignoring: %s", rvalue);
continue;
}
r = strv_extend(sv, n);
if (r < 0)
return log_oom();
}
int config_parse_strv(const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
char ***sv = data;
const char *word, *state;
size_t l;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
assert(data);
if (isempty(rvalue)) {
char **empty;
/* Empty assignment resets the list. As a special rule
* we actually fill in a real empty array here rather
* than NULL, since some code wants to know if
* something was set at all... */
empty = strv_new(NULL, NULL);
if (!empty)
return log_oom();
strv_free(*sv);
*sv = empty;
return 0;
}
FOREACH_WORD_QUOTED(word, l, rvalue, state) {
char *n;
n = strndup(word, l);
if (!n)
return log_oom();
if (!utf8_is_valid(n)) {
log_invalid_utf8(unit, LOG_ERR, filename, line, EINVAL, rvalue);
continue;
}
r = strv_consume(sv, n);
if (r < 0)
return log_oom();
}
static void test_strv_env_unset(void) {
_cleanup_strv_free_ char **l = NULL;
l = strv_new("PIEP", "SCHLUMPF=SMURFF", "NANANANA=YES", NULL);
assert_se(l);
assert_se(strv_env_unset(l, "SCHLUMPF") == l);
assert_se(streq(l[0], "PIEP"));
assert_se(streq(l[1], "NANANANA=YES"));
assert_se(strv_length(l) == 2);
}
static void test_strv_env_set(void) {
_cleanup_strv_free_ char **l = NULL, **r = NULL;
l = strv_new("PIEP", "SCHLUMPF=SMURFF", "NANANANA=YES", NULL);
assert_se(l);
r = strv_env_set(l, "WALDO=WALDO");
assert_se(r);
assert_se(streq(r[0], "PIEP"));
assert_se(streq(r[1], "SCHLUMPF=SMURFF"));
assert_se(streq(r[2], "NANANANA=YES"));
assert_se(streq(r[3], "WALDO=WALDO"));
assert_se(strv_length(r) == 4);
}
static int environment_dirs(char ***ret) {
_cleanup_strv_free_ char **dirs = NULL;
_cleanup_free_ char *c = NULL;
int r;
dirs = strv_new(CONF_PATHS_USR("environment.d"), NULL);
if (!dirs)
return -ENOMEM;
/* ~/.config/systemd/environment.d */
r = sd_path_home(SD_PATH_USER_CONFIGURATION, "environment.d", &c);
if (r < 0)
return r;
r = strv_extend_front(&dirs, c);
if (r < 0)
return r;
*ret = TAKE_PTR(dirs);
return 0;
}
int parse_sleep_config(const char *verb, char ***_modes, char ***_states) {
_cleanup_strv_free_ char
**suspend_mode = NULL, **suspend_state = NULL,
**hibernate_mode = NULL, **hibernate_state = NULL,
**hybrid_mode = NULL, **hybrid_state = NULL;
char **modes, **states;
const ConfigTableItem items[] = {
{ "Sleep", "SuspendMode", config_parse_strv, 0, &suspend_mode },
{ "Sleep", "SuspendState", config_parse_strv, 0, &suspend_state },
{ "Sleep", "HibernateMode", config_parse_strv, 0, &hibernate_mode },
{ "Sleep", "HibernateState", config_parse_strv, 0, &hibernate_state },
{ "Sleep", "HybridSleepMode", config_parse_strv, 0, &hybrid_mode },
{ "Sleep", "HybridSleepState", config_parse_strv, 0, &hybrid_state },
{}
};
int r;
_cleanup_fclose_ FILE *f;
f = fopen(PKGSYSCONFDIR "/sleep.conf", "re");
if (!f)
log_full(errno == ENOENT ? LOG_DEBUG: LOG_WARNING,
"Failed to open configuration file " PKGSYSCONFDIR "/sleep.conf: %m");
else {
r = config_parse(NULL, PKGSYSCONFDIR "/sleep.conf", f, "Sleep\0",
config_item_table_lookup, (void*) items, false, false, NULL);
if (r < 0)
log_warning("Failed to parse configuration file: %s", strerror(-r));
}
if (streq(verb, "suspend")) {
/* empty by default */
USE(modes, suspend_mode);
if (suspend_state)
USE(states, suspend_state);
else
states = strv_new("mem", "standby", "freeze", NULL);
} else if (streq(verb, "hibernate")) {
if (hibernate_mode)
USE(modes, hibernate_mode);
else
modes = strv_new("platform", "shutdown", NULL);
if (hibernate_state)
USE(states, hibernate_state);
else
states = strv_new("disk", NULL);
} else if (streq(verb, "hybrid-sleep")) {
if (hybrid_mode)
USE(modes, hybrid_mode);
else
modes = strv_new("suspend", "platform", "shutdown", NULL);
if (hybrid_state)
USE(states, hybrid_state);
else
states = strv_new("disk", NULL);
} else
assert_not_reached("what verb");
if ((!modes && !streq(verb, "suspend")) || !states) {
strv_free(modes);
strv_free(states);
return log_oom();
}
*_modes = modes;
*_states = states;
return 0;
}
static Manager *manager_new(void) {
Manager *m;
int r;
m = new0(Manager, 1);
if (!m)
return NULL;
m->console_active_fd = -1;
m->reserve_vt_fd = -1;
m->n_autovts = 6;
m->reserve_vt = 6;
m->remove_ipc = true;
m->inhibit_delay_max = 5 * USEC_PER_SEC;
m->handle_power_key = HANDLE_POWEROFF;
m->handle_suspend_key = HANDLE_SUSPEND;
m->handle_hibernate_key = HANDLE_HIBERNATE;
m->handle_lid_switch = HANDLE_SUSPEND;
m->handle_lid_switch_docked = HANDLE_IGNORE;
m->lid_switch_ignore_inhibited = true;
m->holdoff_timeout_usec = 30 * USEC_PER_SEC;
m->idle_action_usec = 30 * USEC_PER_MINUTE;
m->idle_action = HANDLE_IGNORE;
m->idle_action_not_before_usec = now(CLOCK_MONOTONIC);
m->runtime_dir_size = PAGE_ALIGN((size_t) (physical_memory() / 10)); /* 10% */
m->devices = hashmap_new(&string_hash_ops);
m->seats = hashmap_new(&string_hash_ops);
m->sessions = hashmap_new(&string_hash_ops);
m->users = hashmap_new(NULL);
m->inhibitors = hashmap_new(&string_hash_ops);
m->buttons = hashmap_new(&string_hash_ops);
m->user_units = hashmap_new(&string_hash_ops);
m->session_units = hashmap_new(&string_hash_ops);
if (!m->devices || !m->seats || !m->sessions || !m->users || !m->inhibitors || !m->buttons || !m->user_units || !m->session_units)
goto fail;
m->kill_exclude_users = strv_new("root", NULL);
if (!m->kill_exclude_users)
goto fail;
m->udev = udev_new();
if (!m->udev)
goto fail;
r = sd_event_default(&m->event);
if (r < 0)
goto fail;
sd_event_set_watchdog(m->event, true);
return m;
fail:
manager_free(m);
return NULL;
}
int parse_sleep_config(const char *verb, char ***_modes, char ***_states) {
_cleanup_strv_free_ char
**suspend_mode = NULL, **suspend_state = NULL,
**hibernate_mode = NULL, **hibernate_state = NULL,
**hybrid_mode = NULL, **hybrid_state = NULL;
char **modes, **states;
const ConfigTableItem items[] = {
{ "Sleep", "SuspendMode", config_parse_strv, 0, &suspend_mode },
{ "Sleep", "SuspendState", config_parse_strv, 0, &suspend_state },
{ "Sleep", "HibernateMode", config_parse_strv, 0, &hibernate_mode },
{ "Sleep", "HibernateState", config_parse_strv, 0, &hibernate_state },
{ "Sleep", "HybridSleepMode", config_parse_strv, 0, &hybrid_mode },
{ "Sleep", "HybridSleepState", config_parse_strv, 0, &hybrid_state },
{}
};
config_parse_many(PKGSYSCONFDIR "/sleep.conf",
CONF_PATHS_NULSTR("systemd/sleep.conf.d"),
"Sleep\0", config_item_table_lookup, items,
false, NULL);
if (streq(verb, "suspend")) {
/* empty by default */
USE(modes, suspend_mode);
if (suspend_state)
USE(states, suspend_state);
else
states = strv_new("mem", "standby", "freeze", NULL);
} else if (streq(verb, "hibernate")) {
if (hibernate_mode)
USE(modes, hibernate_mode);
else
modes = strv_new("platform", "shutdown", NULL);
if (hibernate_state)
USE(states, hibernate_state);
else
states = strv_new("disk", NULL);
} else if (streq(verb, "hybrid-sleep")) {
if (hybrid_mode)
USE(modes, hybrid_mode);
else
modes = strv_new("suspend", "platform", "shutdown", NULL);
if (hybrid_state)
USE(states, hybrid_state);
else
states = strv_new("disk", NULL);
} else
assert_not_reached("what verb");
if ((!modes && !streq(verb, "suspend")) || !states) {
strv_free(modes);
strv_free(states);
return log_oom();
}
*_modes = modes;
*_states = states;
return 0;
}
int lookup_paths_init(
LookupPaths *p,
SystemdRunningAs running_as,
bool personal,
const char *root_dir,
const char *generator,
const char *generator_early,
const char *generator_late) {
const char *e;
bool append = false; /* Add items from SYSTEMD_UNIT_PATH before normal directories */
assert(p);
/* First priority is whatever has been passed to us via env
* vars */
e = getenv("SYSTEMD_UNIT_PATH");
if (e) {
if (endswith(e, ":")) {
e = strndupa(e, strlen(e) - 1);
append = true;
}
/* FIXME: empty components in other places should be
* rejected. */
p->unit_path = path_split_and_make_absolute(e);
if (!p->unit_path)
return -ENOMEM;
} else
p->unit_path = NULL;
if (!p->unit_path || append) {
/* Let's figure something out. */
_cleanup_strv_free_ char **unit_path;
int r;
/* For the user units we include share/ in the search
* path in order to comply with the XDG basedir spec.
* For the system stuff we avoid such nonsense. OTOH
* we include /lib in the search path for the system
* stuff but avoid it for user stuff. */
if (running_as == SYSTEMD_USER) {
if (personal)
unit_path = user_dirs(generator, generator_early, generator_late);
else
unit_path = strv_new(
/* If you modify this you also want to modify
* systemduserunitpath= in systemd.pc.in, and
* the arrays in user_dirs() above! */
STRV_IFNOTNULL(generator_early),
USER_CONFIG_UNIT_PATH,
"/etc/systemd/user",
"/run/systemd/user",
STRV_IFNOTNULL(generator),
"/usr/local/lib/systemd/user",
"/usr/local/share/systemd/user",
USER_DATA_UNIT_PATH,
"/usr/lib/systemd/user",
"/usr/share/systemd/user",
STRV_IFNOTNULL(generator_late),
NULL);
} else
unit_path = strv_new(
/* If you modify this you also want to modify
* systemdsystemunitpath= in systemd.pc.in! */
STRV_IFNOTNULL(generator_early),
SYSTEM_CONFIG_UNIT_PATH,
"/etc/systemd/system",
"/run/systemd/system",
STRV_IFNOTNULL(generator),
"/usr/local/lib/systemd/system",
SYSTEM_DATA_UNIT_PATH,
"/usr/lib/systemd/system",
#ifdef HAVE_SPLIT_USR
"/lib/systemd/system",
#endif
STRV_IFNOTNULL(generator_late),
NULL);
if (!unit_path)
return -ENOMEM;
r = strv_extend_strv(&p->unit_path, unit_path);
if (r < 0)
return r;
}
if (!path_strv_resolve_uniq(p->unit_path, root_dir))
return -ENOMEM;
if (!strv_isempty(p->unit_path)) {
_cleanup_free_ char *t = strv_join(p->unit_path, "\n\t");
if (!t)
return -ENOMEM;
log_debug("Looking for unit files in (higher priority first):\n\t%s", t);
} else {
log_debug("Ignoring unit files.");
strv_free(p->unit_path);
p->unit_path = NULL;
}
if (running_as == SYSTEMD_SYSTEM) {
#ifdef HAVE_SYSV_COMPAT
/* /etc/init.d/ compatibility does not matter to users */
e = getenv("SYSTEMD_SYSVINIT_PATH");
if (e) {
p->sysvinit_path = path_split_and_make_absolute(e);
if (!p->sysvinit_path)
return -ENOMEM;
} else
p->sysvinit_path = NULL;
if (strv_isempty(p->sysvinit_path)) {
strv_free(p->sysvinit_path);
p->sysvinit_path = strv_new(
SYSTEM_SYSVINIT_PATH, /* /etc/init.d/ */
NULL);
if (!p->sysvinit_path)
return -ENOMEM;
}
e = getenv("SYSTEMD_SYSVRCND_PATH");
if (e) {
p->sysvrcnd_path = path_split_and_make_absolute(e);
if (!p->sysvrcnd_path)
return -ENOMEM;
} else
p->sysvrcnd_path = NULL;
if (strv_isempty(p->sysvrcnd_path)) {
strv_free(p->sysvrcnd_path);
p->sysvrcnd_path = strv_new(
SYSTEM_SYSVRCND_PATH, /* /etc/rcN.d/ */
NULL);
if (!p->sysvrcnd_path)
return -ENOMEM;
}
if (!path_strv_resolve_uniq(p->sysvinit_path, root_dir))
return -ENOMEM;
if (!path_strv_resolve_uniq(p->sysvrcnd_path, root_dir))
return -ENOMEM;
if (!strv_isempty(p->sysvinit_path)) {
_cleanup_free_ char *t = strv_join(p->sysvinit_path, "\n\t");
if (!t)
return -ENOMEM;
log_debug("Looking for SysV init scripts in:\n\t%s", t);
} else {
log_debug("Ignoring SysV init scripts.");
strv_free(p->sysvinit_path);
p->sysvinit_path = NULL;
}
if (!strv_isempty(p->sysvrcnd_path)) {
_cleanup_free_ char *t =
strv_join(p->sysvrcnd_path, "\n\t");
if (!t)
return -ENOMEM;
log_debug("Looking for SysV rcN.d links in:\n\t%s", t);
} else {
log_debug("Ignoring SysV rcN.d links.");
strv_free(p->sysvrcnd_path);
p->sysvrcnd_path = NULL;
}
#else
log_debug("SysV init scripts and rcN.d links support disabled");
#endif
}
return 0;
}
Manager *manager_new(void) {
Manager *m;
int r;
m = new0(Manager, 1);
if (!m)
return NULL;
m->console_active_fd = -1;
m->reserve_vt_fd = -1;
m->n_autovts = 6;
m->reserve_vt = 6;
m->inhibit_delay_max = 5 * USEC_PER_SEC;
m->handle_power_key = HANDLE_POWEROFF;
m->handle_suspend_key = HANDLE_SUSPEND;
m->handle_hibernate_key = HANDLE_HIBERNATE;
m->handle_lid_switch = HANDLE_SUSPEND;
m->lid_switch_ignore_inhibited = true;
m->idle_action_usec = 30 * USEC_PER_MINUTE;
m->idle_action = HANDLE_IGNORE;
m->idle_action_not_before_usec = now(CLOCK_MONOTONIC);
m->devices = hashmap_new(string_hash_func, string_compare_func);
m->seats = hashmap_new(string_hash_func, string_compare_func);
m->sessions = hashmap_new(string_hash_func, string_compare_func);
m->users = hashmap_new(trivial_hash_func, trivial_compare_func);
m->inhibitors = hashmap_new(string_hash_func, string_compare_func);
m->buttons = hashmap_new(string_hash_func, string_compare_func);
m->user_units = hashmap_new(string_hash_func, string_compare_func);
m->session_units = hashmap_new(string_hash_func, string_compare_func);
m->busnames = set_new(string_hash_func, string_compare_func);
if (!m->devices || !m->seats || !m->sessions || !m->users || !m->inhibitors || !m->buttons || !m->busnames ||
!m->user_units || !m->session_units ||
!m->busnames) {
manager_free(m);
return NULL;
}
m->kill_exclude_users = strv_new("root", NULL);
if (!m->kill_exclude_users) {
manager_free(m);
return NULL;
}
m->udev = udev_new();
if (!m->udev) {
manager_free(m);
return NULL;
}
r = sd_event_default(&m->event);
if (r < 0) {
manager_free(m);
return NULL;
}
sd_event_set_watchdog(m->event, true);
return m;
}
int lookup_paths_init(
LookupPaths *p,
SystemdRunningAs running_as,
bool personal,
const char *generator,
const char *generator_early,
const char *generator_late) {
const char *e;
assert(p);
/* First priority is whatever has been passed to us via env
* vars */
e = getenv("SYSTEMD_UNIT_PATH");
if (e) {
p->unit_path = path_split_and_make_absolute(e);
if (!p->unit_path)
return -ENOMEM;
} else
p->unit_path = NULL;
if (strv_isempty(p->unit_path)) {
/* Nothing is set, so let's figure something out. */
strv_free(p->unit_path);
/* For the user units we include share/ in the search
* path in order to comply with the XDG basedir
* spec. For the system stuff we avoid such
* nonsense. OTOH we include /lib in the search path
* for the system stuff but avoid it for user
* stuff. */
if (running_as == SYSTEMD_USER) {
if (personal)
p->unit_path = user_dirs(generator, generator_early, generator_late);
else
p->unit_path = strv_new(
/* If you modify this you also want to modify
* systemduserunitpath= in systemd.pc.in, and
* the arrays in user_dirs() above! */
STRV_IFNOTNULL(generator_early),
USER_CONFIG_UNIT_PATH,
"/etc/systemd/user",
"/run/systemd/user",
STRV_IFNOTNULL(generator),
"/usr/local/lib/systemd/user",
"/usr/local/share/systemd/user",
USER_DATA_UNIT_PATH,
"/usr/lib/systemd/user",
"/usr/share/systemd/user",
STRV_IFNOTNULL(generator_late),
NULL);
if (!p->unit_path)
return -ENOMEM;
} else {
p->unit_path = strv_new(
/* If you modify this you also want to modify
* systemdsystemunitpath= in systemd.pc.in! */
STRV_IFNOTNULL(generator_early),
SYSTEM_CONFIG_UNIT_PATH,
"/etc/systemd/system",
"/run/systemd/system",
STRV_IFNOTNULL(generator),
"/usr/local/lib/systemd/system",
SYSTEM_DATA_UNIT_PATH,
"/usr/lib/systemd/system",
#ifdef HAVE_SPLIT_USR
"/lib/systemd/system",
#endif
STRV_IFNOTNULL(generator_late),
NULL);
if (!p->unit_path)
return -ENOMEM;
}
}
if (!path_strv_canonicalize(p->unit_path))
return -ENOMEM;
strv_uniq(p->unit_path);
if (!strv_isempty(p->unit_path)) {
_cleanup_free_ char *t = strv_join(p->unit_path, "\n\t");
if (!t)
return -ENOMEM;
log_debug("Looking for unit files in (higher priority first):\n\t%s", t);
} else {
log_debug("Ignoring unit files.");
strv_free(p->unit_path);
p->unit_path = NULL;
}
if (running_as == SYSTEMD_SYSTEM) {
#ifdef HAVE_SYSV_COMPAT
/* /etc/init.d/ compatibility does not matter to users */
e = getenv("SYSTEMD_SYSVINIT_PATH");
if (e) {
p->sysvinit_path = path_split_and_make_absolute(e);
if (!p->sysvinit_path)
return -ENOMEM;
} else
p->sysvinit_path = NULL;
if (strv_isempty(p->sysvinit_path)) {
strv_free(p->sysvinit_path);
p->sysvinit_path = strv_new(
SYSTEM_SYSVINIT_PATH, /* /etc/init.d/ */
NULL);
if (!p->sysvinit_path)
return -ENOMEM;
}
e = getenv("SYSTEMD_SYSVRCND_PATH");
if (e) {
p->sysvrcnd_path = path_split_and_make_absolute(e);
if (!p->sysvrcnd_path)
return -ENOMEM;
} else
p->sysvrcnd_path = NULL;
if (strv_isempty(p->sysvrcnd_path)) {
strv_free(p->sysvrcnd_path);
p->sysvrcnd_path = strv_new(
SYSTEM_SYSVRCND_PATH, /* /etc/rcN.d/ */
NULL);
if (!p->sysvrcnd_path)
return -ENOMEM;
}
if (!path_strv_canonicalize(p->sysvinit_path))
return -ENOMEM;
if (!path_strv_canonicalize(p->sysvrcnd_path))
return -ENOMEM;
strv_uniq(p->sysvinit_path);
strv_uniq(p->sysvrcnd_path);
if (!strv_isempty(p->sysvinit_path)) {
_cleanup_free_ char *t = strv_join(p->sysvinit_path, "\n\t");
if (!t)
return -ENOMEM;
log_debug("Looking for SysV init scripts in:\n\t%s", t);
} else {
log_debug("Ignoring SysV init scripts.");
strv_free(p->sysvinit_path);
p->sysvinit_path = NULL;
}
if (!strv_isempty(p->sysvrcnd_path)) {
_cleanup_free_ char *t =
strv_join(p->sysvrcnd_path, "\n\t");
if (!t)
return -ENOMEM;
log_debug("Looking for SysV rcN.d links in:\n\t%s", t);
} else {
log_debug("Ignoring SysV rcN.d links.");
strv_free(p->sysvrcnd_path);
p->sysvrcnd_path = NULL;
}
#else
log_debug("SysV init scripts and rcN.d links support disabled");
#endif
}
return 0;
}
