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