]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/libsystemd/sd-bus/busctl.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
sd-bus: rename sd_bus_get_owner_id() → sd_bus_get_bus_id()
[thirdparty/systemd.git] / src / libsystemd / sd-bus / busctl.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4 This file is part of systemd.
5
6 Copyright 2013 Lennart Poettering
7
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
12
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
17
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <getopt.h>
23
24 #include "strv.h"
25 #include "util.h"
26 #include "log.h"
27 #include "build.h"
28 #include "pager.h"
29 #include "xml.h"
30 #include "path-util.h"
31
32 #include "sd-bus.h"
33 #include "bus-message.h"
34 #include "bus-internal.h"
35 #include "bus-util.h"
36 #include "bus-dump.h"
37 #include "bus-signature.h"
38 #include "bus-type.h"
39 #include "busctl-introspect.h"
40
41 static bool arg_no_pager = false;
42 static bool arg_legend = true;
43 static char *arg_address = NULL;
44 static bool arg_unique = false;
45 static bool arg_acquired = false;
46 static bool arg_activatable = false;
47 static bool arg_show_machine = false;
48 static char **arg_matches = NULL;
49 static BusTransport arg_transport = BUS_TRANSPORT_LOCAL;
50 static char *arg_host = NULL;
51 static bool arg_user = false;
52 static size_t arg_snaplen = 4096;
53 static bool arg_list = false;
54 static bool arg_quiet = false;
55 static bool arg_verbose = false;
56 static bool arg_expect_reply = true;
57 static bool arg_auto_start = true;
58 static bool arg_allow_interactive_authorization = true;
59 static bool arg_augment_creds = true;
60 static usec_t arg_timeout = 0;
61
62 static void pager_open_if_enabled(void) {
63
64 /* Cache result before we open the pager */
65 if (arg_no_pager)
66 return;
67
68 pager_open(false);
69 }
70
71 #define NAME_IS_ACQUIRED INT_TO_PTR(1)
72 #define NAME_IS_ACTIVATABLE INT_TO_PTR(2)
73
74 static int list_bus_names(sd_bus *bus, char **argv) {
75 _cleanup_strv_free_ char **acquired = NULL, **activatable = NULL;
76 _cleanup_free_ char **merged = NULL;
77 _cleanup_hashmap_free_ Hashmap *names = NULL;
78 char **i;
79 int r;
80 size_t max_i = 0;
81 unsigned n = 0;
82 void *v;
83 char *k;
84 Iterator iterator;
85
86 assert(bus);
87
88 if (!arg_unique && !arg_acquired && !arg_activatable)
89 arg_unique = arg_acquired = arg_activatable = true;
90
91 r = sd_bus_list_names(bus, (arg_acquired || arg_unique) ? &acquired : NULL, arg_activatable ? &activatable : NULL);
92 if (r < 0)
93 return log_error_errno(r, "Failed to list names: %m");
94
95 pager_open_if_enabled();
96
97 names = hashmap_new(&string_hash_ops);
98 if (!names)
99 return log_oom();
100
101 STRV_FOREACH(i, acquired) {
102 max_i = MAX(max_i, strlen(*i));
103
104 r = hashmap_put(names, *i, NAME_IS_ACQUIRED);
105 if (r < 0)
106 return log_error_errno(r, "Failed to add to hashmap: %m");
107 }
108
109 STRV_FOREACH(i, activatable) {
110 max_i = MAX(max_i, strlen(*i));
111
112 r = hashmap_put(names, *i, NAME_IS_ACTIVATABLE);
113 if (r < 0 && r != -EEXIST)
114 return log_error_errno(r, "Failed to add to hashmap: %m");
115 }
116
117 merged = new(char*, hashmap_size(names) + 1);
118 HASHMAP_FOREACH_KEY(v, k, names, iterator)
119 merged[n++] = k;
120
121 merged[n] = NULL;
122 strv_sort(merged);
123
124 if (arg_legend) {
125 printf("%-*s %*s %-*s %-*s %-*s %-*s %-*s %-*s",
126 (int) max_i, "NAME", 10, "PID", 15, "PROCESS", 16, "USER", 13, "CONNECTION", 25, "UNIT", 10, "SESSION", 19, "DESCRIPTION");
127
128 if (arg_show_machine)
129 puts(" MACHINE");
130 else
131 putchar('\n');
132 }
133
134 STRV_FOREACH(i, merged) {
135 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
136 sd_id128_t mid;
137
138 if (hashmap_get(names, *i) == NAME_IS_ACTIVATABLE) {
139 /* Activatable */
140
141 printf("%-*s", (int) max_i, *i);
142 printf(" - - - (activatable) - - ");
143 if (arg_show_machine)
144 puts(" -");
145 else
146 putchar('\n');
147 continue;
148
149 }
150
151 if (!arg_unique && (*i)[0] == ':')
152 continue;
153
154 if (!arg_acquired && (*i)[0] != ':')
155 continue;
156
157 printf("%-*s", (int) max_i, *i);
158
159 r = sd_bus_get_name_creds(
160 bus, *i,
161 (arg_augment_creds ? SD_BUS_CREDS_AUGMENT : 0) |
162 SD_BUS_CREDS_UID|SD_BUS_CREDS_PID|SD_BUS_CREDS_COMM|
163 SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_UNIT|SD_BUS_CREDS_SESSION|
164 SD_BUS_CREDS_DESCRIPTION, &creds);
165 if (r >= 0) {
166 const char *unique, *session, *unit, *cn;
167 pid_t pid;
168 uid_t uid;
169
170 r = sd_bus_creds_get_pid(creds, &pid);
171 if (r >= 0) {
172 const char *comm = NULL;
173
174 sd_bus_creds_get_comm(creds, &comm);
175
176 printf(" %10lu %-15s", (unsigned long) pid, strna(comm));
177 } else
178 fputs(" - - ", stdout);
179
180 r = sd_bus_creds_get_uid(creds, &uid);
181 if (r >= 0) {
182 _cleanup_free_ char *u = NULL;
183
184 u = uid_to_name(uid);
185 if (!u)
186 return log_oom();
187
188 if (strlen(u) > 16)
189 u[16] = 0;
190
191 printf(" %-16s", u);
192 } else
193 fputs(" - ", stdout);
194
195 r = sd_bus_creds_get_unique_name(creds, &unique);
196 if (r >= 0)
197 printf(" %-13s", unique);
198 else
199 fputs(" - ", stdout);
200
201 r = sd_bus_creds_get_unit(creds, &unit);
202 if (r >= 0) {
203 _cleanup_free_ char *e;
204
205 e = ellipsize(unit, 25, 100);
206 if (!e)
207 return log_oom();
208
209 printf(" %-25s", e);
210 } else
211 fputs(" - ", stdout);
212
213 r = sd_bus_creds_get_session(creds, &session);
214 if (r >= 0)
215 printf(" %-10s", session);
216 else
217 fputs(" - ", stdout);
218
219 r = sd_bus_creds_get_description(creds, &cn);
220 if (r >= 0)
221 printf(" %-19s", cn);
222 else
223 fputs(" - ", stdout);
224
225 } else
226 printf(" - - - - - - - ");
227
228 if (arg_show_machine) {
229 r = sd_bus_get_name_machine_id(bus, *i, &mid);
230 if (r >= 0) {
231 char m[SD_ID128_STRING_MAX];
232 printf(" %s\n", sd_id128_to_string(mid, m));
233 } else
234 puts(" -");
235 } else
236 putchar('\n');
237 }
238
239 return 0;
240 }
241
242 static void print_subtree(const char *prefix, const char *path, char **l) {
243 const char *vertical, *space;
244 char **n;
245
246 /* We assume the list is sorted. Let's first skip over the
247 * entry we are looking at. */
248 for (;;) {
249 if (!*l)
250 return;
251
252 if (!streq(*l, path))
253 break;
254
255 l++;
256 }
257
258 vertical = strappenda(prefix, draw_special_char(DRAW_TREE_VERTICAL));
259 space = strappenda(prefix, draw_special_char(DRAW_TREE_SPACE));
260
261 for (;;) {
262 bool has_more = false;
263
264 if (!*l || !path_startswith(*l, path))
265 break;
266
267 n = l + 1;
268 for (;;) {
269 if (!*n || !path_startswith(*n, path))
270 break;
271
272 if (!path_startswith(*n, *l)) {
273 has_more = true;
274 break;
275 }
276
277 n++;
278 }
279
280 printf("%s%s%s\n", prefix, draw_special_char(has_more ? DRAW_TREE_BRANCH : DRAW_TREE_RIGHT), *l);
281
282 print_subtree(has_more ? vertical : space, *l, l);
283 l = n;
284 }
285 }
286
287 static void print_tree(const char *prefix, char **l) {
288
289 pager_open_if_enabled();
290
291 prefix = strempty(prefix);
292
293 if (arg_list) {
294 char **i;
295
296 STRV_FOREACH(i, l)
297 printf("%s%s\n", prefix, *i);
298 return;
299 }
300
301 if (strv_isempty(l)) {
302 printf("No objects discovered.\n");
303 return;
304 }
305
306 if (streq(l[0], "/") && !l[1]) {
307 printf("Only root object discovered.\n");
308 return;
309 }
310
311 print_subtree(prefix, "/", l);
312 }
313
314 static int on_path(const char *path, void *userdata) {
315 Set *paths = userdata;
316 int r;
317
318 assert(paths);
319
320 r = set_put_strdup(paths, path);
321 if (r < 0)
322 return log_oom();
323
324 return 0;
325 }
326
327 static int find_nodes(sd_bus *bus, const char *service, const char *path, Set *paths, bool many) {
328 static const XMLIntrospectOps ops = {
329 .on_path = on_path,
330 };
331
332 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
333 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
334 const char *xml;
335 int r;
336
337 r = sd_bus_call_method(bus, service, path, "org.freedesktop.DBus.Introspectable", "Introspect", &error, &reply, "");
338 if (r < 0) {
339 if (many)
340 printf("Failed to introspect object %s of service %s: %s\n", path, service, bus_error_message(&error, r));
341 else
342 log_error("Failed to introspect object %s of service %s: %s", path, service, bus_error_message(&error, r));
343 return r;
344 }
345
346 r = sd_bus_message_read(reply, "s", &xml);
347 if (r < 0)
348 return bus_log_parse_error(r);
349
350 return parse_xml_introspect(path, xml, &ops, paths);
351 }
352
353 static int tree_one(sd_bus *bus, const char *service, const char *prefix, bool many) {
354 _cleanup_set_free_free_ Set *paths = NULL, *done = NULL, *failed = NULL;
355 _cleanup_free_ char **l = NULL;
356 char *m;
357 int r;
358
359 paths = set_new(&string_hash_ops);
360 if (!paths)
361 return log_oom();
362
363 done = set_new(&string_hash_ops);
364 if (!done)
365 return log_oom();
366
367 failed = set_new(&string_hash_ops);
368 if (!failed)
369 return log_oom();
370
371 m = strdup("/");
372 if (!m)
373 return log_oom();
374
375 r = set_put(paths, m);
376 if (r < 0) {
377 free(m);
378 return log_oom();
379 }
380
381 for (;;) {
382 _cleanup_free_ char *p = NULL;
383 int q;
384
385 p = set_steal_first(paths);
386 if (!p)
387 break;
388
389 if (set_contains(done, p) ||
390 set_contains(failed, p))
391 continue;
392
393 q = find_nodes(bus, service, p, paths, many);
394 if (q < 0) {
395 if (r >= 0)
396 r = q;
397
398 q = set_put(failed, p);
399 } else
400 q = set_put(done, p);
401
402 if (q < 0)
403 return log_oom();
404
405 assert(q != 0);
406 p = NULL;
407 }
408
409 pager_open_if_enabled();
410
411 l = set_get_strv(done);
412 if (!l)
413 return log_oom();
414
415 strv_sort(l);
416 print_tree(prefix, l);
417
418 fflush(stdout);
419
420 return r;
421 }
422
423 static int tree(sd_bus *bus, char **argv) {
424 char **i;
425 int r = 0;
426
427 if (!arg_unique && !arg_acquired)
428 arg_acquired = true;
429
430 if (strv_length(argv) <= 1) {
431 _cleanup_strv_free_ char **names = NULL;
432 bool not_first = false;
433
434 r = sd_bus_list_names(bus, &names, NULL);
435 if (r < 0)
436 return log_error_errno(r, "Failed to get name list: %m");
437
438 pager_open_if_enabled();
439
440 STRV_FOREACH(i, names) {
441 int q;
442
443 if (!arg_unique && (*i)[0] == ':')
444 continue;
445
446 if (!arg_acquired && (*i)[0] == ':')
447 continue;
448
449 if (not_first)
450 printf("\n");
451
452 printf("Service %s%s%s:\n", ansi_highlight(), *i, ansi_highlight_off());
453
454 q = tree_one(bus, *i, NULL, true);
455 if (q < 0 && r >= 0)
456 r = q;
457
458 not_first = true;
459 }
460 } else {
461 STRV_FOREACH(i, argv+1) {
462 int q;
463
464 if (i > argv+1)
465 printf("\n");
466
467 if (argv[2]) {
468 pager_open_if_enabled();
469 printf("Service %s%s%s:\n", ansi_highlight(), *i, ansi_highlight_off());
470 }
471
472 q = tree_one(bus, *i, NULL, !!argv[2]);
473 if (q < 0 && r >= 0)
474 r = q;
475 }
476 }
477
478 return r;
479 }
480
481 static int format_cmdline(sd_bus_message *m, FILE *f, bool needs_space) {
482 int r;
483
484 for (;;) {
485 const char *contents = NULL;
486 char type;
487 union {
488 uint8_t u8;
489 uint16_t u16;
490 int16_t s16;
491 uint32_t u32;
492 int32_t s32;
493 uint64_t u64;
494 int64_t s64;
495 double d64;
496 const char *string;
497 int i;
498 } basic;
499
500 r = sd_bus_message_peek_type(m, &type, &contents);
501 if (r <= 0)
502 return r;
503
504 if (bus_type_is_container(type) > 0) {
505
506 r = sd_bus_message_enter_container(m, type, contents);
507 if (r < 0)
508 return r;
509
510 if (type == SD_BUS_TYPE_ARRAY) {
511 unsigned n = 0;
512
513 /* count array entries */
514 for (;;) {
515
516 r = sd_bus_message_skip(m, contents);
517 if (r < 0)
518 return r;
519 if (r == 0)
520 break;
521
522 n++;
523 }
524
525 r = sd_bus_message_rewind(m, false);
526 if (r < 0)
527 return r;
528
529 if (needs_space)
530 fputc(' ', f);
531
532 fprintf(f, "%u", n);
533 } else if (type == SD_BUS_TYPE_VARIANT) {
534
535 if (needs_space)
536 fputc(' ', f);
537
538 fprintf(f, "%s", contents);
539 }
540
541 r = format_cmdline(m, f, true);
542 if (r < 0)
543 return r;
544
545 r = sd_bus_message_exit_container(m);
546 if (r < 0)
547 return r;
548
549 continue;
550 }
551
552 r = sd_bus_message_read_basic(m, type, &basic);
553 if (r < 0)
554 return r;
555
556 if (needs_space)
557 fputc(' ', f);
558
559 switch (type) {
560 case SD_BUS_TYPE_BYTE:
561 fprintf(f, "%u", basic.u8);
562 break;
563
564 case SD_BUS_TYPE_BOOLEAN:
565 fputs(true_false(basic.i), f);
566 break;
567
568 case SD_BUS_TYPE_INT16:
569 fprintf(f, "%i", basic.s16);
570 break;
571
572 case SD_BUS_TYPE_UINT16:
573 fprintf(f, "%u", basic.u16);
574 break;
575
576 case SD_BUS_TYPE_INT32:
577 fprintf(f, "%i", basic.s32);
578 break;
579
580 case SD_BUS_TYPE_UINT32:
581 fprintf(f, "%u", basic.u32);
582 break;
583
584 case SD_BUS_TYPE_INT64:
585 fprintf(f, "%" PRIi64, basic.s64);
586 break;
587
588 case SD_BUS_TYPE_UINT64:
589 fprintf(f, "%" PRIu64, basic.u64);
590 break;
591
592 case SD_BUS_TYPE_DOUBLE:
593 fprintf(f, "%g", basic.d64);
594 break;
595
596 case SD_BUS_TYPE_STRING:
597 case SD_BUS_TYPE_OBJECT_PATH:
598 case SD_BUS_TYPE_SIGNATURE: {
599 _cleanup_free_ char *b = NULL;
600
601 b = cescape(basic.string);
602 if (!b)
603 return -ENOMEM;
604
605 fprintf(f, "\"%s\"", b);
606 break;
607 }
608
609 case SD_BUS_TYPE_UNIX_FD:
610 fprintf(f, "%i", basic.i);
611 break;
612
613 default:
614 assert_not_reached("Unknown basic type.");
615 }
616
617 }
618 }
619
620 typedef struct Member {
621 const char *type;
622 char *interface;
623 char *name;
624 char *signature;
625 char *result;
626 char *value;
627 bool writable;
628 uint64_t flags;
629 } Member;
630
631 static unsigned long member_hash_func(const void *p, const uint8_t hash_key[]) {
632 const Member *m = p;
633 unsigned long ul;
634
635 assert(m);
636 assert(m->type);
637
638 ul = string_hash_func(m->type, hash_key);
639
640 if (m->name)
641 ul ^= string_hash_func(m->name, hash_key);
642
643 if (m->interface)
644 ul ^= string_hash_func(m->interface, hash_key);
645
646 return ul;
647 }
648
649 static int member_compare_func(const void *a, const void *b) {
650 const Member *x = a, *y = b;
651 int d;
652
653 assert(x);
654 assert(y);
655 assert(x->type);
656 assert(y->type);
657
658 if (!x->interface && y->interface)
659 return -1;
660 if (x->interface && !y->interface)
661 return 1;
662 if (x->interface && y->interface) {
663 d = strcmp(x->interface, y->interface);
664 if (d != 0)
665 return d;
666 }
667
668 d = strcmp(x->type, y->type);
669 if (d != 0)
670 return d;
671
672 if (!x->name && y->name)
673 return -1;
674 if (x->name && !y->name)
675 return 1;
676 if (x->name && y->name)
677 return strcmp(x->name, y->name);
678
679 return 0;
680 }
681
682 static int member_compare_funcp(const void *a, const void *b) {
683 const Member *const * x = (const Member *const *) a, * const *y = (const Member *const *) b;
684
685 return member_compare_func(*x, *y);
686 }
687
688 static void member_free(Member *m) {
689 if (!m)
690 return;
691
692 free(m->interface);
693 free(m->name);
694 free(m->signature);
695 free(m->result);
696 free(m->value);
697 free(m);
698 }
699
700 DEFINE_TRIVIAL_CLEANUP_FUNC(Member*, member_free);
701
702 static void member_set_free(Set *s) {
703 Member *m;
704
705 while ((m = set_steal_first(s)))
706 member_free(m);
707
708 set_free(s);
709 }
710
711 DEFINE_TRIVIAL_CLEANUP_FUNC(Set*, member_set_free);
712
713 static int on_interface(const char *interface, uint64_t flags, void *userdata) {
714 _cleanup_(member_freep) Member *m;
715 Set *members = userdata;
716 int r;
717
718 assert(interface);
719 assert(members);
720
721 m = new0(Member, 1);
722 if (!m)
723 return log_oom();
724
725 m->type = "interface";
726 m->flags = flags;
727
728 r = free_and_strdup(&m->interface, interface);
729 if (r < 0)
730 return log_oom();
731
732 r = set_put(members, m);
733 if (r <= 0) {
734 log_error("Duplicate interface");
735 return -EINVAL;
736 }
737
738 m = NULL;
739 return 0;
740 }
741
742 static int on_method(const char *interface, const char *name, const char *signature, const char *result, uint64_t flags, void *userdata) {
743 _cleanup_(member_freep) Member *m;
744 Set *members = userdata;
745 int r;
746
747 assert(interface);
748 assert(name);
749
750 m = new0(Member, 1);
751 if (!m)
752 return log_oom();
753
754 m->type = "method";
755 m->flags = flags;
756
757 r = free_and_strdup(&m->interface, interface);
758 if (r < 0)
759 return log_oom();
760
761 r = free_and_strdup(&m->name, name);
762 if (r < 0)
763 return log_oom();
764
765 r = free_and_strdup(&m->signature, signature);
766 if (r < 0)
767 return log_oom();
768
769 r = free_and_strdup(&m->result, result);
770 if (r < 0)
771 return log_oom();
772
773 r = set_put(members, m);
774 if (r <= 0) {
775 log_error("Duplicate method");
776 return -EINVAL;
777 }
778
779 m = NULL;
780 return 0;
781 }
782
783 static int on_signal(const char *interface, const char *name, const char *signature, uint64_t flags, void *userdata) {
784 _cleanup_(member_freep) Member *m;
785 Set *members = userdata;
786 int r;
787
788 assert(interface);
789 assert(name);
790
791 m = new0(Member, 1);
792 if (!m)
793 return log_oom();
794
795 m->type = "signal";
796 m->flags = flags;
797
798 r = free_and_strdup(&m->interface, interface);
799 if (r < 0)
800 return log_oom();
801
802 r = free_and_strdup(&m->name, name);
803 if (r < 0)
804 return log_oom();
805
806 r = free_and_strdup(&m->signature, signature);
807 if (r < 0)
808 return log_oom();
809
810 r = set_put(members, m);
811 if (r <= 0) {
812 log_error("Duplicate signal");
813 return -EINVAL;
814 }
815
816 m = NULL;
817 return 0;
818 }
819
820 static int on_property(const char *interface, const char *name, const char *signature, bool writable, uint64_t flags, void *userdata) {
821 _cleanup_(member_freep) Member *m;
822 Set *members = userdata;
823 int r;
824
825 assert(interface);
826 assert(name);
827
828 m = new0(Member, 1);
829 if (!m)
830 return log_oom();
831
832 m->type = "property";
833 m->flags = flags;
834 m->writable = writable;
835
836 r = free_and_strdup(&m->interface, interface);
837 if (r < 0)
838 return log_oom();
839
840 r = free_and_strdup(&m->name, name);
841 if (r < 0)
842 return log_oom();
843
844 r = free_and_strdup(&m->signature, signature);
845 if (r < 0)
846 return log_oom();
847
848 r = set_put(members, m);
849 if (r <= 0) {
850 log_error("Duplicate property");
851 return -EINVAL;
852 }
853
854 m = NULL;
855 return 0;
856 }
857
858 static const char *strdash(const char *x) {
859 return isempty(x) ? "-" : x;
860 }
861
862 static int introspect(sd_bus *bus, char **argv) {
863 static const struct hash_ops member_hash_ops = {
864 .hash = member_hash_func,
865 .compare = member_compare_func,
866 };
867
868 static const XMLIntrospectOps ops = {
869 .on_interface = on_interface,
870 .on_method = on_method,
871 .on_signal = on_signal,
872 .on_property = on_property,
873 };
874
875 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
876 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
877 _cleanup_(member_set_freep) Set *members = NULL;
878 Iterator i;
879 Member *m;
880 const char *xml;
881 int r;
882 unsigned name_width, type_width, signature_width, result_width;
883 Member **sorted = NULL;
884 unsigned k = 0, j;
885
886 if (strv_length(argv) != 3) {
887 log_error("Requires service and object path argument.");
888 return -EINVAL;
889 }
890
891 members = set_new(&member_hash_ops);
892 if (!members)
893 return log_oom();
894
895 r = sd_bus_call_method(bus, argv[1], argv[2], "org.freedesktop.DBus.Introspectable", "Introspect", &error, &reply, "");
896 if (r < 0) {
897 log_error("Failed to introspect object %s of service %s: %s", argv[2], argv[1], bus_error_message(&error, r));
898 return r;
899 }
900
901 r = sd_bus_message_read(reply, "s", &xml);
902 if (r < 0)
903 return bus_log_parse_error(r);
904
905 /* First, get list of all properties */
906 r = parse_xml_introspect(argv[2], xml, &ops, members);
907 if (r < 0)
908 return r;
909
910 /* Second, find the current values for them */
911 SET_FOREACH(m, members, i) {
912
913 if (!streq(m->type, "property"))
914 continue;
915
916 if (m->value)
917 continue;
918
919 r = sd_bus_call_method(bus, argv[1], argv[2], "org.freedesktop.DBus.Properties", "GetAll", &error, &reply, "s", m->interface);
920 if (r < 0) {
921 log_error("%s", bus_error_message(&error, r));
922 return r;
923 }
924
925 r = sd_bus_message_enter_container(reply, 'a', "{sv}");
926 if (r < 0)
927 return bus_log_parse_error(r);
928
929 for (;;) {
930 Member *z;
931 _cleanup_free_ char *buf = NULL;
932 _cleanup_fclose_ FILE *mf = NULL;
933 size_t sz = 0;
934 const char *name;
935
936 r = sd_bus_message_enter_container(reply, 'e', "sv");
937 if (r < 0)
938 return bus_log_parse_error(r);
939
940 if (r == 0)
941 break;
942
943 r = sd_bus_message_read(reply, "s", &name);
944 if (r < 0)
945 return bus_log_parse_error(r);
946
947 r = sd_bus_message_enter_container(reply, 'v', NULL);
948 if (r < 0)
949 return bus_log_parse_error(r);
950
951 mf = open_memstream(&buf, &sz);
952 if (!mf)
953 return log_oom();
954
955 r = format_cmdline(reply, mf, false);
956 if (r < 0)
957 return bus_log_parse_error(r);
958
959 fclose(mf);
960 mf = NULL;
961
962 z = set_get(members, &((Member) {
963 .type = "property",
964 .interface = m->interface,
965 .name = (char*) name }));
966 if (z) {
967 free(z->value);
968 z->value = buf;
969 buf = NULL;
970 }
971
972 r = sd_bus_message_exit_container(reply);
973 if (r < 0)
974 return bus_log_parse_error(r);
975
976 r = sd_bus_message_exit_container(reply);
977 if (r < 0)
978 return bus_log_parse_error(r);
979 }
980
981 r = sd_bus_message_exit_container(reply);
982 if (r < 0)
983 return bus_log_parse_error(r);
984 }
985
986 pager_open_if_enabled();
987
988 name_width = strlen("NAME");
989 type_width = strlen("TYPE");
990 signature_width = strlen("SIGNATURE");
991 result_width = strlen("RESULT/VALUE");
992
993 sorted = newa(Member*, set_size(members));
994
995 SET_FOREACH(m, members, i) {
996 if (m->interface)
997 name_width = MAX(name_width, strlen(m->interface));
998 if (m->name)
999 name_width = MAX(name_width, strlen(m->name) + 1);
1000 if (m->type)
1001 type_width = MAX(type_width, strlen(m->type));
1002 if (m->signature)
1003 signature_width = MAX(signature_width, strlen(m->signature));
1004 if (m->result)
1005 result_width = MAX(result_width, strlen(m->result));
1006 if (m->value)
1007 result_width = MAX(result_width, strlen(m->value));
1008
1009 sorted[k++] = m;
1010 }
1011
1012 if (result_width > 40)
1013 result_width = 40;
1014
1015 assert(k == set_size(members));
1016 qsort(sorted, k, sizeof(Member*), member_compare_funcp);
1017
1018 if (arg_legend) {
1019 printf("%-*s %-*s %-*s %-*s %s\n",
1020 (int) name_width, "NAME",
1021 (int) type_width, "TYPE",
1022 (int) signature_width, "SIGNATURE",
1023 (int) result_width, "RESULT/VALUE",
1024 "FLAGS");
1025 }
1026
1027 for (j = 0; j < k; j++) {
1028 _cleanup_free_ char *ellipsized = NULL;
1029 const char *rv;
1030 bool is_interface;
1031
1032 m = sorted[j];
1033
1034 is_interface = streq(m->type, "interface");
1035
1036 if (m->value) {
1037 ellipsized = ellipsize(m->value, result_width, 100);
1038 if (!ellipsized)
1039 return log_oom();
1040
1041 rv = ellipsized;
1042 } else
1043 rv = strdash(m->result);
1044
1045 printf("%s%s%-*s%s %-*s %-*s %-*s%s%s%s%s%s%s\n",
1046 is_interface ? ansi_highlight() : "",
1047 is_interface ? "" : ".",
1048 - !is_interface + (int) name_width, strdash(streq_ptr(m->type, "interface") ? m->interface : m->name),
1049 is_interface ? ansi_highlight_off() : "",
1050 (int) type_width, strdash(m->type),
1051 (int) signature_width, strdash(m->signature),
1052 (int) result_width, rv,
1053 (m->flags & SD_BUS_VTABLE_DEPRECATED) ? " deprecated" : (m->flags || m->writable ? "" : " -"),
1054 (m->flags & SD_BUS_VTABLE_METHOD_NO_REPLY) ? " no-reply" : "",
1055 (m->flags & SD_BUS_VTABLE_PROPERTY_CONST) ? " const" : "",
1056 (m->flags & SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE) ? " emits-change" : "",
1057 (m->flags & SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION) ? " emits-invalidation" : "",
1058 m->writable ? " writable" : "");
1059 }
1060
1061 return 0;
1062 }
1063
1064 static int message_dump(sd_bus_message *m, FILE *f) {
1065 return bus_message_dump(m, f, BUS_MESSAGE_DUMP_WITH_HEADER);
1066 }
1067
1068 static int message_pcap(sd_bus_message *m, FILE *f) {
1069 return bus_message_pcap_frame(m, arg_snaplen, f);
1070 }
1071
1072 static int monitor(sd_bus *bus, char *argv[], int (*dump)(sd_bus_message *m, FILE *f)) {
1073 bool added_something = false;
1074 char **i;
1075 int r;
1076
1077 STRV_FOREACH(i, argv+1) {
1078 _cleanup_free_ char *m = NULL;
1079
1080 if (!service_name_is_valid(*i)) {
1081 log_error("Invalid service name '%s'", *i);
1082 return -EINVAL;
1083 }
1084
1085 m = strjoin("sender='", *i, "'", NULL);
1086 if (!m)
1087 return log_oom();
1088
1089 r = sd_bus_add_match(bus, NULL, m, NULL, NULL);
1090 if (r < 0)
1091 return log_error_errno(r, "Failed to add match: %m");
1092
1093 added_something = true;
1094 }
1095
1096 STRV_FOREACH(i, arg_matches) {
1097 r = sd_bus_add_match(bus, NULL, *i, NULL, NULL);
1098 if (r < 0)
1099 return log_error_errno(r, "Failed to add match: %m");
1100
1101 added_something = true;
1102 }
1103
1104 if (!added_something) {
1105 r = sd_bus_add_match(bus, NULL, "", NULL, NULL);
1106 if (r < 0)
1107 return log_error_errno(r, "Failed to add match: %m");
1108 }
1109
1110 for (;;) {
1111 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1112
1113 r = sd_bus_process(bus, &m);
1114 if (r < 0)
1115 return log_error_errno(r, "Failed to process bus: %m");
1116
1117 if (m) {
1118 dump(m, stdout);
1119 continue;
1120 }
1121
1122 if (r > 0)
1123 continue;
1124
1125 r = sd_bus_wait(bus, (uint64_t) -1);
1126 if (r < 0)
1127 return log_error_errno(r, "Failed to wait for bus: %m");
1128 }
1129 }
1130
1131 static int capture(sd_bus *bus, char *argv[]) {
1132 int r;
1133
1134 if (isatty(fileno(stdout)) > 0) {
1135 log_error("Refusing to write message data to console, please redirect output to a file.");
1136 return -EINVAL;
1137 }
1138
1139 bus_pcap_header(arg_snaplen, stdout);
1140
1141 r = monitor(bus, argv, message_pcap);
1142 if (r < 0)
1143 return r;
1144
1145 if (ferror(stdout)) {
1146 log_error("Couldn't write capture file.");
1147 return -EIO;
1148 }
1149
1150 return r;
1151 }
1152
1153 static int status(sd_bus *bus, char *argv[]) {
1154 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
1155 pid_t pid;
1156 int r;
1157
1158 assert(bus);
1159
1160 if (strv_length(argv) > 2) {
1161 log_error("Expects no or one argument.");
1162 return -EINVAL;
1163 }
1164
1165 if (argv[1]) {
1166 r = parse_pid(argv[1], &pid);
1167 if (r < 0)
1168 r = sd_bus_get_name_creds(
1169 bus,
1170 argv[1],
1171 (arg_augment_creds ? SD_BUS_CREDS_AUGMENT : 0) | _SD_BUS_CREDS_ALL,
1172 &creds);
1173 else
1174 r = sd_bus_creds_new_from_pid(
1175 &creds,
1176 pid,
1177 _SD_BUS_CREDS_ALL);
1178 } else {
1179 const char *scope;
1180 sd_id128_t bus_id;
1181
1182 r = sd_bus_get_scope(bus, &scope);
1183 if (r >= 0)
1184 printf("Scope=%s%s%s\n", ansi_highlight(), scope, ansi_highlight_off());
1185
1186 r = sd_bus_get_bus_id(bus, &bus_id);
1187 if (r >= 0)
1188 printf("BusID=%s" SD_ID128_FORMAT_STR "%s\n", ansi_highlight(), SD_ID128_FORMAT_VAL(bus_id), ansi_highlight_off());
1189
1190 r = sd_bus_get_owner_creds(
1191 bus,
1192 (arg_augment_creds ? SD_BUS_CREDS_AUGMENT : 0) | _SD_BUS_CREDS_ALL,
1193 &creds);
1194 }
1195
1196 if (r < 0)
1197 return log_error_errno(r, "Failed to get credentials: %m");
1198
1199 bus_creds_dump(creds, NULL, false);
1200 return 0;
1201 }
1202
1203 static int message_append_cmdline(sd_bus_message *m, const char *signature, char ***x) {
1204 char **p;
1205 int r;
1206
1207 assert(m);
1208 assert(signature);
1209 assert(x);
1210
1211 p = *x;
1212
1213 for (;;) {
1214 const char *v;
1215 char t;
1216
1217 t = *signature;
1218 v = *p;
1219
1220 if (t == 0)
1221 break;
1222 if (!v) {
1223 log_error("Too few parameters for signature.");
1224 return -EINVAL;
1225 }
1226
1227 signature++;
1228 p++;
1229
1230 switch (t) {
1231
1232 case SD_BUS_TYPE_BOOLEAN:
1233
1234 r = parse_boolean(v);
1235 if (r < 0) {
1236 log_error("Failed to parse as boolean: %s", v);
1237 return r;
1238 }
1239
1240 r = sd_bus_message_append_basic(m, t, &r);
1241 break;
1242
1243 case SD_BUS_TYPE_BYTE: {
1244 uint8_t z;
1245
1246 r = safe_atou8(v, &z);
1247 if (r < 0) {
1248 log_error("Failed to parse as byte (unsigned 8bit integer): %s", v);
1249 return r;
1250 }
1251
1252 r = sd_bus_message_append_basic(m, t, &z);
1253 break;
1254 }
1255
1256 case SD_BUS_TYPE_INT16: {
1257 int16_t z;
1258
1259 r = safe_atoi16(v, &z);
1260 if (r < 0) {
1261 log_error("Failed to parse as signed 16bit integer: %s", v);
1262 return r;
1263 }
1264
1265 r = sd_bus_message_append_basic(m, t, &z);
1266 break;
1267 }
1268
1269 case SD_BUS_TYPE_UINT16: {
1270 uint16_t z;
1271
1272 r = safe_atou16(v, &z);
1273 if (r < 0) {
1274 log_error("Failed to parse as unsigned 16bit integer: %s", v);
1275 return r;
1276 }
1277
1278 r = sd_bus_message_append_basic(m, t, &z);
1279 break;
1280 }
1281
1282 case SD_BUS_TYPE_INT32: {
1283 int32_t z;
1284
1285 r = safe_atoi32(v, &z);
1286 if (r < 0) {
1287 log_error("Failed to parse as signed 32bit integer: %s", v);
1288 return r;
1289 }
1290
1291 r = sd_bus_message_append_basic(m, t, &z);
1292 break;
1293 }
1294
1295 case SD_BUS_TYPE_UINT32: {
1296 uint32_t z;
1297
1298 r = safe_atou32(v, &z);
1299 if (r < 0) {
1300 log_error("Failed to parse as unsigned 32bit integer: %s", v);
1301 return r;
1302 }
1303
1304 r = sd_bus_message_append_basic(m, t, &z);
1305 break;
1306 }
1307
1308 case SD_BUS_TYPE_INT64: {
1309 int64_t z;
1310
1311 r = safe_atoi64(v, &z);
1312 if (r < 0) {
1313 log_error("Failed to parse as signed 64bit integer: %s", v);
1314 return r;
1315 }
1316
1317 r = sd_bus_message_append_basic(m, t, &z);
1318 break;
1319 }
1320
1321 case SD_BUS_TYPE_UINT64: {
1322 uint64_t z;
1323
1324 r = safe_atou64(v, &z);
1325 if (r < 0) {
1326 log_error("Failed to parse as unsigned 64bit integer: %s", v);
1327 return r;
1328 }
1329
1330 r = sd_bus_message_append_basic(m, t, &z);
1331 break;
1332 }
1333
1334
1335 case SD_BUS_TYPE_DOUBLE: {
1336 double z;
1337
1338 r = safe_atod(v, &z);
1339 if (r < 0) {
1340 log_error("Failed to parse as double precision floating point: %s", v);
1341 return r;
1342 }
1343
1344 r = sd_bus_message_append_basic(m, t, &z);
1345 break;
1346 }
1347
1348 case SD_BUS_TYPE_STRING:
1349 case SD_BUS_TYPE_OBJECT_PATH:
1350 case SD_BUS_TYPE_SIGNATURE:
1351
1352 r = sd_bus_message_append_basic(m, t, v);
1353 break;
1354
1355 case SD_BUS_TYPE_ARRAY: {
1356 uint32_t n;
1357 size_t k;
1358
1359 r = safe_atou32(v, &n);
1360 if (r < 0) {
1361 log_error("Failed to parse number of array entries: %s", v);
1362 return r;
1363 }
1364
1365 r = signature_element_length(signature, &k);
1366 if (r < 0) {
1367 log_error("Invalid array signature.");
1368 return r;
1369 }
1370
1371 {
1372 unsigned i;
1373 char s[k + 1];
1374 memcpy(s, signature, k);
1375 s[k] = 0;
1376
1377 r = sd_bus_message_open_container(m, SD_BUS_TYPE_ARRAY, s);
1378 if (r < 0)
1379 return bus_log_create_error(r);
1380
1381 for (i = 0; i < n; i++) {
1382 r = message_append_cmdline(m, s, &p);
1383 if (r < 0)
1384 return r;
1385 }
1386 }
1387
1388 signature += k;
1389
1390 r = sd_bus_message_close_container(m);
1391 break;
1392 }
1393
1394 case SD_BUS_TYPE_VARIANT:
1395 r = sd_bus_message_open_container(m, SD_BUS_TYPE_VARIANT, v);
1396 if (r < 0)
1397 return bus_log_create_error(r);
1398
1399 r = message_append_cmdline(m, v, &p);
1400 if (r < 0)
1401 return r;
1402
1403 r = sd_bus_message_close_container(m);
1404 break;
1405
1406 case SD_BUS_TYPE_STRUCT_BEGIN:
1407 case SD_BUS_TYPE_DICT_ENTRY_BEGIN: {
1408 size_t k;
1409
1410 signature--;
1411 p--;
1412
1413 r = signature_element_length(signature, &k);
1414 if (r < 0) {
1415 log_error("Invalid struct/dict entry signature.");
1416 return r;
1417 }
1418
1419 {
1420 char s[k-1];
1421 memcpy(s, signature + 1, k - 2);
1422 s[k - 2] = 0;
1423
1424 r = sd_bus_message_open_container(m, t == SD_BUS_TYPE_STRUCT_BEGIN ? SD_BUS_TYPE_STRUCT : SD_BUS_TYPE_DICT_ENTRY, s);
1425 if (r < 0)
1426 return bus_log_create_error(r);
1427
1428 r = message_append_cmdline(m, s, &p);
1429 if (r < 0)
1430 return r;
1431 }
1432
1433 signature += k;
1434
1435 r = sd_bus_message_close_container(m);
1436 break;
1437 }
1438
1439 case SD_BUS_TYPE_UNIX_FD:
1440 log_error("UNIX file descriptor not supported as type.");
1441 return -EINVAL;
1442
1443 default:
1444 log_error("Unknown signature type %c.", t);
1445 return -EINVAL;
1446 }
1447
1448 if (r < 0)
1449 return bus_log_create_error(r);
1450 }
1451
1452 *x = p;
1453 return 0;
1454 }
1455
1456 static int call(sd_bus *bus, char *argv[]) {
1457 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1458 _cleanup_bus_message_unref_ sd_bus_message *m = NULL, *reply = NULL;
1459 int r;
1460
1461 assert(bus);
1462
1463 if (strv_length(argv) < 5) {
1464 log_error("Expects at least four arguments.");
1465 return -EINVAL;
1466 }
1467
1468 r = sd_bus_message_new_method_call(bus, &m, argv[1], argv[2], argv[3], argv[4]);
1469 if (r < 0)
1470 return bus_log_create_error(r);
1471
1472 r = sd_bus_message_set_expect_reply(m, arg_expect_reply);
1473 if (r < 0)
1474 return bus_log_create_error(r);
1475
1476 r = sd_bus_message_set_auto_start(m, arg_auto_start);
1477 if (r < 0)
1478 return bus_log_create_error(r);
1479
1480 r = sd_bus_message_set_allow_interactive_authorization(m, arg_allow_interactive_authorization);
1481 if (r < 0)
1482 return bus_log_create_error(r);
1483
1484 if (!isempty(argv[5])) {
1485 char **p;
1486
1487 p = argv+6;
1488
1489 r = message_append_cmdline(m, argv[5], &p);
1490 if (r < 0)
1491 return r;
1492
1493 if (*p) {
1494 log_error("Too many parameters for signature.");
1495 return -EINVAL;
1496 }
1497 }
1498
1499 if (!arg_expect_reply) {
1500 r = sd_bus_send(bus, m, NULL);
1501 if (r < 0) {
1502 log_error("Failed to send message.");
1503 return r;
1504 }
1505
1506 return 0;
1507 }
1508
1509 r = sd_bus_call(bus, m, arg_timeout, &error, &reply);
1510 if (r < 0) {
1511 log_error("%s", bus_error_message(&error, r));
1512 return r;
1513 }
1514
1515 r = sd_bus_message_is_empty(reply);
1516 if (r < 0)
1517 return bus_log_parse_error(r);
1518
1519 if (r == 0 && !arg_quiet) {
1520
1521 if (arg_verbose) {
1522 pager_open_if_enabled();
1523
1524 r = bus_message_dump(reply, stdout, 0);
1525 if (r < 0)
1526 return r;
1527 } else {
1528
1529 fputs(sd_bus_message_get_signature(reply, true), stdout);
1530 fputc(' ', stdout);
1531
1532 r = format_cmdline(reply, stdout, false);
1533 if (r < 0)
1534 return bus_log_parse_error(r);
1535
1536 fputc('\n', stdout);
1537 }
1538 }
1539
1540 return 0;
1541 }
1542
1543 static int get_property(sd_bus *bus, char *argv[]) {
1544 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1545 unsigned n;
1546 char **i;
1547 int r;
1548
1549 assert(bus);
1550
1551 n = strv_length(argv);
1552 if (n < 5) {
1553 log_error("Expects at least four arguments.");
1554 return -EINVAL;
1555 }
1556
1557 STRV_FOREACH(i, argv + 4) {
1558 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1559 const char *contents = NULL;
1560 char type;
1561
1562 r = sd_bus_call_method(bus, argv[1], argv[2], "org.freedesktop.DBus.Properties", "Get", &error, &reply, "ss", argv[3], *i);
1563 if (r < 0) {
1564 log_error("%s", bus_error_message(&error, r));
1565 return r;
1566 }
1567
1568 r = sd_bus_message_peek_type(reply, &type, &contents);
1569 if (r < 0)
1570 return bus_log_parse_error(r);
1571
1572 r = sd_bus_message_enter_container(reply, 'v', contents);
1573 if (r < 0)
1574 return bus_log_parse_error(r);
1575
1576 if (arg_verbose) {
1577 pager_open_if_enabled();
1578
1579 r = bus_message_dump(reply, stdout, BUS_MESSAGE_DUMP_SUBTREE_ONLY);
1580 if (r < 0)
1581 return r;
1582 } else {
1583 fputs(contents, stdout);
1584 fputc(' ', stdout);
1585
1586 r = format_cmdline(reply, stdout, false);
1587 if (r < 0)
1588 return bus_log_parse_error(r);
1589
1590 fputc('\n', stdout);
1591 }
1592
1593 r = sd_bus_message_exit_container(reply);
1594 if (r < 0)
1595 return bus_log_parse_error(r);
1596 }
1597
1598 return 0;
1599 }
1600
1601 static int set_property(sd_bus *bus, char *argv[]) {
1602 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1603 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1604 unsigned n;
1605 char **p;
1606 int r;
1607
1608 assert(bus);
1609
1610 n = strv_length(argv);
1611 if (n < 6) {
1612 log_error("Expects at least five arguments.");
1613 return -EINVAL;
1614 }
1615
1616 r = sd_bus_message_new_method_call(bus, &m, argv[1], argv[2], "org.freedesktop.DBus.Properties", "Set");
1617 if (r < 0)
1618 return bus_log_create_error(r);
1619
1620 r = sd_bus_message_append(m, "ss", argv[3], argv[4]);
1621 if (r < 0)
1622 return bus_log_create_error(r);
1623
1624 r = sd_bus_message_open_container(m, 'v', argv[5]);
1625 if (r < 0)
1626 return bus_log_create_error(r);
1627
1628 p = argv+6;
1629 r = message_append_cmdline(m, argv[5], &p);
1630 if (r < 0)
1631 return r;
1632
1633 r = sd_bus_message_close_container(m);
1634 if (r < 0)
1635 return bus_log_create_error(r);
1636
1637 if (*p) {
1638 log_error("Too many parameters for signature.");
1639 return -EINVAL;
1640 }
1641
1642 r = sd_bus_call(bus, m, arg_timeout, &error, NULL);
1643 if (r < 0) {
1644 log_error("%s", bus_error_message(&error, r));
1645 return r;
1646 }
1647
1648 return 0;
1649 }
1650
1651 static int help(void) {
1652 printf("%s [OPTIONS...] {COMMAND} ...\n\n"
1653 "Introspect the bus.\n\n"
1654 " -h --help Show this help\n"
1655 " --version Show package version\n"
1656 " --no-pager Do not pipe output into a pager\n"
1657 " --no-legend Do not show the headers and footers\n"
1658 " --system Connect to system bus\n"
1659 " --user Connect to user bus\n"
1660 " -H --host=[USER@]HOST Operate on remote host\n"
1661 " -M --machine=CONTAINER Operate on local container\n"
1662 " --address=ADDRESS Connect to bus specified by address\n"
1663 " --show-machine Show machine ID column in list\n"
1664 " --unique Only show unique names\n"
1665 " --acquired Only show acquired names\n"
1666 " --activatable Only show activatable names\n"
1667 " --match=MATCH Only show matching messages\n"
1668 " --list Don't show tree, but simple object path list\n"
1669 " --quiet Don't show method call reply\n"
1670 " --verbose Show result values in long format\n"
1671 " --expect-reply=BOOL Expect a method call reply\n"
1672 " --auto-start=BOOL Auto-start destination service\n"
1673 " --allow-interactive-authorization=BOOL\n"
1674 " Allow interactive authorization for operation\n"
1675 " --timeout=SECS Maximum time to wait for method call completion\n"
1676 " --augment-creds=BOOL Extend credential data with data read from /proc/$PID\n\n"
1677 "Commands:\n"
1678 " list List bus names\n"
1679 " status [SERVICE] Show bus service, process or bus owner credentials\n"
1680 " monitor [SERVICE...] Show bus traffic\n"
1681 " capture [SERVICE...] Capture bus traffic as pcap\n"
1682 " tree [SERVICE...] Show object tree of service\n"
1683 " introspect SERVICE OBJECT\n"
1684 " call SERVICE OBJECT INTERFACE METHOD [SIGNATURE [ARGUMENT...]]\n"
1685 " Call a method\n"
1686 " get-property SERVICE OBJECT INTERFACE PROPERTY...\n"
1687 " Get property value\n"
1688 " set-property SERVICE OBJECT INTERFACE PROPERTY SIGNATURE ARGUMENT...\n"
1689 " Set property value\n"
1690 " help Show this help\n"
1691 , program_invocation_short_name);
1692
1693 return 0;
1694 }
1695
1696 static int parse_argv(int argc, char *argv[]) {
1697
1698 enum {
1699 ARG_VERSION = 0x100,
1700 ARG_NO_PAGER,
1701 ARG_NO_LEGEND,
1702 ARG_SYSTEM,
1703 ARG_USER,
1704 ARG_ADDRESS,
1705 ARG_MATCH,
1706 ARG_SHOW_MACHINE,
1707 ARG_UNIQUE,
1708 ARG_ACQUIRED,
1709 ARG_ACTIVATABLE,
1710 ARG_SIZE,
1711 ARG_LIST,
1712 ARG_VERBOSE,
1713 ARG_EXPECT_REPLY,
1714 ARG_AUTO_START,
1715 ARG_ALLOW_INTERACTIVE_AUTHORIZATION,
1716 ARG_TIMEOUT,
1717 ARG_AUGMENT_CREDS,
1718 };
1719
1720 static const struct option options[] = {
1721 { "help", no_argument, NULL, 'h' },
1722 { "version", no_argument, NULL, ARG_VERSION },
1723 { "no-pager", no_argument, NULL, ARG_NO_PAGER },
1724 { "no-legend", no_argument, NULL, ARG_NO_LEGEND },
1725 { "system", no_argument, NULL, ARG_SYSTEM },
1726 { "user", no_argument, NULL, ARG_USER },
1727 { "address", required_argument, NULL, ARG_ADDRESS },
1728 { "show-machine", no_argument, NULL, ARG_SHOW_MACHINE },
1729 { "unique", no_argument, NULL, ARG_UNIQUE },
1730 { "acquired", no_argument, NULL, ARG_ACQUIRED },
1731 { "activatable", no_argument, NULL, ARG_ACTIVATABLE },
1732 { "match", required_argument, NULL, ARG_MATCH },
1733 { "host", required_argument, NULL, 'H' },
1734 { "machine", required_argument, NULL, 'M' },
1735 { "size", required_argument, NULL, ARG_SIZE },
1736 { "list", no_argument, NULL, ARG_LIST },
1737 { "quiet", no_argument, NULL, 'q' },
1738 { "verbose", no_argument, NULL, ARG_VERBOSE },
1739 { "expect-reply", required_argument, NULL, ARG_EXPECT_REPLY },
1740 { "auto-start", required_argument, NULL, ARG_AUTO_START },
1741 { "allow-interactive-authorization", required_argument, NULL, ARG_ALLOW_INTERACTIVE_AUTHORIZATION },
1742 { "timeout", required_argument, NULL, ARG_TIMEOUT },
1743 { "augment-creds",required_argument, NULL, ARG_AUGMENT_CREDS},
1744 {},
1745 };
1746
1747 int c, r;
1748
1749 assert(argc >= 0);
1750 assert(argv);
1751
1752 while ((c = getopt_long(argc, argv, "hH:M:q", options, NULL)) >= 0)
1753
1754 switch (c) {
1755
1756 case 'h':
1757 return help();
1758
1759 case ARG_VERSION:
1760 puts(PACKAGE_STRING);
1761 puts(SYSTEMD_FEATURES);
1762 return 0;
1763
1764 case ARG_NO_PAGER:
1765 arg_no_pager = true;
1766 break;
1767
1768 case ARG_NO_LEGEND:
1769 arg_legend = false;
1770 break;
1771
1772 case ARG_USER:
1773 arg_user = true;
1774 break;
1775
1776 case ARG_SYSTEM:
1777 arg_user = false;
1778 break;
1779
1780 case ARG_ADDRESS:
1781 arg_address = optarg;
1782 break;
1783
1784 case ARG_SHOW_MACHINE:
1785 arg_show_machine = true;
1786 break;
1787
1788 case ARG_UNIQUE:
1789 arg_unique = true;
1790 break;
1791
1792 case ARG_ACQUIRED:
1793 arg_acquired = true;
1794 break;
1795
1796 case ARG_ACTIVATABLE:
1797 arg_activatable = true;
1798 break;
1799
1800 case ARG_MATCH:
1801 if (strv_extend(&arg_matches, optarg) < 0)
1802 return log_oom();
1803 break;
1804
1805 case ARG_SIZE: {
1806 off_t o;
1807
1808 r = parse_size(optarg, 0, &o);
1809 if (r < 0) {
1810 log_error("Failed to parse size: %s", optarg);
1811 return r;
1812 }
1813
1814 if ((off_t) (size_t) o != o) {
1815 log_error("Size out of range.");
1816 return -E2BIG;
1817 }
1818
1819 arg_snaplen = (size_t) o;
1820 break;
1821 }
1822
1823 case ARG_LIST:
1824 arg_list = true;
1825 break;
1826
1827 case 'H':
1828 arg_transport = BUS_TRANSPORT_REMOTE;
1829 arg_host = optarg;
1830 break;
1831
1832 case 'M':
1833 arg_transport = BUS_TRANSPORT_CONTAINER;
1834 arg_host = optarg;
1835 break;
1836
1837 case 'q':
1838 arg_quiet = true;
1839 break;
1840
1841 case ARG_VERBOSE:
1842 arg_verbose = true;
1843 break;
1844
1845 case ARG_EXPECT_REPLY:
1846 r = parse_boolean(optarg);
1847 if (r < 0) {
1848 log_error("Failed to parse --expect-reply= parameter.");
1849 return r;
1850 }
1851
1852 arg_expect_reply = !!r;
1853 break;
1854
1855
1856 case ARG_AUTO_START:
1857 r = parse_boolean(optarg);
1858 if (r < 0) {
1859 log_error("Failed to parse --auto-start= parameter.");
1860 return r;
1861 }
1862
1863 arg_auto_start = !!r;
1864 break;
1865
1866
1867 case ARG_ALLOW_INTERACTIVE_AUTHORIZATION:
1868 r = parse_boolean(optarg);
1869 if (r < 0) {
1870 log_error("Failed to parse --allow-interactive-authorization= parameter.");
1871 return r;
1872 }
1873
1874 arg_allow_interactive_authorization = !!r;
1875 break;
1876
1877 case ARG_TIMEOUT:
1878 r = parse_sec(optarg, &arg_timeout);
1879 if (r < 0) {
1880 log_error("Failed to parse --timeout= parameter.");
1881 return r;
1882 }
1883
1884 break;
1885
1886 case ARG_AUGMENT_CREDS:
1887 r = parse_boolean(optarg);
1888 if (r < 0) {
1889 log_error("Failed to parse --augment-creds= parameter.");
1890 return r;
1891 }
1892
1893 arg_augment_creds = !!r;
1894 break;
1895
1896 case '?':
1897 return -EINVAL;
1898
1899 default:
1900 assert_not_reached("Unhandled option");
1901 }
1902
1903 return 1;
1904 }
1905
1906 static int busctl_main(sd_bus *bus, int argc, char *argv[]) {
1907 assert(bus);
1908
1909 if (optind >= argc ||
1910 streq(argv[optind], "list"))
1911 return list_bus_names(bus, argv + optind);
1912
1913 if (streq(argv[optind], "monitor"))
1914 return monitor(bus, argv + optind, message_dump);
1915
1916 if (streq(argv[optind], "capture"))
1917 return capture(bus, argv + optind);
1918
1919 if (streq(argv[optind], "status"))
1920 return status(bus, argv + optind);
1921
1922 if (streq(argv[optind], "tree"))
1923 return tree(bus, argv + optind);
1924
1925 if (streq(argv[optind], "introspect"))
1926 return introspect(bus, argv + optind);
1927
1928 if (streq(argv[optind], "call"))
1929 return call(bus, argv + optind);
1930
1931 if (streq(argv[optind], "get-property"))
1932 return get_property(bus, argv + optind);
1933
1934 if (streq(argv[optind], "set-property"))
1935 return set_property(bus, argv + optind);
1936
1937 if (streq(argv[optind], "help"))
1938 return help();
1939
1940 log_error("Unknown command '%s'", argv[optind]);
1941 return -EINVAL;
1942 }
1943
1944 int main(int argc, char *argv[]) {
1945 _cleanup_bus_close_unref_ sd_bus *bus = NULL;
1946 int r;
1947
1948 log_parse_environment();
1949 log_open();
1950
1951 r = parse_argv(argc, argv);
1952 if (r <= 0)
1953 goto finish;
1954
1955 r = sd_bus_new(&bus);
1956 if (r < 0) {
1957 log_error_errno(r, "Failed to allocate bus: %m");
1958 goto finish;
1959 }
1960
1961 if (streq_ptr(argv[optind], "monitor") ||
1962 streq_ptr(argv[optind], "capture")) {
1963
1964 r = sd_bus_set_monitor(bus, true);
1965 if (r < 0) {
1966 log_error_errno(r, "Failed to set monitor mode: %m");
1967 goto finish;
1968 }
1969
1970 r = sd_bus_negotiate_creds(bus, true, _SD_BUS_CREDS_ALL);
1971 if (r < 0) {
1972 log_error_errno(r, "Failed to enable credentials: %m");
1973 goto finish;
1974 }
1975
1976 r = sd_bus_negotiate_timestamp(bus, true);
1977 if (r < 0) {
1978 log_error_errno(r, "Failed to enable timestamps: %m");
1979 goto finish;
1980 }
1981
1982 r = sd_bus_negotiate_fds(bus, true);
1983 if (r < 0) {
1984 log_error_errno(r, "Failed to enable fds: %m");
1985 goto finish;
1986 }
1987 }
1988
1989 if (arg_address)
1990 r = sd_bus_set_address(bus, arg_address);
1991 else {
1992 r = sd_bus_set_bus_client(bus, true);
1993 if (r < 0) {
1994 log_error_errno(r, "Failed to set bus client: %m");
1995 goto finish;
1996 }
1997
1998 switch (arg_transport) {
1999
2000 case BUS_TRANSPORT_LOCAL:
2001 if (arg_user) {
2002 bus->is_user = true;
2003 r = bus_set_address_user(bus);
2004 } else {
2005 bus->is_system = true;
2006 r = bus_set_address_system(bus);
2007 }
2008 break;
2009
2010 case BUS_TRANSPORT_REMOTE:
2011 r = bus_set_address_system_remote(bus, arg_host);
2012 break;
2013
2014 case BUS_TRANSPORT_CONTAINER:
2015 r = bus_set_address_system_container(bus, arg_host);
2016 break;
2017
2018 default:
2019 assert_not_reached("Hmm, unknown transport type.");
2020 }
2021 }
2022 if (r < 0) {
2023 log_error_errno(r, "Failed to set address: %m");
2024 goto finish;
2025 }
2026
2027 r = sd_bus_start(bus);
2028 if (r < 0) {
2029 log_error_errno(r, "Failed to connect to bus: %m");
2030 goto finish;
2031 }
2032
2033 r = busctl_main(bus, argc, argv);
2034
2035 finish:
2036 pager_close();
2037
2038 strv_free(arg_matches);
2039
2040 return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
2041 }
Unnamed repository; edit this file 'description' to name the repository.