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