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