[thirdparty/systemd.git] / src / libsystemd / sd-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_unique = false;
static bool arg_acquired = false;
static bool arg_activatable = false;
static bool arg_show_machine = 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 **acquired = NULL, **activatable = NULL;
        _cleanup_free_ char **merged = NULL;
        _cleanup_hashmap_free_ Hashmap *names = NULL;
        char **i;
        int r;
        size_t max_i = 0;
        unsigned n = 0;
        void *v;
        char *k;
        Iterator iterator;

        assert(bus);

        r = sd_bus_list_names(bus, (arg_acquired || arg_unique) ? &acquired : NULL, arg_activatable ? &activatable : NULL);
        if (r < 0) {
                log_error("Failed to list names: %s", strerror(-r));
                return r;
        }

        pager_open_if_enabled();

        names = hashmap_new(string_hash_func, string_compare_func);
        if (!names)
                return log_oom();

        STRV_FOREACH(i, acquired) {
                max_i = MAX(max_i, strlen(*i));

                r = hashmap_put(names, *i, INT_TO_PTR(1));
                if (r < 0) {
                        log_error("Failed to add to hashmap: %s", strerror(-r));
                        return r;
                }
        }

        STRV_FOREACH(i, activatable) {
                max_i = MAX(max_i, strlen(*i));

                r = hashmap_put(names, *i, INT_TO_PTR(2));
                if (r < 0 && r != -EEXIST) {
                        log_error("Failed to add to hashmap: %s", strerror(-r));
                        return r;
                }
        }

        merged = new(char*, hashmap_size(names) + 1);
        HASHMAP_FOREACH_KEY(v, k, names, iterator)
                merged[n++] = k;

        merged[n] = NULL;
        strv_sort(merged);

        printf("%-*s %*s %-*s %-*s %-*s %-*s %-*s %-*s",
               (int) max_i, "NAME", 10, "PID", 15, "PROCESS", 16, "USER", 13, "CONNECTION", 25, "UNIT", 10, "SESSION", 19, "CONNECTION-NAME");

        if (arg_show_machine)
                puts(" MACHINE");
        else
                putchar('\n');

        STRV_FOREACH(i, merged) {
                _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
                sd_id128_t mid;

                if (hashmap_get(names, *i) == INT_TO_PTR(2)) {
                        /* Activatable */

                        printf("%-*s", (int) max_i, *i);
                        printf("          - -               -                (activatable) -                         -         ");
                        if (arg_show_machine)
                                puts(" -");
                        else
                                putchar('\n');
                        continue;

                }

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

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

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

                r = sd_bus_get_owner(bus, *i,
                                     SD_BUS_CREDS_UID|SD_BUS_CREDS_PID|SD_BUS_CREDS_COMM|
                                     SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_UNIT|SD_BUS_CREDS_SESSION|
                                     SD_BUS_CREDS_CONNECTION_NAME, &creds);
                if (r >= 0) {
                        const char *unique, *session, *unit, *cn;
                        pid_t pid;
                        uid_t uid;

                        r = sd_bus_creds_get_pid(creds, &pid);
                        if (r >= 0) {
                                const char *comm = NULL;

                                sd_bus_creds_get_comm(creds, &comm);

                                printf(" %10lu %-15s", (unsigned long) pid, strna(comm));
                        } else
                                fputs("          - -              ", stdout);

                        r = sd_bus_creds_get_uid(creds, &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
                                fputs(" -               ", stdout);

                        r = sd_bus_creds_get_unique_name(creds, &unique);
                        if (r >= 0)
                                printf(" %-13s", unique);
                        else
                                fputs(" -            ", stdout);

                        r = sd_bus_creds_get_unit(creds, &unit);
                        if (r >= 0) {
                                _cleanup_free_ char *e;

                                e = ellipsize(unit, 25, 100);
                                if (!e)
                                        return log_oom();

                                printf(" %-25s", e);
                        } else
                                fputs(" -                        ", stdout);

                        r = sd_bus_creds_get_session(creds, &session);
                        if (r >= 0)
                                printf(" %-10s", session);
                        else
                                fputs(" -         ", stdout);

                        r = sd_bus_creds_get_connection_name(creds, &cn);
                        if (r >= 0)
                                printf(" %-19s", cn);
                        else
                                fputs(" -                  ", stdout);

                } else
                        printf("          - -               -                -             -                         -          -                  ");

                if (arg_show_machine) {
                        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
                                puts(" -");
                } else
                        putchar('\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;
                }
        }
}

static int status(sd_bus *bus, char *argv[]) {
        _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
        pid_t pid;
        int r;

        assert(bus);

        if (strv_length(argv) != 2) {
                log_error("Expects one argument.");
                return -EINVAL;
        }

        r = parse_pid(argv[1], &pid);
        if (r < 0)
                r = sd_bus_get_owner(bus, argv[1], _SD_BUS_CREDS_ALL, &creds);
        else
                r = sd_bus_creds_new_from_pid(pid, _SD_BUS_CREDS_ALL, &creds);

        if (r < 0) {
                log_error("Failed to get credentials: %s", strerror(-r));
                return r;
        }

        bus_creds_dump(creds, NULL);
        return 0;
}

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"
               "     --show-machine       Show machine ID column in list\n"
               "     --unique             Only show unique names\n"
               "     --acquired           Only show acquired names\n"
               "     --activatable        Only show activatable names\n"
               "     --match=MATCH        Only show matching messages\n\n"
               "Commands:\n"
               "  list                    List bus names\n"
               "  monitor [SERVICE...]    Show bus traffic\n"
               "  status NAME             Show name status\n"
               "  help                    Show this help\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_SHOW_MACHINE,
                ARG_UNIQUE,
                ARG_ACQUIRED,
                ARG_ACTIVATABLE
        };

        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      },
                { "show-machine", no_argument,       NULL, ARG_SHOW_MACHINE },
                { "unique",       no_argument,       NULL, ARG_UNIQUE       },
                { "acquired",     no_argument,       NULL, ARG_ACQUIRED     },
                { "activatable",  no_argument,       NULL, ARG_ACTIVATABLE  },
                { "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_SHOW_MACHINE:
                        arg_show_machine = true;
                        break;

                case ARG_UNIQUE:
                        arg_unique = true;
                        break;

                case ARG_ACQUIRED:
                        arg_acquired = true;
                        break;

                case ARG_ACTIVATABLE:
                        arg_activatable = 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");
                }
        }

        if (!arg_unique && !arg_acquired && !arg_activatable)
                arg_unique = arg_acquired = arg_activatable = true;

        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], "status"))
                return status(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
de1c301e LP	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
1f849790 LP	22	#include <getopt.h>
1f849790 LP	23
89ffcd2a LP	24	#include "strv.h"
	25	#include "util.h"
	26	#include "log.h"
1f849790 LP	27	#include "build.h"
1f849790 LP	28	#include "pager.h"
89ffcd2a	29
de1c301e	30	#include "sd-bus.h"
89ffcd2a LP	31	#include "bus-message.h"
89ffcd2a LP	32	#include "bus-internal.h"
40ca29a1	33	#include "bus-util.h"
2b5c5383	34	#include "bus-dump.h"
de1c301e	35
1f849790 LP	36	static bool arg_no_pager = false;
1f849790 LP	37	static char *arg_address = NULL;
56e61788 LP	38	static bool arg_unique = false;
	39	static bool arg_acquired = false;
	40	static bool arg_activatable = false;
	41	static bool arg_show_machine = false;
1f849790	42	static char **arg_matches = NULL;
d75edbd6 LP	43	static BusTransport arg_transport = BUS_TRANSPORT_LOCAL;
	44	static char *arg_host = NULL;
	45	static bool arg_user = false;
1f849790 LP	46
	47	static void pager_open_if_enabled(void) {
	48
	49	/* Cache result before we open the pager */
	50	if (arg_no_pager)
	51	return;
	52
	53	pager_open(false);
	54	}
	55
	56	static int list_bus_names(sd_bus bus, char *argv) {
71f2ab46	57	_cleanup_strv_free_ char acquired = NULL, activatable = NULL;
5e2f14e6 LP	58	_cleanup_free_ char **merged = NULL;
5e2f14e6 LP	59	_cleanup_hashmap_free_ Hashmap *names = NULL;
de1c301e LP	60	char **i;
de1c301e LP	61	int r;
89ffcd2a	62	size_t max_i = 0;
5e2f14e6 LP	63	unsigned n = 0;
	64	void *v;
	65	char *k;
	66	Iterator iterator;
de1c301e	67
1f849790	68	assert(bus);
de1c301e	69
56e61788	70	r = sd_bus_list_names(bus, (arg_acquired \|\| arg_unique) ? &acquired : NULL, arg_activatable ? &activatable : NULL);
de1c301e LP	71	if (r < 0) {
de1c301e LP	72	log_error("Failed to list names: %s", strerror(-r));
1f849790	73	return r;
de1c301e LP	74	}
de1c301e LP	75
1f849790 LP	76	pager_open_if_enabled();
1f849790 LP	77
5e2f14e6 LP	78	names = hashmap_new(string_hash_func, string_compare_func);
	79	if (!names)
	80	return log_oom();
89ffcd2a	81
5e2f14e6	82	STRV_FOREACH(i, acquired) {
71f2ab46 LP	83	max_i = MAX(max_i, strlen(*i));
71f2ab46 LP	84
5e2f14e6 LP	85	r = hashmap_put(names, *i, INT_TO_PTR(1));
	86	if (r < 0) {
	87	log_error("Failed to add to hashmap: %s", strerror(-r));
	88	return r;
	89	}
	90	}
	91
	92	STRV_FOREACH(i, activatable) {
89ffcd2a LP	93	max_i = MAX(max_i, strlen(*i));
89ffcd2a LP	94
5e2f14e6 LP	95	r = hashmap_put(names, *i, INT_TO_PTR(2));
	96	if (r < 0 && r != -EEXIST) {
	97	log_error("Failed to add to hashmap: %s", strerror(-r));
	98	return r;
	99	}
	100	}
	101
	102	merged = new(char*, hashmap_size(names) + 1);
	103	HASHMAP_FOREACH_KEY(v, k, names, iterator)
	104	merged[n++] = k;
	105
	106	merged[n] = NULL;
	107	strv_sort(merged);
	108
14008e4e LP	109	printf("%-s %s %-s %-s %-s %-s %-s %-s",
14008e4e LP	110	(int) max_i, "NAME", 10, "PID", 15, "PROCESS", 16, "USER", 13, "CONNECTION", 25, "UNIT", 10, "SESSION", 19, "CONNECTION-NAME");
89ffcd2a	111
56e61788	112	if (arg_show_machine)
a4297f08 LP	113	puts(" MACHINE");
	114	else
	115	putchar('\n');
	116
5e2f14e6 LP	117	STRV_FOREACH(i, merged) {
	118	_cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
	119	sd_id128_t mid;
71f2ab46	120
5e2f14e6 LP	121	if (hashmap_get(names, *i) == INT_TO_PTR(2)) {
5e2f14e6 LP	122	/* Activatable */
71f2ab46	123
5e2f14e6	124	printf("%-s", (int) max_i, i);
56e61788 LP	125	printf(" - - - (activatable) - - ");
56e61788 LP	126	if (arg_show_machine)
5e2f14e6	127	puts(" -");
56e61788 LP	128	else
56e61788 LP	129	putchar('\n');
71f2ab46 LP	130	continue;
71f2ab46 LP	131
5e2f14e6	132	}
de1c301e	133
56e61788 LP	134	if (!arg_unique && (*i)[0] == ':')
	135	continue;
	136
	137	if (!arg_acquired && (*i)[0] != ':')
1f849790	138	continue;
89ffcd2a LP	139
89ffcd2a LP	140	printf("%-s", (int) max_i, i);
de1c301e	141
14008e4e LP	142	r = sd_bus_get_owner(bus, *i,
	143	SD_BUS_CREDS_UID\|SD_BUS_CREDS_PID\|SD_BUS_CREDS_COMM\|
	144	SD_BUS_CREDS_UNIQUE_NAME\|SD_BUS_CREDS_UNIT\|SD_BUS_CREDS_SESSION\|
	145	SD_BUS_CREDS_CONNECTION_NAME, &creds);
89ffcd2a	146	if (r >= 0) {
14008e4e	147	const char unique, session, unit, cn;
5b12334d LP	148	pid_t pid;
5b12334d LP	149	uid_t uid;
de1c301e	150
5b12334d LP	151	r = sd_bus_creds_get_pid(creds, &pid);
	152	if (r >= 0) {
	153	const char *comm = NULL;
de1c301e	154
5b12334d	155	sd_bus_creds_get_comm(creds, &comm);
89ffcd2a	156
5b12334d LP	157	printf(" %10lu %-15s", (unsigned long) pid, strna(comm));
5b12334d LP	158	} else
a4297f08	159	fputs(" - - ", stdout);
89ffcd2a	160
5b12334d LP	161	r = sd_bus_creds_get_uid(creds, &uid);
	162	if (r >= 0) {
	163	_cleanup_free_ char *u = NULL;
89ffcd2a	164
5b12334d LP	165	u = uid_to_name(uid);
	166	if (!u)
	167	return log_oom();
89ffcd2a	168
5b12334d LP	169	if (strlen(u) > 16)
	170	u[16] = 0;
	171
	172	printf(" %-16s", u);
	173	} else
a4297f08	174	fputs(" - ", stdout);
89ffcd2a	175
49b832c5 LP	176	r = sd_bus_creds_get_unique_name(creds, &unique);
49b832c5 LP	177	if (r >= 0)
56e61788 LP	178	printf(" %-13s", unique);
	179	else
	180	fputs(" - ", stdout);
	181
	182	r = sd_bus_creds_get_unit(creds, &unit);
	183	if (r >= 0) {
	184	_cleanup_free_ char *e;
	185
	186	e = ellipsize(unit, 25, 100);
	187	if (!e)
	188	return log_oom();
	189
	190	printf(" %-25s", e);
	191	} else
	192	fputs(" - ", stdout);
	193
	194	r = sd_bus_creds_get_session(creds, &session);
	195	if (r >= 0)
	196	printf(" %-10s", session);
a4297f08	197	else
56e61788	198	fputs(" - ", stdout);
7b0b392f	199
14008e4e LP	200	r = sd_bus_creds_get_connection_name(creds, &cn);
	201	if (r >= 0)
	202	printf(" %-19s", cn);
	203	else
	204	fputs(" - ", stdout);
	205
7b0b392f	206	} else
14008e4e	207	printf(" - - - - - - - ");
a4297f08	208
56e61788	209	if (arg_show_machine) {
a4297f08 LP	210	r = sd_bus_get_owner_machine_id(bus, *i, &mid);
	211	if (r >= 0) {
	212	char m[SD_ID128_STRING_MAX];
	213	printf(" %s\n", sd_id128_to_string(mid, m));
	214	} else
	215	puts(" -");
56e61788 LP	216	} else
56e61788 LP	217	putchar('\n');
de1c301e LP	218	}
de1c301e LP	219
1f849790 LP	220	return 0;
	221	}
	222
	223	static int monitor(sd_bus bus, char argv[]) {
b51f299a	224	bool added_something = false;
1f849790 LP	225	char **i;
	226	int r;
	227
	228	STRV_FOREACH(i, argv+1) {
	229	_cleanup_free_ char *m = NULL;
	230
	231	if (!service_name_is_valid(*i)) {
	232	log_error("Invalid service name '%s'", *i);
	233	return -EINVAL;
	234	}
	235
	236	m = strjoin("sender='", *i, "'", NULL);
	237	if (!m)
	238	return log_oom();
	239
	240	r = sd_bus_add_match(bus, m, NULL, NULL);
	241	if (r < 0) {
	242	log_error("Failed to add match: %s", strerror(-r));
	243	return r;
	244	}
b51f299a LP	245
b51f299a LP	246	added_something = true;
1f849790 LP	247	}
	248
	249	STRV_FOREACH(i, arg_matches) {
	250	r = sd_bus_add_match(bus, *i, NULL, NULL);
	251	if (r < 0) {
	252	log_error("Failed to add match: %s", strerror(-r));
	253	return r;
	254	}
b51f299a LP	255
	256	added_something = true;
	257	}
	258
	259	if (!added_something) {
	260	r = sd_bus_add_match(bus, "", NULL, NULL);
	261	if (r < 0) {
	262	log_error("Failed to add match: %s", strerror(-r));
	263	return r;
	264	}
1f849790 LP	265	}
	266
	267	for (;;) {
	268	_cleanup_bus_message_unref_ sd_bus_message *m = NULL;
	269
	270	r = sd_bus_process(bus, &m);
	271	if (r < 0) {
	272	log_error("Failed to process bus: %s", strerror(-r));
	273	return r;
	274	}
	275
	276	if (m) {
c430fee6	277	bus_message_dump(m, stdout, true);
1f849790 LP	278	continue;
	279	}
	280
	281	if (r > 0)
	282	continue;
	283
	284	r = sd_bus_wait(bus, (uint64_t) -1);
	285	if (r < 0) {
	286	log_error("Failed to wait for bus: %s", strerror(-r));
	287	return r;
	288	}
	289	}
95c4fe82	290	}
1f849790	291
95c4fe82 LP	292	static int status(sd_bus bus, char argv[]) {
	293	_cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
	294	pid_t pid;
	295	int r;
	296
	297	assert(bus);
	298
	299	if (strv_length(argv) != 2) {
	300	log_error("Expects one argument.");
	301	return -EINVAL;
	302	}
	303
	304	r = parse_pid(argv[1], &pid);
	305	if (r < 0)
	306	r = sd_bus_get_owner(bus, argv[1], _SD_BUS_CREDS_ALL, &creds);
	307	else
	308	r = sd_bus_creds_new_from_pid(pid, _SD_BUS_CREDS_ALL, &creds);
	309
	310	if (r < 0) {
	311	log_error("Failed to get credentials: %s", strerror(-r));
	312	return r;
	313	}
	314
	315	bus_creds_dump(creds, NULL);
	316	return 0;
1f849790 LP	317	}
	318
	319	static int help(void) {
	320
	321	printf("%s [OPTIONS...] {COMMAND} ...\n\n"
	322	"Introspect the bus.\n\n"
d75edbd6 LP	323	" -h --help Show this help\n"
d75edbd6 LP	324	" --version Show package version\n"
a86a47ce	325	" --no-pager Do not pipe output into a pager\n"
d75edbd6 LP	326	" --system Connect to system bus\n"
	327	" --user Connect to user bus\n"
	328	" -H --host=[USER@]HOST Operate on remote host\n"
	329	" -M --machine=CONTAINER Operate on local container\n"
	330	" --address=ADDRESS Connect to bus specified by address\n"
56e61788 LP	331	" --show-machine Show machine ID column in list\n"
	332	" --unique Only show unique names\n"
	333	" --acquired Only show acquired names\n"
	334	" --activatable Only show activatable names\n"
b5dda4d8	335	" --match=MATCH Only show matching messages\n\n"
1f849790	336	"Commands:\n"
d75edbd6	337	" list List bus names\n"
d94fe1f1	338	" monitor [SERVICE...] Show bus traffic\n"
56e61788	339	" status NAME Show name status\n"
86cb0691	340	" help Show this help\n",
1f849790 LP	341	program_invocation_short_name);
	342
	343	return 0;
	344	}
	345
	346	static int parse_argv(int argc, char *argv[]) {
	347
	348	enum {
	349	ARG_VERSION = 0x100,
	350	ARG_NO_PAGER,
	351	ARG_SYSTEM,
	352	ARG_USER,
	353	ARG_ADDRESS,
	354	ARG_MATCH,
56e61788 LP	355	ARG_SHOW_MACHINE,
	356	ARG_UNIQUE,
	357	ARG_ACQUIRED,
	358	ARG_ACTIVATABLE
1f849790 LP	359	};
	360
	361	static const struct option options[] = {
56e61788 LP	362	{ "help", no_argument, NULL, 'h' },
	363	{ "version", no_argument, NULL, ARG_VERSION },
	364	{ "no-pager", no_argument, NULL, ARG_NO_PAGER },
	365	{ "system", no_argument, NULL, ARG_SYSTEM },
	366	{ "user", no_argument, NULL, ARG_USER },
	367	{ "address", required_argument, NULL, ARG_ADDRESS },
	368	{ "show-machine", no_argument, NULL, ARG_SHOW_MACHINE },
	369	{ "unique", no_argument, NULL, ARG_UNIQUE },
	370	{ "acquired", no_argument, NULL, ARG_ACQUIRED },
	371	{ "activatable", no_argument, NULL, ARG_ACTIVATABLE },
	372	{ "match", required_argument, NULL, ARG_MATCH },
	373	{ "host", required_argument, NULL, 'H' },
	374	{ "machine", required_argument, NULL, 'M' },
eb9da376	375	{},
1f849790 LP	376	};
	377
	378	int c;
	379
	380	assert(argc >= 0);
	381	assert(argv);
	382
d75edbd6	383	while ((c = getopt_long(argc, argv, "hH:M:", options, NULL)) >= 0) {
1f849790 LP	384
	385	switch (c) {
	386
	387	case 'h':
	388	return help();
	389
	390	case ARG_VERSION:
	391	puts(PACKAGE_STRING);
	392	puts(SYSTEMD_FEATURES);
	393	return 0;
	394
	395	case ARG_NO_PAGER:
	396	arg_no_pager = true;
	397	break;
	398
	399	case ARG_USER:
	400	arg_user = true;
	401	break;
	402
	403	case ARG_SYSTEM:
	404	arg_user = false;
	405	break;
	406
	407	case ARG_ADDRESS:
	408	arg_address = optarg;
	409	break;
	410
56e61788 LP	411	case ARG_SHOW_MACHINE:
	412	arg_show_machine = true;
	413	break;
	414
	415	case ARG_UNIQUE:
	416	arg_unique = true;
1f849790 LP	417	break;
1f849790 LP	418
56e61788 LP	419	case ARG_ACQUIRED:
	420	arg_acquired = true;
	421	break;
	422
	423	case ARG_ACTIVATABLE:
	424	arg_activatable = true;
a4297f08 LP	425	break;
a4297f08 LP	426
1f849790 LP	427	case ARG_MATCH:
	428	if (strv_extend(&arg_matches, optarg) < 0)
	429	return log_oom();
	430	break;
	431
d75edbd6 LP	432	case 'H':
	433	arg_transport = BUS_TRANSPORT_REMOTE;
	434	arg_host = optarg;
	435	break;
	436
	437	case 'M':
	438	arg_transport = BUS_TRANSPORT_CONTAINER;
	439	arg_host = optarg;
	440	break;
	441
1f849790 LP	442	case '?':
	443	return -EINVAL;
	444
	445	default:
eb9da376	446	assert_not_reached("Unhandled option");
1f849790 LP	447	}
	448	}
	449
56e61788 LP	450	if (!arg_unique && !arg_acquired && !arg_activatable)
	451	arg_unique = arg_acquired = arg_activatable = true;
	452
1f849790 LP	453	return 1;
	454	}
	455
	456	static int busctl_main(sd_bus bus, int argc, char argv[]) {
	457	assert(bus);
	458
	459	if (optind >= argc \|\|
	460	streq(argv[optind], "list"))
	461	return list_bus_names(bus, argv + optind);
	462
	463	if (streq(argv[optind], "monitor"))
	464	return monitor(bus, argv + optind);
	465
95c4fe82 LP	466	if (streq(argv[optind], "status"))
	467	return status(bus, argv + optind);
	468
1f849790 LP	469	if (streq(argv[optind], "help"))
	470	return help();
	471
	472	log_error("Unknown command '%s'", argv[optind]);
	473	return -EINVAL;
	474	}
	475
	476	int main(int argc, char *argv[]) {
	477	_cleanup_bus_unref_ sd_bus *bus = NULL;
	478	int r;
	479
	480	log_parse_environment();
	481	log_open();
	482
	483	r = parse_argv(argc, argv);
	484	if (r <= 0)
	485	goto finish;
	486
	487	if (arg_address) {
	488	r = sd_bus_new(&bus);
	489	if (r < 0) {
	490	log_error("Failed to allocate bus: %s", strerror(-r));
	491	goto finish;
	492	}
	493
	494	r = sd_bus_set_address(bus, arg_address);
	495	if (r < 0) {
	496	log_error("Failed to set address: %s", strerror(-r));
	497	goto finish;
	498	}
	499
	500	r = sd_bus_set_bus_client(bus, true);
	501	if (r < 0) {
	502	log_error("Failed to set bus client: %s", strerror(-r));
	503	goto finish;
	504	}
	505
	506	r = sd_bus_start(bus);
d75edbd6 LP	507	} else
d75edbd6 LP	508	r = bus_open_transport(arg_transport, arg_host, arg_user, &bus);
1f849790 LP	509
	510	if (r < 0) {
	511	log_error("Failed to connect to bus: %s", strerror(-r));
	512	goto finish;
	513	}
	514
	515	r = busctl_main(bus, argc, argv);
	516
	517	finish:
	518	pager_close();
d75edbd6	519
1f849790	520	strv_free(arg_matches);
de1c301e	521
de1c301e LP	522	return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
de1c301e LP	523	}