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