]> 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: derive uid from cgroup if possible
[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 uid_t uid;
1245 int r;
1246
1247 assert(b);
1248
1249 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1250 if (e)
1251 return sd_bus_set_address(b, e);
1252
1253 r = cg_pid_get_owner_uid(0, &uid);
1254 if (r < 0)
1255 uid = getuid();
1256
1257 e = secure_getenv("XDG_RUNTIME_DIR");
1258 if (e) {
1259 _cleanup_free_ char *ee = NULL;
1260
1261 ee = bus_address_escape(e);
1262 if (!ee)
1263 return -ENOMEM;
1264
1265 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT ";" UNIX_USER_BUS_ADDRESS_FMT, uid, ee);
1266 } else
1267 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT, uid);
1268
1269 if (!b->address)
1270 return -ENOMEM;
1271
1272 return 0;
1273 }
1274
1275 _public_ int sd_bus_open_user(sd_bus **ret) {
1276 sd_bus *b;
1277 int r;
1278
1279 assert_return(ret, -EINVAL);
1280
1281 r = sd_bus_new(&b);
1282 if (r < 0)
1283 return r;
1284
1285 r = bus_set_address_user(b);
1286 if (r < 0)
1287 return r;
1288
1289 b->bus_client = true;
1290 b->is_user = true;
1291
1292 /* We don't do any per-method access control on the user
1293 * bus. */
1294 b->trusted = true;
1295
1296 r = sd_bus_start(b);
1297 if (r < 0)
1298 goto fail;
1299
1300 *ret = b;
1301 return 0;
1302
1303 fail:
1304 bus_free(b);
1305 return r;
1306 }
1307
1308 int bus_set_address_system_remote(sd_bus *b, const char *host) {
1309 _cleanup_free_ char *e = NULL;
1310 char *m = NULL, *c = NULL;
1311
1312 assert(b);
1313 assert(host);
1314
1315 /* Let's see if we shall enter some container */
1316 m = strchr(host, ':');
1317 if (m) {
1318 m++;
1319
1320 /* Let's make sure this is not a port of some kind,
1321 * and is a valid machine name. */
1322 if (!in_charset(m, "0123456789") && machine_name_is_valid(m)) {
1323 char *t;
1324
1325 /* Cut out the host part */
1326 t = strndupa(host, m - host - 1);
1327 e = bus_address_escape(t);
1328 if (!e)
1329 return -ENOMEM;
1330
1331 c = strjoina(",argv4=--machine=", m);
1332 }
1333 }
1334
1335 if (!e) {
1336 e = bus_address_escape(host);
1337 if (!e)
1338 return -ENOMEM;
1339 }
1340
1341 b->address = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", c, NULL);
1342 if (!b->address)
1343 return -ENOMEM;
1344
1345 return 0;
1346 }
1347
1348 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1349 sd_bus *bus;
1350 int r;
1351
1352 assert_return(host, -EINVAL);
1353 assert_return(ret, -EINVAL);
1354
1355 r = sd_bus_new(&bus);
1356 if (r < 0)
1357 return r;
1358
1359 r = bus_set_address_system_remote(bus, host);
1360 if (r < 0)
1361 goto fail;
1362
1363 bus->bus_client = true;
1364 bus->trusted = false;
1365 bus->is_system = true;
1366
1367 r = sd_bus_start(bus);
1368 if (r < 0)
1369 goto fail;
1370
1371 *ret = bus;
1372 return 0;
1373
1374 fail:
1375 bus_free(bus);
1376 return r;
1377 }
1378
1379 int bus_set_address_system_machine(sd_bus *b, const char *machine) {
1380 _cleanup_free_ char *e = NULL;
1381
1382 assert(b);
1383 assert(machine);
1384
1385 e = bus_address_escape(machine);
1386 if (!e)
1387 return -ENOMEM;
1388
1389 b->address = strjoin("x-machine-kernel:machine=", e, ";x-machine-unix:machine=", e, NULL);
1390 if (!b->address)
1391 return -ENOMEM;
1392
1393 return 0;
1394 }
1395
1396 _public_ int sd_bus_open_system_machine(sd_bus **ret, const char *machine) {
1397 sd_bus *bus;
1398 int r;
1399
1400 assert_return(machine, -EINVAL);
1401 assert_return(ret, -EINVAL);
1402 assert_return(machine_name_is_valid(machine), -EINVAL);
1403
1404 r = sd_bus_new(&bus);
1405 if (r < 0)
1406 return r;
1407
1408 r = bus_set_address_system_machine(bus, machine);
1409 if (r < 0)
1410 goto fail;
1411
1412 bus->bus_client = true;
1413 bus->trusted = false;
1414 bus->is_system = true;
1415
1416 r = sd_bus_start(bus);
1417 if (r < 0)
1418 goto fail;
1419
1420 *ret = bus;
1421 return 0;
1422
1423 fail:
1424 bus_free(bus);
1425 return r;
1426 }
1427
1428 _public_ void sd_bus_close(sd_bus *bus) {
1429
1430 if (!bus)
1431 return;
1432 if (bus->state == BUS_CLOSED)
1433 return;
1434 if (bus_pid_changed(bus))
1435 return;
1436
1437 bus->state = BUS_CLOSED;
1438
1439 sd_bus_detach_event(bus);
1440
1441 /* Drop all queued messages so that they drop references to
1442 * the bus object and the bus may be freed */
1443 bus_reset_queues(bus);
1444
1445 if (!bus->is_kernel)
1446 bus_close_fds(bus);
1447
1448 /* We'll leave the fd open in case this is a kernel bus, since
1449 * there might still be memblocks around that reference this
1450 * bus, and they might need to invoke the KDBUS_CMD_FREE
1451 * ioctl on the fd when they are freed. */
1452 }
1453
1454 _public_ sd_bus* sd_bus_flush_close_unref(sd_bus *bus) {
1455
1456 if (!bus)
1457 return NULL;
1458
1459 sd_bus_flush(bus);
1460 sd_bus_close(bus);
1461
1462 return sd_bus_unref(bus);
1463 }
1464
1465 static void bus_enter_closing(sd_bus *bus) {
1466 assert(bus);
1467
1468 if (bus->state != BUS_OPENING &&
1469 bus->state != BUS_AUTHENTICATING &&
1470 bus->state != BUS_HELLO &&
1471 bus->state != BUS_RUNNING)
1472 return;
1473
1474 bus->state = BUS_CLOSING;
1475 }
1476
1477 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1478 assert_return(bus, NULL);
1479
1480 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1481
1482 return bus;
1483 }
1484
1485 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1486 unsigned i;
1487
1488 if (!bus)
1489 return NULL;
1490
1491 i = REFCNT_DEC(bus->n_ref);
1492 if (i > 0)
1493 return NULL;
1494
1495 bus_free(bus);
1496 return NULL;
1497 }
1498
1499 _public_ int sd_bus_is_open(sd_bus *bus) {
1500
1501 assert_return(bus, -EINVAL);
1502 assert_return(!bus_pid_changed(bus), -ECHILD);
1503
1504 return BUS_IS_OPEN(bus->state);
1505 }
1506
1507 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1508 int r;
1509
1510 assert_return(bus, -EINVAL);
1511 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1512 assert_return(!bus_pid_changed(bus), -ECHILD);
1513
1514 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
1515 return 0;
1516
1517 if (type == SD_BUS_TYPE_UNIX_FD) {
1518 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1519 return 0;
1520
1521 r = bus_ensure_running(bus);
1522 if (r < 0)
1523 return r;
1524
1525 return bus->can_fds;
1526 }
1527
1528 return bus_type_is_valid(type);
1529 }
1530
1531 _public_ int sd_bus_get_bus_id(sd_bus *bus, sd_id128_t *id) {
1532 int r;
1533
1534 assert_return(bus, -EINVAL);
1535 assert_return(id, -EINVAL);
1536 assert_return(!bus_pid_changed(bus), -ECHILD);
1537
1538 r = bus_ensure_running(bus);
1539 if (r < 0)
1540 return r;
1541
1542 *id = bus->server_id;
1543 return 0;
1544 }
1545
1546 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1547 assert(b);
1548 assert(m);
1549
1550 if (m->sealed) {
1551 /* If we copy the same message to multiple
1552 * destinations, avoid using the same cookie
1553 * numbers. */
1554 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1555 return 0;
1556 }
1557
1558 if (timeout == 0)
1559 timeout = BUS_DEFAULT_TIMEOUT;
1560
1561 return bus_message_seal(m, ++b->cookie, timeout);
1562 }
1563
1564 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1565 bool remarshal = false;
1566
1567 assert(b);
1568
1569 /* wrong packet version */
1570 if (b->message_version != 0 && b->message_version != (*m)->header->version)
1571 remarshal = true;
1572
1573 /* wrong packet endianness */
1574 if (b->message_endian != 0 && b->message_endian != (*m)->header->endian)
1575 remarshal = true;
1576
1577 /* TODO: kdbus-messages received from the kernel contain data which is
1578 * not allowed to be passed to KDBUS_CMD_SEND. Therefore, we have to
1579 * force remarshaling of the message. Technically, we could just
1580 * recreate the kdbus message, but that is non-trivial as other parts of
1581 * the message refer to m->kdbus already. This should be fixed! */
1582 if ((*m)->kdbus && (*m)->release_kdbus)
1583 remarshal = true;
1584
1585 return remarshal ? bus_message_remarshal(b, m) : 0;
1586 }
1587
1588 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1589 assert(b);
1590 assert(m);
1591
1592 /* Fake some timestamps, if they were requested, and not
1593 * already initialized */
1594 if (b->attach_flags & KDBUS_ATTACH_TIMESTAMP) {
1595 if (m->realtime <= 0)
1596 m->realtime = now(CLOCK_REALTIME);
1597
1598 if (m->monotonic <= 0)
1599 m->monotonic = now(CLOCK_MONOTONIC);
1600 }
1601
1602 /* The bus specification says the serial number cannot be 0,
1603 * hence let's fill something in for synthetic messages. Since
1604 * synthetic messages might have a fake sender and we don't
1605 * want to interfere with the real sender's serial numbers we
1606 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1607 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1608 * even though kdbus can do 64bit. */
1609 return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1610 }
1611
1612 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1613 int r;
1614
1615 assert(bus);
1616 assert(m);
1617
1618 if (bus->is_kernel)
1619 r = bus_kernel_write_message(bus, m, hint_sync_call);
1620 else
1621 r = bus_socket_write_message(bus, m, idx);
1622
1623 if (r <= 0)
1624 return r;
1625
1626 if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1627 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
1628 bus_message_type_to_string(m->header->type),
1629 strna(sd_bus_message_get_sender(m)),
1630 strna(sd_bus_message_get_destination(m)),
1631 strna(sd_bus_message_get_path(m)),
1632 strna(sd_bus_message_get_interface(m)),
1633 strna(sd_bus_message_get_member(m)),
1634 BUS_MESSAGE_COOKIE(m),
1635 m->reply_cookie,
1636 strna(m->error.message));
1637
1638 return r;
1639 }
1640
1641 static int dispatch_wqueue(sd_bus *bus) {
1642 int r, ret = 0;
1643
1644 assert(bus);
1645 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1646
1647 while (bus->wqueue_size > 0) {
1648
1649 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1650 if (r < 0)
1651 return r;
1652 else if (r == 0)
1653 /* Didn't do anything this time */
1654 return ret;
1655 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1656 /* Fully written. Let's drop the entry from
1657 * the queue.
1658 *
1659 * This isn't particularly optimized, but
1660 * well, this is supposed to be our worst-case
1661 * buffer only, and the socket buffer is
1662 * supposed to be our primary buffer, and if
1663 * it got full, then all bets are off
1664 * anyway. */
1665
1666 bus->wqueue_size --;
1667 sd_bus_message_unref(bus->wqueue[0]);
1668 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1669 bus->windex = 0;
1670
1671 ret = 1;
1672 }
1673 }
1674
1675 return ret;
1676 }
1677
1678 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1679 assert(bus);
1680
1681 if (bus->is_kernel)
1682 return bus_kernel_read_message(bus, hint_priority, priority);
1683 else
1684 return bus_socket_read_message(bus);
1685 }
1686
1687 int bus_rqueue_make_room(sd_bus *bus) {
1688 assert(bus);
1689
1690 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1691 return -ENOBUFS;
1692
1693 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1694 return -ENOMEM;
1695
1696 return 0;
1697 }
1698
1699 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1700 int r, ret = 0;
1701
1702 assert(bus);
1703 assert(m);
1704 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1705
1706 /* Note that the priority logic is only available on kdbus,
1707 * where the rqueue is unused. We check the rqueue here
1708 * anyway, because it's simple... */
1709
1710 for (;;) {
1711 if (bus->rqueue_size > 0) {
1712 /* Dispatch a queued message */
1713
1714 *m = bus->rqueue[0];
1715 bus->rqueue_size --;
1716 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1717 return 1;
1718 }
1719
1720 /* Try to read a new message */
1721 r = bus_read_message(bus, hint_priority, priority);
1722 if (r < 0)
1723 return r;
1724 if (r == 0)
1725 return ret;
1726
1727 ret = 1;
1728 }
1729 }
1730
1731 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1732 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1733 int r;
1734
1735 assert_return(m, -EINVAL);
1736
1737 if (!bus)
1738 bus = m->bus;
1739
1740 assert_return(!bus_pid_changed(bus), -ECHILD);
1741 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1742
1743 if (!BUS_IS_OPEN(bus->state))
1744 return -ENOTCONN;
1745
1746 if (m->n_fds > 0) {
1747 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1748 if (r < 0)
1749 return r;
1750 if (r == 0)
1751 return -EOPNOTSUPP;
1752 }
1753
1754 /* If the cookie number isn't kept, then we know that no reply
1755 * is expected */
1756 if (!cookie && !m->sealed)
1757 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1758
1759 r = bus_seal_message(bus, m, 0);
1760 if (r < 0)
1761 return r;
1762
1763 /* Remarshall if we have to. This will possibly unref the
1764 * message and place a replacement in m */
1765 r = bus_remarshal_message(bus, &m);
1766 if (r < 0)
1767 return r;
1768
1769 /* If this is a reply and no reply was requested, then let's
1770 * suppress this, if we can */
1771 if (m->dont_send)
1772 goto finish;
1773
1774 if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1775 size_t idx = 0;
1776
1777 r = bus_write_message(bus, m, hint_sync_call, &idx);
1778 if (r < 0) {
1779 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1780 bus_enter_closing(bus);
1781 return -ECONNRESET;
1782 }
1783
1784 return r;
1785 }
1786
1787 if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1788 /* Wasn't fully written. So let's remember how
1789 * much was written. Note that the first entry
1790 * of the wqueue array is always allocated so
1791 * that we always can remember how much was
1792 * written. */
1793 bus->wqueue[0] = sd_bus_message_ref(m);
1794 bus->wqueue_size = 1;
1795 bus->windex = idx;
1796 }
1797
1798 } else {
1799 /* Just append it to the queue. */
1800
1801 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1802 return -ENOBUFS;
1803
1804 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1805 return -ENOMEM;
1806
1807 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1808 }
1809
1810 finish:
1811 if (cookie)
1812 *cookie = BUS_MESSAGE_COOKIE(m);
1813
1814 return 1;
1815 }
1816
1817 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1818 return bus_send_internal(bus, m, cookie, false);
1819 }
1820
1821 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1822 int r;
1823
1824 assert_return(m, -EINVAL);
1825
1826 if (!bus)
1827 bus = m->bus;
1828
1829 assert_return(!bus_pid_changed(bus), -ECHILD);
1830
1831 if (!BUS_IS_OPEN(bus->state))
1832 return -ENOTCONN;
1833
1834 if (!streq_ptr(m->destination, destination)) {
1835
1836 if (!destination)
1837 return -EEXIST;
1838
1839 r = sd_bus_message_set_destination(m, destination);
1840 if (r < 0)
1841 return r;
1842 }
1843
1844 return sd_bus_send(bus, m, cookie);
1845 }
1846
1847 static usec_t calc_elapse(uint64_t usec) {
1848 if (usec == (uint64_t) -1)
1849 return 0;
1850
1851 return now(CLOCK_MONOTONIC) + usec;
1852 }
1853
1854 static int timeout_compare(const void *a, const void *b) {
1855 const struct reply_callback *x = a, *y = b;
1856
1857 if (x->timeout != 0 && y->timeout == 0)
1858 return -1;
1859
1860 if (x->timeout == 0 && y->timeout != 0)
1861 return 1;
1862
1863 if (x->timeout < y->timeout)
1864 return -1;
1865
1866 if (x->timeout > y->timeout)
1867 return 1;
1868
1869 return 0;
1870 }
1871
1872 _public_ int sd_bus_call_async(
1873 sd_bus *bus,
1874 sd_bus_slot **slot,
1875 sd_bus_message *_m,
1876 sd_bus_message_handler_t callback,
1877 void *userdata,
1878 uint64_t usec) {
1879
1880 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1881 _cleanup_bus_slot_unref_ sd_bus_slot *s = NULL;
1882 int r;
1883
1884 assert_return(m, -EINVAL);
1885 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1886 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1887 assert_return(callback, -EINVAL);
1888
1889 if (!bus)
1890 bus = m->bus;
1891
1892 assert_return(!bus_pid_changed(bus), -ECHILD);
1893 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1894
1895 if (!BUS_IS_OPEN(bus->state))
1896 return -ENOTCONN;
1897
1898 r = ordered_hashmap_ensure_allocated(&bus->reply_callbacks, &uint64_hash_ops);
1899 if (r < 0)
1900 return r;
1901
1902 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1903 if (r < 0)
1904 return r;
1905
1906 r = bus_seal_message(bus, m, usec);
1907 if (r < 0)
1908 return r;
1909
1910 r = bus_remarshal_message(bus, &m);
1911 if (r < 0)
1912 return r;
1913
1914 s = bus_slot_allocate(bus, !slot, BUS_REPLY_CALLBACK, sizeof(struct reply_callback), userdata);
1915 if (!s)
1916 return -ENOMEM;
1917
1918 s->reply_callback.callback = callback;
1919
1920 s->reply_callback.cookie = BUS_MESSAGE_COOKIE(m);
1921 r = ordered_hashmap_put(bus->reply_callbacks, &s->reply_callback.cookie, &s->reply_callback);
1922 if (r < 0) {
1923 s->reply_callback.cookie = 0;
1924 return r;
1925 }
1926
1927 s->reply_callback.timeout = calc_elapse(m->timeout);
1928 if (s->reply_callback.timeout != 0) {
1929 r = prioq_put(bus->reply_callbacks_prioq, &s->reply_callback, &s->reply_callback.prioq_idx);
1930 if (r < 0) {
1931 s->reply_callback.timeout = 0;
1932 return r;
1933 }
1934 }
1935
1936 r = sd_bus_send(bus, m, &s->reply_callback.cookie);
1937 if (r < 0)
1938 return r;
1939
1940 if (slot)
1941 *slot = s;
1942 s = NULL;
1943
1944 return r;
1945 }
1946
1947 int bus_ensure_running(sd_bus *bus) {
1948 int r;
1949
1950 assert(bus);
1951
1952 if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1953 return -ENOTCONN;
1954 if (bus->state == BUS_RUNNING)
1955 return 1;
1956
1957 for (;;) {
1958 r = sd_bus_process(bus, NULL);
1959 if (r < 0)
1960 return r;
1961 if (bus->state == BUS_RUNNING)
1962 return 1;
1963 if (r > 0)
1964 continue;
1965
1966 r = sd_bus_wait(bus, (uint64_t) -1);
1967 if (r < 0)
1968 return r;
1969 }
1970 }
1971
1972 _public_ int sd_bus_call(
1973 sd_bus *bus,
1974 sd_bus_message *_m,
1975 uint64_t usec,
1976 sd_bus_error *error,
1977 sd_bus_message **reply) {
1978
1979 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1980 usec_t timeout;
1981 uint64_t cookie;
1982 unsigned i;
1983 int r;
1984
1985 bus_assert_return(m, -EINVAL, error);
1986 bus_assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL, error);
1987 bus_assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL, error);
1988 bus_assert_return(!bus_error_is_dirty(error), -EINVAL, error);
1989
1990 if (!bus)
1991 bus = m->bus;
1992
1993 bus_assert_return(!bus_pid_changed(bus), -ECHILD, error);
1994 bus_assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS, error);
1995
1996 if (!BUS_IS_OPEN(bus->state)) {
1997 r = -ENOTCONN;
1998 goto fail;
1999 }
2000
2001 r = bus_ensure_running(bus);
2002 if (r < 0)
2003 goto fail;
2004
2005 i = bus->rqueue_size;
2006
2007 r = bus_seal_message(bus, m, usec);
2008 if (r < 0)
2009 goto fail;
2010
2011 r = bus_remarshal_message(bus, &m);
2012 if (r < 0)
2013 goto fail;
2014
2015 r = bus_send_internal(bus, m, &cookie, true);
2016 if (r < 0)
2017 goto fail;
2018
2019 timeout = calc_elapse(m->timeout);
2020
2021 for (;;) {
2022 usec_t left;
2023
2024 while (i < bus->rqueue_size) {
2025 sd_bus_message *incoming = NULL;
2026
2027 incoming = bus->rqueue[i];
2028
2029 if (incoming->reply_cookie == cookie) {
2030 /* Found a match! */
2031
2032 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2033 bus->rqueue_size--;
2034 log_debug_bus_message(incoming);
2035
2036 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
2037
2038 if (incoming->n_fds <= 0 || (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2039 if (reply)
2040 *reply = incoming;
2041 else
2042 sd_bus_message_unref(incoming);
2043
2044 return 1;
2045 }
2046
2047 r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry.");
2048 sd_bus_message_unref(incoming);
2049 return r;
2050
2051 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR) {
2052 r = sd_bus_error_copy(error, &incoming->error);
2053 sd_bus_message_unref(incoming);
2054 return r;
2055 } else {
2056 r = -EIO;
2057 goto fail;
2058 }
2059
2060 } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
2061 bus->unique_name &&
2062 incoming->sender &&
2063 streq(bus->unique_name, incoming->sender)) {
2064
2065 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2066 bus->rqueue_size--;
2067
2068 /* Our own message? Somebody is trying
2069 * to send its own client a message,
2070 * let's not dead-lock, let's fail
2071 * immediately. */
2072
2073 sd_bus_message_unref(incoming);
2074 r = -ELOOP;
2075 goto fail;
2076 }
2077
2078 /* Try to read more, right-away */
2079 i++;
2080 }
2081
2082 r = bus_read_message(bus, false, 0);
2083 if (r < 0) {
2084 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2085 bus_enter_closing(bus);
2086 r = -ECONNRESET;
2087 }
2088
2089 goto fail;
2090 }
2091 if (r > 0)
2092 continue;
2093
2094 if (timeout > 0) {
2095 usec_t n;
2096
2097 n = now(CLOCK_MONOTONIC);
2098 if (n >= timeout) {
2099 r = -ETIMEDOUT;
2100 goto fail;
2101 }
2102
2103 left = timeout - n;
2104 } else
2105 left = (uint64_t) -1;
2106
2107 r = bus_poll(bus, true, left);
2108 if (r < 0)
2109 goto fail;
2110 if (r == 0) {
2111 r = -ETIMEDOUT;
2112 goto fail;
2113 }
2114
2115 r = dispatch_wqueue(bus);
2116 if (r < 0) {
2117 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2118 bus_enter_closing(bus);
2119 r = -ECONNRESET;
2120 }
2121
2122 goto fail;
2123 }
2124 }
2125
2126 fail:
2127 return sd_bus_error_set_errno(error, r);
2128 }
2129
2130 _public_ int sd_bus_get_fd(sd_bus *bus) {
2131
2132 assert_return(bus, -EINVAL);
2133 assert_return(bus->input_fd == bus->output_fd, -EPERM);
2134 assert_return(!bus_pid_changed(bus), -ECHILD);
2135
2136 return bus->input_fd;
2137 }
2138
2139 _public_ int sd_bus_get_events(sd_bus *bus) {
2140 int flags = 0;
2141
2142 assert_return(bus, -EINVAL);
2143 assert_return(!bus_pid_changed(bus), -ECHILD);
2144
2145 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2146 return -ENOTCONN;
2147
2148 if (bus->state == BUS_OPENING)
2149 flags |= POLLOUT;
2150 else if (bus->state == BUS_AUTHENTICATING) {
2151
2152 if (bus_socket_auth_needs_write(bus))
2153 flags |= POLLOUT;
2154
2155 flags |= POLLIN;
2156
2157 } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
2158 if (bus->rqueue_size <= 0)
2159 flags |= POLLIN;
2160 if (bus->wqueue_size > 0)
2161 flags |= POLLOUT;
2162 }
2163
2164 return flags;
2165 }
2166
2167 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2168 struct reply_callback *c;
2169
2170 assert_return(bus, -EINVAL);
2171 assert_return(timeout_usec, -EINVAL);
2172 assert_return(!bus_pid_changed(bus), -ECHILD);
2173
2174 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2175 return -ENOTCONN;
2176
2177 if (bus->track_queue) {
2178 *timeout_usec = 0;
2179 return 1;
2180 }
2181
2182 if (bus->state == BUS_CLOSING) {
2183 *timeout_usec = 0;
2184 return 1;
2185 }
2186
2187 if (bus->state == BUS_AUTHENTICATING) {
2188 *timeout_usec = bus->auth_timeout;
2189 return 1;
2190 }
2191
2192 if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
2193 *timeout_usec = (uint64_t) -1;
2194 return 0;
2195 }
2196
2197 if (bus->rqueue_size > 0) {
2198 *timeout_usec = 0;
2199 return 1;
2200 }
2201
2202 c = prioq_peek(bus->reply_callbacks_prioq);
2203 if (!c) {
2204 *timeout_usec = (uint64_t) -1;
2205 return 0;
2206 }
2207
2208 if (c->timeout == 0) {
2209 *timeout_usec = (uint64_t) -1;
2210 return 0;
2211 }
2212
2213 *timeout_usec = c->timeout;
2214 return 1;
2215 }
2216
2217 static int process_timeout(sd_bus *bus) {
2218 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2219 _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
2220 struct reply_callback *c;
2221 sd_bus_slot *slot;
2222 usec_t n;
2223 int r;
2224
2225 assert(bus);
2226
2227 c = prioq_peek(bus->reply_callbacks_prioq);
2228 if (!c)
2229 return 0;
2230
2231 n = now(CLOCK_MONOTONIC);
2232 if (c->timeout > n)
2233 return 0;
2234
2235 r = bus_message_new_synthetic_error(
2236 bus,
2237 c->cookie,
2238 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2239 &m);
2240 if (r < 0)
2241 return r;
2242
2243 r = bus_seal_synthetic_message(bus, m);
2244 if (r < 0)
2245 return r;
2246
2247 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2248 c->timeout = 0;
2249
2250 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2251 c->cookie = 0;
2252
2253 slot = container_of(c, sd_bus_slot, reply_callback);
2254
2255 bus->iteration_counter ++;
2256
2257 bus->current_message = m;
2258 bus->current_slot = sd_bus_slot_ref(slot);
2259 bus->current_handler = c->callback;
2260 bus->current_userdata = slot->userdata;
2261 r = c->callback(m, slot->userdata, &error_buffer);
2262 bus->current_userdata = NULL;
2263 bus->current_handler = NULL;
2264 bus->current_slot = NULL;
2265 bus->current_message = NULL;
2266
2267 if (slot->floating) {
2268 bus_slot_disconnect(slot);
2269 sd_bus_slot_unref(slot);
2270 }
2271
2272 sd_bus_slot_unref(slot);
2273
2274 return bus_maybe_reply_error(m, r, &error_buffer);
2275 }
2276
2277 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2278 assert(bus);
2279 assert(m);
2280
2281 if (bus->state != BUS_HELLO)
2282 return 0;
2283
2284 /* Let's make sure the first message on the bus is the HELLO
2285 * reply. But note that we don't actually parse the message
2286 * here (we leave that to the usual handling), we just verify
2287 * we don't let any earlier msg through. */
2288
2289 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2290 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2291 return -EIO;
2292
2293 if (m->reply_cookie != 1)
2294 return -EIO;
2295
2296 return 0;
2297 }
2298
2299 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2300 _cleanup_bus_message_unref_ sd_bus_message *synthetic_reply = NULL;
2301 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2302 struct reply_callback *c;
2303 sd_bus_slot *slot;
2304 int r;
2305
2306 assert(bus);
2307 assert(m);
2308
2309 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2310 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2311 return 0;
2312
2313 if (bus->is_kernel && (bus->hello_flags & KDBUS_HELLO_MONITOR))
2314 return 0;
2315
2316 if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2317 return 0;
2318
2319 c = ordered_hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2320 if (!c)
2321 return 0;
2322
2323 c->cookie = 0;
2324
2325 slot = container_of(c, sd_bus_slot, reply_callback);
2326
2327 if (m->n_fds > 0 && !(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2328
2329 /* If the reply contained a file descriptor which we
2330 * didn't want we pass an error instead. */
2331
2332 r = bus_message_new_synthetic_error(
2333 bus,
2334 m->reply_cookie,
2335 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2336 &synthetic_reply);
2337 if (r < 0)
2338 return r;
2339
2340 /* Copy over original timestamp */
2341 synthetic_reply->realtime = m->realtime;
2342 synthetic_reply->monotonic = m->monotonic;
2343 synthetic_reply->seqnum = m->seqnum;
2344
2345 r = bus_seal_synthetic_message(bus, synthetic_reply);
2346 if (r < 0)
2347 return r;
2348
2349 m = synthetic_reply;
2350 } else {
2351 r = sd_bus_message_rewind(m, true);
2352 if (r < 0)
2353 return r;
2354 }
2355
2356 if (c->timeout != 0) {
2357 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2358 c->timeout = 0;
2359 }
2360
2361 bus->current_slot = sd_bus_slot_ref(slot);
2362 bus->current_handler = c->callback;
2363 bus->current_userdata = slot->userdata;
2364 r = c->callback(m, slot->userdata, &error_buffer);
2365 bus->current_userdata = NULL;
2366 bus->current_handler = NULL;
2367 bus->current_slot = NULL;
2368
2369 if (slot->floating) {
2370 bus_slot_disconnect(slot);
2371 sd_bus_slot_unref(slot);
2372 }
2373
2374 sd_bus_slot_unref(slot);
2375
2376 return bus_maybe_reply_error(m, r, &error_buffer);
2377 }
2378
2379 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2380 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2381 struct filter_callback *l;
2382 int r;
2383
2384 assert(bus);
2385 assert(m);
2386
2387 do {
2388 bus->filter_callbacks_modified = false;
2389
2390 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2391 sd_bus_slot *slot;
2392
2393 if (bus->filter_callbacks_modified)
2394 break;
2395
2396 /* Don't run this more than once per iteration */
2397 if (l->last_iteration == bus->iteration_counter)
2398 continue;
2399
2400 l->last_iteration = bus->iteration_counter;
2401
2402 r = sd_bus_message_rewind(m, true);
2403 if (r < 0)
2404 return r;
2405
2406 slot = container_of(l, sd_bus_slot, filter_callback);
2407
2408 bus->current_slot = sd_bus_slot_ref(slot);
2409 bus->current_handler = l->callback;
2410 bus->current_userdata = slot->userdata;
2411 r = l->callback(m, slot->userdata, &error_buffer);
2412 bus->current_userdata = NULL;
2413 bus->current_handler = NULL;
2414 bus->current_slot = sd_bus_slot_unref(slot);
2415
2416 r = bus_maybe_reply_error(m, r, &error_buffer);
2417 if (r != 0)
2418 return r;
2419
2420 }
2421
2422 } while (bus->filter_callbacks_modified);
2423
2424 return 0;
2425 }
2426
2427 static int process_match(sd_bus *bus, sd_bus_message *m) {
2428 int r;
2429
2430 assert(bus);
2431 assert(m);
2432
2433 do {
2434 bus->match_callbacks_modified = false;
2435
2436 r = bus_match_run(bus, &bus->match_callbacks, m);
2437 if (r != 0)
2438 return r;
2439
2440 } while (bus->match_callbacks_modified);
2441
2442 return 0;
2443 }
2444
2445 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2446 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2447 int r;
2448
2449 assert(bus);
2450 assert(m);
2451
2452 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2453 return 0;
2454
2455 if (bus->manual_peer_interface)
2456 return 0;
2457
2458 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2459 return 0;
2460
2461 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2462 return 0;
2463
2464 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2465 return 1;
2466
2467 if (streq_ptr(m->member, "Ping"))
2468 r = sd_bus_message_new_method_return(m, &reply);
2469 else if (streq_ptr(m->member, "GetMachineId")) {
2470 sd_id128_t id;
2471 char sid[33];
2472
2473 r = sd_id128_get_machine(&id);
2474 if (r < 0)
2475 return r;
2476
2477 r = sd_bus_message_new_method_return(m, &reply);
2478 if (r < 0)
2479 return r;
2480
2481 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2482 } else {
2483 r = sd_bus_message_new_method_errorf(
2484 m, &reply,
2485 SD_BUS_ERROR_UNKNOWN_METHOD,
2486 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2487 }
2488
2489 if (r < 0)
2490 return r;
2491
2492 r = sd_bus_send(bus, reply, NULL);
2493 if (r < 0)
2494 return r;
2495
2496 return 1;
2497 }
2498
2499 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2500 assert(bus);
2501 assert(m);
2502
2503 /* If we got a message with a file descriptor which we didn't
2504 * want to accept, then let's drop it. How can this even
2505 * happen? For example, when the kernel queues a message into
2506 * an activatable names's queue which allows fds, and then is
2507 * delivered to us later even though we ourselves did not
2508 * negotiate it. */
2509
2510 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2511 return 0;
2512
2513 if (m->n_fds <= 0)
2514 return 0;
2515
2516 if (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)
2517 return 0;
2518
2519 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2520 return 1; /* just eat it up */
2521
2522 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2523 }
2524
2525 static int process_message(sd_bus *bus, sd_bus_message *m) {
2526 int r;
2527
2528 assert(bus);
2529 assert(m);
2530
2531 bus->current_message = m;
2532 bus->iteration_counter++;
2533
2534 log_debug_bus_message(m);
2535
2536 r = process_hello(bus, m);
2537 if (r != 0)
2538 goto finish;
2539
2540 r = process_reply(bus, m);
2541 if (r != 0)
2542 goto finish;
2543
2544 r = process_fd_check(bus, m);
2545 if (r != 0)
2546 goto finish;
2547
2548 r = process_filter(bus, m);
2549 if (r != 0)
2550 goto finish;
2551
2552 r = process_match(bus, m);
2553 if (r != 0)
2554 goto finish;
2555
2556 r = process_builtin(bus, m);
2557 if (r != 0)
2558 goto finish;
2559
2560 r = bus_process_object(bus, m);
2561
2562 finish:
2563 bus->current_message = NULL;
2564 return r;
2565 }
2566
2567 static int dispatch_track(sd_bus *bus) {
2568 assert(bus);
2569
2570 if (!bus->track_queue)
2571 return 0;
2572
2573 bus_track_dispatch(bus->track_queue);
2574 return 1;
2575 }
2576
2577 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2578 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2579 int r;
2580
2581 assert(bus);
2582 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2583
2584 r = process_timeout(bus);
2585 if (r != 0)
2586 goto null_message;
2587
2588 r = dispatch_wqueue(bus);
2589 if (r != 0)
2590 goto null_message;
2591
2592 r = dispatch_track(bus);
2593 if (r != 0)
2594 goto null_message;
2595
2596 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2597 if (r < 0)
2598 return r;
2599 if (!m)
2600 goto null_message;
2601
2602 r = process_message(bus, m);
2603 if (r != 0)
2604 goto null_message;
2605
2606 if (ret) {
2607 r = sd_bus_message_rewind(m, true);
2608 if (r < 0)
2609 return r;
2610
2611 *ret = m;
2612 m = NULL;
2613 return 1;
2614 }
2615
2616 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2617
2618 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2619 strna(sd_bus_message_get_sender(m)),
2620 strna(sd_bus_message_get_path(m)),
2621 strna(sd_bus_message_get_interface(m)),
2622 strna(sd_bus_message_get_member(m)));
2623
2624 r = sd_bus_reply_method_errorf(
2625 m,
2626 SD_BUS_ERROR_UNKNOWN_OBJECT,
2627 "Unknown object '%s'.", m->path);
2628 if (r < 0)
2629 return r;
2630 }
2631
2632 return 1;
2633
2634 null_message:
2635 if (r >= 0 && ret)
2636 *ret = NULL;
2637
2638 return r;
2639 }
2640
2641 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2642 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2643 struct reply_callback *c;
2644 int r;
2645
2646 assert(bus);
2647 assert(bus->state == BUS_CLOSING);
2648
2649 c = ordered_hashmap_first(bus->reply_callbacks);
2650 if (c) {
2651 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2652 sd_bus_slot *slot;
2653
2654 /* First, fail all outstanding method calls */
2655 r = bus_message_new_synthetic_error(
2656 bus,
2657 c->cookie,
2658 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2659 &m);
2660 if (r < 0)
2661 return r;
2662
2663 r = bus_seal_synthetic_message(bus, m);
2664 if (r < 0)
2665 return r;
2666
2667 if (c->timeout != 0) {
2668 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2669 c->timeout = 0;
2670 }
2671
2672 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2673 c->cookie = 0;
2674
2675 slot = container_of(c, sd_bus_slot, reply_callback);
2676
2677 bus->iteration_counter++;
2678
2679 bus->current_message = m;
2680 bus->current_slot = sd_bus_slot_ref(slot);
2681 bus->current_handler = c->callback;
2682 bus->current_userdata = slot->userdata;
2683 r = c->callback(m, slot->userdata, &error_buffer);
2684 bus->current_userdata = NULL;
2685 bus->current_handler = NULL;
2686 bus->current_slot = NULL;
2687 bus->current_message = NULL;
2688
2689 if (slot->floating) {
2690 bus_slot_disconnect(slot);
2691 sd_bus_slot_unref(slot);
2692 }
2693
2694 sd_bus_slot_unref(slot);
2695
2696 return bus_maybe_reply_error(m, r, &error_buffer);
2697 }
2698
2699 /* Then, synthesize a Disconnected message */
2700 r = sd_bus_message_new_signal(
2701 bus,
2702 &m,
2703 "/org/freedesktop/DBus/Local",
2704 "org.freedesktop.DBus.Local",
2705 "Disconnected");
2706 if (r < 0)
2707 return r;
2708
2709 bus_message_set_sender_local(bus, m);
2710
2711 r = bus_seal_synthetic_message(bus, m);
2712 if (r < 0)
2713 return r;
2714
2715 sd_bus_close(bus);
2716
2717 bus->current_message = m;
2718 bus->iteration_counter++;
2719
2720 r = process_filter(bus, m);
2721 if (r != 0)
2722 goto finish;
2723
2724 r = process_match(bus, m);
2725 if (r != 0)
2726 goto finish;
2727
2728 if (ret) {
2729 *ret = m;
2730 m = NULL;
2731 }
2732
2733 r = 1;
2734
2735 finish:
2736 bus->current_message = NULL;
2737
2738 return r;
2739 }
2740
2741 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2742 BUS_DONT_DESTROY(bus);
2743 int r;
2744
2745 /* Returns 0 when we didn't do anything. This should cause the
2746 * caller to invoke sd_bus_wait() before returning the next
2747 * time. Returns > 0 when we did something, which possibly
2748 * means *ret is filled in with an unprocessed message. */
2749
2750 assert_return(bus, -EINVAL);
2751 assert_return(!bus_pid_changed(bus), -ECHILD);
2752
2753 /* We don't allow recursively invoking sd_bus_process(). */
2754 assert_return(!bus->current_message, -EBUSY);
2755 assert(!bus->current_slot);
2756
2757 switch (bus->state) {
2758
2759 case BUS_UNSET:
2760 return -ENOTCONN;
2761
2762 case BUS_CLOSED:
2763 return -ECONNRESET;
2764
2765 case BUS_OPENING:
2766 r = bus_socket_process_opening(bus);
2767 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2768 bus_enter_closing(bus);
2769 r = 1;
2770 } else if (r < 0)
2771 return r;
2772 if (ret)
2773 *ret = NULL;
2774 return r;
2775
2776 case BUS_AUTHENTICATING:
2777 r = bus_socket_process_authenticating(bus);
2778 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2779 bus_enter_closing(bus);
2780 r = 1;
2781 } else if (r < 0)
2782 return r;
2783
2784 if (ret)
2785 *ret = NULL;
2786
2787 return r;
2788
2789 case BUS_RUNNING:
2790 case BUS_HELLO:
2791 r = process_running(bus, hint_priority, priority, ret);
2792 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2793 bus_enter_closing(bus);
2794 r = 1;
2795
2796 if (ret)
2797 *ret = NULL;
2798 }
2799
2800 return r;
2801
2802 case BUS_CLOSING:
2803 return process_closing(bus, ret);
2804 }
2805
2806 assert_not_reached("Unknown state");
2807 }
2808
2809 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2810 return bus_process_internal(bus, false, 0, ret);
2811 }
2812
2813 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2814 return bus_process_internal(bus, true, priority, ret);
2815 }
2816
2817 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2818 struct pollfd p[2] = {};
2819 int r, e, n;
2820 struct timespec ts;
2821 usec_t m = USEC_INFINITY;
2822
2823 assert(bus);
2824
2825 if (bus->state == BUS_CLOSING)
2826 return 1;
2827
2828 if (!BUS_IS_OPEN(bus->state))
2829 return -ENOTCONN;
2830
2831 e = sd_bus_get_events(bus);
2832 if (e < 0)
2833 return e;
2834
2835 if (need_more)
2836 /* The caller really needs some more data, he doesn't
2837 * care about what's already read, or any timeouts
2838 * except its own. */
2839 e |= POLLIN;
2840 else {
2841 usec_t until;
2842 /* The caller wants to process if there's something to
2843 * process, but doesn't care otherwise */
2844
2845 r = sd_bus_get_timeout(bus, &until);
2846 if (r < 0)
2847 return r;
2848 if (r > 0) {
2849 usec_t nw;
2850 nw = now(CLOCK_MONOTONIC);
2851 m = until > nw ? until - nw : 0;
2852 }
2853 }
2854
2855 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2856 m = timeout_usec;
2857
2858 p[0].fd = bus->input_fd;
2859 if (bus->output_fd == bus->input_fd) {
2860 p[0].events = e;
2861 n = 1;
2862 } else {
2863 p[0].events = e & POLLIN;
2864 p[1].fd = bus->output_fd;
2865 p[1].events = e & POLLOUT;
2866 n = 2;
2867 }
2868
2869 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2870 if (r < 0)
2871 return -errno;
2872
2873 return r > 0 ? 1 : 0;
2874 }
2875
2876 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2877
2878 assert_return(bus, -EINVAL);
2879 assert_return(!bus_pid_changed(bus), -ECHILD);
2880
2881 if (bus->state == BUS_CLOSING)
2882 return 0;
2883
2884 if (!BUS_IS_OPEN(bus->state))
2885 return -ENOTCONN;
2886
2887 if (bus->rqueue_size > 0)
2888 return 0;
2889
2890 return bus_poll(bus, false, timeout_usec);
2891 }
2892
2893 _public_ int sd_bus_flush(sd_bus *bus) {
2894 int r;
2895
2896 assert_return(bus, -EINVAL);
2897 assert_return(!bus_pid_changed(bus), -ECHILD);
2898
2899 if (bus->state == BUS_CLOSING)
2900 return 0;
2901
2902 if (!BUS_IS_OPEN(bus->state))
2903 return -ENOTCONN;
2904
2905 r = bus_ensure_running(bus);
2906 if (r < 0)
2907 return r;
2908
2909 if (bus->wqueue_size <= 0)
2910 return 0;
2911
2912 for (;;) {
2913 r = dispatch_wqueue(bus);
2914 if (r < 0) {
2915 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2916 bus_enter_closing(bus);
2917 return -ECONNRESET;
2918 }
2919
2920 return r;
2921 }
2922
2923 if (bus->wqueue_size <= 0)
2924 return 0;
2925
2926 r = bus_poll(bus, false, (uint64_t) -1);
2927 if (r < 0)
2928 return r;
2929 }
2930 }
2931
2932 _public_ int sd_bus_add_filter(
2933 sd_bus *bus,
2934 sd_bus_slot **slot,
2935 sd_bus_message_handler_t callback,
2936 void *userdata) {
2937
2938 sd_bus_slot *s;
2939
2940 assert_return(bus, -EINVAL);
2941 assert_return(callback, -EINVAL);
2942 assert_return(!bus_pid_changed(bus), -ECHILD);
2943
2944 s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
2945 if (!s)
2946 return -ENOMEM;
2947
2948 s->filter_callback.callback = callback;
2949
2950 bus->filter_callbacks_modified = true;
2951 LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
2952
2953 if (slot)
2954 *slot = s;
2955
2956 return 0;
2957 }
2958
2959 _public_ int sd_bus_add_match(
2960 sd_bus *bus,
2961 sd_bus_slot **slot,
2962 const char *match,
2963 sd_bus_message_handler_t callback,
2964 void *userdata) {
2965
2966 struct bus_match_component *components = NULL;
2967 unsigned n_components = 0;
2968 sd_bus_slot *s = NULL;
2969 int r = 0;
2970
2971 assert_return(bus, -EINVAL);
2972 assert_return(match, -EINVAL);
2973 assert_return(!bus_pid_changed(bus), -ECHILD);
2974
2975 r = bus_match_parse(match, &components, &n_components);
2976 if (r < 0)
2977 goto finish;
2978
2979 s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
2980 if (!s) {
2981 r = -ENOMEM;
2982 goto finish;
2983 }
2984
2985 s->match_callback.callback = callback;
2986 s->match_callback.cookie = ++bus->match_cookie;
2987
2988 if (bus->bus_client) {
2989 enum bus_match_scope scope;
2990
2991 scope = bus_match_get_scope(components, n_components);
2992
2993 /* Do not install server-side matches for matches
2994 * against the local service, interface or bus
2995 * path. */
2996 if (scope != BUS_MATCH_LOCAL) {
2997
2998 if (!bus->is_kernel) {
2999 /* When this is not a kernel transport, we
3000 * store the original match string, so that we
3001 * can use it to remove the match again */
3002
3003 s->match_callback.match_string = strdup(match);
3004 if (!s->match_callback.match_string) {
3005 r = -ENOMEM;
3006 goto finish;
3007 }
3008 }
3009
3010 r = bus_add_match_internal(bus, s->match_callback.match_string, components, n_components, s->match_callback.cookie);
3011 if (r < 0)
3012 goto finish;
3013
3014 s->match_added = true;
3015 }
3016 }
3017
3018 bus->match_callbacks_modified = true;
3019 r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
3020 if (r < 0)
3021 goto finish;
3022
3023 if (slot)
3024 *slot = s;
3025 s = NULL;
3026
3027 finish:
3028 bus_match_parse_free(components, n_components);
3029 sd_bus_slot_unref(s);
3030
3031 return r;
3032 }
3033
3034 int bus_remove_match_by_string(
3035 sd_bus *bus,
3036 const char *match,
3037 sd_bus_message_handler_t callback,
3038 void *userdata) {
3039
3040 struct bus_match_component *components = NULL;
3041 unsigned n_components = 0;
3042 struct match_callback *c;
3043 int r = 0;
3044
3045 assert_return(bus, -EINVAL);
3046 assert_return(match, -EINVAL);
3047 assert_return(!bus_pid_changed(bus), -ECHILD);
3048
3049 r = bus_match_parse(match, &components, &n_components);
3050 if (r < 0)
3051 goto finish;
3052
3053 r = bus_match_find(&bus->match_callbacks, components, n_components, NULL, NULL, &c);
3054 if (r <= 0)
3055 goto finish;
3056
3057 sd_bus_slot_unref(container_of(c, sd_bus_slot, match_callback));
3058
3059 finish:
3060 bus_match_parse_free(components, n_components);
3061
3062 return r;
3063 }
3064
3065 bool bus_pid_changed(sd_bus *bus) {
3066 assert(bus);
3067
3068 /* We don't support people creating a bus connection and
3069 * keeping it around over a fork(). Let's complain. */
3070
3071 return bus->original_pid != getpid();
3072 }
3073
3074 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
3075 sd_bus *bus = userdata;
3076 int r;
3077
3078 assert(bus);
3079
3080 r = sd_bus_process(bus, NULL);
3081 if (r < 0)
3082 return r;
3083
3084 return 1;
3085 }
3086
3087 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
3088 sd_bus *bus = userdata;
3089 int r;
3090
3091 assert(bus);
3092
3093 r = sd_bus_process(bus, NULL);
3094 if (r < 0)
3095 return r;
3096
3097 return 1;
3098 }
3099
3100 static int prepare_callback(sd_event_source *s, void *userdata) {
3101 sd_bus *bus = userdata;
3102 int r, e;
3103 usec_t until;
3104
3105 assert(s);
3106 assert(bus);
3107
3108 e = sd_bus_get_events(bus);
3109 if (e < 0)
3110 return e;
3111
3112 if (bus->output_fd != bus->input_fd) {
3113
3114 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
3115 if (r < 0)
3116 return r;
3117
3118 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
3119 if (r < 0)
3120 return r;
3121 } else {
3122 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
3123 if (r < 0)
3124 return r;
3125 }
3126
3127 r = sd_bus_get_timeout(bus, &until);
3128 if (r < 0)
3129 return r;
3130 if (r > 0) {
3131 int j;
3132
3133 j = sd_event_source_set_time(bus->time_event_source, until);
3134 if (j < 0)
3135 return j;
3136 }
3137
3138 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
3139 if (r < 0)
3140 return r;
3141
3142 return 1;
3143 }
3144
3145 static int quit_callback(sd_event_source *event, void *userdata) {
3146 sd_bus *bus = userdata;
3147
3148 assert(event);
3149
3150 sd_bus_flush(bus);
3151 sd_bus_close(bus);
3152
3153 return 1;
3154 }
3155
3156 static int attach_io_events(sd_bus *bus) {
3157 int r;
3158
3159 assert(bus);
3160
3161 if (bus->input_fd < 0)
3162 return 0;
3163
3164 if (!bus->event)
3165 return 0;
3166
3167 if (!bus->input_io_event_source) {
3168 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3169 if (r < 0)
3170 return r;
3171
3172 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3173 if (r < 0)
3174 return r;
3175
3176 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3177 if (r < 0)
3178 return r;
3179
3180 r = sd_event_source_set_description(bus->input_io_event_source, "bus-input");
3181 } else
3182 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3183
3184 if (r < 0)
3185 return r;
3186
3187 if (bus->output_fd != bus->input_fd) {
3188 assert(bus->output_fd >= 0);
3189
3190 if (!bus->output_io_event_source) {
3191 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3192 if (r < 0)
3193 return r;
3194
3195 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3196 if (r < 0)
3197 return r;
3198
3199 r = sd_event_source_set_description(bus->input_io_event_source, "bus-output");
3200 } else
3201 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3202
3203 if (r < 0)
3204 return r;
3205 }
3206
3207 return 0;
3208 }
3209
3210 static void detach_io_events(sd_bus *bus) {
3211 assert(bus);
3212
3213 if (bus->input_io_event_source) {
3214 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3215 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3216 }
3217
3218 if (bus->output_io_event_source) {
3219 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3220 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3221 }
3222 }
3223
3224 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3225 int r;
3226
3227 assert_return(bus, -EINVAL);
3228 assert_return(!bus->event, -EBUSY);
3229
3230 assert(!bus->input_io_event_source);
3231 assert(!bus->output_io_event_source);
3232 assert(!bus->time_event_source);
3233
3234 if (event)
3235 bus->event = sd_event_ref(event);
3236 else {
3237 r = sd_event_default(&bus->event);
3238 if (r < 0)
3239 return r;
3240 }
3241
3242 bus->event_priority = priority;
3243
3244 r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3245 if (r < 0)
3246 goto fail;
3247
3248 r = sd_event_source_set_priority(bus->time_event_source, priority);
3249 if (r < 0)
3250 goto fail;
3251
3252 r = sd_event_source_set_description(bus->time_event_source, "bus-time");
3253 if (r < 0)
3254 goto fail;
3255
3256 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3257 if (r < 0)
3258 goto fail;
3259
3260 r = sd_event_source_set_description(bus->quit_event_source, "bus-exit");
3261 if (r < 0)
3262 goto fail;
3263
3264 r = attach_io_events(bus);
3265 if (r < 0)
3266 goto fail;
3267
3268 return 0;
3269
3270 fail:
3271 sd_bus_detach_event(bus);
3272 return r;
3273 }
3274
3275 _public_ int sd_bus_detach_event(sd_bus *bus) {
3276 assert_return(bus, -EINVAL);
3277
3278 if (!bus->event)
3279 return 0;
3280
3281 detach_io_events(bus);
3282
3283 if (bus->time_event_source) {
3284 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3285 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3286 }
3287
3288 if (bus->quit_event_source) {
3289 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3290 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3291 }
3292
3293 bus->event = sd_event_unref(bus->event);
3294 return 1;
3295 }
3296
3297 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3298 assert_return(bus, NULL);
3299
3300 return bus->event;
3301 }
3302
3303 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3304 assert_return(bus, NULL);
3305
3306 return bus->current_message;
3307 }
3308
3309 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3310 assert_return(bus, NULL);
3311
3312 return bus->current_slot;
3313 }
3314
3315 _public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) {
3316 assert_return(bus, NULL);
3317
3318 return bus->current_handler;
3319 }
3320
3321 _public_ void* sd_bus_get_current_userdata(sd_bus *bus) {
3322 assert_return(bus, NULL);
3323
3324 return bus->current_userdata;
3325 }
3326
3327 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3328 sd_bus *b = NULL;
3329 int r;
3330
3331 assert(bus_open);
3332 assert(default_bus);
3333
3334 if (!ret)
3335 return !!*default_bus;
3336
3337 if (*default_bus) {
3338 *ret = sd_bus_ref(*default_bus);
3339 return 0;
3340 }
3341
3342 r = bus_open(&b);
3343 if (r < 0)
3344 return r;
3345
3346 b->default_bus_ptr = default_bus;
3347 b->tid = gettid();
3348 *default_bus = b;
3349
3350 *ret = b;
3351 return 1;
3352 }
3353
3354 _public_ int sd_bus_default_system(sd_bus **ret) {
3355 static thread_local sd_bus *default_system_bus = NULL;
3356
3357 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3358 }
3359
3360 _public_ int sd_bus_default_user(sd_bus **ret) {
3361 static thread_local sd_bus *default_user_bus = NULL;
3362
3363 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3364 }
3365
3366 _public_ int sd_bus_default(sd_bus **ret) {
3367
3368 const char *e;
3369
3370 /* Let's try our best to reuse another cached connection. If
3371 * the starter bus type is set, connect via our normal
3372 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3373 * we can share the connection with the user/system default
3374 * bus. */
3375
3376 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3377 if (e) {
3378 if (streq(e, "system"))
3379 return sd_bus_default_system(ret);
3380 else if (STR_IN_SET(e, "user", "session"))
3381 return sd_bus_default_user(ret);
3382 }
3383
3384 /* No type is specified, so we have not other option than to
3385 * use the starter address if it is set. */
3386
3387 e = secure_getenv("DBUS_STARTER_ADDRESS");
3388 if (e) {
3389 static thread_local sd_bus *default_starter_bus = NULL;
3390
3391 return bus_default(sd_bus_open, &default_starter_bus, ret);
3392 }
3393
3394 /* Finally, if nothing is set use the cached connection for
3395 * the right scope */
3396
3397 if (cg_pid_get_owner_uid(0, NULL) >= 0)
3398 return sd_bus_default_user(ret);
3399 else
3400 return sd_bus_default_system(ret);
3401 }
3402
3403 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3404 assert_return(b, -EINVAL);
3405 assert_return(tid, -EINVAL);
3406 assert_return(!bus_pid_changed(b), -ECHILD);
3407
3408 if (b->tid != 0) {
3409 *tid = b->tid;
3410 return 0;
3411 }
3412
3413 if (b->event)
3414 return sd_event_get_tid(b->event, tid);
3415
3416 return -ENXIO;
3417 }
3418
3419 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3420 _cleanup_free_ char *e = NULL;
3421 char *ret;
3422
3423 assert_return(object_path_is_valid(prefix), -EINVAL);
3424 assert_return(external_id, -EINVAL);
3425 assert_return(ret_path, -EINVAL);
3426
3427 e = bus_label_escape(external_id);
3428 if (!e)
3429 return -ENOMEM;
3430
3431 ret = strjoin(prefix, "/", e, NULL);
3432 if (!ret)
3433 return -ENOMEM;
3434
3435 *ret_path = ret;
3436 return 0;
3437 }
3438
3439 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3440 const char *e;
3441 char *ret;
3442
3443 assert_return(object_path_is_valid(path), -EINVAL);
3444 assert_return(object_path_is_valid(prefix), -EINVAL);
3445 assert_return(external_id, -EINVAL);
3446
3447 e = object_path_startswith(path, prefix);
3448 if (!e) {
3449 *external_id = NULL;
3450 return 0;
3451 }
3452
3453 ret = bus_label_unescape(e);
3454 if (!ret)
3455 return -ENOMEM;
3456
3457 *external_id = ret;
3458 return 1;
3459 }
3460
3461 _public_ int sd_bus_try_close(sd_bus *bus) {
3462 int r;
3463
3464 assert_return(bus, -EINVAL);
3465 assert_return(!bus_pid_changed(bus), -ECHILD);
3466
3467 if (!bus->is_kernel)
3468 return -EOPNOTSUPP;
3469
3470 if (!BUS_IS_OPEN(bus->state))
3471 return -ENOTCONN;
3472
3473 if (bus->rqueue_size > 0)
3474 return -EBUSY;
3475
3476 if (bus->wqueue_size > 0)
3477 return -EBUSY;
3478
3479 r = bus_kernel_try_close(bus);
3480 if (r < 0)
3481 return r;
3482
3483 sd_bus_close(bus);
3484 return 0;
3485 }
3486
3487 _public_ int sd_bus_get_description(sd_bus *bus, const char **description) {
3488 assert_return(bus, -EINVAL);
3489 assert_return(description, -EINVAL);
3490 assert_return(bus->description, -ENXIO);
3491 assert_return(!bus_pid_changed(bus), -ECHILD);
3492
3493 *description = bus->description;
3494 return 0;
3495 }
3496
3497 int bus_get_root_path(sd_bus *bus) {
3498 int r;
3499
3500 if (bus->cgroup_root)
3501 return 0;
3502
3503 r = cg_get_root_path(&bus->cgroup_root);
3504 if (r == -ENOENT) {
3505 bus->cgroup_root = strdup("/");
3506 if (!bus->cgroup_root)
3507 return -ENOMEM;
3508
3509 r = 0;
3510 }
3511
3512 return r;
3513 }
3514
3515 _public_ int sd_bus_get_scope(sd_bus *bus, const char **scope) {
3516 int r;
3517
3518 assert_return(bus, -EINVAL);
3519 assert_return(scope, -EINVAL);
3520 assert_return(!bus_pid_changed(bus), -ECHILD);
3521
3522 if (bus->is_kernel) {
3523 _cleanup_free_ char *n = NULL;
3524 const char *dash;
3525
3526 r = bus_kernel_get_bus_name(bus, &n);
3527 if (r < 0)
3528 return r;
3529
3530 if (streq(n, "0-system")) {
3531 *scope = "system";
3532 return 0;
3533 }
3534
3535 dash = strchr(n, '-');
3536 if (streq_ptr(dash, "-user")) {
3537 *scope = "user";
3538 return 0;
3539 }
3540 }
3541
3542 if (bus->is_user) {
3543 *scope = "user";
3544 return 0;
3545 }
3546
3547 if (bus->is_system) {
3548 *scope = "system";
3549 return 0;
3550 }
3551
3552 return -ENODATA;
3553 }
3554
3555 _public_ int sd_bus_get_address(sd_bus *bus, const char **address) {
3556
3557 assert_return(bus, -EINVAL);
3558 assert_return(address, -EINVAL);
3559 assert_return(!bus_pid_changed(bus), -ECHILD);
3560
3561 if (bus->address) {
3562 *address = bus->address;
3563 return 0;
3564 }
3565
3566 return -ENODATA;
3567 }
3568
3569 _public_ int sd_bus_get_creds_mask(sd_bus *bus, uint64_t *mask) {
3570 assert_return(bus, -EINVAL);
3571 assert_return(mask, -EINVAL);
3572 assert_return(!bus_pid_changed(bus), -ECHILD);
3573
3574 *mask = bus->creds_mask;
3575 return 0;
3576 }
3577
3578 _public_ int sd_bus_is_bus_client(sd_bus *bus) {
3579 assert_return(bus, -EINVAL);
3580 assert_return(!bus_pid_changed(bus), -ECHILD);
3581
3582 return bus->bus_client;
3583 }
3584
3585 _public_ int sd_bus_is_server(sd_bus *bus) {
3586 assert_return(bus, -EINVAL);
3587 assert_return(!bus_pid_changed(bus), -ECHILD);
3588
3589 return bus->is_server;
3590 }
3591
3592 _public_ int sd_bus_is_anonymous(sd_bus *bus) {
3593 assert_return(bus, -EINVAL);
3594 assert_return(!bus_pid_changed(bus), -ECHILD);
3595
3596 return bus->anonymous_auth;
3597 }
3598
3599 _public_ int sd_bus_is_trusted(sd_bus *bus) {
3600 assert_return(bus, -EINVAL);
3601 assert_return(!bus_pid_changed(bus), -ECHILD);
3602
3603 return bus->trusted;
3604 }
3605
3606 _public_ int sd_bus_is_monitor(sd_bus *bus) {
3607 assert_return(bus, -EINVAL);
3608 assert_return(!bus_pid_changed(bus), -ECHILD);
3609
3610 return !!(bus->hello_flags & KDBUS_HELLO_MONITOR);
3611 }
Unnamed repository; edit this file 'description' to name the repository.