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