if (arg_no_pager)
return;
- pager_open();
+ pager_open(false);
}
static void ask_password_agent_open_if_enabled(void) {
if (!arg_full) {
unsigned basic_len;
- id_len = MIN(max_id_len, 25);
+ id_len = MIN(max_id_len, 25u);
basic_len = 5 + id_len + 5 + active_len + sub_len;
if (job_count)
basic_len += job_len + 1;
extra_len = columns() - basic_len;
/* Either UNIT already got 25, or is fully satisfied.
* Grant up to 25 to DESC now. */
- incr = MIN(extra_len, 25);
+ incr = MIN(extra_len, 25u);
desc_len += incr;
extra_len -= incr;
/* split the remaining space between UNIT and DESC,
if (*c >= n_units) {
struct unit_info *w;
- n_units = MAX(2 * *c, 16);
+ n_units = MAX(2 * *c, 16u);
w = realloc(*unit_infos, sizeof(struct unit_info) * n_units);
if (!w)
return log_oom();
if (!arg_full) {
unsigned basic_cols;
- id_cols = MIN(max_id_len, 25);
+ id_cols = MIN(max_id_len, 25u);
basic_cols = 1 + id_cols + state_cols;
if (basic_cols < (unsigned) columns())
id_cols += MIN(columns() - basic_cols, max_id_len - id_cols);
if (c >= n_units) {
UnitFileList *w;
- n_units = MAX(2*c, 16);
+ n_units = MAX(2*c, 16u);
w = realloc(units, sizeof(struct UnitFileList) * n_units);
if (!w)
return log_oom();
int i;
_cleanup_free_ char *n = NULL;
size_t len = 0;
- size_t max_len = MAX(columns(),20);
+ size_t max_len = MAX(columns(),20u);
for (i = level - 1; i >= 0; i--) {
len += 2;
}
static int get_cgroup_attr(DBusConnection *bus, char **args) {
- _cleanup_dbus_message_unref_ DBusMessage *m = NULL, *reply = NULL;
+ _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
_cleanup_free_ char *n = NULL;
char **argument;
int r;
if (r < 0)
return r;
- dbus_message_iter_init(reply, &iter);
+ if (!dbus_message_iter_init(reply, &iter)) {
+ log_error("Failed to initialize iterator.");
+ return -EIO;
+ }
+
r = bus_parse_strv_iter(&iter, &list);
if (r < 0) {
log_error("Failed to parse value list.");
unsigned n_connections;
bool accept;
+ char **listen;
+
/* Device */
const char *sysfs_path;
}
}
+ if (!strv_isempty(i->listen)) {
+ char **t;
+ bool first = true;
+
+ STRV_FOREACH(t, i->listen) {
+ if (first) {
+ printf("\t Listen: %s\n", *t);
+ first = false;
+ } else
+ printf("\t %s\n", *t);
+ }
+ }
+
if (i->accept)
printf("\tAccepted: %u; Connected: %u\n", i->n_accepted, i->n_connections);
if (i->id && arg_transport != TRANSPORT_SSH) {
printf("\n");
- if(arg_scope == UNIT_FILE_SYSTEM)
- show_journal_by_unit(stdout,
- i->id,
- arg_output,
- 0,
- i->inactive_exit_timestamp_monotonic,
- arg_lines,
- flags);
- else
- show_journal_by_user_unit(stdout,
- i->id,
- arg_output,
- 0,
- i->inactive_exit_timestamp_monotonic,
- arg_lines,
- getuid(),
- flags);
+ show_journal_by_unit(stdout,
+ i->id,
+ arg_output,
+ 0,
+ i->inactive_exit_timestamp_monotonic,
+ arg_lines,
+ getuid(),
+ flags,
+ arg_scope == UNIT_FILE_SYSTEM);
}
if (i->need_daemon_reload)
dbus_message_iter_next(&sub);
}
+
+ } else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && streq(name, "Listen")) {
+ DBusMessageIter sub, sub2;
+
+ dbus_message_iter_recurse(iter, &sub);
+ while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
+ const char *type, *path;
+
+ 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) {
+ char * buf, **l;
+ if (asprintf(&buf, "%s: %s", type, path) < 0)
+ return -ENOMEM;
+
+ l = strv_append(i->listen, buf);
+ free(buf);
+
+ if (!l)
+ return -ENOMEM;
+
+ strv_free(i->listen);
+ i->listen = l;
+ }
+
+ dbus_message_iter_next(&sub);
+ }
+
+ return 0;
+
} else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRING &&
streq(name, "Documentation")) {
DBusMessageIter sub, sub2;
dbus_message_iter_recurse(iter, &sub);
+
while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
const char *type, *path;
return 0;
+ } else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && streq(name, "Listen")) {
+ DBusMessageIter sub, sub2;
+
+ dbus_message_iter_recurse(iter, &sub);
+ while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
+ const char *type, *path;
+
+ 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)
+ printf("Listen%s=%s\n", type, path);
+
+ dbus_message_iter_next(&sub);
+ }
+
+ return 0;
+
} else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && streq(name, "Timers")) {
DBusMessageIter sub, sub2;
}
static int show_one(const char *verb, DBusConnection *bus, const char *path, bool show_properties, bool *new_line) {
- _cleanup_free_ DBusMessage *reply = NULL;
+ DBusMessage _cleanup_free_ *reply = NULL;
const char *interface = "";
int r;
DBusMessageIter iter, sub, sub2, sub3;
}
strv_free(info.documentation);
+ strv_free(info.listen);
if (!streq_ptr(info.active_state, "active") &&
!streq_ptr(info.active_state, "reloading") &&
DBusMessage _cleanup_dbus_message_unref_ *reply = NULL;
bool enabled;
char **name;
+ char *n;
dbus_error_init(&error);
STRV_FOREACH(name, args+1) {
UnitFileState state;
- state = unit_file_get_state(arg_scope, arg_root, *name);
+ n = unit_name_mangle(*name);
+ if (!n)
+ return log_oom();
+
+ state = unit_file_get_state(arg_scope, arg_root, n);
+
+ free(n);
+
if (state < 0)
return state;
STRV_FOREACH(name, args+1) {
const char *s;
+ n = unit_name_mangle(*name);
+ if (!n)
+ return log_oom();
+
r = bus_method_call_with_reply (
bus,
"org.freedesktop.systemd1",
"GetUnitFileState",
&reply,
NULL,
- DBUS_TYPE_STRING, name,
+ DBUS_TYPE_STRING, &n,
DBUS_TYPE_INVALID);
+
+ free(n);
+
if (r)
return r;
static int help_types(void) {
int i;
+ const char *t;
puts("Available unit types:");
- for(i = UNIT_SERVICE; i < _UNIT_TYPE_MAX; i++)
- if (unit_type_table[i])
- puts(unit_type_table[i]);
+ for(i = 0; i < _UNIT_TYPE_MAX; i++) {
+ t = unit_type_to_string(i);
+ if (t)
+ puts(t);
+ }
puts("\nAvailable unit load states: ");
- for(i = UNIT_STUB; i < _UNIT_LOAD_STATE_MAX; i++)
- if (unit_type_table[i])
- puts(unit_load_state_table[i]);
+ for(i = 0; i < _UNIT_LOAD_STATE_MAX; i++) {
+ t = unit_load_state_to_string(i);
+ if (t)
+ puts(t);
+ }
return 0;
}
errno = 0;
hour = strtol(t, &e, 10);
- if (errno != 0 || *e != ':' || hour < 0 || hour > 23)
+ if (errno > 0 || *e != ':' || hour < 0 || hour > 23)
return -EINVAL;
minute = strtol(e+1, &e, 10);
- if (errno != 0 || *e != 0 || minute < 0 || minute > 59)
+ if (errno > 0 || *e != 0 || minute < 0 || minute > 59)
return -EINVAL;
n = now(CLOCK_REALTIME);
* request to it. For now we simply
* guess that it is Upstart. */
- execv("/lib/upstart/telinit", argv);
+ execv(TELINIT, argv);
log_error("Couldn't find an alternative telinit implementation to spawn.");
return -EIO;
}
static int talk_initctl(void) {
- struct init_request request;
- int r, fd;
+ struct init_request request = {0};
+ int r;
+ int _cleanup_close_ fd = -1;
char rl;
- if (!(rl = action_to_runlevel()))
+ rl = action_to_runlevel();
+ if (!rl)
return 0;
- zero(request);
request.magic = INIT_MAGIC;
request.sleeptime = 0;
request.cmd = INIT_CMD_RUNLVL;
request.runlevel = rl;
- if ((fd = open(INIT_FIFO, O_WRONLY|O_NDELAY|O_CLOEXEC|O_NOCTTY)) < 0) {
-
+ fd = open(INIT_FIFO, O_WRONLY|O_NDELAY|O_CLOEXEC|O_NOCTTY);
+ if (fd < 0) {
if (errno == ENOENT)
return 0;
errno = 0;
r = loop_write(fd, &request, sizeof(request), false) != sizeof(request);
- close_nointr_nofail(fd);
-
- if (r < 0) {
+ if (r) {
log_error("Failed to write to "INIT_FIFO": %m");
return errno ? -errno : -EIO;
}
~ianmdlvl / elogind.git / blobdiff