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"
48 #include "bus-container.h"
49 #include "bus-protocol.h"
50 #include "bus-track.h"
53 #define log_debug_bus_message(m) \
55 sd_bus_message *_mm = (m); \
56 log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s", \
57 bus_message_type_to_string(_mm->header->type), \
58 strna(sd_bus_message_get_sender(_mm)), \
59 strna(sd_bus_message_get_destination(_mm)), \
60 strna(sd_bus_message_get_path(_mm)), \
61 strna(sd_bus_message_get_interface(_mm)), \
62 strna(sd_bus_message_get_member(_mm)), \
63 BUS_MESSAGE_COOKIE(_mm), \
65 strna(_mm->error.message)); \
68 static int bus_poll(sd_bus
*bus
, bool need_more
, uint64_t timeout_usec
);
69 static int attach_io_events(sd_bus
*b
);
70 static void detach_io_events(sd_bus
*b
);
72 static void bus_close_fds(sd_bus
*b
) {
77 if (b
->input_fd
!= b
->output_fd
)
78 safe_close(b
->output_fd
);
79 b
->output_fd
= b
->input_fd
= safe_close(b
->input_fd
);
82 static void bus_reset_queues(sd_bus
*b
) {
85 while (b
->rqueue_size
> 0)
86 sd_bus_message_unref(b
->rqueue
[--b
->rqueue_size
]);
88 b
->rqueue
= mfree(b
->rqueue
);
89 b
->rqueue_allocated
= 0;
91 while (b
->wqueue_size
> 0)
92 sd_bus_message_unref(b
->wqueue
[--b
->wqueue_size
]);
94 b
->wqueue
= mfree(b
->wqueue
);
95 b
->wqueue_allocated
= 0;
98 static void bus_free(sd_bus
*b
) {
102 assert(!b
->track_queue
);
104 b
->state
= BUS_CLOSED
;
106 sd_bus_detach_event(b
);
108 while ((s
= b
->slots
)) {
109 /* At this point only floating slots can still be
110 * around, because the non-floating ones keep a
111 * reference to the bus, and we thus couldn't be
112 * destructing right now... We forcibly disconnect the
113 * slots here, so that they still can be referenced by
114 * apps, but are dead. */
117 bus_slot_disconnect(s
);
118 sd_bus_slot_unref(s
);
121 if (b
->default_bus_ptr
)
122 *b
->default_bus_ptr
= NULL
;
127 munmap(b
->kdbus_buffer
, KDBUS_POOL_SIZE
);
131 free(b
->unique_name
);
132 free(b
->auth_buffer
);
137 free(b
->cgroup_root
);
138 free(b
->description
);
141 strv_free(b
->exec_argv
);
143 close_many(b
->fds
, b
->n_fds
);
148 ordered_hashmap_free_free(b
->reply_callbacks
);
149 prioq_free(b
->reply_callbacks_prioq
);
151 assert(b
->match_callbacks
.type
== BUS_MATCH_ROOT
);
152 bus_match_free(&b
->match_callbacks
);
154 hashmap_free_free(b
->vtable_methods
);
155 hashmap_free_free(b
->vtable_properties
);
157 assert(hashmap_isempty(b
->nodes
));
158 hashmap_free(b
->nodes
);
160 bus_kernel_flush_memfd(b
);
162 assert_se(pthread_mutex_destroy(&b
->memfd_cache_mutex
) == 0);
167 _public_
int sd_bus_new(sd_bus
**ret
) {
170 assert_return(ret
, -EINVAL
);
176 r
->n_ref
= REFCNT_INIT
;
177 r
->input_fd
= r
->output_fd
= -1;
178 r
->message_version
= 1;
179 r
->creds_mask
|= SD_BUS_CREDS_WELL_KNOWN_NAMES
|SD_BUS_CREDS_UNIQUE_NAME
;
180 r
->hello_flags
|= KDBUS_HELLO_ACCEPT_FD
;
181 r
->attach_flags
|= KDBUS_ATTACH_NAMES
;
182 r
->original_pid
= getpid();
184 assert_se(pthread_mutex_init(&r
->memfd_cache_mutex
, NULL
) == 0);
186 /* We guarantee that wqueue always has space for at least one
188 if (!GREEDY_REALLOC(r
->wqueue
, r
->wqueue_allocated
, 1)) {
197 _public_
int sd_bus_set_address(sd_bus
*bus
, const char *address
) {
200 assert_return(bus
, -EINVAL
);
201 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
202 assert_return(address
, -EINVAL
);
203 assert_return(!bus_pid_changed(bus
), -ECHILD
);
215 _public_
int sd_bus_set_fd(sd_bus
*bus
, int input_fd
, int output_fd
) {
216 assert_return(bus
, -EINVAL
);
217 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
218 assert_return(input_fd
>= 0, -EBADF
);
219 assert_return(output_fd
>= 0, -EBADF
);
220 assert_return(!bus_pid_changed(bus
), -ECHILD
);
222 bus
->input_fd
= input_fd
;
223 bus
->output_fd
= output_fd
;
227 _public_
int sd_bus_set_exec(sd_bus
*bus
, const char *path
, char *const argv
[]) {
230 assert_return(bus
, -EINVAL
);
231 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
232 assert_return(path
, -EINVAL
);
233 assert_return(!strv_isempty(argv
), -EINVAL
);
234 assert_return(!bus_pid_changed(bus
), -ECHILD
);
246 free(bus
->exec_path
);
247 strv_free(bus
->exec_argv
);
255 _public_
int sd_bus_set_bus_client(sd_bus
*bus
, int b
) {
256 assert_return(bus
, -EINVAL
);
257 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
258 assert_return(!bus_pid_changed(bus
), -ECHILD
);
260 bus
->bus_client
= !!b
;
264 _public_
int sd_bus_set_monitor(sd_bus
*bus
, int b
) {
265 assert_return(bus
, -EINVAL
);
266 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
267 assert_return(!bus_pid_changed(bus
), -ECHILD
);
269 SET_FLAG(bus
->hello_flags
, KDBUS_HELLO_MONITOR
, b
);
273 _public_
int sd_bus_negotiate_fds(sd_bus
*bus
, int b
) {
274 assert_return(bus
, -EINVAL
);
275 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
276 assert_return(!bus_pid_changed(bus
), -ECHILD
);
278 SET_FLAG(bus
->hello_flags
, KDBUS_HELLO_ACCEPT_FD
, b
);
282 _public_
int sd_bus_negotiate_timestamp(sd_bus
*bus
, int b
) {
284 assert_return(bus
, -EINVAL
);
285 assert_return(!IN_SET(bus
->state
, BUS_CLOSING
, BUS_CLOSED
), -EPERM
);
286 assert_return(!bus_pid_changed(bus
), -ECHILD
);
288 new_flags
= bus
->attach_flags
;
289 SET_FLAG(new_flags
, KDBUS_ATTACH_TIMESTAMP
, b
);
291 if (bus
->attach_flags
== new_flags
)
294 bus
->attach_flags
= new_flags
;
295 if (bus
->state
!= BUS_UNSET
&& bus
->is_kernel
)
296 bus_kernel_realize_attach_flags(bus
);
301 _public_
int sd_bus_negotiate_creds(sd_bus
*bus
, int b
, uint64_t mask
) {
304 assert_return(bus
, -EINVAL
);
305 assert_return(mask
<= _SD_BUS_CREDS_ALL
, -EINVAL
);
306 assert_return(!IN_SET(bus
->state
, BUS_CLOSING
, BUS_CLOSED
), -EPERM
);
307 assert_return(!bus_pid_changed(bus
), -ECHILD
);
310 bus
->creds_mask
|= mask
;
312 bus
->creds_mask
&= ~mask
;
314 /* The well knowns we need unconditionally, so that matches can work */
315 bus
->creds_mask
|= SD_BUS_CREDS_WELL_KNOWN_NAMES
|SD_BUS_CREDS_UNIQUE_NAME
;
317 /* Make sure we don't lose the timestamp flag */
318 new_flags
= (bus
->attach_flags
& KDBUS_ATTACH_TIMESTAMP
) | attach_flags_to_kdbus(bus
->creds_mask
);
319 if (bus
->attach_flags
== new_flags
)
322 bus
->attach_flags
= new_flags
;
323 if (bus
->state
!= BUS_UNSET
&& bus
->is_kernel
)
324 bus_kernel_realize_attach_flags(bus
);
329 _public_
int sd_bus_set_server(sd_bus
*bus
, int b
, sd_id128_t server_id
) {
330 assert_return(bus
, -EINVAL
);
331 assert_return(b
|| sd_id128_equal(server_id
, SD_ID128_NULL
), -EINVAL
);
332 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
333 assert_return(!bus_pid_changed(bus
), -ECHILD
);
335 bus
->is_server
= !!b
;
336 bus
->server_id
= server_id
;
340 _public_
int sd_bus_set_anonymous(sd_bus
*bus
, int b
) {
341 assert_return(bus
, -EINVAL
);
342 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
343 assert_return(!bus_pid_changed(bus
), -ECHILD
);
345 bus
->anonymous_auth
= !!b
;
349 _public_
int sd_bus_set_trusted(sd_bus
*bus
, int b
) {
350 assert_return(bus
, -EINVAL
);
351 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
352 assert_return(!bus_pid_changed(bus
), -ECHILD
);
358 _public_
int sd_bus_set_description(sd_bus
*bus
, const char *description
) {
359 assert_return(bus
, -EINVAL
);
360 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
361 assert_return(!bus_pid_changed(bus
), -ECHILD
);
363 return free_and_strdup(&bus
->description
, description
);
366 _public_
int sd_bus_set_allow_interactive_authorization(sd_bus
*bus
, int b
) {
367 assert_return(bus
, -EINVAL
);
368 assert_return(!bus_pid_changed(bus
), -ECHILD
);
370 bus
->allow_interactive_authorization
= !!b
;
374 _public_
int sd_bus_get_allow_interactive_authorization(sd_bus
*bus
) {
375 assert_return(bus
, -EINVAL
);
376 assert_return(!bus_pid_changed(bus
), -ECHILD
);
378 return bus
->allow_interactive_authorization
;
381 static int hello_callback(sd_bus_message
*reply
, void *userdata
, sd_bus_error
*error
) {
389 assert(bus
->state
== BUS_HELLO
|| bus
->state
== BUS_CLOSING
);
391 r
= sd_bus_message_get_errno(reply
);
395 r
= sd_bus_message_read(reply
, "s", &s
);
399 if (!service_name_is_valid(s
) || s
[0] != ':')
402 bus
->unique_name
= strdup(s
);
403 if (!bus
->unique_name
)
406 if (bus
->state
== BUS_HELLO
)
407 bus
->state
= BUS_RUNNING
;
412 static int bus_send_hello(sd_bus
*bus
) {
413 _cleanup_bus_message_unref_ sd_bus_message
*m
= NULL
;
418 if (!bus
->bus_client
|| bus
->is_kernel
)
421 r
= sd_bus_message_new_method_call(
424 "org.freedesktop.DBus",
425 "/org/freedesktop/DBus",
426 "org.freedesktop.DBus",
431 return sd_bus_call_async(bus
, NULL
, m
, hello_callback
, NULL
, 0);
434 int bus_start_running(sd_bus
*bus
) {
437 if (bus
->bus_client
&& !bus
->is_kernel
) {
438 bus
->state
= BUS_HELLO
;
442 bus
->state
= BUS_RUNNING
;
446 static int parse_address_key(const char **p
, const char *key
, char **value
) {
447 size_t l
, n
= 0, allocated
= 0;
457 if (strncmp(*p
, key
, l
) != 0)
470 while (*a
!= ';' && *a
!= ',' && *a
!= 0) {
488 c
= (char) ((x
<< 4) | y
);
495 if (!GREEDY_REALLOC(r
, allocated
, n
+ 2))
519 static void skip_address_key(const char **p
) {
523 *p
+= strcspn(*p
, ",");
529 static int parse_unix_address(sd_bus
*b
, const char **p
, char **guid
) {
530 _cleanup_free_
char *path
= NULL
, *abstract
= NULL
;
539 while (**p
!= 0 && **p
!= ';') {
540 r
= parse_address_key(p
, "guid", guid
);
546 r
= parse_address_key(p
, "path", &path
);
552 r
= parse_address_key(p
, "abstract", &abstract
);
561 if (!path
&& !abstract
)
564 if (path
&& abstract
)
569 if (l
> sizeof(b
->sockaddr
.un
.sun_path
))
572 b
->sockaddr
.un
.sun_family
= AF_UNIX
;
573 strncpy(b
->sockaddr
.un
.sun_path
, path
, sizeof(b
->sockaddr
.un
.sun_path
));
574 b
->sockaddr_size
= offsetof(struct sockaddr_un
, sun_path
) + l
;
575 } else if (abstract
) {
576 l
= strlen(abstract
);
577 if (l
> sizeof(b
->sockaddr
.un
.sun_path
) - 1)
580 b
->sockaddr
.un
.sun_family
= AF_UNIX
;
581 b
->sockaddr
.un
.sun_path
[0] = 0;
582 strncpy(b
->sockaddr
.un
.sun_path
+1, abstract
, sizeof(b
->sockaddr
.un
.sun_path
)-1);
583 b
->sockaddr_size
= offsetof(struct sockaddr_un
, sun_path
) + 1 + l
;
589 static int parse_tcp_address(sd_bus
*b
, const char **p
, char **guid
) {
590 _cleanup_free_
char *host
= NULL
, *port
= NULL
, *family
= NULL
;
592 struct addrinfo
*result
, hints
= {
593 .ai_socktype
= SOCK_STREAM
,
594 .ai_flags
= AI_ADDRCONFIG
,
602 while (**p
!= 0 && **p
!= ';') {
603 r
= parse_address_key(p
, "guid", guid
);
609 r
= parse_address_key(p
, "host", &host
);
615 r
= parse_address_key(p
, "port", &port
);
621 r
= parse_address_key(p
, "family", &family
);
634 if (streq(family
, "ipv4"))
635 hints
.ai_family
= AF_INET
;
636 else if (streq(family
, "ipv6"))
637 hints
.ai_family
= AF_INET6
;
642 r
= getaddrinfo(host
, port
, &hints
, &result
);
646 return -EADDRNOTAVAIL
;
648 memcpy(&b
->sockaddr
, result
->ai_addr
, result
->ai_addrlen
);
649 b
->sockaddr_size
= result
->ai_addrlen
;
651 freeaddrinfo(result
);
656 static int parse_exec_address(sd_bus
*b
, const char **p
, char **guid
) {
658 unsigned n_argv
= 0, j
;
660 size_t allocated
= 0;
668 while (**p
!= 0 && **p
!= ';') {
669 r
= parse_address_key(p
, "guid", guid
);
675 r
= parse_address_key(p
, "path", &path
);
681 if (startswith(*p
, "argv")) {
685 ul
= strtoul(*p
+ 4, (char**) p
, 10);
686 if (errno
> 0 || **p
!= '=' || ul
> 256) {
694 if (!GREEDY_REALLOC0(argv
, allocated
, ul
+ 2)) {
702 r
= parse_address_key(p
, NULL
, argv
+ ul
);
717 /* Make sure there are no holes in the array, with the
718 * exception of argv[0] */
719 for (j
= 1; j
< n_argv
; j
++)
725 if (argv
&& argv
[0] == NULL
) {
726 argv
[0] = strdup(path
);
738 for (j
= 0; j
< n_argv
; j
++)
746 static int parse_kernel_address(sd_bus
*b
, const char **p
, char **guid
) {
747 _cleanup_free_
char *path
= NULL
;
755 while (**p
!= 0 && **p
!= ';') {
756 r
= parse_address_key(p
, "guid", guid
);
762 r
= parse_address_key(p
, "path", &path
);
781 static int parse_container_unix_address(sd_bus
*b
, const char **p
, char **guid
) {
782 _cleanup_free_
char *machine
= NULL
, *pid
= NULL
;
790 while (**p
!= 0 && **p
!= ';') {
791 r
= parse_address_key(p
, "guid", guid
);
797 r
= parse_address_key(p
, "machine", &machine
);
803 r
= parse_address_key(p
, "pid", &pid
);
812 if (!machine
== !pid
)
816 if (!machine_name_is_valid(machine
))
820 b
->machine
= machine
;
828 r
= parse_pid(pid
, &b
->nspid
);
834 b
->sockaddr
.un
.sun_family
= AF_UNIX
;
835 strncpy(b
->sockaddr
.un
.sun_path
, "/var/run/dbus/system_bus_socket", sizeof(b
->sockaddr
.un
.sun_path
));
836 b
->sockaddr_size
= offsetof(struct sockaddr_un
, sun_path
) + strlen("/var/run/dbus/system_bus_socket");
841 static int parse_container_kernel_address(sd_bus
*b
, const char **p
, char **guid
) {
842 _cleanup_free_
char *machine
= NULL
, *pid
= NULL
;
850 while (**p
!= 0 && **p
!= ';') {
851 r
= parse_address_key(p
, "guid", guid
);
857 r
= parse_address_key(p
, "machine", &machine
);
863 r
= parse_address_key(p
, "pid", &pid
);
872 if (!machine
== !pid
)
876 if (!machine_name_is_valid(machine
))
880 b
->machine
= machine
;
888 r
= parse_pid(pid
, &b
->nspid
);
894 r
= free_and_strdup(&b
->kernel
, "/sys/fs/kdbus/0-system/bus");
901 static void bus_reset_parsed_address(sd_bus
*b
) {
905 b
->sockaddr_size
= 0;
906 b
->exec_argv
= strv_free(b
->exec_argv
);
907 b
->exec_path
= mfree(b
->exec_path
);
908 b
->server_id
= SD_ID128_NULL
;
909 b
->kernel
= mfree(b
->kernel
);
910 b
->machine
= mfree(b
->machine
);
914 static int bus_parse_next_address(sd_bus
*b
) {
915 _cleanup_free_
char *guid
= NULL
;
923 if (b
->address
[b
->address_index
] == 0)
926 bus_reset_parsed_address(b
);
928 a
= b
->address
+ b
->address_index
;
937 if (startswith(a
, "unix:")) {
940 r
= parse_unix_address(b
, &a
, &guid
);
945 } else if (startswith(a
, "tcp:")) {
948 r
= parse_tcp_address(b
, &a
, &guid
);
954 } else if (startswith(a
, "unixexec:")) {
957 r
= parse_exec_address(b
, &a
, &guid
);
963 } else if (startswith(a
, "kernel:")) {
966 r
= parse_kernel_address(b
, &a
, &guid
);
971 } else if (startswith(a
, "x-machine-unix:")) {
974 r
= parse_container_unix_address(b
, &a
, &guid
);
979 } else if (startswith(a
, "x-machine-kernel:")) {
982 r
= parse_container_kernel_address(b
, &a
, &guid
);
995 r
= sd_id128_from_string(guid
, &b
->server_id
);
1000 b
->address_index
= a
- b
->address
;
1004 static int bus_start_address(sd_bus
*b
) {
1005 bool container_kdbus_available
= false;
1006 bool kdbus_available
= false;
1012 bool skipped
= false;
1017 * Usually, if you provide multiple different bus-addresses, we
1018 * try all of them in order. We use the first one that
1019 * succeeds. However, if you mix kernel and unix addresses, we
1020 * never try unix-addresses if a previous kernel address was
1021 * tried and kdbus was available. This is required to prevent
1022 * clients to fallback to the bus-proxy if kdbus is available
1023 * but failed (eg., too many connections).
1027 r
= bus_socket_exec(b
);
1029 else if ((b
->nspid
> 0 || b
->machine
) && b
->kernel
) {
1030 r
= bus_container_connect_kernel(b
);
1031 if (r
< 0 && !IN_SET(r
, -ENOENT
, -ESOCKTNOSUPPORT
))
1032 container_kdbus_available
= true;
1034 } else if ((b
->nspid
> 0 || b
->machine
) && b
->sockaddr
.sa
.sa_family
!= AF_UNSPEC
) {
1035 if (!container_kdbus_available
)
1036 r
= bus_container_connect_socket(b
);
1040 } else if (b
->kernel
) {
1041 r
= bus_kernel_connect(b
);
1042 if (r
< 0 && !IN_SET(r
, -ENOENT
, -ESOCKTNOSUPPORT
))
1043 kdbus_available
= true;
1045 } else if (b
->sockaddr
.sa
.sa_family
!= AF_UNSPEC
) {
1046 if (!kdbus_available
)
1047 r
= bus_socket_connect(b
);
1056 r
= attach_io_events(b
);
1061 b
->last_connect_error
= -r
;
1064 r
= bus_parse_next_address(b
);
1068 return b
->last_connect_error
? -b
->last_connect_error
: -ECONNREFUSED
;
1072 int bus_next_address(sd_bus
*b
) {
1075 bus_reset_parsed_address(b
);
1076 return bus_start_address(b
);
1079 static int bus_start_fd(sd_bus
*b
) {
1084 assert(b
->input_fd
>= 0);
1085 assert(b
->output_fd
>= 0);
1087 r
= fd_nonblock(b
->input_fd
, true);
1091 r
= fd_cloexec(b
->input_fd
, true);
1095 if (b
->input_fd
!= b
->output_fd
) {
1096 r
= fd_nonblock(b
->output_fd
, true);
1100 r
= fd_cloexec(b
->output_fd
, true);
1105 if (fstat(b
->input_fd
, &st
) < 0)
1108 if (S_ISCHR(b
->input_fd
))
1109 return bus_kernel_take_fd(b
);
1111 return bus_socket_take_fd(b
);
1114 _public_
int sd_bus_start(sd_bus
*bus
) {
1117 assert_return(bus
, -EINVAL
);
1118 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
1119 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1121 bus
->state
= BUS_OPENING
;
1123 if (bus
->is_server
&& bus
->bus_client
)
1126 if (bus
->input_fd
>= 0)
1127 r
= bus_start_fd(bus
);
1128 else if (bus
->address
|| bus
->sockaddr
.sa
.sa_family
!= AF_UNSPEC
|| bus
->exec_path
|| bus
->kernel
|| bus
->machine
)
1129 r
= bus_start_address(bus
);
1138 return bus_send_hello(bus
);
1141 _public_
int sd_bus_open(sd_bus
**ret
) {
1146 assert_return(ret
, -EINVAL
);
1148 /* Let's connect to the starter bus if it is set, and
1149 * otherwise to the bus that is appropropriate for the scope
1150 * we are running in */
1152 e
= secure_getenv("DBUS_STARTER_BUS_TYPE");
1154 if (streq(e
, "system"))
1155 return sd_bus_open_system(ret
);
1156 else if (STR_IN_SET(e
, "session", "user"))
1157 return sd_bus_open_user(ret
);
1160 e
= secure_getenv("DBUS_STARTER_ADDRESS");
1162 if (cg_pid_get_owner_uid(0, NULL
) >= 0)
1163 return sd_bus_open_user(ret
);
1165 return sd_bus_open_system(ret
);
1172 r
= sd_bus_set_address(b
, e
);
1176 b
->bus_client
= true;
1178 /* We don't know whether the bus is trusted or not, so better
1179 * be safe, and authenticate everything */
1181 b
->attach_flags
|= KDBUS_ATTACH_CAPS
| KDBUS_ATTACH_CREDS
;
1182 b
->creds_mask
|= SD_BUS_CREDS_UID
| SD_BUS_CREDS_EUID
| SD_BUS_CREDS_EFFECTIVE_CAPS
;
1184 r
= sd_bus_start(b
);
1196 int bus_set_address_system(sd_bus
*b
) {
1200 e
= secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1202 return sd_bus_set_address(b
, e
);
1204 return sd_bus_set_address(b
, DEFAULT_SYSTEM_BUS_ADDRESS
);
1207 _public_
int sd_bus_open_system(sd_bus
**ret
) {
1211 assert_return(ret
, -EINVAL
);
1217 r
= bus_set_address_system(b
);
1221 b
->bus_client
= true;
1222 b
->is_system
= true;
1224 /* Let's do per-method access control on the system bus. We
1225 * need the caller's UID and capability set for that. */
1227 b
->attach_flags
|= KDBUS_ATTACH_CAPS
| KDBUS_ATTACH_CREDS
;
1228 b
->creds_mask
|= SD_BUS_CREDS_UID
| SD_BUS_CREDS_EUID
| SD_BUS_CREDS_EFFECTIVE_CAPS
;
1230 r
= sd_bus_start(b
);
1242 int bus_set_address_user(sd_bus
*b
) {
1247 e
= secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1249 return sd_bus_set_address(b
, e
);
1251 e
= secure_getenv("XDG_RUNTIME_DIR");
1253 _cleanup_free_
char *ee
= NULL
;
1255 ee
= bus_address_escape(e
);
1259 (void) asprintf(&b
->address
, KERNEL_USER_BUS_ADDRESS_FMT
";" UNIX_USER_BUS_ADDRESS_FMT
, getuid(), ee
);
1261 (void) asprintf(&b
->address
, KERNEL_USER_BUS_ADDRESS_FMT
, getuid());
1269 _public_
int sd_bus_open_user(sd_bus
**ret
) {
1273 assert_return(ret
, -EINVAL
);
1279 r
= bus_set_address_user(b
);
1283 b
->bus_client
= true;
1286 /* We don't do any per-method access control on the user
1290 r
= sd_bus_start(b
);
1302 int bus_set_address_system_remote(sd_bus
*b
, const char *host
) {
1303 _cleanup_free_
char *e
= NULL
;
1304 char *m
= NULL
, *c
= NULL
;
1309 /* Let's see if we shall enter some container */
1310 m
= strchr(host
, ':');
1314 /* Let's make sure this is not a port of some kind,
1315 * and is a valid machine name. */
1316 if (!in_charset(m
, "0123456789") && machine_name_is_valid(m
)) {
1319 /* Cut out the host part */
1320 t
= strndupa(host
, m
- host
- 1);
1321 e
= bus_address_escape(t
);
1325 c
= strjoina(",argv4=--machine=", m
);
1330 e
= bus_address_escape(host
);
1335 b
->address
= strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e
, ",argv3=systemd-stdio-bridge", c
, NULL
);
1342 _public_
int sd_bus_open_system_remote(sd_bus
**ret
, const char *host
) {
1346 assert_return(host
, -EINVAL
);
1347 assert_return(ret
, -EINVAL
);
1349 r
= sd_bus_new(&bus
);
1353 r
= bus_set_address_system_remote(bus
, host
);
1357 bus
->bus_client
= true;
1358 bus
->trusted
= false;
1359 bus
->is_system
= true;
1361 r
= sd_bus_start(bus
);
1373 int bus_set_address_system_machine(sd_bus
*b
, const char *machine
) {
1374 _cleanup_free_
char *e
= NULL
;
1379 e
= bus_address_escape(machine
);
1383 b
->address
= strjoin("x-machine-kernel:machine=", e
, ";x-machine-unix:machine=", e
, NULL
);
1390 _public_
int sd_bus_open_system_machine(sd_bus
**ret
, const char *machine
) {
1394 assert_return(machine
, -EINVAL
);
1395 assert_return(ret
, -EINVAL
);
1396 assert_return(machine_name_is_valid(machine
), -EINVAL
);
1398 r
= sd_bus_new(&bus
);
1402 r
= bus_set_address_system_machine(bus
, machine
);
1406 bus
->bus_client
= true;
1407 bus
->trusted
= false;
1408 bus
->is_system
= true;
1410 r
= sd_bus_start(bus
);
1422 _public_
void sd_bus_close(sd_bus
*bus
) {
1426 if (bus
->state
== BUS_CLOSED
)
1428 if (bus_pid_changed(bus
))
1431 bus
->state
= BUS_CLOSED
;
1433 sd_bus_detach_event(bus
);
1435 /* Drop all queued messages so that they drop references to
1436 * the bus object and the bus may be freed */
1437 bus_reset_queues(bus
);
1439 if (!bus
->is_kernel
)
1442 /* We'll leave the fd open in case this is a kernel bus, since
1443 * there might still be memblocks around that reference this
1444 * bus, and they might need to invoke the KDBUS_CMD_FREE
1445 * ioctl on the fd when they are freed. */
1448 _public_ sd_bus
* sd_bus_flush_close_unref(sd_bus
*bus
) {
1456 return sd_bus_unref(bus
);
1459 static void bus_enter_closing(sd_bus
*bus
) {
1462 if (bus
->state
!= BUS_OPENING
&&
1463 bus
->state
!= BUS_AUTHENTICATING
&&
1464 bus
->state
!= BUS_HELLO
&&
1465 bus
->state
!= BUS_RUNNING
)
1468 bus
->state
= BUS_CLOSING
;
1471 _public_ sd_bus
*sd_bus_ref(sd_bus
*bus
) {
1472 assert_return(bus
, NULL
);
1474 assert_se(REFCNT_INC(bus
->n_ref
) >= 2);
1479 _public_ sd_bus
*sd_bus_unref(sd_bus
*bus
) {
1485 i
= REFCNT_DEC(bus
->n_ref
);
1493 _public_
int sd_bus_is_open(sd_bus
*bus
) {
1495 assert_return(bus
, -EINVAL
);
1496 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1498 return BUS_IS_OPEN(bus
->state
);
1501 _public_
int sd_bus_can_send(sd_bus
*bus
, char type
) {
1504 assert_return(bus
, -EINVAL
);
1505 assert_return(bus
->state
!= BUS_UNSET
, -ENOTCONN
);
1506 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1508 if (bus
->hello_flags
& KDBUS_HELLO_MONITOR
)
1511 if (type
== SD_BUS_TYPE_UNIX_FD
) {
1512 if (!(bus
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
))
1515 r
= bus_ensure_running(bus
);
1519 return bus
->can_fds
;
1522 return bus_type_is_valid(type
);
1525 _public_
int sd_bus_get_bus_id(sd_bus
*bus
, sd_id128_t
*id
) {
1528 assert_return(bus
, -EINVAL
);
1529 assert_return(id
, -EINVAL
);
1530 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1532 r
= bus_ensure_running(bus
);
1536 *id
= bus
->server_id
;
1540 static int bus_seal_message(sd_bus
*b
, sd_bus_message
*m
, usec_t timeout
) {
1545 /* If we copy the same message to multiple
1546 * destinations, avoid using the same cookie
1548 b
->cookie
= MAX(b
->cookie
, BUS_MESSAGE_COOKIE(m
));
1553 timeout
= BUS_DEFAULT_TIMEOUT
;
1555 return bus_message_seal(m
, ++b
->cookie
, timeout
);
1558 static int bus_remarshal_message(sd_bus
*b
, sd_bus_message
**m
) {
1559 bool remarshal
= false;
1563 /* wrong packet version */
1564 if (b
->message_version
!= 0 && b
->message_version
!= (*m
)->header
->version
)
1567 /* wrong packet endianness */
1568 if (b
->message_endian
!= 0 && b
->message_endian
!= (*m
)->header
->endian
)
1571 /* TODO: kdbus-messages received from the kernel contain data which is
1572 * not allowed to be passed to KDBUS_CMD_SEND. Therefore, we have to
1573 * force remarshaling of the message. Technically, we could just
1574 * recreate the kdbus message, but that is non-trivial as other parts of
1575 * the message refer to m->kdbus already. This should be fixed! */
1576 if ((*m
)->kdbus
&& (*m
)->release_kdbus
)
1579 return remarshal
? bus_message_remarshal(b
, m
) : 0;
1582 int bus_seal_synthetic_message(sd_bus
*b
, sd_bus_message
*m
) {
1586 /* Fake some timestamps, if they were requested, and not
1587 * already initialized */
1588 if (b
->attach_flags
& KDBUS_ATTACH_TIMESTAMP
) {
1589 if (m
->realtime
<= 0)
1590 m
->realtime
= now(CLOCK_REALTIME
);
1592 if (m
->monotonic
<= 0)
1593 m
->monotonic
= now(CLOCK_MONOTONIC
);
1596 /* The bus specification says the serial number cannot be 0,
1597 * hence let's fill something in for synthetic messages. Since
1598 * synthetic messages might have a fake sender and we don't
1599 * want to interfere with the real sender's serial numbers we
1600 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1601 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1602 * even though kdbus can do 64bit. */
1603 return bus_message_seal(m
, 0xFFFFFFFFULL
, 0);
1606 static int bus_write_message(sd_bus
*bus
, sd_bus_message
*m
, bool hint_sync_call
, size_t *idx
) {
1613 r
= bus_kernel_write_message(bus
, m
, hint_sync_call
);
1615 r
= bus_socket_write_message(bus
, m
, idx
);
1620 if (bus
->is_kernel
|| *idx
>= BUS_MESSAGE_SIZE(m
))
1621 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64
" reply_cookie=%" PRIu64
" error=%s",
1622 bus_message_type_to_string(m
->header
->type
),
1623 strna(sd_bus_message_get_sender(m
)),
1624 strna(sd_bus_message_get_destination(m
)),
1625 strna(sd_bus_message_get_path(m
)),
1626 strna(sd_bus_message_get_interface(m
)),
1627 strna(sd_bus_message_get_member(m
)),
1628 BUS_MESSAGE_COOKIE(m
),
1630 strna(m
->error
.message
));
1635 static int dispatch_wqueue(sd_bus
*bus
) {
1639 assert(bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
);
1641 while (bus
->wqueue_size
> 0) {
1643 r
= bus_write_message(bus
, bus
->wqueue
[0], false, &bus
->windex
);
1647 /* Didn't do anything this time */
1649 else if (bus
->is_kernel
|| bus
->windex
>= BUS_MESSAGE_SIZE(bus
->wqueue
[0])) {
1650 /* Fully written. Let's drop the entry from
1653 * This isn't particularly optimized, but
1654 * well, this is supposed to be our worst-case
1655 * buffer only, and the socket buffer is
1656 * supposed to be our primary buffer, and if
1657 * it got full, then all bets are off
1660 bus
->wqueue_size
--;
1661 sd_bus_message_unref(bus
->wqueue
[0]);
1662 memmove(bus
->wqueue
, bus
->wqueue
+ 1, sizeof(sd_bus_message
*) * bus
->wqueue_size
);
1672 static int bus_read_message(sd_bus
*bus
, bool hint_priority
, int64_t priority
) {
1676 return bus_kernel_read_message(bus
, hint_priority
, priority
);
1678 return bus_socket_read_message(bus
);
1681 int bus_rqueue_make_room(sd_bus
*bus
) {
1684 if (bus
->rqueue_size
>= BUS_RQUEUE_MAX
)
1687 if (!GREEDY_REALLOC(bus
->rqueue
, bus
->rqueue_allocated
, bus
->rqueue_size
+ 1))
1693 static int dispatch_rqueue(sd_bus
*bus
, bool hint_priority
, int64_t priority
, sd_bus_message
**m
) {
1698 assert(bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
);
1700 /* Note that the priority logic is only available on kdbus,
1701 * where the rqueue is unused. We check the rqueue here
1702 * anyway, because it's simple... */
1705 if (bus
->rqueue_size
> 0) {
1706 /* Dispatch a queued message */
1708 *m
= bus
->rqueue
[0];
1709 bus
->rqueue_size
--;
1710 memmove(bus
->rqueue
, bus
->rqueue
+ 1, sizeof(sd_bus_message
*) * bus
->rqueue_size
);
1714 /* Try to read a new message */
1715 r
= bus_read_message(bus
, hint_priority
, priority
);
1725 static int bus_send_internal(sd_bus
*bus
, sd_bus_message
*_m
, uint64_t *cookie
, bool hint_sync_call
) {
1726 _cleanup_bus_message_unref_ sd_bus_message
*m
= sd_bus_message_ref(_m
);
1729 assert_return(m
, -EINVAL
);
1734 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1735 assert_return(!bus
->is_kernel
|| !(bus
->hello_flags
& KDBUS_HELLO_MONITOR
), -EROFS
);
1737 if (!BUS_IS_OPEN(bus
->state
))
1741 r
= sd_bus_can_send(bus
, SD_BUS_TYPE_UNIX_FD
);
1748 /* If the cookie number isn't kept, then we know that no reply
1750 if (!cookie
&& !m
->sealed
)
1751 m
->header
->flags
|= BUS_MESSAGE_NO_REPLY_EXPECTED
;
1753 r
= bus_seal_message(bus
, m
, 0);
1757 /* Remarshall if we have to. This will possibly unref the
1758 * message and place a replacement in m */
1759 r
= bus_remarshal_message(bus
, &m
);
1763 /* If this is a reply and no reply was requested, then let's
1764 * suppress this, if we can */
1768 if ((bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
) && bus
->wqueue_size
<= 0) {
1771 r
= bus_write_message(bus
, m
, hint_sync_call
, &idx
);
1773 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
1774 bus_enter_closing(bus
);
1781 if (!bus
->is_kernel
&& idx
< BUS_MESSAGE_SIZE(m
)) {
1782 /* Wasn't fully written. So let's remember how
1783 * much was written. Note that the first entry
1784 * of the wqueue array is always allocated so
1785 * that we always can remember how much was
1787 bus
->wqueue
[0] = sd_bus_message_ref(m
);
1788 bus
->wqueue_size
= 1;
1793 /* Just append it to the queue. */
1795 if (bus
->wqueue_size
>= BUS_WQUEUE_MAX
)
1798 if (!GREEDY_REALLOC(bus
->wqueue
, bus
->wqueue_allocated
, bus
->wqueue_size
+ 1))
1801 bus
->wqueue
[bus
->wqueue_size
++] = sd_bus_message_ref(m
);
1806 *cookie
= BUS_MESSAGE_COOKIE(m
);
1811 _public_
int sd_bus_send(sd_bus
*bus
, sd_bus_message
*m
, uint64_t *cookie
) {
1812 return bus_send_internal(bus
, m
, cookie
, false);
1815 _public_
int sd_bus_send_to(sd_bus
*bus
, sd_bus_message
*m
, const char *destination
, uint64_t *cookie
) {
1818 assert_return(m
, -EINVAL
);
1823 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1825 if (!BUS_IS_OPEN(bus
->state
))
1828 if (!streq_ptr(m
->destination
, destination
)) {
1833 r
= sd_bus_message_set_destination(m
, destination
);
1838 return sd_bus_send(bus
, m
, cookie
);
1841 static usec_t
calc_elapse(uint64_t usec
) {
1842 if (usec
== (uint64_t) -1)
1845 return now(CLOCK_MONOTONIC
) + usec
;
1848 static int timeout_compare(const void *a
, const void *b
) {
1849 const struct reply_callback
*x
= a
, *y
= b
;
1851 if (x
->timeout
!= 0 && y
->timeout
== 0)
1854 if (x
->timeout
== 0 && y
->timeout
!= 0)
1857 if (x
->timeout
< y
->timeout
)
1860 if (x
->timeout
> y
->timeout
)
1866 _public_
int sd_bus_call_async(
1870 sd_bus_message_handler_t callback
,
1874 _cleanup_bus_message_unref_ sd_bus_message
*m
= sd_bus_message_ref(_m
);
1875 _cleanup_bus_slot_unref_ sd_bus_slot
*s
= NULL
;
1878 assert_return(m
, -EINVAL
);
1879 assert_return(m
->header
->type
== SD_BUS_MESSAGE_METHOD_CALL
, -EINVAL
);
1880 assert_return(!(m
->header
->flags
& BUS_MESSAGE_NO_REPLY_EXPECTED
), -EINVAL
);
1881 assert_return(callback
, -EINVAL
);
1886 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1887 assert_return(!bus
->is_kernel
|| !(bus
->hello_flags
& KDBUS_HELLO_MONITOR
), -EROFS
);
1889 if (!BUS_IS_OPEN(bus
->state
))
1892 r
= ordered_hashmap_ensure_allocated(&bus
->reply_callbacks
, &uint64_hash_ops
);
1896 r
= prioq_ensure_allocated(&bus
->reply_callbacks_prioq
, timeout_compare
);
1900 r
= bus_seal_message(bus
, m
, usec
);
1904 r
= bus_remarshal_message(bus
, &m
);
1908 s
= bus_slot_allocate(bus
, !slot
, BUS_REPLY_CALLBACK
, sizeof(struct reply_callback
), userdata
);
1912 s
->reply_callback
.callback
= callback
;
1914 s
->reply_callback
.cookie
= BUS_MESSAGE_COOKIE(m
);
1915 r
= ordered_hashmap_put(bus
->reply_callbacks
, &s
->reply_callback
.cookie
, &s
->reply_callback
);
1917 s
->reply_callback
.cookie
= 0;
1921 s
->reply_callback
.timeout
= calc_elapse(m
->timeout
);
1922 if (s
->reply_callback
.timeout
!= 0) {
1923 r
= prioq_put(bus
->reply_callbacks_prioq
, &s
->reply_callback
, &s
->reply_callback
.prioq_idx
);
1925 s
->reply_callback
.timeout
= 0;
1930 r
= sd_bus_send(bus
, m
, &s
->reply_callback
.cookie
);
1941 int bus_ensure_running(sd_bus
*bus
) {
1946 if (bus
->state
== BUS_UNSET
|| bus
->state
== BUS_CLOSED
|| bus
->state
== BUS_CLOSING
)
1948 if (bus
->state
== BUS_RUNNING
)
1952 r
= sd_bus_process(bus
, NULL
);
1955 if (bus
->state
== BUS_RUNNING
)
1960 r
= sd_bus_wait(bus
, (uint64_t) -1);
1966 _public_
int sd_bus_call(
1970 sd_bus_error
*error
,
1971 sd_bus_message
**reply
) {
1973 _cleanup_bus_message_unref_ sd_bus_message
*m
= sd_bus_message_ref(_m
);
1979 bus_assert_return(m
, -EINVAL
, error
);
1980 bus_assert_return(m
->header
->type
== SD_BUS_MESSAGE_METHOD_CALL
, -EINVAL
, error
);
1981 bus_assert_return(!(m
->header
->flags
& BUS_MESSAGE_NO_REPLY_EXPECTED
), -EINVAL
, error
);
1982 bus_assert_return(!bus_error_is_dirty(error
), -EINVAL
, error
);
1987 bus_assert_return(!bus_pid_changed(bus
), -ECHILD
, error
);
1988 bus_assert_return(!bus
->is_kernel
|| !(bus
->hello_flags
& KDBUS_HELLO_MONITOR
), -EROFS
, error
);
1990 if (!BUS_IS_OPEN(bus
->state
)) {
1995 r
= bus_ensure_running(bus
);
1999 i
= bus
->rqueue_size
;
2001 r
= bus_seal_message(bus
, m
, usec
);
2005 r
= bus_remarshal_message(bus
, &m
);
2009 r
= bus_send_internal(bus
, m
, &cookie
, true);
2013 timeout
= calc_elapse(m
->timeout
);
2018 while (i
< bus
->rqueue_size
) {
2019 sd_bus_message
*incoming
= NULL
;
2021 incoming
= bus
->rqueue
[i
];
2023 if (incoming
->reply_cookie
== cookie
) {
2024 /* Found a match! */
2026 memmove(bus
->rqueue
+ i
, bus
->rqueue
+ i
+ 1, sizeof(sd_bus_message
*) * (bus
->rqueue_size
- i
- 1));
2028 log_debug_bus_message(incoming
);
2030 if (incoming
->header
->type
== SD_BUS_MESSAGE_METHOD_RETURN
) {
2032 if (incoming
->n_fds
<= 0 || (bus
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
)) {
2036 sd_bus_message_unref(incoming
);
2041 r
= sd_bus_error_setf(error
, SD_BUS_ERROR_INCONSISTENT_MESSAGE
, "Reply message contained file descriptors which I couldn't accept. Sorry.");
2042 sd_bus_message_unref(incoming
);
2045 } else if (incoming
->header
->type
== SD_BUS_MESSAGE_METHOD_ERROR
) {
2046 r
= sd_bus_error_copy(error
, &incoming
->error
);
2047 sd_bus_message_unref(incoming
);
2054 } else if (BUS_MESSAGE_COOKIE(incoming
) == cookie
&&
2057 streq(bus
->unique_name
, incoming
->sender
)) {
2059 memmove(bus
->rqueue
+ i
, bus
->rqueue
+ i
+ 1, sizeof(sd_bus_message
*) * (bus
->rqueue_size
- i
- 1));
2062 /* Our own message? Somebody is trying
2063 * to send its own client a message,
2064 * let's not dead-lock, let's fail
2067 sd_bus_message_unref(incoming
);
2072 /* Try to read more, right-away */
2076 r
= bus_read_message(bus
, false, 0);
2078 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2079 bus_enter_closing(bus
);
2091 n
= now(CLOCK_MONOTONIC
);
2099 left
= (uint64_t) -1;
2101 r
= bus_poll(bus
, true, left
);
2109 r
= dispatch_wqueue(bus
);
2111 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2112 bus_enter_closing(bus
);
2121 return sd_bus_error_set_errno(error
, r
);
2124 _public_
int sd_bus_get_fd(sd_bus
*bus
) {
2126 assert_return(bus
, -EINVAL
);
2127 assert_return(bus
->input_fd
== bus
->output_fd
, -EPERM
);
2128 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2130 return bus
->input_fd
;
2133 _public_
int sd_bus_get_events(sd_bus
*bus
) {
2136 assert_return(bus
, -EINVAL
);
2137 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2139 if (!BUS_IS_OPEN(bus
->state
) && bus
->state
!= BUS_CLOSING
)
2142 if (bus
->state
== BUS_OPENING
)
2144 else if (bus
->state
== BUS_AUTHENTICATING
) {
2146 if (bus_socket_auth_needs_write(bus
))
2151 } else if (bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
) {
2152 if (bus
->rqueue_size
<= 0)
2154 if (bus
->wqueue_size
> 0)
2161 _public_
int sd_bus_get_timeout(sd_bus
*bus
, uint64_t *timeout_usec
) {
2162 struct reply_callback
*c
;
2164 assert_return(bus
, -EINVAL
);
2165 assert_return(timeout_usec
, -EINVAL
);
2166 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2168 if (!BUS_IS_OPEN(bus
->state
) && bus
->state
!= BUS_CLOSING
)
2171 if (bus
->track_queue
) {
2176 if (bus
->state
== BUS_CLOSING
) {
2181 if (bus
->state
== BUS_AUTHENTICATING
) {
2182 *timeout_usec
= bus
->auth_timeout
;
2186 if (bus
->state
!= BUS_RUNNING
&& bus
->state
!= BUS_HELLO
) {
2187 *timeout_usec
= (uint64_t) -1;
2191 if (bus
->rqueue_size
> 0) {
2196 c
= prioq_peek(bus
->reply_callbacks_prioq
);
2198 *timeout_usec
= (uint64_t) -1;
2202 if (c
->timeout
== 0) {
2203 *timeout_usec
= (uint64_t) -1;
2207 *timeout_usec
= c
->timeout
;
2211 static int process_timeout(sd_bus
*bus
) {
2212 _cleanup_bus_error_free_ sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2213 _cleanup_bus_message_unref_ sd_bus_message
* m
= NULL
;
2214 struct reply_callback
*c
;
2221 c
= prioq_peek(bus
->reply_callbacks_prioq
);
2225 n
= now(CLOCK_MONOTONIC
);
2229 r
= bus_message_new_synthetic_error(
2232 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY
, "Method call timed out"),
2237 r
= bus_seal_synthetic_message(bus
, m
);
2241 assert_se(prioq_pop(bus
->reply_callbacks_prioq
) == c
);
2244 ordered_hashmap_remove(bus
->reply_callbacks
, &c
->cookie
);
2247 slot
= container_of(c
, sd_bus_slot
, reply_callback
);
2249 bus
->iteration_counter
++;
2251 bus
->current_message
= m
;
2252 bus
->current_slot
= sd_bus_slot_ref(slot
);
2253 bus
->current_handler
= c
->callback
;
2254 bus
->current_userdata
= slot
->userdata
;
2255 r
= c
->callback(m
, slot
->userdata
, &error_buffer
);
2256 bus
->current_userdata
= NULL
;
2257 bus
->current_handler
= NULL
;
2258 bus
->current_slot
= NULL
;
2259 bus
->current_message
= NULL
;
2261 if (slot
->floating
) {
2262 bus_slot_disconnect(slot
);
2263 sd_bus_slot_unref(slot
);
2266 sd_bus_slot_unref(slot
);
2268 return bus_maybe_reply_error(m
, r
, &error_buffer
);
2271 static int process_hello(sd_bus
*bus
, sd_bus_message
*m
) {
2275 if (bus
->state
!= BUS_HELLO
)
2278 /* Let's make sure the first message on the bus is the HELLO
2279 * reply. But note that we don't actually parse the message
2280 * here (we leave that to the usual handling), we just verify
2281 * we don't let any earlier msg through. */
2283 if (m
->header
->type
!= SD_BUS_MESSAGE_METHOD_RETURN
&&
2284 m
->header
->type
!= SD_BUS_MESSAGE_METHOD_ERROR
)
2287 if (m
->reply_cookie
!= 1)
2293 static int process_reply(sd_bus
*bus
, sd_bus_message
*m
) {
2294 _cleanup_bus_message_unref_ sd_bus_message
*synthetic_reply
= NULL
;
2295 _cleanup_bus_error_free_ sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2296 struct reply_callback
*c
;
2303 if (m
->header
->type
!= SD_BUS_MESSAGE_METHOD_RETURN
&&
2304 m
->header
->type
!= SD_BUS_MESSAGE_METHOD_ERROR
)
2307 if (bus
->is_kernel
&& (bus
->hello_flags
& KDBUS_HELLO_MONITOR
))
2310 if (m
->destination
&& bus
->unique_name
&& !streq_ptr(m
->destination
, bus
->unique_name
))
2313 c
= ordered_hashmap_remove(bus
->reply_callbacks
, &m
->reply_cookie
);
2319 slot
= container_of(c
, sd_bus_slot
, reply_callback
);
2321 if (m
->n_fds
> 0 && !(bus
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
)) {
2323 /* If the reply contained a file descriptor which we
2324 * didn't want we pass an error instead. */
2326 r
= bus_message_new_synthetic_error(
2329 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE
, "Reply message contained file descriptor"),
2334 /* Copy over original timestamp */
2335 synthetic_reply
->realtime
= m
->realtime
;
2336 synthetic_reply
->monotonic
= m
->monotonic
;
2337 synthetic_reply
->seqnum
= m
->seqnum
;
2339 r
= bus_seal_synthetic_message(bus
, synthetic_reply
);
2343 m
= synthetic_reply
;
2345 r
= sd_bus_message_rewind(m
, true);
2350 if (c
->timeout
!= 0) {
2351 prioq_remove(bus
->reply_callbacks_prioq
, c
, &c
->prioq_idx
);
2355 bus
->current_slot
= sd_bus_slot_ref(slot
);
2356 bus
->current_handler
= c
->callback
;
2357 bus
->current_userdata
= slot
->userdata
;
2358 r
= c
->callback(m
, slot
->userdata
, &error_buffer
);
2359 bus
->current_userdata
= NULL
;
2360 bus
->current_handler
= NULL
;
2361 bus
->current_slot
= NULL
;
2363 if (slot
->floating
) {
2364 bus_slot_disconnect(slot
);
2365 sd_bus_slot_unref(slot
);
2368 sd_bus_slot_unref(slot
);
2370 return bus_maybe_reply_error(m
, r
, &error_buffer
);
2373 static int process_filter(sd_bus
*bus
, sd_bus_message
*m
) {
2374 _cleanup_bus_error_free_ sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2375 struct filter_callback
*l
;
2382 bus
->filter_callbacks_modified
= false;
2384 LIST_FOREACH(callbacks
, l
, bus
->filter_callbacks
) {
2387 if (bus
->filter_callbacks_modified
)
2390 /* Don't run this more than once per iteration */
2391 if (l
->last_iteration
== bus
->iteration_counter
)
2394 l
->last_iteration
= bus
->iteration_counter
;
2396 r
= sd_bus_message_rewind(m
, true);
2400 slot
= container_of(l
, sd_bus_slot
, filter_callback
);
2402 bus
->current_slot
= sd_bus_slot_ref(slot
);
2403 bus
->current_handler
= l
->callback
;
2404 bus
->current_userdata
= slot
->userdata
;
2405 r
= l
->callback(m
, slot
->userdata
, &error_buffer
);
2406 bus
->current_userdata
= NULL
;
2407 bus
->current_handler
= NULL
;
2408 bus
->current_slot
= sd_bus_slot_unref(slot
);
2410 r
= bus_maybe_reply_error(m
, r
, &error_buffer
);
2416 } while (bus
->filter_callbacks_modified
);
2421 static int process_match(sd_bus
*bus
, sd_bus_message
*m
) {
2428 bus
->match_callbacks_modified
= false;
2430 r
= bus_match_run(bus
, &bus
->match_callbacks
, m
);
2434 } while (bus
->match_callbacks_modified
);
2439 static int process_builtin(sd_bus
*bus
, sd_bus_message
*m
) {
2440 _cleanup_bus_message_unref_ sd_bus_message
*reply
= NULL
;
2446 if (bus
->hello_flags
& KDBUS_HELLO_MONITOR
)
2449 if (bus
->manual_peer_interface
)
2452 if (m
->header
->type
!= SD_BUS_MESSAGE_METHOD_CALL
)
2455 if (!streq_ptr(m
->interface
, "org.freedesktop.DBus.Peer"))
2458 if (m
->header
->flags
& BUS_MESSAGE_NO_REPLY_EXPECTED
)
2461 if (streq_ptr(m
->member
, "Ping"))
2462 r
= sd_bus_message_new_method_return(m
, &reply
);
2463 else if (streq_ptr(m
->member
, "GetMachineId")) {
2467 r
= sd_id128_get_machine(&id
);
2471 r
= sd_bus_message_new_method_return(m
, &reply
);
2475 r
= sd_bus_message_append(reply
, "s", sd_id128_to_string(id
, sid
));
2477 r
= sd_bus_message_new_method_errorf(
2479 SD_BUS_ERROR_UNKNOWN_METHOD
,
2480 "Unknown method '%s' on interface '%s'.", m
->member
, m
->interface
);
2486 r
= sd_bus_send(bus
, reply
, NULL
);
2493 static int process_fd_check(sd_bus
*bus
, sd_bus_message
*m
) {
2497 /* If we got a message with a file descriptor which we didn't
2498 * want to accept, then let's drop it. How can this even
2499 * happen? For example, when the kernel queues a message into
2500 * an activatable names's queue which allows fds, and then is
2501 * delivered to us later even though we ourselves did not
2504 if (bus
->hello_flags
& KDBUS_HELLO_MONITOR
)
2510 if (bus
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
)
2513 if (m
->header
->type
!= SD_BUS_MESSAGE_METHOD_CALL
)
2514 return 1; /* just eat it up */
2516 return sd_bus_reply_method_errorf(m
, SD_BUS_ERROR_INCONSISTENT_MESSAGE
, "Message contains file descriptors, which I cannot accept. Sorry.");
2519 static int process_message(sd_bus
*bus
, sd_bus_message
*m
) {
2525 bus
->current_message
= m
;
2526 bus
->iteration_counter
++;
2528 log_debug_bus_message(m
);
2530 r
= process_hello(bus
, m
);
2534 r
= process_reply(bus
, m
);
2538 r
= process_fd_check(bus
, m
);
2542 r
= process_filter(bus
, m
);
2546 r
= process_match(bus
, m
);
2550 r
= process_builtin(bus
, m
);
2554 r
= bus_process_object(bus
, m
);
2557 bus
->current_message
= NULL
;
2561 static int dispatch_track(sd_bus
*bus
) {
2564 if (!bus
->track_queue
)
2567 bus_track_dispatch(bus
->track_queue
);
2571 static int process_running(sd_bus
*bus
, bool hint_priority
, int64_t priority
, sd_bus_message
**ret
) {
2572 _cleanup_bus_message_unref_ sd_bus_message
*m
= NULL
;
2576 assert(bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
);
2578 r
= process_timeout(bus
);
2582 r
= dispatch_wqueue(bus
);
2586 r
= dispatch_track(bus
);
2590 r
= dispatch_rqueue(bus
, hint_priority
, priority
, &m
);
2596 r
= process_message(bus
, m
);
2601 r
= sd_bus_message_rewind(m
, true);
2610 if (m
->header
->type
== SD_BUS_MESSAGE_METHOD_CALL
) {
2612 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2613 strna(sd_bus_message_get_sender(m
)),
2614 strna(sd_bus_message_get_path(m
)),
2615 strna(sd_bus_message_get_interface(m
)),
2616 strna(sd_bus_message_get_member(m
)));
2618 r
= sd_bus_reply_method_errorf(
2620 SD_BUS_ERROR_UNKNOWN_OBJECT
,
2621 "Unknown object '%s'.", m
->path
);
2635 static int process_closing(sd_bus
*bus
, sd_bus_message
**ret
) {
2636 _cleanup_bus_message_unref_ sd_bus_message
*m
= NULL
;
2637 struct reply_callback
*c
;
2641 assert(bus
->state
== BUS_CLOSING
);
2643 c
= ordered_hashmap_first(bus
->reply_callbacks
);
2645 _cleanup_bus_error_free_ sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2648 /* First, fail all outstanding method calls */
2649 r
= bus_message_new_synthetic_error(
2652 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY
, "Connection terminated"),
2657 r
= bus_seal_synthetic_message(bus
, m
);
2661 if (c
->timeout
!= 0) {
2662 prioq_remove(bus
->reply_callbacks_prioq
, c
, &c
->prioq_idx
);
2666 ordered_hashmap_remove(bus
->reply_callbacks
, &c
->cookie
);
2669 slot
= container_of(c
, sd_bus_slot
, reply_callback
);
2671 bus
->iteration_counter
++;
2673 bus
->current_message
= m
;
2674 bus
->current_slot
= sd_bus_slot_ref(slot
);
2675 bus
->current_handler
= c
->callback
;
2676 bus
->current_userdata
= slot
->userdata
;
2677 r
= c
->callback(m
, slot
->userdata
, &error_buffer
);
2678 bus
->current_userdata
= NULL
;
2679 bus
->current_handler
= NULL
;
2680 bus
->current_slot
= NULL
;
2681 bus
->current_message
= NULL
;
2683 if (slot
->floating
) {
2684 bus_slot_disconnect(slot
);
2685 sd_bus_slot_unref(slot
);
2688 sd_bus_slot_unref(slot
);
2690 return bus_maybe_reply_error(m
, r
, &error_buffer
);
2693 /* Then, synthesize a Disconnected message */
2694 r
= sd_bus_message_new_signal(
2697 "/org/freedesktop/DBus/Local",
2698 "org.freedesktop.DBus.Local",
2703 bus_message_set_sender_local(bus
, m
);
2705 r
= bus_seal_synthetic_message(bus
, m
);
2711 bus
->current_message
= m
;
2712 bus
->iteration_counter
++;
2714 r
= process_filter(bus
, m
);
2718 r
= process_match(bus
, m
);
2730 bus
->current_message
= NULL
;
2735 static int bus_process_internal(sd_bus
*bus
, bool hint_priority
, int64_t priority
, sd_bus_message
**ret
) {
2736 BUS_DONT_DESTROY(bus
);
2739 /* Returns 0 when we didn't do anything. This should cause the
2740 * caller to invoke sd_bus_wait() before returning the next
2741 * time. Returns > 0 when we did something, which possibly
2742 * means *ret is filled in with an unprocessed message. */
2744 assert_return(bus
, -EINVAL
);
2745 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2747 /* We don't allow recursively invoking sd_bus_process(). */
2748 assert_return(!bus
->current_message
, -EBUSY
);
2749 assert(!bus
->current_slot
);
2751 switch (bus
->state
) {
2760 r
= bus_socket_process_opening(bus
);
2761 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2762 bus_enter_closing(bus
);
2770 case BUS_AUTHENTICATING
:
2771 r
= bus_socket_process_authenticating(bus
);
2772 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2773 bus_enter_closing(bus
);
2785 r
= process_running(bus
, hint_priority
, priority
, ret
);
2786 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2787 bus_enter_closing(bus
);
2797 return process_closing(bus
, ret
);
2800 assert_not_reached("Unknown state");
2803 _public_
int sd_bus_process(sd_bus
*bus
, sd_bus_message
**ret
) {
2804 return bus_process_internal(bus
, false, 0, ret
);
2807 _public_
int sd_bus_process_priority(sd_bus
*bus
, int64_t priority
, sd_bus_message
**ret
) {
2808 return bus_process_internal(bus
, true, priority
, ret
);
2811 static int bus_poll(sd_bus
*bus
, bool need_more
, uint64_t timeout_usec
) {
2812 struct pollfd p
[2] = {};
2815 usec_t m
= USEC_INFINITY
;
2819 if (bus
->state
== BUS_CLOSING
)
2822 if (!BUS_IS_OPEN(bus
->state
))
2825 e
= sd_bus_get_events(bus
);
2830 /* The caller really needs some more data, he doesn't
2831 * care about what's already read, or any timeouts
2832 * except its own. */
2836 /* The caller wants to process if there's something to
2837 * process, but doesn't care otherwise */
2839 r
= sd_bus_get_timeout(bus
, &until
);
2844 nw
= now(CLOCK_MONOTONIC
);
2845 m
= until
> nw
? until
- nw
: 0;
2849 if (timeout_usec
!= (uint64_t) -1 && (m
== (uint64_t) -1 || timeout_usec
< m
))
2852 p
[0].fd
= bus
->input_fd
;
2853 if (bus
->output_fd
== bus
->input_fd
) {
2857 p
[0].events
= e
& POLLIN
;
2858 p
[1].fd
= bus
->output_fd
;
2859 p
[1].events
= e
& POLLOUT
;
2863 r
= ppoll(p
, n
, m
== (uint64_t) -1 ? NULL
: timespec_store(&ts
, m
), NULL
);
2867 return r
> 0 ? 1 : 0;
2870 _public_
int sd_bus_wait(sd_bus
*bus
, uint64_t timeout_usec
) {
2872 assert_return(bus
, -EINVAL
);
2873 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2875 if (bus
->state
== BUS_CLOSING
)
2878 if (!BUS_IS_OPEN(bus
->state
))
2881 if (bus
->rqueue_size
> 0)
2884 return bus_poll(bus
, false, timeout_usec
);
2887 _public_
int sd_bus_flush(sd_bus
*bus
) {
2890 assert_return(bus
, -EINVAL
);
2891 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2893 if (bus
->state
== BUS_CLOSING
)
2896 if (!BUS_IS_OPEN(bus
->state
))
2899 r
= bus_ensure_running(bus
);
2903 if (bus
->wqueue_size
<= 0)
2907 r
= dispatch_wqueue(bus
);
2909 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2910 bus_enter_closing(bus
);
2917 if (bus
->wqueue_size
<= 0)
2920 r
= bus_poll(bus
, false, (uint64_t) -1);
2926 _public_
int sd_bus_add_filter(
2929 sd_bus_message_handler_t callback
,
2934 assert_return(bus
, -EINVAL
);
2935 assert_return(callback
, -EINVAL
);
2936 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2938 s
= bus_slot_allocate(bus
, !slot
, BUS_FILTER_CALLBACK
, sizeof(struct filter_callback
), userdata
);
2942 s
->filter_callback
.callback
= callback
;
2944 bus
->filter_callbacks_modified
= true;
2945 LIST_PREPEND(callbacks
, bus
->filter_callbacks
, &s
->filter_callback
);
2953 _public_
int sd_bus_add_match(
2957 sd_bus_message_handler_t callback
,
2960 struct bus_match_component
*components
= NULL
;
2961 unsigned n_components
= 0;
2962 sd_bus_slot
*s
= NULL
;
2965 assert_return(bus
, -EINVAL
);
2966 assert_return(match
, -EINVAL
);
2967 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2969 r
= bus_match_parse(match
, &components
, &n_components
);
2973 s
= bus_slot_allocate(bus
, !slot
, BUS_MATCH_CALLBACK
, sizeof(struct match_callback
), userdata
);
2979 s
->match_callback
.callback
= callback
;
2980 s
->match_callback
.cookie
= ++bus
->match_cookie
;
2982 if (bus
->bus_client
) {
2983 enum bus_match_scope scope
;
2985 scope
= bus_match_get_scope(components
, n_components
);
2987 /* Do not install server-side matches for matches
2988 * against the local service, interface or bus
2990 if (scope
!= BUS_MATCH_LOCAL
) {
2992 if (!bus
->is_kernel
) {
2993 /* When this is not a kernel transport, we
2994 * store the original match string, so that we
2995 * can use it to remove the match again */
2997 s
->match_callback
.match_string
= strdup(match
);
2998 if (!s
->match_callback
.match_string
) {
3004 r
= bus_add_match_internal(bus
, s
->match_callback
.match_string
, components
, n_components
, s
->match_callback
.cookie
);
3008 s
->match_added
= true;
3012 bus
->match_callbacks_modified
= true;
3013 r
= bus_match_add(&bus
->match_callbacks
, components
, n_components
, &s
->match_callback
);
3022 bus_match_parse_free(components
, n_components
);
3023 sd_bus_slot_unref(s
);
3028 int bus_remove_match_by_string(
3031 sd_bus_message_handler_t callback
,
3034 struct bus_match_component
*components
= NULL
;
3035 unsigned n_components
= 0;
3036 struct match_callback
*c
;
3039 assert_return(bus
, -EINVAL
);
3040 assert_return(match
, -EINVAL
);
3041 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3043 r
= bus_match_parse(match
, &components
, &n_components
);
3047 r
= bus_match_find(&bus
->match_callbacks
, components
, n_components
, NULL
, NULL
, &c
);
3051 sd_bus_slot_unref(container_of(c
, sd_bus_slot
, match_callback
));
3054 bus_match_parse_free(components
, n_components
);
3059 bool bus_pid_changed(sd_bus
*bus
) {
3062 /* We don't support people creating a bus connection and
3063 * keeping it around over a fork(). Let's complain. */
3065 return bus
->original_pid
!= getpid();
3068 static int io_callback(sd_event_source
*s
, int fd
, uint32_t revents
, void *userdata
) {
3069 sd_bus
*bus
= userdata
;
3074 r
= sd_bus_process(bus
, NULL
);
3081 static int time_callback(sd_event_source
*s
, uint64_t usec
, void *userdata
) {
3082 sd_bus
*bus
= userdata
;
3087 r
= sd_bus_process(bus
, NULL
);
3094 static int prepare_callback(sd_event_source
*s
, void *userdata
) {
3095 sd_bus
*bus
= userdata
;
3102 e
= sd_bus_get_events(bus
);
3106 if (bus
->output_fd
!= bus
->input_fd
) {
3108 r
= sd_event_source_set_io_events(bus
->input_io_event_source
, e
& POLLIN
);
3112 r
= sd_event_source_set_io_events(bus
->output_io_event_source
, e
& POLLOUT
);
3116 r
= sd_event_source_set_io_events(bus
->input_io_event_source
, e
);
3121 r
= sd_bus_get_timeout(bus
, &until
);
3127 j
= sd_event_source_set_time(bus
->time_event_source
, until
);
3132 r
= sd_event_source_set_enabled(bus
->time_event_source
, r
> 0);
3139 static int quit_callback(sd_event_source
*event
, void *userdata
) {
3140 sd_bus
*bus
= userdata
;
3150 static int attach_io_events(sd_bus
*bus
) {
3155 if (bus
->input_fd
< 0)
3161 if (!bus
->input_io_event_source
) {
3162 r
= sd_event_add_io(bus
->event
, &bus
->input_io_event_source
, bus
->input_fd
, 0, io_callback
, bus
);
3166 r
= sd_event_source_set_prepare(bus
->input_io_event_source
, prepare_callback
);
3170 r
= sd_event_source_set_priority(bus
->input_io_event_source
, bus
->event_priority
);
3174 r
= sd_event_source_set_description(bus
->input_io_event_source
, "bus-input");
3176 r
= sd_event_source_set_io_fd(bus
->input_io_event_source
, bus
->input_fd
);
3181 if (bus
->output_fd
!= bus
->input_fd
) {
3182 assert(bus
->output_fd
>= 0);
3184 if (!bus
->output_io_event_source
) {
3185 r
= sd_event_add_io(bus
->event
, &bus
->output_io_event_source
, bus
->output_fd
, 0, io_callback
, bus
);
3189 r
= sd_event_source_set_priority(bus
->output_io_event_source
, bus
->event_priority
);
3193 r
= sd_event_source_set_description(bus
->input_io_event_source
, "bus-output");
3195 r
= sd_event_source_set_io_fd(bus
->output_io_event_source
, bus
->output_fd
);
3204 static void detach_io_events(sd_bus
*bus
) {
3207 if (bus
->input_io_event_source
) {
3208 sd_event_source_set_enabled(bus
->input_io_event_source
, SD_EVENT_OFF
);
3209 bus
->input_io_event_source
= sd_event_source_unref(bus
->input_io_event_source
);
3212 if (bus
->output_io_event_source
) {
3213 sd_event_source_set_enabled(bus
->output_io_event_source
, SD_EVENT_OFF
);
3214 bus
->output_io_event_source
= sd_event_source_unref(bus
->output_io_event_source
);
3218 _public_
int sd_bus_attach_event(sd_bus
*bus
, sd_event
*event
, int priority
) {
3221 assert_return(bus
, -EINVAL
);
3222 assert_return(!bus
->event
, -EBUSY
);
3224 assert(!bus
->input_io_event_source
);
3225 assert(!bus
->output_io_event_source
);
3226 assert(!bus
->time_event_source
);
3229 bus
->event
= sd_event_ref(event
);
3231 r
= sd_event_default(&bus
->event
);
3236 bus
->event_priority
= priority
;
3238 r
= sd_event_add_time(bus
->event
, &bus
->time_event_source
, CLOCK_MONOTONIC
, 0, 0, time_callback
, bus
);
3242 r
= sd_event_source_set_priority(bus
->time_event_source
, priority
);
3246 r
= sd_event_source_set_description(bus
->time_event_source
, "bus-time");
3250 r
= sd_event_add_exit(bus
->event
, &bus
->quit_event_source
, quit_callback
, bus
);
3254 r
= sd_event_source_set_description(bus
->quit_event_source
, "bus-exit");
3258 r
= attach_io_events(bus
);
3265 sd_bus_detach_event(bus
);
3269 _public_
int sd_bus_detach_event(sd_bus
*bus
) {
3270 assert_return(bus
, -EINVAL
);
3275 detach_io_events(bus
);
3277 if (bus
->time_event_source
) {
3278 sd_event_source_set_enabled(bus
->time_event_source
, SD_EVENT_OFF
);
3279 bus
->time_event_source
= sd_event_source_unref(bus
->time_event_source
);
3282 if (bus
->quit_event_source
) {
3283 sd_event_source_set_enabled(bus
->quit_event_source
, SD_EVENT_OFF
);
3284 bus
->quit_event_source
= sd_event_source_unref(bus
->quit_event_source
);
3287 bus
->event
= sd_event_unref(bus
->event
);
3291 _public_ sd_event
* sd_bus_get_event(sd_bus
*bus
) {
3292 assert_return(bus
, NULL
);
3297 _public_ sd_bus_message
* sd_bus_get_current_message(sd_bus
*bus
) {
3298 assert_return(bus
, NULL
);
3300 return bus
->current_message
;
3303 _public_ sd_bus_slot
* sd_bus_get_current_slot(sd_bus
*bus
) {
3304 assert_return(bus
, NULL
);
3306 return bus
->current_slot
;
3309 _public_ sd_bus_message_handler_t
sd_bus_get_current_handler(sd_bus
*bus
) {
3310 assert_return(bus
, NULL
);
3312 return bus
->current_handler
;
3315 _public_
void* sd_bus_get_current_userdata(sd_bus
*bus
) {
3316 assert_return(bus
, NULL
);
3318 return bus
->current_userdata
;
3321 static int bus_default(int (*bus_open
)(sd_bus
**), sd_bus
**default_bus
, sd_bus
**ret
) {
3326 assert(default_bus
);
3329 return !!*default_bus
;
3332 *ret
= sd_bus_ref(*default_bus
);
3340 b
->default_bus_ptr
= default_bus
;
3348 _public_
int sd_bus_default_system(sd_bus
**ret
) {
3349 static thread_local sd_bus
*default_system_bus
= NULL
;
3351 return bus_default(sd_bus_open_system
, &default_system_bus
, ret
);
3354 _public_
int sd_bus_default_user(sd_bus
**ret
) {
3355 static thread_local sd_bus
*default_user_bus
= NULL
;
3357 return bus_default(sd_bus_open_user
, &default_user_bus
, ret
);
3360 _public_
int sd_bus_default(sd_bus
**ret
) {
3364 /* Let's try our best to reuse another cached connection. If
3365 * the starter bus type is set, connect via our normal
3366 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3367 * we can share the connection with the user/system default
3370 e
= secure_getenv("DBUS_STARTER_BUS_TYPE");
3372 if (streq(e
, "system"))
3373 return sd_bus_default_system(ret
);
3374 else if (STR_IN_SET(e
, "user", "session"))
3375 return sd_bus_default_user(ret
);
3378 /* No type is specified, so we have not other option than to
3379 * use the starter address if it is set. */
3381 e
= secure_getenv("DBUS_STARTER_ADDRESS");
3383 static thread_local sd_bus
*default_starter_bus
= NULL
;
3385 return bus_default(sd_bus_open
, &default_starter_bus
, ret
);
3388 /* Finally, if nothing is set use the cached connection for
3389 * the right scope */
3391 if (cg_pid_get_owner_uid(0, NULL
) >= 0)
3392 return sd_bus_default_user(ret
);
3394 return sd_bus_default_system(ret
);
3397 _public_
int sd_bus_get_tid(sd_bus
*b
, pid_t
*tid
) {
3398 assert_return(b
, -EINVAL
);
3399 assert_return(tid
, -EINVAL
);
3400 assert_return(!bus_pid_changed(b
), -ECHILD
);
3408 return sd_event_get_tid(b
->event
, tid
);
3413 _public_
int sd_bus_path_encode(const char *prefix
, const char *external_id
, char **ret_path
) {
3414 _cleanup_free_
char *e
= NULL
;
3417 assert_return(object_path_is_valid(prefix
), -EINVAL
);
3418 assert_return(external_id
, -EINVAL
);
3419 assert_return(ret_path
, -EINVAL
);
3421 e
= bus_label_escape(external_id
);
3425 ret
= strjoin(prefix
, "/", e
, NULL
);
3433 _public_
int sd_bus_path_decode(const char *path
, const char *prefix
, char **external_id
) {
3437 assert_return(object_path_is_valid(path
), -EINVAL
);
3438 assert_return(object_path_is_valid(prefix
), -EINVAL
);
3439 assert_return(external_id
, -EINVAL
);
3441 e
= object_path_startswith(path
, prefix
);
3443 *external_id
= NULL
;
3447 ret
= bus_label_unescape(e
);
3455 _public_
int sd_bus_try_close(sd_bus
*bus
) {
3458 assert_return(bus
, -EINVAL
);
3459 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3461 if (!bus
->is_kernel
)
3464 if (!BUS_IS_OPEN(bus
->state
))
3467 if (bus
->rqueue_size
> 0)
3470 if (bus
->wqueue_size
> 0)
3473 r
= bus_kernel_try_close(bus
);
3481 _public_
int sd_bus_get_description(sd_bus
*bus
, const char **description
) {
3482 assert_return(bus
, -EINVAL
);
3483 assert_return(description
, -EINVAL
);
3484 assert_return(bus
->description
, -ENXIO
);
3485 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3487 *description
= bus
->description
;
3491 int bus_get_root_path(sd_bus
*bus
) {
3494 if (bus
->cgroup_root
)
3497 r
= cg_get_root_path(&bus
->cgroup_root
);
3499 bus
->cgroup_root
= strdup("/");
3500 if (!bus
->cgroup_root
)
3509 _public_
int sd_bus_get_scope(sd_bus
*bus
, const char **scope
) {
3512 assert_return(bus
, -EINVAL
);
3513 assert_return(scope
, -EINVAL
);
3514 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3516 if (bus
->is_kernel
) {
3517 _cleanup_free_
char *n
= NULL
;
3520 r
= bus_kernel_get_bus_name(bus
, &n
);
3524 if (streq(n
, "0-system")) {
3529 dash
= strchr(n
, '-');
3530 if (streq_ptr(dash
, "-user")) {
3541 if (bus
->is_system
) {
3549 _public_
int sd_bus_get_address(sd_bus
*bus
, const char **address
) {
3551 assert_return(bus
, -EINVAL
);
3552 assert_return(address
, -EINVAL
);
3553 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3556 *address
= bus
->address
;
3563 _public_
int sd_bus_get_creds_mask(sd_bus
*bus
, uint64_t *mask
) {
3564 assert_return(bus
, -EINVAL
);
3565 assert_return(mask
, -EINVAL
);
3566 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3568 *mask
= bus
->creds_mask
;
3572 _public_
int sd_bus_is_bus_client(sd_bus
*bus
) {
3573 assert_return(bus
, -EINVAL
);
3574 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3576 return bus
->bus_client
;
3579 _public_
int sd_bus_is_server(sd_bus
*bus
) {
3580 assert_return(bus
, -EINVAL
);
3581 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3583 return bus
->is_server
;
3586 _public_
int sd_bus_is_anonymous(sd_bus
*bus
) {
3587 assert_return(bus
, -EINVAL
);
3588 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3590 return bus
->anonymous_auth
;
3593 _public_
int sd_bus_is_trusted(sd_bus
*bus
) {
3594 assert_return(bus
, -EINVAL
);
3595 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3597 return bus
->trusted
;
3600 _public_
int sd_bus_is_monitor(sd_bus
*bus
) {
3601 assert_return(bus
, -EINVAL
);
3602 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3604 return !!(bus
->hello_flags
& KDBUS_HELLO_MONITOR
);