|| u->following[0]) || u->job_id > 0);
}
-static void output_units_list(const UnitInfo *unit_infos, unsigned c, char** patterns) {
+static void output_units_list(const UnitInfo *unit_infos, unsigned c) {
unsigned id_len, max_id_len, load_len, active_len, sub_len, job_len, desc_len;
const UnitInfo *u;
unsigned n_shown = 0;
desc_len = 0;
for (u = unit_infos; u < unit_infos + c; u++) {
- if (!output_show_unit(u, patterns))
- continue;
-
max_id_len = MAX(max_id_len, strlen(u->id));
load_len = MAX(load_len, strlen(u->load_state));
active_len = MAX(active_len, strlen(u->active_state));
const char *on_loaded, *off_loaded, *on = "";
const char *on_active, *off_active, *off = "";
- if (!output_show_unit(u, patterns))
- continue;
-
if (!n_shown && !arg_no_legend) {
printf("%-*s %-*s %-*s %-*s ",
id_len, "UNIT",
const char *on, *off;
if (n_shown) {
- printf("\nLOAD = Reflects whether the unit definition was properly loaded.\n"
- "ACTIVE = The high-level unit activation state, i.e. generalization of SUB.\n"
- "SUB = The low-level unit activation state, values depend on unit type.\n");
- if (job_count)
- printf("JOB = Pending job for the unit.\n");
- puts("");
+ puts("\nLOAD = Reflects whether the unit definition was properly loaded.\n"
+ "ACTIVE = The high-level unit activation state, i.e. generalization of SUB.\n"
+ "SUB = The low-level unit activation state, values depend on unit type.");
+ puts(job_count ? "JOB = Pending job for the unit.\n" : "");
on = ansi_highlight();
off = ansi_highlight_off();
} else {
static int get_unit_list(
sd_bus *bus,
sd_bus_message **_reply,
- UnitInfo **_unit_infos) {
+ UnitInfo **_unit_infos,
+ char **patterns) {
_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
return bus_log_parse_error(r);
while ((r = bus_parse_unit_info(reply, &u)) > 0) {
+ if (!output_show_unit(&u, patterns))
+ continue;
if (!GREEDY_REALLOC(unit_infos, size, c+1))
return log_oom();
pager_open_if_enabled();
- r = get_unit_list(bus, &reply, &unit_infos);
+ r = get_unit_list(bus, &reply, &unit_infos, strv_skip_first(args));
if (r < 0)
return r;
qsort_safe(unit_infos, r, sizeof(UnitInfo), compare_unit_info);
- output_units_list(unit_infos, r, strv_skip_first(args));
+ output_units_list(unit_infos, r);
return 0;
}
static int list_sockets(sd_bus *bus, char **args) {
_cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
_cleanup_free_ UnitInfo *unit_infos = NULL;
- struct socket_info *socket_infos = NULL;
+ _cleanup_free_ struct socket_info *socket_infos = NULL;
const UnitInfo *u;
struct socket_info *s;
unsigned cs = 0;
pager_open_if_enabled();
- n = get_unit_list(bus, &reply, &unit_infos);
+ n = get_unit_list(bus, &reply, &unit_infos, strv_skip_first(args));
if (n < 0)
return n;
_cleanup_strv_free_ char **listening = NULL, **triggered = NULL;
int i, c;
- if (!output_show_unit(u, strv_skip_first(args)))
- continue;
-
if (!endswith(u->id, ".socket"))
continue;
if (s->own_triggered)
strv_free(s->triggered);
}
- free(socket_infos);
return r;
}
pager_open_if_enabled();
- n = get_unit_list(bus, &reply, &unit_infos);
+ n = get_unit_list(bus, &reply, &unit_infos, strv_skip_first(args));
if (n < 0)
return n;
dual_timestamp next;
usec_t m;
- if (!output_show_unit(u, strv_skip_first(args)))
- continue;
-
if (!endswith(u->id, ".timer"))
continue;
return !arg_types || ((dot = strrchr(u->path, '.')) && strv_find(arg_types, dot+1));
}
-static void output_unit_file_list(const UnitFileList *units, unsigned c, char **patterns) {
+static void output_unit_file_list(const UnitFileList *units, unsigned c) {
unsigned max_id_len, id_cols, state_cols, n_shown = 0;
const UnitFileList *u;
state_cols = sizeof("STATE")-1;
for (u = units; u < units + c; u++) {
- if (!output_show_unit_file(u, patterns))
- continue;
-
max_id_len = MAX(max_id_len, strlen(basename(u->path)));
state_cols = MAX(state_cols, strlen(unit_file_state_to_string(u->state)));
}
const char *on, *off;
const char *id;
- if (!output_show_unit_file(u, patterns))
- continue;
-
n_shown++;
if (u->state == UNIT_FILE_MASKED ||
_cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_free_ UnitFileList *units = NULL;
+ UnitFileList *unit;
+ size_t size = 0;
unsigned c = 0;
const char *state;
char *path;
}
HASHMAP_FOREACH(u, h, i) {
- memcpy(units + c++, u, sizeof(UnitFileList));
+ if (!output_show_unit_file(u, strv_skip_first(args)))
+ continue;
+
+ units[c++] = *u;
free(u);
}
- assert(c == n_units);
+ assert(c <= n_units);
hashmap_free(h);
} else {
- size_t size = 0;
-
r = sd_bus_call_method(
bus,
"org.freedesktop.systemd1",
if (!GREEDY_REALLOC(units, size, c + 1))
return log_oom();
- units[c++] = (struct UnitFileList) {
+ units[c] = (struct UnitFileList) {
path,
unit_file_state_from_string(state)
};
+
+ if (output_show_unit_file(&units[c], strv_skip_first(args)))
+ c ++;
+
}
if (r < 0)
return bus_log_parse_error(r);
if (c > 0) {
qsort(units, c, sizeof(UnitFileList), compare_unit_file_list);
- output_unit_file_list(units, c, strv_skip_first(args));
+ output_unit_file_list(units, c);
}
+ if (avoid_bus())
+ for (unit = units; unit < units + c; unit++)
+ free(unit->path);
+
return 0;
}
assert(bus);
if (args[1]) {
- unit = unit_name_mangle(args[1]);
+ unit = unit_name_mangle(args[1], false);
if (!unit)
return log_oom();
u = unit;
unsigned n_changes = 0;
int r;
- unit = unit_name_mangle_with_suffix(args[1], ".target");
+ unit = unit_name_mangle_with_suffix(args[1], false, ".target");
if (!unit)
return log_oom();
static int need_daemon_reload(sd_bus *bus, const char *unit) {
_cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
- _cleanup_free_ char *n = NULL;
const char *path;
int b, r;
/* We ignore all errors here, since this is used to show a
* warning only */
- n = unit_name_mangle(unit);
- if (!n)
- return -ENOMEM;
-
/* We don't use unit_dbus_path_from_name() directly since we
* don't want to load the unit if it isn't loaded. */
"GetUnit",
NULL,
&reply,
- "s", n);
+ "s", unit);
if (r < 0)
return r;
while (!set_isempty(s)) {
q = bus_process_wait(bus);
- if (q < 0)
+ if (q < 0) {
+ log_error("Failed to wait for response: %s", strerror(-r));
return q;
+ }
if (d.result) {
q = check_wait_response(&d);
* meaningful. */
if (q < 0 && r == 0)
r = q;
+ log_debug("Got result %s/%s for job %s",
+ strna(d.result), strerror(-q), strna(d.name));
}
free(d.name);
assert(name);
- n = unit_name_mangle(name);
+ n = unit_name_mangle(name, false);
if (!n)
return log_oom();
char **i;
int r;
- n = unit_name_mangle(name);
+ n = unit_name_mangle(name, false);
if (!n)
return log_oom();
Set *s) {
_cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
- _cleanup_free_ char *n;
const char *path;
int r;
assert(mode);
assert(error);
- n = unit_name_mangle(name);
- if (!n)
- return log_oom();
-
+ log_debug("Calling manager for %s on %s, %s", method, name, mode);
r = sd_bus_call_method(
bus,
"org.freedesktop.systemd1",
method,
error,
&reply,
- "ss", n, mode);
+ "ss", name, mode);
if (r < 0) {
if (r == -ENOENT && arg_action != ACTION_SYSTEMCTL)
/* There's always a fallback possible for
* legacy actions. */
return -EADDRNOTAVAIL;
- log_error("Failed to start %s: %s", name, bus_error_message(error, r));
+ log_error("Failed to %s %s: %s", method, name, bus_error_message(error, r));
return r;
}
if (r < 0)
return bus_log_parse_error(r);
- if (need_daemon_reload(bus, n) > 0)
+ if (need_daemon_reload(bus, name) > 0)
log_warning("Warning: Unit file of %s changed on disk, 'systemctl%s daemon-reload' recommended.",
- n, arg_scope == UNIT_FILE_SYSTEM ? "" : " --user");
+ name, arg_scope == UNIT_FILE_SYSTEM ? "" : " --user");
if (s) {
char *p;
if (!p)
return log_oom();
+ log_debug("Adding %s to the set", p);
r = set_consume(s, p);
if (r < 0)
return log_oom();
return 0;
}
+static int expand_names(sd_bus *bus, char **names, const char* suffix, char ***ret) {
+
+ _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
+ _cleanup_strv_free_ char **mangled = NULL, **globs = NULL;
+ char **name;
+ int r = 0, i;
+
+ STRV_FOREACH(name, names) {
+ char *t;
+
+ if (suffix)
+ t = unit_name_mangle_with_suffix(*name, true, suffix);
+ else
+ t = unit_name_mangle(*name, true);
+ if (!t)
+ return log_oom();
+
+ if (string_is_glob(t))
+ r = strv_push(&globs, t);
+ else
+ r = strv_push(&mangled, t);
+ if (r < 0) {
+ free(t);
+ return log_oom();
+ }
+ }
+
+ /* Query the manager only if any of the names are a glob, since
+ * this is fairly expensive */
+ if (!strv_isempty(globs)) {
+ _cleanup_free_ UnitInfo *unit_infos = NULL;
+
+ r = get_unit_list(bus, &reply, &unit_infos, globs);
+ if (r < 0)
+ return r;
+
+ for (i = 0; i < r; i++)
+ if (strv_extend(&mangled, unit_infos[i].id) < 0)
+ return log_oom();
+ }
+
+ *ret = mangled;
+ mangled = NULL; /* do not free */
+ return 0;
+}
+
static const struct {
const char *target;
const char *verb;
}
static int start_unit(sd_bus *bus, char **args) {
- _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_set_free_free_ Set *s = NULL;
+ _cleanup_strv_free_ char **names = NULL;
const char *method, *mode, *one_name;
char **name;
- int r;
+ int r = 0;
assert(bus);
one_name = action_table[arg_action].target;
}
+ if (one_name)
+ names = strv_new(one_name, NULL);
+ else {
+ r = expand_names(bus, args + 1, NULL, &names);
+ if (r < 0)
+ log_error("Failed to expand names: %s", strerror(-r));
+ }
+
if (!arg_no_block) {
r = enable_wait_for_jobs(bus);
if (r < 0) {
return log_oom();
}
- if (one_name) {
- r = start_unit_one(bus, method, one_name, mode, &error, s);
- if (r < 0)
- r = translate_bus_error_to_exit_status(r, &error);
- } else {
- r = 0;
-
- STRV_FOREACH(name, args+1) {
- int q;
+ STRV_FOREACH(name, names) {
+ _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+ int q;
- q = start_unit_one(bus, method, *name, mode, &error, s);
- if (q < 0) {
- r = translate_bus_error_to_exit_status(q, &error);
- sd_bus_error_free(&error);
- }
- }
+ q = start_unit_one(bus, method, *name, mode, &error, s);
+ if (r >= 0 && q < 0)
+ r = translate_bus_error_to_exit_status(q, &error);
}
if (!arg_no_block) {
/* When stopping units, warn if they can still be triggered by
* another active unit (socket, path, timer) */
- if (!arg_quiet && streq(method, "StopUnit")) {
- if (one_name)
- check_triggering_units(bus, one_name);
- else
- STRV_FOREACH(name, args+1)
- check_triggering_units(bus, *name);
- }
+ if (!arg_quiet && streq(method, "StopUnit"))
+ STRV_FOREACH(name, names)
+ check_triggering_units(bus, *name);
}
return r;
return r;
}
-static int check_unit_active(sd_bus *bus, char **args) {
+static int check_unit_generic(sd_bus *bus, int code, const char *good_states, char **args) {
+ _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+ _cleanup_strv_free_ char **names = NULL;
char **name;
- int r = 3; /* According to LSB: "program is not running" */
+ int r = code;
assert(bus);
assert(args);
- STRV_FOREACH(name, args+1) {
+ r = expand_names(bus, args, NULL, &names);
+ if (r < 0)
+ log_error("Failed to expand names: %s", strerror(-r));
+
+ STRV_FOREACH(name, names) {
int state;
- state = check_one_unit(bus, *name, "active\0reloading\0", arg_quiet);
+ state = check_one_unit(bus, *name, good_states, arg_quiet);
if (state < 0)
return state;
if (state > 0)
return r;
}
-static int check_unit_failed(sd_bus *bus, char **args) {
- char **name;
- int r = 1;
-
- assert(bus);
- assert(args);
-
- STRV_FOREACH(name, args+1) {
- int state;
-
- state = check_one_unit(bus, *name, "failed\0", arg_quiet);
- if (state < 0)
- return state;
- if (state > 0)
- r = 0;
- }
+static int check_unit_active(sd_bus *bus, char **args) {
+ /* According to LSB: 3, "program is not running" */
+ return check_unit_generic(bus, 3, "active\0reloading\0", args + 1);
+}
- return r;
+static int check_unit_failed(sd_bus *bus, char **args) {
+ return check_unit_generic(bus, 1, "failed\0", args + 1);
}
static int kill_unit(sd_bus *bus, char **args) {
_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+ _cleanup_strv_free_ char **names = NULL;
char **name;
- int r = 0;
+ int r, q;
assert(bus);
assert(args);
if (!arg_kill_who)
arg_kill_who = "all";
- STRV_FOREACH(name, args+1) {
- _cleanup_free_ char *n = NULL;
-
- n = unit_name_mangle(*name);
- if (!n)
- return log_oom();
+ r = expand_names(bus, args + 1, NULL, &names);
+ if (r < 0)
+ log_error("Failed to expand names: %s", strerror(-r));
- r = sd_bus_call_method(
+ STRV_FOREACH(name, names) {
+ q = sd_bus_call_method(
bus,
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"KillUnit",
&error,
NULL,
- "ssi", n, arg_kill_who, arg_signal);
- if (r < 0) {
- log_error("Failed to kill unit %s: %s", n, bus_error_message(&error, r));
- return r;
+ "ssi", *names, arg_kill_who, arg_signal);
+ if (q < 0) {
+ log_error("Failed to kill unit %s: %s",
+ *names, bus_error_message(&error, r));
+ if (r == 0)
+ r = q;
}
}
- return 0;
+ return r;
}
typedef struct ExecStatusInfo {
assert(path);
assert(new_line);
+ log_debug("Showing one %s", path);
+
r = sd_bus_call_method(
bus,
"org.freedesktop.systemd1",
_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
+ char *u;
int r;
r = sd_bus_call_method(
return r;
}
- r = sd_bus_message_read(reply, "o", unit);
+ r = sd_bus_message_read(reply, "o", &u);
if (r < 0)
return bus_log_parse_error(r);
+ u = strdup(u);
+ if (!u)
+ return log_oom();
+
+ *unit = u;
return 0;
}
unsigned c;
int r;
- r = get_unit_list(bus, &reply, &unit_infos);
+ r = get_unit_list(bus, &reply, &unit_infos, NULL);
if (r < 0)
return r;
for (u = unit_infos; u < unit_infos + c; u++) {
_cleanup_free_ char *p = NULL;
- if (!output_show_unit(u, NULL))
- continue;
-
p = unit_dbus_path_from_name(u->id);
if (!p)
return log_oom();
}
static int cat(sd_bus *bus, char **args) {
- _cleanup_free_ char *unit = NULL, *n = NULL;
- int r = 0;
+ _cleanup_free_ char *unit = NULL;
+ _cleanup_strv_free_ char **names = NULL;
char **name;
+ bool first = true;
+ int r = 0;
assert(bus);
assert(args);
+ r = expand_names(bus, args + 1, NULL, &names);
+ if (r < 0)
+ log_error("Failed to expand names: %s", strerror(-r));
+
pager_open_if_enabled();
- STRV_FOREACH(name, args+1) {
+ STRV_FOREACH(name, names) {
_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_strv_free_ char **dropin_paths = NULL;
_cleanup_free_ char *fragment_path = NULL;
char **path;
- n = unit_name_mangle(*name);
- if (!n)
- return log_oom();
-
- unit = unit_dbus_path_from_name(n);
+ unit = unit_dbus_path_from_name(*name);
if (!unit)
return log_oom();
- if (need_daemon_reload(bus, n) > 0)
+ if (need_daemon_reload(bus, *name) > 0)
log_warning("Unit file of %s changed on disk. Run 'systemctl%s daemon-reload'.",
- n, arg_scope == UNIT_FILE_SYSTEM ? "" : " --user");
+ *name, arg_scope == UNIT_FILE_SYSTEM ? "" : " --user");
r = sd_bus_get_property_string(
bus,
continue;
}
+ if (first)
+ first = false;
+ else
+ puts("");
+
if (!isempty(fragment_path)) {
- fprintf(stdout, "# %s\n", fragment_path);
+ printf("%s# %s%s\n",
+ ansi_highlight_blue(),
+ fragment_path,
+ ansi_highlight_off());
fflush(stdout);
r = sendfile_full(STDOUT_FILENO, fragment_path);
}
STRV_FOREACH(path, dropin_paths) {
- fprintf(stdout, "%s# %s\n",
- isempty(fragment_path) && path == dropin_paths ? "" : "\n",
- *path);
+ printf("%s%s# %s%s\n",
+ isempty(fragment_path) && path == dropin_paths ? "" : "\n",
+ ansi_highlight_blue(),
+ *path,
+ ansi_highlight_off());
fflush(stdout);
r = sendfile_full(STDOUT_FILENO, *path);
}
static int show(sd_bus *bus, char **args) {
- int r, ret = 0;
bool show_properties, show_status, new_line = false;
- char **name;
bool ellipsized = false;
+ int r, ret = 0;
assert(bus);
assert(args);
if (show_status && strv_length(args) <= 1)
ret = show_all(args[0], bus, false, &new_line, &ellipsized);
- else
- STRV_FOREACH(name, args+1) {
+ else {
+ _cleanup_free_ char **patterns = NULL;
+ char **name;
+
+ STRV_FOREACH(name, args + 1) {
_cleanup_free_ char *unit = NULL;
uint32_t id;
if (safe_atou32(*name, &id) < 0) {
- _cleanup_free_ char *n = NULL;
- /* Interpret as unit name */
-
- n = unit_name_mangle(*name);
- if (!n)
- return log_oom();
-
- unit = unit_dbus_path_from_name(n);
- if (!unit)
+ if (strv_push(&patterns, *name) < 0)
return log_oom();
+ continue;
} else if (show_properties) {
/* Interpret as job id */
if (asprintf(&unit, "/org/freedesktop/systemd1/job/%u", id) < 0)
} else {
/* Interpret as PID */
r = get_unit_dbus_path_by_pid(bus, id, &unit);
- if (r < 0)
+ if (r < 0) {
ret = r;
+ continue;
+ }
}
show_one(args[0], bus, unit, show_properties, &new_line, &ellipsized);
}
+ if (!strv_isempty(patterns)) {
+ _cleanup_strv_free_ char **names = NULL;
+
+ r = expand_names(bus, patterns, NULL, &names);
+ if (r < 0)
+ log_error("Failed to expand names: %s", strerror(-r));
+
+ STRV_FOREACH(name, names) {
+ _cleanup_free_ char *unit;
+
+ unit = unit_dbus_path_from_name(*name);
+ if (!unit)
+ return log_oom();
+
+ show_one(args[0], bus, unit, show_properties, &new_line, &ellipsized);
+ }
+ }
+ }
+
if (ellipsized && !arg_quiet)
printf("Hint: Some lines were ellipsized, use -l to show in full.\n");
if (r < 0)
return bus_log_create_error(r);
- n = unit_name_mangle(args[1]);
+ n = unit_name_mangle(args[1], false);
if (!n)
return log_oom();
int r;
if (strv_length(args) > 1)
- n = unit_name_mangle_with_suffix(args[1], ".snapshot");
+ n = unit_name_mangle_with_suffix(args[1], false, ".snapshot");
else
n = strdup("");
if (!n)
static int delete_snapshot(sd_bus *bus, char **args) {
_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+ _cleanup_strv_free_ char **names = NULL;
char **name;
- int r;
+ int r, q;
assert(args);
- STRV_FOREACH(name, args+1) {
- _cleanup_free_ char *n = NULL;
-
- n = unit_name_mangle_with_suffix(*name, ".snapshot");
- if (!n)
- return log_oom();
+ r = expand_names(bus, args + 1, ".snapshot", &names);
+ if (r < 0)
+ log_error("Failed to expand names: %s", strerror(-r));
- r = sd_bus_call_method(
+ STRV_FOREACH(name, names) {
+ q = sd_bus_call_method(
bus,
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"RemoveSnapshot",
&error,
NULL,
- "s", n);
- if (r < 0) {
- log_error("Failed to remove snapshot %s: %s", n, bus_error_message(&error, r));
- return r;
+ "s", *name);
+ if (q < 0) {
+ log_error("Failed to remove snapshot %s: %s",
+ *name, bus_error_message(&error, r));
+ if (r == 0)
+ r = q;
}
}
- return 0;
+ return r;
}
static int daemon_reload(sd_bus *bus, char **args) {
static int reset_failed(sd_bus *bus, char **args) {
_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+ _cleanup_strv_free_ char **names = NULL;
char **name;
- int r;
+ int r, q;
if (strv_length(args) <= 1)
return daemon_reload(bus, args);
- STRV_FOREACH(name, args+1) {
- _cleanup_free_ char *n;
-
- n = unit_name_mangle(*name);
- if (!n)
- return log_oom();
+ r = expand_names(bus, args + 1, NULL, &names);
+ if (r < 0)
+ log_error("Failed to expand names: %s", strerror(-r));
- r = sd_bus_call_method(
+ STRV_FOREACH(name, names) {
+ q = sd_bus_call_method(
bus,
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"ResetFailedUnit",
&error,
NULL,
- "s", n);
- if (r < 0) {
- log_error("Failed to reset failed state of unit %s: %s", n, bus_error_message(&error, r));
- return r;
+ "s", *name);
+ if (q < 0) {
+ log_error("Failed to reset failed state of unit %s: %s",
+ *name, bus_error_message(&error, r));
+ if (r == 0)
+ r = q;
}
}
- return 0;
+ return r;
}
static int show_environment(sd_bus *bus, char **args) {
if (is_path(*name))
*i = strdup(*name);
else
- *i = unit_name_mangle(*name);
+ *i = unit_name_mangle(*name, false);
if (!*i) {
strv_free(l);
}
static int enable_unit(sd_bus *bus, char **args) {
- _cleanup_strv_free_ char **mangled_names = NULL;
+ _cleanup_strv_free_ char **names = NULL;
const char *verb = args[0];
UnitFileChange *changes = NULL;
unsigned n_changes = 0;
if (!args[1])
return 0;
- r = mangle_names(args+1, &mangled_names);
+ r = mangle_names(args+1, &names);
if (r < 0)
return r;
- r = enable_sysv_units(verb, mangled_names);
+ r = enable_sysv_units(verb, names);
if (r < 0)
return r;
if (!bus || avoid_bus()) {
if (streq(verb, "enable")) {
- r = unit_file_enable(arg_scope, arg_runtime, arg_root, mangled_names, arg_force, &changes, &n_changes);
+ r = unit_file_enable(arg_scope, arg_runtime, arg_root, names, arg_force, &changes, &n_changes);
carries_install_info = r;
} else if (streq(verb, "disable"))
- r = unit_file_disable(arg_scope, arg_runtime, arg_root, mangled_names, &changes, &n_changes);
+ r = unit_file_disable(arg_scope, arg_runtime, arg_root, names, &changes, &n_changes);
else if (streq(verb, "reenable")) {
- r = unit_file_reenable(arg_scope, arg_runtime, arg_root, mangled_names, arg_force, &changes, &n_changes);
+ r = unit_file_reenable(arg_scope, arg_runtime, arg_root, names, arg_force, &changes, &n_changes);
carries_install_info = r;
} else if (streq(verb, "link"))
- r = unit_file_link(arg_scope, arg_runtime, arg_root, mangled_names, arg_force, &changes, &n_changes);
+ r = unit_file_link(arg_scope, arg_runtime, arg_root, names, arg_force, &changes, &n_changes);
else if (streq(verb, "preset")) {
- r = unit_file_preset(arg_scope, arg_runtime, arg_root, mangled_names, arg_force, &changes, &n_changes);
+ r = unit_file_preset(arg_scope, arg_runtime, arg_root, names, arg_force, &changes, &n_changes);
carries_install_info = r;
} else if (streq(verb, "mask"))
- r = unit_file_mask(arg_scope, arg_runtime, arg_root, mangled_names, arg_force, &changes, &n_changes);
+ r = unit_file_mask(arg_scope, arg_runtime, arg_root, names, arg_force, &changes, &n_changes);
else if (streq(verb, "unmask"))
- r = unit_file_unmask(arg_scope, arg_runtime, arg_root, mangled_names, &changes, &n_changes);
+ r = unit_file_unmask(arg_scope, arg_runtime, arg_root, names, &changes, &n_changes);
else
assert_not_reached("Unknown verb");
if (r < 0)
return bus_log_create_error(r);
- r = sd_bus_message_append_strv(m, mangled_names);
+ r = sd_bus_message_append_strv(m, names);
if (r < 0)
return bus_log_create_error(r);
static int unit_is_enabled(sd_bus *bus, char **args) {
_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
- _cleanup_strv_free_ char **mangled_names = NULL;
+ _cleanup_strv_free_ char **names = NULL;
bool enabled;
char **name;
int r;
- r = mangle_names(args+1, &mangled_names);
+ r = mangle_names(args+1, &names);
if (r < 0)
return r;
- r = enable_sysv_units(args[0], mangled_names);
+ r = enable_sysv_units(args[0], names);
if (r < 0)
return r;
if (!bus || avoid_bus()) {
- STRV_FOREACH(name, mangled_names) {
+ STRV_FOREACH(name, names) {
UnitFileState state;
state = unit_file_get_state(arg_scope, arg_root, *name);
}
} else {
- STRV_FOREACH(name, mangled_names) {
+ STRV_FOREACH(name, names) {
_cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
const char *s;
~ianmdlvl / elogind.git / blobdiff