mirror of
https://github.com/troglobit/finit.git
synced 2026-11-20 19:41:51 +00:00
With restart-max-sec the delay before the next restart varies, and
nothing showed what it was or how far it could grow.
Show both in initctl status, for a service that has the setting:
Restarts : 7 (4/-1)
Restart in : 160 sec (max 300)
Add the D-Bus properties RestartDelay and RestartDelayMax for it, so
the status is the same when initctl goes over D-Bus.
Signed-off-by: Joachim Wiberg <troglobit@gmail.com>
2861 lines
65 KiB
C
2861 lines
65 KiB
C
/* New client tool, replaces old /dev/initctl API and telinit tool
|
|
*
|
|
* Copyright (c) 2015-2025 Joachim Wiberg <troglobit@gmail.com>
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
* THE SOFTWARE.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <ftw.h>
|
|
#include <ctype.h>
|
|
#include <getopt.h>
|
|
#include <paths.h>
|
|
#include <signal.h>
|
|
#include <stdio.h>
|
|
#include <syslog.h>
|
|
#include <time.h>
|
|
#include <utmp.h>
|
|
#include <arpa/inet.h>
|
|
|
|
#include "initctl.h"
|
|
#include "client.h"
|
|
#include "cond.h"
|
|
#include "serv.h"
|
|
#include "service.h"
|
|
#include "cgutil.h"
|
|
#include "utmp-api.h"
|
|
#ifdef HAVE_DBUS
|
|
#include "link.h"
|
|
#include "path.h"
|
|
#endif
|
|
|
|
/* Used by both do_cond_act and (with HAVE_DBUS) cond_dbus_call. */
|
|
typedef enum { COND_CLR, COND_SET, COND_GET } condop_t;
|
|
|
|
struct cmd {
|
|
char *cmd;
|
|
struct cmd *ctx;
|
|
int (*cb)(char *arg);
|
|
int *cond;
|
|
int (*cb_multiarg)(int argc, char **argv);
|
|
};
|
|
|
|
char *finit_conf = NULL;
|
|
char *finit_rcsd = NULL;
|
|
|
|
int icreate = 0;
|
|
int iforce = 0;
|
|
int ionce = 0;
|
|
int debug = 0;
|
|
int heading = 1;
|
|
int json = 0;
|
|
int noerr = 0;
|
|
int verbose = 0;
|
|
int plain = 0;
|
|
int quiet = 0;
|
|
int runlevel = 0;
|
|
int timeout = 0;
|
|
int cgrp = 0;
|
|
int utmp = 0;
|
|
|
|
int iw, pw;
|
|
|
|
extern int reboot_main(int argc, char *argv[]);
|
|
|
|
/* figure ut width of IDENT and PID columns */
|
|
static void col_widths(void)
|
|
{
|
|
char ident[MAX_IDENT_LEN];
|
|
char pid[10];
|
|
svc_t *svc;
|
|
|
|
iw = 0;
|
|
pw = 0;
|
|
|
|
for (svc = client_svc_iterator(1); svc; svc = client_svc_iterator(0)) {
|
|
int w, p;
|
|
|
|
svc_ident(svc, ident, sizeof(ident));
|
|
w = (int)strlen(ident);
|
|
if (w > iw)
|
|
iw = w;
|
|
|
|
p = snprintf(pid, sizeof(pid), "%d", svc->pid);
|
|
if (p > pw)
|
|
pw = p;
|
|
}
|
|
|
|
/* adjust for min col width */
|
|
if (iw < 6)
|
|
iw = 6;
|
|
if (pw < 3)
|
|
pw = 3;
|
|
}
|
|
|
|
void print_header(const char *fmt, ...)
|
|
{
|
|
va_list ap;
|
|
|
|
va_start(ap, fmt);
|
|
|
|
if (plain) {
|
|
int len;
|
|
|
|
vfprintf(stdout, fmt, ap);
|
|
fputs("\n", stdout);
|
|
for (len = 0; len < ttcols; len++)
|
|
fputc('=', stdout);
|
|
fputs("\n", stdout);
|
|
} else {
|
|
char buf[ttcols - 9];
|
|
|
|
vsnprintf(buf, sizeof(buf), fmt, ap);
|
|
printheader(stdout, buf, 0);
|
|
}
|
|
|
|
va_end(ap);
|
|
}
|
|
|
|
static int runlevel_get(int *prevlevel)
|
|
{
|
|
struct init_request rq;
|
|
int rc;
|
|
|
|
rq.cmd = INIT_CMD_GET_RUNLEVEL;
|
|
rq.magic = INIT_MAGIC;
|
|
|
|
rc = client_send(&rq, sizeof(rq));
|
|
if (!rc) {
|
|
rc = rq.runlevel;
|
|
if (prevlevel)
|
|
*prevlevel = rq.sleeptime;
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
#ifdef HAVE_DBUS
|
|
static int try_dbus_manager(const char *method, const char *arg_sig,
|
|
const char *arg);
|
|
#endif
|
|
|
|
static int toggle_debug(char *arg)
|
|
{
|
|
struct init_request rq = {
|
|
.magic = INIT_MAGIC,
|
|
.cmd = INIT_CMD_DEBUG,
|
|
};
|
|
|
|
(void)arg;
|
|
#ifdef HAVE_DBUS
|
|
{
|
|
int rc = try_dbus_manager("SetDebug", "", NULL);
|
|
if (rc >= 0) return rc;
|
|
}
|
|
#endif
|
|
return client_send(&rq, sizeof(rq));
|
|
}
|
|
|
|
static int do_log_named(const char *nm, pid_t pid, char *tail)
|
|
{
|
|
const char *logfile = "/var/log/syslog";
|
|
|
|
if (!pid)
|
|
return 0; /* not running */
|
|
|
|
if (!fexist(logfile)) {
|
|
logfile = "/var/log/messages";
|
|
if (!fexist(logfile))
|
|
return 0; /* bail out, maybe in container */
|
|
}
|
|
|
|
return systemf("cat %s | grep '\\[%d\\]\\|%s' %s", logfile, pid, nm, tail);
|
|
}
|
|
|
|
static int do_log(svc_t *svc, char *tail)
|
|
{
|
|
if (svc)
|
|
return do_log_named(svc_ident(svc, NULL, 0), svc->pid, tail);
|
|
return do_log_named("finit", 1, tail);
|
|
}
|
|
|
|
static int show_log(char *arg)
|
|
{
|
|
svc_t *svc = NULL;
|
|
|
|
if (arg) {
|
|
svc = client_svc_find(arg);
|
|
if (!svc)
|
|
ERRX(noerr ? 0 : 69, "no such task or service(s): %s", arg);
|
|
}
|
|
|
|
return do_log(svc, "");
|
|
}
|
|
|
|
#ifdef HAVE_DBUS
|
|
/*
|
|
* Advance one a{sv} dict entry: key + variant type; the caller reads
|
|
* the value with the link_r_* matching `type`.
|
|
*/
|
|
static int dbus_dict_next(link_reader_t *r, const char **key, char *type)
|
|
{
|
|
if (link_r_align(r, 8) < 0)
|
|
return -1;
|
|
if (link_r_string(r, key) < 0)
|
|
return -1;
|
|
return link_r_variant_begin(r, type);
|
|
}
|
|
|
|
/* Fetch all org.finit.Manager1 string properties in one Properties.GetAll
|
|
* round-trip, then pick out a subset. `wanted` is a NULL-terminated array
|
|
* of property names; `out` parallel-receives the values (each entry left
|
|
* untouched if its property wasn't returned). Returns 0 on transport
|
|
* success (even if some properties weren't present), -1 on transport or
|
|
* parse failure. */
|
|
static int dbus_get_manager_props(const char *const *wanted, char **out, size_t out_sz)
|
|
{
|
|
link_client_t *c;
|
|
const link_reply_t *r;
|
|
link_reader_t reader;
|
|
size_t end;
|
|
int rc;
|
|
|
|
c = link_client_open(FINIT_BUS_SOCKET);
|
|
if (!c)
|
|
return -1;
|
|
|
|
rc = link_client_call_v(c, "/org/finit/manager",
|
|
"org.freedesktop.DBus.Properties", "GetAll",
|
|
"s", "org.finit.Manager1");
|
|
if (rc != LINK_CALL_OK) {
|
|
link_client_close(c);
|
|
return -1;
|
|
}
|
|
|
|
r = link_client_reply(c);
|
|
if (!r || !r->body) {
|
|
link_client_close(c);
|
|
return -1;
|
|
}
|
|
|
|
link_reader_init(&reader, r->body, r->body_len);
|
|
if (link_r_array_begin(&reader, &end) < 0) {
|
|
link_client_close(c);
|
|
return -1;
|
|
}
|
|
|
|
while (link_r_pos(&reader) < end) {
|
|
const char *key = NULL;
|
|
const char *val = NULL;
|
|
char type;
|
|
size_t i;
|
|
|
|
if (dbus_dict_next(&reader, &key, &type) < 0)
|
|
goto fail;
|
|
if (type != 's' || link_r_string(&reader, &val) < 0)
|
|
goto fail;
|
|
|
|
for (i = 0; wanted[i]; i++) {
|
|
if (!strcmp(key, wanted[i])) {
|
|
strlcpy(out[i], val, out_sz);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
link_client_close(c);
|
|
return 0;
|
|
fail:
|
|
link_client_close(c);
|
|
return -1;
|
|
}
|
|
|
|
#endif
|
|
|
|
static int do_runlevel(char *arg)
|
|
{
|
|
struct init_request rq = {
|
|
.magic = INIT_MAGIC,
|
|
.cmd = INIT_CMD_RUNLVL,
|
|
};
|
|
|
|
if (!arg) {
|
|
int prevlevel = 0;
|
|
int currlevel;
|
|
char prev, curr;
|
|
|
|
#ifdef HAVE_DBUS
|
|
char curr_buf[16] = { 0 }, prev_buf[16] = { 0 };
|
|
const char *const wanted[] = { "Runlevel", "PrevRunlevel", NULL };
|
|
char *out[] = { curr_buf, prev_buf };
|
|
|
|
if (dbus_get_manager_props(wanted, out, sizeof(curr_buf)) == 0 &&
|
|
curr_buf[0] && prev_buf[0]) {
|
|
/* already in runlevel(8) encoding: digits, S, N */
|
|
printf("%s %s\n", prev_buf, curr_buf);
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
currlevel = runlevel_get(&prevlevel);
|
|
switch (currlevel) {
|
|
case 255:
|
|
printf("unknown\n");
|
|
return 0;
|
|
case INIT_LEVEL:
|
|
curr = 'S';
|
|
break;
|
|
default:
|
|
curr = currlevel + '0';
|
|
break;
|
|
}
|
|
|
|
prev = prevlevel + '0';
|
|
if (prev <= '0' || prev > '9')
|
|
prev = 'N';
|
|
|
|
printf("%c %c\n", prev , curr);
|
|
return 0;
|
|
}
|
|
|
|
/* set runlevel */
|
|
rq.runlevel = (int)arg[0];
|
|
|
|
return client_send(&rq, sizeof(rq));
|
|
}
|
|
|
|
static int do_svc(int cmd, char *arg)
|
|
{
|
|
struct init_request rq = {
|
|
.magic = INIT_MAGIC,
|
|
.cmd = cmd,
|
|
.data = "",
|
|
};
|
|
|
|
if (arg)
|
|
strlcpy(rq.data, arg, sizeof(rq.data));
|
|
|
|
return client_send(&rq, sizeof(rq));
|
|
}
|
|
|
|
/*
|
|
* This is a wrapper for do_svc() that adds a simple sanity check of
|
|
* the service(s) provided as argument. If a service does not exist
|
|
* we make sure to return an error code.
|
|
*/
|
|
static int do_startstop(int cmd, char *arg)
|
|
{
|
|
struct init_request rq = {
|
|
.magic = INIT_MAGIC,
|
|
.cmd = INIT_CMD_SVC_QUERY
|
|
};
|
|
|
|
if (!arg || !arg[0])
|
|
ERRX(2, "missing command argument");
|
|
|
|
strlcpy(rq.data, arg, sizeof(rq.data));
|
|
if (client_send(&rq, sizeof(rq)))
|
|
ERRX(noerr ? 0 : 69, "no such task or service(s): %s", arg);
|
|
|
|
return do_svc(cmd, arg);
|
|
}
|
|
|
|
#ifdef HAVE_DBUS
|
|
|
|
/* Map a LINK_CALL_ERROR reply on `c` to the appropriate ERRX exit:
|
|
* org.finit.Error.NoSuchService -> exit 69 (legacy "no such svc")
|
|
* org.freedesktop.DBus.Error.AccessDenied -> exit 1 (permission denied)
|
|
* anything else -> exit 1 (method: err)
|
|
* `c` is closed before exit either way. Use exact-match on the
|
|
* fully-qualified error name; a substring match would misfire on a
|
|
* future name that contained one of these as a prefix. */
|
|
/* The reply view points into the client's rxbuf, which link_client_close()
|
|
* frees, so anyone who wants the error name past the close has to copy it
|
|
* out first. Both D-Bus error paths in this file do; keep the one copy
|
|
* here so a third caller cannot reintroduce the use-after-free. */
|
|
static void take_dbus_err(link_client_t *c, char *buf, size_t len)
|
|
{
|
|
const link_reply_t *r = link_client_reply(c);
|
|
|
|
if (r && r->error_name)
|
|
strlcpy(buf, r->error_name, len);
|
|
else if (len)
|
|
buf[0] = '\0';
|
|
}
|
|
|
|
static void map_dbus_err(link_client_t *c, const char *method, const char *ident)
|
|
{
|
|
char err[128];
|
|
|
|
take_dbus_err(c, err, sizeof(err));
|
|
link_client_close(c);
|
|
|
|
if (!strcmp(err, "org.finit.Error.NoSuchService"))
|
|
ERRX(noerr ? 0 : 69, "no such task or service(s): %s",
|
|
ident ? ident : "");
|
|
if (!strcmp(err, "org.freedesktop.DBus.Error.AccessDenied"))
|
|
ERRX(1, "permission denied: %s requires root", method);
|
|
ERRX(1, "%s: %s", method, *err ? err : "D-Bus error");
|
|
}
|
|
|
|
/* Try the D-Bus path for a Manager1 method. Returns:
|
|
* 0 succeeded via D-Bus
|
|
* -1 D-Bus not reachable -- callers should fall back to the
|
|
* legacy INIT_SOCKET transport
|
|
* LINK_CALL_ERROR is handled internally via map_dbus_err (does not
|
|
* return). */
|
|
static int try_dbus_manager(const char *method, const char *arg_sig,
|
|
const char *arg)
|
|
{
|
|
link_client_t *c;
|
|
int rc;
|
|
|
|
c = link_client_open(FINIT_BUS_SOCKET);
|
|
if (!c)
|
|
return -1;
|
|
|
|
/* "s" methods take the service identity (arg may be NULL ->
|
|
* empty string); void methods pass no body. */
|
|
if (arg_sig && !strcmp(arg_sig, "s"))
|
|
rc = link_client_call_v(c, "/org/finit/manager",
|
|
"org.finit.Manager1", method,
|
|
"s", arg ? arg : "");
|
|
else if (!arg_sig || !*arg_sig)
|
|
rc = link_client_call_v(c, "/org/finit/manager",
|
|
"org.finit.Manager1", method, NULL);
|
|
else
|
|
rc = LINK_CALL_FAIL;
|
|
|
|
if (rc == LINK_CALL_ERROR)
|
|
map_dbus_err(c, method, arg); /* exits */
|
|
link_client_close(c);
|
|
return (rc == LINK_CALL_OK) ? 0 : -1;
|
|
}
|
|
|
|
/* Build the object path for a service identity, same encoding as the
|
|
* server side; use instead of a Manager1.GetService round-trip. */
|
|
static int dbus_svc_path(const char *ident, char *path, size_t len)
|
|
{
|
|
const char *prefix = "/org/finit/service/";
|
|
size_t plen = strlen(prefix);
|
|
|
|
if (!ident || !*ident || plen >= len)
|
|
return -1;
|
|
memcpy(path, prefix, plen);
|
|
return link_path_encode(ident, path + plen, len - plen);
|
|
}
|
|
|
|
/* Call a void-arg method on Service1 at /org/finit/service/<encoded>.
|
|
* Same return convention as try_dbus_manager. */
|
|
static int try_dbus_service(const char *method, const char *ident)
|
|
{
|
|
char path[256];
|
|
link_client_t *c;
|
|
int rc;
|
|
|
|
if (dbus_svc_path(ident, path, sizeof(path)) < 0)
|
|
return -1;
|
|
|
|
c = link_client_open(FINIT_BUS_SOCKET);
|
|
if (!c)
|
|
return -1;
|
|
|
|
rc = link_client_call_v(c, path, "org.finit.Service1", method, NULL);
|
|
if (rc == LINK_CALL_ERROR)
|
|
map_dbus_err(c, method, ident); /* exits */
|
|
link_client_close(c);
|
|
return (rc == LINK_CALL_OK) ? 0 : -1;
|
|
}
|
|
|
|
/* Try one Cond1.{Get,Set,Clear} call. On COND_GET success the helper
|
|
* fills *out_exit with the exit code (0 = on, 1 = off, 255 = flux).
|
|
* Outcomes:
|
|
* 1 call succeeded; for GET the result is in *out_exit, for
|
|
* SET/CLR the caller loops to the next arg
|
|
* 0 bus not reachable, or LINK_CALL_FAIL -- *bus is closed/NULLed
|
|
* and the caller should drop to the legacy filesystem path
|
|
* (LINK_CALL_ERROR exits via ERRX inside the helper)
|
|
*
|
|
* `*bus` is borrowed; the helper closes it (and sets NULL) on every
|
|
* exit path that leaves the bus unusable. */
|
|
static int cond_dbus_call(link_client_t **bus, condop_t op,
|
|
const char *arg, int *out_exit)
|
|
{
|
|
const char *method = (op == COND_GET) ? "Get"
|
|
: (op == COND_SET) ? "Set" : "Clear";
|
|
int rc;
|
|
|
|
if (!*bus)
|
|
return 0;
|
|
|
|
rc = link_client_call_v(*bus, "/org/finit/cond",
|
|
"org.finit.Cond1", method,
|
|
"s", arg);
|
|
if (rc == LINK_CALL_OK) {
|
|
if (op == COND_GET) {
|
|
const char *state = NULL;
|
|
|
|
link_reply_get_string(link_client_reply(*bus), &state);
|
|
if (verbose && state)
|
|
puts(state);
|
|
*out_exit = (state && !strcmp(state, "on")) ? 0
|
|
: (state && !strcmp(state, "off")) ? 1 : 255;
|
|
}
|
|
return 1;
|
|
}
|
|
if (rc == LINK_CALL_ERROR) {
|
|
char err[128];
|
|
|
|
take_dbus_err(*bus, err, sizeof(err));
|
|
link_client_close(*bus);
|
|
*bus = NULL;
|
|
if (!strcmp(err, "org.freedesktop.DBus.Error.AccessDenied"))
|
|
ERRX(1, "permission denied: cond %s requires root", method);
|
|
ERRX(73, "Failed %s condition <%s>: %s",
|
|
op == COND_SET ? "asserting" : "deasserting",
|
|
arg, err[0] ? err : "D-Bus error");
|
|
}
|
|
/* LINK_CALL_FAIL */
|
|
link_client_close(*bus);
|
|
*bus = NULL;
|
|
return 0;
|
|
}
|
|
|
|
/* Subscribe to every signal on the bus and print one line per
|
|
* incoming message:
|
|
* HH:MM:SS interface.member(arg1, arg2, ...)
|
|
*
|
|
* Only string-typed leading args are decoded (matches what our two
|
|
* current signals -- ServiceStateChanged (sss) and ConditionChanged
|
|
* (ss) -- emit). Non-string args are silently skipped. Loops until
|
|
* the connection drops or the user hits ^C. */
|
|
static int do_monitor(char *arg)
|
|
{
|
|
link_client_t *c;
|
|
int rc;
|
|
|
|
(void)arg;
|
|
|
|
c = link_client_open(FINIT_BUS_SOCKET);
|
|
if (!c)
|
|
ERRX(1, "monitor requires the D-Bus socket at %s", FINIT_BUS_SOCKET);
|
|
|
|
rc = link_client_call_v(c, "/org/freedesktop/DBus",
|
|
"org.freedesktop.DBus", "AddMatch",
|
|
"s", "type='signal'");
|
|
if (rc != LINK_CALL_OK) {
|
|
link_client_close(c);
|
|
ERRX(1, "AddMatch failed (rc=%d)", rc);
|
|
}
|
|
|
|
for (;;) {
|
|
const link_reply_t *r;
|
|
link_reader_t reader;
|
|
char ts[16];
|
|
time_t now;
|
|
struct tm tm;
|
|
|
|
rc = link_client_wait(c, -1);
|
|
if (rc < 0) {
|
|
link_client_close(c);
|
|
ERRX(1, "bus connection lost");
|
|
}
|
|
if (rc > 0) /* impossible with timeout=-1, but harmless */
|
|
continue;
|
|
r = link_client_reply(c);
|
|
if (!r || r->type != LINK_MSG_SIGNAL)
|
|
continue;
|
|
|
|
now = time(NULL);
|
|
localtime_r(&now, &tm);
|
|
strftime(ts, sizeof(ts), "%H:%M:%S", &tm);
|
|
printf("%s %s.%s(", ts,
|
|
r->interface ? r->interface : "?",
|
|
r->member ? r->member : "?");
|
|
|
|
link_reader_init(&reader, r->body, r->body_len);
|
|
if (r->signature) {
|
|
const char *p;
|
|
int first = 1;
|
|
|
|
for (p = r->signature; *p == 's'; p++) {
|
|
const char *s;
|
|
|
|
if (link_r_string(&reader, &s) < 0)
|
|
break;
|
|
printf("%s%s", first ? "" : ", ", s);
|
|
first = 0;
|
|
}
|
|
}
|
|
printf(")\n");
|
|
fflush(stdout);
|
|
}
|
|
|
|
link_client_close(c);
|
|
return 0;
|
|
}
|
|
#endif /* HAVE_DBUS */
|
|
|
|
static int do_start (char *arg)
|
|
{
|
|
#ifdef HAVE_DBUS
|
|
int rc = try_dbus_manager("Start", "s", arg);
|
|
if (rc >= 0) return rc;
|
|
#endif
|
|
return do_startstop(INIT_CMD_START_SVC, arg);
|
|
}
|
|
|
|
static int do_stop (char *arg)
|
|
{
|
|
#ifdef HAVE_DBUS
|
|
int rc = try_dbus_manager("Stop", "s", arg);
|
|
if (rc >= 0) return rc;
|
|
#endif
|
|
return do_startstop(INIT_CMD_STOP_SVC, arg);
|
|
}
|
|
|
|
static int do_reload (char *arg)
|
|
{
|
|
if (!arg || !arg[0]) {
|
|
#ifdef HAVE_DBUS
|
|
int rc = try_dbus_manager("Reload", "", NULL);
|
|
if (rc >= 0) return rc;
|
|
#endif
|
|
return do_svc(INIT_CMD_RELOAD, NULL);
|
|
}
|
|
|
|
#ifdef HAVE_DBUS
|
|
{
|
|
int rc = try_dbus_service("Reload", arg);
|
|
if (rc >= 0) return rc;
|
|
}
|
|
#endif
|
|
return do_startstop(INIT_CMD_RELOAD_SVC, arg);
|
|
}
|
|
|
|
static int do_restart(char *arg)
|
|
{
|
|
#ifdef HAVE_DBUS
|
|
int rc = try_dbus_manager("Restart", "s", arg);
|
|
if (rc == 0) return 0;
|
|
if (rc == 1) ERRX(noerr ? 0 : 7, "failed restarting %s", arg);
|
|
#endif
|
|
if (do_startstop(INIT_CMD_RESTART_SVC, arg))
|
|
ERRX(noerr ? 0 : 7, "failed restarting %s", arg);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* do_signal - Ask finit to send a signal to a service.
|
|
* @argv: must point to an array of strings, containing a service
|
|
* and signal name, in that order.
|
|
* @argc: must be 2.
|
|
*
|
|
* A signal can be a complete signal name such as "SIGHUP", or
|
|
* it can be the shortest unique name, such as "HUP" (no SIG prefix).
|
|
* It can also be a raw signal number, such as "9" (SIGKILL).
|
|
*/
|
|
int do_signal(int argc, char *argv[])
|
|
{
|
|
struct init_request rq = {
|
|
.magic = INIT_MAGIC,
|
|
.cmd = INIT_CMD_SVC_QUERY
|
|
};
|
|
int signo;
|
|
|
|
if (argc != 2)
|
|
ERRX(2, "invalid number of arguments to signal");
|
|
|
|
signo = str2sig(argv[1]);
|
|
if (signo == -1) {
|
|
const char *errstr = NULL;
|
|
|
|
signo = (int)strtonum(argv[1], 1, 31, &errstr);
|
|
if (errstr)
|
|
ERRX(65, "%s signal: %s", errstr, argv[1]);
|
|
}
|
|
|
|
#ifdef HAVE_DBUS
|
|
{
|
|
link_client_t *c = link_client_open(FINIT_BUS_SOCKET);
|
|
|
|
if (c) {
|
|
int rc = link_client_call_v(c, "/org/finit/manager",
|
|
"org.finit.Manager1", "Signal",
|
|
"su", argv[0], (uint32_t)signo);
|
|
|
|
if (rc == LINK_CALL_ERROR)
|
|
map_dbus_err(c, "Signal", argv[0]); /* exits */
|
|
link_client_close(c);
|
|
if (rc == LINK_CALL_OK)
|
|
return 0;
|
|
/* LINK_CALL_FAIL: drop to legacy */
|
|
}
|
|
}
|
|
#endif
|
|
|
|
strlcpy(rq.data, argv[0], sizeof(rq.data));
|
|
if (client_send(&rq, sizeof(rq)))
|
|
ERRX(noerr ? 0 : 69, "no such task or service(s): %s", argv[0]);
|
|
|
|
/* Reuse runlevel for signal number. */
|
|
rq.magic = INIT_MAGIC;
|
|
rq.cmd = INIT_CMD_SIGNAL;
|
|
rq.runlevel = signo;
|
|
strlcpy(rq.data, argv[0], sizeof(rq.data));
|
|
|
|
return client_send(&rq, sizeof(rq));
|
|
}
|
|
|
|
int dump_once;
|
|
char *dump_filter;
|
|
static int dump_one_cond(const char *fpath, const struct stat *sb, int tflag, struct FTW *ftwbuf)
|
|
{
|
|
const char *cond, *asserted;
|
|
char *nm = "init";
|
|
pid_t pid = 1;
|
|
svc_t *svc;
|
|
|
|
if (tflag != FTW_F)
|
|
return 0;
|
|
|
|
if (!strcmp(fpath, _PATH_RECONF))
|
|
return 0;
|
|
|
|
asserted = condstr(cond_get_path(fpath));
|
|
cond = &fpath[strlen(_PATH_COND)];
|
|
|
|
if (dump_filter && dump_filter[0] && strncmp(cond, dump_filter, strlen(dump_filter)))
|
|
return 0;
|
|
|
|
/*
|
|
* Any namespace can be claimed with provides, so ask who owns
|
|
* the condition before falling back to what the namespace
|
|
* implies on its own.
|
|
*/
|
|
svc = client_svc_find_by_cond(cond);
|
|
if (svc) {
|
|
nm = svc_ident(svc, NULL, 0);
|
|
pid = svc->pid;
|
|
} else if (strncmp("pid/", cond, 4) == 0) {
|
|
nm = "unknown";
|
|
pid = 0;
|
|
} else if (strncmp("usr/", cond, 4) == 0) {
|
|
nm = "static";
|
|
pid = 0;
|
|
} else if (strncmp("hook/", cond, 4) == 0) {
|
|
nm = "static";
|
|
pid = 1;
|
|
}
|
|
|
|
if (json) {
|
|
if (!dump_once)
|
|
puts("[");
|
|
|
|
printf("%s {\n"
|
|
" \"pid\": %d,\n"
|
|
" \"identity\": \"%s\",\n"
|
|
" \"status\": \"%s\",\n"
|
|
" \"condition\": \"%s\"\n"
|
|
" }",
|
|
dump_once ? ",\n" : "",
|
|
pid, nm, asserted, cond);
|
|
|
|
dump_once++;
|
|
} else
|
|
printf("%-*d %-*s %-6s <%s>\n", pw, pid, iw, nm, asserted, cond);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int do_cond_dump(char *arg)
|
|
{
|
|
col_widths();
|
|
if (heading && !json)
|
|
print_header("%-*s %-*s %-6s %s", pw, "PID", iw, "IDENT",
|
|
"STATUS", "CONDITION");
|
|
|
|
dump_once = 0;
|
|
dump_filter = arg;
|
|
if (nftw(_PATH_COND, dump_one_cond, 20, 0) == -1) {
|
|
WARNX("Failed parsing %s", _PATH_COND);
|
|
return 1;
|
|
}
|
|
if (dump_once)
|
|
puts("\n]");
|
|
|
|
return 0;
|
|
}
|
|
|
|
static cond_state_t cond_read(char *path)
|
|
{
|
|
int now, gen;
|
|
|
|
if (fngetint(path, &gen) == -1)
|
|
return COND_OFF;
|
|
|
|
/*
|
|
* if we cannot read the reconf generation, then either sth is
|
|
* very wrong, or we are called very early/late boot/shutdown.
|
|
*/
|
|
if (fngetint(_PATH_RECONF, &now) == -1)
|
|
return COND_FLUX; /* classify as flux */
|
|
|
|
if (now != gen)
|
|
return COND_FLUX;
|
|
|
|
return COND_ON;
|
|
}
|
|
|
|
/*
|
|
* cond get allows only one argument
|
|
* cond set|clr iterate over multiple args
|
|
*/
|
|
static int do_cond_act(char *args, condop_t op)
|
|
{
|
|
cond_state_t cstate;
|
|
char path[256];
|
|
char *arg;
|
|
#ifdef HAVE_DBUS
|
|
link_client_t *bus = link_client_open(FINIT_BUS_SOCKET);
|
|
#endif
|
|
|
|
if (!args || !args[0])
|
|
ERRX(2, "Invalid condition (empty)");
|
|
|
|
arg = strtok(args, " \t");
|
|
while (arg) {
|
|
size_t off;
|
|
|
|
if (strncmp(arg, COND_USR, strlen(COND_USR)) == 0)
|
|
arg += strlen(COND_USR);
|
|
|
|
/* allowed to read any condition, but not set/clr */
|
|
if (op != COND_GET) {
|
|
if (strchr(arg, '/'))
|
|
ERRX(2, "Invalid condition (slashes)");
|
|
if (strchr(arg, '.'))
|
|
ERRX(2, "Invalid condition (periods)");
|
|
}
|
|
|
|
#ifdef HAVE_DBUS
|
|
{
|
|
int exit_code;
|
|
|
|
if (cond_dbus_call(&bus, op, arg, &exit_code)) {
|
|
if (op == COND_GET) {
|
|
link_client_close(bus);
|
|
return exit_code;
|
|
}
|
|
arg = strtok(NULL, " \t");
|
|
continue;
|
|
}
|
|
/* bus is NULL now -- drop through to legacy */
|
|
}
|
|
#endif
|
|
|
|
if (strchr(arg, '/'))
|
|
snprintf(path, sizeof(path), _PATH_COND "%s", arg);
|
|
else
|
|
snprintf(path, sizeof(path), _PATH_CONDUSR "%s", arg);
|
|
off = strlen(_PATH_COND);
|
|
|
|
switch (op) {
|
|
case COND_GET:
|
|
cstate = cond_read(path);
|
|
if (verbose)
|
|
puts(condstr(cstate));
|
|
|
|
switch (cstate) {
|
|
case COND_ON:
|
|
return 0;
|
|
case COND_OFF:
|
|
return 1;
|
|
case COND_FLUX:
|
|
default:
|
|
break;
|
|
}
|
|
return 255;
|
|
|
|
case COND_SET:
|
|
if (symlink(_PATH_RECONF, path) && errno != EEXIST)
|
|
ERR(73, "Failed asserting condition <%s>", &path[off]);
|
|
break;
|
|
case COND_CLR:
|
|
if (erase(path) && errno != ENOENT)
|
|
ERR(73, "Failed deasserting condition <%s>", &path[off]);
|
|
break;
|
|
}
|
|
|
|
arg = strtok(NULL, " \t");
|
|
}
|
|
|
|
#ifdef HAVE_DBUS
|
|
if (bus)
|
|
link_client_close(bus);
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
static int do_cond_get(char *arg) { return do_cond_act(arg, COND_GET); }
|
|
static int do_cond_set(char *arg) { return do_cond_act(arg, COND_SET); }
|
|
static int do_cond_clr(char *arg) { return do_cond_act(arg, COND_CLR); }
|
|
|
|
static char *cond_string(const char *condstr, char *buf, size_t len, int ansi)
|
|
{
|
|
char *cond, *conds;
|
|
|
|
buf[0] = 0;
|
|
|
|
if (!condstr || !condstr[0])
|
|
return buf;
|
|
|
|
conds = strdupa(condstr);
|
|
if (!conds)
|
|
return buf;
|
|
|
|
if (json)
|
|
strlcat(buf, "[ ", len);
|
|
|
|
for (cond = strtok(conds, ","); cond; cond = strtok(NULL, ",")) {
|
|
if (cond != conds) {
|
|
strlcat(buf, ",", len);
|
|
if (json)
|
|
strlcat(buf, " ", len);
|
|
}
|
|
|
|
if (json)
|
|
strlcat(buf, "\"", len);
|
|
|
|
switch (cond_get(cond)) {
|
|
case COND_ON:
|
|
strlcat(buf, "+", len);
|
|
strlcat(buf, cond, len);
|
|
break;
|
|
|
|
case COND_FLUX:
|
|
if (ansi)
|
|
strlcat(buf, "\e[1m", len);
|
|
strlcat(buf, "~", len);
|
|
strlcat(buf, cond, len);
|
|
if (ansi)
|
|
strlcat(buf, "\e[0m", len);
|
|
break;
|
|
|
|
case COND_OFF:
|
|
if (ansi)
|
|
strlcat(buf, "\e[1m", len);
|
|
strlcat(buf, "-", len);
|
|
strlcat(buf, cond, len);
|
|
if (ansi)
|
|
strlcat(buf, "\e[0m", len);
|
|
break;
|
|
}
|
|
|
|
if (json)
|
|
strlcat(buf, "\"", len);
|
|
}
|
|
|
|
if (json)
|
|
strlcat(buf, " ]", len);
|
|
|
|
return buf;
|
|
}
|
|
|
|
static char *svc_cond(svc_t *svc, char *buf, size_t len, int ansi)
|
|
{
|
|
return cond_string(svc->cond, buf, len, ansi);
|
|
}
|
|
|
|
static int do_cond_show(char *arg)
|
|
{
|
|
enum cond_state cond;
|
|
char buf[512];
|
|
int once = 0;
|
|
svc_t *svc;
|
|
|
|
col_widths();
|
|
if (heading && !json)
|
|
print_header("%-*s %-*s %-6s %s", pw, "PID", iw, "IDENT",
|
|
"STATUS", "CONDITION (+ ON, ~ FLUX, - OFF)");
|
|
|
|
for (svc = client_svc_iterator(1); svc; svc = client_svc_iterator(0)) {
|
|
if (!svc->cond[0])
|
|
continue;
|
|
|
|
cond = cond_get_agg(svc->cond);
|
|
svc_ident(svc, buf, sizeof(buf));
|
|
|
|
if (json) {
|
|
if (!once)
|
|
puts("[");
|
|
|
|
printf("%s {\n"
|
|
" \"pid\": %d,\n"
|
|
" \"identity\": \"%s\",\n"
|
|
" \"status\": \"%s\",\n",
|
|
once ? ",\n" : "",
|
|
svc->pid,
|
|
buf,
|
|
condstr(cond));
|
|
svc_cond(svc, buf, sizeof(buf), !plain);
|
|
printf(" \"condition\": %s\n"
|
|
" }", buf);
|
|
|
|
once++;
|
|
continue;
|
|
}
|
|
|
|
printf("%-*d %-*s ", pw, svc->pid, iw, buf);
|
|
|
|
if (cond == COND_ON)
|
|
printf("%-6.6s ", condstr(cond));
|
|
else
|
|
printf("\e[1m%-6.6s\e[0m ", condstr(cond));
|
|
|
|
svc_cond(svc, buf, sizeof(buf), !plain);
|
|
if (buf[0])
|
|
printf("<%s>", buf);
|
|
puts("");
|
|
}
|
|
|
|
if (json && once)
|
|
puts("\n]");
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int do_cmd(int cmd)
|
|
{
|
|
struct init_request rq = {
|
|
.magic = INIT_MAGIC,
|
|
.cmd = cmd,
|
|
.sleeptime = timeout,
|
|
};
|
|
|
|
if (client_send(&rq, sizeof(rq))) {
|
|
if (rq.cmd == INIT_CMD_NACK)
|
|
puts(rq.data);
|
|
|
|
return 1;
|
|
}
|
|
|
|
/* Wait here for systemd to shutdown/reboot */
|
|
sleep(5);
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef HAVE_DBUS
|
|
static int do_reboot_dbus(const char *method)
|
|
{
|
|
link_client_t *c;
|
|
int rc;
|
|
|
|
c = link_client_open(FINIT_BUS_SOCKET);
|
|
if (!c)
|
|
return -1; /* fall back to legacy transport */
|
|
|
|
/* Timeout in seconds arms the emergency shutdown bypass, 0 = none */
|
|
rc = link_client_call_v(c, "/org/finit/manager",
|
|
"org.finit.Manager1", method,
|
|
"u", (uint32_t)timeout);
|
|
if (rc == LINK_CALL_ERROR)
|
|
map_dbus_err(c, method, NULL); /* exits */
|
|
link_client_close(c);
|
|
|
|
if (rc == LINK_CALL_OK) {
|
|
sleep(5); /* match legacy: wait for finit to shut down */
|
|
return 0;
|
|
}
|
|
return -1; /* fall back */
|
|
}
|
|
#endif
|
|
|
|
/* Scheduled shutdown, see issue #149, @cmd is INIT_CMD_REBOOT, _HALT or _POWEROFF */
|
|
int do_shutdown_at(int cmd, int sec, const char *msg)
|
|
{
|
|
struct init_request rq = {
|
|
.magic = INIT_MAGIC,
|
|
.cmd = INIT_CMD_SHUTDOWN,
|
|
.runlevel = cmd,
|
|
.sleeptime = sec,
|
|
};
|
|
|
|
strlcpy(rq.data, msg ? msg : "", sizeof(rq.data));
|
|
return client_send(&rq, sizeof(rq));
|
|
}
|
|
|
|
int do_shutdown_cancel(void)
|
|
{
|
|
struct init_request rq = {
|
|
.magic = INIT_MAGIC,
|
|
.cmd = INIT_CMD_SHUTDOWN_CANCEL,
|
|
};
|
|
|
|
if (client_send(&rq, sizeof(rq))) {
|
|
if (rq.cmd == INIT_CMD_NACK)
|
|
warnx("%s", rq.data);
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int do_reboot (char *arg)
|
|
{
|
|
#ifdef HAVE_DBUS
|
|
int rc = do_reboot_dbus("Reboot");
|
|
if (rc >= 0) return rc;
|
|
#endif
|
|
return do_cmd(INIT_CMD_REBOOT);
|
|
}
|
|
|
|
int do_halt (char *arg)
|
|
{
|
|
#ifdef HAVE_DBUS
|
|
int rc = do_reboot_dbus("Halt");
|
|
if (rc >= 0) return rc;
|
|
#endif
|
|
return do_cmd(INIT_CMD_HALT);
|
|
}
|
|
|
|
int do_poweroff(char *arg)
|
|
{
|
|
#ifdef HAVE_DBUS
|
|
int rc = do_reboot_dbus("Poweroff");
|
|
if (rc >= 0) return rc;
|
|
#endif
|
|
return do_cmd(INIT_CMD_POWEROFF);
|
|
}
|
|
|
|
int do_suspend(char *arg)
|
|
{
|
|
(void)arg;
|
|
#ifdef HAVE_DBUS
|
|
{
|
|
int rc = try_dbus_manager("Suspend", "", NULL);
|
|
if (rc >= 0) return rc;
|
|
}
|
|
#endif
|
|
return do_cmd(INIT_CMD_SUSPEND);
|
|
}
|
|
|
|
/**
|
|
* do_switch_root - Switch to a new root filesystem (initramfs only)
|
|
* @argc: Number of arguments (1 or 2)
|
|
* @argv: [0] = newroot path, [1] = optional init path
|
|
*
|
|
* This command is only valid during runlevel S (bootstrap) or 1 when
|
|
* running from an initramfs. It stops all services, moves virtual
|
|
* filesystems, and exec's the new init.
|
|
*/
|
|
int do_switch_root(int argc, char *argv[])
|
|
{
|
|
struct init_request rq = {
|
|
.magic = INIT_MAGIC,
|
|
.cmd = INIT_CMD_SWITCH_ROOT,
|
|
};
|
|
char *newroot, *newinit = NULL;
|
|
size_t off;
|
|
|
|
if (argc < 1)
|
|
ERRX(2, "Usage: initctl switch-root NEWROOT [INIT]");
|
|
|
|
newroot = argv[0];
|
|
if (argc > 1)
|
|
newinit = argv[1];
|
|
|
|
/* Verify newroot exists */
|
|
if (access(newroot, F_OK))
|
|
ERR(1, "Cannot access %s", newroot);
|
|
|
|
/*
|
|
* Pack both strings into rq.data with null separators:
|
|
* "newroot\0newinit\0"
|
|
*/
|
|
strlcpy(rq.data, newroot, sizeof(rq.data));
|
|
off = strlen(newroot) + 1;
|
|
|
|
if (newinit && off < sizeof(rq.data) - 1)
|
|
strlcpy(rq.data + off, newinit, sizeof(rq.data) - off);
|
|
|
|
printf("Switching root to %s", newroot);
|
|
if (newinit)
|
|
printf(", init %s", newinit);
|
|
printf(" ...\n");
|
|
|
|
/*
|
|
* Unlike do_cmd(), a failing client_send() is expected here: on
|
|
* success Finit execs the new init and the connection dies with
|
|
* no reply. Only an explicit NACK means the request was denied.
|
|
*/
|
|
if (client_send(&rq, sizeof(rq)) && rq.cmd == INIT_CMD_NACK) {
|
|
puts(rq.data);
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int utmp_show(char *file)
|
|
{
|
|
struct utmp *ut;
|
|
time_t sec;
|
|
|
|
if (heading) {
|
|
static int once = 0;
|
|
|
|
print_header("%s%s ", once ? "\n" : "", file);
|
|
once++;
|
|
}
|
|
utmpname(file);
|
|
|
|
setutent();
|
|
while ((ut = getutent())) {
|
|
char user[sizeof(ut->ut_user) + 1];
|
|
char id[sizeof(ut->ut_id) + 1];
|
|
struct tm *sectm;
|
|
char when[80];
|
|
char addr[64];
|
|
int pid;
|
|
|
|
strlcpy(id, ut->ut_id, sizeof(id));
|
|
strlcpy(user, ut->ut_user, sizeof(user));
|
|
|
|
sec = ut->ut_tv.tv_sec;
|
|
sectm = localtime(&sec);
|
|
strftime(when, sizeof(when), "%F %T", sectm);
|
|
|
|
pid = ut->ut_pid;
|
|
if (ut->ut_addr_v6[1] || ut->ut_addr_v6[2] || ut->ut_addr_v6[3])
|
|
inet_ntop(AF_INET6, ut->ut_addr_v6, addr, sizeof(addr));
|
|
else
|
|
inet_ntop(AF_INET, &ut->ut_addr, addr, sizeof(addr));
|
|
|
|
printf("[%d] [%05d] [%-4.4s] [%-8.8s] [%-12.12s] [%-20.20s] [%-15.15s] [%-19.19s]\n",
|
|
ut->ut_type, pid, id, user, ut->ut_line, ut->ut_host, addr, when);
|
|
}
|
|
endutent();
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int do_utmp(char *file)
|
|
{
|
|
if (!utmp)
|
|
return 1;
|
|
|
|
if (fexist(file))
|
|
return utmp_show(file);
|
|
|
|
return utmp_show(_PATH_WTMP) ||
|
|
utmp_show(_PATH_UTMP);
|
|
}
|
|
|
|
static int show_version(char *arg)
|
|
{
|
|
puts(PACKAGE_STRING);
|
|
printf("Bug report address: %-40s\n", PACKAGE_BUGREPORT);
|
|
#ifdef PACKAGE_URL
|
|
printf("Project homepage: %s\n", PACKAGE_URL);
|
|
#endif
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int plugins_list(char *arg)
|
|
{
|
|
struct init_request rq = {
|
|
.magic = INIT_MAGIC,
|
|
.cmd = INIT_CMD_GET_PLUGINS,
|
|
};
|
|
char buf[sizeof(rq.data) + 1];
|
|
char *ptr;
|
|
int rc;
|
|
|
|
rc = client_send(&rq, sizeof(rq));
|
|
if (rc) {
|
|
if (rc == 255)
|
|
return 69;
|
|
else
|
|
ERRX(69, "No such command");
|
|
}
|
|
memcpy(buf, rq.data, sizeof(buf) - 1);
|
|
buf[sizeof(rq.data)] = 0;
|
|
|
|
if (heading)
|
|
print_header("%-18s %s", "PLUGIN", "DEPENDENCIES");
|
|
|
|
ptr = strtok(buf, " ");
|
|
while (ptr) {
|
|
rq.cmd = INIT_CMD_PLUGIN_DEPS;
|
|
strlcpy(rq.data, ptr, sizeof(rq.data));
|
|
rc = client_send(&rq, sizeof(rq));
|
|
if (rc)
|
|
printf("%s\n", ptr);
|
|
else
|
|
printf("%-18s %s\n", ptr, rq.data);
|
|
|
|
ptr = strtok(NULL, " ");
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* runlevel_string - Convert a bit encoded runlevel to .conf syntax
|
|
* @levels: Bit encoded runlevels
|
|
*
|
|
* Returns:
|
|
* Pointer to string on the form [2345], may be up to 12 chars long,
|
|
* plus escape sequences for highlighting current runlevel.
|
|
*/
|
|
char *runlevel_string(int currlevel, int levels)
|
|
{
|
|
static char lvl[32];
|
|
int i = INIT_LEVEL;
|
|
|
|
strlcpy(lvl, "[", sizeof(lvl));
|
|
|
|
do {
|
|
if (ISSET(levels, i)) {
|
|
char l[2] = { '0' + i, 0 };
|
|
|
|
if (!plain && currlevel == i)
|
|
strlcat(lvl, "\e[1m", sizeof(lvl));
|
|
|
|
strlcat(lvl, i == INIT_LEVEL ? "S" : l, sizeof(lvl));
|
|
|
|
if (!plain && currlevel == i)
|
|
strlcat(lvl, "\e[0m", sizeof(lvl));
|
|
} else {
|
|
strlcat(lvl, "-", sizeof(lvl));
|
|
}
|
|
|
|
/* XXX: ugly hack to get order right: S0123456789 */
|
|
if (i == INIT_LEVEL)
|
|
i = 0;
|
|
else
|
|
i++;
|
|
} while (i < INIT_LEVEL);
|
|
|
|
strlcat(lvl, "]", sizeof(lvl));
|
|
|
|
return lvl;
|
|
}
|
|
|
|
char *runlevel_arr(int levels)
|
|
{
|
|
static char lvl[42];
|
|
int i = INIT_LEVEL;
|
|
int p = 2, s = 0;
|
|
|
|
strlcpy(lvl, "[ ", sizeof(lvl));
|
|
do {
|
|
if (ISSET(levels, i)) {
|
|
if (i == INIT_LEVEL)
|
|
p += snprintf(&lvl[p], sizeof(lvl) - p, "\"S\"");
|
|
else
|
|
p += snprintf(&lvl[p], sizeof(lvl) - p, "%s%c", s ? ", " : "", '0' + i);
|
|
s++;
|
|
}
|
|
/* XXX: ugly hack to get order right: S0123456789 */
|
|
if (i == INIT_LEVEL)
|
|
i = 0;
|
|
else
|
|
i++;
|
|
} while (i < INIT_LEVEL);
|
|
strlcat(lvl, " ]", sizeof(lvl));
|
|
|
|
return lvl;
|
|
}
|
|
|
|
static char *svc_command(svc_t *svc, char *buf, size_t len)
|
|
{
|
|
strlcpy(buf, svc->cmd, len);
|
|
|
|
for (int i = 1; i < MAX_NUM_SVC_ARGS; i++) {
|
|
if (!svc->args[i][0])
|
|
break;
|
|
|
|
strlcat(buf, " ", len);
|
|
strlcat(buf, svc->args[i], len);
|
|
}
|
|
|
|
if (svc_is_sysv(svc)) {
|
|
char *cmd = svc->state == SVC_HALTED_STATE ? "stop" : "start";
|
|
|
|
strlcat(buf, " ", len);
|
|
strlcat(buf, cmd, len);
|
|
}
|
|
|
|
return buf;
|
|
}
|
|
|
|
static char *exit_status_raw(int status, int manual, char *buf, size_t len)
|
|
{
|
|
int rc, sig;
|
|
char *str;
|
|
|
|
rc = WEXITSTATUS(status);
|
|
sig = WTERMSIG(status);
|
|
|
|
if (WIFEXITED(status)) {
|
|
str = code2str(rc);
|
|
snprintf(buf, len, " (code=exited, status=%d%s%s%s)", rc,
|
|
str[0] ? "/" : "", str,
|
|
manual ? ", manual=yes" : "");
|
|
}
|
|
else if (WIFSIGNALED(status)) {
|
|
str = sig2str(sig);
|
|
snprintf(buf, len, " (code=signal, status=%d%s%s)", sig, str[0] ? "/" : "", str);
|
|
}
|
|
|
|
return buf;
|
|
}
|
|
|
|
static void show_cgroup_tree(char *group, char *pfx)
|
|
{
|
|
char path[256];
|
|
|
|
if (!group) {
|
|
puts("");
|
|
return;
|
|
}
|
|
|
|
strlcpy(path, FINIT_CGPATH, sizeof(path));
|
|
strlcat(path, group, sizeof(path));
|
|
|
|
cgroup_tree(path, pfx, 0, 0);
|
|
}
|
|
|
|
/*
|
|
* arg: 'foo' should match foo:1 foo:2, etc. but not foobar
|
|
* arg: 'foo:1' should only match foo:1
|
|
* arg: 'foo:' is allowed to fail, unsupported syntax atm
|
|
* arg: 'foo:*' is allowed to fail, unsupported syntax atm
|
|
*/
|
|
static int svc_compare(svc_t *svc, char *arg)
|
|
{
|
|
char ident[MAX_IDENT_LEN];
|
|
char *ptr;
|
|
|
|
svc_ident(svc, ident, sizeof(ident));
|
|
ptr = strchr(ident, ':');
|
|
if (ptr && !strchr(arg, ':'))
|
|
*ptr = 0;
|
|
|
|
if (!strcmp(ident, arg))
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* All fields the status views need, transport-independent: filled
|
|
* from a raw svc_t on the legacy socket path or from Service1
|
|
* properties on the D-Bus path, rendered by the same printers.
|
|
*/
|
|
struct svc_row {
|
|
char ident[MAX_IDENT_LEN];
|
|
char state[16];
|
|
char type[16];
|
|
char desc[MAX_STR_LEN];
|
|
char cmdline[512];
|
|
char env[MAX_CMD_LEN];
|
|
char cond[MAX_COND_LEN];
|
|
char pidfile[MAX_CMD_LEN];
|
|
char user[MAX_USER_LEN];
|
|
char grp[MAX_USER_LEN];
|
|
char origin[MAX_ARG_LEN];
|
|
uint32_t pid;
|
|
uint32_t runlevels;
|
|
uint32_t uptime; /* seconds, 0 when not running */
|
|
uint32_t exitstatus; /* raw waitpid(2) status */
|
|
uint32_t starts;
|
|
int32_t restart_tot;
|
|
int32_t restart_cnt;
|
|
int32_t restart_max; /* -1 = restart:always */
|
|
uint32_t restart_delay; /* seconds, before the next restart */
|
|
uint32_t restart_delay_max; /* restart-max-sec, 0 = not set */
|
|
int manual;
|
|
int forking;
|
|
int started;
|
|
};
|
|
|
|
static void fill_row_from_svc(struct svc_row *r, svc_t *svc)
|
|
{
|
|
long now = jiffies();
|
|
|
|
memset(r, 0, sizeof(*r));
|
|
svc_ident(svc, r->ident, sizeof(r->ident));
|
|
strlcpy(r->state, svc_status(svc), sizeof(r->state));
|
|
strlcpy(r->type, svc_typestr(svc), sizeof(r->type));
|
|
strlcpy(r->desc, svc->desc, sizeof(r->desc));
|
|
svc_command(svc, r->cmdline, sizeof(r->cmdline));
|
|
strlcpy(r->env, svc->env, sizeof(r->env));
|
|
strlcpy(r->cond, svc->cond, sizeof(r->cond));
|
|
strlcpy(r->pidfile, svc->pidfile, sizeof(r->pidfile));
|
|
strlcpy(r->user, svc->username, sizeof(r->user));
|
|
strlcpy(r->grp, svc->group, sizeof(r->grp));
|
|
strlcpy(r->origin, svc->file, sizeof(r->origin));
|
|
r->pid = svc->pid > 0 ? (uint32_t)svc->pid : 0;
|
|
r->runlevels = (uint32_t)svc->runlevels;
|
|
if (svc->pid && now > svc->start_time)
|
|
r->uptime = (uint32_t)(now - svc->start_time);
|
|
r->exitstatus = (uint32_t)svc->status;
|
|
r->starts = (uint32_t)svc->once;
|
|
r->restart_tot = (int32_t)svc->restart_tot;
|
|
r->restart_cnt = (int32_t)svc->restart_cnt;
|
|
r->restart_max = (int32_t)svc->restart_max;
|
|
r->restart_delay = (uint32_t)svc->restart_tmo / 1000;
|
|
r->restart_delay_max = (uint32_t)svc->restart_tmo_max / 1000;
|
|
r->manual = svc->manual;
|
|
r->forking = svc->forking;
|
|
r->started = svc->started;
|
|
}
|
|
|
|
static const char *pidfile_str(struct svc_row *r)
|
|
{
|
|
const char *pidfn = r->pidfile;
|
|
|
|
if (pidfn[0] == '!')
|
|
pidfn++;
|
|
else if (pidfn[0] == 0)
|
|
pidfn = "none";
|
|
|
|
return pidfn;
|
|
}
|
|
|
|
/* string-only twin of svc_checkenv() */
|
|
static int checkenv_str(const char *env)
|
|
{
|
|
if (!env || !env[0] || env[0] == '-')
|
|
return 1;
|
|
|
|
return fexist(env);
|
|
}
|
|
|
|
/* same matching rules as svc_compare() */
|
|
static int row_compare(struct svc_row *r, char *arg)
|
|
{
|
|
char ident[MAX_IDENT_LEN];
|
|
char *ptr;
|
|
|
|
strlcpy(ident, r->ident, sizeof(ident));
|
|
ptr = strchr(ident, ':');
|
|
if (ptr && !strchr(arg, ':'))
|
|
*ptr = 0;
|
|
|
|
return !strcmp(ident, arg);
|
|
}
|
|
|
|
static int row_missing(struct svc_row *r)
|
|
{
|
|
char argv0[512];
|
|
char *sep;
|
|
|
|
if (strcmp(r->state, "missing"))
|
|
return 0;
|
|
|
|
strlcpy(argv0, r->cmdline, sizeof(argv0));
|
|
sep = strchr(argv0, ' ');
|
|
if (sep)
|
|
*sep = 0;
|
|
|
|
return !whichp(argv0);
|
|
}
|
|
|
|
/* the words svc_status() emits for a blocked/halted service */
|
|
static const char *halted_words[] = {
|
|
"halted", "missing", "crashed", "stopped", "busy",
|
|
"restart", "conflict", "unknown", NULL
|
|
};
|
|
|
|
/* transport-independent status(svc, full) */
|
|
static char *row_status(struct svc_row *r, int full)
|
|
{
|
|
static char buf[96];
|
|
const char *color;
|
|
char ok[48] = {0};
|
|
int st = (int)r->exitstatus;
|
|
size_t i;
|
|
|
|
if (!full) {
|
|
snprintf(buf, sizeof(buf), "%-8.8s", r->state);
|
|
return buf;
|
|
}
|
|
|
|
if (!strcmp(r->state, "running")) {
|
|
color = "\e[1;32m";
|
|
} else if (!strcmp(r->state, "done") || !strcmp(r->state, "failed")) {
|
|
exit_status_raw(st, r->manual, ok, sizeof(ok));
|
|
if (WIFEXITED(st))
|
|
color = WEXITSTATUS(st) ? "\e[1;31m" : "\e[1;32m";
|
|
else if (WIFSIGNALED(st))
|
|
color = "\e[1;31m";
|
|
else
|
|
color = "\e[1;33m";
|
|
} else {
|
|
exit_status_raw(st, r->manual, ok, sizeof(ok));
|
|
color = "\e[1;33m";
|
|
for (i = 0; halted_words[i]; i++) {
|
|
if (!strcmp(r->state, halted_words[i])) {
|
|
color = "\e[1m";
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (plain)
|
|
color = NULL;
|
|
|
|
snprintf(buf, sizeof(buf), "%s%s%s%s",
|
|
color ? color : "", r->state, ok, color ? "\e[0m" : "");
|
|
|
|
return buf;
|
|
}
|
|
|
|
/* scripting mode: exit code only, same rules as the legacy path */
|
|
static int quiet_row(struct svc_row *r)
|
|
{
|
|
if (!strcmp(r->type, "run") || !strcmp(r->type, "task"))
|
|
return r->started ? 0 : 1;
|
|
|
|
return strcmp(r->state, "running") != 0;
|
|
}
|
|
|
|
/*
|
|
* Escape a string for safe JSON output. Handles quotes, backslashes,
|
|
* and control characters. Returns pointer to static buffer.
|
|
*/
|
|
static char *json_escape(const char *str)
|
|
{
|
|
static char buf[1024];
|
|
char *ptr = buf;
|
|
size_t left = sizeof(buf) - 1;
|
|
|
|
if (!str)
|
|
return "";
|
|
|
|
while (*str && left > 1) {
|
|
char c = *str++;
|
|
|
|
switch (c) {
|
|
case '"':
|
|
case '\\':
|
|
*ptr++ = '\\';
|
|
*ptr++ = c;
|
|
left -= 2;
|
|
break;
|
|
case '\n':
|
|
*ptr++ = '\\';
|
|
*ptr++ = 'n';
|
|
left -= 2;
|
|
break;
|
|
case '\r':
|
|
*ptr++ = '\\';
|
|
*ptr++ = 'r';
|
|
left -= 2;
|
|
break;
|
|
case '\t':
|
|
*ptr++ = '\\';
|
|
*ptr++ = 't';
|
|
left -= 2;
|
|
break;
|
|
default:
|
|
if ((unsigned char)c < 0x20) {
|
|
/* Other control chars: use \uXXXX */
|
|
int n = snprintf(ptr, left, "\\u%04x", (unsigned char)c);
|
|
ptr += n;
|
|
left -= n;
|
|
} else {
|
|
*ptr++ = c;
|
|
left--;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
*ptr = '\0';
|
|
|
|
return buf;
|
|
}
|
|
|
|
static int json_status_one(FILE *fp, struct svc_row *r, char *indent, int prev)
|
|
{
|
|
const char *pidfn = pidfile_str(r);
|
|
char buf[512];
|
|
|
|
fprintf(fp,
|
|
"%s"
|
|
"%s{\n"
|
|
"%s \"identity\": \"%s\",\n",
|
|
prev ? ",\n" : indent, prev ? indent : "",
|
|
indent, r->ident);
|
|
fprintf(fp,
|
|
"%s \"description\": \"%s\",\n",
|
|
indent, json_escape(r->desc));
|
|
fprintf(fp,
|
|
"%s \"type\": \"%s\",\n"
|
|
"%s \"forking\": %s,\n"
|
|
"%s \"status\": \"%s\",\n",
|
|
indent, r->type,
|
|
indent, r->forking ? "true" : "false",
|
|
indent, r->state);
|
|
|
|
if (strcmp(r->state, "running")) {
|
|
int st = (int)r->exitstatus;
|
|
int rc, sig;
|
|
|
|
rc = WEXITSTATUS(st);
|
|
sig = WTERMSIG(st);
|
|
|
|
if (WIFEXITED(st))
|
|
fprintf(fp,
|
|
"%s \"exit\": { \"%s\": %d },\n",
|
|
indent, "code", rc);
|
|
else if (WIFSIGNALED(st))
|
|
fprintf(fp,
|
|
"%s \"exit\": { \"%s\": %d },\n",
|
|
indent, "signal", sig);
|
|
}
|
|
|
|
fprintf(fp,
|
|
"%s \"origin\": \"%s\",\n",
|
|
indent, r->origin[0] ? r->origin : "built-in");
|
|
fprintf(fp,
|
|
"%s \"command\": \"%s\",\n",
|
|
indent, json_escape(r->cmdline));
|
|
|
|
if (r->env[0])
|
|
fprintf(fp,
|
|
"%s \"environment\": \"%s\",\n", indent, json_escape(r->env));
|
|
|
|
cond_string(r->cond, buf, sizeof(buf), 0);
|
|
if (buf[0])
|
|
fprintf(fp,
|
|
"%s \"condition\": %s,\n", indent, buf);
|
|
|
|
if (r->manual)
|
|
fprintf(fp,
|
|
"%s \"starts\": %u,\n", indent, r->starts);
|
|
|
|
fprintf(fp,
|
|
"%s \"restarts\": %d,\n", indent, r->restart_tot); /* XXX: add restart_cnt and restart_max */
|
|
|
|
/* Add memory and CPU information if cgroup support is available */
|
|
if (cgrp && r->pid > 1) {
|
|
char *group = pid_cgroup(r->pid);
|
|
|
|
if (group) {
|
|
uint64_t throttled_usec = 0;
|
|
uint64_t nr_throttled = 0;
|
|
char path[256];
|
|
struct cg *cg;
|
|
|
|
fprintf(fp, "%s \"cgroup\": \"%s\",\n", indent, group);
|
|
fprintf(fp, "%s \"memory\": %lu,\n", indent, cgroup_memory(group));
|
|
|
|
if (cgroup_throttle(group, &throttled_usec, &nr_throttled) == 0) {
|
|
fprintf(fp, "%s \"cpu\": {\n", indent);
|
|
fprintf(fp, "%s \"throttled_usec\": %lu,\n", indent, throttled_usec);
|
|
fprintf(fp, "%s \"nr_throttled\": %lu\n", indent, nr_throttled);
|
|
fprintf(fp, "%s },\n", indent);
|
|
}
|
|
|
|
/* Add limits structure using existing cg_conf() */
|
|
snprintf(path, sizeof(path), "%s/%s", FINIT_CGPATH, group);
|
|
cg = cg_conf(path);
|
|
|
|
if (cg && (cg->cg_mem.min[0] || cg->cg_mem.max[0] ||
|
|
cg->cg_cpu.weight[0] || cg->cg_cpu.max[0])) {
|
|
int has_memory = cg->cg_mem.min[0] || cg->cg_mem.max[0];
|
|
int has_cpu = cg->cg_cpu.weight[0] || cg->cg_cpu.max[0];
|
|
|
|
fprintf(fp, "%s \"limits\": {\n", indent);
|
|
|
|
if (has_memory) {
|
|
fprintf(fp, "%s \"memory\": {\n", indent);
|
|
if (cg->cg_mem.min[0]) {
|
|
if (!strcmp(cg->cg_mem.min, "max"))
|
|
fprintf(fp, "%s \"min\": \"%s\"", indent, cg->cg_mem.min);
|
|
else
|
|
fprintf(fp, "%s \"min\": %s", indent, cg->cg_mem.min);
|
|
if (cg->cg_mem.max[0])
|
|
fprintf(fp, ",\n");
|
|
else
|
|
fprintf(fp, "\n");
|
|
}
|
|
if (cg->cg_mem.max[0]) {
|
|
if (!strcmp(cg->cg_mem.max, "max"))
|
|
fprintf(fp, "%s \"max\": \"%s\"\n", indent, cg->cg_mem.max);
|
|
else
|
|
fprintf(fp, "%s \"max\": %s\n", indent, cg->cg_mem.max);
|
|
}
|
|
fprintf(fp, "%s }", indent);
|
|
if (has_cpu)
|
|
fprintf(fp, ",\n");
|
|
else
|
|
fprintf(fp, "\n");
|
|
}
|
|
|
|
if (has_cpu) {
|
|
char cpu_burst[32];
|
|
char *quota, *period;
|
|
char max_copy[32];
|
|
|
|
fprintf(fp, "%s \"cpu\": {\n", indent);
|
|
|
|
if (cg->cg_cpu.weight[0])
|
|
fprintf(fp, "%s \"weight\": %s,\n", indent, cg->cg_cpu.weight);
|
|
|
|
if (cg->cg_cpu.max[0]) {
|
|
/* Split cpu.max into quota and period */
|
|
strlcpy(max_copy, cg->cg_cpu.max, sizeof(max_copy));
|
|
quota = strtok(max_copy, " ");
|
|
period = strtok(NULL, " ");
|
|
|
|
fprintf(fp, "%s \"max\": {\n", indent);
|
|
if (quota) {
|
|
if (!strcmp(quota, "max"))
|
|
fprintf(fp, "%s \"quota\": \"%s\"", indent, quota);
|
|
else
|
|
fprintf(fp, "%s \"quota\": %s", indent, quota);
|
|
if (period)
|
|
fprintf(fp, ",\n");
|
|
else
|
|
fprintf(fp, "\n");
|
|
}
|
|
if (period)
|
|
fprintf(fp, "%s \"period\": %s\n", indent, period);
|
|
fprintf(fp, "%s }", indent);
|
|
|
|
/* Check for cpu.max.burst (kernel >= 5.14) */
|
|
if (cgroup_val(path, "cpu.max.burst", cpu_burst, sizeof(cpu_burst)))
|
|
fprintf(fp, ",\n%s \"max_burst\": %s\n", indent, cpu_burst);
|
|
else
|
|
fprintf(fp, "\n");
|
|
}
|
|
|
|
fprintf(fp, "%s }\n", indent);
|
|
}
|
|
|
|
fprintf(fp, "%s },\n", indent);
|
|
}
|
|
|
|
free(group);
|
|
}
|
|
}
|
|
|
|
fprintf(fp,
|
|
"%s \"pidfile\": \"%s\",\n"
|
|
"%s \"pid\": %u,\n"
|
|
"%s \"user\": \"%s\",\n"
|
|
"%s \"group\": \"%s\",\n"
|
|
"%s \"uptime\": %ld,\n"
|
|
"%s \"runlevels\": %s\n"
|
|
"%s}",
|
|
indent, pidfn,
|
|
indent, r->pid,
|
|
indent, r->user,
|
|
indent, r->grp,
|
|
indent, (long)r->uptime,
|
|
indent, runlevel_arr((int)r->runlevels),
|
|
indent);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void status_heading(int pidw, int identw)
|
|
{
|
|
char title[80];
|
|
|
|
snprintf(title, sizeof(title), "%-*s %-*s %-8s %-13s ",
|
|
pidw, "PID", identw, "IDENT", "STATUS", "RUNLEVELS");
|
|
strlcat(title, !verbose ? "DESCRIPTION" : "COMMAND", sizeof(title));
|
|
print_header("%s", title);
|
|
}
|
|
|
|
static void print_runlevels(const char *lvls)
|
|
{
|
|
/* ANSI escapes for the active level eat into the field width */
|
|
if (strchr(lvls, '\e'))
|
|
printf("%-21.21s ", lvls);
|
|
else
|
|
printf("%-13.13s ", lvls);
|
|
}
|
|
|
|
/*
|
|
* The detail view, shared by the legacy and D-Bus paths; the caller
|
|
* fills a svc_row from its transport first. Cgroup statistics and
|
|
* the log tail are always local operations, they only need the PID.
|
|
*/
|
|
static int show_one_row(struct svc_row *r)
|
|
{
|
|
char uptm[42] = "N/A";
|
|
char buf[512];
|
|
int bold;
|
|
|
|
printf(" Status : %s\n", row_status(r, 1));
|
|
printf(" Identity : %s\n", r->ident);
|
|
printf("Description : %s\n", r->desc);
|
|
printf(" Origin : %s\n", r->origin[0] ? r->origin : "built-in");
|
|
|
|
if (r->env[0]) {
|
|
bold = !plain && !strcmp(r->state, "missing") &&
|
|
!checkenv_str(r->env);
|
|
printf("Environment : %s%s%s\n", bold ? "\e[1m" : "",
|
|
r->env, bold ? "\e[0m" : "");
|
|
}
|
|
|
|
cond_string(r->cond, buf, sizeof(buf), !plain);
|
|
if (buf[0])
|
|
printf("Condition(s): <%s>\n", buf);
|
|
|
|
bold = !plain && row_missing(r);
|
|
printf(" Command : %s%s%s\n", bold ? "\e[1m" : "",
|
|
r->cmdline, bold ? "\e[0m" : "");
|
|
printf(" PID file : %s\n", pidfile_str(r));
|
|
printf(" PID : %u\n", r->pid);
|
|
printf(" User : %s\n", r->user);
|
|
printf(" Group : %s\n", r->grp);
|
|
printf(" Uptime : %s\n", r->pid
|
|
? uptime((long)r->uptime, uptm, sizeof(uptm)) : uptm);
|
|
if (r->manual)
|
|
printf(" Starts : %u\n", r->starts);
|
|
printf(" Restarts : %d (%d/%d)\n",
|
|
r->restart_tot, r->restart_cnt, r->restart_max);
|
|
if (r->restart_delay_max)
|
|
printf(" Restart in : %u sec (max %u)\n",
|
|
r->restart_delay, r->restart_delay_max);
|
|
printf(" Runlevels : %s\n",
|
|
runlevel_string(runlevel, (int)r->runlevels));
|
|
|
|
if (cgrp && r->pid > 1) {
|
|
const struct cg *cg;
|
|
uint64_t throttled_usec = 0;
|
|
uint64_t nr_throttled = 0;
|
|
char path[256];
|
|
char *group;
|
|
|
|
group = pid_cgroup(r->pid);
|
|
if (!group)
|
|
goto no_cgroup; /* ... or PID doesn't exist (anymore) */
|
|
|
|
snprintf(path, sizeof(path), "%s/%s", FINIT_CGPATH, group);
|
|
cg = cg_conf(path);
|
|
|
|
printf(" Memory : %s\n", memsz(cgroup_memory(group), uptm, sizeof(uptm)));
|
|
|
|
if (cgroup_throttle(group, &throttled_usec, &nr_throttled) == 0) {
|
|
printf("CPU Throttle : %lu usec (%lu times)\n",
|
|
throttled_usec, nr_throttled);
|
|
}
|
|
|
|
printf(" CGroup : %s cpu %s [%s, %s] mem [%s, %s]\n",
|
|
group, cg->cg_cpu.set, cg->cg_cpu.weight, cg->cg_cpu.max,
|
|
cg->cg_mem.min, cg->cg_mem.max);
|
|
show_cgroup_tree(group, " ");
|
|
|
|
free(group);
|
|
}
|
|
no_cgroup:
|
|
printf("\n");
|
|
|
|
return do_log_named(r->ident, r->pid, "| tail -10");
|
|
}
|
|
|
|
static void render_table(struct svc_row *rows, int n, char *filter)
|
|
{
|
|
int i, identw = 0, pidw = 0;
|
|
|
|
for (i = 0; i < n; i++) {
|
|
int w;
|
|
|
|
w = (int)strlen(rows[i].ident);
|
|
if (w > identw)
|
|
identw = w;
|
|
w = snprintf(NULL, 0, "%u", rows[i].pid);
|
|
if (w > pidw)
|
|
pidw = w;
|
|
}
|
|
if (identw < 6)
|
|
identw = 6;
|
|
if (pidw < 3)
|
|
pidw = 3;
|
|
|
|
if (heading)
|
|
status_heading(pidw, identw);
|
|
|
|
for (i = 0; i < n; i++) {
|
|
struct svc_row *r = &rows[i];
|
|
|
|
if (filter && !row_compare(r, filter))
|
|
continue;
|
|
|
|
printf("%-*u ", pidw, r->pid);
|
|
printf("%-*s %s ", identw, r->ident, row_status(r, 0));
|
|
print_runlevels(runlevel_string(runlevel, (int)r->runlevels));
|
|
|
|
if (!verbose)
|
|
puts(r->desc);
|
|
else {
|
|
int bold = !plain && row_missing(r);
|
|
|
|
printf("%s%s%s\n", bold ? "\e[1m" : "",
|
|
r->cmdline, bold ? "\e[0m" : "");
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef HAVE_DBUS
|
|
/*
|
|
* Service1 wire properties -> svc_row fields. Unknown keys and
|
|
* value types are skipped so newer finit keeps working with older
|
|
* initctl.
|
|
*/
|
|
#define ROW_STR(k, f) { k, 's', offsetof(struct svc_row, f), \
|
|
sizeof(((struct svc_row *)0)->f) }
|
|
#define ROW_U32(k, f) { k, 'u', offsetof(struct svc_row, f), 0 }
|
|
#define ROW_BOOL(k, f) { k, 'b', offsetof(struct svc_row, f), 0 }
|
|
|
|
static const struct row_field {
|
|
const char *key;
|
|
char type;
|
|
size_t off;
|
|
size_t len;
|
|
} row_fields[] = {
|
|
ROW_STR ("State", state),
|
|
ROW_STR ("Type", type),
|
|
ROW_STR ("Description", desc),
|
|
ROW_STR ("Command", cmdline),
|
|
ROW_STR ("Environment", env),
|
|
ROW_STR ("Conditions", cond),
|
|
ROW_STR ("PidFile", pidfile),
|
|
ROW_STR ("User", user),
|
|
ROW_STR ("Group", grp),
|
|
ROW_STR ("Origin", origin),
|
|
ROW_U32 ("Pid", pid),
|
|
ROW_U32 ("Runlevels", runlevels),
|
|
ROW_U32 ("Uptime", uptime),
|
|
ROW_U32 ("ExitStatus", exitstatus),
|
|
ROW_U32 ("Starts", starts),
|
|
ROW_U32 ("RestartsTotal", restart_tot),
|
|
ROW_U32 ("RestartCount", restart_cnt),
|
|
ROW_U32 ("RestartMax", restart_max),
|
|
ROW_U32 ("RestartDelay", restart_delay),
|
|
ROW_U32 ("RestartDelayMax", restart_delay_max),
|
|
ROW_BOOL("ManualStart", manual),
|
|
ROW_BOOL("Forking", forking),
|
|
ROW_BOOL("Started", started),
|
|
{ NULL, 0, 0, 0 }
|
|
};
|
|
|
|
/*
|
|
* One service's Properties.GetAll into a row. Returns 0 on success,
|
|
* 1 when the object vanished since ListServices (bus error reply),
|
|
* -1 on transport failure.
|
|
*/
|
|
static int dbus_fill_row(link_client_t *c, struct svc_row *row)
|
|
{
|
|
const link_reply_t *r;
|
|
link_reader_t reader;
|
|
char path[256];
|
|
size_t end;
|
|
int rc;
|
|
|
|
if (dbus_svc_path(row->ident, path, sizeof(path)) < 0)
|
|
return -1;
|
|
|
|
rc = link_client_call_v(c, path,
|
|
"org.freedesktop.DBus.Properties",
|
|
"GetAll", "s", "org.finit.Service1");
|
|
if (rc == LINK_CALL_ERROR)
|
|
return 1; /* gone since ListServices */
|
|
if (rc != LINK_CALL_OK)
|
|
return -1;
|
|
r = link_client_reply(c);
|
|
if (!r || !r->body)
|
|
return -1;
|
|
|
|
link_reader_init(&reader, r->body, r->body_len);
|
|
if (link_r_array_begin(&reader, &end) < 0)
|
|
return -1;
|
|
|
|
while (link_r_pos(&reader) < end) {
|
|
const struct row_field *f;
|
|
const char *key, *val;
|
|
uint32_t u;
|
|
int b;
|
|
char type;
|
|
|
|
if (dbus_dict_next(&reader, &key, &type) < 0)
|
|
return -1;
|
|
|
|
for (f = row_fields; f->key; f++)
|
|
if (f->type == type && !strcmp(f->key, key))
|
|
break;
|
|
|
|
if (!f->key) {
|
|
if (link_r_skip_basic(&reader, type) < 0)
|
|
return -1;
|
|
continue;
|
|
}
|
|
|
|
switch (type) {
|
|
case 's':
|
|
if (link_r_string(&reader, &val) < 0)
|
|
return -1;
|
|
strlcpy((char *)row + f->off, val, f->len);
|
|
break;
|
|
case 'u':
|
|
if (link_r_u32(&reader, &u) < 0)
|
|
return -1;
|
|
memcpy((char *)row + f->off, &u, sizeof(u));
|
|
break;
|
|
case 'b':
|
|
if (link_r_bool(&reader, &b) < 0)
|
|
return -1;
|
|
memcpy((char *)row + f->off, &b, sizeof(b));
|
|
break;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* ListServices into a caller-freed ident array. One round trip;
|
|
* show_ident() needs nothing more. Returns count or -1.
|
|
*/
|
|
static int dbus_list_idents(link_client_t *c, char (**out)[MAX_IDENT_LEN])
|
|
{
|
|
char (*idents)[MAX_IDENT_LEN] = NULL, (*tmp)[MAX_IDENT_LEN];
|
|
const link_reply_t *r;
|
|
link_reader_t reader;
|
|
size_t n = 0, end;
|
|
int rc;
|
|
|
|
rc = link_client_call_v(c, "/org/finit/manager",
|
|
"org.finit.Manager1", "ListServices", NULL);
|
|
if (rc != LINK_CALL_OK)
|
|
return -1;
|
|
|
|
r = link_client_reply(c);
|
|
if (!r || !r->body)
|
|
return -1;
|
|
|
|
link_reader_init(&reader, r->body, r->body_len);
|
|
if (link_r_array_begin(&reader, &end) < 0)
|
|
return -1;
|
|
|
|
while (link_r_pos(&reader) < end) {
|
|
const char *ident;
|
|
|
|
if (link_r_string(&reader, &ident) < 0)
|
|
goto fail;
|
|
tmp = realloc(idents, (n + 1) * sizeof(*idents));
|
|
if (!tmp)
|
|
goto fail;
|
|
idents = tmp;
|
|
/* copied: the next call clobbers the client rx buffer */
|
|
strlcpy(idents[n], ident, sizeof(idents[n]));
|
|
n++;
|
|
}
|
|
|
|
*out = idents;
|
|
return (int)n;
|
|
fail:
|
|
free(idents);
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
* Rows for every service matching `arg` (all when NULL), fetched over
|
|
* D-Bus. Returns the row count (caller frees *out), or -1 to fall
|
|
* back to the legacy socket.
|
|
*/
|
|
static int dbus_fetch_svc_rows(char *arg, struct svc_row **out)
|
|
{
|
|
char (*idents)[MAX_IDENT_LEN] = NULL;
|
|
struct svc_row *rows = NULL;
|
|
link_client_t *c;
|
|
int n, i, m = 0;
|
|
|
|
c = link_client_open(FINIT_BUS_SOCKET);
|
|
if (!c)
|
|
return -1;
|
|
|
|
n = dbus_list_idents(c, &idents);
|
|
if (n < 0)
|
|
goto fail;
|
|
|
|
rows = calloc(n ? n : 1, sizeof(*rows));
|
|
if (!rows)
|
|
goto fail;
|
|
|
|
for (i = 0; i < n; i++) {
|
|
struct svc_row *row = &rows[m];
|
|
int rc;
|
|
|
|
strlcpy(row->ident, idents[i], sizeof(row->ident));
|
|
if (arg && arg[0] && !row_compare(row, arg))
|
|
continue;
|
|
|
|
rc = dbus_fill_row(c, row);
|
|
if (rc < 0)
|
|
goto fail;
|
|
if (rc > 0)
|
|
continue; /* vanished, skip */
|
|
m++;
|
|
}
|
|
|
|
free(idents);
|
|
link_client_close(c);
|
|
*out = rows;
|
|
return m;
|
|
fail:
|
|
free(idents);
|
|
free(rows);
|
|
link_client_close(c);
|
|
return -1;
|
|
}
|
|
|
|
/* wire encoding is runlevel(8) style: digits, S, N */
|
|
static int runlevel_from_str(const char *s)
|
|
{
|
|
if (!strcmp(s, "S"))
|
|
return INIT_LEVEL;
|
|
|
|
return atoi(s);
|
|
}
|
|
|
|
/*
|
|
* All show_status() views over D-Bus, self-contained (the current
|
|
* runlevel comes from Manager1, not the legacy socket). Returns 0
|
|
* with the command exit code in *retval, or -1 to fall back.
|
|
*/
|
|
static int dbus_show_status(char *arg, int *retval)
|
|
{
|
|
static const char *const wanted[] = { "Runlevel", NULL };
|
|
char curr[16] = "0";
|
|
char *outv[] = { curr };
|
|
struct svc_row *rows = NULL;
|
|
char *filter;
|
|
int n, i;
|
|
|
|
n = dbus_fetch_svc_rows(arg, &rows);
|
|
if (n < 0)
|
|
return -1;
|
|
|
|
*retval = 0;
|
|
|
|
if (arg && arg[0]) {
|
|
if (!n) {
|
|
free(rows);
|
|
/* exits, exactly like the legacy path */
|
|
ERRX(noerr ? 0 : 69, "no such task or service(s): %s", arg);
|
|
}
|
|
if (n == 1) {
|
|
if (quiet) {
|
|
*retval = quiet_row(&rows[0]);
|
|
free(rows);
|
|
return 0;
|
|
}
|
|
/* runlevel feeds the detail view's Runlevels line */
|
|
if (dbus_get_manager_props(wanted, outv, sizeof(curr)) < 0)
|
|
goto fail;
|
|
runlevel = runlevel_from_str(curr);
|
|
if (json) {
|
|
*retval = json_status_one(stdout, &rows[0], "", 0);
|
|
puts("");
|
|
} else
|
|
*retval = show_one_row(&rows[0]);
|
|
free(rows);
|
|
return 0;
|
|
}
|
|
/* several matches: filtered table below */
|
|
}
|
|
|
|
if (dbus_get_manager_props(wanted, outv, sizeof(curr)) < 0)
|
|
goto fail;
|
|
runlevel = runlevel_from_str(curr);
|
|
|
|
filter = (arg && arg[0]) ? arg : NULL;
|
|
if (json) {
|
|
int prev = 0;
|
|
|
|
for (i = 0; i < n; i++) {
|
|
if (filter && !row_compare(&rows[i], filter))
|
|
continue;
|
|
if (!prev)
|
|
fputs("[\n", stdout);
|
|
json_status_one(stdout, &rows[i], " ", prev++);
|
|
}
|
|
if (prev)
|
|
fputs("\n]\n", stdout);
|
|
} else
|
|
render_table(rows, n, filter);
|
|
|
|
free(rows);
|
|
return 0;
|
|
fail:
|
|
free(rows);
|
|
return -1;
|
|
}
|
|
#endif /* HAVE_DBUS */
|
|
|
|
static int show_status(char *arg)
|
|
{
|
|
struct svc_row row;
|
|
int num = 0;
|
|
svc_t *svc;
|
|
|
|
#ifdef HAVE_DBUS
|
|
{
|
|
int rc;
|
|
|
|
if (dbus_show_status(arg, &rc) == 0)
|
|
return rc;
|
|
}
|
|
#endif
|
|
|
|
runlevel = runlevel_get(NULL);
|
|
|
|
while (arg && arg[0]) {
|
|
for (svc = client_svc_iterator(1); svc; svc = client_svc_iterator(0))
|
|
num += svc_compare(svc, arg);
|
|
|
|
if (num > 1)
|
|
break;
|
|
|
|
svc = client_svc_find(arg);
|
|
if (!svc)
|
|
ERRX(noerr ? 0 : 69, "no such task or service(s): %s", arg);
|
|
|
|
fill_row_from_svc(&row, svc);
|
|
if (quiet)
|
|
return quiet_row(&row);
|
|
|
|
if (json) {
|
|
int rc;
|
|
|
|
rc = json_status_one(stdout, &row, "", 0);
|
|
puts("");
|
|
return rc;
|
|
}
|
|
|
|
return show_one_row(&row);
|
|
}
|
|
|
|
if (json) {
|
|
int prev = 0;
|
|
|
|
for (svc = client_svc_iterator(1); svc; svc = client_svc_iterator(0)) {
|
|
if (num && !svc_compare(svc, arg))
|
|
continue;
|
|
|
|
if (!prev)
|
|
fputs("[\n", stdout);
|
|
fill_row_from_svc(&row, svc);
|
|
json_status_one(stdout, &row, " ", prev++);
|
|
}
|
|
if (prev)
|
|
fputs("\n]\n", stdout);
|
|
|
|
return 0;
|
|
}
|
|
|
|
{
|
|
struct svc_row *rows = NULL, *tmp;
|
|
int n = 0;
|
|
|
|
for (svc = client_svc_iterator(1); svc; svc = client_svc_iterator(0)) {
|
|
tmp = realloc(rows, (n + 1) * sizeof(*rows));
|
|
if (!tmp) {
|
|
free(rows);
|
|
return 1;
|
|
}
|
|
rows = tmp;
|
|
fill_row_from_svc(&rows[n++], svc);
|
|
}
|
|
render_table(rows, n, num > 1 ? arg : NULL);
|
|
free(rows);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void ident_line(const char *identity, char *arg)
|
|
{
|
|
size_t len;
|
|
char *pos;
|
|
|
|
pos = strchr(identity, ':');
|
|
if (pos)
|
|
len = (size_t)(pos - identity);
|
|
else
|
|
len = strlen(identity);
|
|
if (arg && arg[0] && strncasecmp(identity, arg, len))
|
|
return;
|
|
|
|
puts(identity);
|
|
}
|
|
|
|
static int show_ident(char *arg)
|
|
{
|
|
svc_t *svc;
|
|
|
|
#ifdef HAVE_DBUS
|
|
{
|
|
char (*idents)[MAX_IDENT_LEN];
|
|
link_client_t *c;
|
|
int n = -1, i;
|
|
|
|
c = link_client_open(FINIT_BUS_SOCKET);
|
|
if (c) {
|
|
n = dbus_list_idents(c, &idents);
|
|
link_client_close(c);
|
|
}
|
|
if (n >= 0) {
|
|
for (i = 0; i < n; i++)
|
|
ident_line(idents[i], arg);
|
|
free(idents);
|
|
return 0;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
for (svc = client_svc_iterator(1); svc; svc = client_svc_iterator(0)) {
|
|
char ident[MAX_IDENT_LEN];
|
|
|
|
svc_ident(svc, ident, sizeof(ident));
|
|
ident_line(ident, arg);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int transform(char *nm)
|
|
{
|
|
char *names[] = {
|
|
"reboot", "shutdown", "poweroff", "halt", "suspend",
|
|
NULL
|
|
};
|
|
size_t i;
|
|
|
|
for (i = 0; names[i]; i++) {
|
|
if (!strcmp(nm, names[i]))
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int has_conf(char *path, size_t len, char *name)
|
|
{
|
|
paste(path, len, finit_rcsd, name);
|
|
if (!fisdir(path)) {
|
|
strlcpy(path, finit_rcsd, len);
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int usage(int rc)
|
|
{
|
|
int has_rcsd = fisdir(finit_rcsd);
|
|
int has_ena;
|
|
char avail[256];
|
|
char ena[256];
|
|
|
|
has_conf(avail, sizeof(avail), "available");
|
|
has_ena = has_conf(ena, sizeof(ena), "enabled");
|
|
|
|
fprintf(stderr,
|
|
"Usage: %s [OPTIONS] [COMMAND]\n"
|
|
"\n"
|
|
"Options:\n"
|
|
" -b, --batch Batch mode, no screen size probing\n"
|
|
" -c, --create Create missing paths (and files) as needed\n"
|
|
" -f, --force Ignore missing files and arguments, never prompt\n"
|
|
" -h, --help This help text\n"
|
|
" -j, --json JSON output in 'status' and 'cond' commands\n"
|
|
" -n, --noerr Ignore error, e.g., already started/enabled/...\n"
|
|
" -1, --once Only one lap in commands like 'top'\n"
|
|
" -p, --plain Use plain table headings, no ctrl chars\n"
|
|
" -q, --quiet Silent, only return status of command\n"
|
|
" -t, --no-heading Skip table headings\n"
|
|
" -v, --verbose Verbose output\n"
|
|
" -V, --version Show program version\n"
|
|
"\n"
|
|
"Commands:\n"
|
|
" debug Toggle Finit (daemon) debug\n"
|
|
" help This help text\n"
|
|
" version Show program version\n"
|
|
"\n", prognm);
|
|
|
|
if (has_rcsd)
|
|
fprintf(stderr,
|
|
" ls | list List all .conf in %s\n"
|
|
" create <CONF> Create .conf in %s\n"
|
|
" delete <CONF> Delete .conf in %s\n"
|
|
" show <CONF> Show .conf in %s\n"
|
|
" edit <CONF> Edit .conf in %s\n"
|
|
" touch <CONF> Change .conf in %s\n",
|
|
finit_rcsd, avail, avail, avail, avail, avail);
|
|
else
|
|
fprintf(stderr,
|
|
" show Show %s\n", finit_conf);
|
|
|
|
if (has_ena)
|
|
fprintf(stderr,
|
|
" enable <CONF> Enable .conf in %s\n", avail);
|
|
if (has_ena)
|
|
fprintf(stderr,
|
|
" disable <CONF> Disable .conf in %s\n", ena);
|
|
if (has_rcsd)
|
|
fprintf(stderr,
|
|
" reload Reload *.conf in %s (activate changes)\n", finit_rcsd);
|
|
else
|
|
fprintf(stderr,
|
|
" reload Reload %s (activate changes)\n", finit_conf);
|
|
|
|
fprintf(stderr,
|
|
"\n"
|
|
" cond set <COND> Set (assert) user-defined conditions +usr/COND\n"
|
|
" cond get <COND> Get status of user-defined condition, see $? and -v\n"
|
|
" cond clear <COND> Clear (deassert) user-defined conditions -usr/COND\n"
|
|
" cond status Show condition status, default cond command\n"
|
|
" cond dump [TYPE] Dump all, or a type of, conditions and their status\n"
|
|
"\n"
|
|
" log [NAME] Show ten last Finit, or NAME, messages from syslog\n"
|
|
" start <NAME>[:ID] Start service by name, with optional ID\n"
|
|
" stop <NAME>[:ID] Stop/Pause a running service by name\n"
|
|
" reload <NAME>[:ID] Reload service as if .conf changed (SIGHUP or restart)\n"
|
|
" This allows restart of run/tasks that have already run\n"
|
|
" Note: Finit .conf file(s) are *not* reloaded!\n"
|
|
" restart <NAME>[:ID] Restart (stop/start) service by name\n"
|
|
" kill <NAME>[:ID] <S> Send signal S to service by name, with optional ID\n"
|
|
#ifdef HAVE_DBUS
|
|
" monitor Stream D-Bus signals (service state, conditions) until ^C\n"
|
|
#endif
|
|
" ident [NAME] Show matching identities for NAME, or all\n"
|
|
" status <NAME>[:ID] Show service status, by name\n"
|
|
" status Show status of services, default command\n");
|
|
if (cgrp)
|
|
fprintf(stderr,
|
|
"\n"
|
|
" cgroup List cgroup config overview\n"
|
|
" ps List processes based on cgroups\n"
|
|
" top Show top-like listing based on cgroups\n");
|
|
fprintf(stderr,
|
|
"\n"
|
|
" plugins List installed plugins\n"
|
|
"\n"
|
|
" runlevel [0-9] Show or set runlevel: 0 halt, 6 reboot\n"
|
|
" reboot Reboot system\n"
|
|
" halt Halt system\n"
|
|
" poweroff Halt and power off system\n"
|
|
" suspend Suspend system\n"
|
|
" switch-root ROOT [INIT] Switch to new root filesystem (initramfs)\n");
|
|
|
|
if (utmp)
|
|
fprintf(stderr,
|
|
"\n"
|
|
" utmp show Raw dump of UTMP/WTMP db\n");
|
|
fprintf(stderr, "\n");
|
|
|
|
return rc;
|
|
}
|
|
|
|
static int do_devel(char *arg)
|
|
{
|
|
(void)arg;
|
|
|
|
printf("Screen %dx%d\n", ttcols, ttrows);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int do_help(char *arg)
|
|
{
|
|
return usage(0);
|
|
}
|
|
|
|
static int cmd_cond(struct cmd *cmd)
|
|
{
|
|
if (!cmd || !cmd->cond)
|
|
return 1;
|
|
|
|
return *cmd->cond;
|
|
}
|
|
|
|
static int cmd_parse(int argc, char *argv[], struct cmd *command)
|
|
{
|
|
int i, j;
|
|
|
|
for (i = 0; argc > 0 && command[i].cmd; i++) {
|
|
if (!cmd_cond(&command[i]))
|
|
continue;
|
|
|
|
if (!string_compare(command[i].cmd, argv[0]))
|
|
continue;
|
|
|
|
if (command[i].ctx)
|
|
return cmd_parse(argc - 1, &argv[1], command[i].ctx);
|
|
|
|
if (command[i].cb_multiarg)
|
|
return command[i].cb_multiarg(argc - 1, argv + 1);
|
|
|
|
if (command[i].cb) {
|
|
int rc = 0;
|
|
|
|
if (argc == 1)
|
|
return command[i].cb(NULL);
|
|
|
|
for (j = 1; j < argc; j++)
|
|
rc |= command[i].cb(argv[j]);
|
|
|
|
return rc;
|
|
}
|
|
}
|
|
|
|
if (argv[0] && strlen(argv[0]) > 0)
|
|
ERRX(3, "No such command. See 'initctl help' for an overview of available commands.");
|
|
|
|
return command[0].cb(NULL); /* default cmd */
|
|
}
|
|
|
|
static void cleanup(void)
|
|
{
|
|
if (finit_conf)
|
|
free(finit_conf);
|
|
if (finit_rcsd)
|
|
free(finit_rcsd);
|
|
}
|
|
|
|
static void sourcerc(void)
|
|
{
|
|
char *line;
|
|
FILE *fp;
|
|
|
|
fp = fopen(_PATH_VARRUN "finit/.initrc", "r");
|
|
if (!fp)
|
|
goto fallback;
|
|
|
|
while ((line = fparseln(fp, NULL, NULL, NULL, 0))) {
|
|
char *val;
|
|
|
|
if ((val = fgetval(line, "FINIT_CONF", "="))) {
|
|
if (finit_conf)
|
|
free(finit_conf);
|
|
finit_conf = val;
|
|
}
|
|
if ((val = fgetval(line, "FINIT_RCSD", "="))) {
|
|
if (finit_rcsd)
|
|
free(finit_rcsd);
|
|
finit_rcsd = val;
|
|
}
|
|
|
|
free(line);
|
|
}
|
|
|
|
fallback:
|
|
if (!finit_conf)
|
|
finit_conf = strdup(FINIT_CONF);
|
|
if (!finit_rcsd)
|
|
finit_rcsd = strdup(FINIT_RCSD);
|
|
|
|
atexit(cleanup);
|
|
}
|
|
|
|
int main(int argc, char *argv[])
|
|
{
|
|
struct option long_options[] = {
|
|
{ "batch", 0, NULL, 'b' },
|
|
{ "create", 0, NULL, 'c' },
|
|
{ "debug", 0, NULL, 'd' },
|
|
{ "force", 0, NULL, 'f' },
|
|
{ "help", 0, NULL, 'h' },
|
|
{ "json", 0, NULL, 'j' },
|
|
{ "noerr", 0, NULL, 'n' },
|
|
{ "once", 0, NULL, '1' },
|
|
{ "plain", 0, NULL, 'p' },
|
|
{ "quiet", 0, NULL, 'q' },
|
|
{ "no-heading", 0, NULL, 't' },
|
|
{ "verbose", 0, NULL, 'v' },
|
|
{ "version", 0, NULL, 'V' },
|
|
{ NULL, 0, NULL, 0 }
|
|
};
|
|
struct cmd cond[] = {
|
|
{ "status", NULL, do_cond_show, NULL, NULL }, /* default cmd */
|
|
{ "dump", NULL, do_cond_dump, NULL, NULL },
|
|
{ "set", NULL, do_cond_set, NULL, NULL },
|
|
{ "get", NULL, do_cond_get, NULL, NULL },
|
|
{ "clr", NULL, do_cond_clr, NULL, NULL },
|
|
{ "clear", NULL, do_cond_clr, NULL, NULL },
|
|
{ NULL, NULL, NULL, NULL, NULL }
|
|
};
|
|
struct cmd command[] = {
|
|
{ "status", NULL, show_status, NULL, NULL }, /* default cmd */
|
|
{ "ident", NULL, show_ident, NULL, NULL },
|
|
|
|
{ "debug", NULL, toggle_debug, NULL, NULL },
|
|
{ "devel", NULL, do_devel, NULL, NULL },
|
|
{ "help", NULL, do_help, NULL, NULL },
|
|
{ "version", NULL, show_version, NULL, NULL },
|
|
|
|
{ "list", NULL, serv_list, NULL, NULL },
|
|
{ "ls", NULL, serv_list, NULL, NULL },
|
|
{ "enable", NULL, serv_enable, NULL, NULL },
|
|
{ "disable", NULL, serv_disable, NULL, NULL },
|
|
{ "touch", NULL, serv_touch, NULL, NULL },
|
|
{ "show", NULL, serv_show, NULL, NULL },
|
|
{ "cat", NULL, serv_show, NULL, NULL }, /* alias */
|
|
{ "edit", NULL, serv_edit, NULL, NULL },
|
|
{ "create", NULL, serv_creat, NULL, NULL },
|
|
{ "delete", NULL, serv_delete, NULL, NULL },
|
|
{ "reload", NULL, do_reload, NULL, NULL },
|
|
|
|
{ "cond", cond, NULL, NULL, NULL },
|
|
|
|
{ "log", NULL, show_log, NULL, NULL },
|
|
{ "start", NULL, do_start, NULL, NULL },
|
|
{ "stop", NULL, do_stop, NULL, NULL },
|
|
{ "restart", NULL, do_restart, NULL, NULL },
|
|
#ifdef HAVE_DBUS
|
|
{ "monitor", NULL, do_monitor, NULL, NULL },
|
|
#endif
|
|
{ "signal", NULL, NULL, NULL, do_signal },
|
|
{ "kill", NULL, NULL, NULL, do_signal }, /* alias */
|
|
|
|
{ "cgroup", NULL, show_cgroup, &cgrp, NULL },
|
|
{ "ps", NULL, show_cgps, &cgrp, NULL },
|
|
{ "top", NULL, show_cgtop, &cgrp, NULL },
|
|
|
|
{ "plugins", NULL, plugins_list, NULL, NULL },
|
|
|
|
{ "runlevel", NULL, do_runlevel, NULL, NULL },
|
|
{ "reboot", NULL, do_reboot, NULL, NULL },
|
|
{ "halt", NULL, do_halt, NULL, NULL },
|
|
{ "poweroff", NULL, do_poweroff, NULL, NULL },
|
|
{ "suspend", NULL, do_suspend, NULL, NULL },
|
|
{ "switch-root", NULL, NULL, NULL, do_switch_root },
|
|
|
|
{ "utmp", NULL, do_utmp, &utmp, NULL },
|
|
{ NULL, NULL, NULL, NULL, NULL }
|
|
};
|
|
int interactive = 1, c;
|
|
|
|
if (transform(progname(argv[0])))
|
|
return reboot_main(argc, argv);
|
|
|
|
/* Enable functionality depending on system capabilities */
|
|
sourcerc();
|
|
cgrp = cgroup_avail();
|
|
utmp = has_utmp();
|
|
|
|
while ((c = getopt_long(argc, argv, "1bcdfh?jnpqtvV", long_options, NULL)) != EOF) {
|
|
switch(c) {
|
|
case '1':
|
|
ionce = 1;
|
|
break;
|
|
|
|
case 'b':
|
|
interactive = 0;
|
|
break;
|
|
|
|
case 'c':
|
|
icreate = 1;
|
|
break;
|
|
|
|
case 'd':
|
|
debug = 1;
|
|
break;
|
|
|
|
case 'f':
|
|
iforce = 1;
|
|
break;
|
|
|
|
case 'h':
|
|
case '?':
|
|
return usage(0);
|
|
|
|
case 'j':
|
|
json = 1;
|
|
break;
|
|
|
|
case 'n':
|
|
noerr = 1;
|
|
break;
|
|
|
|
case 'p':
|
|
plain = 1;
|
|
break;
|
|
|
|
case 'q':
|
|
quiet = 1;
|
|
break;
|
|
|
|
case 't':
|
|
heading = 0;
|
|
break;
|
|
|
|
case 'v':
|
|
verbose = 1;
|
|
break;
|
|
|
|
case 'V':
|
|
return show_version(NULL);
|
|
}
|
|
}
|
|
|
|
if (interactive)
|
|
ttinit(0);
|
|
|
|
return cmd_parse(argc - optind, &argv[optind], command);
|
|
}
|
|
|
|
void logit(int prio, const char *fmt, ...)
|
|
{
|
|
va_list ap;
|
|
|
|
if (quiet)
|
|
return;
|
|
|
|
va_start(ap, fmt);
|
|
if (prio <= LOG_ERR)
|
|
verrx(1, fmt, ap);
|
|
else
|
|
vwarnx(fmt, ap);
|
|
va_end(ap);
|
|
}
|
|
|
|
/**
|
|
* Local Variables:
|
|
* indent-tabs-mode: t
|
|
* c-file-style: "linux"
|
|
* End:
|
|
*/
|