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