[thirdparty/systemd.git] / src / libsystemd-bus / busctl.c

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  This file is part of systemd.

  Copyright 2013 Lennart Poettering

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <getopt.h>

#include "strv.h"
#include "util.h"
#include "log.h"
#include "build.h"
#include "pager.h"

#include "sd-bus.h"
#include "bus-message.h"
#include "bus-internal.h"
#include "bus-util.h"
#include "bus-dump.h"

static bool arg_no_pager = false;
static char *arg_address = NULL;
static bool arg_no_unique = false;
static char **arg_matches = NULL;
static BusTransport arg_transport = BUS_TRANSPORT_LOCAL;
static char *arg_host = NULL;
static bool arg_user = false;

static void pager_open_if_enabled(void) {

        /* Cache result before we open the pager */
        if (arg_no_pager)
                return;

        pager_open(false);
}

static int list_bus_names(sd_bus *bus, char **argv) {
        _cleanup_strv_free_ char **l = NULL;
        char **i;
        int r;
        size_t max_i = 0;

        assert(bus);

        r = sd_bus_list_names(bus, &l);
        if (r < 0) {
                log_error("Failed to list names: %s", strerror(-r));
                return r;
        }

        pager_open_if_enabled();

        strv_sort(l);

        STRV_FOREACH(i, l)
                max_i = MAX(max_i, strlen(*i));

        printf("%-*s %*s %-*s %-*s %-*s MACHINE\n",
               (int) max_i, "NAME", 10, "PID", 15, "PROCESS", 16, "USER", 20, "CONNECTION");

        STRV_FOREACH(i, l) {
                _cleanup_free_ char *owner = NULL;
                sd_id128_t mid;
                pid_t pid;
                uid_t uid;

                if (arg_no_unique && (*i)[0] == ':')
                        continue;

                printf("%-*s", (int) max_i, *i);

                r = sd_bus_get_owner_pid(bus, *i, &pid);
                if (r >= 0) {
                        _cleanup_free_ char *comm = NULL;

                        printf(" %10lu", (unsigned long) pid);

                        get_process_comm(pid, &comm);
                        printf(" %-15s", strna(comm));
                } else
                        printf("          - -              ");

                r = sd_bus_get_owner_uid(bus, *i, &uid);
                if (r >= 0) {
                        _cleanup_free_ char *u = NULL;

                        u = uid_to_name(uid);
                        if (!u)
                                return log_oom();

                        if (strlen(u) > 16)
                                u[16] = 0;

                        printf(" %-16s", u);
                } else
                        printf(" -               ");

                r = sd_bus_get_owner(bus, *i, &owner);
                if (r >= 0)
                        printf(" %-20s", owner);
                else
                        printf(" -                   ");

                r = sd_bus_get_owner_machine_id(bus, *i, &mid);
                if (r >= 0) {
                        char m[SD_ID128_STRING_MAX];
                        printf(" %s\n", sd_id128_to_string(mid, m));
                } else
                        printf(" -\n");
        }

        return 0;
}

static int monitor(sd_bus *bus, char *argv[]) {
        bool added_something = false;
        char **i;
        int r;

        STRV_FOREACH(i, argv+1) {
                _cleanup_free_ char *m = NULL;

                if (!service_name_is_valid(*i)) {
                        log_error("Invalid service name '%s'", *i);
                        return -EINVAL;
                }

                m = strjoin("sender='", *i, "'", NULL);
                if (!m)
                        return log_oom();

                r = sd_bus_add_match(bus, m, NULL, NULL);
                if (r < 0) {
                        log_error("Failed to add match: %s", strerror(-r));
                        return r;
                }

                added_something = true;
        }

        STRV_FOREACH(i, arg_matches) {
                r = sd_bus_add_match(bus, *i, NULL, NULL);
                if (r < 0) {
                        log_error("Failed to add match: %s", strerror(-r));
                        return r;
                }

                added_something = true;
        }

        if (!added_something) {
                r = sd_bus_add_match(bus, "", NULL, NULL);
                if (r < 0) {
                        log_error("Failed to add match: %s", strerror(-r));
                        return r;
                }
        }

        for (;;) {
                _cleanup_bus_message_unref_ sd_bus_message *m = NULL;

                r = sd_bus_process(bus, &m);
                if (r < 0) {
                        log_error("Failed to process bus: %s", strerror(-r));
                        return r;
                }

                if (m) {
                        bus_message_dump(m, stdout, true);
                        continue;
                }

                if (r > 0)
                        continue;

                r = sd_bus_wait(bus, (uint64_t) -1);
                if (r < 0) {
                        log_error("Failed to wait for bus: %s", strerror(-r));
                        return r;
                }
        }

        return -EINVAL;
}

static int help(void) {

        printf("%s [OPTIONS...] {COMMAND} ...\n\n"
               "Introspect the bus.\n\n"
               "  -h --help               Show this help\n"
               "     --version            Show package version\n"
               "     --no-pager           Do not pipe output into a pager\n"
               "     --system             Connect to system bus\n"
               "     --user               Connect to user bus\n"
               "  -H --host=[USER@]HOST   Operate on remote host\n"
               "  -M --machine=CONTAINER  Operate on local container\n"
               "     --address=ADDRESS    Connect to bus specified by address\n"
               "     --no-unique          Only show well-known names\n"
               "     --match=MATCH        Only show matching messages\n\n"
               "Commands:\n"
               "  list                    List bus names\n"
               "  monitor [SERVICE...]    Show bus traffic\n",
               program_invocation_short_name);

        return 0;
}

static int parse_argv(int argc, char *argv[]) {

        enum {
                ARG_VERSION = 0x100,
                ARG_NO_PAGER,
                ARG_SYSTEM,
                ARG_USER,
                ARG_ADDRESS,
                ARG_MATCH,
                ARG_NO_UNIQUE
        };

        static const struct option options[] = {
                { "help",      no_argument,       NULL, 'h'           },
                { "version",   no_argument,       NULL, ARG_VERSION   },
                { "no-pager",  no_argument,       NULL, ARG_NO_PAGER  },
                { "system",    no_argument,       NULL, ARG_SYSTEM    },
                { "user",      no_argument,       NULL, ARG_USER      },
                { "address",   required_argument, NULL, ARG_ADDRESS   },
                { "no-unique", no_argument,       NULL, ARG_NO_UNIQUE },
                { "match",     required_argument, NULL, ARG_MATCH     },
                { "host",      required_argument, NULL, 'H'           },
                { "machine",   required_argument, NULL, 'M'           },
                {},
        };

        int c;

        assert(argc >= 0);
        assert(argv);

        while ((c = getopt_long(argc, argv, "hH:M:", options, NULL)) >= 0) {

                switch (c) {

                case 'h':
                        return help();

                case ARG_VERSION:
                        puts(PACKAGE_STRING);
                        puts(SYSTEMD_FEATURES);
                        return 0;

                case ARG_NO_PAGER:
                        arg_no_pager = true;
                        break;

                case ARG_USER:
                        arg_user = true;
                        break;

                case ARG_SYSTEM:
                        arg_user = false;
                        break;

                case ARG_ADDRESS:
                        arg_address = optarg;
                        break;

                case ARG_NO_UNIQUE:
                        arg_no_unique = true;
                        break;

                case ARG_MATCH:
                        if (strv_extend(&arg_matches, optarg) < 0)
                                return log_oom();
                        break;

                case 'H':
                        arg_transport = BUS_TRANSPORT_REMOTE;
                        arg_host = optarg;
                        break;

                case 'M':
                        arg_transport = BUS_TRANSPORT_CONTAINER;
                        arg_host = optarg;
                        break;

                case '?':
                        return -EINVAL;

                default:
                        assert_not_reached("Unhandled option");
                }
        }

        return 1;
}

static int busctl_main(sd_bus *bus, int argc, char *argv[]) {
        assert(bus);

        if (optind >= argc ||
            streq(argv[optind], "list"))
                return list_bus_names(bus, argv + optind);

        if (streq(argv[optind], "monitor"))
                return monitor(bus, argv + optind);

        if (streq(argv[optind], "help"))
                return help();

        log_error("Unknown command '%s'", argv[optind]);
        return -EINVAL;
}

int main(int argc, char *argv[]) {
        _cleanup_bus_unref_ sd_bus *bus = NULL;
        int r;

        log_parse_environment();
        log_open();

        r = parse_argv(argc, argv);
        if (r <= 0)
                goto finish;

        if (arg_address) {
                r = sd_bus_new(&bus);
                if (r < 0) {
                        log_error("Failed to allocate bus: %s", strerror(-r));
                        goto finish;
                }

                r = sd_bus_set_address(bus, arg_address);
                if (r < 0) {
                        log_error("Failed to set address: %s", strerror(-r));
                        goto finish;
                }

                r = sd_bus_set_bus_client(bus, true);
                if (r < 0) {
                        log_error("Failed to set bus client: %s", strerror(-r));
                        goto finish;
                }

                r = sd_bus_start(bus);
        } else
                r = bus_open_transport(arg_transport, arg_host, arg_user, &bus);

        if (r < 0) {
                log_error("Failed to connect to bus: %s", strerror(-r));
                goto finish;
        }

        r = busctl_main(bus, argc, argv);

finish:
        pager_close();

        strv_free(arg_matches);

        return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
}
Commit	Line	Data
	1	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/
	2
	3	/***
	4	This file is part of systemd.
	5
	6	Copyright 2013 Lennart Poettering
	7
	8	systemd is free software; you can redistribute it and/or modify it
	9	under the terms of the GNU Lesser General Public License as published by
	10	the Free Software Foundation; either version 2.1 of the License, or
	11	(at your option) any later version.
	12
	13	systemd is distributed in the hope that it will be useful, but
	14	WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	Lesser General Public License for more details.
	17
	18	You should have received a copy of the GNU Lesser General Public License
	19	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	20	***/
	21
	22	#include <getopt.h>
	23
	24	#include "strv.h"
	25	#include "util.h"
	26	#include "log.h"
	27	#include "build.h"
	28	#include "pager.h"
	29
	30	#include "sd-bus.h"
	31	#include "bus-message.h"
	32	#include "bus-internal.h"
	33	#include "bus-util.h"
	34	#include "bus-dump.h"
	35
	36	static bool arg_no_pager = false;
	37	static char *arg_address = NULL;
	38	static bool arg_no_unique = false;
	39	static char **arg_matches = NULL;
	40	static BusTransport arg_transport = BUS_TRANSPORT_LOCAL;
	41	static char *arg_host = NULL;
	42	static bool arg_user = false;
	43
	44	static void pager_open_if_enabled(void) {
	45
	46	/* Cache result before we open the pager */
	47	if (arg_no_pager)
	48	return;
	49
	50	pager_open(false);
	51	}
	52
	53	static int list_bus_names(sd_bus bus, char *argv) {
	54	_cleanup_strv_free_ char **l = NULL;
	55	char **i;
	56	int r;
	57	size_t max_i = 0;
	58
	59	assert(bus);
	60
	61	r = sd_bus_list_names(bus, &l);
	62	if (r < 0) {
	63	log_error("Failed to list names: %s", strerror(-r));
	64	return r;
	65	}
	66
	67	pager_open_if_enabled();
	68
	69	strv_sort(l);
	70
	71	STRV_FOREACH(i, l)
	72	max_i = MAX(max_i, strlen(*i));
	73
	74	printf("%-s %s %-s %-s %-*s MACHINE\n",
	75	(int) max_i, "NAME", 10, "PID", 15, "PROCESS", 16, "USER", 20, "CONNECTION");
	76
	77	STRV_FOREACH(i, l) {
	78	_cleanup_free_ char *owner = NULL;
	79	sd_id128_t mid;
	80	pid_t pid;
	81	uid_t uid;
	82
	83	if (arg_no_unique && (*i)[0] == ':')
	84	continue;
	85
	86	printf("%-s", (int) max_i, i);
	87
	88	r = sd_bus_get_owner_pid(bus, *i, &pid);
	89	if (r >= 0) {
	90	_cleanup_free_ char *comm = NULL;
	91
	92	printf(" %10lu", (unsigned long) pid);
	93
	94	get_process_comm(pid, &comm);
	95	printf(" %-15s", strna(comm));
	96	} else
	97	printf(" - - ");
	98
	99	r = sd_bus_get_owner_uid(bus, *i, &uid);
	100	if (r >= 0) {
	101	_cleanup_free_ char *u = NULL;
	102
	103	u = uid_to_name(uid);
	104	if (!u)
	105	return log_oom();
	106
	107	if (strlen(u) > 16)
	108	u[16] = 0;
	109
	110	printf(" %-16s", u);
	111	} else
	112	printf(" - ");
	113
	114	r = sd_bus_get_owner(bus, *i, &owner);
	115	if (r >= 0)
	116	printf(" %-20s", owner);
	117	else
	118	printf(" - ");
	119
	120	r = sd_bus_get_owner_machine_id(bus, *i, &mid);
	121	if (r >= 0) {
	122	char m[SD_ID128_STRING_MAX];
	123	printf(" %s\n", sd_id128_to_string(mid, m));
	124	} else
	125	printf(" -\n");
	126	}
	127
	128	return 0;
	129	}
	130
	131	static int monitor(sd_bus bus, char argv[]) {
	132	bool added_something = false;
	133	char **i;
	134	int r;
	135
	136	STRV_FOREACH(i, argv+1) {
	137	_cleanup_free_ char *m = NULL;
	138
	139	if (!service_name_is_valid(*i)) {
	140	log_error("Invalid service name '%s'", *i);
	141	return -EINVAL;
	142	}
	143
	144	m = strjoin("sender='", *i, "'", NULL);
	145	if (!m)
	146	return log_oom();
	147
	148	r = sd_bus_add_match(bus, m, NULL, NULL);
	149	if (r < 0) {
	150	log_error("Failed to add match: %s", strerror(-r));
	151	return r;
	152	}
	153
	154	added_something = true;
	155	}
	156
	157	STRV_FOREACH(i, arg_matches) {
	158	r = sd_bus_add_match(bus, *i, NULL, NULL);
	159	if (r < 0) {
	160	log_error("Failed to add match: %s", strerror(-r));
	161	return r;
	162	}
	163
	164	added_something = true;
	165	}
	166
	167	if (!added_something) {
	168	r = sd_bus_add_match(bus, "", NULL, NULL);
	169	if (r < 0) {
	170	log_error("Failed to add match: %s", strerror(-r));
	171	return r;
	172	}
	173	}
	174
	175	for (;;) {
	176	_cleanup_bus_message_unref_ sd_bus_message *m = NULL;
	177
	178	r = sd_bus_process(bus, &m);
	179	if (r < 0) {
	180	log_error("Failed to process bus: %s", strerror(-r));
	181	return r;
	182	}
	183
	184	if (m) {
	185	bus_message_dump(m, stdout, true);
	186	continue;
	187	}
	188
	189	if (r > 0)
	190	continue;
	191
	192	r = sd_bus_wait(bus, (uint64_t) -1);
	193	if (r < 0) {
	194	log_error("Failed to wait for bus: %s", strerror(-r));
	195	return r;
	196	}
	197	}
	198
	199	return -EINVAL;
	200	}
	201
	202	static int help(void) {
	203
	204	printf("%s [OPTIONS...] {COMMAND} ...\n\n"
	205	"Introspect the bus.\n\n"
	206	" -h --help Show this help\n"
	207	" --version Show package version\n"
	208	" --no-pager Do not pipe output into a pager\n"
	209	" --system Connect to system bus\n"
	210	" --user Connect to user bus\n"
	211	" -H --host=[USER@]HOST Operate on remote host\n"
	212	" -M --machine=CONTAINER Operate on local container\n"
	213	" --address=ADDRESS Connect to bus specified by address\n"
	214	" --no-unique Only show well-known names\n"
	215	" --match=MATCH Only show matching messages\n\n"
	216	"Commands:\n"
	217	" list List bus names\n"
	218	" monitor [SERVICE...] Show bus traffic\n",
	219	program_invocation_short_name);
	220
	221	return 0;
	222	}
	223
	224	static int parse_argv(int argc, char *argv[]) {
	225
	226	enum {
	227	ARG_VERSION = 0x100,
	228	ARG_NO_PAGER,
	229	ARG_SYSTEM,
	230	ARG_USER,
	231	ARG_ADDRESS,
	232	ARG_MATCH,
	233	ARG_NO_UNIQUE
	234	};
	235
	236	static const struct option options[] = {
	237	{ "help", no_argument, NULL, 'h' },
	238	{ "version", no_argument, NULL, ARG_VERSION },
	239	{ "no-pager", no_argument, NULL, ARG_NO_PAGER },
	240	{ "system", no_argument, NULL, ARG_SYSTEM },
	241	{ "user", no_argument, NULL, ARG_USER },
	242	{ "address", required_argument, NULL, ARG_ADDRESS },
	243	{ "no-unique", no_argument, NULL, ARG_NO_UNIQUE },
	244	{ "match", required_argument, NULL, ARG_MATCH },
	245	{ "host", required_argument, NULL, 'H' },
	246	{ "machine", required_argument, NULL, 'M' },
	247	{},
	248	};
	249
	250	int c;
	251
	252	assert(argc >= 0);
	253	assert(argv);
	254
	255	while ((c = getopt_long(argc, argv, "hH:M:", options, NULL)) >= 0) {
	256
	257	switch (c) {
	258
	259	case 'h':
	260	return help();
	261
	262	case ARG_VERSION:
	263	puts(PACKAGE_STRING);
	264	puts(SYSTEMD_FEATURES);
	265	return 0;
	266
	267	case ARG_NO_PAGER:
	268	arg_no_pager = true;
	269	break;
	270
	271	case ARG_USER:
	272	arg_user = true;
	273	break;
	274
	275	case ARG_SYSTEM:
	276	arg_user = false;
	277	break;
	278
	279	case ARG_ADDRESS:
	280	arg_address = optarg;
	281	break;
	282
	283	case ARG_NO_UNIQUE:
	284	arg_no_unique = true;
	285	break;
	286
	287	case ARG_MATCH:
	288	if (strv_extend(&arg_matches, optarg) < 0)
	289	return log_oom();
	290	break;
	291
	292	case 'H':
	293	arg_transport = BUS_TRANSPORT_REMOTE;
	294	arg_host = optarg;
	295	break;
	296
	297	case 'M':
	298	arg_transport = BUS_TRANSPORT_CONTAINER;
	299	arg_host = optarg;
	300	break;
	301
	302	case '?':
	303	return -EINVAL;
	304
	305	default:
	306	assert_not_reached("Unhandled option");
	307	}
	308	}
	309
	310	return 1;
	311	}
	312
	313	static int busctl_main(sd_bus bus, int argc, char argv[]) {
	314	assert(bus);
	315
	316	if (optind >= argc \|\|
	317	streq(argv[optind], "list"))
	318	return list_bus_names(bus, argv + optind);
	319
	320	if (streq(argv[optind], "monitor"))
	321	return monitor(bus, argv + optind);
	322
	323	if (streq(argv[optind], "help"))
	324	return help();
	325
	326	log_error("Unknown command '%s'", argv[optind]);
	327	return -EINVAL;
	328	}
	329
	330	int main(int argc, char *argv[]) {
	331	_cleanup_bus_unref_ sd_bus *bus = NULL;
	332	int r;
	333
	334	log_parse_environment();
	335	log_open();
	336
	337	r = parse_argv(argc, argv);
	338	if (r <= 0)
	339	goto finish;
	340
	341	if (arg_address) {
	342	r = sd_bus_new(&bus);
	343	if (r < 0) {
	344	log_error("Failed to allocate bus: %s", strerror(-r));
	345	goto finish;
	346	}
	347
	348	r = sd_bus_set_address(bus, arg_address);
	349	if (r < 0) {
	350	log_error("Failed to set address: %s", strerror(-r));
	351	goto finish;
	352	}
	353
	354	r = sd_bus_set_bus_client(bus, true);
	355	if (r < 0) {
	356	log_error("Failed to set bus client: %s", strerror(-r));
	357	goto finish;
	358	}
	359
	360	r = sd_bus_start(bus);
	361	} else
	362	r = bus_open_transport(arg_transport, arg_host, arg_user, &bus);
	363
	364	if (r < 0) {
	365	log_error("Failed to connect to bus: %s", strerror(-r));
	366	goto finish;
	367	}
	368
	369	r = busctl_main(bus, argc, argv);
	370
	371	finish:
	372	pager_close();
	373
	374	strv_free(arg_matches);
	375
	376	return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
	377	}