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