Debian Codegraph @

src/busctl/busctl.c

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include <unistd.h>
4
5 #include "sd-bus.h"
6 #include "sd-daemon.h"
7 #include "sd-event.h"
8 #include "sd-json.h"
9
10 #include "alloc-util.h"
11 #include "ansi-color.h"
12 #include "bitfield.h"
13 #include "build.h"
14 #include "bus-dump.h"
15 #include "bus-error.h"
16 #include "bus-internal.h"
17 #include "bus-signature.h"
18 #include "bus-type.h"
19 #include "bus-util.h"
20 #include "busctl-introspect.h"
21 #include "capsule-util.h"
22 #include "errno-util.h"
23 #include "escape.h"
24 #include "fd-util.h"
25 #include "fdset.h"
26 #include "fileio.h"
27 #include "format-table.h"
28 #include "glyph-util.h"
29 #include "help-util.h"
30 #include "log.h"
31 #include "logarithm.h"
32 #include "main-func.h"
33 #include "memstream-util.h"
34 #include "options.h"
35 #include "os-util.h"
36 #include "pager.h"
37 #include "parse-argument.h"
38 #include "parse-util.h"
39 #include "path-util.h"
40 #include "runtime-scope.h"
41 #include "set.h"
42 #include "string-util.h"
43 #include "strv.h"
44 #include "terminal-util.h"
45 #include "time-util.h"
46 #include "user-util.h"
47 #include "verbs.h"
48 #include "version.h"
49
50 static sd_json_format_flags_t arg_json_format_flags = SD_JSON_FORMAT_OFF;
51 static PagerFlags arg_pager_flags = 0;
52 static bool arg_legend = true;
53 static int arg_full = -1;
54 static const char *arg_address = NULL;
55 static bool arg_unique = false;
56 static bool arg_acquired = false;
57 static bool arg_activatable = false;
58 static bool arg_show_machine = false;
59 static char **arg_matches = NULL;
60 static BusTransport arg_transport = BUS_TRANSPORT_LOCAL;
61 static const char *arg_host = NULL;
62 static RuntimeScope arg_runtime_scope = RUNTIME_SCOPE_SYSTEM;
63 static size_t arg_snaplen = 4096;
64 static bool arg_list = false;
65 static bool arg_quiet = false;
66 static bool arg_verbose = false;
67 static bool arg_xml_interface = false;
68 static bool arg_expect_reply = true;
69 static bool arg_auto_start = true;
70 static bool arg_allow_interactive_authorization = true;
71 static bool arg_augment_creds = true;
72 static bool arg_watch_bind = false;
73 static usec_t arg_timeout = 0;
74 static const char *arg_destination = NULL;
75 static uint64_t arg_limit_messages = UINT64_MAX;
76 static uint64_t arg_limit_signals = 1;
77
78 STATIC_DESTRUCTOR_REGISTER(arg_matches, strv_freep);
79
80 #define NAME_IS_ACQUIRED INT_TO_PTR(1)
81 #define NAME_IS_ACTIVATABLE INT_TO_PTR(2)
82
83 static int acquire_bus(bool set_monitor, sd_bus **ret) {
84 _cleanup_(sd_bus_close_unrefp) sd_bus *bus = NULL;
85 _cleanup_close_ int pin_fd = -EBADF;
86 int r;
87
88 r = sd_bus_new(&bus);
89 if (r < 0)
90 return log_error_errno(r, "Failed to allocate bus: %m");
91
92 (void) sd_bus_set_description(bus, "busctl");
93
94 if (set_monitor) {
95 r = sd_bus_set_monitor(bus, true);
96 if (r < 0)
97 return log_error_errno(r, "Failed to set monitor mode: %m");
98
99 r = sd_bus_negotiate_creds(bus, true, _SD_BUS_CREDS_ALL);
100 if (r < 0)
101 return log_error_errno(r, "Failed to enable credentials: %m");
102
103 r = sd_bus_negotiate_timestamp(bus, true);
104 if (r < 0)
105 return log_error_errno(r, "Failed to enable timestamps: %m");
106
107 r = sd_bus_negotiate_fds(bus, true);
108 if (r < 0)
109 return log_error_errno(r, "Failed to enable fds: %m");
110 }
111
112 r = sd_bus_set_bus_client(bus, true);
113 if (r < 0)
114 return log_error_errno(r, "Failed to set bus client: %m");
115
116 r = sd_bus_set_watch_bind(bus, arg_watch_bind);
117 if (r < 0)
118 return log_error_errno(r, "Failed to set watch-bind setting to '%s': %m",
119 yes_no(arg_watch_bind));
120
121 if (arg_address)
122 r = sd_bus_set_address(bus, arg_address);
123 else
124 switch (arg_transport) {
125
126 case BUS_TRANSPORT_LOCAL:
127
128 switch (arg_runtime_scope) {
129
130 case RUNTIME_SCOPE_USER:
131 r = bus_set_address_user(bus);
132 break;
133
134 case RUNTIME_SCOPE_SYSTEM:
135 r = bus_set_address_system(bus);
136 break;
137
138 default:
139 assert_not_reached();
140 }
141
142 break;
143
144 case BUS_TRANSPORT_REMOTE:
145 r = bus_set_address_system_remote(bus, arg_host);
146 break;
147
148 case BUS_TRANSPORT_MACHINE:
149 r = bus_set_address_machine(bus, arg_runtime_scope, arg_host);
150 break;
151
152 case BUS_TRANSPORT_CAPSULE:
153 r = bus_set_address_capsule_bus(bus, arg_host, &pin_fd);
154 break;
155
156 default:
157 assert_not_reached();
158 }
159 if (r < 0)
160 return bus_log_address_error(r, arg_transport);
161
162 r = sd_bus_start(bus);
163 if (r < 0)
164 return bus_log_connect_error(r, arg_transport, arg_runtime_scope);
165
166 *ret = TAKE_PTR(bus);
167
168 return 0;
169 }
170
171 static void notify_bus_error(const sd_bus_error *error) {
172
173 if (!sd_bus_error_is_set(error))
174 return;
175
176 (void) sd_notifyf(/* unset_environment= */ false, "BUSERROR=%s", error->name);
177 }
178
179 VERB_DEFAULT_NOARG(verb_list, "list", "List bus names");
180 static int verb_list(int argc, char *argv[], uintptr_t _data, void *userdata) {
181 _cleanup_strv_free_ char **acquired = NULL, **activatable = NULL;
182 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
183 _cleanup_hashmap_free_ Hashmap *names = NULL;
184 _cleanup_(table_unrefp) Table *table = NULL;
185 char *k;
186 void *v;
187 int r;
188
189 enum {
190 COLUMN_ACTIVATABLE,
191 COLUMN_NAME,
192 COLUMN_PID,
193 COLUMN_PROCESS,
194 COLUMN_USER,
195 COLUMN_CONNECTION,
196 COLUMN_UNIT,
197 COLUMN_SESSION,
198 COLUMN_DESCRIPTION,
199 COLUMN_MACHINE,
200 };
201
202 if (!arg_unique && !arg_acquired && !arg_activatable)
203 arg_unique = arg_acquired = arg_activatable = true;
204
205 r = acquire_bus(false, &bus);
206 if (r < 0)
207 return r;
208
209 r = sd_bus_list_names(bus,
210 (arg_acquired || arg_unique) ? &acquired : NULL,
211 arg_activatable ? &activatable : NULL);
212 if (r < 0)
213 return log_error_errno(r, "Failed to list names: %m");
214
215 names = hashmap_new(&string_hash_ops);
216 if (!names)
217 return log_oom();
218
219 STRV_FOREACH(i, acquired) {
220 r = hashmap_put(names, *i, NAME_IS_ACQUIRED);
221 if (r < 0)
222 return log_error_errno(r, "Failed to add to hashmap: %m");
223 }
224
225 STRV_FOREACH(i, activatable) {
226 r = hashmap_put(names, *i, NAME_IS_ACTIVATABLE);
227 if (r < 0 && r != -EEXIST)
228 return log_error_errno(r, "Failed to add to hashmap: %m");
229 }
230
231 table = table_new("activatable",
232 "name",
233 "pid",
234 "process",
235 "user",
236 "connection",
237 "unit",
238 "session",
239 "description",
240 "machine");
241 if (!table)
242 return log_oom();
243
244 if (arg_full > 0)
245 table_set_width(table, 0);
246
247 r = table_set_align_percent(table, table_get_cell(table, 0, COLUMN_PID), 100);
248 if (r < 0)
249 return log_error_errno(r, "Failed to set alignment: %m");
250
251 table_set_ersatz_string(table, TABLE_ERSATZ_DASH);
252
253 r = table_set_sort(table, (size_t) COLUMN_NAME);
254 if (r < 0)
255 return log_error_errno(r, "Failed to set sort column: %m");
256
257 if (arg_show_machine)
258 r = table_set_display(table, (size_t) COLUMN_NAME,
259 (size_t) COLUMN_PID,
260 (size_t) COLUMN_PROCESS,
261 (size_t) COLUMN_USER,
262 (size_t) COLUMN_CONNECTION,
263 (size_t) COLUMN_UNIT,
264 (size_t) COLUMN_SESSION,
265 (size_t) COLUMN_DESCRIPTION,
266 (size_t) COLUMN_MACHINE);
267 else
268 r = table_set_display(table, (size_t) COLUMN_NAME,
269 (size_t) COLUMN_PID,
270 (size_t) COLUMN_PROCESS,
271 (size_t) COLUMN_USER,
272 (size_t) COLUMN_CONNECTION,
273 (size_t) COLUMN_UNIT,
274 (size_t) COLUMN_SESSION,
275 (size_t) COLUMN_DESCRIPTION);
276
277 if (r < 0)
278 return log_error_errno(r, "Failed to set columns to display: %m");
279
280 HASHMAP_FOREACH_KEY(v, k, names) {
281 _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
282
283 if (v == NAME_IS_ACTIVATABLE) {
284 r = table_add_many(
285 table,
286 TABLE_INT, PTR_TO_INT(v),
287 TABLE_STRING, k,
288 TABLE_EMPTY,
289 TABLE_EMPTY,
290 TABLE_EMPTY,
291 TABLE_STRING, "(activatable)", TABLE_SET_COLOR, ansi_grey(),
292 TABLE_EMPTY,
293 TABLE_EMPTY,
294 TABLE_EMPTY,
295 TABLE_EMPTY);
296 if (r < 0)
297 return table_log_add_error(r);
298
299 continue;
300 }
301
302 assert(v == NAME_IS_ACQUIRED);
303
304 if (!arg_unique && k[0] == ':')
305 continue;
306
307 if (!arg_acquired && k[0] != ':')
308 continue;
309
310 r = table_add_many(table,
311 TABLE_INT, PTR_TO_INT(v),
312 TABLE_STRING, k);
313 if (r < 0)
314 return table_log_add_error(r);
315
316 r = sd_bus_get_name_creds(
317 bus, k,
318 (arg_augment_creds ? SD_BUS_CREDS_AUGMENT : 0) |
319 SD_BUS_CREDS_EUID|SD_BUS_CREDS_PID|SD_BUS_CREDS_COMM|
320 SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_UNIT|SD_BUS_CREDS_SESSION|
321 SD_BUS_CREDS_DESCRIPTION, &creds);
322 if (r < 0) {
323 log_debug_errno(r, "Failed to acquire credentials of service %s, ignoring: %m", k);
324
325 r = table_fill_empty(table, COLUMN_MACHINE);
326 } else {
327 const char *unique = NULL, *session = NULL, *unit = NULL, *cn = NULL;
328 pid_t pid;
329 uid_t uid;
330
331 r = sd_bus_creds_get_pid(creds, &pid);
332 if (r >= 0) {
333 const char *comm = NULL;
334
335 (void) sd_bus_creds_get_comm(creds, &comm);
336
337 r = table_add_many(table,
338 TABLE_PID, pid,
339 TABLE_STRING, strna(comm));
340 } else
341 r = table_add_many(table, TABLE_EMPTY, TABLE_EMPTY);
342 if (r < 0)
343 return table_log_add_error(r);
344
345 r = sd_bus_creds_get_euid(creds, &uid);
346 if (r >= 0) {
347 _cleanup_free_ char *u = NULL;
348
349 u = uid_to_name(uid);
350 if (!u)
351 return log_oom();
352
353 r = table_add_cell(table, NULL, TABLE_STRING, u);
354 } else
355 r = table_add_cell(table, NULL, TABLE_EMPTY, NULL);
356 if (r < 0)
357 return table_log_add_error(r);
358
359 (void) sd_bus_creds_get_unique_name(creds, &unique);
360 (void) sd_bus_creds_get_unit(creds, &unit);
361 (void) sd_bus_creds_get_session(creds, &session);
362 (void) sd_bus_creds_get_description(creds, &cn);
363
364 r = table_add_many(
365 table,
366 TABLE_STRING, unique,
367 TABLE_STRING, unit,
368 TABLE_STRING, session,
369 TABLE_STRING, cn);
370 }
371 if (r < 0)
372 return table_log_add_error(r);
373
374 if (arg_show_machine) {
375 sd_id128_t mid;
376
377 r = sd_bus_get_name_machine_id(bus, k, &mid);
378 if (r < 0)
379 log_debug_errno(r, "Failed to acquire credentials of service %s, ignoring: %m", k);
380 else {
381 r = table_add_cell(table, NULL, TABLE_ID128, &mid);
382 if (r < 0)
383 return table_log_add_error(r);
384
385 continue; /* line fully filled, no need to fill the remainder below */
386 }
387 }
388
389 r = table_fill_empty(table, 0);
390 if (r < 0)
391 return log_error_errno(r, "Failed to fill line: %m");
392 }
393
394 return table_print_with_pager(table, arg_json_format_flags, arg_pager_flags, arg_legend);
395 }
396
397 static void print_subtree(const char *prefix, const char *path, char **l) {
398 assert(l);
399
400 /* We assume the list is sorted. Let's first skip over the
401 * entry we are looking at. */
402 for (;;) {
403 if (!*l)
404 return;
405
406 if (!streq(*l, path))
407 break;
408
409 l++;
410 }
411
412 const char
413 *vertical = strjoina(prefix, glyph(GLYPH_TREE_VERTICAL)),
414 *space = strjoina(prefix, glyph(GLYPH_TREE_SPACE));
415
416 for (;;) {
417 bool has_more = false;
418 char **n;
419
420 if (!*l || !path_startswith(*l, path))
421 break;
422
423 n = l + 1;
424 for (;;) {
425 if (!*n || !path_startswith(*n, path))
426 break;
427
428 if (!path_startswith(*n, *l)) {
429 has_more = true;
430 break;
431 }
432
433 n++;
434 }
435
436 printf("%s%s %s\n",
437 prefix,
438 glyph(has_more ? GLYPH_TREE_BRANCH : GLYPH_TREE_RIGHT),
439 *l);
440
441 print_subtree(has_more ? vertical : space, *l, l);
442 l = n;
443 }
444 }
445
446 static void print_tree(char **l) {
447 if (arg_list)
448 strv_print(l);
449 else if (strv_isempty(l))
450 printf("No objects discovered.\n");
451 else if (streq(l[0], "/") && !l[1])
452 printf("Only root object discovered.\n");
453 else
454 print_subtree("", "/", l);
455 }
456
457 static int on_path(const char *path, void *userdata) {
458 Set *paths = ASSERT_PTR(userdata);
459 int r;
460
461 r = set_put_strdup(&paths, path);
462 if (r < 0)
463 return log_oom();
464
465 return 0;
466 }
467
468 static int find_nodes(sd_bus *bus, const char *service, const char *path, Set *paths) {
469 static const XMLIntrospectOps ops = {
470 .on_path = on_path,
471 };
472
473 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
474 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
475 const char *xml;
476 int r;
477
478 r = sd_bus_call_method(bus, service, path,
479 "org.freedesktop.DBus.Introspectable", "Introspect",
480 &error, &reply, NULL);
481 if (r < 0) {
482 notify_bus_error(&error);
483 printf("%sFailed to introspect object %s of service %s: %s%s\n",
484 ansi_highlight_red(),
485 path, service, bus_error_message(&error, r),
486 ansi_normal());
487 return r;
488 }
489
490 r = sd_bus_message_read(reply, "s", &xml);
491 if (r < 0)
492 return bus_log_parse_error(r);
493
494 return parse_xml_introspect(path, xml, &ops, paths);
495 }
496
497 static int tree_one(sd_bus *bus, const char *service) {
498 _cleanup_set_free_ Set *paths = NULL, *done = NULL, *failed = NULL;
499 _cleanup_free_ char **l = NULL;
500 int r;
501
502 r = set_put_strdup(&paths, "/");
503 if (r < 0)
504 return log_oom();
505
506 for (;;) {
507 _cleanup_free_ char *p = NULL;
508 int q;
509
510 p = set_steal_first(paths);
511 if (!p)
512 break;
513
514 if (set_contains(done, p) ||
515 set_contains(failed, p))
516 continue;
517
518 q = find_nodes(bus, service, p, paths);
519 if (q < 0 && r >= 0)
520 r = q;
521
522 q = set_ensure_consume(q < 0 ? &failed : &done, &string_hash_ops_free, TAKE_PTR(p));
523 assert(q != 0);
524 if (q < 0)
525 return log_oom();
526 }
527
528 pager_open(arg_pager_flags);
529
530 l = set_get_strv(done);
531 if (!l)
532 return log_oom();
533
534 strv_sort(l);
535 print_tree(l);
536
537 fflush(stdout);
538
539 return r;
540 }
541
542 VERB(verb_tree, "tree", "[SERVICE…]", VERB_ANY, VERB_ANY, 0,
543 "Show object tree of service");
544 static int verb_tree(int argc, char *argv[], uintptr_t _data, void *userdata) {
545 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
546 int r;
547
548 /* Do superficial verification of arguments before even opening the bus */
549 STRV_FOREACH(i, strv_skip(argv, 1))
550 if (!sd_bus_service_name_is_valid(*i))
551 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
552 "Invalid bus service name: %s", *i);
553
554 if (!arg_unique && !arg_acquired)
555 arg_acquired = true;
556
557 r = acquire_bus(false, &bus);
558 if (r < 0)
559 return r;
560
561 char **args = strv_skip(argv, 1);
562 if (args)
563 STRV_FOREACH(arg, args) {
564 if (arg != args)
565 puts("");
566
567 if (args[1]) {
568 pager_open(arg_pager_flags);
569 printf("Service %s%s%s:\n", ansi_highlight(), *arg, ansi_normal());
570 }
571
572 RET_GATHER(r, tree_one(bus, *arg));
573 }
574 else {
575 _cleanup_strv_free_ char **names = NULL;
576
577 r = sd_bus_list_names(bus, &names, NULL);
578 if (r < 0)
579 return log_error_errno(r, "Failed to get name list: %m");
580
581 pager_open(arg_pager_flags);
582
583 STRV_FOREACH(name, names) {
584 if (!arg_unique && (*name)[0] == ':')
585 continue;
586
587 if (!arg_acquired && (*name)[0] == ':')
588 continue;
589
590 if (name != names)
591 puts("");
592
593 printf("Service %s%s%s:\n", ansi_highlight(), *name, ansi_normal());
594
595 RET_GATHER(r, tree_one(bus, *name));
596 }
597 }
598
599 return r;
600 }
601
602 static int format_cmdline(sd_bus_message *m, FILE *f, bool needs_space) {
603 int r;
604
605 for (;;) {
606 const char *contents = NULL;
607 char type;
608 union {
609 uint8_t u8;
610 uint16_t u16;
611 int16_t s16;
612 uint32_t u32;
613 int32_t s32;
614 uint64_t u64;
615 int64_t s64;
616 double d64;
617 const char *string;
618 int i;
619 } basic;
620
621 r = sd_bus_message_peek_type(m, &type, &contents);
622 if (r < 0)
623 return r;
624 if (r == 0)
625 return needs_space;
626
627 if (bus_type_is_container(type) > 0) {
628
629 r = sd_bus_message_enter_container(m, type, contents);
630 if (r < 0)
631 return r;
632
633 if (type == SD_BUS_TYPE_ARRAY) {
634 unsigned n = 0;
635
636 /* count array entries */
637 for (;;) {
638
639 r = sd_bus_message_skip(m, contents);
640 if (r < 0)
641 return r;
642 if (r == 0)
643 break;
644
645 n++;
646 }
647
648 r = sd_bus_message_rewind(m, false);
649 if (r < 0)
650 return r;
651
652 if (needs_space)
653 fputc(' ', f);
654
655 fprintf(f, "%u", n);
656 needs_space = true;
657
658 } else if (type == SD_BUS_TYPE_VARIANT) {
659
660 if (needs_space)
661 fputc(' ', f);
662
663 fprintf(f, "%s", contents);
664 needs_space = true;
665 }
666
667 r = format_cmdline(m, f, needs_space);
668 if (r < 0)
669 return r;
670
671 needs_space = r > 0;
672
673 r = sd_bus_message_exit_container(m);
674 if (r < 0)
675 return r;
676
677 continue;
678 }
679
680 r = sd_bus_message_read_basic(m, type, &basic);
681 if (r < 0)
682 return r;
683
684 if (needs_space)
685 fputc(' ', f);
686
687 switch (type) {
688 case SD_BUS_TYPE_BYTE:
689 fprintf(f, "%u", basic.u8);
690 break;
691
692 case SD_BUS_TYPE_BOOLEAN:
693 fputs(true_false(basic.i), f);
694 break;
695
696 case SD_BUS_TYPE_INT16:
697 fprintf(f, "%i", basic.s16);
698 break;
699
700 case SD_BUS_TYPE_UINT16:
701 fprintf(f, "%u", basic.u16);
702 break;
703
704 case SD_BUS_TYPE_INT32:
705 fprintf(f, "%i", basic.s32);
706 break;
707
708 case SD_BUS_TYPE_UINT32:
709 fprintf(f, "%u", basic.u32);
710 break;
711
712 case SD_BUS_TYPE_INT64:
713 fprintf(f, "%" PRIi64, basic.s64);
714 break;
715
716 case SD_BUS_TYPE_UINT64:
717 fprintf(f, "%" PRIu64, basic.u64);
718 break;
719
720 case SD_BUS_TYPE_DOUBLE:
721 fprintf(f, "%g", basic.d64);
722 break;
723
724 case SD_BUS_TYPE_STRING:
725 case SD_BUS_TYPE_OBJECT_PATH:
726 case SD_BUS_TYPE_SIGNATURE: {
727 _cleanup_free_ char *b = NULL;
728
729 b = cescape(basic.string);
730 if (!b)
731 return -ENOMEM;
732
733 fprintf(f, "\"%s\"", b);
734 break;
735 }
736
737 case SD_BUS_TYPE_UNIX_FD:
738 fprintf(f, "%i", basic.i);
739 break;
740
741 default:
742 assert_not_reached();
743 }
744
745 needs_space = true;
746 }
747 }
748
749 typedef struct Member {
750 const char *type;
751 char *interface;
752 char *name;
753 char *signature;
754 char *result;
755 char *value;
756 bool writable;
757 uint64_t flags;
758 } Member;
759
760 static void member_hash_func(const Member *m, struct siphash *state) {
761 uint64_t arity = 1;
762
763 assert(m);
764 assert(m->type);
765
766 string_hash_func(m->type, state);
767
768 arity += !!m->name + !!m->interface;
769
770 uint64_hash_func(&arity, state);
771
772 if (m->name)
773 string_hash_func(m->name, state);
774
775 if (m->signature)
776 string_hash_func(m->signature, state);
777
778 if (m->interface)
779 string_hash_func(m->interface, state);
780 }
781
782 static int member_compare_func(const Member *x, const Member *y) {
783 int d;
784
785 assert(x);
786 assert(y);
787 assert(x->type);
788 assert(y->type);
789
790 d = strcmp_ptr(x->interface, y->interface);
791 if (d != 0)
792 return d;
793
794 d = strcmp(x->type, y->type);
795 if (d != 0)
796 return d;
797
798 d = strcmp_ptr(x->name, y->name);
799 if (d != 0)
800 return d;
801
802 return strcmp_ptr(x->signature, y->signature);
803 }
804
805 static Member* member_free(Member *m) {
806 if (!m)
807 return NULL;
808
809 free(m->interface);
810 free(m->name);
811 free(m->signature);
812 free(m->result);
813 free(m->value);
814 return mfree(m);
815 }
816 DEFINE_TRIVIAL_CLEANUP_FUNC(Member*, member_free);
817
818 static int on_interface(const char *interface, uint64_t flags, void *userdata) {
819 _cleanup_(member_freep) Member *m = NULL;
820 Set *members = ASSERT_PTR(userdata);
821 int r;
822
823 assert(interface);
824
825 m = new(Member, 1);
826 if (!m)
827 return log_oom();
828
829 *m = (Member) {
830 .type = "interface",
831 .flags = flags,
832 };
833
834 r = strdup_to(&m->interface, interface);
835 if (r < 0)
836 return log_oom();
837
838 r = set_consume(members, TAKE_PTR(m));
839 if (r < 0)
840 return log_oom();
841 if (r == 0)
842 return log_error_errno(SYNTHETIC_ERRNO(EEXIST),
843 "Invalid introspection data: duplicate interface '%s'.", interface);
844
845 return 0;
846 }
847
848 static int on_method(const char *interface, const char *name, const char *signature, const char *result, uint64_t flags, void *userdata) {
849 _cleanup_(member_freep) Member *m = NULL;
850 Set *members = userdata;
851 int r;
852
853 assert(interface);
854 assert(name);
855
856 m = new(Member, 1);
857 if (!m)
858 return log_oom();
859
860 *m = (Member) {
861 .type = "method",
862 .flags = flags,
863 };
864
865 r = strdup_to(&m->interface, interface);
866 if (r < 0)
867 return log_oom();
868
869 r = strdup_to(&m->name, name);
870 if (r < 0)
871 return log_oom();
872
873 r = strdup_to(&m->signature, signature);
874 if (r < 0)
875 return log_oom();
876
877 r = strdup_to(&m->result, result);
878 if (r < 0)
879 return log_oom();
880
881 r = set_consume(members, TAKE_PTR(m));
882 if (r < 0)
883 return log_oom();
884 if (r == 0)
885 return log_error_errno(SYNTHETIC_ERRNO(EEXIST),
886 "Invalid introspection data: duplicate method '%s' on interface '%s'.", name, interface);
887
888 return 0;
889 }
890
891 static int on_signal(const char *interface, const char *name, const char *signature, uint64_t flags, void *userdata) {
892 _cleanup_(member_freep) Member *m = NULL;
893 Set *members = userdata;
894 int r;
895
896 assert(interface);
897 assert(name);
898
899 m = new(Member, 1);
900 if (!m)
901 return log_oom();
902
903 *m = (Member) {
904 .type = "signal",
905 .flags = flags,
906 };
907
908 r = strdup_to(&m->interface, interface);
909 if (r < 0)
910 return log_oom();
911
912 r = strdup_to(&m->name, name);
913 if (r < 0)
914 return log_oom();
915
916 r = strdup_to(&m->signature, signature);
917 if (r < 0)
918 return log_oom();
919
920 r = set_consume(members, TAKE_PTR(m));
921 if (r < 0)
922 return log_oom();
923 if (r == 0)
924 return log_error_errno(SYNTHETIC_ERRNO(EEXIST),
925 "Invalid introspection data: duplicate signal '%s' on interface '%s'.", name, interface);
926
927 return 0;
928 }
929
930 static int on_property(const char *interface, const char *name, const char *signature, bool writable, uint64_t flags, void *userdata) {
931 _cleanup_(member_freep) Member *m = NULL;
932 Set *members = userdata;
933 int r;
934
935 assert(interface);
936 assert(name);
937
938 m = new(Member, 1);
939 if (!m)
940 return log_oom();
941
942 *m = (Member) {
943 .type = "property",
944 .flags = flags,
945 .writable = writable,
946 };
947
948 r = strdup_to(&m->interface, interface);
949 if (r < 0)
950 return log_oom();
951
952 r = strdup_to(&m->name, name);
953 if (r < 0)
954 return log_oom();
955
956 r = strdup_to(&m->signature, signature);
957 if (r < 0)
958 return log_oom();
959
960 r = set_consume(members, TAKE_PTR(m));
961 if (r < 0)
962 return log_oom();
963 if (r == 0)
964 return log_error_errno(SYNTHETIC_ERRNO(EEXIST),
965 "Invalid introspection data: duplicate property '%s' on interface '%s'.", name, interface);
966
967 return 0;
968 }
969
970 DEFINE_PRIVATE_HASH_OPS_WITH_KEY_DESTRUCTOR(
971 member_hash_ops,
972 Member,
973 member_hash_func,
974 member_compare_func,
975 member_free);
976
977 static int members_flags_to_string(const Member *m, char **ret) {
978 static const char *map[] = {
979 [LOG2U(SD_BUS_VTABLE_DEPRECATED)] = "deprecated",
980 [LOG2U(SD_BUS_VTABLE_METHOD_NO_REPLY)] = "no-reply",
981 [LOG2U(SD_BUS_VTABLE_PROPERTY_CONST)] = "const",
982 [LOG2U(SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE)] = "emits-change",
983 [LOG2U(SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION)] = "emits-invalidation",
984 };
985
986 assert(m);
987 assert(ret);
988
989 _cleanup_free_ char *str = NULL;
990 for (size_t i = 0; i < ELEMENTSOF(map); i++)
991 if (BIT_SET(m->flags, i) && map[i])
992 if (!strextend_with_separator(&str, " ", map[i]))
993 return -ENOMEM;
994
995 if (m->writable)
996 if (!strextend_with_separator(&str, " ", "writable"))
997 return -ENOMEM;
998
999 *ret = TAKE_PTR(str);
1000 return 0;
1001 }
1002
1003 VERB(verb_introspect, "introspect", "SERVICE OBJECT [INTERFACE]", 3, 4, 0,
1004 "Introspect an object");
1005 static int verb_introspect(int argc, char *argv[], uintptr_t _data, void *userdata) {
1006 static const XMLIntrospectOps ops = {
1007 .on_interface = on_interface,
1008 .on_method = on_method,
1009 .on_signal = on_signal,
1010 .on_property = on_property,
1011 };
1012
1013 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
1014 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply_xml = NULL;
1015 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1016 _cleanup_set_free_ Set *members = NULL;
1017 Member *m;
1018 const char *xml;
1019 int r;
1020
1021 r = acquire_bus(false, &bus);
1022 if (r < 0)
1023 return r;
1024
1025 members = set_new(&member_hash_ops);
1026 if (!members)
1027 return log_oom();
1028
1029 r = sd_bus_call_method(bus, argv[1], argv[2],
1030 "org.freedesktop.DBus.Introspectable", "Introspect",
1031 &error, &reply_xml, NULL);
1032 if (r < 0) {
1033 notify_bus_error(&error);
1034 return log_error_errno(r, "Failed to introspect object %s of service %s: %s",
1035 argv[2], argv[1], bus_error_message(&error, r));
1036 }
1037
1038 r = sd_bus_message_read(reply_xml, "s", &xml);
1039 if (r < 0)
1040 return bus_log_parse_error(r);
1041
1042 if (arg_xml_interface) {
1043 /* Just dump the received XML and finish */
1044 pager_open(arg_pager_flags);
1045 puts(xml);
1046 return 0;
1047 }
1048
1049 /* First, get list of all properties */
1050 r = parse_xml_introspect(argv[2], xml, &ops, members);
1051 if (r < 0)
1052 return r;
1053
1054 /* Second, find the current values for them */
1055 SET_FOREACH(m, members) {
1056 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
1057
1058 if (!streq(m->type, "property"))
1059 continue;
1060
1061 if (m->value)
1062 continue;
1063
1064 if (argv[3] && !streq(argv[3], m->interface))
1065 continue;
1066
1067 r = sd_bus_call_method(bus, argv[1], argv[2],
1068 "org.freedesktop.DBus.Properties", "GetAll",
1069 &error, &reply, "s", m->interface);
1070 if (r < 0) {
1071 notify_bus_error(&error);
1072 return log_error_errno(r, "Failed to get all properties on interface %s: %s",
1073 m->interface, bus_error_message(&error, r));
1074 }
1075
1076 r = sd_bus_message_enter_container(reply, 'a', "{sv}");
1077 if (r < 0)
1078 return bus_log_parse_error(r);
1079
1080 for (;;) {
1081 _cleanup_(memstream_done) MemStream ms = {};
1082 _cleanup_free_ char *buf = NULL;
1083 const char *name, *contents;
1084 Member *z;
1085 char type;
1086 FILE *mf;
1087
1088 r = sd_bus_message_enter_container(reply, 'e', "sv");
1089 if (r < 0)
1090 return bus_log_parse_error(r);
1091 if (r == 0)
1092 break;
1093
1094 r = sd_bus_message_read(reply, "s", &name);
1095 if (r < 0)
1096 return bus_log_parse_error(r);
1097
1098 r = sd_bus_message_peek_type(reply, &type, &contents);
1099 if (r < 0)
1100 return bus_log_parse_error(r);
1101 if (type != 'v')
1102 return bus_log_parse_error(EINVAL);
1103
1104 r = sd_bus_message_enter_container(reply, 'v', contents);
1105 if (r < 0)
1106 return bus_log_parse_error(r);
1107
1108 mf = memstream_init(&ms);
1109 if (!mf)
1110 return log_oom();
1111
1112 r = format_cmdline(reply, mf, false);
1113 if (r < 0)
1114 return bus_log_parse_error(r);
1115
1116 r = memstream_finalize(&ms, &buf, NULL);
1117 if (r < 0)
1118 return log_error_errno(r, "Failed to flush and close memstream: %m");
1119
1120 z = set_get(members, &((Member) {
1121 .type = "property",
1122 .interface = m->interface,
1123 .signature = (char*) contents,
1124 .name = (char*) name }));
1125 if (z)
1126 free_and_replace(z->value, buf);
1127
1128 r = sd_bus_message_exit_container(reply);
1129 if (r < 0)
1130 return bus_log_parse_error(r);
1131
1132 r = sd_bus_message_exit_container(reply);
1133 if (r < 0)
1134 return bus_log_parse_error(r);
1135 }
1136
1137 r = sd_bus_message_exit_container(reply);
1138 if (r < 0)
1139 return bus_log_parse_error(r);
1140 }
1141
1142 size_t n;
1143 _cleanup_free_ Member **sorted = NULL;
1144 r = set_dump_sorted(members, (void***) &sorted, &n);
1145 if (r < 0)
1146 return log_oom();
1147
1148 _cleanup_(table_unrefp) Table *table = table_new("name", "type", "signature", "result/value", "flags");
1149 if (!table)
1150 return log_oom();
1151
1152 if (arg_full)
1153 table_set_width(table, 0);
1154 (void) table_set_maximum_width(table, table_get_cell(table, 0, 3), arg_full ? 100 : 40);
1155 table_set_header(table, arg_legend);
1156 table_set_ersatz_string(table, TABLE_ERSATZ_DASH);
1157
1158 FOREACH_ARRAY(p, sorted, n) {
1159 bool is_interface;
1160
1161 m = *p;
1162
1163 if (argv[3] && !streq(argv[3], m->interface))
1164 continue;
1165
1166 is_interface = streq(m->type, "interface");
1167
1168 if (argv[3] && is_interface)
1169 continue;
1170
1171 if (is_interface)
1172 r = table_add_many(
1173 table,
1174 TABLE_STRING, m->interface,
1175 TABLE_SET_COLOR, ansi_highlight());
1176 else
1177 r = table_add_cell_stringf(
1178 table, /* ret_cell= */ NULL, ".%s", m->name);
1179 if (r < 0)
1180 return table_log_add_error(r);
1181
1182 _cleanup_free_ char *flags = NULL;
1183 r = members_flags_to_string(m, &flags);
1184 if (r < 0)
1185 return log_oom();
1186
1187 r = table_add_many(
1188 table,
1189 TABLE_STRING, m->type,
1190 TABLE_STRING, m->signature,
1191 TABLE_STRING, m->value ?: m->result,
1192 TABLE_STRING, flags);
1193 if (r < 0)
1194 return table_log_add_error(r);
1195 }
1196
1197 return table_print_with_pager(table, arg_json_format_flags, arg_pager_flags, arg_legend);
1198 }
1199
1200 static int message_dump(sd_bus_message *m, FILE *f) {
1201 int r;
1202
1203 assert(m);
1204
1205 r = sd_bus_message_dump(m, f, SD_BUS_MESSAGE_DUMP_WITH_HEADER);
1206 if (r < 0)
1207 return log_error_errno(r, "Failed to dump DBus message: %m");
1208
1209 return 0;
1210 }
1211
1212 static int message_pcap(sd_bus_message *m, FILE *f) {
1213 int r;
1214
1215 assert(m);
1216
1217 r = bus_message_pcap_frame(m, arg_snaplen, f);
1218 if (r < 0)
1219 return log_error_errno(r, "Failed to dump DBus message in PCAP format: %m");
1220
1221 return 0;
1222 }
1223
1224 static int message_json(sd_bus_message *m, FILE *f) {
1225 _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
1226 int r;
1227
1228 assert(m);
1229
1230 r = sd_bus_message_dump_json(m, SD_BUS_MESSAGE_DUMP_WITH_HEADER, &v);
1231 if (r < 0)
1232 return log_error_errno(r, "Failed to build JSON object from DBus message: %m");
1233
1234 r = sd_json_variant_dump(v, arg_json_format_flags, f, NULL);
1235 if (r < 0)
1236 return log_error_errno(r, "Failed to show JSON object: %m");
1237
1238 return 0;
1239 }
1240
1241 static int monitor(int argc, char **argv, int (*dump)(sd_bus_message *m, FILE *f)) {
1242 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
1243 _cleanup_(sd_bus_message_unrefp) sd_bus_message *message = NULL;
1244 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1245 uint32_t flags = 0;
1246 const char *unique_name;
1247 bool is_monitor = false;
1248 int r;
1249
1250 r = acquire_bus(true, &bus);
1251 if (r < 0)
1252 return r;
1253
1254 usec_t end = arg_timeout > 0 ?
1255 usec_add(now(CLOCK_MONOTONIC), arg_timeout) : USEC_INFINITY;
1256
1257 /* upgrade connection; it's not used for anything else after this call */
1258 r = sd_bus_message_new_method_call(bus,
1259 &message,
1260 "org.freedesktop.DBus",
1261 "/org/freedesktop/DBus",
1262 "org.freedesktop.DBus.Monitoring",
1263 "BecomeMonitor");
1264 if (r < 0)
1265 return bus_log_create_error(r);
1266
1267 r = sd_bus_message_open_container(message, 'a', "s");
1268 if (r < 0)
1269 return bus_log_create_error(r);
1270
1271 STRV_FOREACH(i, argv+1) {
1272 _cleanup_free_ char *m = NULL;
1273
1274 if (!sd_bus_service_name_is_valid(*i))
1275 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid service name '%s'", *i);
1276
1277 m = strjoin("sender='", *i, "'");
1278 if (!m)
1279 return log_oom();
1280
1281 r = sd_bus_message_append_basic(message, 's', m);
1282 if (r < 0)
1283 return bus_log_create_error(r);
1284
1285 free(m);
1286 m = strjoin("destination='", *i, "'");
1287 if (!m)
1288 return log_oom();
1289
1290 r = sd_bus_message_append_basic(message, 's', m);
1291 if (r < 0)
1292 return bus_log_create_error(r);
1293 }
1294
1295 STRV_FOREACH(i, arg_matches) {
1296 r = sd_bus_message_append_basic(message, 's', *i);
1297 if (r < 0)
1298 return bus_log_create_error(r);
1299 }
1300
1301 r = sd_bus_message_close_container(message);
1302 if (r < 0)
1303 return bus_log_create_error(r);
1304
1305 r = sd_bus_message_append_basic(message, 'u', &flags);
1306 if (r < 0)
1307 return bus_log_create_error(r);
1308
1309 r = sd_bus_call(bus, message, arg_timeout, &error, NULL);
1310 if (r < 0) {
1311 notify_bus_error(&error);
1312 return log_error_errno(r, "Call to org.freedesktop.DBus.Monitoring.BecomeMonitor failed: %s",
1313 bus_error_message(&error, r));
1314 }
1315
1316 r = sd_bus_get_unique_name(bus, &unique_name);
1317 if (r < 0)
1318 return log_error_errno(r, "Failed to get unique name: %m");
1319
1320 if (!arg_quiet && !sd_json_format_enabled(arg_json_format_flags))
1321 log_info("Monitoring bus message stream.");
1322
1323 (void) sd_notify(/* unset_environment=false */ false, "READY=1");
1324
1325 for (;;) {
1326 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
1327
1328 r = sd_bus_process(bus, &m);
1329 if (r < 0)
1330 return log_error_errno(r, "Failed to process bus: %m");
1331
1332 if (m) {
1333 if (!is_monitor) {
1334 const char *name;
1335
1336 /* wait until we lose our unique name */
1337 if (sd_bus_message_is_signal(m, "org.freedesktop.DBus", "NameLost") <= 0)
1338 continue;
1339
1340 r = sd_bus_message_read(m, "s", &name);
1341 if (r < 0)
1342 return bus_log_parse_error(r);
1343
1344 if (streq(name, unique_name))
1345 is_monitor = true;
1346
1347 continue;
1348 }
1349
1350 dump(m, stdout);
1351 fflush(stdout);
1352
1353 if (arg_limit_messages != UINT64_MAX) {
1354 arg_limit_messages--;
1355
1356 if (arg_limit_messages == 0) {
1357 if (!arg_quiet && !sd_json_format_enabled(arg_json_format_flags))
1358 log_info("Received requested maximum number of messages, exiting.");
1359 return 0;
1360 }
1361 }
1362
1363 if (sd_bus_message_is_signal(m, "org.freedesktop.DBus.Local", "Disconnected") > 0) {
1364 if (!arg_quiet && !sd_json_format_enabled(arg_json_format_flags))
1365 log_info("Connection terminated, exiting.");
1366 return 0;
1367 }
1368
1369 continue;
1370 }
1371
1372 if (r > 0)
1373 continue;
1374
1375 r = sd_bus_wait(bus, arg_timeout > 0 ? usec_sub_unsigned(end, now(CLOCK_MONOTONIC)) : UINT64_MAX);
1376 if (r == 0 && arg_timeout > 0 && now(CLOCK_MONOTONIC) >= end) {
1377 if (!arg_quiet && !sd_json_format_enabled(arg_json_format_flags))
1378 log_info("Timed out waiting for messages, exiting.");
1379 return 0;
1380 }
1381 if (r < 0)
1382 return log_error_errno(r, "Failed to wait for bus: %m");
1383 }
1384 }
1385
1386 VERB(verb_monitor, "monitor", "[SERVICE…]", VERB_ANY, VERB_ANY, 0,
1387 "Show bus traffic");
1388 static int verb_monitor(int argc, char *argv[], uintptr_t _data, void *userdata) {
1389 return monitor(argc, argv, sd_json_format_enabled(arg_json_format_flags) ? message_json : message_dump);
1390 }
1391
1392 VERB(verb_capture, "capture", "[SERVICE…]", VERB_ANY, VERB_ANY, 0,
1393 "Capture bus traffic as pcap");
1394 static int verb_capture(int argc, char *argv[], uintptr_t _data, void *userdata) {
1395 _cleanup_free_ char *osname = NULL;
1396 static const char info[] =
1397 "busctl (systemd) " PROJECT_VERSION_FULL " (Git " GIT_VERSION ")";
1398 int r;
1399
1400 if (isatty_safe(STDOUT_FILENO))
1401 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1402 "Refusing to write message data to console, please redirect output to a file.");
1403
1404 r = parse_os_release(NULL, "PRETTY_NAME", &osname);
1405 if (r < 0)
1406 log_full_errno(r == -ENOENT ? LOG_DEBUG : LOG_INFO, r,
1407 "Failed to read os-release file, ignoring: %m");
1408 bus_pcap_header(arg_snaplen, osname, info, stdout);
1409
1410 r = monitor(argc, argv, message_pcap);
1411 if (r < 0)
1412 return r;
1413
1414 r = fflush_and_check(stdout);
1415 if (r < 0)
1416 return log_error_errno(r, "Couldn't write capture file: %m");
1417
1418 return r;
1419 }
1420
1421 VERB(verb_status, "status", "[SERVICE]", VERB_ANY, 2, 0,
1422 "Show bus service, process, or bus owner credentials");
1423 static int verb_status(int argc, char *argv[], uintptr_t _data, void *userdata) {
1424 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
1425 _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
1426 pid_t pid;
1427 int r;
1428
1429 r = acquire_bus(false, &bus);
1430 if (r < 0)
1431 return r;
1432
1433 pager_open(arg_pager_flags);
1434
1435 if (!isempty(argv[1])) {
1436 r = parse_pid(argv[1], &pid);
1437 if (r < 0)
1438 r = sd_bus_get_name_creds(
1439 bus,
1440 argv[1],
1441 (arg_augment_creds ? SD_BUS_CREDS_AUGMENT : 0) | _SD_BUS_CREDS_ALL,
1442 &creds);
1443 else
1444 r = sd_bus_creds_new_from_pid(
1445 &creds,
1446 pid,
1447 _SD_BUS_CREDS_ALL);
1448 } else {
1449 const char *scope, *address;
1450 sd_id128_t bus_id;
1451
1452 r = sd_bus_get_address(bus, &address);
1453 if (r >= 0)
1454 printf("BusAddress=%s%s%s\n", ansi_highlight(), address, ansi_normal());
1455
1456 r = sd_bus_get_scope(bus, &scope);
1457 if (r >= 0)
1458 printf("BusScope=%s%s%s\n", ansi_highlight(), scope, ansi_normal());
1459
1460 r = sd_bus_get_bus_id(bus, &bus_id);
1461 if (r >= 0)
1462 printf("BusID=%s" SD_ID128_FORMAT_STR "%s\n",
1463 ansi_highlight(), SD_ID128_FORMAT_VAL(bus_id), ansi_normal());
1464
1465 r = sd_bus_get_owner_creds(
1466 bus,
1467 (arg_augment_creds ? SD_BUS_CREDS_AUGMENT : 0) | _SD_BUS_CREDS_ALL,
1468 &creds);
1469 }
1470
1471 if (r < 0)
1472 return log_error_errno(r, "Failed to get credentials: %m");
1473
1474 bus_creds_dump(creds, NULL, false);
1475 return 0;
1476 }
1477
1478 static int message_append_cmdline(sd_bus_message *m, const char *signature, FDSet **passed_fdset, char ***x) {
1479 char **p;
1480 int r;
1481
1482 assert(m);
1483 assert(signature);
1484 assert(passed_fdset);
1485 assert(x);
1486
1487 p = *x;
1488
1489 for (;;) {
1490 const char *v;
1491 char t;
1492
1493 t = *signature;
1494 v = *p;
1495
1496 if (t == 0)
1497 break;
1498 if (!v)
1499 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1500 "Too few parameters for signature.");
1501
1502 signature++;
1503 p++;
1504
1505 switch (t) {
1506
1507 case SD_BUS_TYPE_BOOLEAN:
1508
1509 r = parse_boolean(v);
1510 if (r < 0)
1511 return log_error_errno(r, "Failed to parse '%s' as boolean: %m", v);
1512
1513 r = sd_bus_message_append_basic(m, t, &r);
1514 break;
1515
1516 case SD_BUS_TYPE_BYTE: {
1517 uint8_t z;
1518
1519 r = safe_atou8(v, &z);
1520 if (r < 0)
1521 return log_error_errno(r, "Failed to parse '%s' as byte (unsigned 8-bit integer): %m", v);
1522
1523 r = sd_bus_message_append_basic(m, t, &z);
1524 break;
1525 }
1526
1527 case SD_BUS_TYPE_INT16: {
1528 int16_t z;
1529
1530 r = safe_atoi16(v, &z);
1531 if (r < 0)
1532 return log_error_errno(r, "Failed to parse '%s' as signed 16-bit integer: %m", v);
1533
1534 r = sd_bus_message_append_basic(m, t, &z);
1535 break;
1536 }
1537
1538 case SD_BUS_TYPE_UINT16: {
1539 uint16_t z;
1540
1541 r = safe_atou16(v, &z);
1542 if (r < 0)
1543 return log_error_errno(r, "Failed to parse '%s' as unsigned 16-bit integer: %m", v);
1544
1545 r = sd_bus_message_append_basic(m, t, &z);
1546 break;
1547 }
1548
1549 case SD_BUS_TYPE_INT32: {
1550 int32_t z;
1551
1552 r = safe_atoi32(v, &z);
1553 if (r < 0)
1554 return log_error_errno(r, "Failed to parse '%s' as signed 32-bit integer: %m", v);
1555
1556 r = sd_bus_message_append_basic(m, t, &z);
1557 break;
1558 }
1559
1560 case SD_BUS_TYPE_UINT32: {
1561 uint32_t z;
1562
1563 r = safe_atou32(v, &z);
1564 if (r < 0)
1565 return log_error_errno(r, "Failed to parse '%s' as unsigned 32-bit integer: %m", v);
1566
1567 r = sd_bus_message_append_basic(m, t, &z);
1568 break;
1569 }
1570
1571 case SD_BUS_TYPE_INT64: {
1572 int64_t z;
1573
1574 r = safe_atoi64(v, &z);
1575 if (r < 0)
1576 return log_error_errno(r, "Failed to parse '%s' as signed 64-bit integer: %m", v);
1577
1578 r = sd_bus_message_append_basic(m, t, &z);
1579 break;
1580 }
1581
1582 case SD_BUS_TYPE_UINT64: {
1583 uint64_t z;
1584
1585 r = safe_atou64(v, &z);
1586 if (r < 0)
1587 return log_error_errno(r, "Failed to parse '%s' as unsigned 64-bit integer: %m", v);
1588
1589 r = sd_bus_message_append_basic(m, t, &z);
1590 break;
1591 }
1592
1593 case SD_BUS_TYPE_DOUBLE: {
1594 double z;
1595
1596 r = safe_atod(v, &z);
1597 if (r < 0)
1598 return log_error_errno(r, "Failed to parse '%s' as double precision floating point: %m", v);
1599
1600 r = sd_bus_message_append_basic(m, t, &z);
1601 break;
1602 }
1603
1604 case SD_BUS_TYPE_STRING:
1605 case SD_BUS_TYPE_OBJECT_PATH:
1606 case SD_BUS_TYPE_SIGNATURE:
1607
1608 r = sd_bus_message_append_basic(m, t, v);
1609 break;
1610
1611 case SD_BUS_TYPE_ARRAY: {
1612 uint32_t n;
1613 size_t k;
1614
1615 r = safe_atou32(v, &n);
1616 if (r < 0)
1617 return log_error_errno(r, "Failed to parse '%s' number of array entries: %m", v);
1618
1619 r = signature_element_length(signature, &k);
1620 if (r < 0)
1621 return log_error_errno(r, "Invalid array signature: %m");
1622
1623 {
1624 char s[k + 1];
1625 memcpy(s, signature, k);
1626 s[k] = 0;
1627
1628 r = sd_bus_message_open_container(m, SD_BUS_TYPE_ARRAY, s);
1629 if (r < 0)
1630 return bus_log_create_error(r);
1631
1632 for (unsigned i = 0; i < n; i++) {
1633 r = message_append_cmdline(m, s, passed_fdset, &p);
1634 if (r < 0)
1635 return r;
1636 }
1637 }
1638
1639 signature += k;
1640
1641 r = sd_bus_message_close_container(m);
1642 break;
1643 }
1644
1645 case SD_BUS_TYPE_VARIANT:
1646 r = sd_bus_message_open_container(m, SD_BUS_TYPE_VARIANT, v);
1647 if (r < 0)
1648 return bus_log_create_error(r);
1649
1650 r = message_append_cmdline(m, v, passed_fdset, &p);
1651 if (r < 0)
1652 return r;
1653
1654 r = sd_bus_message_close_container(m);
1655 break;
1656
1657 case SD_BUS_TYPE_STRUCT_BEGIN:
1658 case SD_BUS_TYPE_DICT_ENTRY_BEGIN: {
1659 size_t k;
1660
1661 signature--;
1662 p--;
1663
1664 r = signature_element_length(signature, &k);
1665 if (r < 0 || k < 2) {
1666 if (r >= 0 && k < 2)
1667 r = -ERANGE;
1668 return log_error_errno(r, "Invalid struct/dict entry signature: %m");
1669 }
1670
1671 {
1672 char s[k-1];
1673 memcpy(s, signature + 1, k - 2);
1674 s[k - 2] = 0;
1675
1676 const char ctype = t == SD_BUS_TYPE_STRUCT_BEGIN ?
1677 SD_BUS_TYPE_STRUCT : SD_BUS_TYPE_DICT_ENTRY;
1678 r = sd_bus_message_open_container(m, ctype, s);
1679 if (r < 0)
1680 return bus_log_create_error(r);
1681
1682 r = message_append_cmdline(m, s, passed_fdset, &p);
1683 if (r < 0)
1684 return r;
1685 }
1686
1687 signature += k;
1688
1689 r = sd_bus_message_close_container(m);
1690 break;
1691 }
1692
1693 case SD_BUS_TYPE_UNIX_FD: {
1694 int fd;
1695
1696 fd = parse_fd(v);
1697 if (fd < 0)
1698 return log_error_errno(fd, "Failed to parse '%s' as a file descriptor: %m", v);
1699
1700 if (!*passed_fdset) {
1701 r = fdset_new_fill(/* filter_cloexec= */ 0, passed_fdset);
1702 if (r < 0)
1703 return log_error_errno(r, "Failed to create fd set: %m");
1704 }
1705
1706 if (!fdset_contains(*passed_fdset, fd))
1707 return log_error_errno(SYNTHETIC_ERRNO(EBADF), "Failed to find file descriptor '%s' among passed file descriptors.", v);
1708
1709 r = sd_bus_message_append_basic(m, t, &fd);
1710 break;
1711 }
1712
1713 default:
1714 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1715 "Unknown signature type %c.", t);
1716 }
1717
1718 if (r < 0)
1719 return bus_log_create_error(r);
1720 }
1721
1722 *x = p;
1723 return 0;
1724 }
1725
1726 static int bus_message_dump(sd_bus_message *m, uint64_t flags) {
1727 const char *contents;
1728 int r;
1729
1730 assert(m);
1731
1732 r = sd_bus_message_rewind(m, !FLAGS_SET(flags, SD_BUS_MESSAGE_DUMP_SUBTREE_ONLY));
1733 if (r < 0)
1734 return log_error_errno(r, "Failed to rewind: %m");
1735
1736 if (FLAGS_SET(flags, SD_BUS_MESSAGE_DUMP_SUBTREE_ONLY)) {
1737 r = sd_bus_message_peek_type(m, /* ret_type= */ NULL, &contents);
1738 if (r < 0)
1739 return bus_log_parse_error(r);
1740
1741 r = sd_bus_message_enter_container(m, 'v', contents);
1742 if (r < 0)
1743 return bus_log_parse_error(r);
1744 } else {
1745 r = sd_bus_message_is_empty(m);
1746 if (r < 0)
1747 return bus_log_parse_error(r);
1748 if (r > 0 || arg_quiet)
1749 return 0;
1750 }
1751
1752 if (sd_json_format_enabled(arg_json_format_flags)) {
1753 _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
1754
1755 if (arg_json_format_flags & (SD_JSON_FORMAT_PRETTY|SD_JSON_FORMAT_PRETTY_AUTO))
1756 pager_open(arg_pager_flags);
1757
1758 r = sd_bus_message_dump_json(m, flags, &v);
1759 if (r < 0)
1760 return log_error_errno(r, "Failed to dump DBus message to JSON object: %m");
1761
1762 r = sd_json_variant_dump(v, arg_json_format_flags, NULL, NULL);
1763 if (r < 0)
1764 return log_error_errno(r, "Failed to dump JSON object: %m");
1765
1766 } else if (arg_verbose) {
1767 pager_open(arg_pager_flags);
1768
1769 r = sd_bus_message_dump(m, NULL, flags);
1770 if (r < 0)
1771 return log_error_errno(r, "Failed to dump DBus message: %m");
1772 } else {
1773
1774 fputs(FLAGS_SET(flags, SD_BUS_MESSAGE_DUMP_SUBTREE_ONLY) ? contents : sd_bus_message_get_signature(m, true), stdout);
1775 fputc(' ', stdout);
1776
1777 r = format_cmdline(m, stdout, /* needs_space= */ false);
1778 if (r < 0)
1779 return bus_log_parse_error(r);
1780
1781 fputc('\n', stdout);
1782 }
1783
1784 if (FLAGS_SET(flags, SD_BUS_MESSAGE_DUMP_SUBTREE_ONLY)) {
1785 r = sd_bus_message_exit_container(m);
1786 if (r < 0)
1787 return bus_log_parse_error(r);
1788 }
1789
1790 return 0;
1791 }
1792
1793 VERB(verb_call, "call", "SERVICE OBJECT INTERFACE METHOD [SIGNATURE [ARGUMENT…]]", 5, VERB_ANY, 0,
1794 "Call a method");
1795 static int verb_call(int argc, char *argv[], uintptr_t _data, void *userdata) {
1796 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
1797 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1798 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL, *reply = NULL;
1799 _cleanup_fdset_free_ FDSet *passed_fdset = NULL;
1800 int r;
1801
1802 r = acquire_bus(false, &bus);
1803 if (r < 0)
1804 return r;
1805
1806 if (!service_name_is_valid(argv[1]))
1807 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid service name: %s", argv[1]);
1808 if (!object_path_is_valid(argv[2]))
1809 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid object path: %s", argv[2]);
1810 if (!interface_name_is_valid(argv[3]))
1811 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid interface name: %s", argv[3]);
1812 if (!member_name_is_valid(argv[4]))
1813 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid member name: %s", argv[4]);
1814
1815 r = sd_bus_message_new_method_call(bus, &m, argv[1], argv[2], argv[3], argv[4]);
1816 if (r < 0)
1817 return bus_log_create_error(r);
1818
1819 r = sd_bus_message_set_expect_reply(m, arg_expect_reply);
1820 if (r < 0)
1821 return bus_log_create_error(r);
1822
1823 r = sd_bus_message_set_auto_start(m, arg_auto_start);
1824 if (r < 0)
1825 return bus_log_create_error(r);
1826
1827 r = sd_bus_message_set_allow_interactive_authorization(m, arg_allow_interactive_authorization);
1828 if (r < 0)
1829 return bus_log_create_error(r);
1830
1831 if (!isempty(argv[5])) {
1832 char **p;
1833
1834 p = argv+6;
1835
1836 r = message_append_cmdline(m, argv[5], &passed_fdset, &p);
1837 if (r < 0)
1838 return r;
1839
1840 if (*p)
1841 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1842 "Too many parameters for signature.");
1843 }
1844
1845 if (!arg_expect_reply) {
1846 r = sd_bus_send(bus, m, NULL);
1847 if (r < 0)
1848 return log_error_errno(r, "Failed to send message: %m");
1849
1850 return 0;
1851 }
1852
1853 r = sd_bus_call(bus, m, arg_timeout, &error, &reply);
1854 if (r < 0) {
1855 notify_bus_error(&error);
1856 return log_error_errno(r, "Call failed: %s", bus_error_message(&error, r));
1857 }
1858
1859 return bus_message_dump(reply, /* flags= */ 0);
1860 }
1861
1862 VERB(verb_emit, "emit", "OBJECT INTERFACE SIGNAL [SIGNATURE [ARGUMENT…]]", 4, VERB_ANY, 0,
1863 "Emit a signal");
1864 static int verb_emit(int argc, char *argv[], uintptr_t _data, void *userdata) {
1865 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
1866 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
1867 _cleanup_fdset_free_ FDSet *passed_fdset = NULL;
1868 int r;
1869
1870 r = acquire_bus(false, &bus);
1871 if (r < 0)
1872 return r;
1873
1874 r = sd_bus_message_new_signal(bus, &m, argv[1], argv[2], argv[3]);
1875 if (r < 0)
1876 return bus_log_create_error(r);
1877
1878 if (arg_destination) {
1879 r = sd_bus_message_set_destination(m, arg_destination);
1880 if (r < 0)
1881 return bus_log_create_error(r);
1882 }
1883
1884 r = sd_bus_message_set_auto_start(m, arg_auto_start);
1885 if (r < 0)
1886 return bus_log_create_error(r);
1887
1888 if (!isempty(argv[4])) {
1889 char **p;
1890
1891 p = argv+5;
1892
1893 r = message_append_cmdline(m, argv[4], &passed_fdset, &p);
1894 if (r < 0)
1895 return r;
1896
1897 if (*p)
1898 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1899 "Too many parameters for signature.");
1900 }
1901
1902 r = sd_bus_send(bus, m, NULL);
1903 if (r < 0)
1904 return log_error_errno(r, "Failed to send signal: %m");
1905
1906 return 0;
1907 }
1908
1909 VERB(verb_get_property, "get-property", "SERVICE OBJECT INTERFACE PROPERTY…", 5, VERB_ANY, 0,
1910 "Get property value");
1911 static int verb_get_property(int argc, char *argv[], uintptr_t _data, void *userdata) {
1912 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
1913 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1914 int r;
1915
1916 if (!service_name_is_valid(argv[1]))
1917 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid service name: %s", argv[1]);
1918 if (!object_path_is_valid(argv[2]))
1919 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid object path: %s", argv[2]);
1920 if (!interface_name_is_valid(argv[3]))
1921 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid interface name: %s", argv[3]);
1922
1923 r = acquire_bus(false, &bus);
1924 if (r < 0)
1925 return r;
1926
1927 STRV_FOREACH(i, argv + 4) {
1928 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
1929
1930 r = sd_bus_call_method(bus, argv[1], argv[2],
1931 "org.freedesktop.DBus.Properties", "Get",
1932 &error, &reply, "ss", argv[3], *i);
1933 if (r < 0) {
1934 notify_bus_error(&error);
1935 return log_error_errno(r, "Failed to get property %s on interface %s: %s",
1936 *i, argv[3],
1937 bus_error_message(&error, r));
1938 }
1939
1940 r = bus_message_dump(reply, SD_BUS_MESSAGE_DUMP_SUBTREE_ONLY);
1941 if (r < 0)
1942 return r;
1943 }
1944
1945 return 0;
1946 }
1947
1948 static int on_bus_signal(sd_bus_message *msg, void *userdata, sd_bus_error *ret_error) {
1949 int r;
1950
1951 r = bus_message_dump(msg, /* flags= */ 0);
1952 if (r < 0)
1953 return sd_event_exit(sd_bus_get_event(sd_bus_message_get_bus(ASSERT_PTR(msg))), r);
1954
1955 if (arg_limit_signals != UINT64_MAX) {
1956 arg_limit_signals--;
1957
1958 if (arg_limit_signals == 0) {
1959 if (!arg_quiet && !sd_json_format_enabled(arg_json_format_flags))
1960 log_info("Received requested maximum number of signals, exiting.");
1961
1962 return sd_event_exit(sd_bus_get_event(sd_bus_message_get_bus(ASSERT_PTR(msg))), 0);
1963 }
1964 }
1965
1966 return 0;
1967 }
1968
1969 VERB(verb_wait, "wait", "[SERVICE] OBJECT INTERFACE SIGNAL", 4, 5, 0,
1970 "Wait for a signal");
1971 static int verb_wait(int argc, char *argv[], uintptr_t _data, void *userdata) {
1972 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
1973 _cleanup_(sd_event_unrefp) sd_event *e = NULL;
1974 _cleanup_(sd_event_source_unrefp) sd_event_source *timer = NULL;
1975 int argn = 1, r;
1976
1977 const char *sender = argc == 5 ? argv[argn++] : NULL;
1978 const char *path = argv[argn++];
1979 const char *interface = argv[argn++];
1980 const char *member = argv[argn++];
1981
1982 if (sender && !service_name_is_valid(sender))
1983 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid service name: %s", sender);
1984 if (!object_path_is_valid(path))
1985 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid object path: %s", path);
1986 if (!interface_name_is_valid(interface))
1987 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid interface name: %s", interface);
1988 if (!member_name_is_valid(member))
1989 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid member name: %s", member);
1990
1991 r = acquire_bus(/* set_monitor= */ false, &bus);
1992 if (r < 0)
1993 return r;
1994
1995 r = sd_bus_match_signal(bus, NULL, sender, path, interface, member, on_bus_signal, NULL);
1996 if (r < 0)
1997 return log_error_errno(r, "Failed to match signal %s on interface %s: %m", member, interface);
1998
1999 r = sd_event_new(&e);
2000 if (r < 0)
2001 return log_error_errno(r, "Failed to allocate event loop: %m\n");
2002
2003 r = sd_bus_attach_event(bus, e, SD_EVENT_PRIORITY_NORMAL);
2004 if (r < 0)
2005 return log_error_errno(r, "Failed to attach bus event: %m\n");
2006
2007 if (arg_timeout) {
2008 r = sd_event_add_time_relative(e, &timer, CLOCK_MONOTONIC, arg_timeout, 0, NULL, NULL);
2009 if (r < 0)
2010 return log_error_errno(r, "Failed to schedule timeout: %m\n");
2011 }
2012
2013 /* The match is installed and we're ready to observe the signal */
2014 sd_notify(/* unset_environment= */ false, "READY=1");
2015
2016 return sd_event_loop(e);
2017 }
2018
2019 VERB(verb_set_property, "set-property", "SERVICE OBJECT INTERFACE PROPERTY SIGNATURE ARGUMENT…", 6, VERB_ANY, 0,
2020 "Set property value");
2021 static int verb_set_property(int argc, char *argv[], uintptr_t _data, void *userdata) {
2022 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
2023 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
2024 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
2025 _cleanup_fdset_free_ FDSet *passed_fdset = NULL;
2026 char **p;
2027 int r;
2028
2029 if (!service_name_is_valid(argv[1]))
2030 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid service name: %s", argv[1]);
2031 if (!object_path_is_valid(argv[2]))
2032 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid object path: %s", argv[2]);
2033 if (!interface_name_is_valid(argv[3]))
2034 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid interface name: %s", argv[3]);
2035
2036 r = acquire_bus(false, &bus);
2037 if (r < 0)
2038 return r;
2039
2040 r = sd_bus_message_new_method_call(bus, &m, argv[1], argv[2],
2041 "org.freedesktop.DBus.Properties", "Set");
2042 if (r < 0)
2043 return bus_log_create_error(r);
2044
2045 r = sd_bus_message_append(m, "ss", argv[3], argv[4]);
2046 if (r < 0)
2047 return bus_log_create_error(r);
2048
2049 r = sd_bus_message_open_container(m, 'v', argv[5]);
2050 if (r < 0)
2051 return bus_log_create_error(r);
2052
2053 p = argv + 6;
2054 r = message_append_cmdline(m, argv[5], &passed_fdset, &p);
2055 if (r < 0)
2056 return r;
2057
2058 r = sd_bus_message_close_container(m);
2059 if (r < 0)
2060 return bus_log_create_error(r);
2061
2062 if (*p)
2063 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Too many parameters for signature.");
2064
2065 r = sd_bus_call(bus, m, arg_timeout, &error, NULL);
2066 if (r < 0) {
2067 notify_bus_error(&error);
2068 return log_error_errno(r, "Failed to set property %s on interface %s: %s",
2069 argv[4], argv[3],
2070 bus_error_message(&error, r));
2071 }
2072
2073 return 0;
2074 }
2075
2076 static int help(void) {
2077 _cleanup_(table_unrefp) Table *options = NULL, *verbs = NULL;
2078 int r;
2079
2080 pager_open(arg_pager_flags);
2081
2082 r = verbs_get_help_table(&verbs);
2083 if (r < 0)
2084 return r;
2085
2086 r = option_parser_get_help_table(&options);
2087 if (r < 0)
2088 return r;
2089
2090 /* Note: column widths are not synced, because the verbs table is very wide. */
2091
2092 help_cmdline("[OPTIONS…] COMMAND …");
2093 help_abstract("Introspect the D-Bus IPC bus.");
2094
2095 help_section("Commands");
2096 r = table_print_or_warn(verbs);
2097 if (r < 0)
2098 return r;
2099
2100 help_section("Options");
2101 r = table_print_or_warn(options);
2102 if (r < 0)
2103 return r;
2104
2105 help_man_page_reference("busctl", "1");
2106
2107 return 0;
2108 }
2109
2110 VERB_COMMON_HELP(help);
2111
2112 static int parse_argv(int argc, char *argv[], char ***remaining_args) {
2113 assert(argc >= 0);
2114 assert(argv);
2115 assert(remaining_args);
2116
2117 OptionParser opts = { argc, argv };
2118 int r;
2119
2120 FOREACH_OPTION_OR_RETURN(c, &opts)
2121 switch (c) {
2122
2123 OPTION_COMMON_HELP:
2124 return help();
2125
2126 OPTION_COMMON_VERSION:
2127 return version();
2128
2129 OPTION_COMMON_NO_PAGER:
2130 arg_pager_flags |= PAGER_DISABLE;
2131 break;
2132
2133 OPTION_COMMON_NO_LEGEND:
2134 arg_legend = false;
2135 break;
2136
2137 OPTION('l', "full", NULL, "Do not ellipsize output"):
2138 arg_full = true;
2139 break;
2140
2141 OPTION_LONG("system", NULL, "Connect to system bus"):
2142 arg_runtime_scope = RUNTIME_SCOPE_SYSTEM;
2143 break;
2144
2145 OPTION_LONG("user", NULL, "Connect to user bus"):
2146 arg_runtime_scope = RUNTIME_SCOPE_USER;
2147 break;
2148
2149 OPTION_COMMON_HOST:
2150 arg_transport = BUS_TRANSPORT_REMOTE;
2151 arg_host = opts.arg;
2152 break;
2153
2154 OPTION_COMMON_MACHINE:
2155 r = parse_machine_argument(opts.arg, &arg_host, &arg_transport);
2156 if (r < 0)
2157 return r;
2158 break;
2159
2160 OPTION('C', "capsule", "NAME", "Operate on capsule"):
2161 r = capsule_name_is_valid(opts.arg);
2162 if (r < 0)
2163 return log_error_errno(r, "Unable to validate capsule name '%s': %m", opts.arg);
2164 if (r == 0)
2165 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid capsule name: %s", opts.arg);
2166
2167 arg_host = opts.arg;
2168 arg_transport = BUS_TRANSPORT_CAPSULE;
2169 break;
2170
2171 OPTION_LONG("address", "ADDRESS", "Connect to bus specified by address"):
2172 arg_address = opts.arg;
2173 break;
2174
2175 OPTION_LONG("show-machine", NULL, "Show machine ID column in list"):
2176 arg_show_machine = true;
2177 break;
2178
2179 OPTION_LONG("unique", NULL, "Only show unique names"):
2180 arg_unique = true;
2181 break;
2182
2183 OPTION_LONG("acquired", NULL, "Only show acquired names"):
2184 arg_acquired = true;
2185 break;
2186
2187 OPTION_LONG("activatable", NULL, "Only show activatable names"):
2188 arg_activatable = true;
2189 break;
2190
2191 OPTION_LONG("match", "MATCH", "Only show matching messages"):
2192 if (strv_extend(&arg_matches, opts.arg) < 0)
2193 return log_oom();
2194 break;
2195
2196 OPTION_LONG("size", "SIZE", "Maximum length of captured packet"): {
2197 uint64_t sz;
2198
2199 r = parse_size(opts.arg, 1024, &sz);
2200 if (r < 0)
2201 return log_error_errno(r, "Failed to parse size '%s': %m", opts.arg);
2202
2203 if ((uint64_t) (size_t) sz != sz)
2204 return log_error_errno(SYNTHETIC_ERRNO(E2BIG),
2205 "Size out of range.");
2206
2207 arg_snaplen = (size_t) sz;
2208 break;
2209 }
2210
2211 OPTION_LONG("list", NULL, "Don't show tree, but simple object path list"):
2212 arg_list = true;
2213 break;
2214
2215 OPTION('q', "quiet", NULL, "Don't show method call reply"):
2216 arg_quiet = true;
2217 break;
2218
2219 OPTION_LONG("verbose", NULL, "Show result values in long format"):
2220 arg_verbose = true;
2221 break;
2222
2223 OPTION_COMMON_JSON:
2224 r = parse_json_argument(opts.arg, &arg_json_format_flags);
2225 if (r <= 0)
2226 return r;
2227 break;
2228
2229 OPTION_COMMON_LOWERCASE_J:
2230 arg_json_format_flags = SD_JSON_FORMAT_PRETTY_AUTO|SD_JSON_FORMAT_COLOR_AUTO;
2231 break;
2232
2233 OPTION_LONG("xml-interface", NULL, "Dump the XML description in introspect command"):
2234 arg_xml_interface = true;
2235 break;
2236
2237 OPTION_LONG("expect-reply", "BOOL", "Expect a method call reply"):
2238 r = parse_boolean_argument("--expect-reply=", opts.arg, &arg_expect_reply);
2239 if (r < 0)
2240 return r;
2241 break;
2242
2243 OPTION_LONG("auto-start", "BOOL", "Auto-start destination service"):
2244 r = parse_boolean_argument("--auto-start=", opts.arg, &arg_auto_start);
2245 if (r < 0)
2246 return r;
2247 break;
2248
2249 OPTION_LONG("allow-interactive-authorization", "",
2250 "Allow interactive authorization for operation"):
2251 r = parse_boolean_argument("--allow-interactive-authorization=", opts.arg,
2252 &arg_allow_interactive_authorization);
2253 if (r < 0)
2254 return r;
2255 break;
2256
2257 OPTION_LONG("timeout", "SECS", "Maximum time to wait for method call completion"):
2258 if (isempty(opts.arg)) {
2259 arg_timeout = 0; /* Reset to default */
2260 break;
2261 }
2262
2263 r = parse_sec(opts.arg, &arg_timeout);
2264 if (r < 0)
2265 return log_error_errno(r, "Failed to parse --timeout= parameter '%s': %m", opts.arg);
2266 break;
2267
2268 OPTION_LONG("augment-creds", "BOOL",
2269 "Extend credential data with data read from /proc/$PID"):
2270 r = parse_boolean_argument("--augment-creds=", opts.arg, &arg_augment_creds);
2271 if (r < 0)
2272 return r;
2273 break;
2274
2275 OPTION_LONG("watch-bind", "BOOL",
2276 "Wait for bus AF_UNIX socket to be bound in the file system"):
2277 r = parse_boolean_argument("--watch-bind=", opts.arg, &arg_watch_bind);
2278 if (r < 0)
2279 return r;
2280 break;
2281
2282 OPTION_LONG("destination", "SERVICE", "Destination service of a signal"):
2283 arg_destination = opts.arg;
2284 break;
2285
2286 OPTION('N', "limit-messages", "NUMBER",
2287 "Stop monitoring after receiving the specified number of messages"):
2288 if (isempty(opts.arg)) {
2289 /* Reset to default */
2290 arg_limit_messages = UINT64_MAX;
2291 arg_limit_signals = 1;
2292 break;
2293 }
2294
2295 if (streq(opts.arg, "infinity")) {
2296 arg_limit_signals = arg_limit_messages = UINT64_MAX;
2297 break;
2298 }
2299
2300 r = safe_atou64(opts.arg, &arg_limit_messages);
2301 if (r < 0)
2302 return log_error_errno(r, "Failed to parse --limit-messages= parameter: %s", opts.arg);
2303 if (arg_limit_messages == 0)
2304 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "--limit-messages= parameter cannot be 0");
2305
2306 arg_limit_signals = arg_limit_messages;
2307 break;
2308 }
2309
2310 if (arg_full < 0)
2311 arg_full = terminal_is_dumb();
2312
2313 *remaining_args = option_parser_get_args(&opts);
2314 return 1;
2315 }
2316
2317 static int run(int argc, char *argv[]) {
2318 int r;
2319
2320 log_setup();
2321
2322 char **args = NULL;
2323 r = parse_argv(argc, argv, &args);
2324 if (r <= 0)
2325 return r;
2326
2327 return dispatch_verb(args, NULL);
2328 }
2329
2330 DEFINE_MAIN_FUNCTION(run);