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