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