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
) {
76 if (b
->input_fd
!= b
->output_fd
)
77 safe_close(b
->output_fd
);
78 b
->output_fd
= b
->input_fd
= safe_close(b
->input_fd
);
81 static void bus_reset_queues(sd_bus
*b
) {
84 while (b
->rqueue_size
> 0)
85 sd_bus_message_unref(b
->rqueue
[--b
->rqueue_size
]);
87 b
->rqueue
= mfree(b
->rqueue
);
88 b
->rqueue_allocated
= 0;
90 while (b
->wqueue_size
> 0)
91 sd_bus_message_unref(b
->wqueue
[--b
->wqueue_size
]);
93 b
->wqueue
= mfree(b
->wqueue
);
94 b
->wqueue_allocated
= 0;
97 static void bus_free(sd_bus
*b
) {
101 assert(!b
->track_queue
);
103 b
->state
= BUS_CLOSED
;
105 sd_bus_detach_event(b
);
107 while ((s
= b
->slots
)) {
108 /* At this point only floating slots can still be
109 * around, because the non-floating ones keep a
110 * reference to the bus, and we thus couldn't be
111 * destructing right now... We forcibly disconnect the
112 * slots here, so that they still can be referenced by
113 * apps, but are dead. */
116 bus_slot_disconnect(s
);
117 sd_bus_slot_unref(s
);
120 if (b
->default_bus_ptr
)
121 *b
->default_bus_ptr
= NULL
;
126 munmap(b
->kdbus_buffer
, KDBUS_POOL_SIZE
);
130 free(b
->unique_name
);
131 free(b
->auth_buffer
);
136 free(b
->cgroup_root
);
137 free(b
->description
);
140 strv_free(b
->exec_argv
);
142 close_many(b
->fds
, b
->n_fds
);
147 ordered_hashmap_free_free(b
->reply_callbacks
);
148 prioq_free(b
->reply_callbacks_prioq
);
150 assert(b
->match_callbacks
.type
== BUS_MATCH_ROOT
);
151 bus_match_free(&b
->match_callbacks
);
153 hashmap_free_free(b
->vtable_methods
);
154 hashmap_free_free(b
->vtable_properties
);
156 assert(hashmap_isempty(b
->nodes
));
157 hashmap_free(b
->nodes
);
159 bus_kernel_flush_memfd(b
);
161 assert_se(pthread_mutex_destroy(&b
->memfd_cache_mutex
) == 0);
166 _public_
int sd_bus_new(sd_bus
**ret
) {
169 assert_return(ret
, -EINVAL
);
175 r
->n_ref
= REFCNT_INIT
;
176 r
->input_fd
= r
->output_fd
= -1;
177 r
->message_version
= 1;
178 r
->creds_mask
|= SD_BUS_CREDS_WELL_KNOWN_NAMES
|SD_BUS_CREDS_UNIQUE_NAME
;
179 r
->hello_flags
|= KDBUS_HELLO_ACCEPT_FD
;
180 r
->attach_flags
|= KDBUS_ATTACH_NAMES
;
181 r
->original_pid
= getpid();
183 assert_se(pthread_mutex_init(&r
->memfd_cache_mutex
, NULL
) == 0);
185 /* We guarantee that wqueue always has space for at least one
187 if (!GREEDY_REALLOC(r
->wqueue
, r
->wqueue_allocated
, 1)) {
196 _public_
int sd_bus_set_address(sd_bus
*bus
, const char *address
) {
199 assert_return(bus
, -EINVAL
);
200 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
201 assert_return(address
, -EINVAL
);
202 assert_return(!bus_pid_changed(bus
), -ECHILD
);
214 _public_
int sd_bus_set_fd(sd_bus
*bus
, int input_fd
, int output_fd
) {
215 assert_return(bus
, -EINVAL
);
216 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
217 assert_return(input_fd
>= 0, -EINVAL
);
218 assert_return(output_fd
>= 0, -EINVAL
);
219 assert_return(!bus_pid_changed(bus
), -ECHILD
);
221 bus
->input_fd
= input_fd
;
222 bus
->output_fd
= output_fd
;
226 _public_
int sd_bus_set_exec(sd_bus
*bus
, const char *path
, char *const argv
[]) {
229 assert_return(bus
, -EINVAL
);
230 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
231 assert_return(path
, -EINVAL
);
232 assert_return(!strv_isempty(argv
), -EINVAL
);
233 assert_return(!bus_pid_changed(bus
), -ECHILD
);
245 free(bus
->exec_path
);
246 strv_free(bus
->exec_argv
);
254 _public_
int sd_bus_set_bus_client(sd_bus
*bus
, int b
) {
255 assert_return(bus
, -EINVAL
);
256 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
257 assert_return(!bus_pid_changed(bus
), -ECHILD
);
259 bus
->bus_client
= !!b
;
263 _public_
int sd_bus_set_monitor(sd_bus
*bus
, int b
) {
264 assert_return(bus
, -EINVAL
);
265 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
266 assert_return(!bus_pid_changed(bus
), -ECHILD
);
268 SET_FLAG(bus
->hello_flags
, KDBUS_HELLO_MONITOR
, b
);
272 _public_
int sd_bus_negotiate_fds(sd_bus
*bus
, int b
) {
273 assert_return(bus
, -EINVAL
);
274 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
275 assert_return(!bus_pid_changed(bus
), -ECHILD
);
277 SET_FLAG(bus
->hello_flags
, KDBUS_HELLO_ACCEPT_FD
, b
);
281 _public_
int sd_bus_negotiate_timestamp(sd_bus
*bus
, int b
) {
283 assert_return(bus
, -EINVAL
);
284 assert_return(!IN_SET(bus
->state
, BUS_CLOSING
, BUS_CLOSED
), -EPERM
);
285 assert_return(!bus_pid_changed(bus
), -ECHILD
);
287 new_flags
= bus
->attach_flags
;
288 SET_FLAG(new_flags
, KDBUS_ATTACH_TIMESTAMP
, b
);
290 if (bus
->attach_flags
== new_flags
)
293 bus
->attach_flags
= new_flags
;
294 if (bus
->state
!= BUS_UNSET
&& bus
->is_kernel
)
295 bus_kernel_realize_attach_flags(bus
);
300 _public_
int sd_bus_negotiate_creds(sd_bus
*bus
, int b
, uint64_t mask
) {
303 assert_return(bus
, -EINVAL
);
304 assert_return(mask
<= _SD_BUS_CREDS_ALL
, -EINVAL
);
305 assert_return(!IN_SET(bus
->state
, BUS_CLOSING
, BUS_CLOSED
), -EPERM
);
306 assert_return(!bus_pid_changed(bus
), -ECHILD
);
309 bus
->creds_mask
|= mask
;
311 bus
->creds_mask
&= ~mask
;
313 /* The well knowns we need unconditionally, so that matches can work */
314 bus
->creds_mask
|= SD_BUS_CREDS_WELL_KNOWN_NAMES
|SD_BUS_CREDS_UNIQUE_NAME
;
316 /* Make sure we don't lose the timestamp flag */
317 new_flags
= (bus
->attach_flags
& KDBUS_ATTACH_TIMESTAMP
) | attach_flags_to_kdbus(bus
->creds_mask
);
318 if (bus
->attach_flags
== new_flags
)
321 bus
->attach_flags
= new_flags
;
322 if (bus
->state
!= BUS_UNSET
&& bus
->is_kernel
)
323 bus_kernel_realize_attach_flags(bus
);
328 _public_
int sd_bus_set_server(sd_bus
*bus
, int b
, sd_id128_t server_id
) {
329 assert_return(bus
, -EINVAL
);
330 assert_return(b
|| sd_id128_equal(server_id
, SD_ID128_NULL
), -EINVAL
);
331 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
332 assert_return(!bus_pid_changed(bus
), -ECHILD
);
334 bus
->is_server
= !!b
;
335 bus
->server_id
= server_id
;
339 _public_
int sd_bus_set_anonymous(sd_bus
*bus
, int b
) {
340 assert_return(bus
, -EINVAL
);
341 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
342 assert_return(!bus_pid_changed(bus
), -ECHILD
);
344 bus
->anonymous_auth
= !!b
;
348 _public_
int sd_bus_set_trusted(sd_bus
*bus
, int b
) {
349 assert_return(bus
, -EINVAL
);
350 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
351 assert_return(!bus_pid_changed(bus
), -ECHILD
);
357 _public_
int sd_bus_set_description(sd_bus
*bus
, const char *description
) {
358 assert_return(bus
, -EINVAL
);
359 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
360 assert_return(!bus_pid_changed(bus
), -ECHILD
);
362 return free_and_strdup(&bus
->description
, description
);
365 _public_
int sd_bus_set_allow_interactive_authorization(sd_bus
*bus
, int b
) {
366 assert_return(bus
, -EINVAL
);
367 assert_return(!bus_pid_changed(bus
), -ECHILD
);
369 bus
->allow_interactive_authorization
= !!b
;
373 _public_
int sd_bus_get_allow_interactive_authorization(sd_bus
*bus
) {
374 assert_return(bus
, -EINVAL
);
375 assert_return(!bus_pid_changed(bus
), -ECHILD
);
377 return bus
->allow_interactive_authorization
;
380 static int hello_callback(sd_bus_message
*reply
, void *userdata
, sd_bus_error
*error
) {
388 assert(bus
->state
== BUS_HELLO
|| bus
->state
== BUS_CLOSING
);
390 r
= sd_bus_message_get_errno(reply
);
394 r
= sd_bus_message_read(reply
, "s", &s
);
398 if (!service_name_is_valid(s
) || s
[0] != ':')
401 bus
->unique_name
= strdup(s
);
402 if (!bus
->unique_name
)
405 if (bus
->state
== BUS_HELLO
)
406 bus
->state
= BUS_RUNNING
;
411 static int bus_send_hello(sd_bus
*bus
) {
412 _cleanup_bus_message_unref_ sd_bus_message
*m
= NULL
;
417 if (!bus
->bus_client
|| bus
->is_kernel
)
420 r
= sd_bus_message_new_method_call(
423 "org.freedesktop.DBus",
424 "/org/freedesktop/DBus",
425 "org.freedesktop.DBus",
430 return sd_bus_call_async(bus
, NULL
, m
, hello_callback
, NULL
, 0);
433 int bus_start_running(sd_bus
*bus
) {
436 if (bus
->bus_client
&& !bus
->is_kernel
) {
437 bus
->state
= BUS_HELLO
;
441 bus
->state
= BUS_RUNNING
;
445 static int parse_address_key(const char **p
, const char *key
, char **value
) {
446 size_t l
, n
= 0, allocated
= 0;
456 if (strncmp(*p
, key
, l
) != 0)
469 while (*a
!= ';' && *a
!= ',' && *a
!= 0) {
487 c
= (char) ((x
<< 4) | y
);
494 if (!GREEDY_REALLOC(r
, allocated
, n
+ 2))
518 static void skip_address_key(const char **p
) {
522 *p
+= strcspn(*p
, ",");
528 static int parse_unix_address(sd_bus
*b
, const char **p
, char **guid
) {
529 _cleanup_free_
char *path
= NULL
, *abstract
= NULL
;
538 while (**p
!= 0 && **p
!= ';') {
539 r
= parse_address_key(p
, "guid", guid
);
545 r
= parse_address_key(p
, "path", &path
);
551 r
= parse_address_key(p
, "abstract", &abstract
);
560 if (!path
&& !abstract
)
563 if (path
&& abstract
)
568 if (l
> sizeof(b
->sockaddr
.un
.sun_path
))
571 b
->sockaddr
.un
.sun_family
= AF_UNIX
;
572 strncpy(b
->sockaddr
.un
.sun_path
, path
, sizeof(b
->sockaddr
.un
.sun_path
));
573 b
->sockaddr_size
= offsetof(struct sockaddr_un
, sun_path
) + l
;
574 } else if (abstract
) {
575 l
= strlen(abstract
);
576 if (l
> sizeof(b
->sockaddr
.un
.sun_path
) - 1)
579 b
->sockaddr
.un
.sun_family
= AF_UNIX
;
580 b
->sockaddr
.un
.sun_path
[0] = 0;
581 strncpy(b
->sockaddr
.un
.sun_path
+1, abstract
, sizeof(b
->sockaddr
.un
.sun_path
)-1);
582 b
->sockaddr_size
= offsetof(struct sockaddr_un
, sun_path
) + 1 + l
;
588 static int parse_tcp_address(sd_bus
*b
, const char **p
, char **guid
) {
589 _cleanup_free_
char *host
= NULL
, *port
= NULL
, *family
= NULL
;
591 struct addrinfo
*result
, hints
= {
592 .ai_socktype
= SOCK_STREAM
,
593 .ai_flags
= AI_ADDRCONFIG
,
601 while (**p
!= 0 && **p
!= ';') {
602 r
= parse_address_key(p
, "guid", guid
);
608 r
= parse_address_key(p
, "host", &host
);
614 r
= parse_address_key(p
, "port", &port
);
620 r
= parse_address_key(p
, "family", &family
);
633 if (streq(family
, "ipv4"))
634 hints
.ai_family
= AF_INET
;
635 else if (streq(family
, "ipv6"))
636 hints
.ai_family
= AF_INET6
;
641 r
= getaddrinfo(host
, port
, &hints
, &result
);
645 return -EADDRNOTAVAIL
;
647 memcpy(&b
->sockaddr
, result
->ai_addr
, result
->ai_addrlen
);
648 b
->sockaddr_size
= result
->ai_addrlen
;
650 freeaddrinfo(result
);
655 static int parse_exec_address(sd_bus
*b
, const char **p
, char **guid
) {
657 unsigned n_argv
= 0, j
;
659 size_t allocated
= 0;
667 while (**p
!= 0 && **p
!= ';') {
668 r
= parse_address_key(p
, "guid", guid
);
674 r
= parse_address_key(p
, "path", &path
);
680 if (startswith(*p
, "argv")) {
684 ul
= strtoul(*p
+ 4, (char**) p
, 10);
685 if (errno
> 0 || **p
!= '=' || ul
> 256) {
693 if (!GREEDY_REALLOC0(argv
, allocated
, ul
+ 2)) {
701 r
= parse_address_key(p
, NULL
, argv
+ ul
);
716 /* Make sure there are no holes in the array, with the
717 * exception of argv[0] */
718 for (j
= 1; j
< n_argv
; j
++)
724 if (argv
&& argv
[0] == NULL
) {
725 argv
[0] = strdup(path
);
737 for (j
= 0; j
< n_argv
; j
++)
745 static int parse_kernel_address(sd_bus
*b
, const char **p
, char **guid
) {
746 _cleanup_free_
char *path
= NULL
;
754 while (**p
!= 0 && **p
!= ';') {
755 r
= parse_address_key(p
, "guid", guid
);
761 r
= parse_address_key(p
, "path", &path
);
780 static int parse_container_unix_address(sd_bus
*b
, const char **p
, char **guid
) {
781 _cleanup_free_
char *machine
= NULL
, *pid
= NULL
;
789 while (**p
!= 0 && **p
!= ';') {
790 r
= parse_address_key(p
, "guid", guid
);
796 r
= parse_address_key(p
, "machine", &machine
);
802 r
= parse_address_key(p
, "pid", &pid
);
811 if (!machine
== !pid
)
815 if (!machine_name_is_valid(machine
))
819 b
->machine
= machine
;
827 r
= parse_pid(pid
, &b
->nspid
);
833 b
->sockaddr
.un
.sun_family
= AF_UNIX
;
834 strncpy(b
->sockaddr
.un
.sun_path
, "/var/run/dbus/system_bus_socket", sizeof(b
->sockaddr
.un
.sun_path
));
835 b
->sockaddr_size
= offsetof(struct sockaddr_un
, sun_path
) + strlen("/var/run/dbus/system_bus_socket");
840 static int parse_container_kernel_address(sd_bus
*b
, const char **p
, char **guid
) {
841 _cleanup_free_
char *machine
= NULL
, *pid
= NULL
;
849 while (**p
!= 0 && **p
!= ';') {
850 r
= parse_address_key(p
, "guid", guid
);
856 r
= parse_address_key(p
, "machine", &machine
);
862 r
= parse_address_key(p
, "pid", &pid
);
871 if (!machine
== !pid
)
875 if (!machine_name_is_valid(machine
))
879 b
->machine
= machine
;
887 r
= parse_pid(pid
, &b
->nspid
);
893 r
= free_and_strdup(&b
->kernel
, "/sys/fs/kdbus/0-system/bus");
900 static void bus_reset_parsed_address(sd_bus
*b
) {
904 b
->sockaddr_size
= 0;
905 b
->exec_argv
= strv_free(b
->exec_argv
);
906 b
->exec_path
= mfree(b
->exec_path
);
907 b
->server_id
= SD_ID128_NULL
;
908 b
->kernel
= mfree(b
->kernel
);
909 b
->machine
= mfree(b
->machine
);
913 static int bus_parse_next_address(sd_bus
*b
) {
914 _cleanup_free_
char *guid
= NULL
;
922 if (b
->address
[b
->address_index
] == 0)
925 bus_reset_parsed_address(b
);
927 a
= b
->address
+ b
->address_index
;
936 if (startswith(a
, "unix:")) {
939 r
= parse_unix_address(b
, &a
, &guid
);
944 } else if (startswith(a
, "tcp:")) {
947 r
= parse_tcp_address(b
, &a
, &guid
);
953 } else if (startswith(a
, "unixexec:")) {
956 r
= parse_exec_address(b
, &a
, &guid
);
962 } else if (startswith(a
, "kernel:")) {
965 r
= parse_kernel_address(b
, &a
, &guid
);
970 } else if (startswith(a
, "x-machine-unix:")) {
973 r
= parse_container_unix_address(b
, &a
, &guid
);
978 } else if (startswith(a
, "x-machine-kernel:")) {
981 r
= parse_container_kernel_address(b
, &a
, &guid
);
994 r
= sd_id128_from_string(guid
, &b
->server_id
);
999 b
->address_index
= a
- b
->address
;
1003 static int bus_start_address(sd_bus
*b
) {
1009 bool skipped
= false;
1014 r
= bus_socket_exec(b
);
1015 else if ((b
->nspid
> 0 || b
->machine
) && b
->kernel
)
1016 r
= bus_container_connect_kernel(b
);
1017 else if ((b
->nspid
> 0 || b
->machine
) && b
->sockaddr
.sa
.sa_family
!= AF_UNSPEC
)
1018 r
= bus_container_connect_socket(b
);
1020 r
= bus_kernel_connect(b
);
1021 else if (b
->sockaddr
.sa
.sa_family
!= AF_UNSPEC
)
1022 r
= bus_socket_connect(b
);
1028 r
= attach_io_events(b
);
1033 b
->last_connect_error
= -r
;
1036 r
= bus_parse_next_address(b
);
1040 return b
->last_connect_error
? -b
->last_connect_error
: -ECONNREFUSED
;
1044 int bus_next_address(sd_bus
*b
) {
1047 bus_reset_parsed_address(b
);
1048 return bus_start_address(b
);
1051 static int bus_start_fd(sd_bus
*b
) {
1056 assert(b
->input_fd
>= 0);
1057 assert(b
->output_fd
>= 0);
1059 r
= fd_nonblock(b
->input_fd
, true);
1063 r
= fd_cloexec(b
->input_fd
, true);
1067 if (b
->input_fd
!= b
->output_fd
) {
1068 r
= fd_nonblock(b
->output_fd
, true);
1072 r
= fd_cloexec(b
->output_fd
, true);
1077 if (fstat(b
->input_fd
, &st
) < 0)
1080 if (S_ISCHR(b
->input_fd
))
1081 return bus_kernel_take_fd(b
);
1083 return bus_socket_take_fd(b
);
1086 _public_
int sd_bus_start(sd_bus
*bus
) {
1089 assert_return(bus
, -EINVAL
);
1090 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
1091 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1093 bus
->state
= BUS_OPENING
;
1095 if (bus
->is_server
&& bus
->bus_client
)
1098 if (bus
->input_fd
>= 0)
1099 r
= bus_start_fd(bus
);
1100 else if (bus
->address
|| bus
->sockaddr
.sa
.sa_family
!= AF_UNSPEC
|| bus
->exec_path
|| bus
->kernel
|| bus
->machine
)
1101 r
= bus_start_address(bus
);
1110 return bus_send_hello(bus
);
1113 _public_
int sd_bus_open(sd_bus
**ret
) {
1118 assert_return(ret
, -EINVAL
);
1120 /* Let's connect to the starter bus if it is set, and
1121 * otherwise to the bus that is appropropriate for the scope
1122 * we are running in */
1124 e
= secure_getenv("DBUS_STARTER_BUS_TYPE");
1126 if (streq(e
, "system"))
1127 return sd_bus_open_system(ret
);
1128 else if (STR_IN_SET(e
, "session", "user"))
1129 return sd_bus_open_user(ret
);
1132 e
= secure_getenv("DBUS_STARTER_ADDRESS");
1134 if (cg_pid_get_owner_uid(0, NULL
) >= 0)
1135 return sd_bus_open_user(ret
);
1137 return sd_bus_open_system(ret
);
1144 r
= sd_bus_set_address(b
, e
);
1148 b
->bus_client
= true;
1150 /* We don't know whether the bus is trusted or not, so better
1151 * be safe, and authenticate everything */
1153 b
->attach_flags
|= KDBUS_ATTACH_CAPS
| KDBUS_ATTACH_CREDS
;
1154 b
->creds_mask
|= SD_BUS_CREDS_UID
| SD_BUS_CREDS_EUID
| SD_BUS_CREDS_EFFECTIVE_CAPS
;
1156 r
= sd_bus_start(b
);
1168 int bus_set_address_system(sd_bus
*b
) {
1172 e
= secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1174 return sd_bus_set_address(b
, e
);
1176 return sd_bus_set_address(b
, DEFAULT_SYSTEM_BUS_ADDRESS
);
1179 _public_
int sd_bus_open_system(sd_bus
**ret
) {
1183 assert_return(ret
, -EINVAL
);
1189 r
= bus_set_address_system(b
);
1193 b
->bus_client
= true;
1194 b
->is_system
= true;
1196 /* Let's do per-method access control on the system bus. We
1197 * need the caller's UID and capability set for that. */
1199 b
->attach_flags
|= KDBUS_ATTACH_CAPS
| KDBUS_ATTACH_CREDS
;
1200 b
->creds_mask
|= SD_BUS_CREDS_UID
| SD_BUS_CREDS_EUID
| SD_BUS_CREDS_EFFECTIVE_CAPS
;
1202 r
= sd_bus_start(b
);
1214 int bus_set_address_user(sd_bus
*b
) {
1219 e
= secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1221 return sd_bus_set_address(b
, e
);
1223 e
= secure_getenv("XDG_RUNTIME_DIR");
1225 _cleanup_free_
char *ee
= NULL
;
1227 ee
= bus_address_escape(e
);
1231 (void) asprintf(&b
->address
, KERNEL_USER_BUS_ADDRESS_FMT
";" UNIX_USER_BUS_ADDRESS_FMT
, getuid(), ee
);
1233 (void) asprintf(&b
->address
, KERNEL_USER_BUS_ADDRESS_FMT
, getuid());
1241 _public_
int sd_bus_open_user(sd_bus
**ret
) {
1245 assert_return(ret
, -EINVAL
);
1251 r
= bus_set_address_user(b
);
1255 b
->bus_client
= true;
1258 /* We don't do any per-method access control on the user
1262 r
= sd_bus_start(b
);
1274 int bus_set_address_system_remote(sd_bus
*b
, const char *host
) {
1275 _cleanup_free_
char *e
= NULL
;
1276 char *m
= NULL
, *c
= NULL
;
1281 /* Let's see if we shall enter some container */
1282 m
= strchr(host
, ':');
1286 /* Let's make sure this is not a port of some kind,
1287 * and is a valid machine name. */
1288 if (!in_charset(m
, "0123456789") && machine_name_is_valid(m
)) {
1291 /* Cut out the host part */
1292 t
= strndupa(host
, m
- host
- 1);
1293 e
= bus_address_escape(t
);
1297 c
= strjoina(",argv4=--machine=", m
);
1302 e
= bus_address_escape(host
);
1307 b
->address
= strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e
, ",argv3=systemd-stdio-bridge", c
, NULL
);
1314 _public_
int sd_bus_open_system_remote(sd_bus
**ret
, const char *host
) {
1318 assert_return(host
, -EINVAL
);
1319 assert_return(ret
, -EINVAL
);
1321 r
= sd_bus_new(&bus
);
1325 r
= bus_set_address_system_remote(bus
, host
);
1329 bus
->bus_client
= true;
1330 bus
->trusted
= false;
1331 bus
->is_system
= true;
1333 r
= sd_bus_start(bus
);
1345 int bus_set_address_system_machine(sd_bus
*b
, const char *machine
) {
1346 _cleanup_free_
char *e
= NULL
;
1351 e
= bus_address_escape(machine
);
1355 b
->address
= strjoin("x-machine-kernel:machine=", e
, ";x-machine-unix:machine=", e
, NULL
);
1362 _public_
int sd_bus_open_system_machine(sd_bus
**ret
, const char *machine
) {
1366 assert_return(machine
, -EINVAL
);
1367 assert_return(ret
, -EINVAL
);
1368 assert_return(machine_name_is_valid(machine
), -EINVAL
);
1370 r
= sd_bus_new(&bus
);
1374 r
= bus_set_address_system_machine(bus
, machine
);
1378 bus
->bus_client
= true;
1379 bus
->trusted
= false;
1380 bus
->is_system
= true;
1382 r
= sd_bus_start(bus
);
1394 _public_
void sd_bus_close(sd_bus
*bus
) {
1398 if (bus
->state
== BUS_CLOSED
)
1400 if (bus_pid_changed(bus
))
1403 bus
->state
= BUS_CLOSED
;
1405 sd_bus_detach_event(bus
);
1407 /* Drop all queued messages so that they drop references to
1408 * the bus object and the bus may be freed */
1409 bus_reset_queues(bus
);
1411 if (!bus
->is_kernel
)
1414 /* We'll leave the fd open in case this is a kernel bus, since
1415 * there might still be memblocks around that reference this
1416 * bus, and they might need to invoke the KDBUS_CMD_FREE
1417 * ioctl on the fd when they are freed. */
1420 _public_ sd_bus
* sd_bus_flush_close_unref(sd_bus
*bus
) {
1428 return sd_bus_unref(bus
);
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
2949 if (scope
!= BUS_MATCH_LOCAL
) {
2951 if (!bus
->is_kernel
) {
2952 /* When this is not a kernel transport, we
2953 * store the original match string, so that we
2954 * can use it to remove the match again */
2956 s
->match_callback
.match_string
= strdup(match
);
2957 if (!s
->match_callback
.match_string
) {
2963 r
= bus_add_match_internal(bus
, s
->match_callback
.match_string
, components
, n_components
, s
->match_callback
.cookie
);
2967 s
->match_added
= true;
2971 bus
->match_callbacks_modified
= true;
2972 r
= bus_match_add(&bus
->match_callbacks
, components
, n_components
, &s
->match_callback
);
2981 bus_match_parse_free(components
, n_components
);
2982 sd_bus_slot_unref(s
);
2987 int bus_remove_match_by_string(
2990 sd_bus_message_handler_t callback
,
2993 struct bus_match_component
*components
= NULL
;
2994 unsigned n_components
= 0;
2995 struct match_callback
*c
;
2998 assert_return(bus
, -EINVAL
);
2999 assert_return(match
, -EINVAL
);
3000 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3002 r
= bus_match_parse(match
, &components
, &n_components
);
3006 r
= bus_match_find(&bus
->match_callbacks
, components
, n_components
, NULL
, NULL
, &c
);
3010 sd_bus_slot_unref(container_of(c
, sd_bus_slot
, match_callback
));
3013 bus_match_parse_free(components
, n_components
);
3018 bool bus_pid_changed(sd_bus
*bus
) {
3021 /* We don't support people creating a bus connection and
3022 * keeping it around over a fork(). Let's complain. */
3024 return bus
->original_pid
!= getpid();
3027 static int io_callback(sd_event_source
*s
, int fd
, uint32_t revents
, void *userdata
) {
3028 sd_bus
*bus
= userdata
;
3033 r
= sd_bus_process(bus
, NULL
);
3040 static int time_callback(sd_event_source
*s
, uint64_t usec
, void *userdata
) {
3041 sd_bus
*bus
= userdata
;
3046 r
= sd_bus_process(bus
, NULL
);
3053 static int prepare_callback(sd_event_source
*s
, void *userdata
) {
3054 sd_bus
*bus
= userdata
;
3061 e
= sd_bus_get_events(bus
);
3065 if (bus
->output_fd
!= bus
->input_fd
) {
3067 r
= sd_event_source_set_io_events(bus
->input_io_event_source
, e
& POLLIN
);
3071 r
= sd_event_source_set_io_events(bus
->output_io_event_source
, e
& POLLOUT
);
3075 r
= sd_event_source_set_io_events(bus
->input_io_event_source
, e
);
3080 r
= sd_bus_get_timeout(bus
, &until
);
3086 j
= sd_event_source_set_time(bus
->time_event_source
, until
);
3091 r
= sd_event_source_set_enabled(bus
->time_event_source
, r
> 0);
3098 static int quit_callback(sd_event_source
*event
, void *userdata
) {
3099 sd_bus
*bus
= userdata
;
3109 static int attach_io_events(sd_bus
*bus
) {
3114 if (bus
->input_fd
< 0)
3120 if (!bus
->input_io_event_source
) {
3121 r
= sd_event_add_io(bus
->event
, &bus
->input_io_event_source
, bus
->input_fd
, 0, io_callback
, bus
);
3125 r
= sd_event_source_set_prepare(bus
->input_io_event_source
, prepare_callback
);
3129 r
= sd_event_source_set_priority(bus
->input_io_event_source
, bus
->event_priority
);
3133 r
= sd_event_source_set_description(bus
->input_io_event_source
, "bus-input");
3135 r
= sd_event_source_set_io_fd(bus
->input_io_event_source
, bus
->input_fd
);
3140 if (bus
->output_fd
!= bus
->input_fd
) {
3141 assert(bus
->output_fd
>= 0);
3143 if (!bus
->output_io_event_source
) {
3144 r
= sd_event_add_io(bus
->event
, &bus
->output_io_event_source
, bus
->output_fd
, 0, io_callback
, bus
);
3148 r
= sd_event_source_set_priority(bus
->output_io_event_source
, bus
->event_priority
);
3152 r
= sd_event_source_set_description(bus
->input_io_event_source
, "bus-output");
3154 r
= sd_event_source_set_io_fd(bus
->output_io_event_source
, bus
->output_fd
);
3163 static void detach_io_events(sd_bus
*bus
) {
3166 if (bus
->input_io_event_source
) {
3167 sd_event_source_set_enabled(bus
->input_io_event_source
, SD_EVENT_OFF
);
3168 bus
->input_io_event_source
= sd_event_source_unref(bus
->input_io_event_source
);
3171 if (bus
->output_io_event_source
) {
3172 sd_event_source_set_enabled(bus
->output_io_event_source
, SD_EVENT_OFF
);
3173 bus
->output_io_event_source
= sd_event_source_unref(bus
->output_io_event_source
);
3177 _public_
int sd_bus_attach_event(sd_bus
*bus
, sd_event
*event
, int priority
) {
3180 assert_return(bus
, -EINVAL
);
3181 assert_return(!bus
->event
, -EBUSY
);
3183 assert(!bus
->input_io_event_source
);
3184 assert(!bus
->output_io_event_source
);
3185 assert(!bus
->time_event_source
);
3188 bus
->event
= sd_event_ref(event
);
3190 r
= sd_event_default(&bus
->event
);
3195 bus
->event_priority
= priority
;
3197 r
= sd_event_add_time(bus
->event
, &bus
->time_event_source
, CLOCK_MONOTONIC
, 0, 0, time_callback
, bus
);
3201 r
= sd_event_source_set_priority(bus
->time_event_source
, priority
);
3205 r
= sd_event_source_set_description(bus
->time_event_source
, "bus-time");
3209 r
= sd_event_add_exit(bus
->event
, &bus
->quit_event_source
, quit_callback
, bus
);
3213 r
= sd_event_source_set_description(bus
->quit_event_source
, "bus-exit");
3217 r
= attach_io_events(bus
);
3224 sd_bus_detach_event(bus
);
3228 _public_
int sd_bus_detach_event(sd_bus
*bus
) {
3229 assert_return(bus
, -EINVAL
);
3234 detach_io_events(bus
);
3236 if (bus
->time_event_source
) {
3237 sd_event_source_set_enabled(bus
->time_event_source
, SD_EVENT_OFF
);
3238 bus
->time_event_source
= sd_event_source_unref(bus
->time_event_source
);
3241 if (bus
->quit_event_source
) {
3242 sd_event_source_set_enabled(bus
->quit_event_source
, SD_EVENT_OFF
);
3243 bus
->quit_event_source
= sd_event_source_unref(bus
->quit_event_source
);
3246 bus
->event
= sd_event_unref(bus
->event
);
3250 _public_ sd_event
* sd_bus_get_event(sd_bus
*bus
) {
3251 assert_return(bus
, NULL
);
3256 _public_ sd_bus_message
* sd_bus_get_current_message(sd_bus
*bus
) {
3257 assert_return(bus
, NULL
);
3259 return bus
->current_message
;
3262 _public_ sd_bus_slot
* sd_bus_get_current_slot(sd_bus
*bus
) {
3263 assert_return(bus
, NULL
);
3265 return bus
->current_slot
;
3268 _public_ sd_bus_message_handler_t
sd_bus_get_current_handler(sd_bus
*bus
) {
3269 assert_return(bus
, NULL
);
3271 return bus
->current_handler
;
3274 _public_
void* sd_bus_get_current_userdata(sd_bus
*bus
) {
3275 assert_return(bus
, NULL
);
3277 return bus
->current_userdata
;
3280 static int bus_default(int (*bus_open
)(sd_bus
**), sd_bus
**default_bus
, sd_bus
**ret
) {
3285 assert(default_bus
);
3288 return !!*default_bus
;
3291 *ret
= sd_bus_ref(*default_bus
);
3299 b
->default_bus_ptr
= default_bus
;
3307 _public_
int sd_bus_default_system(sd_bus
**ret
) {
3308 static thread_local sd_bus
*default_system_bus
= NULL
;
3310 return bus_default(sd_bus_open_system
, &default_system_bus
, ret
);
3313 _public_
int sd_bus_default_user(sd_bus
**ret
) {
3314 static thread_local sd_bus
*default_user_bus
= NULL
;
3316 return bus_default(sd_bus_open_user
, &default_user_bus
, ret
);
3319 _public_
int sd_bus_default(sd_bus
**ret
) {
3323 /* Let's try our best to reuse another cached connection. If
3324 * the starter bus type is set, connect via our normal
3325 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3326 * we can share the connection with the user/system default
3329 e
= secure_getenv("DBUS_STARTER_BUS_TYPE");
3331 if (streq(e
, "system"))
3332 return sd_bus_default_system(ret
);
3333 else if (STR_IN_SET(e
, "user", "session"))
3334 return sd_bus_default_user(ret
);
3337 /* No type is specified, so we have not other option than to
3338 * use the starter address if it is set. */
3340 e
= secure_getenv("DBUS_STARTER_ADDRESS");
3342 static thread_local sd_bus
*default_starter_bus
= NULL
;
3344 return bus_default(sd_bus_open
, &default_starter_bus
, ret
);
3347 /* Finally, if nothing is set use the cached connection for
3348 * the right scope */
3350 if (cg_pid_get_owner_uid(0, NULL
) >= 0)
3351 return sd_bus_default_user(ret
);
3353 return sd_bus_default_system(ret
);
3356 _public_
int sd_bus_get_tid(sd_bus
*b
, pid_t
*tid
) {
3357 assert_return(b
, -EINVAL
);
3358 assert_return(tid
, -EINVAL
);
3359 assert_return(!bus_pid_changed(b
), -ECHILD
);
3367 return sd_event_get_tid(b
->event
, tid
);
3372 _public_
int sd_bus_path_encode(const char *prefix
, const char *external_id
, char **ret_path
) {
3373 _cleanup_free_
char *e
= NULL
;
3376 assert_return(object_path_is_valid(prefix
), -EINVAL
);
3377 assert_return(external_id
, -EINVAL
);
3378 assert_return(ret_path
, -EINVAL
);
3380 e
= bus_label_escape(external_id
);
3384 ret
= strjoin(prefix
, "/", e
, NULL
);
3392 _public_
int sd_bus_path_decode(const char *path
, const char *prefix
, char **external_id
) {
3396 assert_return(object_path_is_valid(path
), -EINVAL
);
3397 assert_return(object_path_is_valid(prefix
), -EINVAL
);
3398 assert_return(external_id
, -EINVAL
);
3400 e
= object_path_startswith(path
, prefix
);
3402 *external_id
= NULL
;
3406 ret
= bus_label_unescape(e
);
3414 _public_
int sd_bus_try_close(sd_bus
*bus
) {
3417 assert_return(bus
, -EINVAL
);
3418 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3420 if (!bus
->is_kernel
)
3423 if (!BUS_IS_OPEN(bus
->state
))
3426 if (bus
->rqueue_size
> 0)
3429 if (bus
->wqueue_size
> 0)
3432 r
= bus_kernel_try_close(bus
);
3440 _public_
int sd_bus_get_description(sd_bus
*bus
, const char **description
) {
3441 assert_return(bus
, -EINVAL
);
3442 assert_return(description
, -EINVAL
);
3443 assert_return(bus
->description
, -ENXIO
);
3444 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3446 *description
= bus
->description
;
3450 int bus_get_root_path(sd_bus
*bus
) {
3453 if (bus
->cgroup_root
)
3456 r
= cg_get_root_path(&bus
->cgroup_root
);
3458 bus
->cgroup_root
= strdup("/");
3459 if (!bus
->cgroup_root
)
3468 _public_
int sd_bus_get_scope(sd_bus
*bus
, const char **scope
) {
3471 assert_return(bus
, -EINVAL
);
3472 assert_return(scope
, -EINVAL
);
3473 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3475 if (bus
->is_kernel
) {
3476 _cleanup_free_
char *n
= NULL
;
3479 r
= bus_kernel_get_bus_name(bus
, &n
);
3483 if (streq(n
, "0-system")) {
3488 dash
= strchr(n
, '-');
3489 if (streq_ptr(dash
, "-user")) {
3500 if (bus
->is_system
) {
3508 _public_
int sd_bus_get_address(sd_bus
*bus
, const char **address
) {
3510 assert_return(bus
, -EINVAL
);
3511 assert_return(address
, -EINVAL
);
3512 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3515 *address
= bus
->address
;
3522 _public_
int sd_bus_get_creds_mask(sd_bus
*bus
, uint64_t *mask
) {
3523 assert_return(bus
, -EINVAL
);
3524 assert_return(mask
, -EINVAL
);
3525 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3527 *mask
= bus
->creds_mask
;
3531 _public_
int sd_bus_is_bus_client(sd_bus
*bus
) {
3532 assert_return(bus
, -EINVAL
);
3533 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3535 return bus
->bus_client
;
3538 _public_
int sd_bus_is_server(sd_bus
*bus
) {
3539 assert_return(bus
, -EINVAL
);
3540 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3542 return bus
->is_server
;
3545 _public_
int sd_bus_is_anonymous(sd_bus
*bus
) {
3546 assert_return(bus
, -EINVAL
);
3547 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3549 return bus
->anonymous_auth
;
3552 _public_
int sd_bus_is_trusted(sd_bus
*bus
) {
3553 assert_return(bus
, -EINVAL
);
3554 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3556 return bus
->trusted
;
3559 _public_
int sd_bus_is_monitor(sd_bus
*bus
) {
3560 assert_return(bus
, -EINVAL
);
3561 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3563 return !!(bus
->hello_flags
& KDBUS_HELLO_MONITOR
);