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;
const char *source_path;
const char *default_control_group;
+ char **dropin_paths;
+
const char *load_error;
const char *result;
unsigned n_connections;
bool accept;
+ /* Pairs of type, path */
+ char **listen;
+
/* Device */
const char *sysfs_path;
on_tty() * OUTPUT_COLOR |
!arg_quiet * OUTPUT_WARN_CUTOFF |
arg_full * OUTPUT_FULL_WIDTH;
+ int maxlen = 8; /* a value that'll suffice most of the time */
+ char **t, **t2;
assert(i);
+ STRV_FOREACH_PAIR(t, t2, i->listen)
+ maxlen = MAX(maxlen, (int)(sizeof("Listen") - 1 + strlen(*t)));
+ if (i->accept)
+ maxlen = MAX(maxlen, (int)sizeof("Accept") - 1);
+ if (i->main_pid > 0)
+ maxlen = MAX(maxlen, (int)sizeof("Main PID") - 1);
+ else if (i->control_pid > 0)
+ maxlen = MAX(maxlen, (int)sizeof("Control") - 1);
+
/* This shows pretty information about a unit. See
* print_property() for a low-level property printer */
printf("\n");
if (i->following)
- printf("\t Follow: unit currently follows state of %s\n", i->following);
+ printf(" %*s: unit currently follows state of %s\n", maxlen, "Follow", i->following);
if (streq_ptr(i->load_state, "error")) {
on = ansi_highlight_red(true);
path = i->source_path ? i->source_path : i->fragment_path;
if (i->load_error)
- printf("\t Loaded: %s%s%s (Reason: %s)\n", on, strna(i->load_state), off, i->load_error);
+ printf(" %*s: %s%s%s (Reason: %s)\n",
+ maxlen, "Loaded", on, strna(i->load_state), off, i->load_error);
else if (path && i->unit_file_state)
- printf("\t Loaded: %s%s%s (%s; %s)\n", on, strna(i->load_state), off, path, i->unit_file_state);
+ printf(" %*s: %s%s%s (%s; %s)\n",
+ maxlen, "Loaded", on, strna(i->load_state), off, path, i->unit_file_state);
else if (path)
- printf("\t Loaded: %s%s%s (%s)\n", on, strna(i->load_state), off, path);
+ printf(" %*s: %s%s%s (%s)\n",
+ maxlen, "Loaded", on, strna(i->load_state), off, path);
else
- printf("\t Loaded: %s%s%s\n", on, strna(i->load_state), off);
+ printf(" %*s: %s%s%s\n",
+ maxlen, "Loaded", on, strna(i->load_state), off);
+
+ if (!strv_isempty(i->dropin_paths)) {
+ char ** dropin;
+ char * dir = NULL;
+ bool last = false;
+
+ STRV_FOREACH(dropin, i->dropin_paths) {
+ if (! dir || last) {
+ printf(" %*s ", maxlen, dir ? "" : "Drop-In:");
+
+ free(dir);
+
+ if (path_get_parent(*dropin, &dir) < 0) {
+ log_oom();
+ return;
+ }
+
+ printf("%s\n %*s %s ", dir, maxlen, "",
+ draw_special_char(DRAW_TREE_RIGHT));
+ }
+
+ last = ! (*(dropin + 1) && startswith(*(dropin + 1), dir));
+
+ printf("%s%s", path_get_file_name(*dropin), last ? "\n" : ", ");
+ }
+
+ free(dir);
+ }
ss = streq_ptr(i->active_state, i->sub_state) ? NULL : i->sub_state;
on = off = "";
if (ss)
- printf("\t Active: %s%s (%s)%s",
- on,
- strna(i->active_state),
- ss,
- off);
+ printf(" %*s: %s%s (%s)%s",
+ maxlen, "Active", on, strna(i->active_state), ss, off);
else
- printf("\t Active: %s%s%s",
- on,
- strna(i->active_state),
- off);
+ printf(" %*s: %s%s%s",
+ maxlen, "Active", on, strna(i->active_state), off);
if (!isempty(i->result) && !streq(i->result, "success"))
printf(" (Result: %s)", i->result);
s2 = format_timestamp(since2, sizeof(since2), i->condition_timestamp);
if (s1)
- printf("\t start condition failed at %s; %s\n", s2, s1);
+ printf(" %*s start condition failed at %s; %s\n", maxlen, "", s2, s1);
else if (s2)
- printf("\t start condition failed at %s\n", s2);
+ printf(" %*s start condition failed at %s\n", maxlen, "", s2);
}
if (i->sysfs_path)
- printf("\t Device: %s\n", i->sysfs_path);
+ printf(" %*s: %s\n", maxlen, "Device", i->sysfs_path);
if (i->where)
- printf("\t Where: %s\n", i->where);
+ printf(" %*s: %s\n", maxlen, "Where", i->where);
if (i->what)
- printf("\t What: %s\n", i->what);
+ printf(" %*s: %s\n", maxlen, "What", i->what);
- if (!strv_isempty(i->documentation)) {
- char **t;
- bool first = true;
+ STRV_FOREACH(t, i->documentation)
+ printf(" %*s %s\n", maxlen+1, t == i->documentation ? "Docs:" : "", *t);
- STRV_FOREACH(t, i->documentation) {
- if (first) {
- printf("\t Docs: %s\n", *t);
- first = false;
- } else
- printf("\t %s\n", *t);
- }
- }
+ STRV_FOREACH_PAIR(t, t2, i->listen)
+ printf(" %*s%s: %s\n", maxlen - (int)strlen(*t), "Listen", *t, *t2);
if (i->accept)
- printf("\tAccepted: %u; Connected: %u\n", i->n_accepted, i->n_connections);
+ printf(" %*s: %u; Connected: %u\n", maxlen, "Accepted", i->n_accepted, i->n_connections);
LIST_FOREACH(exec, p, i->exec) {
- _cleanup_free_ char *t = NULL;
+ _cleanup_free_ char *argv = NULL;
bool good;
/* Only show exited processes here */
if (p->code == 0)
continue;
- t = strv_join(p->argv, " ");
- printf("\t Process: %u %s=%s ", p->pid, p->name, strna(t));
+ argv = strv_join(p->argv, " ");
+ printf(" %*s: %u %s=%s ", maxlen, "Process", p->pid, p->name, strna(argv));
good = is_clean_exit_lsb(p->code, p->status, NULL);
if (!good) {
}
if (i->main_pid > 0 || i->control_pid > 0) {
- printf("\t");
-
if (i->main_pid > 0) {
- printf("Main PID: %u", (unsigned) i->main_pid);
+ printf(" %*s: %u", maxlen, "Main PID", (unsigned) i->main_pid);
if (i->running) {
- _cleanup_free_ char *t = NULL;
- get_process_comm(i->main_pid, &t);
- if (t)
- printf(" (%s)", t);
+ _cleanup_free_ char *comm = NULL;
+ get_process_comm(i->main_pid, &comm);
+ if (comm)
+ printf(" (%s)", comm);
} else if (i->exit_code > 0) {
printf(" (code=%s, ", sigchld_code_to_string(i->exit_code));
printf("signal=%s", signal_to_string(i->exit_status));
printf(")");
}
- }
- if (i->main_pid > 0 && i->control_pid > 0)
- printf(";");
+ if (i->control_pid > 0)
+ printf(";");
+ }
if (i->control_pid > 0) {
- _cleanup_free_ char *t = NULL;
+ _cleanup_free_ char *c = NULL;
- printf(" Control: %u", (unsigned) i->control_pid);
+ printf(" %*s: %u", i->main_pid ? 0 : maxlen, "Control", (unsigned) i->control_pid);
- get_process_comm(i->control_pid, &t);
- if (t)
- printf(" (%s)", t);
+ get_process_comm(i->control_pid, &c);
+ if (c)
+ printf(" (%s)", c);
}
printf("\n");
}
if (i->status_text)
- printf("\t Status: \"%s\"\n", i->status_text);
+ printf(" %*s: \"%s\"\n", maxlen, "Status", i->status_text);
if (i->default_control_group &&
(i->main_pid > 0 || i->control_pid > 0 || cg_is_empty_by_spec(i->default_control_group, false) == 0)) {
unsigned c;
- printf("\t CGroup: %s\n", i->default_control_group);
+ printf(" %*s: %s\n", maxlen, "CGroup", i->default_control_group);
if (arg_transport != TRANSPORT_SSH) {
unsigned k = 0;
pid_t extra[2];
+ char prefix[maxlen + 4];
+ memset(prefix, ' ', sizeof(prefix) - 1);
+ prefix[sizeof(prefix) - 1] = '\0';
c = columns();
- if (c > 18)
- c -= 18;
+ if (c > sizeof(prefix) - 1)
+ c -= sizeof(prefix) - 1;
else
c = 0;
if (i->control_pid > 0)
extra[k++] = i->control_pid;
- show_cgroup_and_extra_by_spec(i->default_control_group, "\t\t ", c, false, extra, k, flags);
+ show_cgroup_and_extra_by_spec(i->default_control_group, prefix,
+ c, false, extra, k, flags);
}
}
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) {
+ int r;
+
+ r = strv_extend(&i->listen, type);
+ if (r < 0)
+ return r;
+ r = strv_extend(&i->listen, path);
+ if (r < 0)
+ return r;
+ }
+
+ dbus_message_iter_next(&sub);
+ }
+
+ return 0;
+
+ } else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRING && streq(name, "DropInPaths")) {
+ int r = bus_parse_strv_iter(iter, &i->dropin_paths);
+ if (r < 0)
+ return r;
+
} else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRING &&
streq(name, "Documentation")) {
dbus_message_iter_recurse(iter, &sub);
while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRING) {
const char *s;
- char **l;
+ int r;
dbus_message_iter_get_basic(&sub, &s);
- l = strv_append(i->documentation, s);
- if (!l)
- return -ENOMEM;
-
- strv_free(i->documentation);
- i->documentation = l;
+ r = strv_extend(&i->documentation, s);
+ if (r < 0)
+ return r;
dbus_message_iter_next(&sub);
}
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;
printf("%s={ value=%s ; next_elapse=%s }\n",
base,
- format_timespan(timespan1, sizeof(timespan1), value),
- format_timespan(timespan2, sizeof(timespan2), next_elapse));
+ format_timespan(timespan1, sizeof(timespan1), value, 0),
+ format_timespan(timespan2, sizeof(timespan2), next_elapse, 0));
}
dbus_message_iter_next(&sub);
}
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.dropin_paths);
+ strv_free(info.listen);
if (!streq_ptr(info.active_state, "active") &&
!streq_ptr(info.active_state, "reloading") &&
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;
~ianmdlvl / elogind.git / blobdiff