diff options
Diffstat (limited to 'src/systemctl/systemctl-enable.c')
| -rw-r--r-- | src/systemctl/systemctl-enable.c | 337 |
1 files changed, 337 insertions, 0 deletions
diff --git a/src/systemctl/systemctl-enable.c b/src/systemctl/systemctl-enable.c new file mode 100644 index 0000000..7d9b7c7 --- /dev/null +++ b/src/systemctl/systemctl-enable.c @@ -0,0 +1,337 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ + +#include "bus-error.h" +#include "bus-locator.h" +#include "locale-util.h" +#include "path-util.h" +#include "systemctl-daemon-reload.h" +#include "systemctl-enable.h" +#include "systemctl-start-unit.h" +#include "systemctl-sysv-compat.h" +#include "systemctl-util.h" +#include "systemctl.h" + +static int normalize_filenames(char **names) { + int r; + + STRV_FOREACH(u, names) + if (!path_is_absolute(*u)) { + char* normalized_path; + + if (!isempty(arg_root)) + return log_error_errno(SYNTHETIC_ERRNO(EINVAL), + "Non-absolute paths are not allowed when --root is used: %s", + *u); + + if (!strchr(*u, '/')) + return log_error_errno(SYNTHETIC_ERRNO(EINVAL), + "Link argument must contain at least one directory separator.\n" + "If you intended to link a file in the current directory, try ./%s instead.", + *u); + + r = path_make_absolute_cwd(*u, &normalized_path); + if (r < 0) + return r; + + free_and_replace(*u, normalized_path); + } + + return 0; +} + +static int normalize_names(char **names) { + bool was_path = false; + + STRV_FOREACH(u, names) { + int r; + + if (!is_path(*u)) + continue; + + r = free_and_strdup(u, basename(*u)); + if (r < 0) + return log_error_errno(r, "Failed to normalize unit file path: %m"); + + was_path = true; + } + + if (was_path) + log_warning("Warning: Can't execute disable on the unit file path. Proceeding with the unit name."); + + return 0; +} + +int verb_enable(int argc, char *argv[], void *userdata) { + _cleanup_strv_free_ char **names = NULL; + const char *verb = argv[0]; + int carries_install_info = -1; + bool ignore_carries_install_info = arg_quiet || arg_no_warn; + int r; + + if (!argv[1]) + return 0; + + r = mangle_names("to enable", strv_skip(argv, 1), &names); + if (r < 0) + return r; + + r = enable_sysv_units(verb, names); + if (r < 0) + return r; + + /* If the operation was fully executed by the SysV compat, let's finish early */ + if (strv_isempty(names)) { + if (arg_no_reload || install_client_side()) + return 0; + + r = daemon_reload(ACTION_RELOAD, /* graceful= */ false); + return r > 0 ? 0 : r; + } + + if (streq(verb, "disable")) { + r = normalize_names(names); + if (r < 0) + return r; + } + + if (streq(verb, "link")) { + r = normalize_filenames(names); + if (r < 0) + return r; + } + + if (install_client_side()) { + UnitFileFlags flags; + InstallChange *changes = NULL; + size_t n_changes = 0; + + CLEANUP_ARRAY(changes, n_changes, install_changes_free); + + flags = unit_file_flags_from_args(); + if (streq(verb, "enable")) { + r = unit_file_enable(arg_runtime_scope, flags, arg_root, names, &changes, &n_changes); + carries_install_info = r; + } else if (streq(verb, "disable")) { + r = unit_file_disable(arg_runtime_scope, flags, arg_root, names, &changes, &n_changes); + carries_install_info = r; + } else if (streq(verb, "reenable")) { + r = unit_file_reenable(arg_runtime_scope, flags, arg_root, names, &changes, &n_changes); + carries_install_info = r; + } else if (streq(verb, "link")) + r = unit_file_link(arg_runtime_scope, flags, arg_root, names, &changes, &n_changes); + else if (streq(verb, "preset")) + r = unit_file_preset(arg_runtime_scope, flags, arg_root, names, arg_preset_mode, &changes, &n_changes); + else if (streq(verb, "mask")) + r = unit_file_mask(arg_runtime_scope, flags, arg_root, names, &changes, &n_changes); + else if (streq(verb, "unmask")) + r = unit_file_unmask(arg_runtime_scope, flags, arg_root, names, &changes, &n_changes); + else if (streq(verb, "revert")) + r = unit_file_revert(arg_runtime_scope, arg_root, names, &changes, &n_changes); + else + assert_not_reached(); + + install_changes_dump(r, verb, changes, n_changes, arg_quiet); + if (r < 0) + return r; + } else { + _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL, *m = NULL; + _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL; + bool expect_carries_install_info = false; + bool send_runtime = true, send_force = true, send_preset_mode = false; + const char *method, *warn_trigger_operation = NULL; + bool warn_trigger_ignore_masked = true; /* suppress "used uninitialized" warning */ + sd_bus *bus; + + if (STR_IN_SET(verb, "mask", "unmask")) { + _cleanup_(lookup_paths_free) LookupPaths lp = {}; + + r = lookup_paths_init_or_warn(&lp, arg_runtime_scope, 0, arg_root); + if (r < 0) + return r; + + STRV_FOREACH(name, names) { + r = unit_exists(&lp, *name); + if (r < 0) + return r; + if (r == 0) + log_notice("Unit %s does not exist, proceeding anyway.", *name); + } + } + + r = acquire_bus(BUS_MANAGER, &bus); + if (r < 0) + return r; + + polkit_agent_open_maybe(); + + if (streq(verb, "enable")) { + method = "EnableUnitFiles"; + expect_carries_install_info = true; + } else if (streq(verb, "disable")) { + method = "DisableUnitFilesWithFlagsAndInstallInfo"; + expect_carries_install_info = true; + send_force = false; + + warn_trigger_operation = "Disabling"; + warn_trigger_ignore_masked = true; + } else if (streq(verb, "reenable")) { + method = "ReenableUnitFiles"; + expect_carries_install_info = true; + } else if (streq(verb, "link")) + method = "LinkUnitFiles"; + else if (streq(verb, "preset")) { + + if (arg_preset_mode != UNIT_FILE_PRESET_FULL) { + method = "PresetUnitFilesWithMode"; + send_preset_mode = true; + } else + method = "PresetUnitFiles"; + + expect_carries_install_info = true; + ignore_carries_install_info = true; + } else if (streq(verb, "mask")) { + method = "MaskUnitFiles"; + + warn_trigger_operation = "Masking"; + warn_trigger_ignore_masked = false; + } else if (streq(verb, "unmask")) { + method = "UnmaskUnitFiles"; + send_force = false; + } else if (streq(verb, "revert")) { + method = "RevertUnitFiles"; + send_runtime = send_force = false; + } else + assert_not_reached(); + + r = bus_message_new_method_call(bus, &m, bus_systemd_mgr, method); + if (r < 0) + return bus_log_create_error(r); + + r = sd_bus_message_append_strv(m, names); + if (r < 0) + return bus_log_create_error(r); + + if (send_preset_mode) { + r = sd_bus_message_append(m, "s", unit_file_preset_mode_to_string(arg_preset_mode)); + if (r < 0) + return bus_log_create_error(r); + } + + if (send_runtime) { + if (streq(method, "DisableUnitFilesWithFlagsAndInstallInfo")) + r = sd_bus_message_append(m, "t", arg_runtime ? (uint64_t) UNIT_FILE_RUNTIME : UINT64_C(0)); + else + r = sd_bus_message_append(m, "b", arg_runtime); + if (r < 0) + return bus_log_create_error(r); + } + + if (send_force) { + r = sd_bus_message_append(m, "b", arg_force); + if (r < 0) + return bus_log_create_error(r); + } + + r = sd_bus_call(bus, m, 0, &error, &reply); + if (r < 0) + return log_error_errno(r, "Failed to %s unit: %s", verb, bus_error_message(&error, r)); + + if (expect_carries_install_info) { + r = sd_bus_message_read(reply, "b", &carries_install_info); + if (r < 0) + return bus_log_parse_error(r); + } + + r = bus_deserialize_and_dump_unit_file_changes(reply, arg_quiet); + if (r < 0) + return r; + + /* Try to reload if enabled */ + if (!arg_no_reload) { + r = daemon_reload(ACTION_RELOAD, /* graceful= */ false); + if (r < 0) + return r; + } + + if (warn_trigger_operation && !arg_quiet && !arg_no_warn) + STRV_FOREACH(unit, names) + warn_triggering_units(bus, *unit, warn_trigger_operation, warn_trigger_ignore_masked); + } + + if (carries_install_info == 0 && !ignore_carries_install_info) + log_notice("The unit files have no installation config (WantedBy=, RequiredBy=, UpheldBy=,\n" + "Also=, or Alias= settings in the [Install] section, and DefaultInstance= for\n" + "template units). This means they are not meant to be enabled or disabled using systemctl.\n" + " \n" /* trick: the space is needed so that the line does not get stripped from output */ + "Possible reasons for having these kinds of units are:\n" + "%1$s A unit may be statically enabled by being symlinked from another unit's\n" + " .wants/, .requires/, or .upholds/ directory.\n" + "%1$s A unit's purpose may be to act as a helper for some other unit which has\n" + " a requirement dependency on it.\n" + "%1$s A unit may be started when needed via activation (socket, path, timer,\n" + " D-Bus, udev, scripted systemctl call, ...).\n" + "%1$s In case of template units, the unit is meant to be enabled with some\n" + " instance name specified.", + special_glyph(SPECIAL_GLYPH_BULLET)); + + if (streq(verb, "disable") && arg_runtime_scope == RUNTIME_SCOPE_USER && !arg_quiet && !arg_no_warn) { + /* If some of the units are disabled in user scope but still enabled in global scope, + * we emit a warning for that. */ + + /* No strv_free here, strings are owned by 'names' */ + _cleanup_free_ char **enabled_in_global_scope = NULL; + + STRV_FOREACH(name, names) { + UnitFileState state; + + r = unit_file_get_state(RUNTIME_SCOPE_GLOBAL, arg_root, *name, &state); + if (r == -ENOENT) + continue; + if (r < 0) + return log_error_errno(r, "Failed to get unit file state for %s: %m", *name); + + if (IN_SET(state, UNIT_FILE_ENABLED, UNIT_FILE_ENABLED_RUNTIME)) { + r = strv_push(&enabled_in_global_scope, *name); + if (r < 0) + return log_oom(); + } + } + + if (!strv_isempty(enabled_in_global_scope)) { + _cleanup_free_ char *joined = NULL; + + joined = strv_join(enabled_in_global_scope, ", "); + if (!joined) + return log_oom(); + + log_notice("The following unit files have been enabled in global scope. This means\n" + "they will still be started automatically after a successful disablement\n" + "in user scope:\n" + "%s", + joined); + } + } + + if (arg_now && STR_IN_SET(argv[0], "enable", "disable", "mask")) { + sd_bus *bus; + size_t len, i; + + r = acquire_bus(BUS_MANAGER, &bus); + if (r < 0) + return r; + + len = strv_length(names); + { + char *new_args[len + 2]; + + new_args[0] = (char*) (streq(argv[0], "enable") ? "start" : "stop"); + for (i = 0; i < len; i++) + new_args[i + 1] = basename(names[i]); + new_args[i + 1] = NULL; + + r = verb_start(len + 1, new_args, userdata); + } + } + + return 0; +} |