1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2013 Lennart Poettering
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.
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.
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/>.
30 #include "path-util.h"
33 #include "bus-message.h"
34 #include "bus-internal.h"
37 #include "bus-signature.h"
38 #include "busctl-introspect.h"
40 static bool arg_no_pager = false;
41 static bool arg_legend = true;
42 static char *arg_address = NULL;
43 static bool arg_unique = false;
44 static bool arg_acquired = false;
45 static bool arg_activatable = false;
46 static bool arg_show_machine = false;
47 static char **arg_matches = NULL;
48 static BusTransport arg_transport = BUS_TRANSPORT_LOCAL;
49 static char *arg_host = NULL;
50 static bool arg_user = false;
51 static size_t arg_snaplen = 4096;
52 static bool arg_list = false;
53 static bool arg_quiet = false;
55 static void pager_open_if_enabled(void) {
57 /* Cache result before we open the pager */
64 static int list_bus_names(sd_bus *bus, char **argv) {
65 _cleanup_strv_free_ char **acquired = NULL, **activatable = NULL;
66 _cleanup_free_ char **merged = NULL;
67 _cleanup_hashmap_free_ Hashmap *names = NULL;
78 if (!arg_unique && !arg_acquired && !arg_activatable)
79 arg_unique = arg_acquired = arg_activatable = true;
81 r = sd_bus_list_names(bus, (arg_acquired || arg_unique) ? &acquired : NULL, arg_activatable ? &activatable : NULL);
83 log_error("Failed to list names: %s", strerror(-r));
87 pager_open_if_enabled();
89 names = hashmap_new(&string_hash_ops);
93 STRV_FOREACH(i, acquired) {
94 max_i = MAX(max_i, strlen(*i));
96 r = hashmap_put(names, *i, INT_TO_PTR(1));
98 log_error("Failed to add to hashmap: %s", strerror(-r));
103 STRV_FOREACH(i, activatable) {
104 max_i = MAX(max_i, strlen(*i));
106 r = hashmap_put(names, *i, INT_TO_PTR(2));
107 if (r < 0 && r != -EEXIST) {
108 log_error("Failed to add to hashmap: %s", strerror(-r));
113 merged = new(char*, hashmap_size(names) + 1);
114 HASHMAP_FOREACH_KEY(v, k, names, iterator)
121 printf("%-*s %*s %-*s %-*s %-*s %-*s %-*s %-*s",
122 (int) max_i, "NAME", 10, "PID", 15, "PROCESS", 16, "USER", 13, "CONNECTION", 25, "UNIT", 10, "SESSION", 19, "DESCRIPTION");
124 if (arg_show_machine)
130 STRV_FOREACH(i, merged) {
131 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
134 if (hashmap_get(names, *i) == INT_TO_PTR(2)) {
137 printf("%-*s", (int) max_i, *i);
138 printf(" - - - (activatable) - - ");
139 if (arg_show_machine)
147 if (!arg_unique && (*i)[0] == ':')
150 if (!arg_acquired && (*i)[0] != ':')
153 printf("%-*s", (int) max_i, *i);
155 r = sd_bus_get_name_creds(bus, *i,
156 SD_BUS_CREDS_UID|SD_BUS_CREDS_PID|SD_BUS_CREDS_COMM|
157 SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_UNIT|SD_BUS_CREDS_SESSION|
158 SD_BUS_CREDS_DESCRIPTION, &creds);
160 const char *unique, *session, *unit, *cn;
164 r = sd_bus_creds_get_pid(creds, &pid);
166 const char *comm = NULL;
168 sd_bus_creds_get_comm(creds, &comm);
170 printf(" %10lu %-15s", (unsigned long) pid, strna(comm));
172 fputs(" - - ", stdout);
174 r = sd_bus_creds_get_uid(creds, &uid);
176 _cleanup_free_ char *u = NULL;
178 u = uid_to_name(uid);
187 fputs(" - ", stdout);
189 r = sd_bus_creds_get_unique_name(creds, &unique);
191 printf(" %-13s", unique);
193 fputs(" - ", stdout);
195 r = sd_bus_creds_get_unit(creds, &unit);
197 _cleanup_free_ char *e;
199 e = ellipsize(unit, 25, 100);
205 fputs(" - ", stdout);
207 r = sd_bus_creds_get_session(creds, &session);
209 printf(" %-10s", session);
211 fputs(" - ", stdout);
213 r = sd_bus_creds_get_description(creds, &cn);
215 printf(" %-19s", cn);
217 fputs(" - ", stdout);
220 printf(" - - - - - - - ");
222 if (arg_show_machine) {
223 r = sd_bus_get_name_machine_id(bus, *i, &mid);
225 char m[SD_ID128_STRING_MAX];
226 printf(" %s\n", sd_id128_to_string(mid, m));
236 static void print_subtree(const char *prefix, const char *path, char **l) {
237 const char *vertical, *space;
240 /* We assume the list is sorted. Let's first skip over the
241 * entry we are looking at. */
246 if (!streq(*l, path))
252 vertical = strappenda(prefix, draw_special_char(DRAW_TREE_VERTICAL));
253 space = strappenda(prefix, draw_special_char(DRAW_TREE_SPACE));
256 bool has_more = false;
258 if (!*l || !path_startswith(*l, path))
263 if (!*n || !path_startswith(*n, path))
266 if (!path_startswith(*n, *l)) {
274 printf("%s%s%s\n", prefix, draw_special_char(has_more ? DRAW_TREE_BRANCH : DRAW_TREE_RIGHT), *l);
276 print_subtree(has_more ? vertical : space, *l, l);
281 static void print_tree(const char *prefix, char **l) {
283 pager_open_if_enabled();
285 prefix = strempty(prefix);
291 printf("%s%s\n", prefix, *i);
295 if (strv_isempty(l)) {
296 printf("No objects discovered.\n");
300 if (streq(l[0], "/") && !l[1]) {
301 printf("Only root object discovered.\n");
305 print_subtree(prefix, "/", l);
308 static int on_path(const char *path, void *userdata) {
309 Set *paths = userdata;
314 r = set_put_strdup(paths, path);
321 static int find_nodes(sd_bus *bus, const char *service, const char *path, Set *paths) {
322 const XMLIntrospectOps ops = {
326 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
327 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
331 r = sd_bus_call_method(bus, service, path, "org.freedesktop.DBus.Introspectable", "Introspect", &error, &reply, "");
333 log_error("Failed to introspect object %s of service %s: %s", path, service, bus_error_message(&error, r));
337 r = sd_bus_message_read(reply, "s", &xml);
339 return bus_log_parse_error(r);
341 /* fputs(xml, stdout); */
342 return parse_xml_introspect(path, xml, &ops, paths);
345 static int tree_one(sd_bus *bus, const char *service, const char *prefix) {
346 _cleanup_set_free_free_ Set *paths = NULL, *done = NULL, *failed = NULL;
347 _cleanup_free_ char **l = NULL;
351 paths = set_new(&string_hash_ops);
355 done = set_new(&string_hash_ops);
359 failed = set_new(&string_hash_ops);
367 r = set_put(paths, m);
374 _cleanup_free_ char *p = NULL;
377 p = set_steal_first(paths);
381 if (set_contains(done, p) ||
382 set_contains(failed, p))
385 q = find_nodes(bus, service, p, paths);
390 q = set_put(failed, p);
392 q = set_put(done, p);
401 l = set_get_strv(done);
406 print_tree(prefix, l);
413 static int tree(sd_bus *bus, char **argv) {
417 if (!arg_unique && !arg_acquired)
420 if (strv_length(argv) <= 1) {
421 _cleanup_strv_free_ char **names = NULL;
422 bool not_first = false;
424 r = sd_bus_list_names(bus, &names, NULL);
426 log_error("Failed to get name list: %s", strerror(-r));
430 pager_open_if_enabled();
432 STRV_FOREACH(i, names) {
435 if (!arg_unique && (*i)[0] == ':')
438 if (!arg_acquired && (*i)[0] == ':')
444 printf("Service %s%s%s:\n", ansi_highlight(), *i, ansi_highlight_off());
446 q = tree_one(bus, *i, NULL);
453 pager_open_if_enabled();
455 STRV_FOREACH(i, argv+1) {
462 printf("Service %s%s%s:\n", ansi_highlight(), *i, ansi_highlight_off());
464 q = tree_one(bus, *i, NULL);
473 static int message_dump(sd_bus_message *m, FILE *f) {
474 return bus_message_dump(m, f, BUS_MESSAGE_DUMP_WITH_HEADER);
477 static int message_pcap(sd_bus_message *m, FILE *f) {
478 return bus_message_pcap_frame(m, arg_snaplen, f);
481 static int monitor(sd_bus *bus, char *argv[], int (*dump)(sd_bus_message *m, FILE *f)) {
482 bool added_something = false;
486 STRV_FOREACH(i, argv+1) {
487 _cleanup_free_ char *m = NULL;
489 if (!service_name_is_valid(*i)) {
490 log_error("Invalid service name '%s'", *i);
494 m = strjoin("sender='", *i, "'", NULL);
498 r = sd_bus_add_match(bus, NULL, m, NULL, NULL);
500 log_error("Failed to add match: %s", strerror(-r));
504 added_something = true;
507 STRV_FOREACH(i, arg_matches) {
508 r = sd_bus_add_match(bus, NULL, *i, NULL, NULL);
510 log_error("Failed to add match: %s", strerror(-r));
514 added_something = true;
517 if (!added_something) {
518 r = sd_bus_add_match(bus, NULL, "", NULL, NULL);
520 log_error("Failed to add match: %s", strerror(-r));
526 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
528 r = sd_bus_process(bus, &m);
530 log_error("Failed to process bus: %s", strerror(-r));
542 r = sd_bus_wait(bus, (uint64_t) -1);
544 log_error("Failed to wait for bus: %s", strerror(-r));
550 static int capture(sd_bus *bus, char *argv[]) {
553 if (isatty(fileno(stdout)) > 0) {
554 log_error("Refusing to write message data to console, please redirect output to a file.");
558 bus_pcap_header(arg_snaplen, stdout);
560 r = monitor(bus, argv, message_pcap);
564 if (ferror(stdout)) {
565 log_error("Couldn't write capture file.");
572 static int status(sd_bus *bus, char *argv[]) {
573 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
579 if (strv_length(argv) != 2) {
580 log_error("Expects one argument.");
584 r = parse_pid(argv[1], &pid);
586 r = sd_bus_get_name_creds(bus, argv[1], _SD_BUS_CREDS_ALL, &creds);
588 r = sd_bus_creds_new_from_pid(&creds, pid, _SD_BUS_CREDS_ALL);
591 log_error("Failed to get credentials: %s", strerror(-r));
595 bus_creds_dump(creds, NULL);
599 static int message_append_cmdline(sd_bus_message *m, const char *signature, char ***x) {
619 log_error("Too few parameters for signature.");
628 case SD_BUS_TYPE_BOOLEAN:
630 r = parse_boolean(v);
632 log_error("Failed to parse as boolean: %s", v);
636 r = sd_bus_message_append_basic(m, t, &r);
639 case SD_BUS_TYPE_BYTE: {
642 r = safe_atou8(v, &z);
644 log_error("Failed to parse as byte (unsigned 8bit integer): %s", v);
648 r = sd_bus_message_append_basic(m, t, &z);
652 case SD_BUS_TYPE_INT16: {
655 r = safe_atoi16(v, &z);
657 log_error("Failed to parse as signed 16bit integer: %s", v);
661 r = sd_bus_message_append_basic(m, t, &z);
665 case SD_BUS_TYPE_UINT16: {
668 r = safe_atou16(v, &z);
670 log_error("Failed to parse as unsigned 16bit integer: %s", v);
674 r = sd_bus_message_append_basic(m, t, &z);
678 case SD_BUS_TYPE_INT32: {
681 r = safe_atoi32(v, &z);
683 log_error("Failed to parse as signed 32bit integer: %s", v);
687 r = sd_bus_message_append_basic(m, t, &z);
691 case SD_BUS_TYPE_UINT32: {
694 r = safe_atou32(v, &z);
696 log_error("Failed to parse as unsigned 32bit integer: %s", v);
700 r = sd_bus_message_append_basic(m, t, &z);
704 case SD_BUS_TYPE_INT64: {
707 r = safe_atoi64(v, &z);
709 log_error("Failed to parse as signed 64bit integer: %s", v);
713 r = sd_bus_message_append_basic(m, t, &z);
717 case SD_BUS_TYPE_UINT64: {
720 r = safe_atou64(v, &z);
722 log_error("Failed to parse as unsigned 64bit integer: %s", v);
726 r = sd_bus_message_append_basic(m, t, &z);
731 case SD_BUS_TYPE_DOUBLE: {
734 r = safe_atod(v, &z);
736 log_error("Failed to parse as double precision floating point: %s", v);
740 r = sd_bus_message_append_basic(m, t, &z);
744 case SD_BUS_TYPE_STRING:
745 case SD_BUS_TYPE_OBJECT_PATH:
746 case SD_BUS_TYPE_SIGNATURE:
748 r = sd_bus_message_append_basic(m, t, v);
751 case SD_BUS_TYPE_ARRAY: {
755 r = safe_atou32(v, &n);
757 log_error("Failed to parse number of array entries: %s", v);
761 r = signature_element_length(signature, &k);
763 log_error("Invalid array signature.");
770 memcpy(s, signature, k);
773 r = sd_bus_message_open_container(m, SD_BUS_TYPE_ARRAY, s);
775 return bus_log_create_error(r);
777 for (i = 0; i < n; i++) {
778 r = message_append_cmdline(m, s, &p);
786 r = sd_bus_message_close_container(m);
790 case SD_BUS_TYPE_VARIANT:
791 r = sd_bus_message_open_container(m, SD_BUS_TYPE_VARIANT, v);
793 return bus_log_create_error(r);
795 r = message_append_cmdline(m, v, &p);
799 r = sd_bus_message_close_container(m);
802 case SD_BUS_TYPE_STRUCT_BEGIN:
803 case SD_BUS_TYPE_DICT_ENTRY_BEGIN: {
809 r = signature_element_length(signature, &k);
811 log_error("Invalid struct/dict entry signature.");
817 memcpy(s, signature + 1, k - 2);
820 r = sd_bus_message_open_container(m, t == SD_BUS_TYPE_STRUCT_BEGIN ? SD_BUS_TYPE_STRUCT : SD_BUS_TYPE_DICT_ENTRY, s);
822 return bus_log_create_error(r);
824 r = message_append_cmdline(m, s, &p);
831 r = sd_bus_message_close_container(m);
835 case SD_BUS_TYPE_UNIX_FD:
836 log_error("UNIX file descriptor not supported as type.");
840 log_error("Unknown signature type %c.", t);
845 return bus_log_create_error(r);
852 static int call(sd_bus *bus, char *argv[]) {
853 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
854 _cleanup_bus_message_unref_ sd_bus_message *m = NULL, *reply = NULL;
859 if (strv_length(argv) < 5) {
860 log_error("Expects at least four arguments.");
864 r = sd_bus_message_new_method_call(bus, &m, argv[1], argv[2], argv[3], argv[4]);
866 log_error("Failed to prepare bus message: %s", strerror(-r));
870 if (!isempty(argv[5])) {
875 r = message_append_cmdline(m, argv[5], &p);
880 log_error("Too many parameters for signature.");
885 r = sd_bus_call(bus, m, 0, &error, &reply);
887 log_error("%s", bus_error_message(&error, r));
891 r = sd_bus_message_is_empty(reply);
893 return bus_log_parse_error(r);
894 if (r == 0 && !arg_quiet) {
895 pager_open_if_enabled();
896 bus_message_dump(reply, stdout, 0);
902 static int get_property(sd_bus *bus, char *argv[]) {
903 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
909 n = strv_length(argv);
911 log_error("Expects at least three arguments.");
916 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
917 bool not_first = false;
919 r = sd_bus_call_method(bus, argv[1], argv[2], "org.freedesktop.DBus.Properties", "GetAll", &error, &reply, "s", strempty(argv[3]));
921 log_error("%s", bus_error_message(&error, r));
925 r = sd_bus_message_enter_container(reply, 'a', "{sv}");
927 return bus_log_parse_error(r);
932 r = sd_bus_message_enter_container(reply, 'e', "sv");
934 return bus_log_parse_error(r);
939 r = sd_bus_message_read(reply, "s", &name);
941 return bus_log_parse_error(r);
946 printf("Property %s:\n", name);
948 r = sd_bus_message_enter_container(reply, 'v', NULL);
950 return bus_log_parse_error(r);
952 pager_open_if_enabled();
953 bus_message_dump(reply, stdout, BUS_MESSAGE_DUMP_SUBTREE_ONLY);
955 r = sd_bus_message_exit_container(reply);
957 return bus_log_parse_error(r);
959 r = sd_bus_message_exit_container(reply);
961 return bus_log_parse_error(r);
966 r = sd_bus_message_exit_container(reply);
968 return bus_log_parse_error(r);
972 STRV_FOREACH(i, argv + 4) {
973 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
975 r = sd_bus_call_method(bus, argv[1], argv[2], "org.freedesktop.DBus.Properties", "Get", &error, &reply, "ss", argv[3], *i);
977 log_error("%s", bus_error_message(&error, r));
981 r = sd_bus_message_enter_container(reply, 'v', NULL);
983 return bus_log_parse_error(r);
989 printf("Property %s:\n", *i);
991 pager_open_if_enabled();
992 bus_message_dump(reply, stdout, BUS_MESSAGE_DUMP_SUBTREE_ONLY);
994 r = sd_bus_message_exit_container(reply);
996 return bus_log_parse_error(r);
1003 static int help(void) {
1004 printf("%s [OPTIONS...] {COMMAND} ...\n\n"
1005 "Introspect the bus.\n\n"
1006 " -h --help Show this help\n"
1007 " --version Show package version\n"
1008 " --no-pager Do not pipe output into a pager\n"
1009 " --no-legend Do not show the headers and footers\n"
1010 " --system Connect to system bus\n"
1011 " --user Connect to user bus\n"
1012 " -H --host=[USER@]HOST Operate on remote host\n"
1013 " -M --machine=CONTAINER Operate on local container\n"
1014 " --address=ADDRESS Connect to bus specified by address\n"
1015 " --show-machine Show machine ID column in list\n"
1016 " --unique Only show unique names\n"
1017 " --acquired Only show acquired names\n"
1018 " --activatable Only show activatable names\n"
1019 " --match=MATCH Only show matching messages\n"
1020 " --list Don't show tree, but simple object path list\n"
1021 " --quiet Don't show method call reply\n\n"
1023 " list List bus names\n"
1024 " tree [SERVICE...] Show object tree of service\n"
1025 " monitor [SERVICE...] Show bus traffic\n"
1026 " capture [SERVICE...] Capture bus traffic as pcap\n"
1027 " status SERVICE Show service name status\n"
1028 " call SERVICE PATH INTERFACE METHOD [SIGNATURE [ARGUMENTS...]]\n"
1030 " get-property SERVICE PATH [INTERFACE [PROPERTY...]]\n"
1031 " Get property value\n"
1032 " help Show this help\n"
1033 , program_invocation_short_name);
1038 static int parse_argv(int argc, char *argv[]) {
1041 ARG_VERSION = 0x100,
1056 static const struct option options[] = {
1057 { "help", no_argument, NULL, 'h' },
1058 { "version", no_argument, NULL, ARG_VERSION },
1059 { "no-pager", no_argument, NULL, ARG_NO_PAGER },
1060 { "no-legend", no_argument, NULL, ARG_NO_LEGEND },
1061 { "system", no_argument, NULL, ARG_SYSTEM },
1062 { "user", no_argument, NULL, ARG_USER },
1063 { "address", required_argument, NULL, ARG_ADDRESS },
1064 { "show-machine", no_argument, NULL, ARG_SHOW_MACHINE },
1065 { "unique", no_argument, NULL, ARG_UNIQUE },
1066 { "acquired", no_argument, NULL, ARG_ACQUIRED },
1067 { "activatable", no_argument, NULL, ARG_ACTIVATABLE },
1068 { "match", required_argument, NULL, ARG_MATCH },
1069 { "host", required_argument, NULL, 'H' },
1070 { "machine", required_argument, NULL, 'M' },
1071 { "size", required_argument, NULL, ARG_SIZE },
1072 { "list", no_argument, NULL, ARG_LIST },
1073 { "quiet", no_argument, NULL, 'q' },
1082 while ((c = getopt_long(argc, argv, "hH:M:q", options, NULL)) >= 0)
1090 puts(PACKAGE_STRING);
1091 puts(SYSTEMD_FEATURES);
1095 arg_no_pager = true;
1111 arg_address = optarg;
1114 case ARG_SHOW_MACHINE:
1115 arg_show_machine = true;
1123 arg_acquired = true;
1126 case ARG_ACTIVATABLE:
1127 arg_activatable = true;
1131 if (strv_extend(&arg_matches, optarg) < 0)
1138 r = parse_size(optarg, 0, &o);
1140 log_error("Failed to parse size: %s", optarg);
1144 if ((off_t) (size_t) o != o) {
1145 log_error("Size out of range.");
1149 arg_snaplen = (size_t) o;
1158 arg_transport = BUS_TRANSPORT_REMOTE;
1163 arg_transport = BUS_TRANSPORT_CONTAINER;
1175 assert_not_reached("Unhandled option");
1181 static int busctl_main(sd_bus *bus, int argc, char *argv[]) {
1184 if (optind >= argc ||
1185 streq(argv[optind], "list"))
1186 return list_bus_names(bus, argv + optind);
1188 if (streq(argv[optind], "monitor"))
1189 return monitor(bus, argv + optind, message_dump);
1191 if (streq(argv[optind], "capture"))
1192 return capture(bus, argv + optind);
1194 if (streq(argv[optind], "status"))
1195 return status(bus, argv + optind);
1197 if (streq(argv[optind], "tree"))
1198 return tree(bus, argv + optind);
1200 if (streq(argv[optind], "call"))
1201 return call(bus, argv + optind);
1203 if (streq(argv[optind], "get-property"))
1204 return get_property(bus, argv + optind);
1206 if (streq(argv[optind], "help"))
1209 log_error("Unknown command '%s'", argv[optind]);
1213 int main(int argc, char *argv[]) {
1214 _cleanup_bus_close_unref_ sd_bus *bus = NULL;
1217 log_parse_environment();
1220 r = parse_argv(argc, argv);
1224 r = sd_bus_new(&bus);
1226 log_error("Failed to allocate bus: %s", strerror(-r));
1230 if (streq_ptr(argv[optind], "monitor") ||
1231 streq_ptr(argv[optind], "capture")) {
1233 r = sd_bus_set_monitor(bus, true);
1235 log_error("Failed to set monitor mode: %s", strerror(-r));
1239 r = sd_bus_negotiate_creds(bus, _SD_BUS_CREDS_ALL);
1241 log_error("Failed to enable credentials: %s", strerror(-r));
1245 r = sd_bus_negotiate_timestamp(bus, true);
1247 log_error("Failed to enable timestamps: %s", strerror(-r));
1251 r = sd_bus_negotiate_fds(bus, true);
1253 log_error("Failed to enable fds: %s", strerror(-r));
1259 r = sd_bus_set_address(bus, arg_address);
1261 switch (arg_transport) {
1263 case BUS_TRANSPORT_LOCAL:
1265 r = bus_set_address_user(bus);
1267 r = bus_set_address_system(bus);
1270 case BUS_TRANSPORT_REMOTE:
1271 r = bus_set_address_system_remote(bus, arg_host);
1274 case BUS_TRANSPORT_CONTAINER:
1275 r = bus_set_address_system_container(bus, arg_host);
1279 assert_not_reached("Hmm, unknown transport type.");
1283 log_error("Failed to set address: %s", strerror(-r));
1287 r = sd_bus_set_bus_client(bus, true);
1289 log_error("Failed to set bus client: %s", strerror(-r));
1293 r = sd_bus_start(bus);
1295 log_error("Failed to connect to bus: %s", strerror(-r));
1299 r = busctl_main(bus, argc, argv);
1304 strv_free(arg_matches);
1306 return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;