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 "bus-label.h"
39 #include "bus-internal.h"
40 #include "bus-message.h"
42 #include "bus-socket.h"
43 #include "bus-kernel.h"
44 #include "bus-control.h"
45 #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
) {
77 safe_close(b
->input_fd
);
79 if (b
->output_fd
>= 0 && b
->output_fd
!= b
->input_fd
)
80 safe_close(b
->output_fd
);
82 b
->input_fd
= b
->output_fd
= -1;
85 static void bus_reset_queues(sd_bus
*b
) {
88 while (b
->rqueue_size
> 0)
89 sd_bus_message_unref(b
->rqueue
[--b
->rqueue_size
]);
93 b
->rqueue_allocated
= 0;
95 while (b
->wqueue_size
> 0)
96 sd_bus_message_unref(b
->wqueue
[--b
->wqueue_size
]);
100 b
->wqueue_allocated
= 0;
103 static void bus_free(sd_bus
*b
) {
107 assert(!b
->track_queue
);
109 b
->state
= BUS_CLOSED
;
111 sd_bus_detach_event(b
);
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. */
122 bus_slot_disconnect(s
);
123 sd_bus_slot_unref(s
);
126 if (b
->default_bus_ptr
)
127 *b
->default_bus_ptr
= NULL
;
132 munmap(b
->kdbus_buffer
, KDBUS_POOL_SIZE
);
136 free(b
->unique_name
);
137 free(b
->auth_buffer
);
142 free(b
->cgroup_root
);
143 free(b
->description
);
146 strv_free(b
->exec_argv
);
148 close_many(b
->fds
, b
->n_fds
);
153 ordered_hashmap_free_free(b
->reply_callbacks
);
154 prioq_free(b
->reply_callbacks_prioq
);
156 assert(b
->match_callbacks
.type
== BUS_MATCH_ROOT
);
157 bus_match_free(&b
->match_callbacks
);
159 hashmap_free_free(b
->vtable_methods
);
160 hashmap_free_free(b
->vtable_properties
);
162 assert(hashmap_isempty(b
->nodes
));
163 hashmap_free(b
->nodes
);
165 bus_kernel_flush_memfd(b
);
167 assert_se(pthread_mutex_destroy(&b
->memfd_cache_mutex
) == 0);
172 _public_
int sd_bus_new(sd_bus
**ret
) {
175 assert_return(ret
, -EINVAL
);
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();
189 assert_se(pthread_mutex_init(&r
->memfd_cache_mutex
, NULL
) == 0);
191 /* We guarantee that wqueue always has space for at least one
193 if (!GREEDY_REALLOC(r
->wqueue
, r
->wqueue_allocated
, 1)) {
202 _public_
int sd_bus_set_address(sd_bus
*bus
, const char *address
) {
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
);
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
);
227 bus
->input_fd
= input_fd
;
228 bus
->output_fd
= output_fd
;
232 _public_
int sd_bus_set_exec(sd_bus
*bus
, const char *path
, char *const argv
[]) {
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
);
251 free(bus
->exec_path
);
252 strv_free(bus
->exec_argv
);
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
);
265 bus
->bus_client
= !!b
;
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
);
274 SET_FLAG(bus
->hello_flags
, KDBUS_HELLO_MONITOR
, b
);
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
);
283 SET_FLAG(bus
->hello_flags
, KDBUS_HELLO_ACCEPT_FD
, b
);
287 _public_
int sd_bus_negotiate_timestamp(sd_bus
*bus
, int b
) {
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
);
293 new_flags
= bus
->attach_flags
;
294 SET_FLAG(new_flags
, KDBUS_ATTACH_TIMESTAMP
, b
);
296 if (bus
->attach_flags
== new_flags
)
299 bus
->attach_flags
= new_flags
;
300 if (bus
->state
!= BUS_UNSET
&& bus
->is_kernel
)
301 bus_kernel_realize_attach_flags(bus
);
306 _public_
int sd_bus_negotiate_creds(sd_bus
*bus
, int b
, uint64_t mask
) {
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
);
315 bus
->creds_mask
|= mask
;
317 bus
->creds_mask
&= ~mask
;
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
;
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
)
327 bus
->attach_flags
= new_flags
;
328 if (bus
->state
!= BUS_UNSET
&& bus
->is_kernel
)
329 bus_kernel_realize_attach_flags(bus
);
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
);
340 bus
->is_server
= !!b
;
341 bus
->server_id
= server_id
;
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
);
350 bus
->anonymous_auth
= !!b
;
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
);
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
);
368 return free_and_strdup(&bus
->description
, description
);
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
);
375 bus
->allow_interactive_authorization
= !!b
;
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
);
383 return bus
->allow_interactive_authorization
;
386 static int hello_callback(sd_bus_message
*reply
, void *userdata
, sd_bus_error
*error
) {
394 assert(bus
->state
== BUS_HELLO
|| bus
->state
== BUS_CLOSING
);
396 r
= sd_bus_message_get_errno(reply
);
400 r
= sd_bus_message_read(reply
, "s", &s
);
404 if (!service_name_is_valid(s
) || s
[0] != ':')
407 bus
->unique_name
= strdup(s
);
408 if (!bus
->unique_name
)
411 if (bus
->state
== BUS_HELLO
)
412 bus
->state
= BUS_RUNNING
;
417 static int bus_send_hello(sd_bus
*bus
) {
418 _cleanup_bus_message_unref_ sd_bus_message
*m
= NULL
;
423 if (!bus
->bus_client
|| bus
->is_kernel
)
426 r
= sd_bus_message_new_method_call(
429 "org.freedesktop.DBus",
430 "/org/freedesktop/DBus",
431 "org.freedesktop.DBus",
436 return sd_bus_call_async(bus
, NULL
, m
, hello_callback
, NULL
, 0);
439 int bus_start_running(sd_bus
*bus
) {
442 if (bus
->bus_client
&& !bus
->is_kernel
) {
443 bus
->state
= BUS_HELLO
;
447 bus
->state
= BUS_RUNNING
;
451 static int parse_address_key(const char **p
, const char *key
, char **value
) {
452 size_t l
, n
= 0, allocated
= 0;
462 if (strncmp(*p
, key
, l
) != 0)
475 while (*a
!= ';' && *a
!= ',' && *a
!= 0) {
493 c
= (char) ((x
<< 4) | y
);
500 if (!GREEDY_REALLOC(r
, allocated
, n
+ 2))
524 static void skip_address_key(const char **p
) {
528 *p
+= strcspn(*p
, ",");
534 static int parse_unix_address(sd_bus
*b
, const char **p
, char **guid
) {
535 _cleanup_free_
char *path
= NULL
, *abstract
= NULL
;
544 while (**p
!= 0 && **p
!= ';') {
545 r
= parse_address_key(p
, "guid", guid
);
551 r
= parse_address_key(p
, "path", &path
);
557 r
= parse_address_key(p
, "abstract", &abstract
);
566 if (!path
&& !abstract
)
569 if (path
&& abstract
)
574 if (l
> sizeof(b
->sockaddr
.un
.sun_path
))
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)
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
;
594 static int parse_tcp_address(sd_bus
*b
, const char **p
, char **guid
) {
595 _cleanup_free_
char *host
= NULL
, *port
= NULL
, *family
= NULL
;
597 struct addrinfo
*result
, hints
= {
598 .ai_socktype
= SOCK_STREAM
,
599 .ai_flags
= AI_ADDRCONFIG
,
607 while (**p
!= 0 && **p
!= ';') {
608 r
= parse_address_key(p
, "guid", guid
);
614 r
= parse_address_key(p
, "host", &host
);
620 r
= parse_address_key(p
, "port", &port
);
626 r
= parse_address_key(p
, "family", &family
);
639 if (streq(family
, "ipv4"))
640 hints
.ai_family
= AF_INET
;
641 else if (streq(family
, "ipv6"))
642 hints
.ai_family
= AF_INET6
;
647 r
= getaddrinfo(host
, port
, &hints
, &result
);
651 return -EADDRNOTAVAIL
;
653 memcpy(&b
->sockaddr
, result
->ai_addr
, result
->ai_addrlen
);
654 b
->sockaddr_size
= result
->ai_addrlen
;
656 freeaddrinfo(result
);
661 static int parse_exec_address(sd_bus
*b
, const char **p
, char **guid
) {
663 unsigned n_argv
= 0, j
;
665 size_t allocated
= 0;
673 while (**p
!= 0 && **p
!= ';') {
674 r
= parse_address_key(p
, "guid", guid
);
680 r
= parse_address_key(p
, "path", &path
);
686 if (startswith(*p
, "argv")) {
690 ul
= strtoul(*p
+ 4, (char**) p
, 10);
691 if (errno
> 0 || **p
!= '=' || ul
> 256) {
699 if (!GREEDY_REALLOC0(argv
, allocated
, ul
+ 2)) {
707 r
= parse_address_key(p
, NULL
, argv
+ ul
);
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
++)
730 if (argv
&& argv
[0] == NULL
) {
731 argv
[0] = strdup(path
);
743 for (j
= 0; j
< n_argv
; j
++)
751 static int parse_kernel_address(sd_bus
*b
, const char **p
, char **guid
) {
752 _cleanup_free_
char *path
= NULL
;
760 while (**p
!= 0 && **p
!= ';') {
761 r
= parse_address_key(p
, "guid", guid
);
767 r
= parse_address_key(p
, "path", &path
);
786 static int parse_container_unix_address(sd_bus
*b
, const char **p
, char **guid
) {
787 _cleanup_free_
char *machine
= NULL
, *pid
= NULL
;
795 while (**p
!= 0 && **p
!= ';') {
796 r
= parse_address_key(p
, "guid", guid
);
802 r
= parse_address_key(p
, "machine", &machine
);
808 r
= parse_address_key(p
, "pid", &pid
);
817 if (!machine
== !pid
)
821 if (!machine_name_is_valid(machine
))
825 b
->machine
= machine
;
833 r
= parse_pid(pid
, &b
->nspid
);
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");
846 static int parse_container_kernel_address(sd_bus
*b
, const char **p
, char **guid
) {
847 _cleanup_free_
char *machine
= NULL
, *pid
= NULL
;
855 while (**p
!= 0 && **p
!= ';') {
856 r
= parse_address_key(p
, "guid", guid
);
862 r
= parse_address_key(p
, "machine", &machine
);
868 r
= parse_address_key(p
, "pid", &pid
);
877 if (!machine
== !pid
)
881 if (!machine_name_is_valid(machine
))
885 b
->machine
= machine
;
893 r
= parse_pid(pid
, &b
->nspid
);
900 b
->kernel
= strdup("/sys/fs/kdbus/0-system/bus");
907 static void bus_reset_parsed_address(sd_bus
*b
) {
911 b
->sockaddr_size
= 0;
912 strv_free(b
->exec_argv
);
916 b
->server_id
= SD_ID128_NULL
;
924 static int bus_parse_next_address(sd_bus
*b
) {
925 _cleanup_free_
char *guid
= NULL
;
933 if (b
->address
[b
->address_index
] == 0)
936 bus_reset_parsed_address(b
);
938 a
= b
->address
+ b
->address_index
;
947 if (startswith(a
, "unix:")) {
950 r
= parse_unix_address(b
, &a
, &guid
);
955 } else if (startswith(a
, "tcp:")) {
958 r
= parse_tcp_address(b
, &a
, &guid
);
964 } else if (startswith(a
, "unixexec:")) {
967 r
= parse_exec_address(b
, &a
, &guid
);
973 } else if (startswith(a
, "kernel:")) {
976 r
= parse_kernel_address(b
, &a
, &guid
);
981 } else if (startswith(a
, "x-machine-unix:")) {
984 r
= parse_container_unix_address(b
, &a
, &guid
);
989 } else if (startswith(a
, "x-machine-kernel:")) {
992 r
= parse_container_kernel_address(b
, &a
, &guid
);
1005 r
= sd_id128_from_string(guid
, &b
->server_id
);
1010 b
->address_index
= a
- b
->address
;
1014 static int bus_start_address(sd_bus
*b
) {
1020 bool skipped
= false;
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
);
1031 r
= bus_kernel_connect(b
);
1032 else if (b
->sockaddr
.sa
.sa_family
!= AF_UNSPEC
)
1033 r
= bus_socket_connect(b
);
1039 r
= attach_io_events(b
);
1044 b
->last_connect_error
= -r
;
1047 r
= bus_parse_next_address(b
);
1051 return b
->last_connect_error
? -b
->last_connect_error
: -ECONNREFUSED
;
1055 int bus_next_address(sd_bus
*b
) {
1058 bus_reset_parsed_address(b
);
1059 return bus_start_address(b
);
1062 static int bus_start_fd(sd_bus
*b
) {
1067 assert(b
->input_fd
>= 0);
1068 assert(b
->output_fd
>= 0);
1070 r
= fd_nonblock(b
->input_fd
, true);
1074 r
= fd_cloexec(b
->input_fd
, true);
1078 if (b
->input_fd
!= b
->output_fd
) {
1079 r
= fd_nonblock(b
->output_fd
, true);
1083 r
= fd_cloexec(b
->output_fd
, true);
1088 if (fstat(b
->input_fd
, &st
) < 0)
1091 if (S_ISCHR(b
->input_fd
))
1092 return bus_kernel_take_fd(b
);
1094 return bus_socket_take_fd(b
);
1097 _public_
int sd_bus_start(sd_bus
*bus
) {
1100 assert_return(bus
, -EINVAL
);
1101 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
1102 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1104 bus
->state
= BUS_OPENING
;
1106 if (bus
->is_server
&& bus
->bus_client
)
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
);
1121 return bus_send_hello(bus
);
1124 _public_
int sd_bus_open(sd_bus
**ret
) {
1129 assert_return(ret
, -EINVAL
);
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 */
1135 e
= secure_getenv("DBUS_STARTER_BUS_TYPE");
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
);
1143 e
= secure_getenv("DBUS_STARTER_ADDRESS");
1145 if (cg_pid_get_owner_uid(0, NULL
) >= 0)
1146 return sd_bus_open_user(ret
);
1148 return sd_bus_open_system(ret
);
1155 r
= sd_bus_set_address(b
, e
);
1159 b
->bus_client
= true;
1161 /* We don't know whether the bus is trusted or not, so better
1162 * be safe, and authenticate everything */
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
;
1167 r
= sd_bus_start(b
);
1179 int bus_set_address_system(sd_bus
*b
) {
1183 e
= secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1185 return sd_bus_set_address(b
, e
);
1187 return sd_bus_set_address(b
, DEFAULT_SYSTEM_BUS_ADDRESS
);
1190 _public_
int sd_bus_open_system(sd_bus
**ret
) {
1194 assert_return(ret
, -EINVAL
);
1200 r
= bus_set_address_system(b
);
1204 b
->bus_client
= true;
1205 b
->is_system
= true;
1207 /* Let's do per-method access control on the system bus. We
1208 * need the caller's UID and capability set for that. */
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
;
1213 r
= sd_bus_start(b
);
1225 int bus_set_address_user(sd_bus
*b
) {
1230 e
= secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1232 return sd_bus_set_address(b
, e
);
1234 e
= secure_getenv("XDG_RUNTIME_DIR");
1236 _cleanup_free_
char *ee
= NULL
;
1238 ee
= bus_address_escape(e
);
1242 (void) asprintf(&b
->address
, KERNEL_USER_BUS_ADDRESS_FMT
";" UNIX_USER_BUS_ADDRESS_FMT
, getuid(), ee
);
1244 (void) asprintf(&b
->address
, KERNEL_USER_BUS_ADDRESS_FMT
, getuid());
1252 _public_
int sd_bus_open_user(sd_bus
**ret
) {
1256 assert_return(ret
, -EINVAL
);
1262 r
= bus_set_address_user(b
);
1266 b
->bus_client
= true;
1269 /* We don't do any per-method access control on the user
1273 r
= sd_bus_start(b
);
1285 int bus_set_address_system_remote(sd_bus
*b
, const char *host
) {
1286 _cleanup_free_
char *e
= NULL
;
1287 char *m
= NULL
, *c
= NULL
;
1292 /* Let's see if we shall enter some container */
1293 m
= strchr(host
, ':');
1297 /* Let's make sure this is not a port of some kind,
1298 * and is a valid machine name. */
1299 if (!in_charset(m
, "0123456789") && machine_name_is_valid(m
)) {
1302 /* Cut out the host part */
1303 t
= strndupa(host
, m
- host
- 1);
1304 e
= bus_address_escape(t
);
1308 c
= strjoina(",argv4=--machine=", m
);
1313 e
= bus_address_escape(host
);
1318 b
->address
= strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e
, ",argv3=systemd-stdio-bridge", c
, NULL
);
1325 _public_
int sd_bus_open_system_remote(sd_bus
**ret
, const char *host
) {
1329 assert_return(host
, -EINVAL
);
1330 assert_return(ret
, -EINVAL
);
1332 r
= sd_bus_new(&bus
);
1336 r
= bus_set_address_system_remote(bus
, host
);
1340 bus
->bus_client
= true;
1341 bus
->trusted
= false;
1342 bus
->is_system
= true;
1344 r
= sd_bus_start(bus
);
1356 int bus_set_address_system_machine(sd_bus
*b
, const char *machine
) {
1357 _cleanup_free_
char *e
= NULL
;
1362 e
= bus_address_escape(machine
);
1366 b
->address
= strjoin("x-machine-kernel:machine=", e
, ";x-machine-unix:machine=", e
, NULL
);
1373 _public_
int sd_bus_open_system_machine(sd_bus
**ret
, const char *machine
) {
1377 assert_return(machine
, -EINVAL
);
1378 assert_return(ret
, -EINVAL
);
1379 assert_return(machine_name_is_valid(machine
), -EINVAL
);
1381 r
= sd_bus_new(&bus
);
1385 r
= bus_set_address_system_machine(bus
, machine
);
1389 bus
->bus_client
= true;
1390 bus
->trusted
= false;
1391 bus
->is_system
= true;
1393 r
= sd_bus_start(bus
);
1405 _public_
void sd_bus_close(sd_bus
*bus
) {
1409 if (bus
->state
== BUS_CLOSED
)
1411 if (bus_pid_changed(bus
))
1414 bus
->state
= BUS_CLOSED
;
1416 sd_bus_detach_event(bus
);
1418 /* Drop all queued messages so that they drop references to
1419 * the bus object and the bus may be freed */
1420 bus_reset_queues(bus
);
1422 if (!bus
->is_kernel
)
1425 /* We'll leave the fd open in case this is a kernel bus, since
1426 * there might still be memblocks around that reference this
1427 * bus, and they might need to invoke the KDBUS_CMD_FREE
1428 * ioctl on the fd when they are freed. */
1431 static void bus_enter_closing(sd_bus
*bus
) {
1434 if (bus
->state
!= BUS_OPENING
&&
1435 bus
->state
!= BUS_AUTHENTICATING
&&
1436 bus
->state
!= BUS_HELLO
&&
1437 bus
->state
!= BUS_RUNNING
)
1440 bus
->state
= BUS_CLOSING
;
1443 _public_ sd_bus
*sd_bus_ref(sd_bus
*bus
) {
1444 assert_return(bus
, NULL
);
1446 assert_se(REFCNT_INC(bus
->n_ref
) >= 2);
1451 _public_ sd_bus
*sd_bus_unref(sd_bus
*bus
) {
1457 i
= REFCNT_DEC(bus
->n_ref
);
1465 _public_
int sd_bus_is_open(sd_bus
*bus
) {
1467 assert_return(bus
, -EINVAL
);
1468 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1470 return BUS_IS_OPEN(bus
->state
);
1473 _public_
int sd_bus_can_send(sd_bus
*bus
, char type
) {
1476 assert_return(bus
, -EINVAL
);
1477 assert_return(bus
->state
!= BUS_UNSET
, -ENOTCONN
);
1478 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1480 if (bus
->hello_flags
& KDBUS_HELLO_MONITOR
)
1483 if (type
== SD_BUS_TYPE_UNIX_FD
) {
1484 if (!(bus
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
))
1487 r
= bus_ensure_running(bus
);
1491 return bus
->can_fds
;
1494 return bus_type_is_valid(type
);
1497 _public_
int sd_bus_get_bus_id(sd_bus
*bus
, sd_id128_t
*id
) {
1500 assert_return(bus
, -EINVAL
);
1501 assert_return(id
, -EINVAL
);
1502 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1504 r
= bus_ensure_running(bus
);
1508 *id
= bus
->server_id
;
1512 static int bus_seal_message(sd_bus
*b
, sd_bus_message
*m
, usec_t timeout
) {
1517 /* If we copy the same message to multiple
1518 * destinations, avoid using the same cookie
1520 b
->cookie
= MAX(b
->cookie
, BUS_MESSAGE_COOKIE(m
));
1525 timeout
= BUS_DEFAULT_TIMEOUT
;
1527 return bus_message_seal(m
, ++b
->cookie
, timeout
);
1530 static int bus_remarshal_message(sd_bus
*b
, sd_bus_message
**m
) {
1531 bool remarshal
= false;
1535 /* wrong packet version */
1536 if (b
->message_version
!= 0 && b
->message_version
!= (*m
)->header
->version
)
1539 /* wrong packet endianness */
1540 if (b
->message_endian
!= 0 && b
->message_endian
!= (*m
)->header
->endian
)
1543 /* TODO: kdbus-messages received from the kernel contain data which is
1544 * not allowed to be passed to KDBUS_CMD_SEND. Therefore, we have to
1545 * force remarshaling of the message. Technically, we could just
1546 * recreate the kdbus message, but that is non-trivial as other parts of
1547 * the message refer to m->kdbus already. This should be fixed! */
1548 if ((*m
)->kdbus
&& (*m
)->release_kdbus
)
1551 return remarshal
? bus_message_remarshal(b
, m
) : 0;
1554 int bus_seal_synthetic_message(sd_bus
*b
, sd_bus_message
*m
) {
1558 /* Fake some timestamps, if they were requested, and not
1559 * already initialized */
1560 if (b
->attach_flags
& KDBUS_ATTACH_TIMESTAMP
) {
1561 if (m
->realtime
<= 0)
1562 m
->realtime
= now(CLOCK_REALTIME
);
1564 if (m
->monotonic
<= 0)
1565 m
->monotonic
= now(CLOCK_MONOTONIC
);
1568 /* The bus specification says the serial number cannot be 0,
1569 * hence let's fill something in for synthetic messages. Since
1570 * synthetic messages might have a fake sender and we don't
1571 * want to interfere with the real sender's serial numbers we
1572 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1573 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1574 * even though kdbus can do 64bit. */
1575 return bus_message_seal(m
, 0xFFFFFFFFULL
, 0);
1578 static int bus_write_message(sd_bus
*bus
, sd_bus_message
*m
, bool hint_sync_call
, size_t *idx
) {
1585 r
= bus_kernel_write_message(bus
, m
, hint_sync_call
);
1587 r
= bus_socket_write_message(bus
, m
, idx
);
1592 if (bus
->is_kernel
|| *idx
>= BUS_MESSAGE_SIZE(m
))
1593 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64
" reply_cookie=%" PRIu64
" error=%s",
1594 bus_message_type_to_string(m
->header
->type
),
1595 strna(sd_bus_message_get_sender(m
)),
1596 strna(sd_bus_message_get_destination(m
)),
1597 strna(sd_bus_message_get_path(m
)),
1598 strna(sd_bus_message_get_interface(m
)),
1599 strna(sd_bus_message_get_member(m
)),
1600 BUS_MESSAGE_COOKIE(m
),
1602 strna(m
->error
.message
));
1607 static int dispatch_wqueue(sd_bus
*bus
) {
1611 assert(bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
);
1613 while (bus
->wqueue_size
> 0) {
1615 r
= bus_write_message(bus
, bus
->wqueue
[0], false, &bus
->windex
);
1619 /* Didn't do anything this time */
1621 else if (bus
->is_kernel
|| bus
->windex
>= BUS_MESSAGE_SIZE(bus
->wqueue
[0])) {
1622 /* Fully written. Let's drop the entry from
1625 * This isn't particularly optimized, but
1626 * well, this is supposed to be our worst-case
1627 * buffer only, and the socket buffer is
1628 * supposed to be our primary buffer, and if
1629 * it got full, then all bets are off
1632 bus
->wqueue_size
--;
1633 sd_bus_message_unref(bus
->wqueue
[0]);
1634 memmove(bus
->wqueue
, bus
->wqueue
+ 1, sizeof(sd_bus_message
*) * bus
->wqueue_size
);
1644 static int bus_read_message(sd_bus
*bus
, bool hint_priority
, int64_t priority
) {
1648 return bus_kernel_read_message(bus
, hint_priority
, priority
);
1650 return bus_socket_read_message(bus
);
1653 int bus_rqueue_make_room(sd_bus
*bus
) {
1656 if (bus
->rqueue_size
>= BUS_RQUEUE_MAX
)
1659 if (!GREEDY_REALLOC(bus
->rqueue
, bus
->rqueue_allocated
, bus
->rqueue_size
+ 1))
1665 static int dispatch_rqueue(sd_bus
*bus
, bool hint_priority
, int64_t priority
, sd_bus_message
**m
) {
1670 assert(bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
);
1672 /* Note that the priority logic is only available on kdbus,
1673 * where the rqueue is unused. We check the rqueue here
1674 * anyway, because it's simple... */
1677 if (bus
->rqueue_size
> 0) {
1678 /* Dispatch a queued message */
1680 *m
= bus
->rqueue
[0];
1681 bus
->rqueue_size
--;
1682 memmove(bus
->rqueue
, bus
->rqueue
+ 1, sizeof(sd_bus_message
*) * bus
->rqueue_size
);
1686 /* Try to read a new message */
1687 r
= bus_read_message(bus
, hint_priority
, priority
);
1697 static int bus_send_internal(sd_bus
*bus
, sd_bus_message
*_m
, uint64_t *cookie
, bool hint_sync_call
) {
1698 _cleanup_bus_message_unref_ sd_bus_message
*m
= sd_bus_message_ref(_m
);
1701 assert_return(m
, -EINVAL
);
1706 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1707 assert_return(!bus
->is_kernel
|| !(bus
->hello_flags
& KDBUS_HELLO_MONITOR
), -EROFS
);
1709 if (!BUS_IS_OPEN(bus
->state
))
1713 r
= sd_bus_can_send(bus
, SD_BUS_TYPE_UNIX_FD
);
1720 /* If the cookie number isn't kept, then we know that no reply
1722 if (!cookie
&& !m
->sealed
)
1723 m
->header
->flags
|= BUS_MESSAGE_NO_REPLY_EXPECTED
;
1725 r
= bus_seal_message(bus
, m
, 0);
1729 /* Remarshall if we have to. This will possibly unref the
1730 * message and place a replacement in m */
1731 r
= bus_remarshal_message(bus
, &m
);
1735 /* If this is a reply and no reply was requested, then let's
1736 * suppress this, if we can */
1740 if ((bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
) && bus
->wqueue_size
<= 0) {
1743 r
= bus_write_message(bus
, m
, hint_sync_call
, &idx
);
1745 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
1746 bus_enter_closing(bus
);
1753 if (!bus
->is_kernel
&& idx
< BUS_MESSAGE_SIZE(m
)) {
1754 /* Wasn't fully written. So let's remember how
1755 * much was written. Note that the first entry
1756 * of the wqueue array is always allocated so
1757 * that we always can remember how much was
1759 bus
->wqueue
[0] = sd_bus_message_ref(m
);
1760 bus
->wqueue_size
= 1;
1765 /* Just append it to the queue. */
1767 if (bus
->wqueue_size
>= BUS_WQUEUE_MAX
)
1770 if (!GREEDY_REALLOC(bus
->wqueue
, bus
->wqueue_allocated
, bus
->wqueue_size
+ 1))
1773 bus
->wqueue
[bus
->wqueue_size
++] = sd_bus_message_ref(m
);
1778 *cookie
= BUS_MESSAGE_COOKIE(m
);
1783 _public_
int sd_bus_send(sd_bus
*bus
, sd_bus_message
*m
, uint64_t *cookie
) {
1784 return bus_send_internal(bus
, m
, cookie
, false);
1787 _public_
int sd_bus_send_to(sd_bus
*bus
, sd_bus_message
*m
, const char *destination
, uint64_t *cookie
) {
1790 assert_return(m
, -EINVAL
);
1795 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1797 if (!BUS_IS_OPEN(bus
->state
))
1800 if (!streq_ptr(m
->destination
, destination
)) {
1805 r
= sd_bus_message_set_destination(m
, destination
);
1810 return sd_bus_send(bus
, m
, cookie
);
1813 static usec_t
calc_elapse(uint64_t usec
) {
1814 if (usec
== (uint64_t) -1)
1817 return now(CLOCK_MONOTONIC
) + usec
;
1820 static int timeout_compare(const void *a
, const void *b
) {
1821 const struct reply_callback
*x
= a
, *y
= b
;
1823 if (x
->timeout
!= 0 && y
->timeout
== 0)
1826 if (x
->timeout
== 0 && y
->timeout
!= 0)
1829 if (x
->timeout
< y
->timeout
)
1832 if (x
->timeout
> y
->timeout
)
1838 _public_
int sd_bus_call_async(
1842 sd_bus_message_handler_t callback
,
1846 _cleanup_bus_message_unref_ sd_bus_message
*m
= sd_bus_message_ref(_m
);
1847 _cleanup_bus_slot_unref_ sd_bus_slot
*s
= NULL
;
1850 assert_return(m
, -EINVAL
);
1851 assert_return(m
->header
->type
== SD_BUS_MESSAGE_METHOD_CALL
, -EINVAL
);
1852 assert_return(!(m
->header
->flags
& BUS_MESSAGE_NO_REPLY_EXPECTED
), -EINVAL
);
1853 assert_return(callback
, -EINVAL
);
1858 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1859 assert_return(!bus
->is_kernel
|| !(bus
->hello_flags
& KDBUS_HELLO_MONITOR
), -EROFS
);
1861 if (!BUS_IS_OPEN(bus
->state
))
1864 r
= ordered_hashmap_ensure_allocated(&bus
->reply_callbacks
, &uint64_hash_ops
);
1868 r
= prioq_ensure_allocated(&bus
->reply_callbacks_prioq
, timeout_compare
);
1872 r
= bus_seal_message(bus
, m
, usec
);
1876 r
= bus_remarshal_message(bus
, &m
);
1880 s
= bus_slot_allocate(bus
, !slot
, BUS_REPLY_CALLBACK
, sizeof(struct reply_callback
), userdata
);
1884 s
->reply_callback
.callback
= callback
;
1886 s
->reply_callback
.cookie
= BUS_MESSAGE_COOKIE(m
);
1887 r
= ordered_hashmap_put(bus
->reply_callbacks
, &s
->reply_callback
.cookie
, &s
->reply_callback
);
1889 s
->reply_callback
.cookie
= 0;
1893 s
->reply_callback
.timeout
= calc_elapse(m
->timeout
);
1894 if (s
->reply_callback
.timeout
!= 0) {
1895 r
= prioq_put(bus
->reply_callbacks_prioq
, &s
->reply_callback
, &s
->reply_callback
.prioq_idx
);
1897 s
->reply_callback
.timeout
= 0;
1902 r
= sd_bus_send(bus
, m
, &s
->reply_callback
.cookie
);
1913 int bus_ensure_running(sd_bus
*bus
) {
1918 if (bus
->state
== BUS_UNSET
|| bus
->state
== BUS_CLOSED
|| bus
->state
== BUS_CLOSING
)
1920 if (bus
->state
== BUS_RUNNING
)
1924 r
= sd_bus_process(bus
, NULL
);
1927 if (bus
->state
== BUS_RUNNING
)
1932 r
= sd_bus_wait(bus
, (uint64_t) -1);
1938 _public_
int sd_bus_call(
1942 sd_bus_error
*error
,
1943 sd_bus_message
**reply
) {
1945 _cleanup_bus_message_unref_ sd_bus_message
*m
= sd_bus_message_ref(_m
);
1951 assert_return(m
, -EINVAL
);
1952 assert_return(m
->header
->type
== SD_BUS_MESSAGE_METHOD_CALL
, -EINVAL
);
1953 assert_return(!(m
->header
->flags
& BUS_MESSAGE_NO_REPLY_EXPECTED
), -EINVAL
);
1954 assert_return(!bus_error_is_dirty(error
), -EINVAL
);
1959 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1960 assert_return(!bus
->is_kernel
|| !(bus
->hello_flags
& KDBUS_HELLO_MONITOR
), -EROFS
);
1962 if (!BUS_IS_OPEN(bus
->state
))
1965 r
= bus_ensure_running(bus
);
1969 i
= bus
->rqueue_size
;
1971 r
= bus_seal_message(bus
, m
, usec
);
1975 r
= bus_remarshal_message(bus
, &m
);
1979 r
= bus_send_internal(bus
, m
, &cookie
, true);
1983 timeout
= calc_elapse(m
->timeout
);
1988 while (i
< bus
->rqueue_size
) {
1989 sd_bus_message
*incoming
= NULL
;
1991 incoming
= bus
->rqueue
[i
];
1993 if (incoming
->reply_cookie
== cookie
) {
1994 /* Found a match! */
1996 memmove(bus
->rqueue
+ i
, bus
->rqueue
+ i
+ 1, sizeof(sd_bus_message
*) * (bus
->rqueue_size
- i
- 1));
1998 log_debug_bus_message(incoming
);
2000 if (incoming
->header
->type
== SD_BUS_MESSAGE_METHOD_RETURN
) {
2002 if (incoming
->n_fds
<= 0 || (bus
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
)) {
2006 sd_bus_message_unref(incoming
);
2011 r
= sd_bus_error_setf(error
, SD_BUS_ERROR_INCONSISTENT_MESSAGE
, "Reply message contained file descriptors which I couldn't accept. Sorry.");
2013 } else if (incoming
->header
->type
== SD_BUS_MESSAGE_METHOD_ERROR
)
2014 r
= sd_bus_error_copy(error
, &incoming
->error
);
2018 sd_bus_message_unref(incoming
);
2021 } else if (BUS_MESSAGE_COOKIE(incoming
) == cookie
&&
2024 streq(bus
->unique_name
, incoming
->sender
)) {
2026 memmove(bus
->rqueue
+ i
, bus
->rqueue
+ i
+ 1, sizeof(sd_bus_message
*) * (bus
->rqueue_size
- i
- 1));
2029 /* Our own message? Somebody is trying
2030 * to send its own client a message,
2031 * let's not dead-lock, let's fail
2034 sd_bus_message_unref(incoming
);
2038 /* Try to read more, right-away */
2042 r
= bus_read_message(bus
, false, 0);
2044 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2045 bus_enter_closing(bus
);
2057 n
= now(CLOCK_MONOTONIC
);
2063 left
= (uint64_t) -1;
2065 r
= bus_poll(bus
, true, left
);
2071 r
= dispatch_wqueue(bus
);
2073 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2074 bus_enter_closing(bus
);
2083 _public_
int sd_bus_get_fd(sd_bus
*bus
) {
2085 assert_return(bus
, -EINVAL
);
2086 assert_return(bus
->input_fd
== bus
->output_fd
, -EPERM
);
2087 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2089 return bus
->input_fd
;
2092 _public_
int sd_bus_get_events(sd_bus
*bus
) {
2095 assert_return(bus
, -EINVAL
);
2096 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2098 if (!BUS_IS_OPEN(bus
->state
) && bus
->state
!= BUS_CLOSING
)
2101 if (bus
->state
== BUS_OPENING
)
2103 else if (bus
->state
== BUS_AUTHENTICATING
) {
2105 if (bus_socket_auth_needs_write(bus
))
2110 } else if (bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
) {
2111 if (bus
->rqueue_size
<= 0)
2113 if (bus
->wqueue_size
> 0)
2120 _public_
int sd_bus_get_timeout(sd_bus
*bus
, uint64_t *timeout_usec
) {
2121 struct reply_callback
*c
;
2123 assert_return(bus
, -EINVAL
);
2124 assert_return(timeout_usec
, -EINVAL
);
2125 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2127 if (!BUS_IS_OPEN(bus
->state
) && bus
->state
!= BUS_CLOSING
)
2130 if (bus
->track_queue
) {
2135 if (bus
->state
== BUS_CLOSING
) {
2140 if (bus
->state
== BUS_AUTHENTICATING
) {
2141 *timeout_usec
= bus
->auth_timeout
;
2145 if (bus
->state
!= BUS_RUNNING
&& bus
->state
!= BUS_HELLO
) {
2146 *timeout_usec
= (uint64_t) -1;
2150 if (bus
->rqueue_size
> 0) {
2155 c
= prioq_peek(bus
->reply_callbacks_prioq
);
2157 *timeout_usec
= (uint64_t) -1;
2161 if (c
->timeout
== 0) {
2162 *timeout_usec
= (uint64_t) -1;
2166 *timeout_usec
= c
->timeout
;
2170 static int process_timeout(sd_bus
*bus
) {
2171 _cleanup_bus_error_free_ sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2172 _cleanup_bus_message_unref_ sd_bus_message
* m
= NULL
;
2173 struct reply_callback
*c
;
2180 c
= prioq_peek(bus
->reply_callbacks_prioq
);
2184 n
= now(CLOCK_MONOTONIC
);
2188 r
= bus_message_new_synthetic_error(
2191 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY
, "Method call timed out"),
2196 r
= bus_seal_synthetic_message(bus
, m
);
2200 assert_se(prioq_pop(bus
->reply_callbacks_prioq
) == c
);
2203 ordered_hashmap_remove(bus
->reply_callbacks
, &c
->cookie
);
2206 slot
= container_of(c
, sd_bus_slot
, reply_callback
);
2208 bus
->iteration_counter
++;
2210 bus
->current_message
= m
;
2211 bus
->current_slot
= sd_bus_slot_ref(slot
);
2212 bus
->current_handler
= c
->callback
;
2213 bus
->current_userdata
= slot
->userdata
;
2214 r
= c
->callback(m
, slot
->userdata
, &error_buffer
);
2215 bus
->current_userdata
= NULL
;
2216 bus
->current_handler
= NULL
;
2217 bus
->current_slot
= NULL
;
2218 bus
->current_message
= NULL
;
2220 if (slot
->floating
) {
2221 bus_slot_disconnect(slot
);
2222 sd_bus_slot_unref(slot
);
2225 sd_bus_slot_unref(slot
);
2227 return bus_maybe_reply_error(m
, r
, &error_buffer
);
2230 static int process_hello(sd_bus
*bus
, sd_bus_message
*m
) {
2234 if (bus
->state
!= BUS_HELLO
)
2237 /* Let's make sure the first message on the bus is the HELLO
2238 * reply. But note that we don't actually parse the message
2239 * here (we leave that to the usual handling), we just verify
2240 * we don't let any earlier msg through. */
2242 if (m
->header
->type
!= SD_BUS_MESSAGE_METHOD_RETURN
&&
2243 m
->header
->type
!= SD_BUS_MESSAGE_METHOD_ERROR
)
2246 if (m
->reply_cookie
!= 1)
2252 static int process_reply(sd_bus
*bus
, sd_bus_message
*m
) {
2253 _cleanup_bus_message_unref_ sd_bus_message
*synthetic_reply
= NULL
;
2254 _cleanup_bus_error_free_ sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2255 struct reply_callback
*c
;
2262 if (m
->header
->type
!= SD_BUS_MESSAGE_METHOD_RETURN
&&
2263 m
->header
->type
!= SD_BUS_MESSAGE_METHOD_ERROR
)
2266 if (bus
->is_kernel
&& (bus
->hello_flags
& KDBUS_HELLO_MONITOR
))
2269 if (m
->destination
&& bus
->unique_name
&& !streq_ptr(m
->destination
, bus
->unique_name
))
2272 c
= ordered_hashmap_remove(bus
->reply_callbacks
, &m
->reply_cookie
);
2278 slot
= container_of(c
, sd_bus_slot
, reply_callback
);
2280 if (m
->n_fds
> 0 && !(bus
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
)) {
2282 /* If the reply contained a file descriptor which we
2283 * didn't want we pass an error instead. */
2285 r
= bus_message_new_synthetic_error(
2288 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE
, "Reply message contained file descriptor"),
2293 /* Copy over original timestamp */
2294 synthetic_reply
->realtime
= m
->realtime
;
2295 synthetic_reply
->monotonic
= m
->monotonic
;
2296 synthetic_reply
->seqnum
= m
->seqnum
;
2298 r
= bus_seal_synthetic_message(bus
, synthetic_reply
);
2302 m
= synthetic_reply
;
2304 r
= sd_bus_message_rewind(m
, true);
2309 if (c
->timeout
!= 0) {
2310 prioq_remove(bus
->reply_callbacks_prioq
, c
, &c
->prioq_idx
);
2314 bus
->current_slot
= sd_bus_slot_ref(slot
);
2315 bus
->current_handler
= c
->callback
;
2316 bus
->current_userdata
= slot
->userdata
;
2317 r
= c
->callback(m
, slot
->userdata
, &error_buffer
);
2318 bus
->current_userdata
= NULL
;
2319 bus
->current_handler
= NULL
;
2320 bus
->current_slot
= NULL
;
2322 if (slot
->floating
) {
2323 bus_slot_disconnect(slot
);
2324 sd_bus_slot_unref(slot
);
2327 sd_bus_slot_unref(slot
);
2329 return bus_maybe_reply_error(m
, r
, &error_buffer
);
2332 static int process_filter(sd_bus
*bus
, sd_bus_message
*m
) {
2333 _cleanup_bus_error_free_ sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2334 struct filter_callback
*l
;
2341 bus
->filter_callbacks_modified
= false;
2343 LIST_FOREACH(callbacks
, l
, bus
->filter_callbacks
) {
2346 if (bus
->filter_callbacks_modified
)
2349 /* Don't run this more than once per iteration */
2350 if (l
->last_iteration
== bus
->iteration_counter
)
2353 l
->last_iteration
= bus
->iteration_counter
;
2355 r
= sd_bus_message_rewind(m
, true);
2359 slot
= container_of(l
, sd_bus_slot
, filter_callback
);
2361 bus
->current_slot
= sd_bus_slot_ref(slot
);
2362 bus
->current_handler
= l
->callback
;
2363 bus
->current_userdata
= slot
->userdata
;
2364 r
= l
->callback(m
, slot
->userdata
, &error_buffer
);
2365 bus
->current_userdata
= NULL
;
2366 bus
->current_handler
= NULL
;
2367 bus
->current_slot
= sd_bus_slot_unref(slot
);
2369 r
= bus_maybe_reply_error(m
, r
, &error_buffer
);
2375 } while (bus
->filter_callbacks_modified
);
2380 static int process_match(sd_bus
*bus
, sd_bus_message
*m
) {
2387 bus
->match_callbacks_modified
= false;
2389 r
= bus_match_run(bus
, &bus
->match_callbacks
, m
);
2393 } while (bus
->match_callbacks_modified
);
2398 static int process_builtin(sd_bus
*bus
, sd_bus_message
*m
) {
2399 _cleanup_bus_message_unref_ sd_bus_message
*reply
= NULL
;
2405 if (bus
->hello_flags
& KDBUS_HELLO_MONITOR
)
2408 if (bus
->manual_peer_interface
)
2411 if (m
->header
->type
!= SD_BUS_MESSAGE_METHOD_CALL
)
2414 if (!streq_ptr(m
->interface
, "org.freedesktop.DBus.Peer"))
2417 if (m
->header
->flags
& BUS_MESSAGE_NO_REPLY_EXPECTED
)
2420 if (streq_ptr(m
->member
, "Ping"))
2421 r
= sd_bus_message_new_method_return(m
, &reply
);
2422 else if (streq_ptr(m
->member
, "GetMachineId")) {
2426 r
= sd_id128_get_machine(&id
);
2430 r
= sd_bus_message_new_method_return(m
, &reply
);
2434 r
= sd_bus_message_append(reply
, "s", sd_id128_to_string(id
, sid
));
2436 r
= sd_bus_message_new_method_errorf(
2438 SD_BUS_ERROR_UNKNOWN_METHOD
,
2439 "Unknown method '%s' on interface '%s'.", m
->member
, m
->interface
);
2445 r
= sd_bus_send(bus
, reply
, NULL
);
2452 static int process_fd_check(sd_bus
*bus
, sd_bus_message
*m
) {
2456 /* If we got a message with a file descriptor which we didn't
2457 * want to accept, then let's drop it. How can this even
2458 * happen? For example, when the kernel queues a message into
2459 * an activatable names's queue which allows fds, and then is
2460 * delivered to us later even though we ourselves did not
2463 if (bus
->hello_flags
& KDBUS_HELLO_MONITOR
)
2469 if (bus
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
)
2472 if (m
->header
->type
!= SD_BUS_MESSAGE_METHOD_CALL
)
2473 return 1; /* just eat it up */
2475 return sd_bus_reply_method_errorf(m
, SD_BUS_ERROR_INCONSISTENT_MESSAGE
, "Message contains file descriptors, which I cannot accept. Sorry.");
2478 static int process_message(sd_bus
*bus
, sd_bus_message
*m
) {
2484 bus
->current_message
= m
;
2485 bus
->iteration_counter
++;
2487 log_debug_bus_message(m
);
2489 r
= process_hello(bus
, m
);
2493 r
= process_reply(bus
, m
);
2497 r
= process_fd_check(bus
, m
);
2501 r
= process_filter(bus
, m
);
2505 r
= process_match(bus
, m
);
2509 r
= process_builtin(bus
, m
);
2513 r
= bus_process_object(bus
, m
);
2516 bus
->current_message
= NULL
;
2520 static int dispatch_track(sd_bus
*bus
) {
2523 if (!bus
->track_queue
)
2526 bus_track_dispatch(bus
->track_queue
);
2530 static int process_running(sd_bus
*bus
, bool hint_priority
, int64_t priority
, sd_bus_message
**ret
) {
2531 _cleanup_bus_message_unref_ sd_bus_message
*m
= NULL
;
2535 assert(bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
);
2537 r
= process_timeout(bus
);
2541 r
= dispatch_wqueue(bus
);
2545 r
= dispatch_track(bus
);
2549 r
= dispatch_rqueue(bus
, hint_priority
, priority
, &m
);
2555 r
= process_message(bus
, m
);
2560 r
= sd_bus_message_rewind(m
, true);
2569 if (m
->header
->type
== SD_BUS_MESSAGE_METHOD_CALL
) {
2571 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2572 strna(sd_bus_message_get_sender(m
)),
2573 strna(sd_bus_message_get_path(m
)),
2574 strna(sd_bus_message_get_interface(m
)),
2575 strna(sd_bus_message_get_member(m
)));
2577 r
= sd_bus_reply_method_errorf(
2579 SD_BUS_ERROR_UNKNOWN_OBJECT
,
2580 "Unknown object '%s'.", m
->path
);
2594 static int process_closing(sd_bus
*bus
, sd_bus_message
**ret
) {
2595 _cleanup_bus_message_unref_ sd_bus_message
*m
= NULL
;
2596 struct reply_callback
*c
;
2600 assert(bus
->state
== BUS_CLOSING
);
2602 c
= ordered_hashmap_first(bus
->reply_callbacks
);
2604 _cleanup_bus_error_free_ sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2607 /* First, fail all outstanding method calls */
2608 r
= bus_message_new_synthetic_error(
2611 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY
, "Connection terminated"),
2616 r
= bus_seal_synthetic_message(bus
, m
);
2620 if (c
->timeout
!= 0) {
2621 prioq_remove(bus
->reply_callbacks_prioq
, c
, &c
->prioq_idx
);
2625 ordered_hashmap_remove(bus
->reply_callbacks
, &c
->cookie
);
2628 slot
= container_of(c
, sd_bus_slot
, reply_callback
);
2630 bus
->iteration_counter
++;
2632 bus
->current_message
= m
;
2633 bus
->current_slot
= sd_bus_slot_ref(slot
);
2634 bus
->current_handler
= c
->callback
;
2635 bus
->current_userdata
= slot
->userdata
;
2636 r
= c
->callback(m
, slot
->userdata
, &error_buffer
);
2637 bus
->current_userdata
= NULL
;
2638 bus
->current_handler
= NULL
;
2639 bus
->current_slot
= NULL
;
2640 bus
->current_message
= NULL
;
2642 if (slot
->floating
) {
2643 bus_slot_disconnect(slot
);
2644 sd_bus_slot_unref(slot
);
2647 sd_bus_slot_unref(slot
);
2649 return bus_maybe_reply_error(m
, r
, &error_buffer
);
2652 /* Then, synthesize a Disconnected message */
2653 r
= sd_bus_message_new_signal(
2656 "/org/freedesktop/DBus/Local",
2657 "org.freedesktop.DBus.Local",
2662 bus_message_set_sender_local(bus
, m
);
2664 r
= bus_seal_synthetic_message(bus
, m
);
2670 bus
->current_message
= m
;
2671 bus
->iteration_counter
++;
2673 r
= process_filter(bus
, m
);
2677 r
= process_match(bus
, m
);
2689 bus
->current_message
= NULL
;
2694 static int bus_process_internal(sd_bus
*bus
, bool hint_priority
, int64_t priority
, sd_bus_message
**ret
) {
2695 BUS_DONT_DESTROY(bus
);
2698 /* Returns 0 when we didn't do anything. This should cause the
2699 * caller to invoke sd_bus_wait() before returning the next
2700 * time. Returns > 0 when we did something, which possibly
2701 * means *ret is filled in with an unprocessed message. */
2703 assert_return(bus
, -EINVAL
);
2704 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2706 /* We don't allow recursively invoking sd_bus_process(). */
2707 assert_return(!bus
->current_message
, -EBUSY
);
2708 assert(!bus
->current_slot
);
2710 switch (bus
->state
) {
2719 r
= bus_socket_process_opening(bus
);
2720 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2721 bus_enter_closing(bus
);
2729 case BUS_AUTHENTICATING
:
2730 r
= bus_socket_process_authenticating(bus
);
2731 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2732 bus_enter_closing(bus
);
2744 r
= process_running(bus
, hint_priority
, priority
, ret
);
2745 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2746 bus_enter_closing(bus
);
2756 return process_closing(bus
, ret
);
2759 assert_not_reached("Unknown state");
2762 _public_
int sd_bus_process(sd_bus
*bus
, sd_bus_message
**ret
) {
2763 return bus_process_internal(bus
, false, 0, ret
);
2766 _public_
int sd_bus_process_priority(sd_bus
*bus
, int64_t priority
, sd_bus_message
**ret
) {
2767 return bus_process_internal(bus
, true, priority
, ret
);
2770 static int bus_poll(sd_bus
*bus
, bool need_more
, uint64_t timeout_usec
) {
2771 struct pollfd p
[2] = {};
2774 usec_t m
= USEC_INFINITY
;
2778 if (bus
->state
== BUS_CLOSING
)
2781 if (!BUS_IS_OPEN(bus
->state
))
2784 e
= sd_bus_get_events(bus
);
2789 /* The caller really needs some more data, he doesn't
2790 * care about what's already read, or any timeouts
2791 * except its own. */
2795 /* The caller wants to process if there's something to
2796 * process, but doesn't care otherwise */
2798 r
= sd_bus_get_timeout(bus
, &until
);
2803 nw
= now(CLOCK_MONOTONIC
);
2804 m
= until
> nw
? until
- nw
: 0;
2808 if (timeout_usec
!= (uint64_t) -1 && (m
== (uint64_t) -1 || timeout_usec
< m
))
2811 p
[0].fd
= bus
->input_fd
;
2812 if (bus
->output_fd
== bus
->input_fd
) {
2816 p
[0].events
= e
& POLLIN
;
2817 p
[1].fd
= bus
->output_fd
;
2818 p
[1].events
= e
& POLLOUT
;
2822 r
= ppoll(p
, n
, m
== (uint64_t) -1 ? NULL
: timespec_store(&ts
, m
), NULL
);
2826 return r
> 0 ? 1 : 0;
2829 _public_
int sd_bus_wait(sd_bus
*bus
, uint64_t timeout_usec
) {
2831 assert_return(bus
, -EINVAL
);
2832 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2834 if (bus
->state
== BUS_CLOSING
)
2837 if (!BUS_IS_OPEN(bus
->state
))
2840 if (bus
->rqueue_size
> 0)
2843 return bus_poll(bus
, false, timeout_usec
);
2846 _public_
int sd_bus_flush(sd_bus
*bus
) {
2849 assert_return(bus
, -EINVAL
);
2850 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2852 if (bus
->state
== BUS_CLOSING
)
2855 if (!BUS_IS_OPEN(bus
->state
))
2858 r
= bus_ensure_running(bus
);
2862 if (bus
->wqueue_size
<= 0)
2866 r
= dispatch_wqueue(bus
);
2868 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2869 bus_enter_closing(bus
);
2876 if (bus
->wqueue_size
<= 0)
2879 r
= bus_poll(bus
, false, (uint64_t) -1);
2885 _public_
int sd_bus_add_filter(
2888 sd_bus_message_handler_t callback
,
2893 assert_return(bus
, -EINVAL
);
2894 assert_return(callback
, -EINVAL
);
2895 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2897 s
= bus_slot_allocate(bus
, !slot
, BUS_FILTER_CALLBACK
, sizeof(struct filter_callback
), userdata
);
2901 s
->filter_callback
.callback
= callback
;
2903 bus
->filter_callbacks_modified
= true;
2904 LIST_PREPEND(callbacks
, bus
->filter_callbacks
, &s
->filter_callback
);
2912 _public_
int sd_bus_add_match(
2916 sd_bus_message_handler_t callback
,
2919 struct bus_match_component
*components
= NULL
;
2920 unsigned n_components
= 0;
2921 sd_bus_slot
*s
= NULL
;
2924 assert_return(bus
, -EINVAL
);
2925 assert_return(match
, -EINVAL
);
2926 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2928 r
= bus_match_parse(match
, &components
, &n_components
);
2932 s
= bus_slot_allocate(bus
, !slot
, BUS_MATCH_CALLBACK
, sizeof(struct match_callback
), userdata
);
2938 s
->match_callback
.callback
= callback
;
2939 s
->match_callback
.cookie
= ++bus
->match_cookie
;
2941 if (bus
->bus_client
) {
2942 enum bus_match_scope scope
;
2944 scope
= bus_match_get_scope(components
, n_components
);
2946 /* Do not install server-side matches for matches
2947 * against the local service, interface or bus
2948 * path. Also, when on kdbus don't install driver
2949 * matches server side. */
2950 if (scope
== BUS_MATCH_GENERIC
||
2951 (!bus
->is_kernel
&& scope
== BUS_MATCH_DRIVER
)) {
2953 if (!bus
->is_kernel
) {
2954 /* When this is not a kernel transport, we
2955 * store the original match string, so that we
2956 * can use it to remove the match again */
2958 s
->match_callback
.match_string
= strdup(match
);
2959 if (!s
->match_callback
.match_string
) {
2965 r
= bus_add_match_internal(bus
, s
->match_callback
.match_string
, components
, n_components
, s
->match_callback
.cookie
);
2969 s
->match_added
= true;
2973 bus
->match_callbacks_modified
= true;
2974 r
= bus_match_add(&bus
->match_callbacks
, components
, n_components
, &s
->match_callback
);
2983 bus_match_parse_free(components
, n_components
);
2984 sd_bus_slot_unref(s
);
2989 int bus_remove_match_by_string(
2992 sd_bus_message_handler_t callback
,
2995 struct bus_match_component
*components
= NULL
;
2996 unsigned n_components
= 0;
2997 struct match_callback
*c
;
3000 assert_return(bus
, -EINVAL
);
3001 assert_return(match
, -EINVAL
);
3002 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3004 r
= bus_match_parse(match
, &components
, &n_components
);
3008 r
= bus_match_find(&bus
->match_callbacks
, components
, n_components
, NULL
, NULL
, &c
);
3012 sd_bus_slot_unref(container_of(c
, sd_bus_slot
, match_callback
));
3015 bus_match_parse_free(components
, n_components
);
3020 bool bus_pid_changed(sd_bus
*bus
) {
3023 /* We don't support people creating a bus connection and
3024 * keeping it around over a fork(). Let's complain. */
3026 return bus
->original_pid
!= getpid();
3029 static int io_callback(sd_event_source
*s
, int fd
, uint32_t revents
, void *userdata
) {
3030 sd_bus
*bus
= userdata
;
3035 r
= sd_bus_process(bus
, NULL
);
3042 static int time_callback(sd_event_source
*s
, uint64_t usec
, void *userdata
) {
3043 sd_bus
*bus
= userdata
;
3048 r
= sd_bus_process(bus
, NULL
);
3055 static int prepare_callback(sd_event_source
*s
, void *userdata
) {
3056 sd_bus
*bus
= userdata
;
3063 e
= sd_bus_get_events(bus
);
3067 if (bus
->output_fd
!= bus
->input_fd
) {
3069 r
= sd_event_source_set_io_events(bus
->input_io_event_source
, e
& POLLIN
);
3073 r
= sd_event_source_set_io_events(bus
->output_io_event_source
, e
& POLLOUT
);
3077 r
= sd_event_source_set_io_events(bus
->input_io_event_source
, e
);
3082 r
= sd_bus_get_timeout(bus
, &until
);
3088 j
= sd_event_source_set_time(bus
->time_event_source
, until
);
3093 r
= sd_event_source_set_enabled(bus
->time_event_source
, r
> 0);
3100 static int quit_callback(sd_event_source
*event
, void *userdata
) {
3101 sd_bus
*bus
= userdata
;
3111 static int attach_io_events(sd_bus
*bus
) {
3116 if (bus
->input_fd
< 0)
3122 if (!bus
->input_io_event_source
) {
3123 r
= sd_event_add_io(bus
->event
, &bus
->input_io_event_source
, bus
->input_fd
, 0, io_callback
, bus
);
3127 r
= sd_event_source_set_prepare(bus
->input_io_event_source
, prepare_callback
);
3131 r
= sd_event_source_set_priority(bus
->input_io_event_source
, bus
->event_priority
);
3135 r
= sd_event_source_set_description(bus
->input_io_event_source
, "bus-input");
3137 r
= sd_event_source_set_io_fd(bus
->input_io_event_source
, bus
->input_fd
);
3142 if (bus
->output_fd
!= bus
->input_fd
) {
3143 assert(bus
->output_fd
>= 0);
3145 if (!bus
->output_io_event_source
) {
3146 r
= sd_event_add_io(bus
->event
, &bus
->output_io_event_source
, bus
->output_fd
, 0, io_callback
, bus
);
3150 r
= sd_event_source_set_priority(bus
->output_io_event_source
, bus
->event_priority
);
3154 r
= sd_event_source_set_description(bus
->input_io_event_source
, "bus-output");
3156 r
= sd_event_source_set_io_fd(bus
->output_io_event_source
, bus
->output_fd
);
3165 static void detach_io_events(sd_bus
*bus
) {
3168 if (bus
->input_io_event_source
) {
3169 sd_event_source_set_enabled(bus
->input_io_event_source
, SD_EVENT_OFF
);
3170 bus
->input_io_event_source
= sd_event_source_unref(bus
->input_io_event_source
);
3173 if (bus
->output_io_event_source
) {
3174 sd_event_source_set_enabled(bus
->output_io_event_source
, SD_EVENT_OFF
);
3175 bus
->output_io_event_source
= sd_event_source_unref(bus
->output_io_event_source
);
3179 _public_
int sd_bus_attach_event(sd_bus
*bus
, sd_event
*event
, int priority
) {
3182 assert_return(bus
, -EINVAL
);
3183 assert_return(!bus
->event
, -EBUSY
);
3185 assert(!bus
->input_io_event_source
);
3186 assert(!bus
->output_io_event_source
);
3187 assert(!bus
->time_event_source
);
3190 bus
->event
= sd_event_ref(event
);
3192 r
= sd_event_default(&bus
->event
);
3197 bus
->event_priority
= priority
;
3199 r
= sd_event_add_time(bus
->event
, &bus
->time_event_source
, CLOCK_MONOTONIC
, 0, 0, time_callback
, bus
);
3203 r
= sd_event_source_set_priority(bus
->time_event_source
, priority
);
3207 r
= sd_event_source_set_description(bus
->time_event_source
, "bus-time");
3211 r
= sd_event_add_exit(bus
->event
, &bus
->quit_event_source
, quit_callback
, bus
);
3215 r
= sd_event_source_set_description(bus
->quit_event_source
, "bus-exit");
3219 r
= attach_io_events(bus
);
3226 sd_bus_detach_event(bus
);
3230 _public_
int sd_bus_detach_event(sd_bus
*bus
) {
3231 assert_return(bus
, -EINVAL
);
3236 detach_io_events(bus
);
3238 if (bus
->time_event_source
) {
3239 sd_event_source_set_enabled(bus
->time_event_source
, SD_EVENT_OFF
);
3240 bus
->time_event_source
= sd_event_source_unref(bus
->time_event_source
);
3243 if (bus
->quit_event_source
) {
3244 sd_event_source_set_enabled(bus
->quit_event_source
, SD_EVENT_OFF
);
3245 bus
->quit_event_source
= sd_event_source_unref(bus
->quit_event_source
);
3248 bus
->event
= sd_event_unref(bus
->event
);
3252 _public_ sd_event
* sd_bus_get_event(sd_bus
*bus
) {
3253 assert_return(bus
, NULL
);
3258 _public_ sd_bus_message
* sd_bus_get_current_message(sd_bus
*bus
) {
3259 assert_return(bus
, NULL
);
3261 return bus
->current_message
;
3264 _public_ sd_bus_slot
* sd_bus_get_current_slot(sd_bus
*bus
) {
3265 assert_return(bus
, NULL
);
3267 return bus
->current_slot
;
3270 _public_ sd_bus_message_handler_t
sd_bus_get_current_handler(sd_bus
*bus
) {
3271 assert_return(bus
, NULL
);
3273 return bus
->current_handler
;
3276 _public_
void* sd_bus_get_current_userdata(sd_bus
*bus
) {
3277 assert_return(bus
, NULL
);
3279 return bus
->current_userdata
;
3282 static int bus_default(int (*bus_open
)(sd_bus
**), sd_bus
**default_bus
, sd_bus
**ret
) {
3287 assert(default_bus
);
3290 return !!*default_bus
;
3293 *ret
= sd_bus_ref(*default_bus
);
3301 b
->default_bus_ptr
= default_bus
;
3309 _public_
int sd_bus_default_system(sd_bus
**ret
) {
3310 static thread_local sd_bus
*default_system_bus
= NULL
;
3312 return bus_default(sd_bus_open_system
, &default_system_bus
, ret
);
3315 _public_
int sd_bus_default_user(sd_bus
**ret
) {
3316 static thread_local sd_bus
*default_user_bus
= NULL
;
3318 return bus_default(sd_bus_open_user
, &default_user_bus
, ret
);
3321 _public_
int sd_bus_default(sd_bus
**ret
) {
3325 /* Let's try our best to reuse another cached connection. If
3326 * the starter bus type is set, connect via our normal
3327 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3328 * we can share the connection with the user/system default
3331 e
= secure_getenv("DBUS_STARTER_BUS_TYPE");
3333 if (streq(e
, "system"))
3334 return sd_bus_default_system(ret
);
3335 else if (STR_IN_SET(e
, "user", "session"))
3336 return sd_bus_default_user(ret
);
3339 /* No type is specified, so we have not other option than to
3340 * use the starter address if it is set. */
3342 e
= secure_getenv("DBUS_STARTER_ADDRESS");
3344 static thread_local sd_bus
*default_starter_bus
= NULL
;
3346 return bus_default(sd_bus_open
, &default_starter_bus
, ret
);
3349 /* Finally, if nothing is set use the cached connection for
3350 * the right scope */
3352 if (cg_pid_get_owner_uid(0, NULL
) >= 0)
3353 return sd_bus_default_user(ret
);
3355 return sd_bus_default_system(ret
);
3358 _public_
int sd_bus_get_tid(sd_bus
*b
, pid_t
*tid
) {
3359 assert_return(b
, -EINVAL
);
3360 assert_return(tid
, -EINVAL
);
3361 assert_return(!bus_pid_changed(b
), -ECHILD
);
3369 return sd_event_get_tid(b
->event
, tid
);
3374 _public_
int sd_bus_path_encode(const char *prefix
, const char *external_id
, char **ret_path
) {
3375 _cleanup_free_
char *e
= NULL
;
3378 assert_return(object_path_is_valid(prefix
), -EINVAL
);
3379 assert_return(external_id
, -EINVAL
);
3380 assert_return(ret_path
, -EINVAL
);
3382 e
= bus_label_escape(external_id
);
3386 ret
= strjoin(prefix
, "/", e
, NULL
);
3394 _public_
int sd_bus_path_decode(const char *path
, const char *prefix
, char **external_id
) {
3398 assert_return(object_path_is_valid(path
), -EINVAL
);
3399 assert_return(object_path_is_valid(prefix
), -EINVAL
);
3400 assert_return(external_id
, -EINVAL
);
3402 e
= object_path_startswith(path
, prefix
);
3404 *external_id
= NULL
;
3408 ret
= bus_label_unescape(e
);
3416 _public_
int sd_bus_try_close(sd_bus
*bus
) {
3419 assert_return(bus
, -EINVAL
);
3420 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3422 if (!bus
->is_kernel
)
3425 if (!BUS_IS_OPEN(bus
->state
))
3428 if (bus
->rqueue_size
> 0)
3431 if (bus
->wqueue_size
> 0)
3434 r
= bus_kernel_try_close(bus
);
3442 _public_
int sd_bus_get_description(sd_bus
*bus
, const char **description
) {
3443 assert_return(bus
, -EINVAL
);
3444 assert_return(description
, -EINVAL
);
3445 assert_return(bus
->description
, -ENXIO
);
3446 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3448 *description
= bus
->description
;
3452 int bus_get_root_path(sd_bus
*bus
) {
3455 if (bus
->cgroup_root
)
3458 r
= cg_get_root_path(&bus
->cgroup_root
);
3460 bus
->cgroup_root
= strdup("/");
3461 if (!bus
->cgroup_root
)
3470 _public_
int sd_bus_get_scope(sd_bus
*bus
, const char **scope
) {
3473 assert_return(bus
, -EINVAL
);
3474 assert_return(scope
, -EINVAL
);
3475 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3477 if (bus
->is_kernel
) {
3478 _cleanup_free_
char *n
= NULL
;
3481 r
= bus_kernel_get_bus_name(bus
, &n
);
3485 if (streq(n
, "0-system")) {
3490 dash
= strchr(n
, '-');
3491 if (streq_ptr(dash
, "-user")) {
3502 if (bus
->is_system
) {
3510 _public_
int sd_bus_get_address(sd_bus
*bus
, const char **address
) {
3512 assert_return(bus
, -EINVAL
);
3513 assert_return(address
, -EINVAL
);
3514 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3517 *address
= bus
->address
;
3524 _public_
int sd_bus_get_creds_mask(sd_bus
*bus
, uint64_t *mask
) {
3525 assert_return(bus
, -EINVAL
);
3526 assert_return(mask
, -EINVAL
);
3527 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3529 *mask
= bus
->creds_mask
;
3533 _public_
int sd_bus_is_bus_client(sd_bus
*bus
) {
3534 assert_return(bus
, -EINVAL
);
3535 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3537 return bus
->bus_client
;
3540 _public_
int sd_bus_is_server(sd_bus
*bus
) {
3541 assert_return(bus
, -EINVAL
);
3542 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3544 return bus
->is_server
;
3547 _public_
int sd_bus_is_anonymous(sd_bus
*bus
) {
3548 assert_return(bus
, -EINVAL
);
3549 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3551 return bus
->anonymous_auth
;
3554 _public_
int sd_bus_is_trusted(sd_bus
*bus
) {
3555 assert_return(bus
, -EINVAL
);
3556 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3558 return bus
->trusted
;
3561 _public_
int sd_bus_is_monitor(sd_bus
*bus
) {
3562 assert_return(bus
, -EINVAL
);
3563 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3565 return !!(bus
->hello_flags
& KDBUS_HELLO_MONITOR
);