1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2013 Lennart Poettering
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.
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.
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/>.
35 #include "cgroup-util.h"
36 #include "hostname-util.h"
37 #include "bus-label.h"
40 #include "bus-internal.h"
41 #include "bus-message.h"
43 #include "bus-socket.h"
44 #include "bus-kernel.h"
45 #include "bus-control.h"
46 #include "bus-objects.h"
47 #include "bus-container.h"
48 #include "bus-protocol.h"
49 #include "bus-track.h"
52 #define log_debug_bus_message(m) \
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), \
64 strna(_mm->error.message)); \
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
);
71 static void bus_close_fds(sd_bus
*b
) {
76 if (b
->input_fd
!= b
->output_fd
)
77 safe_close(b
->output_fd
);
78 b
->output_fd
= b
->input_fd
= safe_close(b
->input_fd
);
81 static void bus_reset_queues(sd_bus
*b
) {
84 while (b
->rqueue_size
> 0)
85 sd_bus_message_unref(b
->rqueue
[--b
->rqueue_size
]);
87 b
->rqueue
= mfree(b
->rqueue
);
88 b
->rqueue_allocated
= 0;
90 while (b
->wqueue_size
> 0)
91 sd_bus_message_unref(b
->wqueue
[--b
->wqueue_size
]);
93 b
->wqueue
= mfree(b
->wqueue
);
94 b
->wqueue_allocated
= 0;
97 static void bus_free(sd_bus
*b
) {
101 assert(!b
->track_queue
);
103 b
->state
= BUS_CLOSED
;
105 sd_bus_detach_event(b
);
107 while ((s
= b
->slots
)) {
108 /* At this point only floating slots can still be
109 * around, because the non-floating ones keep a
110 * reference to the bus, and we thus couldn't be
111 * destructing right now... We forcibly disconnect the
112 * slots here, so that they still can be referenced by
113 * apps, but are dead. */
116 bus_slot_disconnect(s
);
117 sd_bus_slot_unref(s
);
120 if (b
->default_bus_ptr
)
121 *b
->default_bus_ptr
= NULL
;
126 munmap(b
->kdbus_buffer
, KDBUS_POOL_SIZE
);
130 free(b
->unique_name
);
131 free(b
->auth_buffer
);
136 free(b
->cgroup_root
);
137 free(b
->description
);
140 strv_free(b
->exec_argv
);
142 close_many(b
->fds
, b
->n_fds
);
147 ordered_hashmap_free_free(b
->reply_callbacks
);
148 prioq_free(b
->reply_callbacks_prioq
);
150 assert(b
->match_callbacks
.type
== BUS_MATCH_ROOT
);
151 bus_match_free(&b
->match_callbacks
);
153 hashmap_free_free(b
->vtable_methods
);
154 hashmap_free_free(b
->vtable_properties
);
156 assert(hashmap_isempty(b
->nodes
));
157 hashmap_free(b
->nodes
);
159 bus_kernel_flush_memfd(b
);
161 assert_se(pthread_mutex_destroy(&b
->memfd_cache_mutex
) == 0);
166 _public_
int sd_bus_new(sd_bus
**ret
) {
169 assert_return(ret
, -EINVAL
);
175 r
->n_ref
= REFCNT_INIT
;
176 r
->input_fd
= r
->output_fd
= -1;
177 r
->message_version
= 1;
178 r
->creds_mask
|= SD_BUS_CREDS_WELL_KNOWN_NAMES
|SD_BUS_CREDS_UNIQUE_NAME
;
179 r
->hello_flags
|= KDBUS_HELLO_ACCEPT_FD
;
180 r
->attach_flags
|= KDBUS_ATTACH_NAMES
;
181 r
->original_pid
= getpid();
183 assert_se(pthread_mutex_init(&r
->memfd_cache_mutex
, NULL
) == 0);
185 /* We guarantee that wqueue always has space for at least one
187 if (!GREEDY_REALLOC(r
->wqueue
, r
->wqueue_allocated
, 1)) {
196 _public_
int sd_bus_set_address(sd_bus
*bus
, const char *address
) {
199 assert_return(bus
, -EINVAL
);
200 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
201 assert_return(address
, -EINVAL
);
202 assert_return(!bus_pid_changed(bus
), -ECHILD
);
214 _public_
int sd_bus_set_fd(sd_bus
*bus
, int input_fd
, int output_fd
) {
215 assert_return(bus
, -EINVAL
);
216 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
217 assert_return(input_fd
>= 0, -EBADF
);
218 assert_return(output_fd
>= 0, -EBADF
);
219 assert_return(!bus_pid_changed(bus
), -ECHILD
);
221 bus
->input_fd
= input_fd
;
222 bus
->output_fd
= output_fd
;
226 _public_
int sd_bus_set_exec(sd_bus
*bus
, const char *path
, char *const argv
[]) {
229 assert_return(bus
, -EINVAL
);
230 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
231 assert_return(path
, -EINVAL
);
232 assert_return(!strv_isempty(argv
), -EINVAL
);
233 assert_return(!bus_pid_changed(bus
), -ECHILD
);
245 free(bus
->exec_path
);
246 strv_free(bus
->exec_argv
);
254 _public_
int sd_bus_set_bus_client(sd_bus
*bus
, int b
) {
255 assert_return(bus
, -EINVAL
);
256 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
257 assert_return(!bus_pid_changed(bus
), -ECHILD
);
259 bus
->bus_client
= !!b
;
263 _public_
int sd_bus_set_monitor(sd_bus
*bus
, int b
) {
264 assert_return(bus
, -EINVAL
);
265 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
266 assert_return(!bus_pid_changed(bus
), -ECHILD
);
268 SET_FLAG(bus
->hello_flags
, KDBUS_HELLO_MONITOR
, b
);
272 _public_
int sd_bus_negotiate_fds(sd_bus
*bus
, int b
) {
273 assert_return(bus
, -EINVAL
);
274 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
275 assert_return(!bus_pid_changed(bus
), -ECHILD
);
277 SET_FLAG(bus
->hello_flags
, KDBUS_HELLO_ACCEPT_FD
, b
);
281 _public_
int sd_bus_negotiate_timestamp(sd_bus
*bus
, int b
) {
283 assert_return(bus
, -EINVAL
);
284 assert_return(!IN_SET(bus
->state
, BUS_CLOSING
, BUS_CLOSED
), -EPERM
);
285 assert_return(!bus_pid_changed(bus
), -ECHILD
);
287 new_flags
= bus
->attach_flags
;
288 SET_FLAG(new_flags
, KDBUS_ATTACH_TIMESTAMP
, b
);
290 if (bus
->attach_flags
== new_flags
)
293 bus
->attach_flags
= new_flags
;
294 if (bus
->state
!= BUS_UNSET
&& bus
->is_kernel
)
295 bus_kernel_realize_attach_flags(bus
);
300 _public_
int sd_bus_negotiate_creds(sd_bus
*bus
, int b
, uint64_t mask
) {
303 assert_return(bus
, -EINVAL
);
304 assert_return(mask
<= _SD_BUS_CREDS_ALL
, -EINVAL
);
305 assert_return(!IN_SET(bus
->state
, BUS_CLOSING
, BUS_CLOSED
), -EPERM
);
306 assert_return(!bus_pid_changed(bus
), -ECHILD
);
309 bus
->creds_mask
|= mask
;
311 bus
->creds_mask
&= ~mask
;
313 /* The well knowns we need unconditionally, so that matches can work */
314 bus
->creds_mask
|= SD_BUS_CREDS_WELL_KNOWN_NAMES
|SD_BUS_CREDS_UNIQUE_NAME
;
316 /* Make sure we don't lose the timestamp flag */
317 new_flags
= (bus
->attach_flags
& KDBUS_ATTACH_TIMESTAMP
) | attach_flags_to_kdbus(bus
->creds_mask
);
318 if (bus
->attach_flags
== new_flags
)
321 bus
->attach_flags
= new_flags
;
322 if (bus
->state
!= BUS_UNSET
&& bus
->is_kernel
)
323 bus_kernel_realize_attach_flags(bus
);
328 _public_
int sd_bus_set_server(sd_bus
*bus
, int b
, sd_id128_t server_id
) {
329 assert_return(bus
, -EINVAL
);
330 assert_return(b
|| sd_id128_equal(server_id
, SD_ID128_NULL
), -EINVAL
);
331 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
332 assert_return(!bus_pid_changed(bus
), -ECHILD
);
334 bus
->is_server
= !!b
;
335 bus
->server_id
= server_id
;
339 _public_
int sd_bus_set_anonymous(sd_bus
*bus
, int b
) {
340 assert_return(bus
, -EINVAL
);
341 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
342 assert_return(!bus_pid_changed(bus
), -ECHILD
);
344 bus
->anonymous_auth
= !!b
;
348 _public_
int sd_bus_set_trusted(sd_bus
*bus
, int b
) {
349 assert_return(bus
, -EINVAL
);
350 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
351 assert_return(!bus_pid_changed(bus
), -ECHILD
);
357 _public_
int sd_bus_set_description(sd_bus
*bus
, const char *description
) {
358 assert_return(bus
, -EINVAL
);
359 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
360 assert_return(!bus_pid_changed(bus
), -ECHILD
);
362 return free_and_strdup(&bus
->description
, description
);
365 _public_
int sd_bus_set_allow_interactive_authorization(sd_bus
*bus
, int b
) {
366 assert_return(bus
, -EINVAL
);
367 assert_return(!bus_pid_changed(bus
), -ECHILD
);
369 bus
->allow_interactive_authorization
= !!b
;
373 _public_
int sd_bus_get_allow_interactive_authorization(sd_bus
*bus
) {
374 assert_return(bus
, -EINVAL
);
375 assert_return(!bus_pid_changed(bus
), -ECHILD
);
377 return bus
->allow_interactive_authorization
;
380 static int hello_callback(sd_bus_message
*reply
, void *userdata
, sd_bus_error
*error
) {
388 assert(bus
->state
== BUS_HELLO
|| bus
->state
== BUS_CLOSING
);
390 r
= sd_bus_message_get_errno(reply
);
394 r
= sd_bus_message_read(reply
, "s", &s
);
398 if (!service_name_is_valid(s
) || s
[0] != ':')
401 bus
->unique_name
= strdup(s
);
402 if (!bus
->unique_name
)
405 if (bus
->state
== BUS_HELLO
)
406 bus
->state
= BUS_RUNNING
;
411 static int bus_send_hello(sd_bus
*bus
) {
412 _cleanup_bus_message_unref_ sd_bus_message
*m
= NULL
;
417 if (!bus
->bus_client
|| bus
->is_kernel
)
420 r
= sd_bus_message_new_method_call(
423 "org.freedesktop.DBus",
424 "/org/freedesktop/DBus",
425 "org.freedesktop.DBus",
430 return sd_bus_call_async(bus
, NULL
, m
, hello_callback
, NULL
, 0);
433 int bus_start_running(sd_bus
*bus
) {
436 if (bus
->bus_client
&& !bus
->is_kernel
) {
437 bus
->state
= BUS_HELLO
;
441 bus
->state
= BUS_RUNNING
;
445 static int parse_address_key(const char **p
, const char *key
, char **value
) {
446 size_t l
, n
= 0, allocated
= 0;
456 if (strncmp(*p
, key
, l
) != 0)
469 while (*a
!= ';' && *a
!= ',' && *a
!= 0) {
487 c
= (char) ((x
<< 4) | y
);
494 if (!GREEDY_REALLOC(r
, allocated
, n
+ 2))
518 static void skip_address_key(const char **p
) {
522 *p
+= strcspn(*p
, ",");
528 static int parse_unix_address(sd_bus
*b
, const char **p
, char **guid
) {
529 _cleanup_free_
char *path
= NULL
, *abstract
= NULL
;
538 while (**p
!= 0 && **p
!= ';') {
539 r
= parse_address_key(p
, "guid", guid
);
545 r
= parse_address_key(p
, "path", &path
);
551 r
= parse_address_key(p
, "abstract", &abstract
);
560 if (!path
&& !abstract
)
563 if (path
&& abstract
)
568 if (l
> sizeof(b
->sockaddr
.un
.sun_path
))
571 b
->sockaddr
.un
.sun_family
= AF_UNIX
;
572 strncpy(b
->sockaddr
.un
.sun_path
, path
, sizeof(b
->sockaddr
.un
.sun_path
));
573 b
->sockaddr_size
= offsetof(struct sockaddr_un
, sun_path
) + l
;
574 } else if (abstract
) {
575 l
= strlen(abstract
);
576 if (l
> sizeof(b
->sockaddr
.un
.sun_path
) - 1)
579 b
->sockaddr
.un
.sun_family
= AF_UNIX
;
580 b
->sockaddr
.un
.sun_path
[0] = 0;
581 strncpy(b
->sockaddr
.un
.sun_path
+1, abstract
, sizeof(b
->sockaddr
.un
.sun_path
)-1);
582 b
->sockaddr_size
= offsetof(struct sockaddr_un
, sun_path
) + 1 + l
;
588 static int parse_tcp_address(sd_bus
*b
, const char **p
, char **guid
) {
589 _cleanup_free_
char *host
= NULL
, *port
= NULL
, *family
= NULL
;
591 struct addrinfo
*result
, hints
= {
592 .ai_socktype
= SOCK_STREAM
,
593 .ai_flags
= AI_ADDRCONFIG
,
601 while (**p
!= 0 && **p
!= ';') {
602 r
= parse_address_key(p
, "guid", guid
);
608 r
= parse_address_key(p
, "host", &host
);
614 r
= parse_address_key(p
, "port", &port
);
620 r
= parse_address_key(p
, "family", &family
);
633 if (streq(family
, "ipv4"))
634 hints
.ai_family
= AF_INET
;
635 else if (streq(family
, "ipv6"))
636 hints
.ai_family
= AF_INET6
;
641 r
= getaddrinfo(host
, port
, &hints
, &result
);
645 return -EADDRNOTAVAIL
;
647 memcpy(&b
->sockaddr
, result
->ai_addr
, result
->ai_addrlen
);
648 b
->sockaddr_size
= result
->ai_addrlen
;
650 freeaddrinfo(result
);
655 static int parse_exec_address(sd_bus
*b
, const char **p
, char **guid
) {
657 unsigned n_argv
= 0, j
;
659 size_t allocated
= 0;
667 while (**p
!= 0 && **p
!= ';') {
668 r
= parse_address_key(p
, "guid", guid
);
674 r
= parse_address_key(p
, "path", &path
);
680 if (startswith(*p
, "argv")) {
684 ul
= strtoul(*p
+ 4, (char**) p
, 10);
685 if (errno
> 0 || **p
!= '=' || ul
> 256) {
693 if (!GREEDY_REALLOC0(argv
, allocated
, ul
+ 2)) {
701 r
= parse_address_key(p
, NULL
, argv
+ ul
);
716 /* Make sure there are no holes in the array, with the
717 * exception of argv[0] */
718 for (j
= 1; j
< n_argv
; j
++)
724 if (argv
&& argv
[0] == NULL
) {
725 argv
[0] = strdup(path
);
737 for (j
= 0; j
< n_argv
; j
++)
745 static int parse_kernel_address(sd_bus
*b
, const char **p
, char **guid
) {
746 _cleanup_free_
char *path
= NULL
;
754 while (**p
!= 0 && **p
!= ';') {
755 r
= parse_address_key(p
, "guid", guid
);
761 r
= parse_address_key(p
, "path", &path
);
780 static int parse_container_unix_address(sd_bus
*b
, const char **p
, char **guid
) {
781 _cleanup_free_
char *machine
= NULL
, *pid
= NULL
;
789 while (**p
!= 0 && **p
!= ';') {
790 r
= parse_address_key(p
, "guid", guid
);
796 r
= parse_address_key(p
, "machine", &machine
);
802 r
= parse_address_key(p
, "pid", &pid
);
811 if (!machine
== !pid
)
815 if (!machine_name_is_valid(machine
))
819 b
->machine
= machine
;
827 r
= parse_pid(pid
, &b
->nspid
);
833 b
->sockaddr
.un
.sun_family
= AF_UNIX
;
834 strncpy(b
->sockaddr
.un
.sun_path
, "/var/run/dbus/system_bus_socket", sizeof(b
->sockaddr
.un
.sun_path
));
835 b
->sockaddr_size
= offsetof(struct sockaddr_un
, sun_path
) + strlen("/var/run/dbus/system_bus_socket");
840 static int parse_container_kernel_address(sd_bus
*b
, const char **p
, char **guid
) {
841 _cleanup_free_
char *machine
= NULL
, *pid
= NULL
;
849 while (**p
!= 0 && **p
!= ';') {
850 r
= parse_address_key(p
, "guid", guid
);
856 r
= parse_address_key(p
, "machine", &machine
);
862 r
= parse_address_key(p
, "pid", &pid
);
871 if (!machine
== !pid
)
875 if (!machine_name_is_valid(machine
))
879 b
->machine
= machine
;
887 r
= parse_pid(pid
, &b
->nspid
);
893 r
= free_and_strdup(&b
->kernel
, "/sys/fs/kdbus/0-system/bus");
900 static void bus_reset_parsed_address(sd_bus
*b
) {
904 b
->sockaddr_size
= 0;
905 b
->exec_argv
= strv_free(b
->exec_argv
);
906 b
->exec_path
= mfree(b
->exec_path
);
907 b
->server_id
= SD_ID128_NULL
;
908 b
->kernel
= mfree(b
->kernel
);
909 b
->machine
= mfree(b
->machine
);
913 static int bus_parse_next_address(sd_bus
*b
) {
914 _cleanup_free_
char *guid
= NULL
;
922 if (b
->address
[b
->address_index
] == 0)
925 bus_reset_parsed_address(b
);
927 a
= b
->address
+ b
->address_index
;
936 if (startswith(a
, "unix:")) {
939 r
= parse_unix_address(b
, &a
, &guid
);
944 } else if (startswith(a
, "tcp:")) {
947 r
= parse_tcp_address(b
, &a
, &guid
);
953 } else if (startswith(a
, "unixexec:")) {
956 r
= parse_exec_address(b
, &a
, &guid
);
962 } else if (startswith(a
, "kernel:")) {
965 r
= parse_kernel_address(b
, &a
, &guid
);
970 } else if (startswith(a
, "x-machine-unix:")) {
973 r
= parse_container_unix_address(b
, &a
, &guid
);
978 } else if (startswith(a
, "x-machine-kernel:")) {
981 r
= parse_container_kernel_address(b
, &a
, &guid
);
994 r
= sd_id128_from_string(guid
, &b
->server_id
);
999 b
->address_index
= a
- b
->address
;
1003 static int bus_start_address(sd_bus
*b
) {
1009 bool skipped
= false;
1014 r
= bus_socket_exec(b
);
1015 else if ((b
->nspid
> 0 || b
->machine
) && b
->kernel
)
1016 r
= bus_container_connect_kernel(b
);
1017 else if ((b
->nspid
> 0 || b
->machine
) && b
->sockaddr
.sa
.sa_family
!= AF_UNSPEC
)
1018 r
= bus_container_connect_socket(b
);
1020 r
= bus_kernel_connect(b
);
1021 else if (b
->sockaddr
.sa
.sa_family
!= AF_UNSPEC
)
1022 r
= bus_socket_connect(b
);
1028 r
= attach_io_events(b
);
1033 b
->last_connect_error
= -r
;
1036 r
= bus_parse_next_address(b
);
1040 return b
->last_connect_error
? -b
->last_connect_error
: -ECONNREFUSED
;
1044 int bus_next_address(sd_bus
*b
) {
1047 bus_reset_parsed_address(b
);
1048 return bus_start_address(b
);
1051 static int bus_start_fd(sd_bus
*b
) {
1056 assert(b
->input_fd
>= 0);
1057 assert(b
->output_fd
>= 0);
1059 r
= fd_nonblock(b
->input_fd
, true);
1063 r
= fd_cloexec(b
->input_fd
, true);
1067 if (b
->input_fd
!= b
->output_fd
) {
1068 r
= fd_nonblock(b
->output_fd
, true);
1072 r
= fd_cloexec(b
->output_fd
, true);
1077 if (fstat(b
->input_fd
, &st
) < 0)
1080 if (S_ISCHR(b
->input_fd
))
1081 return bus_kernel_take_fd(b
);
1083 return bus_socket_take_fd(b
);
1086 _public_
int sd_bus_start(sd_bus
*bus
) {
1089 assert_return(bus
, -EINVAL
);
1090 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
1091 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1093 bus
->state
= BUS_OPENING
;
1095 if (bus
->is_server
&& bus
->bus_client
)
1098 if (bus
->input_fd
>= 0)
1099 r
= bus_start_fd(bus
);
1100 else if (bus
->address
|| bus
->sockaddr
.sa
.sa_family
!= AF_UNSPEC
|| bus
->exec_path
|| bus
->kernel
|| bus
->machine
)
1101 r
= bus_start_address(bus
);
1110 return bus_send_hello(bus
);
1113 _public_
int sd_bus_open(sd_bus
**ret
) {
1118 assert_return(ret
, -EINVAL
);
1120 /* Let's connect to the starter bus if it is set, and
1121 * otherwise to the bus that is appropropriate for the scope
1122 * we are running in */
1124 e
= secure_getenv("DBUS_STARTER_BUS_TYPE");
1126 if (streq(e
, "system"))
1127 return sd_bus_open_system(ret
);
1128 else if (STR_IN_SET(e
, "session", "user"))
1129 return sd_bus_open_user(ret
);
1132 e
= secure_getenv("DBUS_STARTER_ADDRESS");
1134 if (cg_pid_get_owner_uid(0, NULL
) >= 0)
1135 return sd_bus_open_user(ret
);
1137 return sd_bus_open_system(ret
);
1144 r
= sd_bus_set_address(b
, e
);
1148 b
->bus_client
= true;
1150 /* We don't know whether the bus is trusted or not, so better
1151 * be safe, and authenticate everything */
1153 b
->attach_flags
|= KDBUS_ATTACH_CAPS
| KDBUS_ATTACH_CREDS
;
1154 b
->creds_mask
|= SD_BUS_CREDS_UID
| SD_BUS_CREDS_EUID
| SD_BUS_CREDS_EFFECTIVE_CAPS
;
1156 r
= sd_bus_start(b
);
1168 int bus_set_address_system(sd_bus
*b
) {
1172 e
= secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1174 return sd_bus_set_address(b
, e
);
1176 if (is_kdbus_available())
1177 return sd_bus_set_address(b
, KERNEL_SYSTEM_BUS_ADDRESS
);
1179 return sd_bus_set_address(b
, UNIX_SYSTEM_BUS_ADDRESS
);
1182 _public_
int sd_bus_open_system(sd_bus
**ret
) {
1186 assert_return(ret
, -EINVAL
);
1192 r
= bus_set_address_system(b
);
1196 b
->bus_client
= true;
1197 b
->is_system
= true;
1199 /* Let's do per-method access control on the system bus. We
1200 * need the caller's UID and capability set for that. */
1202 b
->attach_flags
|= KDBUS_ATTACH_CAPS
| KDBUS_ATTACH_CREDS
;
1203 b
->creds_mask
|= SD_BUS_CREDS_UID
| SD_BUS_CREDS_EUID
| SD_BUS_CREDS_EFFECTIVE_CAPS
;
1205 r
= sd_bus_start(b
);
1217 int bus_set_address_user(sd_bus
*b
) {
1222 e
= secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1224 return sd_bus_set_address(b
, e
);
1226 e
= secure_getenv("XDG_RUNTIME_DIR");
1227 if (is_kdbus_available())
1228 (void) asprintf(&b
->address
, KERNEL_USER_BUS_ADDRESS_FMT
, getuid());
1230 _cleanup_free_
char *ee
= NULL
;
1232 ee
= bus_address_escape(e
);
1236 (void) asprintf(&b
->address
, UNIX_USER_BUS_ADDRESS_FMT
, ee
);
1245 _public_
int sd_bus_open_user(sd_bus
**ret
) {
1249 assert_return(ret
, -EINVAL
);
1255 r
= bus_set_address_user(b
);
1259 b
->bus_client
= true;
1262 /* We don't do any per-method access control on the user
1266 r
= sd_bus_start(b
);
1278 int bus_set_address_system_remote(sd_bus
*b
, const char *host
) {
1279 _cleanup_free_
char *e
= NULL
;
1280 char *m
= NULL
, *c
= NULL
;
1285 /* Let's see if we shall enter some container */
1286 m
= strchr(host
, ':');
1290 /* Let's make sure this is not a port of some kind,
1291 * and is a valid machine name. */
1292 if (!in_charset(m
, "0123456789") && machine_name_is_valid(m
)) {
1295 /* Cut out the host part */
1296 t
= strndupa(host
, m
- host
- 1);
1297 e
= bus_address_escape(t
);
1301 c
= strjoina(",argv4=--machine=", m
);
1306 e
= bus_address_escape(host
);
1311 b
->address
= strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e
, ",argv3=systemd-stdio-bridge", c
, NULL
);
1318 _public_
int sd_bus_open_system_remote(sd_bus
**ret
, const char *host
) {
1322 assert_return(host
, -EINVAL
);
1323 assert_return(ret
, -EINVAL
);
1325 r
= sd_bus_new(&bus
);
1329 r
= bus_set_address_system_remote(bus
, host
);
1333 bus
->bus_client
= true;
1334 bus
->trusted
= false;
1335 bus
->is_system
= true;
1337 r
= sd_bus_start(bus
);
1349 int bus_set_address_system_machine(sd_bus
*b
, const char *machine
) {
1350 _cleanup_free_
char *e
= NULL
;
1355 e
= bus_address_escape(machine
);
1359 b
->address
= strjoin("x-machine-kernel:machine=", e
, ";x-machine-unix:machine=", e
, NULL
);
1366 _public_
int sd_bus_open_system_machine(sd_bus
**ret
, const char *machine
) {
1370 assert_return(machine
, -EINVAL
);
1371 assert_return(ret
, -EINVAL
);
1372 assert_return(machine_name_is_valid(machine
), -EINVAL
);
1374 r
= sd_bus_new(&bus
);
1378 r
= bus_set_address_system_machine(bus
, machine
);
1382 bus
->bus_client
= true;
1383 bus
->trusted
= false;
1384 bus
->is_system
= true;
1386 r
= sd_bus_start(bus
);
1398 _public_
void sd_bus_close(sd_bus
*bus
) {
1402 if (bus
->state
== BUS_CLOSED
)
1404 if (bus_pid_changed(bus
))
1407 bus
->state
= BUS_CLOSED
;
1409 sd_bus_detach_event(bus
);
1411 /* Drop all queued messages so that they drop references to
1412 * the bus object and the bus may be freed */
1413 bus_reset_queues(bus
);
1415 if (!bus
->is_kernel
)
1418 /* We'll leave the fd open in case this is a kernel bus, since
1419 * there might still be memblocks around that reference this
1420 * bus, and they might need to invoke the KDBUS_CMD_FREE
1421 * ioctl on the fd when they are freed. */
1424 _public_ sd_bus
* sd_bus_flush_close_unref(sd_bus
*bus
) {
1432 return sd_bus_unref(bus
);
1435 static void bus_enter_closing(sd_bus
*bus
) {
1438 if (bus
->state
!= BUS_OPENING
&&
1439 bus
->state
!= BUS_AUTHENTICATING
&&
1440 bus
->state
!= BUS_HELLO
&&
1441 bus
->state
!= BUS_RUNNING
)
1444 bus
->state
= BUS_CLOSING
;
1447 _public_ sd_bus
*sd_bus_ref(sd_bus
*bus
) {
1448 assert_return(bus
, NULL
);
1450 assert_se(REFCNT_INC(bus
->n_ref
) >= 2);
1455 _public_ sd_bus
*sd_bus_unref(sd_bus
*bus
) {
1461 i
= REFCNT_DEC(bus
->n_ref
);
1469 _public_
int sd_bus_is_open(sd_bus
*bus
) {
1471 assert_return(bus
, -EINVAL
);
1472 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1474 return BUS_IS_OPEN(bus
->state
);
1477 _public_
int sd_bus_can_send(sd_bus
*bus
, char type
) {
1480 assert_return(bus
, -EINVAL
);
1481 assert_return(bus
->state
!= BUS_UNSET
, -ENOTCONN
);
1482 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1484 if (bus
->hello_flags
& KDBUS_HELLO_MONITOR
)
1487 if (type
== SD_BUS_TYPE_UNIX_FD
) {
1488 if (!(bus
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
))
1491 r
= bus_ensure_running(bus
);
1495 return bus
->can_fds
;
1498 return bus_type_is_valid(type
);
1501 _public_
int sd_bus_get_bus_id(sd_bus
*bus
, sd_id128_t
*id
) {
1504 assert_return(bus
, -EINVAL
);
1505 assert_return(id
, -EINVAL
);
1506 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1508 r
= bus_ensure_running(bus
);
1512 *id
= bus
->server_id
;
1516 static int bus_seal_message(sd_bus
*b
, sd_bus_message
*m
, usec_t timeout
) {
1521 /* If we copy the same message to multiple
1522 * destinations, avoid using the same cookie
1524 b
->cookie
= MAX(b
->cookie
, BUS_MESSAGE_COOKIE(m
));
1529 timeout
= BUS_DEFAULT_TIMEOUT
;
1531 return bus_message_seal(m
, ++b
->cookie
, timeout
);
1534 static int bus_remarshal_message(sd_bus
*b
, sd_bus_message
**m
) {
1535 bool remarshal
= false;
1539 /* wrong packet version */
1540 if (b
->message_version
!= 0 && b
->message_version
!= (*m
)->header
->version
)
1543 /* wrong packet endianness */
1544 if (b
->message_endian
!= 0 && b
->message_endian
!= (*m
)->header
->endian
)
1547 /* TODO: kdbus-messages received from the kernel contain data which is
1548 * not allowed to be passed to KDBUS_CMD_SEND. Therefore, we have to
1549 * force remarshaling of the message. Technically, we could just
1550 * recreate the kdbus message, but that is non-trivial as other parts of
1551 * the message refer to m->kdbus already. This should be fixed! */
1552 if ((*m
)->kdbus
&& (*m
)->release_kdbus
)
1555 return remarshal
? bus_message_remarshal(b
, m
) : 0;
1558 int bus_seal_synthetic_message(sd_bus
*b
, sd_bus_message
*m
) {
1562 /* Fake some timestamps, if they were requested, and not
1563 * already initialized */
1564 if (b
->attach_flags
& KDBUS_ATTACH_TIMESTAMP
) {
1565 if (m
->realtime
<= 0)
1566 m
->realtime
= now(CLOCK_REALTIME
);
1568 if (m
->monotonic
<= 0)
1569 m
->monotonic
= now(CLOCK_MONOTONIC
);
1572 /* The bus specification says the serial number cannot be 0,
1573 * hence let's fill something in for synthetic messages. Since
1574 * synthetic messages might have a fake sender and we don't
1575 * want to interfere with the real sender's serial numbers we
1576 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1577 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1578 * even though kdbus can do 64bit. */
1579 return bus_message_seal(m
, 0xFFFFFFFFULL
, 0);
1582 static int bus_write_message(sd_bus
*bus
, sd_bus_message
*m
, bool hint_sync_call
, size_t *idx
) {
1589 r
= bus_kernel_write_message(bus
, m
, hint_sync_call
);
1591 r
= bus_socket_write_message(bus
, m
, idx
);
1596 if (bus
->is_kernel
|| *idx
>= BUS_MESSAGE_SIZE(m
))
1597 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64
" reply_cookie=%" PRIu64
" error=%s",
1598 bus_message_type_to_string(m
->header
->type
),
1599 strna(sd_bus_message_get_sender(m
)),
1600 strna(sd_bus_message_get_destination(m
)),
1601 strna(sd_bus_message_get_path(m
)),
1602 strna(sd_bus_message_get_interface(m
)),
1603 strna(sd_bus_message_get_member(m
)),
1604 BUS_MESSAGE_COOKIE(m
),
1606 strna(m
->error
.message
));
1611 static int dispatch_wqueue(sd_bus
*bus
) {
1615 assert(bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
);
1617 while (bus
->wqueue_size
> 0) {
1619 r
= bus_write_message(bus
, bus
->wqueue
[0], false, &bus
->windex
);
1623 /* Didn't do anything this time */
1625 else if (bus
->is_kernel
|| bus
->windex
>= BUS_MESSAGE_SIZE(bus
->wqueue
[0])) {
1626 /* Fully written. Let's drop the entry from
1629 * This isn't particularly optimized, but
1630 * well, this is supposed to be our worst-case
1631 * buffer only, and the socket buffer is
1632 * supposed to be our primary buffer, and if
1633 * it got full, then all bets are off
1636 bus
->wqueue_size
--;
1637 sd_bus_message_unref(bus
->wqueue
[0]);
1638 memmove(bus
->wqueue
, bus
->wqueue
+ 1, sizeof(sd_bus_message
*) * bus
->wqueue_size
);
1648 static int bus_read_message(sd_bus
*bus
, bool hint_priority
, int64_t priority
) {
1652 return bus_kernel_read_message(bus
, hint_priority
, priority
);
1654 return bus_socket_read_message(bus
);
1657 int bus_rqueue_make_room(sd_bus
*bus
) {
1660 if (bus
->rqueue_size
>= BUS_RQUEUE_MAX
)
1663 if (!GREEDY_REALLOC(bus
->rqueue
, bus
->rqueue_allocated
, bus
->rqueue_size
+ 1))
1669 static int dispatch_rqueue(sd_bus
*bus
, bool hint_priority
, int64_t priority
, sd_bus_message
**m
) {
1674 assert(bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
);
1676 /* Note that the priority logic is only available on kdbus,
1677 * where the rqueue is unused. We check the rqueue here
1678 * anyway, because it's simple... */
1681 if (bus
->rqueue_size
> 0) {
1682 /* Dispatch a queued message */
1684 *m
= bus
->rqueue
[0];
1685 bus
->rqueue_size
--;
1686 memmove(bus
->rqueue
, bus
->rqueue
+ 1, sizeof(sd_bus_message
*) * bus
->rqueue_size
);
1690 /* Try to read a new message */
1691 r
= bus_read_message(bus
, hint_priority
, priority
);
1701 static int bus_send_internal(sd_bus
*bus
, sd_bus_message
*_m
, uint64_t *cookie
, bool hint_sync_call
) {
1702 _cleanup_bus_message_unref_ sd_bus_message
*m
= sd_bus_message_ref(_m
);
1705 assert_return(m
, -EINVAL
);
1710 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1711 assert_return(!bus
->is_kernel
|| !(bus
->hello_flags
& KDBUS_HELLO_MONITOR
), -EROFS
);
1713 if (!BUS_IS_OPEN(bus
->state
))
1717 r
= sd_bus_can_send(bus
, SD_BUS_TYPE_UNIX_FD
);
1724 /* If the cookie number isn't kept, then we know that no reply
1726 if (!cookie
&& !m
->sealed
)
1727 m
->header
->flags
|= BUS_MESSAGE_NO_REPLY_EXPECTED
;
1729 r
= bus_seal_message(bus
, m
, 0);
1733 /* Remarshall if we have to. This will possibly unref the
1734 * message and place a replacement in m */
1735 r
= bus_remarshal_message(bus
, &m
);
1739 /* If this is a reply and no reply was requested, then let's
1740 * suppress this, if we can */
1744 if ((bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
) && bus
->wqueue_size
<= 0) {
1747 r
= bus_write_message(bus
, m
, hint_sync_call
, &idx
);
1749 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
1750 bus_enter_closing(bus
);
1757 if (!bus
->is_kernel
&& idx
< BUS_MESSAGE_SIZE(m
)) {
1758 /* Wasn't fully written. So let's remember how
1759 * much was written. Note that the first entry
1760 * of the wqueue array is always allocated so
1761 * that we always can remember how much was
1763 bus
->wqueue
[0] = sd_bus_message_ref(m
);
1764 bus
->wqueue_size
= 1;
1769 /* Just append it to the queue. */
1771 if (bus
->wqueue_size
>= BUS_WQUEUE_MAX
)
1774 if (!GREEDY_REALLOC(bus
->wqueue
, bus
->wqueue_allocated
, bus
->wqueue_size
+ 1))
1777 bus
->wqueue
[bus
->wqueue_size
++] = sd_bus_message_ref(m
);
1782 *cookie
= BUS_MESSAGE_COOKIE(m
);
1787 _public_
int sd_bus_send(sd_bus
*bus
, sd_bus_message
*m
, uint64_t *cookie
) {
1788 return bus_send_internal(bus
, m
, cookie
, false);
1791 _public_
int sd_bus_send_to(sd_bus
*bus
, sd_bus_message
*m
, const char *destination
, uint64_t *cookie
) {
1794 assert_return(m
, -EINVAL
);
1799 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1801 if (!BUS_IS_OPEN(bus
->state
))
1804 if (!streq_ptr(m
->destination
, destination
)) {
1809 r
= sd_bus_message_set_destination(m
, destination
);
1814 return sd_bus_send(bus
, m
, cookie
);
1817 static usec_t
calc_elapse(uint64_t usec
) {
1818 if (usec
== (uint64_t) -1)
1821 return now(CLOCK_MONOTONIC
) + usec
;
1824 static int timeout_compare(const void *a
, const void *b
) {
1825 const struct reply_callback
*x
= a
, *y
= b
;
1827 if (x
->timeout
!= 0 && y
->timeout
== 0)
1830 if (x
->timeout
== 0 && y
->timeout
!= 0)
1833 if (x
->timeout
< y
->timeout
)
1836 if (x
->timeout
> y
->timeout
)
1842 _public_
int sd_bus_call_async(
1846 sd_bus_message_handler_t callback
,
1850 _cleanup_bus_message_unref_ sd_bus_message
*m
= sd_bus_message_ref(_m
);
1851 _cleanup_bus_slot_unref_ sd_bus_slot
*s
= NULL
;
1854 assert_return(m
, -EINVAL
);
1855 assert_return(m
->header
->type
== SD_BUS_MESSAGE_METHOD_CALL
, -EINVAL
);
1856 assert_return(!(m
->header
->flags
& BUS_MESSAGE_NO_REPLY_EXPECTED
), -EINVAL
);
1857 assert_return(callback
, -EINVAL
);
1862 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1863 assert_return(!bus
->is_kernel
|| !(bus
->hello_flags
& KDBUS_HELLO_MONITOR
), -EROFS
);
1865 if (!BUS_IS_OPEN(bus
->state
))
1868 r
= ordered_hashmap_ensure_allocated(&bus
->reply_callbacks
, &uint64_hash_ops
);
1872 r
= prioq_ensure_allocated(&bus
->reply_callbacks_prioq
, timeout_compare
);
1876 r
= bus_seal_message(bus
, m
, usec
);
1880 r
= bus_remarshal_message(bus
, &m
);
1884 s
= bus_slot_allocate(bus
, !slot
, BUS_REPLY_CALLBACK
, sizeof(struct reply_callback
), userdata
);
1888 s
->reply_callback
.callback
= callback
;
1890 s
->reply_callback
.cookie
= BUS_MESSAGE_COOKIE(m
);
1891 r
= ordered_hashmap_put(bus
->reply_callbacks
, &s
->reply_callback
.cookie
, &s
->reply_callback
);
1893 s
->reply_callback
.cookie
= 0;
1897 s
->reply_callback
.timeout
= calc_elapse(m
->timeout
);
1898 if (s
->reply_callback
.timeout
!= 0) {
1899 r
= prioq_put(bus
->reply_callbacks_prioq
, &s
->reply_callback
, &s
->reply_callback
.prioq_idx
);
1901 s
->reply_callback
.timeout
= 0;
1906 r
= sd_bus_send(bus
, m
, &s
->reply_callback
.cookie
);
1917 int bus_ensure_running(sd_bus
*bus
) {
1922 if (bus
->state
== BUS_UNSET
|| bus
->state
== BUS_CLOSED
|| bus
->state
== BUS_CLOSING
)
1924 if (bus
->state
== BUS_RUNNING
)
1928 r
= sd_bus_process(bus
, NULL
);
1931 if (bus
->state
== BUS_RUNNING
)
1936 r
= sd_bus_wait(bus
, (uint64_t) -1);
1942 _public_
int sd_bus_call(
1946 sd_bus_error
*error
,
1947 sd_bus_message
**reply
) {
1949 _cleanup_bus_message_unref_ sd_bus_message
*m
= sd_bus_message_ref(_m
);
1955 bus_assert_return(m
, -EINVAL
, error
);
1956 bus_assert_return(m
->header
->type
== SD_BUS_MESSAGE_METHOD_CALL
, -EINVAL
, error
);
1957 bus_assert_return(!(m
->header
->flags
& BUS_MESSAGE_NO_REPLY_EXPECTED
), -EINVAL
, error
);
1958 bus_assert_return(!bus_error_is_dirty(error
), -EINVAL
, error
);
1963 bus_assert_return(!bus_pid_changed(bus
), -ECHILD
, error
);
1964 bus_assert_return(!bus
->is_kernel
|| !(bus
->hello_flags
& KDBUS_HELLO_MONITOR
), -EROFS
, error
);
1966 if (!BUS_IS_OPEN(bus
->state
)) {
1971 r
= bus_ensure_running(bus
);
1975 i
= bus
->rqueue_size
;
1977 r
= bus_seal_message(bus
, m
, usec
);
1981 r
= bus_remarshal_message(bus
, &m
);
1985 r
= bus_send_internal(bus
, m
, &cookie
, true);
1989 timeout
= calc_elapse(m
->timeout
);
1994 while (i
< bus
->rqueue_size
) {
1995 sd_bus_message
*incoming
= NULL
;
1997 incoming
= bus
->rqueue
[i
];
1999 if (incoming
->reply_cookie
== cookie
) {
2000 /* Found a match! */
2002 memmove(bus
->rqueue
+ i
, bus
->rqueue
+ i
+ 1, sizeof(sd_bus_message
*) * (bus
->rqueue_size
- i
- 1));
2004 log_debug_bus_message(incoming
);
2006 if (incoming
->header
->type
== SD_BUS_MESSAGE_METHOD_RETURN
) {
2008 if (incoming
->n_fds
<= 0 || (bus
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
)) {
2012 sd_bus_message_unref(incoming
);
2017 r
= sd_bus_error_setf(error
, SD_BUS_ERROR_INCONSISTENT_MESSAGE
, "Reply message contained file descriptors which I couldn't accept. Sorry.");
2018 sd_bus_message_unref(incoming
);
2021 } else if (incoming
->header
->type
== SD_BUS_MESSAGE_METHOD_ERROR
) {
2022 r
= sd_bus_error_copy(error
, &incoming
->error
);
2023 sd_bus_message_unref(incoming
);
2030 } else if (BUS_MESSAGE_COOKIE(incoming
) == cookie
&&
2033 streq(bus
->unique_name
, incoming
->sender
)) {
2035 memmove(bus
->rqueue
+ i
, bus
->rqueue
+ i
+ 1, sizeof(sd_bus_message
*) * (bus
->rqueue_size
- i
- 1));
2038 /* Our own message? Somebody is trying
2039 * to send its own client a message,
2040 * let's not dead-lock, let's fail
2043 sd_bus_message_unref(incoming
);
2048 /* Try to read more, right-away */
2052 r
= bus_read_message(bus
, false, 0);
2054 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2055 bus_enter_closing(bus
);
2067 n
= now(CLOCK_MONOTONIC
);
2075 left
= (uint64_t) -1;
2077 r
= bus_poll(bus
, true, left
);
2085 r
= dispatch_wqueue(bus
);
2087 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2088 bus_enter_closing(bus
);
2097 return sd_bus_error_set_errno(error
, r
);
2100 _public_
int sd_bus_get_fd(sd_bus
*bus
) {
2102 assert_return(bus
, -EINVAL
);
2103 assert_return(bus
->input_fd
== bus
->output_fd
, -EPERM
);
2104 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2106 return bus
->input_fd
;
2109 _public_
int sd_bus_get_events(sd_bus
*bus
) {
2112 assert_return(bus
, -EINVAL
);
2113 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2115 if (!BUS_IS_OPEN(bus
->state
) && bus
->state
!= BUS_CLOSING
)
2118 if (bus
->state
== BUS_OPENING
)
2120 else if (bus
->state
== BUS_AUTHENTICATING
) {
2122 if (bus_socket_auth_needs_write(bus
))
2127 } else if (bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
) {
2128 if (bus
->rqueue_size
<= 0)
2130 if (bus
->wqueue_size
> 0)
2137 _public_
int sd_bus_get_timeout(sd_bus
*bus
, uint64_t *timeout_usec
) {
2138 struct reply_callback
*c
;
2140 assert_return(bus
, -EINVAL
);
2141 assert_return(timeout_usec
, -EINVAL
);
2142 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2144 if (!BUS_IS_OPEN(bus
->state
) && bus
->state
!= BUS_CLOSING
)
2147 if (bus
->track_queue
) {
2152 if (bus
->state
== BUS_CLOSING
) {
2157 if (bus
->state
== BUS_AUTHENTICATING
) {
2158 *timeout_usec
= bus
->auth_timeout
;
2162 if (bus
->state
!= BUS_RUNNING
&& bus
->state
!= BUS_HELLO
) {
2163 *timeout_usec
= (uint64_t) -1;
2167 if (bus
->rqueue_size
> 0) {
2172 c
= prioq_peek(bus
->reply_callbacks_prioq
);
2174 *timeout_usec
= (uint64_t) -1;
2178 if (c
->timeout
== 0) {
2179 *timeout_usec
= (uint64_t) -1;
2183 *timeout_usec
= c
->timeout
;
2187 static int process_timeout(sd_bus
*bus
) {
2188 _cleanup_bus_error_free_ sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2189 _cleanup_bus_message_unref_ sd_bus_message
* m
= NULL
;
2190 struct reply_callback
*c
;
2197 c
= prioq_peek(bus
->reply_callbacks_prioq
);
2201 n
= now(CLOCK_MONOTONIC
);
2205 r
= bus_message_new_synthetic_error(
2208 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY
, "Method call timed out"),
2213 r
= bus_seal_synthetic_message(bus
, m
);
2217 assert_se(prioq_pop(bus
->reply_callbacks_prioq
) == c
);
2220 ordered_hashmap_remove(bus
->reply_callbacks
, &c
->cookie
);
2223 slot
= container_of(c
, sd_bus_slot
, reply_callback
);
2225 bus
->iteration_counter
++;
2227 bus
->current_message
= m
;
2228 bus
->current_slot
= sd_bus_slot_ref(slot
);
2229 bus
->current_handler
= c
->callback
;
2230 bus
->current_userdata
= slot
->userdata
;
2231 r
= c
->callback(m
, slot
->userdata
, &error_buffer
);
2232 bus
->current_userdata
= NULL
;
2233 bus
->current_handler
= NULL
;
2234 bus
->current_slot
= NULL
;
2235 bus
->current_message
= NULL
;
2237 if (slot
->floating
) {
2238 bus_slot_disconnect(slot
);
2239 sd_bus_slot_unref(slot
);
2242 sd_bus_slot_unref(slot
);
2244 return bus_maybe_reply_error(m
, r
, &error_buffer
);
2247 static int process_hello(sd_bus
*bus
, sd_bus_message
*m
) {
2251 if (bus
->state
!= BUS_HELLO
)
2254 /* Let's make sure the first message on the bus is the HELLO
2255 * reply. But note that we don't actually parse the message
2256 * here (we leave that to the usual handling), we just verify
2257 * we don't let any earlier msg through. */
2259 if (m
->header
->type
!= SD_BUS_MESSAGE_METHOD_RETURN
&&
2260 m
->header
->type
!= SD_BUS_MESSAGE_METHOD_ERROR
)
2263 if (m
->reply_cookie
!= 1)
2269 static int process_reply(sd_bus
*bus
, sd_bus_message
*m
) {
2270 _cleanup_bus_message_unref_ sd_bus_message
*synthetic_reply
= NULL
;
2271 _cleanup_bus_error_free_ sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2272 struct reply_callback
*c
;
2279 if (m
->header
->type
!= SD_BUS_MESSAGE_METHOD_RETURN
&&
2280 m
->header
->type
!= SD_BUS_MESSAGE_METHOD_ERROR
)
2283 if (bus
->is_kernel
&& (bus
->hello_flags
& KDBUS_HELLO_MONITOR
))
2286 if (m
->destination
&& bus
->unique_name
&& !streq_ptr(m
->destination
, bus
->unique_name
))
2289 c
= ordered_hashmap_remove(bus
->reply_callbacks
, &m
->reply_cookie
);
2295 slot
= container_of(c
, sd_bus_slot
, reply_callback
);
2297 if (m
->n_fds
> 0 && !(bus
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
)) {
2299 /* If the reply contained a file descriptor which we
2300 * didn't want we pass an error instead. */
2302 r
= bus_message_new_synthetic_error(
2305 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE
, "Reply message contained file descriptor"),
2310 /* Copy over original timestamp */
2311 synthetic_reply
->realtime
= m
->realtime
;
2312 synthetic_reply
->monotonic
= m
->monotonic
;
2313 synthetic_reply
->seqnum
= m
->seqnum
;
2315 r
= bus_seal_synthetic_message(bus
, synthetic_reply
);
2319 m
= synthetic_reply
;
2321 r
= sd_bus_message_rewind(m
, true);
2326 if (c
->timeout
!= 0) {
2327 prioq_remove(bus
->reply_callbacks_prioq
, c
, &c
->prioq_idx
);
2331 bus
->current_slot
= sd_bus_slot_ref(slot
);
2332 bus
->current_handler
= c
->callback
;
2333 bus
->current_userdata
= slot
->userdata
;
2334 r
= c
->callback(m
, slot
->userdata
, &error_buffer
);
2335 bus
->current_userdata
= NULL
;
2336 bus
->current_handler
= NULL
;
2337 bus
->current_slot
= NULL
;
2339 if (slot
->floating
) {
2340 bus_slot_disconnect(slot
);
2341 sd_bus_slot_unref(slot
);
2344 sd_bus_slot_unref(slot
);
2346 return bus_maybe_reply_error(m
, r
, &error_buffer
);
2349 static int process_filter(sd_bus
*bus
, sd_bus_message
*m
) {
2350 _cleanup_bus_error_free_ sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2351 struct filter_callback
*l
;
2358 bus
->filter_callbacks_modified
= false;
2360 LIST_FOREACH(callbacks
, l
, bus
->filter_callbacks
) {
2363 if (bus
->filter_callbacks_modified
)
2366 /* Don't run this more than once per iteration */
2367 if (l
->last_iteration
== bus
->iteration_counter
)
2370 l
->last_iteration
= bus
->iteration_counter
;
2372 r
= sd_bus_message_rewind(m
, true);
2376 slot
= container_of(l
, sd_bus_slot
, filter_callback
);
2378 bus
->current_slot
= sd_bus_slot_ref(slot
);
2379 bus
->current_handler
= l
->callback
;
2380 bus
->current_userdata
= slot
->userdata
;
2381 r
= l
->callback(m
, slot
->userdata
, &error_buffer
);
2382 bus
->current_userdata
= NULL
;
2383 bus
->current_handler
= NULL
;
2384 bus
->current_slot
= sd_bus_slot_unref(slot
);
2386 r
= bus_maybe_reply_error(m
, r
, &error_buffer
);
2392 } while (bus
->filter_callbacks_modified
);
2397 static int process_match(sd_bus
*bus
, sd_bus_message
*m
) {
2404 bus
->match_callbacks_modified
= false;
2406 r
= bus_match_run(bus
, &bus
->match_callbacks
, m
);
2410 } while (bus
->match_callbacks_modified
);
2415 static int process_builtin(sd_bus
*bus
, sd_bus_message
*m
) {
2416 _cleanup_bus_message_unref_ sd_bus_message
*reply
= NULL
;
2422 if (bus
->hello_flags
& KDBUS_HELLO_MONITOR
)
2425 if (bus
->manual_peer_interface
)
2428 if (m
->header
->type
!= SD_BUS_MESSAGE_METHOD_CALL
)
2431 if (!streq_ptr(m
->interface
, "org.freedesktop.DBus.Peer"))
2434 if (m
->header
->flags
& BUS_MESSAGE_NO_REPLY_EXPECTED
)
2437 if (streq_ptr(m
->member
, "Ping"))
2438 r
= sd_bus_message_new_method_return(m
, &reply
);
2439 else if (streq_ptr(m
->member
, "GetMachineId")) {
2443 r
= sd_id128_get_machine(&id
);
2447 r
= sd_bus_message_new_method_return(m
, &reply
);
2451 r
= sd_bus_message_append(reply
, "s", sd_id128_to_string(id
, sid
));
2453 r
= sd_bus_message_new_method_errorf(
2455 SD_BUS_ERROR_UNKNOWN_METHOD
,
2456 "Unknown method '%s' on interface '%s'.", m
->member
, m
->interface
);
2462 r
= sd_bus_send(bus
, reply
, NULL
);
2469 static int process_fd_check(sd_bus
*bus
, sd_bus_message
*m
) {
2473 /* If we got a message with a file descriptor which we didn't
2474 * want to accept, then let's drop it. How can this even
2475 * happen? For example, when the kernel queues a message into
2476 * an activatable names's queue which allows fds, and then is
2477 * delivered to us later even though we ourselves did not
2480 if (bus
->hello_flags
& KDBUS_HELLO_MONITOR
)
2486 if (bus
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
)
2489 if (m
->header
->type
!= SD_BUS_MESSAGE_METHOD_CALL
)
2490 return 1; /* just eat it up */
2492 return sd_bus_reply_method_errorf(m
, SD_BUS_ERROR_INCONSISTENT_MESSAGE
, "Message contains file descriptors, which I cannot accept. Sorry.");
2495 static int process_message(sd_bus
*bus
, sd_bus_message
*m
) {
2501 bus
->current_message
= m
;
2502 bus
->iteration_counter
++;
2504 log_debug_bus_message(m
);
2506 r
= process_hello(bus
, m
);
2510 r
= process_reply(bus
, m
);
2514 r
= process_fd_check(bus
, m
);
2518 r
= process_filter(bus
, m
);
2522 r
= process_match(bus
, m
);
2526 r
= process_builtin(bus
, m
);
2530 r
= bus_process_object(bus
, m
);
2533 bus
->current_message
= NULL
;
2537 static int dispatch_track(sd_bus
*bus
) {
2540 if (!bus
->track_queue
)
2543 bus_track_dispatch(bus
->track_queue
);
2547 static int process_running(sd_bus
*bus
, bool hint_priority
, int64_t priority
, sd_bus_message
**ret
) {
2548 _cleanup_bus_message_unref_ sd_bus_message
*m
= NULL
;
2552 assert(bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
);
2554 r
= process_timeout(bus
);
2558 r
= dispatch_wqueue(bus
);
2562 r
= dispatch_track(bus
);
2566 r
= dispatch_rqueue(bus
, hint_priority
, priority
, &m
);
2572 r
= process_message(bus
, m
);
2577 r
= sd_bus_message_rewind(m
, true);
2586 if (m
->header
->type
== SD_BUS_MESSAGE_METHOD_CALL
) {
2588 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2589 strna(sd_bus_message_get_sender(m
)),
2590 strna(sd_bus_message_get_path(m
)),
2591 strna(sd_bus_message_get_interface(m
)),
2592 strna(sd_bus_message_get_member(m
)));
2594 r
= sd_bus_reply_method_errorf(
2596 SD_BUS_ERROR_UNKNOWN_OBJECT
,
2597 "Unknown object '%s'.", m
->path
);
2611 static int process_closing(sd_bus
*bus
, sd_bus_message
**ret
) {
2612 _cleanup_bus_message_unref_ sd_bus_message
*m
= NULL
;
2613 struct reply_callback
*c
;
2617 assert(bus
->state
== BUS_CLOSING
);
2619 c
= ordered_hashmap_first(bus
->reply_callbacks
);
2621 _cleanup_bus_error_free_ sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2624 /* First, fail all outstanding method calls */
2625 r
= bus_message_new_synthetic_error(
2628 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY
, "Connection terminated"),
2633 r
= bus_seal_synthetic_message(bus
, m
);
2637 if (c
->timeout
!= 0) {
2638 prioq_remove(bus
->reply_callbacks_prioq
, c
, &c
->prioq_idx
);
2642 ordered_hashmap_remove(bus
->reply_callbacks
, &c
->cookie
);
2645 slot
= container_of(c
, sd_bus_slot
, reply_callback
);
2647 bus
->iteration_counter
++;
2649 bus
->current_message
= m
;
2650 bus
->current_slot
= sd_bus_slot_ref(slot
);
2651 bus
->current_handler
= c
->callback
;
2652 bus
->current_userdata
= slot
->userdata
;
2653 r
= c
->callback(m
, slot
->userdata
, &error_buffer
);
2654 bus
->current_userdata
= NULL
;
2655 bus
->current_handler
= NULL
;
2656 bus
->current_slot
= NULL
;
2657 bus
->current_message
= NULL
;
2659 if (slot
->floating
) {
2660 bus_slot_disconnect(slot
);
2661 sd_bus_slot_unref(slot
);
2664 sd_bus_slot_unref(slot
);
2666 return bus_maybe_reply_error(m
, r
, &error_buffer
);
2669 /* Then, synthesize a Disconnected message */
2670 r
= sd_bus_message_new_signal(
2673 "/org/freedesktop/DBus/Local",
2674 "org.freedesktop.DBus.Local",
2679 bus_message_set_sender_local(bus
, m
);
2681 r
= bus_seal_synthetic_message(bus
, m
);
2687 bus
->current_message
= m
;
2688 bus
->iteration_counter
++;
2690 r
= process_filter(bus
, m
);
2694 r
= process_match(bus
, m
);
2706 bus
->current_message
= NULL
;
2711 static int bus_process_internal(sd_bus
*bus
, bool hint_priority
, int64_t priority
, sd_bus_message
**ret
) {
2712 BUS_DONT_DESTROY(bus
);
2715 /* Returns 0 when we didn't do anything. This should cause the
2716 * caller to invoke sd_bus_wait() before returning the next
2717 * time. Returns > 0 when we did something, which possibly
2718 * means *ret is filled in with an unprocessed message. */
2720 assert_return(bus
, -EINVAL
);
2721 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2723 /* We don't allow recursively invoking sd_bus_process(). */
2724 assert_return(!bus
->current_message
, -EBUSY
);
2725 assert(!bus
->current_slot
);
2727 switch (bus
->state
) {
2736 r
= bus_socket_process_opening(bus
);
2737 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2738 bus_enter_closing(bus
);
2746 case BUS_AUTHENTICATING
:
2747 r
= bus_socket_process_authenticating(bus
);
2748 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2749 bus_enter_closing(bus
);
2761 r
= process_running(bus
, hint_priority
, priority
, ret
);
2762 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2763 bus_enter_closing(bus
);
2773 return process_closing(bus
, ret
);
2776 assert_not_reached("Unknown state");
2779 _public_
int sd_bus_process(sd_bus
*bus
, sd_bus_message
**ret
) {
2780 return bus_process_internal(bus
, false, 0, ret
);
2783 _public_
int sd_bus_process_priority(sd_bus
*bus
, int64_t priority
, sd_bus_message
**ret
) {
2784 return bus_process_internal(bus
, true, priority
, ret
);
2787 static int bus_poll(sd_bus
*bus
, bool need_more
, uint64_t timeout_usec
) {
2788 struct pollfd p
[2] = {};
2791 usec_t m
= USEC_INFINITY
;
2795 if (bus
->state
== BUS_CLOSING
)
2798 if (!BUS_IS_OPEN(bus
->state
))
2801 e
= sd_bus_get_events(bus
);
2806 /* The caller really needs some more data, he doesn't
2807 * care about what's already read, or any timeouts
2808 * except its own. */
2812 /* The caller wants to process if there's something to
2813 * process, but doesn't care otherwise */
2815 r
= sd_bus_get_timeout(bus
, &until
);
2820 nw
= now(CLOCK_MONOTONIC
);
2821 m
= until
> nw
? until
- nw
: 0;
2825 if (timeout_usec
!= (uint64_t) -1 && (m
== (uint64_t) -1 || timeout_usec
< m
))
2828 p
[0].fd
= bus
->input_fd
;
2829 if (bus
->output_fd
== bus
->input_fd
) {
2833 p
[0].events
= e
& POLLIN
;
2834 p
[1].fd
= bus
->output_fd
;
2835 p
[1].events
= e
& POLLOUT
;
2839 r
= ppoll(p
, n
, m
== (uint64_t) -1 ? NULL
: timespec_store(&ts
, m
), NULL
);
2843 return r
> 0 ? 1 : 0;
2846 _public_
int sd_bus_wait(sd_bus
*bus
, uint64_t timeout_usec
) {
2848 assert_return(bus
, -EINVAL
);
2849 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2851 if (bus
->state
== BUS_CLOSING
)
2854 if (!BUS_IS_OPEN(bus
->state
))
2857 if (bus
->rqueue_size
> 0)
2860 return bus_poll(bus
, false, timeout_usec
);
2863 _public_
int sd_bus_flush(sd_bus
*bus
) {
2866 assert_return(bus
, -EINVAL
);
2867 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2869 if (bus
->state
== BUS_CLOSING
)
2872 if (!BUS_IS_OPEN(bus
->state
))
2875 r
= bus_ensure_running(bus
);
2879 if (bus
->wqueue_size
<= 0)
2883 r
= dispatch_wqueue(bus
);
2885 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2886 bus_enter_closing(bus
);
2893 if (bus
->wqueue_size
<= 0)
2896 r
= bus_poll(bus
, false, (uint64_t) -1);
2902 _public_
int sd_bus_add_filter(
2905 sd_bus_message_handler_t callback
,
2910 assert_return(bus
, -EINVAL
);
2911 assert_return(callback
, -EINVAL
);
2912 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2914 s
= bus_slot_allocate(bus
, !slot
, BUS_FILTER_CALLBACK
, sizeof(struct filter_callback
), userdata
);
2918 s
->filter_callback
.callback
= callback
;
2920 bus
->filter_callbacks_modified
= true;
2921 LIST_PREPEND(callbacks
, bus
->filter_callbacks
, &s
->filter_callback
);
2929 _public_
int sd_bus_add_match(
2933 sd_bus_message_handler_t callback
,
2936 struct bus_match_component
*components
= NULL
;
2937 unsigned n_components
= 0;
2938 sd_bus_slot
*s
= NULL
;
2941 assert_return(bus
, -EINVAL
);
2942 assert_return(match
, -EINVAL
);
2943 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2945 r
= bus_match_parse(match
, &components
, &n_components
);
2949 s
= bus_slot_allocate(bus
, !slot
, BUS_MATCH_CALLBACK
, sizeof(struct match_callback
), userdata
);
2955 s
->match_callback
.callback
= callback
;
2956 s
->match_callback
.cookie
= ++bus
->match_cookie
;
2958 if (bus
->bus_client
) {
2959 enum bus_match_scope scope
;
2961 scope
= bus_match_get_scope(components
, n_components
);
2963 /* Do not install server-side matches for matches
2964 * against the local service, interface or bus
2966 if (scope
!= BUS_MATCH_LOCAL
) {
2968 if (!bus
->is_kernel
) {
2969 /* When this is not a kernel transport, we
2970 * store the original match string, so that we
2971 * can use it to remove the match again */
2973 s
->match_callback
.match_string
= strdup(match
);
2974 if (!s
->match_callback
.match_string
) {
2980 r
= bus_add_match_internal(bus
, s
->match_callback
.match_string
, components
, n_components
, s
->match_callback
.cookie
);
2984 s
->match_added
= true;
2988 bus
->match_callbacks_modified
= true;
2989 r
= bus_match_add(&bus
->match_callbacks
, components
, n_components
, &s
->match_callback
);
2998 bus_match_parse_free(components
, n_components
);
2999 sd_bus_slot_unref(s
);
3004 int bus_remove_match_by_string(
3007 sd_bus_message_handler_t callback
,
3010 struct bus_match_component
*components
= NULL
;
3011 unsigned n_components
= 0;
3012 struct match_callback
*c
;
3015 assert_return(bus
, -EINVAL
);
3016 assert_return(match
, -EINVAL
);
3017 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3019 r
= bus_match_parse(match
, &components
, &n_components
);
3023 r
= bus_match_find(&bus
->match_callbacks
, components
, n_components
, NULL
, NULL
, &c
);
3027 sd_bus_slot_unref(container_of(c
, sd_bus_slot
, match_callback
));
3030 bus_match_parse_free(components
, n_components
);
3035 bool bus_pid_changed(sd_bus
*bus
) {
3038 /* We don't support people creating a bus connection and
3039 * keeping it around over a fork(). Let's complain. */
3041 return bus
->original_pid
!= getpid();
3044 static int io_callback(sd_event_source
*s
, int fd
, uint32_t revents
, void *userdata
) {
3045 sd_bus
*bus
= userdata
;
3050 r
= sd_bus_process(bus
, NULL
);
3057 static int time_callback(sd_event_source
*s
, uint64_t usec
, void *userdata
) {
3058 sd_bus
*bus
= userdata
;
3063 r
= sd_bus_process(bus
, NULL
);
3070 static int prepare_callback(sd_event_source
*s
, void *userdata
) {
3071 sd_bus
*bus
= userdata
;
3078 e
= sd_bus_get_events(bus
);
3082 if (bus
->output_fd
!= bus
->input_fd
) {
3084 r
= sd_event_source_set_io_events(bus
->input_io_event_source
, e
& POLLIN
);
3088 r
= sd_event_source_set_io_events(bus
->output_io_event_source
, e
& POLLOUT
);
3092 r
= sd_event_source_set_io_events(bus
->input_io_event_source
, e
);
3097 r
= sd_bus_get_timeout(bus
, &until
);
3103 j
= sd_event_source_set_time(bus
->time_event_source
, until
);
3108 r
= sd_event_source_set_enabled(bus
->time_event_source
, r
> 0);
3115 static int quit_callback(sd_event_source
*event
, void *userdata
) {
3116 sd_bus
*bus
= userdata
;
3126 static int attach_io_events(sd_bus
*bus
) {
3131 if (bus
->input_fd
< 0)
3137 if (!bus
->input_io_event_source
) {
3138 r
= sd_event_add_io(bus
->event
, &bus
->input_io_event_source
, bus
->input_fd
, 0, io_callback
, bus
);
3142 r
= sd_event_source_set_prepare(bus
->input_io_event_source
, prepare_callback
);
3146 r
= sd_event_source_set_priority(bus
->input_io_event_source
, bus
->event_priority
);
3150 r
= sd_event_source_set_description(bus
->input_io_event_source
, "bus-input");
3152 r
= sd_event_source_set_io_fd(bus
->input_io_event_source
, bus
->input_fd
);
3157 if (bus
->output_fd
!= bus
->input_fd
) {
3158 assert(bus
->output_fd
>= 0);
3160 if (!bus
->output_io_event_source
) {
3161 r
= sd_event_add_io(bus
->event
, &bus
->output_io_event_source
, bus
->output_fd
, 0, io_callback
, bus
);
3165 r
= sd_event_source_set_priority(bus
->output_io_event_source
, bus
->event_priority
);
3169 r
= sd_event_source_set_description(bus
->input_io_event_source
, "bus-output");
3171 r
= sd_event_source_set_io_fd(bus
->output_io_event_source
, bus
->output_fd
);
3180 static void detach_io_events(sd_bus
*bus
) {
3183 if (bus
->input_io_event_source
) {
3184 sd_event_source_set_enabled(bus
->input_io_event_source
, SD_EVENT_OFF
);
3185 bus
->input_io_event_source
= sd_event_source_unref(bus
->input_io_event_source
);
3188 if (bus
->output_io_event_source
) {
3189 sd_event_source_set_enabled(bus
->output_io_event_source
, SD_EVENT_OFF
);
3190 bus
->output_io_event_source
= sd_event_source_unref(bus
->output_io_event_source
);
3194 _public_
int sd_bus_attach_event(sd_bus
*bus
, sd_event
*event
, int priority
) {
3197 assert_return(bus
, -EINVAL
);
3198 assert_return(!bus
->event
, -EBUSY
);
3200 assert(!bus
->input_io_event_source
);
3201 assert(!bus
->output_io_event_source
);
3202 assert(!bus
->time_event_source
);
3205 bus
->event
= sd_event_ref(event
);
3207 r
= sd_event_default(&bus
->event
);
3212 bus
->event_priority
= priority
;
3214 r
= sd_event_add_time(bus
->event
, &bus
->time_event_source
, CLOCK_MONOTONIC
, 0, 0, time_callback
, bus
);
3218 r
= sd_event_source_set_priority(bus
->time_event_source
, priority
);
3222 r
= sd_event_source_set_description(bus
->time_event_source
, "bus-time");
3226 r
= sd_event_add_exit(bus
->event
, &bus
->quit_event_source
, quit_callback
, bus
);
3230 r
= sd_event_source_set_description(bus
->quit_event_source
, "bus-exit");
3234 r
= attach_io_events(bus
);
3241 sd_bus_detach_event(bus
);
3245 _public_
int sd_bus_detach_event(sd_bus
*bus
) {
3246 assert_return(bus
, -EINVAL
);
3251 detach_io_events(bus
);
3253 if (bus
->time_event_source
) {
3254 sd_event_source_set_enabled(bus
->time_event_source
, SD_EVENT_OFF
);
3255 bus
->time_event_source
= sd_event_source_unref(bus
->time_event_source
);
3258 if (bus
->quit_event_source
) {
3259 sd_event_source_set_enabled(bus
->quit_event_source
, SD_EVENT_OFF
);
3260 bus
->quit_event_source
= sd_event_source_unref(bus
->quit_event_source
);
3263 bus
->event
= sd_event_unref(bus
->event
);
3267 _public_ sd_event
* sd_bus_get_event(sd_bus
*bus
) {
3268 assert_return(bus
, NULL
);
3273 _public_ sd_bus_message
* sd_bus_get_current_message(sd_bus
*bus
) {
3274 assert_return(bus
, NULL
);
3276 return bus
->current_message
;
3279 _public_ sd_bus_slot
* sd_bus_get_current_slot(sd_bus
*bus
) {
3280 assert_return(bus
, NULL
);
3282 return bus
->current_slot
;
3285 _public_ sd_bus_message_handler_t
sd_bus_get_current_handler(sd_bus
*bus
) {
3286 assert_return(bus
, NULL
);
3288 return bus
->current_handler
;
3291 _public_
void* sd_bus_get_current_userdata(sd_bus
*bus
) {
3292 assert_return(bus
, NULL
);
3294 return bus
->current_userdata
;
3297 static int bus_default(int (*bus_open
)(sd_bus
**), sd_bus
**default_bus
, sd_bus
**ret
) {
3302 assert(default_bus
);
3305 return !!*default_bus
;
3308 *ret
= sd_bus_ref(*default_bus
);
3316 b
->default_bus_ptr
= default_bus
;
3324 _public_
int sd_bus_default_system(sd_bus
**ret
) {
3325 static thread_local sd_bus
*default_system_bus
= NULL
;
3327 return bus_default(sd_bus_open_system
, &default_system_bus
, ret
);
3330 _public_
int sd_bus_default_user(sd_bus
**ret
) {
3331 static thread_local sd_bus
*default_user_bus
= NULL
;
3333 return bus_default(sd_bus_open_user
, &default_user_bus
, ret
);
3336 _public_
int sd_bus_default(sd_bus
**ret
) {
3340 /* Let's try our best to reuse another cached connection. If
3341 * the starter bus type is set, connect via our normal
3342 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3343 * we can share the connection with the user/system default
3346 e
= secure_getenv("DBUS_STARTER_BUS_TYPE");
3348 if (streq(e
, "system"))
3349 return sd_bus_default_system(ret
);
3350 else if (STR_IN_SET(e
, "user", "session"))
3351 return sd_bus_default_user(ret
);
3354 /* No type is specified, so we have not other option than to
3355 * use the starter address if it is set. */
3357 e
= secure_getenv("DBUS_STARTER_ADDRESS");
3359 static thread_local sd_bus
*default_starter_bus
= NULL
;
3361 return bus_default(sd_bus_open
, &default_starter_bus
, ret
);
3364 /* Finally, if nothing is set use the cached connection for
3365 * the right scope */
3367 if (cg_pid_get_owner_uid(0, NULL
) >= 0)
3368 return sd_bus_default_user(ret
);
3370 return sd_bus_default_system(ret
);
3373 _public_
int sd_bus_get_tid(sd_bus
*b
, pid_t
*tid
) {
3374 assert_return(b
, -EINVAL
);
3375 assert_return(tid
, -EINVAL
);
3376 assert_return(!bus_pid_changed(b
), -ECHILD
);
3384 return sd_event_get_tid(b
->event
, tid
);
3389 _public_
int sd_bus_path_encode(const char *prefix
, const char *external_id
, char **ret_path
) {
3390 _cleanup_free_
char *e
= NULL
;
3393 assert_return(object_path_is_valid(prefix
), -EINVAL
);
3394 assert_return(external_id
, -EINVAL
);
3395 assert_return(ret_path
, -EINVAL
);
3397 e
= bus_label_escape(external_id
);
3401 ret
= strjoin(prefix
, "/", e
, NULL
);
3409 _public_
int sd_bus_path_decode(const char *path
, const char *prefix
, char **external_id
) {
3413 assert_return(object_path_is_valid(path
), -EINVAL
);
3414 assert_return(object_path_is_valid(prefix
), -EINVAL
);
3415 assert_return(external_id
, -EINVAL
);
3417 e
= object_path_startswith(path
, prefix
);
3419 *external_id
= NULL
;
3423 ret
= bus_label_unescape(e
);
3431 _public_
int sd_bus_try_close(sd_bus
*bus
) {
3434 assert_return(bus
, -EINVAL
);
3435 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3437 if (!bus
->is_kernel
)
3440 if (!BUS_IS_OPEN(bus
->state
))
3443 if (bus
->rqueue_size
> 0)
3446 if (bus
->wqueue_size
> 0)
3449 r
= bus_kernel_try_close(bus
);
3457 _public_
int sd_bus_get_description(sd_bus
*bus
, const char **description
) {
3458 assert_return(bus
, -EINVAL
);
3459 assert_return(description
, -EINVAL
);
3460 assert_return(bus
->description
, -ENXIO
);
3461 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3463 *description
= bus
->description
;
3467 int bus_get_root_path(sd_bus
*bus
) {
3470 if (bus
->cgroup_root
)
3473 r
= cg_get_root_path(&bus
->cgroup_root
);
3475 bus
->cgroup_root
= strdup("/");
3476 if (!bus
->cgroup_root
)
3485 _public_
int sd_bus_get_scope(sd_bus
*bus
, const char **scope
) {
3488 assert_return(bus
, -EINVAL
);
3489 assert_return(scope
, -EINVAL
);
3490 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3492 if (bus
->is_kernel
) {
3493 _cleanup_free_
char *n
= NULL
;
3496 r
= bus_kernel_get_bus_name(bus
, &n
);
3500 if (streq(n
, "0-system")) {
3505 dash
= strchr(n
, '-');
3506 if (streq_ptr(dash
, "-user")) {
3517 if (bus
->is_system
) {
3525 _public_
int sd_bus_get_address(sd_bus
*bus
, const char **address
) {
3527 assert_return(bus
, -EINVAL
);
3528 assert_return(address
, -EINVAL
);
3529 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3532 *address
= bus
->address
;
3539 _public_
int sd_bus_get_creds_mask(sd_bus
*bus
, uint64_t *mask
) {
3540 assert_return(bus
, -EINVAL
);
3541 assert_return(mask
, -EINVAL
);
3542 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3544 *mask
= bus
->creds_mask
;
3548 _public_
int sd_bus_is_bus_client(sd_bus
*bus
) {
3549 assert_return(bus
, -EINVAL
);
3550 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3552 return bus
->bus_client
;
3555 _public_
int sd_bus_is_server(sd_bus
*bus
) {
3556 assert_return(bus
, -EINVAL
);
3557 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3559 return bus
->is_server
;
3562 _public_
int sd_bus_is_anonymous(sd_bus
*bus
) {
3563 assert_return(bus
, -EINVAL
);
3564 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3566 return bus
->anonymous_auth
;
3569 _public_
int sd_bus_is_trusted(sd_bus
*bus
) {
3570 assert_return(bus
, -EINVAL
);
3571 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3573 return bus
->trusted
;
3576 _public_
int sd_bus_is_monitor(sd_bus
*bus
) {
3577 assert_return(bus
, -EINVAL
);
3578 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3580 return !!(bus
->hello_flags
& KDBUS_HELLO_MONITOR
);