]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/libsystemd/sd-bus/sd-bus.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
sd-event: rework API to support CLOCK_REALTIME_ALARM and CLOCK_BOOTTIME_ALARM, too
[thirdparty/systemd.git] / src / libsystemd / sd-bus / sd-bus.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 <endian.h>
23 #include <assert.h>
24 #include <stdlib.h>
25 #include <unistd.h>
26 #include <netdb.h>
27 #include <sys/poll.h>
28 #include <byteswap.h>
29 #include <sys/mman.h>
30 #include <pthread.h>
31
32 #include "util.h"
33 #include "macro.h"
34 #include "strv.h"
35 #include "set.h"
36 #include "missing.h"
37 #include "def.h"
38 #include "cgroup-util.h"
39 #include "bus-label.h"
40
41 #include "sd-bus.h"
42 #include "bus-internal.h"
43 #include "bus-message.h"
44 #include "bus-type.h"
45 #include "bus-socket.h"
46 #include "bus-kernel.h"
47 #include "bus-control.h"
48 #include "bus-introspect.h"
49 #include "bus-signature.h"
50 #include "bus-objects.h"
51 #include "bus-util.h"
52 #include "bus-container.h"
53 #include "bus-protocol.h"
54 #include "bus-track.h"
55
56 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec);
57 static int attach_io_events(sd_bus *b);
58 static void detach_io_events(sd_bus *b);
59
60 static void bus_close_fds(sd_bus *b) {
61 assert(b);
62
63 detach_io_events(b);
64
65 if (b->input_fd >= 0)
66 safe_close(b->input_fd);
67
68 if (b->output_fd >= 0 && b->output_fd != b->input_fd)
69 safe_close(b->output_fd);
70
71 b->input_fd = b->output_fd = -1;
72 }
73
74 static void bus_node_destroy(sd_bus *b, struct node *n) {
75 struct node_callback *c;
76 struct node_vtable *v;
77 struct node_enumerator *e;
78
79 assert(b);
80
81 if (!n)
82 return;
83
84 while (n->child)
85 bus_node_destroy(b, n->child);
86
87 while ((c = n->callbacks)) {
88 LIST_REMOVE(callbacks, n->callbacks, c);
89 free(c);
90 }
91
92 while ((v = n->vtables)) {
93 LIST_REMOVE(vtables, n->vtables, v);
94 free(v->interface);
95 free(v);
96 }
97
98 while ((e = n->enumerators)) {
99 LIST_REMOVE(enumerators, n->enumerators, e);
100 free(e);
101 }
102
103 if (n->parent)
104 LIST_REMOVE(siblings, n->parent->child, n);
105
106 assert_se(hashmap_remove(b->nodes, n->path) == n);
107 free(n->path);
108 free(n);
109 }
110
111 static void bus_reset_queues(sd_bus *b) {
112 assert(b);
113
114 /* NOTE: We _must_ decrement b->Xqueue_size before calling
115 * sd_bus_message_unref() for _each_ message. Otherwise the
116 * self-reference checks in sd_bus_unref() will fire for each message.
117 * We would thus recurse into sd_bus_message_unref() and trigger the
118 * assert(m->n_ref > 0) */
119
120 while (b->rqueue_size > 0)
121 sd_bus_message_unref(b->rqueue[--b->rqueue_size]);
122
123 free(b->rqueue);
124 b->rqueue = NULL;
125 b->rqueue_allocated = 0;
126
127 while (b->wqueue_size > 0)
128 sd_bus_message_unref(b->wqueue[--b->wqueue_size]);
129
130 free(b->wqueue);
131 b->wqueue = NULL;
132 b->wqueue_allocated = 0;
133 }
134
135 static void bus_free(sd_bus *b) {
136 struct filter_callback *f;
137 struct node *n;
138
139 assert(b);
140
141 assert(!b->track_queue);
142
143 sd_bus_detach_event(b);
144
145 if (b->default_bus_ptr)
146 *b->default_bus_ptr = NULL;
147
148 bus_close_fds(b);
149
150 if (b->kdbus_buffer)
151 munmap(b->kdbus_buffer, KDBUS_POOL_SIZE);
152
153 free(b->rbuffer);
154 free(b->unique_name);
155 free(b->auth_buffer);
156 free(b->address);
157 free(b->kernel);
158 free(b->machine);
159 free(b->fake_label);
160 free(b->cgroup_root);
161 free(b->connection_name);
162
163 free(b->exec_path);
164 strv_free(b->exec_argv);
165
166 close_many(b->fds, b->n_fds);
167 free(b->fds);
168
169 bus_reset_queues(b);
170
171 hashmap_free_free(b->reply_callbacks);
172 prioq_free(b->reply_callbacks_prioq);
173
174 while ((f = b->filter_callbacks)) {
175 LIST_REMOVE(callbacks, b->filter_callbacks, f);
176 free(f);
177 }
178
179 bus_match_free(&b->match_callbacks);
180
181 hashmap_free_free(b->vtable_methods);
182 hashmap_free_free(b->vtable_properties);
183
184 while ((n = hashmap_first(b->nodes)))
185 bus_node_destroy(b, n);
186
187 hashmap_free(b->nodes);
188
189 bus_kernel_flush_memfd(b);
190
191 assert_se(pthread_mutex_destroy(&b->memfd_cache_mutex) == 0);
192
193 free(b);
194 }
195
196 _public_ int sd_bus_new(sd_bus **ret) {
197 sd_bus *r;
198
199 assert_return(ret, -EINVAL);
200
201 r = new0(sd_bus, 1);
202 if (!r)
203 return -ENOMEM;
204
205 r->n_ref = REFCNT_INIT;
206 r->input_fd = r->output_fd = -1;
207 r->message_version = 1;
208 r->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
209 r->hello_flags |= KDBUS_HELLO_ACCEPT_FD;
210 r->attach_flags |= KDBUS_ATTACH_NAMES;
211 r->original_pid = getpid();
212
213 assert_se(pthread_mutex_init(&r->memfd_cache_mutex, NULL) == 0);
214
215 /* We guarantee that wqueue always has space for at least one
216 * entry */
217 if (!GREEDY_REALLOC(r->wqueue, r->wqueue_allocated, 1)) {
218 free(r);
219 return -ENOMEM;
220 }
221
222 *ret = r;
223 return 0;
224 }
225
226 _public_ int sd_bus_set_address(sd_bus *bus, const char *address) {
227 char *a;
228
229 assert_return(bus, -EINVAL);
230 assert_return(bus->state == BUS_UNSET, -EPERM);
231 assert_return(address, -EINVAL);
232 assert_return(!bus_pid_changed(bus), -ECHILD);
233
234 a = strdup(address);
235 if (!a)
236 return -ENOMEM;
237
238 free(bus->address);
239 bus->address = a;
240
241 return 0;
242 }
243
244 _public_ int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd) {
245 assert_return(bus, -EINVAL);
246 assert_return(bus->state == BUS_UNSET, -EPERM);
247 assert_return(input_fd >= 0, -EINVAL);
248 assert_return(output_fd >= 0, -EINVAL);
249 assert_return(!bus_pid_changed(bus), -ECHILD);
250
251 bus->input_fd = input_fd;
252 bus->output_fd = output_fd;
253 return 0;
254 }
255
256 _public_ int sd_bus_set_exec(sd_bus *bus, const char *path, char *const argv[]) {
257 char *p, **a;
258
259 assert_return(bus, -EINVAL);
260 assert_return(bus->state == BUS_UNSET, -EPERM);
261 assert_return(path, -EINVAL);
262 assert_return(!strv_isempty(argv), -EINVAL);
263 assert_return(!bus_pid_changed(bus), -ECHILD);
264
265 p = strdup(path);
266 if (!p)
267 return -ENOMEM;
268
269 a = strv_copy(argv);
270 if (!a) {
271 free(p);
272 return -ENOMEM;
273 }
274
275 free(bus->exec_path);
276 strv_free(bus->exec_argv);
277
278 bus->exec_path = p;
279 bus->exec_argv = a;
280
281 return 0;
282 }
283
284 _public_ int sd_bus_set_bus_client(sd_bus *bus, int b) {
285 assert_return(bus, -EINVAL);
286 assert_return(bus->state == BUS_UNSET, -EPERM);
287 assert_return(!bus_pid_changed(bus), -ECHILD);
288
289 bus->bus_client = !!b;
290 return 0;
291 }
292
293 _public_ int sd_bus_set_monitor(sd_bus *bus, int b) {
294 assert_return(bus, -EINVAL);
295 assert_return(bus->state == BUS_UNSET, -EPERM);
296 assert_return(!bus_pid_changed(bus), -ECHILD);
297
298 SET_FLAG(bus->hello_flags, KDBUS_HELLO_MONITOR, b);
299 return 0;
300 }
301
302 _public_ int sd_bus_negotiate_fds(sd_bus *bus, int b) {
303 assert_return(bus, -EINVAL);
304 assert_return(bus->state == BUS_UNSET, -EPERM);
305 assert_return(!bus_pid_changed(bus), -ECHILD);
306
307 SET_FLAG(bus->hello_flags, KDBUS_HELLO_ACCEPT_FD, b);
308 return 0;
309 }
310
311 _public_ int sd_bus_negotiate_timestamp(sd_bus *bus, int b) {
312 assert_return(bus, -EINVAL);
313 assert_return(bus->state == BUS_UNSET, -EPERM);
314 assert_return(!bus_pid_changed(bus), -ECHILD);
315
316 SET_FLAG(bus->attach_flags, KDBUS_ATTACH_TIMESTAMP, b);
317 return 0;
318 }
319
320 _public_ int sd_bus_negotiate_creds(sd_bus *bus, uint64_t mask) {
321 assert_return(bus, -EINVAL);
322 assert_return(mask <= _SD_BUS_CREDS_ALL, -EINVAL);
323 assert_return(bus->state == BUS_UNSET, -EPERM);
324 assert_return(!bus_pid_changed(bus), -ECHILD);
325
326 /* The well knowns we need unconditionally, so that matches can work */
327 bus->creds_mask = mask | SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
328
329 return kdbus_translate_attach_flags(bus->creds_mask, &bus->attach_flags);
330 }
331
332 _public_ int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id) {
333 assert_return(bus, -EINVAL);
334 assert_return(b || sd_id128_equal(server_id, SD_ID128_NULL), -EINVAL);
335 assert_return(bus->state == BUS_UNSET, -EPERM);
336 assert_return(!bus_pid_changed(bus), -ECHILD);
337
338 bus->is_server = !!b;
339 bus->server_id = server_id;
340 return 0;
341 }
342
343 _public_ int sd_bus_set_anonymous(sd_bus *bus, int b) {
344 assert_return(bus, -EINVAL);
345 assert_return(bus->state == BUS_UNSET, -EPERM);
346 assert_return(!bus_pid_changed(bus), -ECHILD);
347
348 bus->anonymous_auth = !!b;
349 return 0;
350 }
351
352 _public_ int sd_bus_set_trusted(sd_bus *bus, int b) {
353 assert_return(bus, -EINVAL);
354 assert_return(bus->state == BUS_UNSET, -EPERM);
355 assert_return(!bus_pid_changed(bus), -ECHILD);
356
357 bus->trusted = !!b;
358 return 0;
359 }
360
361 _public_ int sd_bus_set_name(sd_bus *bus, const char *name) {
362 char *n;
363
364 assert_return(bus, -EINVAL);
365 assert_return(name, -EINVAL);
366 assert_return(bus->state == BUS_UNSET, -EPERM);
367 assert_return(!bus_pid_changed(bus), -ECHILD);
368
369 n = strdup(name);
370 if (!n)
371 return -ENOMEM;
372
373 free(bus->connection_name);
374 bus->connection_name = n;
375
376 return 0;
377 }
378
379 static int hello_callback(sd_bus *bus, sd_bus_message *reply, void *userdata, sd_bus_error *error) {
380 const char *s;
381 int r;
382
383 assert(bus);
384 assert(bus->state == BUS_HELLO || bus->state == BUS_CLOSING);
385 assert(reply);
386
387 r = sd_bus_message_get_errno(reply);
388 if (r < 0)
389 return r;
390 if (r > 0)
391 return -r;
392
393 r = sd_bus_message_read(reply, "s", &s);
394 if (r < 0)
395 return r;
396
397 if (!service_name_is_valid(s) || s[0] != ':')
398 return -EBADMSG;
399
400 bus->unique_name = strdup(s);
401 if (!bus->unique_name)
402 return -ENOMEM;
403
404 if (bus->state == BUS_HELLO)
405 bus->state = BUS_RUNNING;
406
407 return 1;
408 }
409
410 static int bus_send_hello(sd_bus *bus) {
411 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
412 int r;
413
414 assert(bus);
415
416 if (!bus->bus_client || bus->is_kernel)
417 return 0;
418
419 r = sd_bus_message_new_method_call(
420 bus,
421 &m,
422 "org.freedesktop.DBus",
423 "/org/freedesktop/DBus",
424 "org.freedesktop.DBus",
425 "Hello");
426 if (r < 0)
427 return r;
428
429 return sd_bus_call_async(bus, m, hello_callback, NULL, 0, &bus->hello_cookie);
430 }
431
432 int bus_start_running(sd_bus *bus) {
433 assert(bus);
434
435 if (bus->bus_client && !bus->is_kernel) {
436 bus->state = BUS_HELLO;
437 return 1;
438 }
439
440 bus->state = BUS_RUNNING;
441 return 1;
442 }
443
444 static int parse_address_key(const char **p, const char *key, char **value) {
445 size_t l, n = 0, allocated = 0;
446 const char *a;
447 char *r = NULL;
448
449 assert(p);
450 assert(*p);
451 assert(value);
452
453 if (key) {
454 l = strlen(key);
455 if (strncmp(*p, key, l) != 0)
456 return 0;
457
458 if ((*p)[l] != '=')
459 return 0;
460
461 if (*value)
462 return -EINVAL;
463
464 a = *p + l + 1;
465 } else
466 a = *p;
467
468 while (*a != ';' && *a != ',' && *a != 0) {
469 char c;
470
471 if (*a == '%') {
472 int x, y;
473
474 x = unhexchar(a[1]);
475 if (x < 0) {
476 free(r);
477 return x;
478 }
479
480 y = unhexchar(a[2]);
481 if (y < 0) {
482 free(r);
483 return y;
484 }
485
486 c = (char) ((x << 4) | y);
487 a += 3;
488 } else {
489 c = *a;
490 a++;
491 }
492
493 if (!GREEDY_REALLOC(r, allocated, n + 2))
494 return -ENOMEM;
495
496 r[n++] = c;
497 }
498
499 if (!r) {
500 r = strdup("");
501 if (!r)
502 return -ENOMEM;
503 } else
504 r[n] = 0;
505
506 if (*a == ',')
507 a++;
508
509 *p = a;
510
511 free(*value);
512 *value = r;
513
514 return 1;
515 }
516
517 static void skip_address_key(const char **p) {
518 assert(p);
519 assert(*p);
520
521 *p += strcspn(*p, ",");
522
523 if (**p == ',')
524 (*p) ++;
525 }
526
527 static int parse_unix_address(sd_bus *b, const char **p, char **guid) {
528 _cleanup_free_ char *path = NULL, *abstract = NULL;
529 size_t l;
530 int r;
531
532 assert(b);
533 assert(p);
534 assert(*p);
535 assert(guid);
536
537 while (**p != 0 && **p != ';') {
538 r = parse_address_key(p, "guid", guid);
539 if (r < 0)
540 return r;
541 else if (r > 0)
542 continue;
543
544 r = parse_address_key(p, "path", &path);
545 if (r < 0)
546 return r;
547 else if (r > 0)
548 continue;
549
550 r = parse_address_key(p, "abstract", &abstract);
551 if (r < 0)
552 return r;
553 else if (r > 0)
554 continue;
555
556 skip_address_key(p);
557 }
558
559 if (!path && !abstract)
560 return -EINVAL;
561
562 if (path && abstract)
563 return -EINVAL;
564
565 if (path) {
566 l = strlen(path);
567 if (l > sizeof(b->sockaddr.un.sun_path))
568 return -E2BIG;
569
570 b->sockaddr.un.sun_family = AF_UNIX;
571 strncpy(b->sockaddr.un.sun_path, path, sizeof(b->sockaddr.un.sun_path));
572 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l;
573 } else if (abstract) {
574 l = strlen(abstract);
575 if (l > sizeof(b->sockaddr.un.sun_path) - 1)
576 return -E2BIG;
577
578 b->sockaddr.un.sun_family = AF_UNIX;
579 b->sockaddr.un.sun_path[0] = 0;
580 strncpy(b->sockaddr.un.sun_path+1, abstract, sizeof(b->sockaddr.un.sun_path)-1);
581 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + 1 + l;
582 }
583
584 return 0;
585 }
586
587 static int parse_tcp_address(sd_bus *b, const char **p, char **guid) {
588 _cleanup_free_ char *host = NULL, *port = NULL, *family = NULL;
589 int r;
590 struct addrinfo *result, hints = {
591 .ai_socktype = SOCK_STREAM,
592 .ai_flags = AI_ADDRCONFIG,
593 };
594
595 assert(b);
596 assert(p);
597 assert(*p);
598 assert(guid);
599
600 while (**p != 0 && **p != ';') {
601 r = parse_address_key(p, "guid", guid);
602 if (r < 0)
603 return r;
604 else if (r > 0)
605 continue;
606
607 r = parse_address_key(p, "host", &host);
608 if (r < 0)
609 return r;
610 else if (r > 0)
611 continue;
612
613 r = parse_address_key(p, "port", &port);
614 if (r < 0)
615 return r;
616 else if (r > 0)
617 continue;
618
619 r = parse_address_key(p, "family", &family);
620 if (r < 0)
621 return r;
622 else if (r > 0)
623 continue;
624
625 skip_address_key(p);
626 }
627
628 if (!host || !port)
629 return -EINVAL;
630
631 if (family) {
632 if (streq(family, "ipv4"))
633 hints.ai_family = AF_INET;
634 else if (streq(family, "ipv6"))
635 hints.ai_family = AF_INET6;
636 else
637 return -EINVAL;
638 }
639
640 r = getaddrinfo(host, port, &hints, &result);
641 if (r == EAI_SYSTEM)
642 return -errno;
643 else if (r != 0)
644 return -EADDRNOTAVAIL;
645
646 memcpy(&b->sockaddr, result->ai_addr, result->ai_addrlen);
647 b->sockaddr_size = result->ai_addrlen;
648
649 freeaddrinfo(result);
650
651 return 0;
652 }
653
654 static int parse_exec_address(sd_bus *b, const char **p, char **guid) {
655 char *path = NULL;
656 unsigned n_argv = 0, j;
657 char **argv = NULL;
658 size_t allocated = 0;
659 int r;
660
661 assert(b);
662 assert(p);
663 assert(*p);
664 assert(guid);
665
666 while (**p != 0 && **p != ';') {
667 r = parse_address_key(p, "guid", guid);
668 if (r < 0)
669 goto fail;
670 else if (r > 0)
671 continue;
672
673 r = parse_address_key(p, "path", &path);
674 if (r < 0)
675 goto fail;
676 else if (r > 0)
677 continue;
678
679 if (startswith(*p, "argv")) {
680 unsigned ul;
681
682 errno = 0;
683 ul = strtoul(*p + 4, (char**) p, 10);
684 if (errno > 0 || **p != '=' || ul > 256) {
685 r = -EINVAL;
686 goto fail;
687 }
688
689 (*p) ++;
690
691 if (ul >= n_argv) {
692 if (!GREEDY_REALLOC0(argv, allocated, ul + 2)) {
693 r = -ENOMEM;
694 goto fail;
695 }
696
697 n_argv = ul + 1;
698 }
699
700 r = parse_address_key(p, NULL, argv + ul);
701 if (r < 0)
702 goto fail;
703
704 continue;
705 }
706
707 skip_address_key(p);
708 }
709
710 if (!path) {
711 r = -EINVAL;
712 goto fail;
713 }
714
715 /* Make sure there are no holes in the array, with the
716 * exception of argv[0] */
717 for (j = 1; j < n_argv; j++)
718 if (!argv[j]) {
719 r = -EINVAL;
720 goto fail;
721 }
722
723 if (argv && argv[0] == NULL) {
724 argv[0] = strdup(path);
725 if (!argv[0]) {
726 r = -ENOMEM;
727 goto fail;
728 }
729 }
730
731 b->exec_path = path;
732 b->exec_argv = argv;
733 return 0;
734
735 fail:
736 for (j = 0; j < n_argv; j++)
737 free(argv[j]);
738
739 free(argv);
740 free(path);
741 return r;
742 }
743
744 static int parse_kernel_address(sd_bus *b, const char **p, char **guid) {
745 _cleanup_free_ char *path = NULL;
746 int r;
747
748 assert(b);
749 assert(p);
750 assert(*p);
751 assert(guid);
752
753 while (**p != 0 && **p != ';') {
754 r = parse_address_key(p, "guid", guid);
755 if (r < 0)
756 return r;
757 else if (r > 0)
758 continue;
759
760 r = parse_address_key(p, "path", &path);
761 if (r < 0)
762 return r;
763 else if (r > 0)
764 continue;
765
766 skip_address_key(p);
767 }
768
769 if (!path)
770 return -EINVAL;
771
772 free(b->kernel);
773 b->kernel = path;
774 path = NULL;
775
776 return 0;
777 }
778
779 static int parse_container_unix_address(sd_bus *b, const char **p, char **guid) {
780 _cleanup_free_ char *machine = NULL;
781 int r;
782
783 assert(b);
784 assert(p);
785 assert(*p);
786 assert(guid);
787
788 while (**p != 0 && **p != ';') {
789 r = parse_address_key(p, "guid", guid);
790 if (r < 0)
791 return r;
792 else if (r > 0)
793 continue;
794
795 r = parse_address_key(p, "machine", &machine);
796 if (r < 0)
797 return r;
798 else if (r > 0)
799 continue;
800
801 skip_address_key(p);
802 }
803
804 if (!machine)
805 return -EINVAL;
806
807 if (!filename_is_safe(machine))
808 return -EINVAL;
809
810 free(b->machine);
811 b->machine = machine;
812 machine = NULL;
813
814 b->sockaddr.un.sun_family = AF_UNIX;
815 strncpy(b->sockaddr.un.sun_path, "/var/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
816 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + strlen("/var/run/dbus/system_bus_socket");
817
818 return 0;
819 }
820
821 static int parse_container_kernel_address(sd_bus *b, const char **p, char **guid) {
822 _cleanup_free_ char *machine = NULL;
823 int r;
824
825 assert(b);
826 assert(p);
827 assert(*p);
828 assert(guid);
829
830 while (**p != 0 && **p != ';') {
831 r = parse_address_key(p, "guid", guid);
832 if (r < 0)
833 return r;
834 else if (r > 0)
835 continue;
836
837 r = parse_address_key(p, "machine", &machine);
838 if (r < 0)
839 return r;
840 else if (r > 0)
841 continue;
842
843 skip_address_key(p);
844 }
845
846 if (!machine)
847 return -EINVAL;
848
849 if (!filename_is_safe(machine))
850 return -EINVAL;
851
852 free(b->machine);
853 b->machine = machine;
854 machine = NULL;
855
856 free(b->kernel);
857 b->kernel = strdup("/dev/kdbus/0-system/bus");
858 if (!b->kernel)
859 return -ENOMEM;
860
861 return 0;
862 }
863
864 static void bus_reset_parsed_address(sd_bus *b) {
865 assert(b);
866
867 zero(b->sockaddr);
868 b->sockaddr_size = 0;
869 strv_free(b->exec_argv);
870 free(b->exec_path);
871 b->exec_path = NULL;
872 b->exec_argv = NULL;
873 b->server_id = SD_ID128_NULL;
874 free(b->kernel);
875 b->kernel = NULL;
876 free(b->machine);
877 b->machine = NULL;
878 }
879
880 static int bus_parse_next_address(sd_bus *b) {
881 _cleanup_free_ char *guid = NULL;
882 const char *a;
883 int r;
884
885 assert(b);
886
887 if (!b->address)
888 return 0;
889 if (b->address[b->address_index] == 0)
890 return 0;
891
892 bus_reset_parsed_address(b);
893
894 a = b->address + b->address_index;
895
896 while (*a != 0) {
897
898 if (*a == ';') {
899 a++;
900 continue;
901 }
902
903 if (startswith(a, "unix:")) {
904 a += 5;
905
906 r = parse_unix_address(b, &a, &guid);
907 if (r < 0)
908 return r;
909 break;
910
911 } else if (startswith(a, "tcp:")) {
912
913 a += 4;
914 r = parse_tcp_address(b, &a, &guid);
915 if (r < 0)
916 return r;
917
918 break;
919
920 } else if (startswith(a, "unixexec:")) {
921
922 a += 9;
923 r = parse_exec_address(b, &a, &guid);
924 if (r < 0)
925 return r;
926
927 break;
928
929 } else if (startswith(a, "kernel:")) {
930
931 a += 7;
932 r = parse_kernel_address(b, &a, &guid);
933 if (r < 0)
934 return r;
935
936 break;
937 } else if (startswith(a, "x-container-unix:")) {
938
939 a += 17;
940 r = parse_container_unix_address(b, &a, &guid);
941 if (r < 0)
942 return r;
943
944 break;
945 } else if (startswith(a, "x-container-kernel:")) {
946
947 a += 19;
948 r = parse_container_kernel_address(b, &a, &guid);
949 if (r < 0)
950 return r;
951
952 break;
953 }
954
955 a = strchr(a, ';');
956 if (!a)
957 return 0;
958 }
959
960 if (guid) {
961 r = sd_id128_from_string(guid, &b->server_id);
962 if (r < 0)
963 return r;
964 }
965
966 b->address_index = a - b->address;
967 return 1;
968 }
969
970 static int bus_start_address(sd_bus *b) {
971 int r;
972
973 assert(b);
974
975 for (;;) {
976 bool skipped = false;
977
978 bus_close_fds(b);
979
980 if (b->exec_path)
981 r = bus_socket_exec(b);
982 else if (b->machine && b->kernel)
983 r = bus_container_connect_kernel(b);
984 else if (b->machine && b->sockaddr.sa.sa_family != AF_UNSPEC)
985 r = bus_container_connect_socket(b);
986 else if (b->kernel)
987 r = bus_kernel_connect(b);
988 else if (b->sockaddr.sa.sa_family != AF_UNSPEC)
989 r = bus_socket_connect(b);
990 else
991 skipped = true;
992
993 if (!skipped) {
994 if (r >= 0) {
995 r = attach_io_events(b);
996 if (r >= 0)
997 return r;
998 }
999
1000 b->last_connect_error = -r;
1001 }
1002
1003 r = bus_parse_next_address(b);
1004 if (r < 0)
1005 return r;
1006 if (r == 0)
1007 return b->last_connect_error ? -b->last_connect_error : -ECONNREFUSED;
1008 }
1009 }
1010
1011 int bus_next_address(sd_bus *b) {
1012 assert(b);
1013
1014 bus_reset_parsed_address(b);
1015 return bus_start_address(b);
1016 }
1017
1018 static int bus_start_fd(sd_bus *b) {
1019 struct stat st;
1020 int r;
1021
1022 assert(b);
1023 assert(b->input_fd >= 0);
1024 assert(b->output_fd >= 0);
1025
1026 r = fd_nonblock(b->input_fd, true);
1027 if (r < 0)
1028 return r;
1029
1030 r = fd_cloexec(b->input_fd, true);
1031 if (r < 0)
1032 return r;
1033
1034 if (b->input_fd != b->output_fd) {
1035 r = fd_nonblock(b->output_fd, true);
1036 if (r < 0)
1037 return r;
1038
1039 r = fd_cloexec(b->output_fd, true);
1040 if (r < 0)
1041 return r;
1042 }
1043
1044 if (fstat(b->input_fd, &st) < 0)
1045 return -errno;
1046
1047 if (S_ISCHR(b->input_fd))
1048 return bus_kernel_take_fd(b);
1049 else
1050 return bus_socket_take_fd(b);
1051 }
1052
1053 _public_ int sd_bus_start(sd_bus *bus) {
1054 int r;
1055
1056 assert_return(bus, -EINVAL);
1057 assert_return(bus->state == BUS_UNSET, -EPERM);
1058 assert_return(!bus_pid_changed(bus), -ECHILD);
1059
1060 bus->state = BUS_OPENING;
1061
1062 if (bus->is_server && bus->bus_client)
1063 return -EINVAL;
1064
1065 if (bus->input_fd >= 0)
1066 r = bus_start_fd(bus);
1067 else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel || bus->machine)
1068 r = bus_start_address(bus);
1069 else
1070 return -EINVAL;
1071
1072 if (r < 0)
1073 return r;
1074
1075 return bus_send_hello(bus);
1076 }
1077
1078 _public_ int sd_bus_open(sd_bus **ret) {
1079 const char *e;
1080 sd_bus *b;
1081 int r;
1082
1083 assert_return(ret, -EINVAL);
1084
1085 /* Let's connect to the starter bus if it is set, and
1086 * otherwise to the bus that is appropropriate for the scope
1087 * we are running in */
1088
1089 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
1090 if (e) {
1091 if (streq(e, "system"))
1092 return sd_bus_open_system(ret);
1093 else if (STR_IN_SET(e, "session", "user"))
1094 return sd_bus_open_user(ret);
1095 }
1096
1097 e = secure_getenv("DBUS_STARTER_ADDRESS");
1098 if (!e) {
1099 if (cg_pid_get_owner_uid(0, NULL) >= 0)
1100 return sd_bus_open_user(ret);
1101 else
1102 return sd_bus_open_system(ret);
1103 }
1104
1105 r = sd_bus_new(&b);
1106 if (r < 0)
1107 return r;
1108
1109 r = sd_bus_set_address(b, e);
1110 if (r < 0)
1111 goto fail;
1112
1113 b->bus_client = true;
1114
1115 /* We don't know whether the bus is trusted or not, so better
1116 * be safe, and authenticate everything */
1117 b->trusted = false;
1118 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1119
1120 r = sd_bus_start(b);
1121 if (r < 0)
1122 goto fail;
1123
1124 *ret = b;
1125 return 0;
1126
1127 fail:
1128 bus_free(b);
1129 return r;
1130 }
1131
1132 int bus_set_address_system(sd_bus *b) {
1133 const char *e;
1134 assert(b);
1135
1136 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1137 if (e)
1138 return sd_bus_set_address(b, e);
1139
1140 return sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_PATH);
1141 }
1142
1143 _public_ int sd_bus_open_system(sd_bus **ret) {
1144 sd_bus *b;
1145 int r;
1146
1147 assert_return(ret, -EINVAL);
1148
1149 r = sd_bus_new(&b);
1150 if (r < 0)
1151 return r;
1152
1153 r = bus_set_address_system(b);
1154 if (r < 0)
1155 goto fail;
1156
1157 b->bus_client = true;
1158 b->is_system = true;
1159
1160 /* Let's do per-method access control on the system bus. We
1161 * need the caller's UID and capability set for that. */
1162 b->trusted = false;
1163 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1164
1165 r = sd_bus_start(b);
1166 if (r < 0)
1167 goto fail;
1168
1169 *ret = b;
1170 return 0;
1171
1172 fail:
1173 bus_free(b);
1174 return r;
1175 }
1176
1177 int bus_set_address_user(sd_bus *b) {
1178 const char *e;
1179
1180 assert(b);
1181
1182 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1183 if (e)
1184 return sd_bus_set_address(b, e);
1185
1186 e = secure_getenv("XDG_RUNTIME_DIR");
1187 if (e) {
1188 _cleanup_free_ char *ee = NULL;
1189
1190 ee = bus_address_escape(e);
1191 if (!ee)
1192 return -ENOMEM;
1193
1194 #ifdef ENABLE_KDBUS
1195 asprintf(&b->address, KERNEL_USER_BUS_FMT ";" UNIX_USER_BUS_FMT, (unsigned long) getuid(), ee);
1196 #else
1197 asprintf(&b->address, UNIX_USER_BUS_FMT, ee);
1198 #endif
1199 } else {
1200 #ifdef ENABLE_KDBUS
1201 asprintf(&b->address, KERNEL_USER_BUS_FMT, (unsigned long) getuid());
1202 #else
1203 return -ECONNREFUSED;
1204 #endif
1205 }
1206
1207 if (!b->address)
1208 return -ENOMEM;
1209
1210 return 0;
1211 }
1212
1213 _public_ int sd_bus_open_user(sd_bus **ret) {
1214 sd_bus *b;
1215 int r;
1216
1217 assert_return(ret, -EINVAL);
1218
1219 r = sd_bus_new(&b);
1220 if (r < 0)
1221 return r;
1222
1223 r = bus_set_address_user(b);
1224 if (r < 0)
1225 return r;
1226
1227 b->bus_client = true;
1228 b->is_user = true;
1229
1230 /* We don't do any per-method access control on the user
1231 * bus. */
1232 b->trusted = true;
1233
1234 r = sd_bus_start(b);
1235 if (r < 0)
1236 goto fail;
1237
1238 *ret = b;
1239 return 0;
1240
1241 fail:
1242 bus_free(b);
1243 return r;
1244 }
1245
1246 int bus_set_address_system_remote(sd_bus *b, const char *host) {
1247 _cleanup_free_ char *e = NULL;
1248
1249 assert(b);
1250 assert(host);
1251
1252 e = bus_address_escape(host);
1253 if (!e)
1254 return -ENOMEM;
1255
1256 b->address = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", NULL);
1257 if (!b->address)
1258 return -ENOMEM;
1259
1260 return 0;
1261 }
1262
1263 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1264 sd_bus *bus;
1265 int r;
1266
1267 assert_return(host, -EINVAL);
1268 assert_return(ret, -EINVAL);
1269
1270 r = sd_bus_new(&bus);
1271 if (r < 0)
1272 return r;
1273
1274 r = bus_set_address_system_remote(bus, host);
1275 if (r < 0)
1276 goto fail;
1277
1278 bus->bus_client = true;
1279 bus->trusted = false;
1280
1281 r = sd_bus_start(bus);
1282 if (r < 0)
1283 goto fail;
1284
1285 *ret = bus;
1286 return 0;
1287
1288 fail:
1289 bus_free(bus);
1290 return r;
1291 }
1292
1293 int bus_set_address_system_container(sd_bus *b, const char *machine) {
1294 _cleanup_free_ char *e = NULL;
1295
1296 assert(b);
1297 assert(machine);
1298
1299 e = bus_address_escape(machine);
1300 if (!e)
1301 return -ENOMEM;
1302
1303 #ifdef ENABLE_KDBUS
1304 b->address = strjoin("x-container-kernel:machine=", e, ";x-container-unix:machine=", e, NULL);
1305 #else
1306 b->address = strjoin("x-container-unix:machine=", e, NULL);
1307 #endif
1308 if (!b->address)
1309 return -ENOMEM;
1310
1311 return 0;
1312 }
1313
1314 _public_ int sd_bus_open_system_container(sd_bus **ret, const char *machine) {
1315 sd_bus *bus;
1316 int r;
1317
1318 assert_return(machine, -EINVAL);
1319 assert_return(ret, -EINVAL);
1320 assert_return(filename_is_safe(machine), -EINVAL);
1321
1322 r = sd_bus_new(&bus);
1323 if (r < 0)
1324 return r;
1325
1326 r = bus_set_address_system_container(bus, machine);
1327 if (r < 0)
1328 goto fail;
1329
1330 bus->bus_client = true;
1331 bus->trusted = false;
1332
1333 r = sd_bus_start(bus);
1334 if (r < 0)
1335 goto fail;
1336
1337 *ret = bus;
1338 return 0;
1339
1340 fail:
1341 bus_free(bus);
1342 return r;
1343 }
1344
1345 _public_ void sd_bus_close(sd_bus *bus) {
1346
1347 if (!bus)
1348 return;
1349 if (bus->state == BUS_CLOSED)
1350 return;
1351 if (bus_pid_changed(bus))
1352 return;
1353
1354 bus->state = BUS_CLOSED;
1355
1356 sd_bus_detach_event(bus);
1357
1358 /* Drop all queued messages so that they drop references to
1359 * the bus object and the bus may be freed */
1360 bus_reset_queues(bus);
1361
1362 if (!bus->is_kernel)
1363 bus_close_fds(bus);
1364
1365 /* We'll leave the fd open in case this is a kernel bus, since
1366 * there might still be memblocks around that reference this
1367 * bus, and they might need to invoke the KDBUS_CMD_FREE
1368 * ioctl on the fd when they are freed. */
1369 }
1370
1371 static void bus_enter_closing(sd_bus *bus) {
1372 assert(bus);
1373
1374 if (bus->state != BUS_OPENING &&
1375 bus->state != BUS_AUTHENTICATING &&
1376 bus->state != BUS_HELLO &&
1377 bus->state != BUS_RUNNING)
1378 return;
1379
1380 bus->state = BUS_CLOSING;
1381 }
1382
1383 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1384 assert_return(bus, NULL);
1385
1386 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1387
1388 return bus;
1389 }
1390
1391 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1392 unsigned i;
1393
1394 if (!bus)
1395 return NULL;
1396
1397 /* TODO/FIXME: It's naive to think REFCNT_GET() is thread-safe in any
1398 * way but exclusive REFCNT_DEC(). The current logic _must_ lock around
1399 * REFCNT_GET() until REFCNT_DEC() or two threads might end up in
1400 * parallel in bus_reset_queues(). But locking would totally break the
1401 * recursion we introduce by bus_reset_queues()...
1402 * (Imagine one thread in sd_bus_message_unref() setting n_ref to 0 and
1403 * thus calling into sd_bus_unref(). If at the same time the real
1404 * thread calls sd_bus_unref(), both end up with "q == true" and will
1405 * call into bus_reset_queues().
1406 * If we require the main bus to be alive until all dispatch threads
1407 * are done, there is no need to do ref-counts at all. So in both ways,
1408 * the REFCNT thing is humbug.)
1409 *
1410 * On a second note: messages are *not* required to have ->bus set nor
1411 * does it have to be _this_ bus that they're assigned to. This whole
1412 * ref-cnt checking breaks apart if a message is not assigned to us.
1413 * (which is _very_ easy to trigger with the current API). */
1414
1415 if (REFCNT_GET(bus->n_ref) == bus->rqueue_size + bus->wqueue_size + 1) {
1416 bool q = true;
1417
1418 for (i = 0; i < bus->rqueue_size; i++)
1419 if (bus->rqueue[i]->n_ref > 1) {
1420 q = false;
1421 break;
1422 }
1423
1424 if (q) {
1425 for (i = 0; i < bus->wqueue_size; i++)
1426 if (bus->wqueue[i]->n_ref > 1) {
1427 q = false;
1428 break;
1429 }
1430 }
1431
1432 /* We are the only holders on the messages, and the
1433 * messages are the only holders on us, so let's drop
1434 * the messages and thus implicitly also kill our own
1435 * last references.
1436 * bus_reset_queues() decrements the queue-size before
1437 * calling into sd_bus_message_unref(). Thus, it
1438 * protects us from recursion. */
1439
1440 if (q)
1441 bus_reset_queues(bus);
1442 }
1443
1444 i = REFCNT_DEC(bus->n_ref);
1445 if (i > 0)
1446 return NULL;
1447
1448 bus_free(bus);
1449 return NULL;
1450 }
1451
1452 _public_ int sd_bus_is_open(sd_bus *bus) {
1453
1454 assert_return(bus, -EINVAL);
1455 assert_return(!bus_pid_changed(bus), -ECHILD);
1456
1457 return BUS_IS_OPEN(bus->state);
1458 }
1459
1460 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1461 int r;
1462
1463 assert_return(bus, -EINVAL);
1464 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1465 assert_return(!bus_pid_changed(bus), -ECHILD);
1466
1467 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
1468 return 0;
1469
1470 if (type == SD_BUS_TYPE_UNIX_FD) {
1471 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1472 return 0;
1473
1474 r = bus_ensure_running(bus);
1475 if (r < 0)
1476 return r;
1477
1478 return bus->can_fds;
1479 }
1480
1481 return bus_type_is_valid(type);
1482 }
1483
1484 _public_ int sd_bus_get_server_id(sd_bus *bus, sd_id128_t *server_id) {
1485 int r;
1486
1487 assert_return(bus, -EINVAL);
1488 assert_return(server_id, -EINVAL);
1489 assert_return(!bus_pid_changed(bus), -ECHILD);
1490
1491 r = bus_ensure_running(bus);
1492 if (r < 0)
1493 return r;
1494
1495 *server_id = bus->server_id;
1496 return 0;
1497 }
1498
1499 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1500 assert(b);
1501 assert(m);
1502
1503 if (m->sealed) {
1504 /* If we copy the same message to multiple
1505 * destinations, avoid using the same cookie
1506 * numbers. */
1507 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1508 return 0;
1509 }
1510
1511 if (timeout == 0)
1512 timeout = BUS_DEFAULT_TIMEOUT;
1513
1514 return bus_message_seal(m, ++b->cookie, timeout);
1515 }
1516
1517 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1518 assert(b);
1519
1520 /* Do packet version and endianness already match? */
1521 if ((b->message_version == 0 || b->message_version == (*m)->header->version) &&
1522 (b->message_endian == 0 || b->message_endian == (*m)->header->endian))
1523 return 0;
1524
1525 /* No? Then remarshal! */
1526 return bus_message_remarshal(b, m);
1527 }
1528
1529 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1530 assert(b);
1531 assert(m);
1532
1533 /* The bus specification says the serial number cannot be 0,
1534 * hence let's fill something in for synthetic messages. Since
1535 * synthetic messages might have a fake sender and we don't
1536 * want to interfere with the real sender's serial numbers we
1537 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1538 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1539 * even though kdbus can do 64bit. */
1540
1541 return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1542 }
1543
1544 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1545 int r;
1546
1547 assert(bus);
1548 assert(m);
1549
1550 if (bus->is_kernel)
1551 r = bus_kernel_write_message(bus, m, hint_sync_call);
1552 else
1553 r = bus_socket_write_message(bus, m, idx);
1554
1555 if (r <= 0)
1556 return r;
1557
1558 if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1559 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
1560 bus_message_type_to_string(m->header->type),
1561 strna(sd_bus_message_get_sender(m)),
1562 strna(sd_bus_message_get_destination(m)),
1563 strna(sd_bus_message_get_path(m)),
1564 strna(sd_bus_message_get_interface(m)),
1565 strna(sd_bus_message_get_member(m)),
1566 BUS_MESSAGE_COOKIE(m),
1567 m->reply_cookie,
1568 strna(m->error.message));
1569
1570 return r;
1571 }
1572
1573 static int dispatch_wqueue(sd_bus *bus) {
1574 int r, ret = 0;
1575
1576 assert(bus);
1577 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1578
1579 while (bus->wqueue_size > 0) {
1580
1581 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1582 if (r < 0)
1583 return r;
1584 else if (r == 0)
1585 /* Didn't do anything this time */
1586 return ret;
1587 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1588 /* Fully written. Let's drop the entry from
1589 * the queue.
1590 *
1591 * This isn't particularly optimized, but
1592 * well, this is supposed to be our worst-case
1593 * buffer only, and the socket buffer is
1594 * supposed to be our primary buffer, and if
1595 * it got full, then all bets are off
1596 * anyway. */
1597
1598 bus->wqueue_size --;
1599 sd_bus_message_unref(bus->wqueue[0]);
1600 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1601 bus->windex = 0;
1602
1603 ret = 1;
1604 }
1605 }
1606
1607 return ret;
1608 }
1609
1610 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1611 assert(bus);
1612
1613 if (bus->is_kernel)
1614 return bus_kernel_read_message(bus, hint_priority, priority);
1615 else
1616 return bus_socket_read_message(bus);
1617 }
1618
1619 int bus_rqueue_make_room(sd_bus *bus) {
1620 assert(bus);
1621
1622 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1623 return -ENOBUFS;
1624
1625 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1626 return -ENOMEM;
1627
1628 return 0;
1629 }
1630
1631 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1632 int r, ret = 0;
1633
1634 assert(bus);
1635 assert(m);
1636 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1637
1638 /* Note that the priority logic is only available on kdbus,
1639 * where the rqueue is unused. We check the rqueue here
1640 * anyway, because it's simple... */
1641
1642 for (;;) {
1643 if (bus->rqueue_size > 0) {
1644 /* Dispatch a queued message */
1645
1646 *m = bus->rqueue[0];
1647 bus->rqueue_size --;
1648 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1649 return 1;
1650 }
1651
1652 /* Try to read a new message */
1653 r = bus_read_message(bus, hint_priority, priority);
1654 if (r < 0)
1655 return r;
1656 if (r == 0)
1657 return ret;
1658
1659 ret = 1;
1660 }
1661 }
1662
1663 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1664 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1665 int r;
1666
1667 assert_return(bus, -EINVAL);
1668 assert_return(m, -EINVAL);
1669 assert_return(!bus_pid_changed(bus), -ECHILD);
1670 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1671
1672 if (!BUS_IS_OPEN(bus->state))
1673 return -ENOTCONN;
1674
1675 if (m->n_fds > 0) {
1676 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1677 if (r < 0)
1678 return r;
1679 if (r == 0)
1680 return -ENOTSUP;
1681 }
1682
1683 /* If the cookie number isn't kept, then we know that no reply
1684 * is expected */
1685 if (!cookie && !m->sealed)
1686 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1687
1688 r = bus_seal_message(bus, m, 0);
1689 if (r < 0)
1690 return r;
1691
1692 /* Remarshall if we have to. This will possibly unref the
1693 * message and place a replacement in m */
1694 r = bus_remarshal_message(bus, &m);
1695 if (r < 0)
1696 return r;
1697
1698 /* If this is a reply and no reply was requested, then let's
1699 * suppress this, if we can */
1700 if (m->dont_send && !cookie)
1701 return 1;
1702
1703 if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1704 size_t idx = 0;
1705
1706 r = bus_write_message(bus, m, hint_sync_call, &idx);
1707 if (r < 0) {
1708 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1709 bus_enter_closing(bus);
1710 return -ECONNRESET;
1711 }
1712
1713 return r;
1714 } else if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1715 /* Wasn't fully written. So let's remember how
1716 * much was written. Note that the first entry
1717 * of the wqueue array is always allocated so
1718 * that we always can remember how much was
1719 * written. */
1720 bus->wqueue[0] = sd_bus_message_ref(m);
1721 bus->wqueue_size = 1;
1722 bus->windex = idx;
1723 }
1724 } else {
1725 /* Just append it to the queue. */
1726
1727 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1728 return -ENOBUFS;
1729
1730 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1731 return -ENOMEM;
1732
1733 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1734 }
1735
1736 if (cookie)
1737 *cookie = BUS_MESSAGE_COOKIE(m);
1738
1739 return 1;
1740 }
1741
1742 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1743 return bus_send_internal(bus, m, cookie, false);
1744 }
1745
1746 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1747 int r;
1748
1749 assert_return(bus, -EINVAL);
1750 assert_return(m, -EINVAL);
1751 assert_return(!bus_pid_changed(bus), -ECHILD);
1752
1753 if (!BUS_IS_OPEN(bus->state))
1754 return -ENOTCONN;
1755
1756 if (!streq_ptr(m->destination, destination)) {
1757
1758 if (!destination)
1759 return -EEXIST;
1760
1761 r = sd_bus_message_set_destination(m, destination);
1762 if (r < 0)
1763 return r;
1764 }
1765
1766 return sd_bus_send(bus, m, cookie);
1767 }
1768
1769 static usec_t calc_elapse(uint64_t usec) {
1770 if (usec == (uint64_t) -1)
1771 return 0;
1772
1773 return now(CLOCK_MONOTONIC) + usec;
1774 }
1775
1776 static int timeout_compare(const void *a, const void *b) {
1777 const struct reply_callback *x = a, *y = b;
1778
1779 if (x->timeout != 0 && y->timeout == 0)
1780 return -1;
1781
1782 if (x->timeout == 0 && y->timeout != 0)
1783 return 1;
1784
1785 if (x->timeout < y->timeout)
1786 return -1;
1787
1788 if (x->timeout > y->timeout)
1789 return 1;
1790
1791 return 0;
1792 }
1793
1794 _public_ int sd_bus_call_async(
1795 sd_bus *bus,
1796 sd_bus_message *_m,
1797 sd_bus_message_handler_t callback,
1798 void *userdata,
1799 uint64_t usec,
1800 uint64_t *cookie) {
1801
1802 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1803 struct reply_callback *c;
1804 int r;
1805
1806 assert_return(bus, -EINVAL);
1807 assert_return(m, -EINVAL);
1808 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1809 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1810 assert_return(callback, -EINVAL);
1811 assert_return(!bus_pid_changed(bus), -ECHILD);
1812 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1813
1814 if (!BUS_IS_OPEN(bus->state))
1815 return -ENOTCONN;
1816
1817 r = hashmap_ensure_allocated(&bus->reply_callbacks, uint64_hash_func, uint64_compare_func);
1818 if (r < 0)
1819 return r;
1820
1821 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1822 if (r < 0)
1823 return r;
1824
1825 r = bus_seal_message(bus, m, usec);
1826 if (r < 0)
1827 return r;
1828
1829 r = bus_remarshal_message(bus, &m);
1830 if (r < 0)
1831 return r;
1832
1833 c = new0(struct reply_callback, 1);
1834 if (!c)
1835 return -ENOMEM;
1836
1837 c->callback = callback;
1838 c->userdata = userdata;
1839 c->cookie = BUS_MESSAGE_COOKIE(m);
1840 c->timeout = calc_elapse(m->timeout);
1841
1842 r = hashmap_put(bus->reply_callbacks, &c->cookie, c);
1843 if (r < 0) {
1844 free(c);
1845 return r;
1846 }
1847
1848 if (c->timeout != 0) {
1849 r = prioq_put(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1850 if (r < 0) {
1851 c->timeout = 0;
1852 sd_bus_call_async_cancel(bus, c->cookie);
1853 return r;
1854 }
1855 }
1856
1857 r = sd_bus_send(bus, m, cookie);
1858 if (r < 0) {
1859 sd_bus_call_async_cancel(bus, c->cookie);
1860 return r;
1861 }
1862
1863 return r;
1864 }
1865
1866 _public_ int sd_bus_call_async_cancel(sd_bus *bus, uint64_t cookie) {
1867 struct reply_callback *c;
1868
1869 assert_return(bus, -EINVAL);
1870 assert_return(cookie != 0, -EINVAL);
1871 assert_return(!bus_pid_changed(bus), -ECHILD);
1872
1873 c = hashmap_remove(bus->reply_callbacks, &cookie);
1874 if (!c)
1875 return 0;
1876
1877 if (c->timeout != 0)
1878 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1879
1880 free(c);
1881 return 1;
1882 }
1883
1884 int bus_ensure_running(sd_bus *bus) {
1885 int r;
1886
1887 assert(bus);
1888
1889 if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1890 return -ENOTCONN;
1891 if (bus->state == BUS_RUNNING)
1892 return 1;
1893
1894 for (;;) {
1895 r = sd_bus_process(bus, NULL);
1896 if (r < 0)
1897 return r;
1898 if (bus->state == BUS_RUNNING)
1899 return 1;
1900 if (r > 0)
1901 continue;
1902
1903 r = sd_bus_wait(bus, (uint64_t) -1);
1904 if (r < 0)
1905 return r;
1906 }
1907 }
1908
1909 _public_ int sd_bus_call(
1910 sd_bus *bus,
1911 sd_bus_message *_m,
1912 uint64_t usec,
1913 sd_bus_error *error,
1914 sd_bus_message **reply) {
1915
1916 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1917 usec_t timeout;
1918 uint64_t cookie;
1919 unsigned i;
1920 int r;
1921
1922 assert_return(bus, -EINVAL);
1923 assert_return(m, -EINVAL);
1924 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1925 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1926 assert_return(!bus_error_is_dirty(error), -EINVAL);
1927 assert_return(!bus_pid_changed(bus), -ECHILD);
1928 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1929
1930 if (!BUS_IS_OPEN(bus->state))
1931 return -ENOTCONN;
1932
1933 r = bus_ensure_running(bus);
1934 if (r < 0)
1935 return r;
1936
1937 i = bus->rqueue_size;
1938
1939 r = bus_seal_message(bus, m, usec);
1940 if (r < 0)
1941 return r;
1942
1943 r = bus_remarshal_message(bus, &m);
1944 if (r < 0)
1945 return r;
1946
1947 r = bus_send_internal(bus, m, &cookie, true);
1948 if (r < 0)
1949 return r;
1950
1951 timeout = calc_elapse(m->timeout);
1952
1953 for (;;) {
1954 usec_t left;
1955
1956 while (i < bus->rqueue_size) {
1957 sd_bus_message *incoming = NULL;
1958
1959 incoming = bus->rqueue[i];
1960
1961 if (incoming->reply_cookie == cookie) {
1962 /* Found a match! */
1963
1964 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1965 bus->rqueue_size--;
1966
1967 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
1968
1969 if (incoming->n_fds <= 0 || (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
1970 if (reply)
1971 *reply = incoming;
1972 else
1973 sd_bus_message_unref(incoming);
1974
1975 return 1;
1976 }
1977
1978 r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry.");
1979
1980 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
1981 r = sd_bus_error_copy(error, &incoming->error);
1982 else
1983 r = -EIO;
1984
1985 sd_bus_message_unref(incoming);
1986 return r;
1987
1988 } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
1989 bus->unique_name &&
1990 incoming->sender &&
1991 streq(bus->unique_name, incoming->sender)) {
1992
1993 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1994 bus->rqueue_size--;
1995
1996 /* Our own message? Somebody is trying
1997 * to send its own client a message,
1998 * let's not dead-lock, let's fail
1999 * immediately. */
2000
2001 sd_bus_message_unref(incoming);
2002 return -ELOOP;
2003 }
2004
2005 /* Try to read more, right-away */
2006 i++;
2007 }
2008
2009 r = bus_read_message(bus, false, 0);
2010 if (r < 0) {
2011 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2012 bus_enter_closing(bus);
2013 return -ECONNRESET;
2014 }
2015
2016 return r;
2017 }
2018 if (r > 0)
2019 continue;
2020
2021 if (timeout > 0) {
2022 usec_t n;
2023
2024 n = now(CLOCK_MONOTONIC);
2025 if (n >= timeout)
2026 return -ETIMEDOUT;
2027
2028 left = timeout - n;
2029 } else
2030 left = (uint64_t) -1;
2031
2032 r = bus_poll(bus, true, left);
2033 if (r < 0)
2034 return r;
2035 if (r == 0)
2036 return -ETIMEDOUT;
2037
2038 r = dispatch_wqueue(bus);
2039 if (r < 0) {
2040 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2041 bus_enter_closing(bus);
2042 return -ECONNRESET;
2043 }
2044
2045 return r;
2046 }
2047 }
2048 }
2049
2050 _public_ int sd_bus_get_fd(sd_bus *bus) {
2051
2052 assert_return(bus, -EINVAL);
2053 assert_return(bus->input_fd == bus->output_fd, -EPERM);
2054 assert_return(!bus_pid_changed(bus), -ECHILD);
2055
2056 return bus->input_fd;
2057 }
2058
2059 _public_ int sd_bus_get_events(sd_bus *bus) {
2060 int flags = 0;
2061
2062 assert_return(bus, -EINVAL);
2063 assert_return(!bus_pid_changed(bus), -ECHILD);
2064
2065 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2066 return -ENOTCONN;
2067
2068 if (bus->state == BUS_OPENING)
2069 flags |= POLLOUT;
2070 else if (bus->state == BUS_AUTHENTICATING) {
2071
2072 if (bus_socket_auth_needs_write(bus))
2073 flags |= POLLOUT;
2074
2075 flags |= POLLIN;
2076
2077 } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
2078 if (bus->rqueue_size <= 0)
2079 flags |= POLLIN;
2080 if (bus->wqueue_size > 0)
2081 flags |= POLLOUT;
2082 }
2083
2084 return flags;
2085 }
2086
2087 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2088 struct reply_callback *c;
2089
2090 assert_return(bus, -EINVAL);
2091 assert_return(timeout_usec, -EINVAL);
2092 assert_return(!bus_pid_changed(bus), -ECHILD);
2093
2094 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2095 return -ENOTCONN;
2096
2097 if (bus->track_queue) {
2098 *timeout_usec = 0;
2099 return 1;
2100 }
2101
2102 if (bus->state == BUS_CLOSING) {
2103 *timeout_usec = 0;
2104 return 1;
2105 }
2106
2107 if (bus->state == BUS_AUTHENTICATING) {
2108 *timeout_usec = bus->auth_timeout;
2109 return 1;
2110 }
2111
2112 if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
2113 *timeout_usec = (uint64_t) -1;
2114 return 0;
2115 }
2116
2117 if (bus->rqueue_size > 0) {
2118 *timeout_usec = 0;
2119 return 1;
2120 }
2121
2122 c = prioq_peek(bus->reply_callbacks_prioq);
2123 if (!c) {
2124 *timeout_usec = (uint64_t) -1;
2125 return 0;
2126 }
2127
2128 *timeout_usec = c->timeout;
2129 return 1;
2130 }
2131
2132 static int process_timeout(sd_bus *bus) {
2133 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2134 _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
2135 struct reply_callback *c;
2136 usec_t n;
2137 int r;
2138
2139 assert(bus);
2140
2141 c = prioq_peek(bus->reply_callbacks_prioq);
2142 if (!c)
2143 return 0;
2144
2145 n = now(CLOCK_MONOTONIC);
2146 if (c->timeout > n)
2147 return 0;
2148
2149 r = bus_message_new_synthetic_error(
2150 bus,
2151 c->cookie,
2152 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2153 &m);
2154 if (r < 0)
2155 return r;
2156
2157 m->sender = "org.freedesktop.DBus";
2158
2159 r = bus_seal_synthetic_message(bus, m);
2160 if (r < 0)
2161 return r;
2162
2163 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2164 hashmap_remove(bus->reply_callbacks, &c->cookie);
2165
2166 bus->current = m;
2167 bus->iteration_counter ++;
2168
2169 r = c->callback(bus, m, c->userdata, &error_buffer);
2170 r = bus_maybe_reply_error(m, r, &error_buffer);
2171 free(c);
2172
2173 bus->current = NULL;
2174
2175 return r;
2176 }
2177
2178 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2179 assert(bus);
2180 assert(m);
2181
2182 if (bus->state != BUS_HELLO)
2183 return 0;
2184
2185 /* Let's make sure the first message on the bus is the HELLO
2186 * reply. But note that we don't actually parse the message
2187 * here (we leave that to the usual handling), we just verify
2188 * we don't let any earlier msg through. */
2189
2190 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2191 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2192 return -EIO;
2193
2194 if (m->reply_cookie != bus->hello_cookie)
2195 return -EIO;
2196
2197 return 0;
2198 }
2199
2200 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2201 _cleanup_bus_message_unref_ sd_bus_message *synthetic_reply = NULL;
2202 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2203 _cleanup_free_ struct reply_callback *c = NULL;
2204 int r;
2205
2206 assert(bus);
2207 assert(m);
2208
2209 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2210 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2211 return 0;
2212
2213 if (bus->is_kernel && (bus->hello_flags & KDBUS_HELLO_MONITOR))
2214 return 0;
2215
2216 if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2217 return 0;
2218
2219 c = hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2220 if (!c)
2221 return 0;
2222
2223 if (c->timeout != 0)
2224 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2225
2226 if (m->n_fds > 0 && !(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2227
2228 /* If the reply contained a file descriptor which we
2229 * didn't want we pass an error instead. */
2230
2231 r = bus_message_new_synthetic_error(
2232 bus,
2233 m->reply_cookie,
2234 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2235 &synthetic_reply);
2236 if (r < 0)
2237 return r;
2238
2239 r = bus_seal_synthetic_message(bus, synthetic_reply);
2240 if (r < 0)
2241 return r;
2242
2243 m = synthetic_reply;
2244 } else {
2245 r = sd_bus_message_rewind(m, true);
2246 if (r < 0)
2247 return r;
2248 }
2249
2250 r = c->callback(bus, m, c->userdata, &error_buffer);
2251 r = bus_maybe_reply_error(m, r, &error_buffer);
2252
2253 return r;
2254 }
2255
2256 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2257 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2258 struct filter_callback *l;
2259 int r;
2260
2261 assert(bus);
2262 assert(m);
2263
2264 do {
2265 bus->filter_callbacks_modified = false;
2266
2267 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2268
2269 if (bus->filter_callbacks_modified)
2270 break;
2271
2272 /* Don't run this more than once per iteration */
2273 if (l->last_iteration == bus->iteration_counter)
2274 continue;
2275
2276 l->last_iteration = bus->iteration_counter;
2277
2278 r = sd_bus_message_rewind(m, true);
2279 if (r < 0)
2280 return r;
2281
2282 r = l->callback(bus, m, l->userdata, &error_buffer);
2283 r = bus_maybe_reply_error(m, r, &error_buffer);
2284 if (r != 0)
2285 return r;
2286
2287 }
2288
2289 } while (bus->filter_callbacks_modified);
2290
2291 return 0;
2292 }
2293
2294 static int process_match(sd_bus *bus, sd_bus_message *m) {
2295 int r;
2296
2297 assert(bus);
2298 assert(m);
2299
2300 do {
2301 bus->match_callbacks_modified = false;
2302
2303 r = bus_match_run(bus, &bus->match_callbacks, m);
2304 if (r != 0)
2305 return r;
2306
2307 } while (bus->match_callbacks_modified);
2308
2309 return 0;
2310 }
2311
2312 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2313 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2314 int r;
2315
2316 assert(bus);
2317 assert(m);
2318
2319 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2320 return 0;
2321
2322 if (bus->manual_peer_interface)
2323 return 0;
2324
2325 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2326 return 0;
2327
2328 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2329 return 0;
2330
2331 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2332 return 1;
2333
2334 if (streq_ptr(m->member, "Ping"))
2335 r = sd_bus_message_new_method_return(m, &reply);
2336 else if (streq_ptr(m->member, "GetMachineId")) {
2337 sd_id128_t id;
2338 char sid[33];
2339
2340 r = sd_id128_get_machine(&id);
2341 if (r < 0)
2342 return r;
2343
2344 r = sd_bus_message_new_method_return(m, &reply);
2345 if (r < 0)
2346 return r;
2347
2348 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2349 } else {
2350 r = sd_bus_message_new_method_errorf(
2351 m, &reply,
2352 SD_BUS_ERROR_UNKNOWN_METHOD,
2353 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2354 }
2355
2356 if (r < 0)
2357 return r;
2358
2359 r = sd_bus_send(bus, reply, NULL);
2360 if (r < 0)
2361 return r;
2362
2363 return 1;
2364 }
2365
2366 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2367 assert(bus);
2368 assert(m);
2369
2370 /* If we got a message with a file descriptor which we didn't
2371 * want to accept, then let's drop it. How can this even
2372 * happen? For example, when the kernel queues a message into
2373 * an activatable names's queue which allows fds, and then is
2374 * delivered to us later even though we ourselves did not
2375 * negotiate it. */
2376
2377 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2378 return 0;
2379
2380 if (m->n_fds <= 0)
2381 return 0;
2382
2383 if (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)
2384 return 0;
2385
2386 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2387 return 1; /* just eat it up */
2388
2389 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2390 }
2391
2392 static int process_message(sd_bus *bus, sd_bus_message *m) {
2393 int r;
2394
2395 assert(bus);
2396 assert(m);
2397
2398 bus->current = m;
2399 bus->iteration_counter++;
2400
2401 log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
2402 bus_message_type_to_string(m->header->type),
2403 strna(sd_bus_message_get_sender(m)),
2404 strna(sd_bus_message_get_destination(m)),
2405 strna(sd_bus_message_get_path(m)),
2406 strna(sd_bus_message_get_interface(m)),
2407 strna(sd_bus_message_get_member(m)),
2408 BUS_MESSAGE_COOKIE(m),
2409 m->reply_cookie,
2410 strna(m->error.message));
2411
2412 r = process_hello(bus, m);
2413 if (r != 0)
2414 goto finish;
2415
2416 r = process_reply(bus, m);
2417 if (r != 0)
2418 goto finish;
2419
2420 r = process_fd_check(bus, m);
2421 if (r != 0)
2422 goto finish;
2423
2424 r = process_filter(bus, m);
2425 if (r != 0)
2426 goto finish;
2427
2428 r = process_match(bus, m);
2429 if (r != 0)
2430 goto finish;
2431
2432 r = process_builtin(bus, m);
2433 if (r != 0)
2434 goto finish;
2435
2436 r = bus_process_object(bus, m);
2437
2438 finish:
2439 bus->current = NULL;
2440 return r;
2441 }
2442
2443 static int dispatch_track(sd_bus *bus) {
2444 assert(bus);
2445
2446 if (!bus->track_queue)
2447 return 0;
2448
2449 bus_track_dispatch(bus->track_queue);
2450 return 1;
2451 }
2452
2453 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2454 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2455 int r;
2456
2457 assert(bus);
2458 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2459
2460 r = process_timeout(bus);
2461 if (r != 0)
2462 goto null_message;
2463
2464 r = dispatch_wqueue(bus);
2465 if (r != 0)
2466 goto null_message;
2467
2468 r = dispatch_track(bus);
2469 if (r != 0)
2470 goto null_message;
2471
2472 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2473 if (r < 0)
2474 return r;
2475 if (!m)
2476 goto null_message;
2477
2478 r = process_message(bus, m);
2479 if (r != 0)
2480 goto null_message;
2481
2482 if (ret) {
2483 r = sd_bus_message_rewind(m, true);
2484 if (r < 0)
2485 return r;
2486
2487 *ret = m;
2488 m = NULL;
2489 return 1;
2490 }
2491
2492 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2493
2494 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2495 strna(sd_bus_message_get_sender(m)),
2496 strna(sd_bus_message_get_path(m)),
2497 strna(sd_bus_message_get_interface(m)),
2498 strna(sd_bus_message_get_member(m)));
2499
2500 r = sd_bus_reply_method_errorf(
2501 m,
2502 SD_BUS_ERROR_UNKNOWN_OBJECT,
2503 "Unknown object '%s'.", m->path);
2504 if (r < 0)
2505 return r;
2506 }
2507
2508 return 1;
2509
2510 null_message:
2511 if (r >= 0 && ret)
2512 *ret = NULL;
2513
2514 return r;
2515 }
2516
2517 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2518 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2519 struct reply_callback *c;
2520 int r;
2521
2522 assert(bus);
2523 assert(bus->state == BUS_CLOSING);
2524
2525 c = hashmap_first(bus->reply_callbacks);
2526 if (c) {
2527 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2528
2529 /* First, fail all outstanding method calls */
2530 r = bus_message_new_synthetic_error(
2531 bus,
2532 c->cookie,
2533 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2534 &m);
2535 if (r < 0)
2536 return r;
2537
2538 r = bus_seal_synthetic_message(bus, m);
2539 if (r < 0)
2540 return r;
2541
2542 if (c->timeout != 0)
2543 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2544
2545 hashmap_remove(bus->reply_callbacks, &c->cookie);
2546
2547 bus->current = m;
2548 bus->iteration_counter++;
2549
2550 r = c->callback(bus, m, c->userdata, &error_buffer);
2551 r = bus_maybe_reply_error(m, r, &error_buffer);
2552 free(c);
2553
2554 goto finish;
2555 }
2556
2557 /* Then, synthesize a Disconnected message */
2558 r = sd_bus_message_new_signal(
2559 bus,
2560 &m,
2561 "/org/freedesktop/DBus/Local",
2562 "org.freedesktop.DBus.Local",
2563 "Disconnected");
2564 if (r < 0)
2565 return r;
2566
2567 m->sender = "org.freedesktop.DBus.Local";
2568
2569 r = bus_seal_synthetic_message(bus, m);
2570 if (r < 0)
2571 return r;
2572
2573 sd_bus_close(bus);
2574
2575 bus->current = m;
2576 bus->iteration_counter++;
2577
2578 r = process_filter(bus, m);
2579 if (r != 0)
2580 goto finish;
2581
2582 r = process_match(bus, m);
2583 if (r != 0)
2584 goto finish;
2585
2586 if (ret) {
2587 *ret = m;
2588 m = NULL;
2589 }
2590
2591 r = 1;
2592
2593 finish:
2594 bus->current = NULL;
2595 return r;
2596 }
2597
2598 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2599 BUS_DONT_DESTROY(bus);
2600 int r;
2601
2602 /* Returns 0 when we didn't do anything. This should cause the
2603 * caller to invoke sd_bus_wait() before returning the next
2604 * time. Returns > 0 when we did something, which possibly
2605 * means *ret is filled in with an unprocessed message. */
2606
2607 assert_return(bus, -EINVAL);
2608 assert_return(!bus_pid_changed(bus), -ECHILD);
2609
2610 /* We don't allow recursively invoking sd_bus_process(). */
2611 assert_return(!bus->current, -EBUSY);
2612
2613 switch (bus->state) {
2614
2615 case BUS_UNSET:
2616 return -ENOTCONN;
2617
2618 case BUS_CLOSED:
2619 return -ECONNRESET;
2620
2621 case BUS_OPENING:
2622 r = bus_socket_process_opening(bus);
2623 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2624 bus_enter_closing(bus);
2625 r = 1;
2626 } else if (r < 0)
2627 return r;
2628 if (ret)
2629 *ret = NULL;
2630 return r;
2631
2632 case BUS_AUTHENTICATING:
2633 r = bus_socket_process_authenticating(bus);
2634 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2635 bus_enter_closing(bus);
2636 r = 1;
2637 } else if (r < 0)
2638 return r;
2639
2640 if (ret)
2641 *ret = NULL;
2642
2643 return r;
2644
2645 case BUS_RUNNING:
2646 case BUS_HELLO:
2647 r = process_running(bus, hint_priority, priority, ret);
2648 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2649 bus_enter_closing(bus);
2650 r = 1;
2651
2652 if (ret)
2653 *ret = NULL;
2654 }
2655
2656 return r;
2657
2658 case BUS_CLOSING:
2659 return process_closing(bus, ret);
2660 }
2661
2662 assert_not_reached("Unknown state");
2663 }
2664
2665 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2666 return bus_process_internal(bus, false, 0, ret);
2667 }
2668
2669 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2670 return bus_process_internal(bus, true, priority, ret);
2671 }
2672
2673 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2674 struct pollfd p[2] = {};
2675 int r, e, n;
2676 struct timespec ts;
2677 usec_t m = (usec_t) -1;
2678
2679 assert(bus);
2680
2681 if (bus->state == BUS_CLOSING)
2682 return 1;
2683
2684 if (!BUS_IS_OPEN(bus->state))
2685 return -ENOTCONN;
2686
2687 e = sd_bus_get_events(bus);
2688 if (e < 0)
2689 return e;
2690
2691 if (need_more)
2692 /* The caller really needs some more data, he doesn't
2693 * care about what's already read, or any timeouts
2694 * except its own.*/
2695 e |= POLLIN;
2696 else {
2697 usec_t until;
2698 /* The caller wants to process if there's something to
2699 * process, but doesn't care otherwise */
2700
2701 r = sd_bus_get_timeout(bus, &until);
2702 if (r < 0)
2703 return r;
2704 if (r > 0) {
2705 usec_t nw;
2706 nw = now(CLOCK_MONOTONIC);
2707 m = until > nw ? until - nw : 0;
2708 }
2709 }
2710
2711 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2712 m = timeout_usec;
2713
2714 p[0].fd = bus->input_fd;
2715 if (bus->output_fd == bus->input_fd) {
2716 p[0].events = e;
2717 n = 1;
2718 } else {
2719 p[0].events = e & POLLIN;
2720 p[1].fd = bus->output_fd;
2721 p[1].events = e & POLLOUT;
2722 n = 2;
2723 }
2724
2725 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2726 if (r < 0)
2727 return -errno;
2728
2729 return r > 0 ? 1 : 0;
2730 }
2731
2732 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2733
2734 assert_return(bus, -EINVAL);
2735 assert_return(!bus_pid_changed(bus), -ECHILD);
2736
2737 if (bus->state == BUS_CLOSING)
2738 return 0;
2739
2740 if (!BUS_IS_OPEN(bus->state))
2741 return -ENOTCONN;
2742
2743 if (bus->rqueue_size > 0)
2744 return 0;
2745
2746 return bus_poll(bus, false, timeout_usec);
2747 }
2748
2749 _public_ int sd_bus_flush(sd_bus *bus) {
2750 int r;
2751
2752 assert_return(bus, -EINVAL);
2753 assert_return(!bus_pid_changed(bus), -ECHILD);
2754
2755 if (bus->state == BUS_CLOSING)
2756 return 0;
2757
2758 if (!BUS_IS_OPEN(bus->state))
2759 return -ENOTCONN;
2760
2761 r = bus_ensure_running(bus);
2762 if (r < 0)
2763 return r;
2764
2765 if (bus->wqueue_size <= 0)
2766 return 0;
2767
2768 for (;;) {
2769 r = dispatch_wqueue(bus);
2770 if (r < 0) {
2771 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2772 bus_enter_closing(bus);
2773 return -ECONNRESET;
2774 }
2775
2776 return r;
2777 }
2778
2779 if (bus->wqueue_size <= 0)
2780 return 0;
2781
2782 r = bus_poll(bus, false, (uint64_t) -1);
2783 if (r < 0)
2784 return r;
2785 }
2786 }
2787
2788 _public_ int sd_bus_add_filter(sd_bus *bus,
2789 sd_bus_message_handler_t callback,
2790 void *userdata) {
2791
2792 struct filter_callback *f;
2793
2794 assert_return(bus, -EINVAL);
2795 assert_return(callback, -EINVAL);
2796 assert_return(!bus_pid_changed(bus), -ECHILD);
2797
2798 f = new0(struct filter_callback, 1);
2799 if (!f)
2800 return -ENOMEM;
2801 f->callback = callback;
2802 f->userdata = userdata;
2803
2804 bus->filter_callbacks_modified = true;
2805 LIST_PREPEND(callbacks, bus->filter_callbacks, f);
2806 return 0;
2807 }
2808
2809 _public_ int sd_bus_remove_filter(sd_bus *bus,
2810 sd_bus_message_handler_t callback,
2811 void *userdata) {
2812
2813 struct filter_callback *f;
2814
2815 assert_return(bus, -EINVAL);
2816 assert_return(callback, -EINVAL);
2817 assert_return(!bus_pid_changed(bus), -ECHILD);
2818
2819 LIST_FOREACH(callbacks, f, bus->filter_callbacks) {
2820 if (f->callback == callback && f->userdata == userdata) {
2821 bus->filter_callbacks_modified = true;
2822 LIST_REMOVE(callbacks, bus->filter_callbacks, f);
2823 free(f);
2824 return 1;
2825 }
2826 }
2827
2828 return 0;
2829 }
2830
2831 _public_ int sd_bus_add_match(sd_bus *bus,
2832 const char *match,
2833 sd_bus_message_handler_t callback,
2834 void *userdata) {
2835
2836 struct bus_match_component *components = NULL;
2837 unsigned n_components = 0;
2838 uint64_t cookie = 0;
2839 int r = 0;
2840
2841 assert_return(bus, -EINVAL);
2842 assert_return(match, -EINVAL);
2843 assert_return(!bus_pid_changed(bus), -ECHILD);
2844
2845 r = bus_match_parse(match, &components, &n_components);
2846 if (r < 0)
2847 goto finish;
2848
2849 if (bus->bus_client) {
2850 cookie = ++bus->match_cookie;
2851
2852 r = bus_add_match_internal(bus, match, components, n_components, cookie);
2853 if (r < 0)
2854 goto finish;
2855 }
2856
2857 bus->match_callbacks_modified = true;
2858 r = bus_match_add(&bus->match_callbacks, components, n_components, callback, userdata, cookie, NULL);
2859 if (r < 0) {
2860 if (bus->bus_client)
2861 bus_remove_match_internal(bus, match, cookie);
2862 }
2863
2864 finish:
2865 bus_match_parse_free(components, n_components);
2866 return r;
2867 }
2868
2869 _public_ int sd_bus_remove_match(sd_bus *bus,
2870 const char *match,
2871 sd_bus_message_handler_t callback,
2872 void *userdata) {
2873
2874 struct bus_match_component *components = NULL;
2875 unsigned n_components = 0;
2876 int r = 0, q = 0;
2877 uint64_t cookie = 0;
2878
2879 assert_return(bus, -EINVAL);
2880 assert_return(match, -EINVAL);
2881 assert_return(!bus_pid_changed(bus), -ECHILD);
2882
2883 r = bus_match_parse(match, &components, &n_components);
2884 if (r < 0)
2885 return r;
2886
2887 bus->match_callbacks_modified = true;
2888 r = bus_match_remove(&bus->match_callbacks, components, n_components, callback, userdata, &cookie);
2889
2890 if (bus->bus_client)
2891 q = bus_remove_match_internal(bus, match, cookie);
2892
2893 bus_match_parse_free(components, n_components);
2894
2895 return r < 0 ? r : q;
2896 }
2897
2898 bool bus_pid_changed(sd_bus *bus) {
2899 assert(bus);
2900
2901 /* We don't support people creating a bus connection and
2902 * keeping it around over a fork(). Let's complain. */
2903
2904 return bus->original_pid != getpid();
2905 }
2906
2907 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
2908 sd_bus *bus = userdata;
2909 int r;
2910
2911 assert(bus);
2912
2913 r = sd_bus_process(bus, NULL);
2914 if (r < 0)
2915 return r;
2916
2917 return 1;
2918 }
2919
2920 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
2921 sd_bus *bus = userdata;
2922 int r;
2923
2924 assert(bus);
2925
2926 r = sd_bus_process(bus, NULL);
2927 if (r < 0)
2928 return r;
2929
2930 return 1;
2931 }
2932
2933 static int prepare_callback(sd_event_source *s, void *userdata) {
2934 sd_bus *bus = userdata;
2935 int r, e;
2936 usec_t until;
2937
2938 assert(s);
2939 assert(bus);
2940
2941 e = sd_bus_get_events(bus);
2942 if (e < 0)
2943 return e;
2944
2945 if (bus->output_fd != bus->input_fd) {
2946
2947 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
2948 if (r < 0)
2949 return r;
2950
2951 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
2952 if (r < 0)
2953 return r;
2954 } else {
2955 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
2956 if (r < 0)
2957 return r;
2958 }
2959
2960 r = sd_bus_get_timeout(bus, &until);
2961 if (r < 0)
2962 return r;
2963 if (r > 0) {
2964 int j;
2965
2966 j = sd_event_source_set_time(bus->time_event_source, until);
2967 if (j < 0)
2968 return j;
2969 }
2970
2971 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
2972 if (r < 0)
2973 return r;
2974
2975 return 1;
2976 }
2977
2978 static int quit_callback(sd_event_source *event, void *userdata) {
2979 sd_bus *bus = userdata;
2980
2981 assert(event);
2982
2983 sd_bus_flush(bus);
2984
2985 return 1;
2986 }
2987
2988 static int attach_io_events(sd_bus *bus) {
2989 int r;
2990
2991 assert(bus);
2992
2993 if (bus->input_fd < 0)
2994 return 0;
2995
2996 if (!bus->event)
2997 return 0;
2998
2999 if (!bus->input_io_event_source) {
3000 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3001 if (r < 0)
3002 return r;
3003
3004 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3005 if (r < 0)
3006 return r;
3007
3008 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3009 } else
3010 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3011
3012 if (r < 0)
3013 return r;
3014
3015 if (bus->output_fd != bus->input_fd) {
3016 assert(bus->output_fd >= 0);
3017
3018 if (!bus->output_io_event_source) {
3019 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3020 if (r < 0)
3021 return r;
3022
3023 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3024 } else
3025 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3026
3027 if (r < 0)
3028 return r;
3029 }
3030
3031 return 0;
3032 }
3033
3034 static void detach_io_events(sd_bus *bus) {
3035 assert(bus);
3036
3037 if (bus->input_io_event_source) {
3038 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3039 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3040 }
3041
3042 if (bus->output_io_event_source) {
3043 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3044 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3045 }
3046 }
3047
3048 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3049 int r;
3050
3051 assert_return(bus, -EINVAL);
3052 assert_return(!bus->event, -EBUSY);
3053
3054 assert(!bus->input_io_event_source);
3055 assert(!bus->output_io_event_source);
3056 assert(!bus->time_event_source);
3057
3058 if (event)
3059 bus->event = sd_event_ref(event);
3060 else {
3061 r = sd_event_default(&bus->event);
3062 if (r < 0)
3063 return r;
3064 }
3065
3066 bus->event_priority = priority;
3067
3068 r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3069 if (r < 0)
3070 goto fail;
3071
3072 r = sd_event_source_set_priority(bus->time_event_source, priority);
3073 if (r < 0)
3074 goto fail;
3075
3076 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3077 if (r < 0)
3078 goto fail;
3079
3080 r = attach_io_events(bus);
3081 if (r < 0)
3082 goto fail;
3083
3084 return 0;
3085
3086 fail:
3087 sd_bus_detach_event(bus);
3088 return r;
3089 }
3090
3091 _public_ int sd_bus_detach_event(sd_bus *bus) {
3092 assert_return(bus, -EINVAL);
3093
3094 if (!bus->event)
3095 return 0;
3096
3097 detach_io_events(bus);
3098
3099 if (bus->time_event_source) {
3100 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3101 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3102 }
3103
3104 if (bus->quit_event_source) {
3105 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3106 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3107 }
3108
3109 if (bus->event)
3110 bus->event = sd_event_unref(bus->event);
3111
3112 return 1;
3113 }
3114
3115 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3116 assert_return(bus, NULL);
3117
3118 return bus->event;
3119 }
3120
3121 _public_ sd_bus_message* sd_bus_get_current(sd_bus *bus) {
3122 assert_return(bus, NULL);
3123
3124 return bus->current;
3125 }
3126
3127 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3128 sd_bus *b = NULL;
3129 int r;
3130
3131 assert(bus_open);
3132 assert(default_bus);
3133
3134 if (!ret)
3135 return !!*default_bus;
3136
3137 if (*default_bus) {
3138 *ret = sd_bus_ref(*default_bus);
3139 return 0;
3140 }
3141
3142 r = bus_open(&b);
3143 if (r < 0)
3144 return r;
3145
3146 b->default_bus_ptr = default_bus;
3147 b->tid = gettid();
3148 *default_bus = b;
3149
3150 *ret = b;
3151 return 1;
3152 }
3153
3154 _public_ int sd_bus_default_system(sd_bus **ret) {
3155 static thread_local sd_bus *default_system_bus = NULL;
3156
3157 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3158 }
3159
3160 _public_ int sd_bus_default_user(sd_bus **ret) {
3161 static thread_local sd_bus *default_user_bus = NULL;
3162
3163 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3164 }
3165
3166 _public_ int sd_bus_default(sd_bus **ret) {
3167
3168 const char *e;
3169
3170 /* Let's try our best to reuse another cached connection. If
3171 * the starter bus type is set, connect via our normal
3172 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3173 * we can share the connection with the user/system default
3174 * bus. */
3175
3176 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3177 if (e) {
3178 if (streq(e, "system"))
3179 return sd_bus_default_system(ret);
3180 else if (STR_IN_SET(e, "user", "session"))
3181 return sd_bus_default_user(ret);
3182 }
3183
3184 /* No type is specified, so we have not other option than to
3185 * use the starter address if it is set. */
3186
3187 e = secure_getenv("DBUS_STARTER_ADDRESS");
3188 if (e) {
3189 static thread_local sd_bus *default_starter_bus = NULL;
3190
3191 return bus_default(sd_bus_open, &default_starter_bus, ret);
3192 }
3193
3194 /* Finally, if nothing is set use the cached connection for
3195 * the right scope */
3196
3197 if (cg_pid_get_owner_uid(0, NULL) >= 0)
3198 return sd_bus_default_user(ret);
3199 else
3200 return sd_bus_default_system(ret);
3201 }
3202
3203 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3204 assert_return(b, -EINVAL);
3205 assert_return(tid, -EINVAL);
3206 assert_return(!bus_pid_changed(b), -ECHILD);
3207
3208 if (b->tid != 0) {
3209 *tid = b->tid;
3210 return 0;
3211 }
3212
3213 if (b->event)
3214 return sd_event_get_tid(b->event, tid);
3215
3216 return -ENXIO;
3217 }
3218
3219 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3220 _cleanup_free_ char *e = NULL;
3221 char *ret;
3222
3223 assert_return(object_path_is_valid(prefix), -EINVAL);
3224 assert_return(external_id, -EINVAL);
3225 assert_return(ret_path, -EINVAL);
3226
3227 e = bus_label_escape(external_id);
3228 if (!e)
3229 return -ENOMEM;
3230
3231 ret = strjoin(prefix, "/", e, NULL);
3232 if (!ret)
3233 return -ENOMEM;
3234
3235 *ret_path = ret;
3236 return 0;
3237 }
3238
3239 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3240 const char *e;
3241 char *ret;
3242
3243 assert_return(object_path_is_valid(path), -EINVAL);
3244 assert_return(object_path_is_valid(prefix), -EINVAL);
3245 assert_return(external_id, -EINVAL);
3246
3247 e = object_path_startswith(path, prefix);
3248 if (!e) {
3249 *external_id = NULL;
3250 return 0;
3251 }
3252
3253 ret = bus_label_unescape(e);
3254 if (!ret)
3255 return -ENOMEM;
3256
3257 *external_id = ret;
3258 return 1;
3259 }
3260
3261 _public_ int sd_bus_get_peer_creds(sd_bus *bus, uint64_t mask, sd_bus_creds **ret) {
3262 sd_bus_creds *c;
3263 pid_t pid = 0;
3264 int r;
3265
3266 assert_return(bus, -EINVAL);
3267 assert_return(mask <= _SD_BUS_CREDS_ALL, -ENOTSUP);
3268 assert_return(ret, -EINVAL);
3269 assert_return(!bus_pid_changed(bus), -ECHILD);
3270
3271 if (!bus->is_kernel)
3272 return -ENOTSUP;
3273
3274 if (!BUS_IS_OPEN(bus->state))
3275 return -ENOTCONN;
3276
3277 if (!bus->ucred_valid && !isempty(bus->label))
3278 return -ENODATA;
3279
3280 c = bus_creds_new();
3281 if (!c)
3282 return -ENOMEM;
3283
3284 if (bus->ucred_valid) {
3285 pid = c->pid = bus->ucred.pid;
3286 c->uid = bus->ucred.uid;
3287 c->gid = bus->ucred.gid;
3288
3289 c->mask |= (SD_BUS_CREDS_UID | SD_BUS_CREDS_PID | SD_BUS_CREDS_GID) & mask;
3290 }
3291
3292 if (!isempty(bus->label) && (mask & SD_BUS_CREDS_SELINUX_CONTEXT)) {
3293 c->label = strdup(bus->label);
3294 if (!c->label) {
3295 sd_bus_creds_unref(c);
3296 return -ENOMEM;
3297 }
3298
3299 c->mask |= SD_BUS_CREDS_SELINUX_CONTEXT;
3300 }
3301
3302 r = bus_creds_add_more(c, mask, pid, 0);
3303 if (r < 0)
3304 return r;
3305
3306 *ret = c;
3307 return 0;
3308 }
3309
3310 _public_ int sd_bus_try_close(sd_bus *bus) {
3311 int r;
3312
3313 assert_return(bus, -EINVAL);
3314 assert_return(!bus_pid_changed(bus), -ECHILD);
3315
3316 if (!bus->is_kernel)
3317 return -ENOTSUP;
3318
3319 if (!BUS_IS_OPEN(bus->state))
3320 return -ENOTCONN;
3321
3322 if (bus->rqueue_size > 0)
3323 return -EBUSY;
3324
3325 if (bus->wqueue_size > 0)
3326 return -EBUSY;
3327
3328 r = bus_kernel_try_close(bus);
3329 if (r < 0)
3330 return r;
3331
3332 sd_bus_close(bus);
3333 return 0;
3334 }
3335
3336 _public_ int sd_bus_get_name(sd_bus *bus, const char **name) {
3337 assert_return(bus, -EINVAL);
3338 assert_return(name, -EINVAL);
3339 assert_return(!bus_pid_changed(bus), -ECHILD);
3340
3341 *name = bus->connection_name;
3342 return 0;
3343 }
Unnamed repository; edit this file 'description' to name the repository.