#include "bus-util.h"
#include "bus-message.h"
#include "bus-error.h"
-#include "bus-errors.h"
+#include "bus-common-errors.h"
+#include "mkdir.h"
static char **arg_types = NULL;
static char **arg_states = NULL;
/* Note: triggered is a list here, although it almost certainly
* will always be one unit. Nevertheless, dbus API allows for multiple
- * values, so let's follow that.*/
+ * values, so let's follow that. */
char** triggered;
/* The strv above is shared. free is set only in the first one. */
return b;
}
+static void warn_unit_file_changed(const char *name) {
+ log_warning("%sWarning:%s %s changed on disk. Run 'systemctl%s daemon-reload' to reload units.",
+ ansi_highlight_red(),
+ ansi_highlight_off(),
+ name,
+ arg_scope == UNIT_FILE_SYSTEM ? "" : " --user");
+}
+
+static int unit_file_find_path(LookupPaths *lp, const char *unit_name, char **unit_path) {
+ char **p;
+
+ assert(lp);
+ assert(unit_name);
+ assert(unit_path);
+
+ STRV_FOREACH(p, lp->unit_path) {
+ char *path;
+
+ path = path_join(arg_root, *p, unit_name);
+ if (!path)
+ return log_oom();
+
+ if (access(path, F_OK) == 0) {
+ *unit_path = path;
+ return 1;
+ }
+
+ free(path);
+ }
+
+ return 0;
+}
+
+static int unit_find_path(sd_bus *bus, const char *unit_name, const char *template, bool avoid_bus_cache, LookupPaths *lp, char **path) {
+ int r;
+
+ assert(unit_name);
+ assert(path);
+ assert(lp);
+
+ if (!avoid_bus_cache && !unit_name_is_template(unit_name)) {
+ _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+ _cleanup_free_ char *unit = NULL;
+ _cleanup_free_ char *tmp_path = NULL;
+
+ unit = unit_dbus_path_from_name(unit_name);
+ if (!unit)
+ return log_oom();
+
+ if (need_daemon_reload(bus, unit_name) > 0) {
+ warn_unit_file_changed(unit_name);
+ return 0;
+ }
+
+ r = sd_bus_get_property_string(
+ bus,
+ "org.freedesktop.systemd1",
+ unit,
+ "org.freedesktop.systemd1.Unit",
+ "FragmentPath",
+ &error,
+ &tmp_path);
+ if (r < 0) {
+ log_warning("Failed to get FragmentPath: %s", bus_error_message(&error, r));
+ return 0;
+ }
+
+ if (isempty(tmp_path)) {
+ log_warning("%s ignored: not found", template);
+ return 0;
+ }
+
+ *path = tmp_path;
+ tmp_path = NULL;
+
+ return 1;
+ } else {
+ r = unit_file_find_path(lp, template, path);
+ if (r == 0)
+ log_warning("%s ignored: not found", template);
+ return r;
+ }
+
+ return 0;
+}
+
typedef struct WaitData {
Set *set;
assert(d->result);
if (!arg_quiet) {
- if (streq(d->result, "timeout"))
- log_error("Job for %s timed out.", strna(d->name));
- else if (streq(d->result, "canceled"))
+ if (streq(d->result, "canceled"))
log_error("Job for %s canceled.", strna(d->name));
+ else if (streq(d->result, "timeout"))
+ log_error("Job for %s timed out.", strna(d->name));
else if (streq(d->result, "dependency"))
log_error("A dependency job for %s failed. See 'journalctl -xe' for details.", strna(d->name));
+ else if (streq(d->result, "invalid"))
+ log_error("Job for %s invalid.", strna(d->name));
+ else if (streq(d->result, "assert"))
+ log_error("Assertion failed on job for %s.", strna(d->name));
+ else if (streq(d->result, "unsupported"))
+ log_error("Operation on or unit type of %s not supported on this system.", strna(d->name));
else if (!streq(d->result, "done") && !streq(d->result, "skipped")) {
if (d->name) {
bool quotes;
}
}
- if (streq(d->result, "timeout"))
- r = -ETIME;
- else if (streq(d->result, "canceled"))
+ if (streq(d->result, "canceled"))
r = -ECANCELED;
+ else if (streq(d->result, "timeout"))
+ r = -ETIME;
else if (streq(d->result, "dependency"))
r = -EIO;
+ else if (streq(d->result, "invalid"))
+ r = -ENOEXEC;
+ else if (streq(d->result, "assert"))
+ r = -EPROTO;
+ else if (streq(d->result, "unsupported"))
+ r = -ENOTSUP;
else if (!streq(d->result, "done") && !streq(d->result, "skipped"))
r = -EIO;
return bus_log_parse_error(r);
if (need_daemon_reload(bus, name) > 0)
- log_warning("Warning: Unit file of %s changed on disk, 'systemctl%s daemon-reload' recommended.",
- name, arg_scope == UNIT_FILE_SYSTEM ? "" : " --user");
+ warn_unit_file_changed(name);
if (s) {
char *p;
const char *active_state;
const char *sub_state;
const char *unit_file_state;
+ const char *unit_file_preset;
const char *description;
const char *following;
if (i->load_error)
printf(" Loaded: %s%s%s (Reason: %s)\n",
on, strna(i->load_state), off, i->load_error);
- else if (path && i->unit_file_state)
+ else if (path && !isempty(i->unit_file_state) && !isempty(i->unit_file_preset))
+ printf(" Loaded: %s%s%s (%s; %s; vendor preset: %s)\n",
+ on, strna(i->load_state), off, path, i->unit_file_state, i->unit_file_preset);
+ else if (path && !isempty(i->unit_file_state))
printf(" Loaded: %s%s%s (%s; %s)\n",
on, strna(i->load_state), off, path, i->unit_file_state);
else if (path)
}
if (i->need_daemon_reload)
- printf("\n%sWarning:%s Unit file changed on disk, 'systemctl %sdaemon-reload' recommended.\n",
- ansi_highlight_red(),
- ansi_highlight_off(),
- arg_scope == UNIT_FILE_SYSTEM ? "" : "--user ");
+ warn_unit_file_changed(i->id);
}
static void show_unit_help(UnitStatusInfo *i) {
i->following = s;
else if (streq(name, "UnitFileState"))
i->unit_file_state = s;
+ else if (streq(name, "UnitFilePreset"))
+ i->unit_file_preset = s;
else if (streq(name, "Result"))
i->result = s;
}
return log_oom();
if (need_daemon_reload(bus, *name) > 0)
- log_warning("Unit file of %s changed on disk. Run 'systemctl%s daemon-reload'.",
- *name, arg_scope == UNIT_FILE_SYSTEM ? "" : " --user");
+ warn_unit_file_changed(*name);
r = sd_bus_get_property_string(
bus,
ansi_highlight_off());
fflush(stdout);
- r = copy_file_fd(fragment_path, STDOUT_FILENO);
+ r = copy_file_fd(fragment_path, STDOUT_FILENO, false);
if (r < 0) {
log_warning_errno(r, "Failed to cat %s: %m", fragment_path);
continue;
ansi_highlight_off());
fflush(stdout);
- r = copy_file_fd(*path, STDOUT_FILENO);
+ r = copy_file_fd(*path, STDOUT_FILENO, false);
if (r < 0) {
log_warning_errno(r, "Failed to cat %s: %m", *path);
continue;
int r = 0;
#if defined(HAVE_SYSV_COMPAT) && defined(HAVE_CHKCONFIG)
- unsigned f = 1, t = 1;
+ unsigned f = 0;
_cleanup_lookup_paths_free_ LookupPaths paths = {};
if (arg_scope != UNIT_FILE_SYSTEM)
return r;
r = 0;
- for (f = 0; args[f]; f++) {
+ while (args[f]) {
const char *name;
_cleanup_free_ char *p = NULL, *q = NULL, *l = NULL;
bool found_native = false, found_sysv;
pid_t pid;
siginfo_t status;
- name = args[f];
+ name = args[f++];
if (!endswith(name, ".service"))
continue;
if (!found_sysv)
continue;
- /* Mark this entry, so that we don't try enabling it as native unit */
- args[f] = (char*) "";
-
log_info("%s is not a native service, redirecting to /sbin/chkconfig.", name);
if (!isempty(arg_root))
return -EINVAL;
} else
return -EPROTO;
- }
-
- /* Drop all SysV units */
- for (f = 0, t = 0; args[f]; f++) {
-
- if (isempty(args[f]))
- continue;
- args[t++] = args[f];
+ /* Remove this entry, so that we don't try enabling it as native unit */
+ assert(f > 0 && streq(args[f-1], name));
+ assert_se(strv_remove(args + f - 1, name));
}
- args[t] = NULL;
-
#endif
return r;
}
return streq(state, "running") ? EXIT_SUCCESS : EXIT_FAILURE;
}
+static int create_edit_temp_file(const char *new_path, const char *original_path, char **ret_tmp_fn) {
+ char *t;
+ int r;
+
+ assert(new_path);
+ assert(original_path);
+ assert(ret_tmp_fn);
+
+ r = tempfn_random(new_path, &t);
+ if (r < 0)
+ return log_error_errno(r, "Failed to determine temporary filename for %s: %m", new_path);
+
+ r = mkdir_parents(new_path, 0755);
+ if (r < 0) {
+ log_error_errno(r, "Failed to create directories for %s: %m", new_path);
+ free(t);
+ return r;
+ }
+
+ r = copy_file(original_path, t, 0, 0644);
+ if (r == -ENOENT) {
+ r = touch(t);
+ if (r < 0) {
+ log_error_errno(r, "Failed to create temporary file %s: %m", t);
+ free(t);
+ return r;
+ }
+ } else if (r < 0) {
+ log_error_errno(r, "Failed to copy %s to %s: %m", original_path, t);
+ free(t);
+ return r;
+ }
+
+ *ret_tmp_fn = t;
+
+ return 0;
+}
+
+static int get_drop_in_to_edit(const char *unit_name, const char *user_home, const char *user_runtime, char **ret_path) {
+ char *tmp_new_path;
+ char *tmp;
+
+ assert(unit_name);
+ assert(ret_path);
+
+ switch (arg_scope) {
+ case UNIT_FILE_SYSTEM:
+ tmp = strappenda(arg_runtime ? "/run/systemd/system/" : SYSTEM_CONFIG_UNIT_PATH "/", unit_name, ".d/override.conf");
+ break;
+ case UNIT_FILE_GLOBAL:
+ tmp = strappenda(arg_runtime ? "/run/systemd/user/" : USER_CONFIG_UNIT_PATH "/", unit_name, ".d/override.conf");
+ break;
+ case UNIT_FILE_USER:
+ assert(user_home);
+ assert(user_runtime);
+
+ tmp = strappenda(arg_runtime ? user_runtime : user_home, "/", unit_name, ".d/override.conf");
+ break;
+ default:
+ assert_not_reached("Invalid scope");
+ }
+
+ tmp_new_path = path_join(arg_root, tmp, NULL);
+ if (!tmp_new_path)
+ return log_oom();
+
+ *ret_path = tmp_new_path;
+
+ return 0;
+}
+
+static int unit_file_create_drop_in(const char *unit_name, const char *user_home, const char *user_runtime, char **ret_new_path, char **ret_tmp_path) {
+ char *tmp_new_path;
+ char *tmp_tmp_path;
+ int r;
+
+ assert(unit_name);
+ assert(ret_new_path);
+ assert(ret_tmp_path);
+
+ r = get_drop_in_to_edit(unit_name, user_home, user_runtime, &tmp_new_path);
+ if (r < 0)
+ return r;
+
+ r = create_edit_temp_file(tmp_new_path, tmp_new_path, &tmp_tmp_path);
+ if (r < 0) {
+ free(tmp_new_path);
+ return r;
+ }
+
+ *ret_new_path = tmp_new_path;
+ *ret_tmp_path = tmp_tmp_path;
+
+ return 0;
+}
+
+static bool unit_is_editable(const char *unit_name, const char *fragment_path, const char *user_home) {
+ bool editable = true;
+ const char *invalid_path;
+
+ assert(unit_name);
+
+ if (!arg_runtime)
+ return true;
+
+ switch (arg_scope) {
+ case UNIT_FILE_SYSTEM:
+ if (path_startswith(fragment_path, "/etc/systemd/system")) {
+ editable = false;
+ invalid_path = "/etc/systemd/system";
+ } else if (path_startswith(fragment_path, SYSTEM_CONFIG_UNIT_PATH)) {
+ editable = false;
+ invalid_path = SYSTEM_CONFIG_UNIT_PATH;
+ }
+ break;
+ case UNIT_FILE_GLOBAL:
+ if (path_startswith(fragment_path, "/etc/systemd/user")) {
+ editable = false;
+ invalid_path = "/etc/systemd/user";
+ } else if (path_startswith(fragment_path, USER_CONFIG_UNIT_PATH)) {
+ editable = false;
+ invalid_path = USER_CONFIG_UNIT_PATH;
+ }
+ break;
+ case UNIT_FILE_USER:
+ assert(user_home);
+
+ if (path_startswith(fragment_path, "/etc/systemd/user")) {
+ editable = false;
+ invalid_path = "/etc/systemd/user";
+ } else if (path_startswith(fragment_path, USER_CONFIG_UNIT_PATH)) {
+ editable = false;
+ invalid_path = USER_CONFIG_UNIT_PATH;
+ } else if (path_startswith(fragment_path, user_home)) {
+ editable = false;
+ invalid_path = user_home;
+ }
+ break;
+ default:
+ assert_not_reached("Invalid scope");
+ }
+
+ if (!editable)
+ log_error("%s ignored: cannot temporarily edit units from %s", unit_name, invalid_path);
+
+ return editable;
+}
+
+static int get_copy_to_edit(const char *unit_name, const char *fragment_path, const char *user_home, const char *user_runtime, char **ret_path) {
+ char *tmp_new_path;
+
+ assert(unit_name);
+ assert(ret_path);
+
+ if (!unit_is_editable(unit_name, fragment_path, user_home))
+ return -EINVAL;
+
+ switch (arg_scope) {
+ case UNIT_FILE_SYSTEM:
+ tmp_new_path = path_join(arg_root, arg_runtime ? "/run/systemd/system/" : SYSTEM_CONFIG_UNIT_PATH, unit_name);
+ break;
+ case UNIT_FILE_GLOBAL:
+ tmp_new_path = path_join(arg_root, arg_runtime ? "/run/systemd/user/" : USER_CONFIG_UNIT_PATH, unit_name);
+ break;
+ case UNIT_FILE_USER:
+ assert(user_home);
+ assert(user_runtime);
+
+ tmp_new_path = path_join(arg_root, arg_runtime ? user_runtime : user_home, unit_name);
+ break;
+ default:
+ assert_not_reached("Invalid scope");
+ }
+ if (!tmp_new_path)
+ return log_oom();
+
+ *ret_path = tmp_new_path;
+
+ return 0;
+}
+
+static int unit_file_create_copy(const char *unit_name,
+ const char *fragment_path,
+ const char *user_home,
+ const char *user_runtime,
+ char **ret_new_path,
+ char **ret_tmp_path) {
+ char *tmp_new_path;
+ char *tmp_tmp_path;
+ int r;
+
+ assert(fragment_path);
+ assert(unit_name);
+ assert(ret_new_path);
+ assert(ret_tmp_path);
+
+ r = get_copy_to_edit(unit_name, fragment_path, user_home, user_runtime, &tmp_new_path);
+ if (r < 0)
+ return r;
+
+ if (!path_equal(fragment_path, tmp_new_path) && access(tmp_new_path, F_OK) == 0) {
+ char response;
+
+ r = ask_char(&response, "yn", "%s already exists, are you sure to overwrite it with %s? [(y)es, (n)o] ", tmp_new_path, fragment_path);
+ if (r < 0) {
+ free(tmp_new_path);
+ return r;
+ }
+ if (response != 'y') {
+ log_warning("%s ignored", unit_name);
+ free(tmp_new_path);
+ return -1;
+ }
+ }
+
+ r = create_edit_temp_file(tmp_new_path, fragment_path, &tmp_tmp_path);
+ if (r < 0) {
+ log_error_errno(r, "Failed to create temporary file for %s: %m", tmp_new_path);
+ free(tmp_new_path);
+ return r;
+ }
+
+ *ret_new_path = tmp_new_path;
+ *ret_tmp_path = tmp_tmp_path;
+
+ return 0;
+}
+
+static int run_editor(char **paths) {
+ pid_t pid;
+ int r;
+
+ assert(paths);
+
+ pid = fork();
+ if (pid < 0) {
+ log_error_errno(errno, "Failed to fork: %m");
+ return -errno;
+ }
+
+ if (pid == 0) {
+ const char **args;
+ char **backup_editors = STRV_MAKE("nano", "vim", "vi");
+ char *editor;
+ char **tmp_path, **original_path, **p;
+ unsigned i = 1;
+ size_t argc;
+
+ argc = strv_length(paths)/2 + 1;
+ args = newa(const char*, argc + 1);
+
+ args[0] = NULL;
+ STRV_FOREACH_PAIR(original_path, tmp_path, paths) {
+ args[i] = *tmp_path;
+ i++;
+ }
+ args[argc] = NULL;
+
+ /* SYSTEMD_EDITOR takes precedence over EDITOR which takes precedence over VISUAL
+ * If neither SYSTEMD_EDITOR nor EDITOR nor VISUAL are present,
+ * we try to execute well known editors
+ */
+ editor = getenv("SYSTEMD_EDITOR");
+ if (!editor)
+ editor = getenv("EDITOR");
+ if (!editor)
+ editor = getenv("VISUAL");
+
+ if (!isempty(editor)) {
+ args[0] = editor;
+ execvp(editor, (char* const*) args);
+ }
+
+ STRV_FOREACH(p, backup_editors) {
+ args[0] = *p;
+ execvp(*p, (char* const*) args);
+ /* We do not fail if the editor doesn't exist
+ * because we want to try each one of them before
+ * failing.
+ */
+ if (errno != ENOENT) {
+ log_error("Failed to execute %s: %m", editor);
+ _exit(EXIT_FAILURE);
+ }
+ }
+
+ log_error("Cannot edit unit(s): No editor available. Please set either SYSTEMD_EDITOR or EDITOR or VISUAL environment variable");
+ _exit(EXIT_FAILURE);
+ }
+
+ r = wait_for_terminate_and_warn("editor", pid, true);
+ if (r < 0)
+ return log_error_errno(r, "Failed to wait for child: %m");
+
+ return r;
+}
+
+static int find_paths_to_edit(sd_bus *bus, char **names, char ***paths) {
+ _cleanup_free_ char *user_home = NULL;
+ _cleanup_free_ char *user_runtime = NULL;
+ _cleanup_lookup_paths_free_ LookupPaths lp = {};
+ bool avoid_bus_cache;
+ char **name;
+ int r;
+
+ assert(names);
+ assert(paths);
+
+ if (arg_scope == UNIT_FILE_USER) {
+ r = user_config_home(&user_home);
+ if (r < 0)
+ return log_error_errno(r, "Failed to query XDG_CONFIG_HOME: %m");
+ else if (r == 0)
+ return log_error_errno(ENOTDIR, "Cannot edit units: $XDG_CONFIG_HOME and $HOME are not set.");
+
+ r = user_runtime_dir(&user_runtime);
+ if (r < 0)
+ return log_error_errno(r, "Failed to query XDG_CONFIG_HOME: %m");
+ else if (r == 0)
+ return log_error_errno(ENOTDIR, "Cannot edit units: $XDG_RUNTIME_DIR is not set.");
+ }
+
+ r = lookup_paths_init(&lp,
+ arg_scope == UNIT_FILE_SYSTEM ? SYSTEMD_SYSTEM : SYSTEMD_USER,
+ arg_scope == UNIT_FILE_USER,
+ arg_root,
+ NULL, NULL, NULL);
+ if (r < 0)
+ return log_error_errno(r, "Failed get lookup paths: %m");
+
+ avoid_bus_cache = !bus || avoid_bus();
+
+ STRV_FOREACH(name, names) {
+ _cleanup_free_ char *path = NULL;
+ _cleanup_free_ char *template = NULL;
+ char *new_path, *tmp_path;
+
+ template = unit_name_template(*name);
+ if (!template)
+ return log_oom();
+
+ r = unit_find_path(bus, *name, template, avoid_bus_cache, &lp, &path);
+ if (r < 0)
+ return r;
+ else if (r == 0) {
+ continue;
+ }
+
+ if (arg_full)
+ r = unit_file_create_copy(template, path, user_home, user_runtime, &new_path, &tmp_path);
+ else
+ r = unit_file_create_drop_in(template, user_home, user_runtime, &new_path, &tmp_path);
+
+ if (r < 0)
+ continue;
+
+ r = strv_push_pair(paths, new_path, tmp_path);
+ if (r < 0)
+ return log_oom();
+ }
+
+ return 0;
+}
+
+static int edit(sd_bus *bus, char **args) {
+ _cleanup_strv_free_ char **names = NULL;
+ _cleanup_strv_free_ char **paths = NULL;
+ char **original, **tmp;
+ int r;
+
+ assert(args);
+
+ if (!on_tty()) {
+ log_error("Cannot edit units if we are not on a tty");
+ return -EINVAL;
+ }
+
+ if (arg_transport != BUS_TRANSPORT_LOCAL) {
+ log_error("Cannot remotely edit units");
+ return -EINVAL;
+ }
+
+ r = expand_names(bus, args + 1, NULL, &names);
+ if (r < 0)
+ return log_error_errno(r, "Failed to expand names: %m");
+
+ if (!names) {
+ log_error("No unit name found by expanding names");
+ return -ENOENT;
+ }
+
+ r = find_paths_to_edit(bus, names, &paths);
+ if (r < 0)
+ return r;
+
+ if (strv_isempty(paths)) {
+ log_error("Cannot find any units to edit");
+ return -ENOENT;
+ }
+
+ r = run_editor(paths);
+ if (r < 0)
+ goto end;
+
+ STRV_FOREACH_PAIR(original, tmp, paths) {
+ /* If the temporary file is empty we ignore it.
+ * It's useful if the user wants to cancel its modification
+ */
+ if (null_or_empty_path(*tmp)) {
+ log_warning("Edition of %s canceled: temporary file empty", *original);
+ continue;
+ }
+ r = rename(*tmp, *original);
+ if (r < 0) {
+ r = log_error_errno(errno, "Failed to rename %s to %s: %m", *tmp, *original);
+ goto end;
+ }
+ }
+
+ if (!arg_no_reload && bus && !avoid_bus())
+ r = daemon_reload(bus, args);
+
+end:
+ STRV_FOREACH_PAIR(original, tmp, paths)
+ unlink_noerrno(*tmp);
+
+ return r;
+}
+
static void systemctl_help(void) {
pager_open_if_enabled();
" add-requires TARGET NAME... Add 'Requires' dependency for the target\n"
" on specified one or more units\n"
" get-default Get the name of the default target\n"
- " set-default NAME Set the default target\n\n"
+ " set-default NAME Set the default target\n"
+ " edit NAME... Edit one or more unit files\n"
+ "\n"
"Machine Commands:\n"
" list-machines [PATTERN...] List local containers and host\n\n"
"Job Commands:\n"
return -errno;
}
- errno = 0;
- r = loop_write(fd, &request, sizeof(request), false) != sizeof(request);
- if (r) {
- log_error_errno(errno, "Failed to write to "INIT_FIFO": %m");
- return errno > 0 ? -errno : -EIO;
- }
+ r = loop_write(fd, &request, sizeof(request), false);
+ if (r < 0)
+ return log_error_errno(r, "Failed to write to "INIT_FIFO": %m");
return 1;
}
{ "get-default", EQUAL, 1, get_default, NOBUS },
{ "set-property", MORE, 3, set_property },
{ "is-system-running", EQUAL, 1, is_system_running },
- { "add-wants", MORE, 3, add_dependency, NOBUS },
- { "add-requires", MORE, 3, add_dependency, NOBUS },
+ { "add-wants", MORE, 3, add_dependency, NOBUS },
+ { "add-requires", MORE, 3, add_dependency, NOBUS },
+ { "edit", MORE, 2, edit, NOBUS },
{}
}, *verb = verbs;
~ianmdlvl / elogind.git / blobdiff