X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Fsystemctl%2Fsystemctl.c;h=12dce3c00139171b801b1cf39256ea89d50dfcaf;hp=e445b50ab881cc2b14cffb5ce98dd1aaa2ae9127;hb=991f2a3932e831ccac609ba88f6e725b6c01acfe;hpb=5a8e9427a6db2af25c1ae628ad6caea0c64a11ec diff --git a/src/systemctl/systemctl.c b/src/systemctl/systemctl.c index e445b50ab..12dce3c00 100644 --- a/src/systemctl/systemctl.c +++ b/src/systemctl/systemctl.c @@ -68,9 +68,9 @@ #include "socket-util.h" #include "fileio.h" -static const char *arg_type = NULL; -static const char *arg_load_state = NULL; -static char **arg_property = NULL; +static char **arg_types = NULL; +static char **arg_load_states = NULL; +static char **arg_properties = NULL; static bool arg_all = false; static const char *arg_job_mode = "replace"; static UnitFileScope arg_scope = UNIT_FILE_SYSTEM; @@ -80,6 +80,7 @@ static bool arg_no_pager = false; static bool arg_no_wtmp = false; static bool arg_no_wall = false; static bool arg_no_reload = false; +static bool arg_show_types = false; static bool arg_ignore_inhibitors = false; static bool arg_dry = false; static bool arg_quiet = false; @@ -295,9 +296,9 @@ static bool output_show_unit(const struct unit_info *u) { if (arg_failed) return streq(u->active_state, "failed"); - return (!arg_type || ((dot = strrchr(u->id, '.')) && - streq(dot+1, arg_type))) && - (!arg_load_state || streq(u->load_state, arg_load_state)) && + return (!arg_types || ((dot = strrchr(u->id, '.')) && + strv_find(arg_types, dot+1))) && + (!arg_load_states || strv_find(arg_load_states, u->load_state)) && (arg_all || !(streq(u->active_state, "inactive") || u->following[0]) || u->job_id > 0); } @@ -353,8 +354,8 @@ static void output_units_list(const struct unit_info *unit_infos, unsigned c) { for (u = unit_infos; u < unit_infos + c; u++) { char _cleanup_free_ *e = NULL; - const char *on_loaded, *off_loaded; - const char *on_active, *off_active; + const char *on_loaded, *off_loaded, *on = ""; + const char *on_active, *off_active, *off = ""; if (!output_show_unit(u)) continue; @@ -373,21 +374,21 @@ static void output_units_list(const struct unit_info *unit_infos, unsigned c) { n_shown++; if (streq(u->load_state, "error")) { - on_loaded = ansi_highlight_red(true); - off_loaded = ansi_highlight_red(false); + on_loaded = on = ansi_highlight_red(true); + off_loaded = off = ansi_highlight_red(false); } else on_loaded = off_loaded = ""; if (streq(u->active_state, "failed")) { - on_active = ansi_highlight_red(true); - off_active = ansi_highlight_red(false); + on_active = on = ansi_highlight_red(true); + off_active = off = ansi_highlight_red(false); } else on_active = off_active = ""; e = arg_full ? NULL : ellipsize(u->id, id_len, 33); - printf("%-*s %s%-6s%s %s%-*s %-*s%s %-*s", - id_len, e ? e : u->id, + printf("%s%-*s%s %s%-6s%s %s%-*s %-*s%s %-*s", + on, id_len, e ? e : u->id, off, on_loaded, u->load_state, off_loaded, on_active, active_len, u->active_state, sub_len, u->sub_state, off_active, @@ -429,7 +430,7 @@ static void output_units_list(const struct unit_info *unit_infos, unsigned c) { static int get_unit_list(DBusConnection *bus, DBusMessage **reply, struct unit_info **unit_infos, unsigned *c) { DBusMessageIter iter, sub; - unsigned n_units = 0; + size_t size = 0; int r; assert(bus); @@ -458,47 +459,300 @@ static int get_unit_list(DBusConnection *bus, DBusMessage **reply, dbus_message_iter_recurse(&iter, &sub); while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) { - struct unit_info *u; + if (!GREEDY_REALLOC(*unit_infos, size, *c + 1)) + return log_oom(); - if (*c >= n_units) { - struct unit_info *w; + bus_parse_unit_info(&sub, *unit_infos + *c); + (*c)++; - n_units = MAX(2 * *c, 16u); - w = realloc(*unit_infos, sizeof(struct unit_info) * n_units); - if (!w) - return log_oom(); + dbus_message_iter_next(&sub); + } + + return 0; +} - *unit_infos = w; +static int list_units(DBusConnection *bus, char **args) { + _cleanup_dbus_message_unref_ DBusMessage *reply = NULL; + _cleanup_free_ struct unit_info *unit_infos = NULL; + unsigned c = 0; + int r; + + pager_open_if_enabled(); + + r = get_unit_list(bus, &reply, &unit_infos, &c); + if (r < 0) + return r; + + qsort(unit_infos, c, sizeof(struct unit_info), compare_unit_info); + + output_units_list(unit_infos, c); + + return 0; +} + +static int get_triggered_units(DBusConnection *bus, const char* unit_path, + char*** triggered) +{ + const char *interface = "org.freedesktop.systemd1.Unit", + *triggers_property = "Triggers"; + DBusMessage _cleanup_dbus_message_unref_ *reply = NULL; + DBusMessageIter iter, sub; + int r; + + r = bus_method_call_with_reply(bus, + "org.freedesktop.systemd1", + unit_path, + "org.freedesktop.DBus.Properties", + "Get", + &reply, + NULL, + DBUS_TYPE_STRING, &interface, + DBUS_TYPE_STRING, &triggers_property, + DBUS_TYPE_INVALID); + if (r < 0) + return r; + + if (!dbus_message_iter_init(reply, &iter) || + dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT) { + log_error("Failed to parse reply."); + return -EBADMSG; + } + + dbus_message_iter_recurse(&iter, &sub); + dbus_message_iter_recurse(&sub, &iter); + sub = iter; + + while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) { + const char *unit; + + if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRING) { + log_error("Failed to parse reply."); + return -EBADMSG; } - u = *unit_infos + *c; + dbus_message_iter_get_basic(&sub, &unit); + r = strv_extend(triggered, unit); + if (r < 0) + return r; + + dbus_message_iter_next(&sub); + } + + return 0; +} - bus_parse_unit_info(&sub, u); +static int get_listening(DBusConnection *bus, const char* unit_path, + char*** listen, unsigned *c) +{ + const char *interface = "org.freedesktop.systemd1.Socket", + *listen_property = "Listen"; + DBusMessage _cleanup_dbus_message_unref_ *reply = NULL; + DBusMessageIter iter, sub; + int r; + + r = bus_method_call_with_reply(bus, + "org.freedesktop.systemd1", + unit_path, + "org.freedesktop.DBus.Properties", + "Get", + &reply, + NULL, + DBUS_TYPE_STRING, &interface, + DBUS_TYPE_STRING, &listen_property, + DBUS_TYPE_INVALID); + if (r < 0) + return r; + + if (!dbus_message_iter_init(reply, &iter) || + dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT) { + log_error("Failed to parse reply."); + return -EBADMSG; + } + + dbus_message_iter_recurse(&iter, &sub); + dbus_message_iter_recurse(&sub, &iter); + sub = iter; + + while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) { + DBusMessageIter sub2; + const char *type, *path; + + if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) { + log_error("Failed to parse reply."); + return -EBADMSG; + } + + dbus_message_iter_recurse(&sub, &sub2); + + if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &type, true) >= 0 && + bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &path, false) >= 0) { + r = strv_extend(listen, type); + if (r < 0) + return r; + + r = strv_extend(listen, path); + if (r < 0) + return r; + + (*c) ++; + } dbus_message_iter_next(&sub); - (*c)++; } - if (*c > 0) - qsort(*unit_infos, *c, sizeof(struct unit_info), compare_unit_info); + return 0; +} + +struct socket_info { + const char* id; + + char* type; + char* path; + + /* 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.*/ + char** triggered; + + /* The strv above is shared. free is set only in the first one. */ + bool own_triggered; +}; + +static int socket_info_compare(struct socket_info *a, struct socket_info *b) { + int o = strcmp(a->path, b->path); + if (o == 0) + o = strcmp(a->type, b->type); + return o; +} + +static int output_sockets_list(struct socket_info *socket_infos, unsigned cs) { + struct socket_info *s; + unsigned pathlen = sizeof("LISTEN") - 1, + typelen = (sizeof("TYPE") - 1) * arg_show_types, + socklen = sizeof("UNIT") - 1, + servlen = sizeof("ACTIVATES") - 1; + const char *on, *off; + + for (s = socket_infos; s < socket_infos + cs; s++) { + char **a; + unsigned tmp = 0; + + socklen = MAX(socklen, strlen(s->id)); + if (arg_show_types) + typelen = MAX(typelen, strlen(s->type)); + pathlen = MAX(pathlen, strlen(s->path)); + + STRV_FOREACH(a, s->triggered) + tmp += strlen(*a) + 2*(a != s->triggered); + servlen = MAX(servlen, tmp); + } + + if (cs) { + printf("%-*s %-*.*s%-*s %s\n", + pathlen, "LISTEN", + typelen + arg_show_types, typelen + arg_show_types, "TYPE ", + socklen, "UNIT", + "ACTIVATES"); + + for (s = socket_infos; s < socket_infos + cs; s++) { + char **a; + + if (arg_show_types) + printf("%-*s %-*s %-*s", + pathlen, s->path, typelen, s->type, socklen, s->id); + else + printf("%-*s %-*s", + pathlen, s->path, socklen, s->id); + STRV_FOREACH(a, s->triggered) + printf("%s %s", + a == s->triggered ? "" : ",", *a); + printf("\n"); + } + + on = ansi_highlight(true); + off = ansi_highlight(false); + printf("\n"); + } else { + on = ansi_highlight_red(true); + off = ansi_highlight_red(false); + } + + printf("%s%u sockets listed.%s\n", on, cs, off); + if (!arg_all) + printf("Pass --all to see loaded but inactive sockets, too.\n"); return 0; } -static int list_units(DBusConnection *bus, char **args) { +static int list_sockets(DBusConnection *bus, char **args) { _cleanup_dbus_message_unref_ DBusMessage *reply = NULL; _cleanup_free_ struct unit_info *unit_infos = NULL; - unsigned c = 0; + struct socket_info *socket_infos = NULL; + const struct unit_info *u; + struct socket_info *s; + unsigned cu = 0, cs = 0; + size_t size = 0; int r; pager_open_if_enabled(); - r = get_unit_list(bus, &reply, &unit_infos, &c); + r = get_unit_list(bus, &reply, &unit_infos, &cu); if (r < 0) return r; - if (c > 0) - output_units_list(unit_infos, c); + for (u = unit_infos; u < unit_infos + cu; u++) { + const char *dot; + char _cleanup_strv_free_ **listen = NULL, **triggered = NULL; + unsigned c = 0, i; + + if (!output_show_unit(u)) + continue; + + if ((dot = strrchr(u->id, '.')) && !streq(dot+1, "socket")) + continue; + + r = get_triggered_units(bus, u->unit_path, &triggered); + if (r < 0) + goto cleanup; + + r = get_listening(bus, u->unit_path, &listen, &c); + if (r < 0) + goto cleanup; + + if (!GREEDY_REALLOC(socket_infos, size, cs + c)) { + r = log_oom(); + goto cleanup; + } + + for (i = 0; i < c; i++) + socket_infos[cs + i] = (struct socket_info) { + .id = u->id, + .type = listen[i*2], + .path = listen[i*2 + 1], + .triggered = triggered, + .own_triggered = i==0, + }; + + /* from this point on we will cleanup those socket_infos */ + cs += c; + free(listen); + listen = triggered = NULL; /* avoid cleanup */ + } + + qsort(socket_infos, cs, sizeof(struct socket_info), + (__compar_fn_t) socket_info_compare); + + output_sockets_list(socket_infos, cs); + + cleanup: + assert(cs == 0 || socket_infos); + for (s = socket_infos; s < socket_infos + cs; s++) { + free(s->type); + free(s->path); + if (s->own_triggered) + strv_free(s->triggered); + } + free(socket_infos); return 0; } @@ -524,7 +778,7 @@ static int compare_unit_file_list(const void *a, const void *b) { static bool output_show_unit_file(const UnitFileList *u) { const char *dot; - return !arg_type || ((dot = strrchr(u->path, '.')) && streq(dot+1, arg_type)); + return !arg_types || ((dot = strrchr(u->path, '.')) && strv_find(arg_types, dot+1)); } static void output_unit_file_list(const UnitFileList *units, unsigned c) { @@ -895,13 +1149,84 @@ static int list_dependencies(DBusConnection *bus, char **args) { return list_dependencies_one(bus, u, 0, NULL, 0); } +struct job_info { + uint32_t id; + char *name, *type, *state; +}; + +static void list_jobs_print(struct job_info* jobs, size_t n) { + size_t i; + struct job_info *j; + const char *on, *off; + bool shorten = false; + + assert(n == 0 || jobs); + + if (n == 0) { + on = ansi_highlight_green(true); + off = ansi_highlight_green(false); + + printf("%sNo jobs running.%s\n", on, off); + return; + } + + pager_open_if_enabled(); + + { + /* JOB UNIT TYPE STATE */ + unsigned l0 = 3, l1 = 4, l2 = 4, l3 = 5; + + for (i = 0, j = jobs; i < n; i++, j++) { + assert(j->name && j->type && j->state); + l0 = MAX(l0, decimal_str_max(j->id)); + l1 = MAX(l1, strlen(j->name)); + l2 = MAX(l2, strlen(j->type)); + l3 = MAX(l3, strlen(j->state)); + } + + if (!arg_full && l0 + 1 + l1 + l2 + 1 + l3 > columns()) { + l1 = MAX(33u, columns() - l0 - l2 - l3 - 3); + shorten = true; + } + + if (on_tty()) + printf("%*s %-*s %-*s %-*s\n", + l0, "JOB", + l1, "UNIT", + l2, "TYPE", + l3, "STATE"); + + for (i = 0, j = jobs; i < n; i++, j++) { + char _cleanup_free_ *e = NULL; + + if (streq(j->state, "running")) { + on = ansi_highlight(true); + off = ansi_highlight(false); + } else + on = off = ""; + + e = shorten ? ellipsize(j->name, l1, 33) : NULL; + printf("%*u %s%-*s%s %-*s %s%-*s%s\n", + l0, j->id, + on, l1, e ? e : j->name, off, + l2, j->type, + on, l3, j->state, off); + } + } + + on = ansi_highlight(true); + off = ansi_highlight(false); + + if (on_tty()) + printf("\n%s%zu jobs listed%s.\n", on, n, off); +} + static int list_jobs(DBusConnection *bus, char **args) { _cleanup_dbus_message_unref_ DBusMessage *reply = NULL; DBusMessageIter iter, sub, sub2; - unsigned k = 0; int r; - - pager_open_if_enabled(); + struct job_info *jobs = NULL; + size_t size = 0, used = 0; r = bus_method_call_with_reply( bus, @@ -924,13 +1249,9 @@ static int list_jobs(DBusConnection *bus, char **args) { dbus_message_iter_recurse(&iter, &sub); - if (on_tty()) - printf("%4s %-25s %-15s %-7s\n", "JOB", "UNIT", "TYPE", "STATE"); - while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) { const char *name, *type, *state, *job_path, *unit_path; uint32_t id; - char _cleanup_free_ *e = NULL; if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) { log_error("Failed to parse reply."); @@ -946,19 +1267,37 @@ static int list_jobs(DBusConnection *bus, char **args) { bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &job_path, true) < 0 || bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &unit_path, false) < 0) { log_error("Failed to parse reply."); - return -EIO; + r = -EIO; + goto finish; } - e = arg_full ? NULL : ellipsize(name, 25, 33); - printf("%4u %-25s %-15s %-7s\n", id, e ? e : name, type, state); + if (!greedy_realloc((void**) &jobs, &size, + sizeof(struct job_info) * (used + 1))) { + r = log_oom(); + goto finish; + } - k++; + jobs[used++] = (struct job_info) { id, + strdup(name), + strdup(type), + strdup(state) }; + if (!jobs[used-1].name || !jobs[used-1].type || !jobs[used-1].state) { + r = log_oom(); + goto finish; + } dbus_message_iter_next(&sub); } - if (on_tty()) - printf("\n%u jobs listed.\n", k); + list_jobs_print(jobs, used); + + finish: + while (used--) { + free(jobs[used].name); + free(jobs[used].type); + free(jobs[used].state); + } + free(jobs); return 0; } @@ -1193,14 +1532,11 @@ static int enable_wait_for_jobs(DBusConnection *bus) { static int wait_for_jobs(DBusConnection *bus, Set *s) { int r = 0; - WaitData d; + WaitData d = { .set = s }; assert(bus); assert(s); - zero(d); - d.set = s; - if (!dbus_connection_add_filter(bus, wait_filter, &d, NULL)) return log_oom(); @@ -2864,7 +3200,7 @@ static int print_property(const char *name, DBusMessageIter *iter) { /* This is a low-level property printer, see * print_status_info() for the nicer output */ - if (arg_property && !strv_find(arg_property, name)) + if (arg_properties && !strv_find(arg_properties, name)) return 0; switch (dbus_message_iter_get_arg_type(iter)) { @@ -3021,9 +3357,8 @@ static int print_property(const char *name, DBusMessageIter *iter) { dbus_message_iter_recurse(iter, &sub); while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) { - ExecStatusInfo info; + ExecStatusInfo info = {}; - zero(info); if (exec_status_info_deserialize(&sub, &info) >= 0) { char timestamp1[FORMAT_TIMESTAMP_MAX], timestamp2[FORMAT_TIMESTAMP_MAX]; char _cleanup_free_ *t; @@ -3070,14 +3405,12 @@ static int show_one(const char *verb, DBusConnection *bus, const char *path, boo const char *interface = ""; int r; DBusMessageIter iter, sub, sub2, sub3; - UnitStatusInfo info; + UnitStatusInfo info = {}; ExecStatusInfo *p; assert(path); assert(new_line); - zero(info); - r = bus_method_call_with_reply( bus, "org.freedesktop.systemd1", @@ -3201,6 +3534,8 @@ static int show_all(const char* verb, DBusConnection *bus, bool show_properties, if (r < 0) return r; + qsort(unit_infos, c, sizeof(struct unit_info), compare_unit_info); + for (u = unit_infos; u < unit_infos + c; u++) { char _cleanup_free_ *p = NULL; @@ -3654,7 +3989,7 @@ static int enable_sysv_units(char **args) { #if defined(HAVE_SYSV_COMPAT) && defined(HAVE_CHKCONFIG) const char *verb = args[0]; unsigned f = 1, t = 1; - LookupPaths paths; + LookupPaths paths = {}; if (arg_scope != UNIT_FILE_SYSTEM) return 0; @@ -3667,7 +4002,6 @@ static int enable_sysv_units(char **args) { /* Processes all SysV units, and reshuffles the array so that * afterwards only the native units remain */ - zero(paths); r = lookup_paths_init(&paths, SYSTEMD_SYSTEM, false, NULL, NULL, NULL); if (r < 0) return r; @@ -4159,6 +4493,8 @@ static int systemctl_help(void) { " --full Don't ellipsize unit names on output\n" " --fail When queueing a new job, fail if conflicting jobs are\n" " pending\n" + " --irreversible Create jobs which cannot be implicitly cancelled\n" + " --show-types When showing sockets, explictly show their type\n" " --ignore-dependencies\n" " When queueing a new job, ignore all its dependencies\n" " -i --ignore-inhibitors\n" @@ -4354,6 +4690,7 @@ static int systemctl_parse_argv(int argc, char *argv[]) { enum { ARG_FAIL = 0x100, + ARG_SHOW_TYPES, ARG_IRREVERSIBLE, ARG_IGNORE_DEPENDENCIES, ARG_VERSION, @@ -4380,6 +4717,7 @@ static int systemctl_parse_argv(int argc, char *argv[]) { { "type", required_argument, NULL, 't' }, { "property", required_argument, NULL, 'p' }, { "all", no_argument, NULL, 'a' }, + { "show-types", no_argument, NULL, ARG_SHOW_TYPES }, { "failed", no_argument, NULL, ARG_FAILED }, { "full", no_argument, NULL, ARG_FULL }, { "fail", no_argument, NULL, ARG_FAIL }, @@ -4426,45 +4764,67 @@ static int systemctl_parse_argv(int argc, char *argv[]) { puts(SYSTEMD_FEATURES); return 0; - case 't': - if (streq(optarg, "help")) { - help_types(); - return 0; - } + case 't': { + char *word, *state; + size_t size; - if (unit_type_from_string(optarg) >= 0) { - arg_type = optarg; - break; - } - if (unit_load_state_from_string(optarg) >= 0) { - arg_load_state = optarg; - break; + FOREACH_WORD_SEPARATOR(word, size, optarg, ",", state) { + char _cleanup_free_ *type; + + type = strndup(word, size); + if (!type) + return -ENOMEM; + + if (streq(type, "help")) { + help_types(); + return 0; + } + + if (unit_type_from_string(type) >= 0) { + if (strv_push(&arg_types, type)) + return log_oom(); + type = NULL; + continue; + } + + if (unit_load_state_from_string(optarg) >= 0) { + if (strv_push(&arg_load_states, type)) + return log_oom(); + type = NULL; + continue; + } + + log_error("Unkown unit type or load state '%s'.", type); + log_info("Use -t help to see a list of allowed values."); + return -EINVAL; } - log_error("Unkown unit type or load state '%s'.", - optarg); - log_info("Use -t help to see a list of allowed values."); - return -EINVAL; + + break; + } + case 'p': { - char *word, *state; - size_t size; /* Make sure that if the empty property list was specified, we won't show any properties. */ - const char *source = isempty(optarg) ? " " : optarg; - - FOREACH_WORD_SEPARATOR(word, size, source, ",", state) { - char _cleanup_free_ *prop; - char **tmp; + if (isempty(optarg) && !arg_properties) { + arg_properties = strv_new(NULL, NULL); + if (!arg_properties) + return log_oom(); + } else { + char *word, *state; + size_t size; - prop = strndup(word, size); - if (!prop) - return -ENOMEM; + FOREACH_WORD_SEPARATOR(word, size, optarg, ",", state) { + char *prop; - tmp = strv_append(arg_property, prop); - if (!tmp) - return -ENOMEM; + prop = strndup(word, size); + if (!prop) + return log_oom(); - strv_free(arg_property); - arg_property = tmp; + if (strv_push(&arg_properties, prop)) { + free(prop); + return log_oom(); + } + } } /* If the user asked for a particular @@ -4479,6 +4839,10 @@ static int systemctl_parse_argv(int argc, char *argv[]) { arg_all = true; break; + case ARG_SHOW_TYPES: + arg_show_types = true; + break; + case ARG_FAIL: arg_job_mode = "fail"; break; @@ -4716,7 +5080,7 @@ static int parse_time_spec(const char *t, usec_t *_u) { } else { char *e = NULL; long hour, minute; - struct tm tm; + struct tm tm = {}; time_t s; usec_t n; @@ -4732,7 +5096,6 @@ static int parse_time_spec(const char *t, usec_t *_u) { n = now(CLOCK_REALTIME); s = (time_t) (n / USEC_PER_SEC); - zero(tm); assert_se(localtime_r(&s, &tm)); tm.tm_hour = (int) hour; @@ -5134,7 +5497,7 @@ finish: } static int talk_initctl(void) { - struct init_request request = {0}; + struct init_request request = {}; int r; int _cleanup_close_ fd = -1; char rl; @@ -5161,7 +5524,7 @@ static int talk_initctl(void) { r = loop_write(fd, &request, sizeof(request), false) != sizeof(request); if (r) { log_error("Failed to write to "INIT_FIFO": %m"); - return errno ? -errno : -EIO; + return errno > 0 ? -errno : -EIO; } return 1; @@ -5181,6 +5544,7 @@ static int systemctl_main(DBusConnection *bus, int argc, char *argv[], DBusError } verbs[] = { { "list-units", LESS, 1, list_units }, { "list-unit-files", EQUAL, 1, list_unit_files }, + { "list-sockets", LESS, 1, list_sockets }, { "list-jobs", EQUAL, 1, list_jobs }, { "clear-jobs", EQUAL, 1, daemon_reload }, { "load", MORE, 2, load_unit }, @@ -5339,41 +5703,38 @@ static int systemctl_main(DBusConnection *bus, int argc, char *argv[], DBusError static int send_shutdownd(usec_t t, char mode, bool dry_run, bool warn, const char *message) { int _cleanup_close_ fd; - struct msghdr msghdr; - struct iovec iovec[2]; - union sockaddr_union sockaddr; - struct sd_shutdown_command c; + struct sd_shutdown_command c = { + .usec = t, + .mode = mode, + .dry_run = dry_run, + .warn_wall = warn, + }; + union sockaddr_union sockaddr = { + .un.sun_family = AF_UNIX, + .un.sun_path = "/run/systemd/shutdownd", + }; + struct iovec iovec[2] = { + {.iov_base = (char*) &c, + .iov_len = offsetof(struct sd_shutdown_command, wall_message), + } + }; + struct msghdr msghdr = { + .msg_name = &sockaddr, + .msg_namelen = offsetof(struct sockaddr_un, sun_path) + + sizeof("/run/systemd/shutdownd") - 1, + .msg_iov = iovec, + .msg_iovlen = 1, + }; fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0); if (fd < 0) return -errno; - zero(c); - c.usec = t; - c.mode = mode; - c.dry_run = dry_run; - c.warn_wall = warn; - - zero(sockaddr); - sockaddr.sa.sa_family = AF_UNIX; - strncpy(sockaddr.un.sun_path, "/run/systemd/shutdownd", sizeof(sockaddr.un.sun_path)); - - zero(msghdr); - msghdr.msg_name = &sockaddr; - msghdr.msg_namelen = offsetof(struct sockaddr_un, sun_path) + sizeof("/run/systemd/shutdownd") - 1; - - zero(iovec); - iovec[0].iov_base = (char*) &c; - iovec[0].iov_len = offsetof(struct sd_shutdown_command, wall_message); - - if (isempty(message)) - msghdr.msg_iovlen = 1; - else { + if (!isempty(message)) { iovec[1].iov_base = (char*) message; iovec[1].iov_len = strlen(message); - msghdr.msg_iovlen = 2; + msghdr.msg_iovlen++; } - msghdr.msg_iov = iovec; if (sendmsg(fd, &msghdr, MSG_NOSIGNAL) < 0) return -errno; @@ -5651,7 +6012,9 @@ finish: dbus_shutdown(); - strv_free(arg_property); + strv_free(arg_types); + strv_free(arg_load_states); + strv_free(arg_properties); pager_close(); ask_password_agent_close();