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