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"
46 #include "bus-container.h"
47 #include "bus-protocol.h"
48 #include "bus-track.h"
51 #define log_debug_bus_message(m) \
53 sd_bus_message *_mm = (m); \
54 log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s", \
55 bus_message_type_to_string(_mm->header->type), \
56 strna(sd_bus_message_get_sender(_mm)), \
57 strna(sd_bus_message_get_destination(_mm)), \
58 strna(sd_bus_message_get_path(_mm)), \
59 strna(sd_bus_message_get_interface(_mm)), \
60 strna(sd_bus_message_get_member(_mm)), \
61 BUS_MESSAGE_COOKIE(_mm), \
63 strna(_mm->error.message)); \
66 static int bus_poll(sd_bus
*bus
, bool need_more
, uint64_t timeout_usec
);
67 static int attach_io_events(sd_bus
*b
);
68 static void detach_io_events(sd_bus
*b
);
70 static void bus_close_fds(sd_bus
*b
) {
75 if (b
->input_fd
!= b
->output_fd
)
76 safe_close(b
->output_fd
);
77 b
->output_fd
= b
->input_fd
= safe_close(b
->input_fd
);
80 static void bus_reset_queues(sd_bus
*b
) {
83 while (b
->rqueue_size
> 0)
84 sd_bus_message_unref(b
->rqueue
[--b
->rqueue_size
]);
86 b
->rqueue
= mfree(b
->rqueue
);
87 b
->rqueue_allocated
= 0;
89 while (b
->wqueue_size
> 0)
90 sd_bus_message_unref(b
->wqueue
[--b
->wqueue_size
]);
92 b
->wqueue
= mfree(b
->wqueue
);
93 b
->wqueue_allocated
= 0;
96 static void bus_free(sd_bus
*b
) {
100 assert(!b
->track_queue
);
102 b
->state
= BUS_CLOSED
;
104 sd_bus_detach_event(b
);
106 while ((s
= b
->slots
)) {
107 /* At this point only floating slots can still be
108 * around, because the non-floating ones keep a
109 * reference to the bus, and we thus couldn't be
110 * destructing right now... We forcibly disconnect the
111 * slots here, so that they still can be referenced by
112 * apps, but are dead. */
115 bus_slot_disconnect(s
);
116 sd_bus_slot_unref(s
);
119 if (b
->default_bus_ptr
)
120 *b
->default_bus_ptr
= NULL
;
125 munmap(b
->kdbus_buffer
, KDBUS_POOL_SIZE
);
129 free(b
->unique_name
);
130 free(b
->auth_buffer
);
135 free(b
->cgroup_root
);
136 free(b
->description
);
139 strv_free(b
->exec_argv
);
141 close_many(b
->fds
, b
->n_fds
);
146 ordered_hashmap_free_free(b
->reply_callbacks
);
147 prioq_free(b
->reply_callbacks_prioq
);
149 assert(b
->match_callbacks
.type
== BUS_MATCH_ROOT
);
150 bus_match_free(&b
->match_callbacks
);
152 hashmap_free_free(b
->vtable_methods
);
153 hashmap_free_free(b
->vtable_properties
);
155 assert(hashmap_isempty(b
->nodes
));
156 hashmap_free(b
->nodes
);
158 bus_kernel_flush_memfd(b
);
160 assert_se(pthread_mutex_destroy(&b
->memfd_cache_mutex
) == 0);
165 _public_
int sd_bus_new(sd_bus
**ret
) {
168 assert_return(ret
, -EINVAL
);
174 r
->n_ref
= REFCNT_INIT
;
175 r
->input_fd
= r
->output_fd
= -1;
176 r
->message_version
= 1;
177 r
->creds_mask
|= SD_BUS_CREDS_WELL_KNOWN_NAMES
|SD_BUS_CREDS_UNIQUE_NAME
;
178 r
->hello_flags
|= KDBUS_HELLO_ACCEPT_FD
;
179 r
->attach_flags
|= KDBUS_ATTACH_NAMES
;
180 r
->original_pid
= getpid();
182 assert_se(pthread_mutex_init(&r
->memfd_cache_mutex
, NULL
) == 0);
184 /* We guarantee that wqueue always has space for at least one
186 if (!GREEDY_REALLOC(r
->wqueue
, r
->wqueue_allocated
, 1)) {
195 _public_
int sd_bus_set_address(sd_bus
*bus
, const char *address
) {
198 assert_return(bus
, -EINVAL
);
199 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
200 assert_return(address
, -EINVAL
);
201 assert_return(!bus_pid_changed(bus
), -ECHILD
);
213 _public_
int sd_bus_set_fd(sd_bus
*bus
, int input_fd
, int output_fd
) {
214 assert_return(bus
, -EINVAL
);
215 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
216 assert_return(input_fd
>= 0, -EINVAL
);
217 assert_return(output_fd
>= 0, -EINVAL
);
218 assert_return(!bus_pid_changed(bus
), -ECHILD
);
220 bus
->input_fd
= input_fd
;
221 bus
->output_fd
= output_fd
;
225 _public_
int sd_bus_set_exec(sd_bus
*bus
, const char *path
, char *const argv
[]) {
228 assert_return(bus
, -EINVAL
);
229 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
230 assert_return(path
, -EINVAL
);
231 assert_return(!strv_isempty(argv
), -EINVAL
);
232 assert_return(!bus_pid_changed(bus
), -ECHILD
);
244 free(bus
->exec_path
);
245 strv_free(bus
->exec_argv
);
253 _public_
int sd_bus_set_bus_client(sd_bus
*bus
, int b
) {
254 assert_return(bus
, -EINVAL
);
255 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
256 assert_return(!bus_pid_changed(bus
), -ECHILD
);
258 bus
->bus_client
= !!b
;
262 _public_
int sd_bus_set_monitor(sd_bus
*bus
, int b
) {
263 assert_return(bus
, -EINVAL
);
264 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
265 assert_return(!bus_pid_changed(bus
), -ECHILD
);
267 SET_FLAG(bus
->hello_flags
, KDBUS_HELLO_MONITOR
, b
);
271 _public_
int sd_bus_negotiate_fds(sd_bus
*bus
, int b
) {
272 assert_return(bus
, -EINVAL
);
273 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
274 assert_return(!bus_pid_changed(bus
), -ECHILD
);
276 SET_FLAG(bus
->hello_flags
, KDBUS_HELLO_ACCEPT_FD
, b
);
280 _public_
int sd_bus_negotiate_timestamp(sd_bus
*bus
, int b
) {
282 assert_return(bus
, -EINVAL
);
283 assert_return(!IN_SET(bus
->state
, BUS_CLOSING
, BUS_CLOSED
), -EPERM
);
284 assert_return(!bus_pid_changed(bus
), -ECHILD
);
286 new_flags
= bus
->attach_flags
;
287 SET_FLAG(new_flags
, KDBUS_ATTACH_TIMESTAMP
, b
);
289 if (bus
->attach_flags
== new_flags
)
292 bus
->attach_flags
= new_flags
;
293 if (bus
->state
!= BUS_UNSET
&& bus
->is_kernel
)
294 bus_kernel_realize_attach_flags(bus
);
299 _public_
int sd_bus_negotiate_creds(sd_bus
*bus
, int b
, uint64_t mask
) {
302 assert_return(bus
, -EINVAL
);
303 assert_return(mask
<= _SD_BUS_CREDS_ALL
, -EINVAL
);
304 assert_return(!IN_SET(bus
->state
, BUS_CLOSING
, BUS_CLOSED
), -EPERM
);
305 assert_return(!bus_pid_changed(bus
), -ECHILD
);
308 bus
->creds_mask
|= mask
;
310 bus
->creds_mask
&= ~mask
;
312 /* The well knowns we need unconditionally, so that matches can work */
313 bus
->creds_mask
|= SD_BUS_CREDS_WELL_KNOWN_NAMES
|SD_BUS_CREDS_UNIQUE_NAME
;
315 /* Make sure we don't lose the timestamp flag */
316 new_flags
= (bus
->attach_flags
& KDBUS_ATTACH_TIMESTAMP
) | attach_flags_to_kdbus(bus
->creds_mask
);
317 if (bus
->attach_flags
== new_flags
)
320 bus
->attach_flags
= new_flags
;
321 if (bus
->state
!= BUS_UNSET
&& bus
->is_kernel
)
322 bus_kernel_realize_attach_flags(bus
);
327 _public_
int sd_bus_set_server(sd_bus
*bus
, int b
, sd_id128_t server_id
) {
328 assert_return(bus
, -EINVAL
);
329 assert_return(b
|| sd_id128_equal(server_id
, SD_ID128_NULL
), -EINVAL
);
330 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
331 assert_return(!bus_pid_changed(bus
), -ECHILD
);
333 bus
->is_server
= !!b
;
334 bus
->server_id
= server_id
;
338 _public_
int sd_bus_set_anonymous(sd_bus
*bus
, int b
) {
339 assert_return(bus
, -EINVAL
);
340 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
341 assert_return(!bus_pid_changed(bus
), -ECHILD
);
343 bus
->anonymous_auth
= !!b
;
347 _public_
int sd_bus_set_trusted(sd_bus
*bus
, int b
) {
348 assert_return(bus
, -EINVAL
);
349 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
350 assert_return(!bus_pid_changed(bus
), -ECHILD
);
356 _public_
int sd_bus_set_description(sd_bus
*bus
, const char *description
) {
357 assert_return(bus
, -EINVAL
);
358 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
359 assert_return(!bus_pid_changed(bus
), -ECHILD
);
361 return free_and_strdup(&bus
->description
, description
);
364 _public_
int sd_bus_set_allow_interactive_authorization(sd_bus
*bus
, int b
) {
365 assert_return(bus
, -EINVAL
);
366 assert_return(!bus_pid_changed(bus
), -ECHILD
);
368 bus
->allow_interactive_authorization
= !!b
;
372 _public_
int sd_bus_get_allow_interactive_authorization(sd_bus
*bus
) {
373 assert_return(bus
, -EINVAL
);
374 assert_return(!bus_pid_changed(bus
), -ECHILD
);
376 return bus
->allow_interactive_authorization
;
379 static int hello_callback(sd_bus_message
*reply
, void *userdata
, sd_bus_error
*error
) {
387 assert(bus
->state
== BUS_HELLO
|| bus
->state
== BUS_CLOSING
);
389 r
= sd_bus_message_get_errno(reply
);
393 r
= sd_bus_message_read(reply
, "s", &s
);
397 if (!service_name_is_valid(s
) || s
[0] != ':')
400 bus
->unique_name
= strdup(s
);
401 if (!bus
->unique_name
)
404 if (bus
->state
== BUS_HELLO
)
405 bus
->state
= BUS_RUNNING
;
410 static int bus_send_hello(sd_bus
*bus
) {
411 _cleanup_bus_message_unref_ sd_bus_message
*m
= NULL
;
416 if (!bus
->bus_client
|| bus
->is_kernel
)
419 r
= sd_bus_message_new_method_call(
422 "org.freedesktop.DBus",
423 "/org/freedesktop/DBus",
424 "org.freedesktop.DBus",
429 return sd_bus_call_async(bus
, NULL
, m
, hello_callback
, NULL
, 0);
432 int bus_start_running(sd_bus
*bus
) {
435 if (bus
->bus_client
&& !bus
->is_kernel
) {
436 bus
->state
= BUS_HELLO
;
440 bus
->state
= BUS_RUNNING
;
444 static int parse_address_key(const char **p
, const char *key
, char **value
) {
445 size_t l
, n
= 0, allocated
= 0;
455 if (strncmp(*p
, key
, l
) != 0)
468 while (*a
!= ';' && *a
!= ',' && *a
!= 0) {
486 c
= (char) ((x
<< 4) | y
);
493 if (!GREEDY_REALLOC(r
, allocated
, n
+ 2))
517 static void skip_address_key(const char **p
) {
521 *p
+= strcspn(*p
, ",");
527 static int parse_unix_address(sd_bus
*b
, const char **p
, char **guid
) {
528 _cleanup_free_
char *path
= NULL
, *abstract
= NULL
;
537 while (**p
!= 0 && **p
!= ';') {
538 r
= parse_address_key(p
, "guid", guid
);
544 r
= parse_address_key(p
, "path", &path
);
550 r
= parse_address_key(p
, "abstract", &abstract
);
559 if (!path
&& !abstract
)
562 if (path
&& abstract
)
567 if (l
> sizeof(b
->sockaddr
.un
.sun_path
))
570 b
->sockaddr
.un
.sun_family
= AF_UNIX
;
571 strncpy(b
->sockaddr
.un
.sun_path
, path
, sizeof(b
->sockaddr
.un
.sun_path
));
572 b
->sockaddr_size
= offsetof(struct sockaddr_un
, sun_path
) + l
;
573 } else if (abstract
) {
574 l
= strlen(abstract
);
575 if (l
> sizeof(b
->sockaddr
.un
.sun_path
) - 1)
578 b
->sockaddr
.un
.sun_family
= AF_UNIX
;
579 b
->sockaddr
.un
.sun_path
[0] = 0;
580 strncpy(b
->sockaddr
.un
.sun_path
+1, abstract
, sizeof(b
->sockaddr
.un
.sun_path
)-1);
581 b
->sockaddr_size
= offsetof(struct sockaddr_un
, sun_path
) + 1 + l
;
587 static int parse_tcp_address(sd_bus
*b
, const char **p
, char **guid
) {
588 _cleanup_free_
char *host
= NULL
, *port
= NULL
, *family
= NULL
;
590 struct addrinfo
*result
, hints
= {
591 .ai_socktype
= SOCK_STREAM
,
592 .ai_flags
= AI_ADDRCONFIG
,
600 while (**p
!= 0 && **p
!= ';') {
601 r
= parse_address_key(p
, "guid", guid
);
607 r
= parse_address_key(p
, "host", &host
);
613 r
= parse_address_key(p
, "port", &port
);
619 r
= parse_address_key(p
, "family", &family
);
632 if (streq(family
, "ipv4"))
633 hints
.ai_family
= AF_INET
;
634 else if (streq(family
, "ipv6"))
635 hints
.ai_family
= AF_INET6
;
640 r
= getaddrinfo(host
, port
, &hints
, &result
);
644 return -EADDRNOTAVAIL
;
646 memcpy(&b
->sockaddr
, result
->ai_addr
, result
->ai_addrlen
);
647 b
->sockaddr_size
= result
->ai_addrlen
;
649 freeaddrinfo(result
);
654 static int parse_exec_address(sd_bus
*b
, const char **p
, char **guid
) {
656 unsigned n_argv
= 0, j
;
658 size_t allocated
= 0;
666 while (**p
!= 0 && **p
!= ';') {
667 r
= parse_address_key(p
, "guid", guid
);
673 r
= parse_address_key(p
, "path", &path
);
679 if (startswith(*p
, "argv")) {
683 ul
= strtoul(*p
+ 4, (char**) p
, 10);
684 if (errno
> 0 || **p
!= '=' || ul
> 256) {
692 if (!GREEDY_REALLOC0(argv
, allocated
, ul
+ 2)) {
700 r
= parse_address_key(p
, NULL
, argv
+ ul
);
715 /* Make sure there are no holes in the array, with the
716 * exception of argv[0] */
717 for (j
= 1; j
< n_argv
; j
++)
723 if (argv
&& argv
[0] == NULL
) {
724 argv
[0] = strdup(path
);
736 for (j
= 0; j
< n_argv
; j
++)
744 static int parse_kernel_address(sd_bus
*b
, const char **p
, char **guid
) {
745 _cleanup_free_
char *path
= NULL
;
753 while (**p
!= 0 && **p
!= ';') {
754 r
= parse_address_key(p
, "guid", guid
);
760 r
= parse_address_key(p
, "path", &path
);
779 static int parse_container_unix_address(sd_bus
*b
, const char **p
, char **guid
) {
780 _cleanup_free_
char *machine
= NULL
, *pid
= NULL
;
788 while (**p
!= 0 && **p
!= ';') {
789 r
= parse_address_key(p
, "guid", guid
);
795 r
= parse_address_key(p
, "machine", &machine
);
801 r
= parse_address_key(p
, "pid", &pid
);
810 if (!machine
== !pid
)
814 if (!machine_name_is_valid(machine
))
818 b
->machine
= machine
;
826 r
= parse_pid(pid
, &b
->nspid
);
832 b
->sockaddr
.un
.sun_family
= AF_UNIX
;
833 strncpy(b
->sockaddr
.un
.sun_path
, "/var/run/dbus/system_bus_socket", sizeof(b
->sockaddr
.un
.sun_path
));
834 b
->sockaddr_size
= offsetof(struct sockaddr_un
, sun_path
) + strlen("/var/run/dbus/system_bus_socket");
839 static int parse_container_kernel_address(sd_bus
*b
, const char **p
, char **guid
) {
840 _cleanup_free_
char *machine
= NULL
, *pid
= NULL
;
848 while (**p
!= 0 && **p
!= ';') {
849 r
= parse_address_key(p
, "guid", guid
);
855 r
= parse_address_key(p
, "machine", &machine
);
861 r
= parse_address_key(p
, "pid", &pid
);
870 if (!machine
== !pid
)
874 if (!machine_name_is_valid(machine
))
878 b
->machine
= machine
;
886 r
= parse_pid(pid
, &b
->nspid
);
892 r
= free_and_strdup(&b
->kernel
, "/sys/fs/kdbus/0-system/bus");
899 static void bus_reset_parsed_address(sd_bus
*b
) {
903 b
->sockaddr_size
= 0;
904 b
->exec_argv
= strv_free(b
->exec_argv
);
905 b
->exec_path
= mfree(b
->exec_path
);
906 b
->server_id
= SD_ID128_NULL
;
907 b
->kernel
= mfree(b
->kernel
);
908 b
->machine
= mfree(b
->machine
);
912 static int bus_parse_next_address(sd_bus
*b
) {
913 _cleanup_free_
char *guid
= NULL
;
921 if (b
->address
[b
->address_index
] == 0)
924 bus_reset_parsed_address(b
);
926 a
= b
->address
+ b
->address_index
;
935 if (startswith(a
, "unix:")) {
938 r
= parse_unix_address(b
, &a
, &guid
);
943 } else if (startswith(a
, "tcp:")) {
946 r
= parse_tcp_address(b
, &a
, &guid
);
952 } else if (startswith(a
, "unixexec:")) {
955 r
= parse_exec_address(b
, &a
, &guid
);
961 } else if (startswith(a
, "kernel:")) {
964 r
= parse_kernel_address(b
, &a
, &guid
);
969 } else if (startswith(a
, "x-machine-unix:")) {
972 r
= parse_container_unix_address(b
, &a
, &guid
);
977 } else if (startswith(a
, "x-machine-kernel:")) {
980 r
= parse_container_kernel_address(b
, &a
, &guid
);
993 r
= sd_id128_from_string(guid
, &b
->server_id
);
998 b
->address_index
= a
- b
->address
;
1002 static int bus_start_address(sd_bus
*b
) {
1008 bool skipped
= false;
1013 r
= bus_socket_exec(b
);
1014 else if ((b
->nspid
> 0 || b
->machine
) && b
->kernel
)
1015 r
= bus_container_connect_kernel(b
);
1016 else if ((b
->nspid
> 0 || b
->machine
) && b
->sockaddr
.sa
.sa_family
!= AF_UNSPEC
)
1017 r
= bus_container_connect_socket(b
);
1019 r
= bus_kernel_connect(b
);
1020 else if (b
->sockaddr
.sa
.sa_family
!= AF_UNSPEC
)
1021 r
= bus_socket_connect(b
);
1027 r
= attach_io_events(b
);
1032 b
->last_connect_error
= -r
;
1035 r
= bus_parse_next_address(b
);
1039 return b
->last_connect_error
? -b
->last_connect_error
: -ECONNREFUSED
;
1043 int bus_next_address(sd_bus
*b
) {
1046 bus_reset_parsed_address(b
);
1047 return bus_start_address(b
);
1050 static int bus_start_fd(sd_bus
*b
) {
1055 assert(b
->input_fd
>= 0);
1056 assert(b
->output_fd
>= 0);
1058 r
= fd_nonblock(b
->input_fd
, true);
1062 r
= fd_cloexec(b
->input_fd
, true);
1066 if (b
->input_fd
!= b
->output_fd
) {
1067 r
= fd_nonblock(b
->output_fd
, true);
1071 r
= fd_cloexec(b
->output_fd
, true);
1076 if (fstat(b
->input_fd
, &st
) < 0)
1079 if (S_ISCHR(b
->input_fd
))
1080 return bus_kernel_take_fd(b
);
1082 return bus_socket_take_fd(b
);
1085 _public_
int sd_bus_start(sd_bus
*bus
) {
1088 assert_return(bus
, -EINVAL
);
1089 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
1090 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1092 bus
->state
= BUS_OPENING
;
1094 if (bus
->is_server
&& bus
->bus_client
)
1097 if (bus
->input_fd
>= 0)
1098 r
= bus_start_fd(bus
);
1099 else if (bus
->address
|| bus
->sockaddr
.sa
.sa_family
!= AF_UNSPEC
|| bus
->exec_path
|| bus
->kernel
|| bus
->machine
)
1100 r
= bus_start_address(bus
);
1109 return bus_send_hello(bus
);
1112 _public_
int sd_bus_open(sd_bus
**ret
) {
1117 assert_return(ret
, -EINVAL
);
1119 /* Let's connect to the starter bus if it is set, and
1120 * otherwise to the bus that is appropropriate for the scope
1121 * we are running in */
1123 e
= secure_getenv("DBUS_STARTER_BUS_TYPE");
1125 if (streq(e
, "system"))
1126 return sd_bus_open_system(ret
);
1127 else if (STR_IN_SET(e
, "session", "user"))
1128 return sd_bus_open_user(ret
);
1131 e
= secure_getenv("DBUS_STARTER_ADDRESS");
1133 if (cg_pid_get_owner_uid(0, NULL
) >= 0)
1134 return sd_bus_open_user(ret
);
1136 return sd_bus_open_system(ret
);
1143 r
= sd_bus_set_address(b
, e
);
1147 b
->bus_client
= true;
1149 /* We don't know whether the bus is trusted or not, so better
1150 * be safe, and authenticate everything */
1152 b
->attach_flags
|= KDBUS_ATTACH_CAPS
| KDBUS_ATTACH_CREDS
;
1153 b
->creds_mask
|= SD_BUS_CREDS_UID
| SD_BUS_CREDS_EUID
| SD_BUS_CREDS_EFFECTIVE_CAPS
;
1155 r
= sd_bus_start(b
);
1167 int bus_set_address_system(sd_bus
*b
) {
1171 e
= secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1173 return sd_bus_set_address(b
, e
);
1175 if (is_kdbus_available())
1176 return sd_bus_set_address(b
, KERNEL_SYSTEM_BUS_ADDRESS
);
1178 return sd_bus_set_address(b
, UNIX_SYSTEM_BUS_ADDRESS
);
1181 _public_
int sd_bus_open_system(sd_bus
**ret
) {
1185 assert_return(ret
, -EINVAL
);
1191 r
= bus_set_address_system(b
);
1195 b
->bus_client
= true;
1196 b
->is_system
= true;
1198 /* Let's do per-method access control on the system bus. We
1199 * need the caller's UID and capability set for that. */
1201 b
->attach_flags
|= KDBUS_ATTACH_CAPS
| KDBUS_ATTACH_CREDS
;
1202 b
->creds_mask
|= SD_BUS_CREDS_UID
| SD_BUS_CREDS_EUID
| SD_BUS_CREDS_EFFECTIVE_CAPS
;
1204 r
= sd_bus_start(b
);
1216 int bus_set_address_user(sd_bus
*b
) {
1221 e
= secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1223 return sd_bus_set_address(b
, e
);
1225 e
= secure_getenv("XDG_RUNTIME_DIR");
1226 if (is_kdbus_available())
1227 (void) asprintf(&b
->address
, KERNEL_USER_BUS_ADDRESS_FMT
, getuid());
1229 _cleanup_free_
char *ee
= NULL
;
1231 ee
= bus_address_escape(e
);
1235 (void) asprintf(&b
->address
, UNIX_USER_BUS_ADDRESS_FMT
, ee
);
1244 _public_
int sd_bus_open_user(sd_bus
**ret
) {
1248 assert_return(ret
, -EINVAL
);
1254 r
= bus_set_address_user(b
);
1258 b
->bus_client
= true;
1261 /* We don't do any per-method access control on the user
1265 r
= sd_bus_start(b
);
1277 int bus_set_address_system_remote(sd_bus
*b
, const char *host
) {
1278 _cleanup_free_
char *e
= NULL
;
1279 char *m
= NULL
, *c
= NULL
;
1284 /* Let's see if we shall enter some container */
1285 m
= strchr(host
, ':');
1289 /* Let's make sure this is not a port of some kind,
1290 * and is a valid machine name. */
1291 if (!in_charset(m
, "0123456789") && machine_name_is_valid(m
)) {
1294 /* Cut out the host part */
1295 t
= strndupa(host
, m
- host
- 1);
1296 e
= bus_address_escape(t
);
1300 c
= strjoina(",argv4=--machine=", m
);
1305 e
= bus_address_escape(host
);
1310 b
->address
= strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e
, ",argv3=systemd-stdio-bridge", c
, NULL
);
1317 _public_
int sd_bus_open_system_remote(sd_bus
**ret
, const char *host
) {
1321 assert_return(host
, -EINVAL
);
1322 assert_return(ret
, -EINVAL
);
1324 r
= sd_bus_new(&bus
);
1328 r
= bus_set_address_system_remote(bus
, host
);
1332 bus
->bus_client
= true;
1333 bus
->trusted
= false;
1334 bus
->is_system
= true;
1336 r
= sd_bus_start(bus
);
1348 int bus_set_address_system_machine(sd_bus
*b
, const char *machine
) {
1349 _cleanup_free_
char *e
= NULL
;
1354 e
= bus_address_escape(machine
);
1358 b
->address
= strjoin("x-machine-kernel:machine=", e
, ";x-machine-unix:machine=", e
, NULL
);
1365 _public_
int sd_bus_open_system_machine(sd_bus
**ret
, const char *machine
) {
1369 assert_return(machine
, -EINVAL
);
1370 assert_return(ret
, -EINVAL
);
1371 assert_return(machine_name_is_valid(machine
), -EINVAL
);
1373 r
= sd_bus_new(&bus
);
1377 r
= bus_set_address_system_machine(bus
, machine
);
1381 bus
->bus_client
= true;
1382 bus
->trusted
= false;
1383 bus
->is_system
= true;
1385 r
= sd_bus_start(bus
);
1397 _public_
void sd_bus_close(sd_bus
*bus
) {
1401 if (bus
->state
== BUS_CLOSED
)
1403 if (bus_pid_changed(bus
))
1406 bus
->state
= BUS_CLOSED
;
1408 sd_bus_detach_event(bus
);
1410 /* Drop all queued messages so that they drop references to
1411 * the bus object and the bus may be freed */
1412 bus_reset_queues(bus
);
1414 if (!bus
->is_kernel
)
1417 /* We'll leave the fd open in case this is a kernel bus, since
1418 * there might still be memblocks around that reference this
1419 * bus, and they might need to invoke the KDBUS_CMD_FREE
1420 * ioctl on the fd when they are freed. */
1423 _public_ sd_bus
* sd_bus_flush_close_unref(sd_bus
*bus
) {
1431 return sd_bus_unref(bus
);
1434 static void bus_enter_closing(sd_bus
*bus
) {
1437 if (bus
->state
!= BUS_OPENING
&&
1438 bus
->state
!= BUS_AUTHENTICATING
&&
1439 bus
->state
!= BUS_HELLO
&&
1440 bus
->state
!= BUS_RUNNING
)
1443 bus
->state
= BUS_CLOSING
;
1446 _public_ sd_bus
*sd_bus_ref(sd_bus
*bus
) {
1447 assert_return(bus
, NULL
);
1449 assert_se(REFCNT_INC(bus
->n_ref
) >= 2);
1454 _public_ sd_bus
*sd_bus_unref(sd_bus
*bus
) {
1460 i
= REFCNT_DEC(bus
->n_ref
);
1468 _public_
int sd_bus_is_open(sd_bus
*bus
) {
1470 assert_return(bus
, -EINVAL
);
1471 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1473 return BUS_IS_OPEN(bus
->state
);
1476 _public_
int sd_bus_can_send(sd_bus
*bus
, char type
) {
1479 assert_return(bus
, -EINVAL
);
1480 assert_return(bus
->state
!= BUS_UNSET
, -ENOTCONN
);
1481 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1483 if (bus
->hello_flags
& KDBUS_HELLO_MONITOR
)
1486 if (type
== SD_BUS_TYPE_UNIX_FD
) {
1487 if (!(bus
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
))
1490 r
= bus_ensure_running(bus
);
1494 return bus
->can_fds
;
1497 return bus_type_is_valid(type
);
1500 _public_
int sd_bus_get_bus_id(sd_bus
*bus
, sd_id128_t
*id
) {
1503 assert_return(bus
, -EINVAL
);
1504 assert_return(id
, -EINVAL
);
1505 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1507 r
= bus_ensure_running(bus
);
1511 *id
= bus
->server_id
;
1515 static int bus_seal_message(sd_bus
*b
, sd_bus_message
*m
, usec_t timeout
) {
1520 /* If we copy the same message to multiple
1521 * destinations, avoid using the same cookie
1523 b
->cookie
= MAX(b
->cookie
, BUS_MESSAGE_COOKIE(m
));
1528 timeout
= BUS_DEFAULT_TIMEOUT
;
1530 return bus_message_seal(m
, ++b
->cookie
, timeout
);
1533 static int bus_remarshal_message(sd_bus
*b
, sd_bus_message
**m
) {
1534 bool remarshal
= false;
1538 /* wrong packet version */
1539 if (b
->message_version
!= 0 && b
->message_version
!= (*m
)->header
->version
)
1542 /* wrong packet endianness */
1543 if (b
->message_endian
!= 0 && b
->message_endian
!= (*m
)->header
->endian
)
1546 /* TODO: kdbus-messages received from the kernel contain data which is
1547 * not allowed to be passed to KDBUS_CMD_SEND. Therefore, we have to
1548 * force remarshaling of the message. Technically, we could just
1549 * recreate the kdbus message, but that is non-trivial as other parts of
1550 * the message refer to m->kdbus already. This should be fixed! */
1551 if ((*m
)->kdbus
&& (*m
)->release_kdbus
)
1554 return remarshal
? bus_message_remarshal(b
, m
) : 0;
1557 int bus_seal_synthetic_message(sd_bus
*b
, sd_bus_message
*m
) {
1561 /* Fake some timestamps, if they were requested, and not
1562 * already initialized */
1563 if (b
->attach_flags
& KDBUS_ATTACH_TIMESTAMP
) {
1564 if (m
->realtime
<= 0)
1565 m
->realtime
= now(CLOCK_REALTIME
);
1567 if (m
->monotonic
<= 0)
1568 m
->monotonic
= now(CLOCK_MONOTONIC
);
1571 /* The bus specification says the serial number cannot be 0,
1572 * hence let's fill something in for synthetic messages. Since
1573 * synthetic messages might have a fake sender and we don't
1574 * want to interfere with the real sender's serial numbers we
1575 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1576 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1577 * even though kdbus can do 64bit. */
1578 return bus_message_seal(m
, 0xFFFFFFFFULL
, 0);
1581 static int bus_write_message(sd_bus
*bus
, sd_bus_message
*m
, bool hint_sync_call
, size_t *idx
) {
1588 r
= bus_kernel_write_message(bus
, m
, hint_sync_call
);
1590 r
= bus_socket_write_message(bus
, m
, idx
);
1595 if (bus
->is_kernel
|| *idx
>= BUS_MESSAGE_SIZE(m
))
1596 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64
" reply_cookie=%" PRIu64
" error=%s",
1597 bus_message_type_to_string(m
->header
->type
),
1598 strna(sd_bus_message_get_sender(m
)),
1599 strna(sd_bus_message_get_destination(m
)),
1600 strna(sd_bus_message_get_path(m
)),
1601 strna(sd_bus_message_get_interface(m
)),
1602 strna(sd_bus_message_get_member(m
)),
1603 BUS_MESSAGE_COOKIE(m
),
1605 strna(m
->error
.message
));
1610 static int dispatch_wqueue(sd_bus
*bus
) {
1614 assert(bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
);
1616 while (bus
->wqueue_size
> 0) {
1618 r
= bus_write_message(bus
, bus
->wqueue
[0], false, &bus
->windex
);
1622 /* Didn't do anything this time */
1624 else if (bus
->is_kernel
|| bus
->windex
>= BUS_MESSAGE_SIZE(bus
->wqueue
[0])) {
1625 /* Fully written. Let's drop the entry from
1628 * This isn't particularly optimized, but
1629 * well, this is supposed to be our worst-case
1630 * buffer only, and the socket buffer is
1631 * supposed to be our primary buffer, and if
1632 * it got full, then all bets are off
1635 bus
->wqueue_size
--;
1636 sd_bus_message_unref(bus
->wqueue
[0]);
1637 memmove(bus
->wqueue
, bus
->wqueue
+ 1, sizeof(sd_bus_message
*) * bus
->wqueue_size
);
1647 static int bus_read_message(sd_bus
*bus
, bool hint_priority
, int64_t priority
) {
1651 return bus_kernel_read_message(bus
, hint_priority
, priority
);
1653 return bus_socket_read_message(bus
);
1656 int bus_rqueue_make_room(sd_bus
*bus
) {
1659 if (bus
->rqueue_size
>= BUS_RQUEUE_MAX
)
1662 if (!GREEDY_REALLOC(bus
->rqueue
, bus
->rqueue_allocated
, bus
->rqueue_size
+ 1))
1668 static int dispatch_rqueue(sd_bus
*bus
, bool hint_priority
, int64_t priority
, sd_bus_message
**m
) {
1673 assert(bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
);
1675 /* Note that the priority logic is only available on kdbus,
1676 * where the rqueue is unused. We check the rqueue here
1677 * anyway, because it's simple... */
1680 if (bus
->rqueue_size
> 0) {
1681 /* Dispatch a queued message */
1683 *m
= bus
->rqueue
[0];
1684 bus
->rqueue_size
--;
1685 memmove(bus
->rqueue
, bus
->rqueue
+ 1, sizeof(sd_bus_message
*) * bus
->rqueue_size
);
1689 /* Try to read a new message */
1690 r
= bus_read_message(bus
, hint_priority
, priority
);
1700 static int bus_send_internal(sd_bus
*bus
, sd_bus_message
*_m
, uint64_t *cookie
, bool hint_sync_call
) {
1701 _cleanup_bus_message_unref_ sd_bus_message
*m
= sd_bus_message_ref(_m
);
1704 assert_return(m
, -EINVAL
);
1709 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1710 assert_return(!bus
->is_kernel
|| !(bus
->hello_flags
& KDBUS_HELLO_MONITOR
), -EROFS
);
1712 if (!BUS_IS_OPEN(bus
->state
))
1716 r
= sd_bus_can_send(bus
, SD_BUS_TYPE_UNIX_FD
);
1723 /* If the cookie number isn't kept, then we know that no reply
1725 if (!cookie
&& !m
->sealed
)
1726 m
->header
->flags
|= BUS_MESSAGE_NO_REPLY_EXPECTED
;
1728 r
= bus_seal_message(bus
, m
, 0);
1732 /* Remarshall if we have to. This will possibly unref the
1733 * message and place a replacement in m */
1734 r
= bus_remarshal_message(bus
, &m
);
1738 /* If this is a reply and no reply was requested, then let's
1739 * suppress this, if we can */
1743 if ((bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
) && bus
->wqueue_size
<= 0) {
1746 r
= bus_write_message(bus
, m
, hint_sync_call
, &idx
);
1748 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
1749 bus_enter_closing(bus
);
1756 if (!bus
->is_kernel
&& idx
< BUS_MESSAGE_SIZE(m
)) {
1757 /* Wasn't fully written. So let's remember how
1758 * much was written. Note that the first entry
1759 * of the wqueue array is always allocated so
1760 * that we always can remember how much was
1762 bus
->wqueue
[0] = sd_bus_message_ref(m
);
1763 bus
->wqueue_size
= 1;
1768 /* Just append it to the queue. */
1770 if (bus
->wqueue_size
>= BUS_WQUEUE_MAX
)
1773 if (!GREEDY_REALLOC(bus
->wqueue
, bus
->wqueue_allocated
, bus
->wqueue_size
+ 1))
1776 bus
->wqueue
[bus
->wqueue_size
++] = sd_bus_message_ref(m
);
1781 *cookie
= BUS_MESSAGE_COOKIE(m
);
1786 _public_
int sd_bus_send(sd_bus
*bus
, sd_bus_message
*m
, uint64_t *cookie
) {
1787 return bus_send_internal(bus
, m
, cookie
, false);
1790 _public_
int sd_bus_send_to(sd_bus
*bus
, sd_bus_message
*m
, const char *destination
, uint64_t *cookie
) {
1793 assert_return(m
, -EINVAL
);
1798 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1800 if (!BUS_IS_OPEN(bus
->state
))
1803 if (!streq_ptr(m
->destination
, destination
)) {
1808 r
= sd_bus_message_set_destination(m
, destination
);
1813 return sd_bus_send(bus
, m
, cookie
);
1816 static usec_t
calc_elapse(uint64_t usec
) {
1817 if (usec
== (uint64_t) -1)
1820 return now(CLOCK_MONOTONIC
) + usec
;
1823 static int timeout_compare(const void *a
, const void *b
) {
1824 const struct reply_callback
*x
= a
, *y
= b
;
1826 if (x
->timeout
!= 0 && y
->timeout
== 0)
1829 if (x
->timeout
== 0 && y
->timeout
!= 0)
1832 if (x
->timeout
< y
->timeout
)
1835 if (x
->timeout
> y
->timeout
)
1841 _public_
int sd_bus_call_async(
1845 sd_bus_message_handler_t callback
,
1849 _cleanup_bus_message_unref_ sd_bus_message
*m
= sd_bus_message_ref(_m
);
1850 _cleanup_bus_slot_unref_ sd_bus_slot
*s
= NULL
;
1853 assert_return(m
, -EINVAL
);
1854 assert_return(m
->header
->type
== SD_BUS_MESSAGE_METHOD_CALL
, -EINVAL
);
1855 assert_return(!(m
->header
->flags
& BUS_MESSAGE_NO_REPLY_EXPECTED
), -EINVAL
);
1856 assert_return(callback
, -EINVAL
);
1861 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1862 assert_return(!bus
->is_kernel
|| !(bus
->hello_flags
& KDBUS_HELLO_MONITOR
), -EROFS
);
1864 if (!BUS_IS_OPEN(bus
->state
))
1867 r
= ordered_hashmap_ensure_allocated(&bus
->reply_callbacks
, &uint64_hash_ops
);
1871 r
= prioq_ensure_allocated(&bus
->reply_callbacks_prioq
, timeout_compare
);
1875 r
= bus_seal_message(bus
, m
, usec
);
1879 r
= bus_remarshal_message(bus
, &m
);
1883 s
= bus_slot_allocate(bus
, !slot
, BUS_REPLY_CALLBACK
, sizeof(struct reply_callback
), userdata
);
1887 s
->reply_callback
.callback
= callback
;
1889 s
->reply_callback
.cookie
= BUS_MESSAGE_COOKIE(m
);
1890 r
= ordered_hashmap_put(bus
->reply_callbacks
, &s
->reply_callback
.cookie
, &s
->reply_callback
);
1892 s
->reply_callback
.cookie
= 0;
1896 s
->reply_callback
.timeout
= calc_elapse(m
->timeout
);
1897 if (s
->reply_callback
.timeout
!= 0) {
1898 r
= prioq_put(bus
->reply_callbacks_prioq
, &s
->reply_callback
, &s
->reply_callback
.prioq_idx
);
1900 s
->reply_callback
.timeout
= 0;
1905 r
= sd_bus_send(bus
, m
, &s
->reply_callback
.cookie
);
1916 int bus_ensure_running(sd_bus
*bus
) {
1921 if (bus
->state
== BUS_UNSET
|| bus
->state
== BUS_CLOSED
|| bus
->state
== BUS_CLOSING
)
1923 if (bus
->state
== BUS_RUNNING
)
1927 r
= sd_bus_process(bus
, NULL
);
1930 if (bus
->state
== BUS_RUNNING
)
1935 r
= sd_bus_wait(bus
, (uint64_t) -1);
1941 _public_
int sd_bus_call(
1945 sd_bus_error
*error
,
1946 sd_bus_message
**reply
) {
1948 _cleanup_bus_message_unref_ sd_bus_message
*m
= sd_bus_message_ref(_m
);
1954 bus_assert_return(m
, -EINVAL
, error
);
1955 bus_assert_return(m
->header
->type
== SD_BUS_MESSAGE_METHOD_CALL
, -EINVAL
, error
);
1956 bus_assert_return(!(m
->header
->flags
& BUS_MESSAGE_NO_REPLY_EXPECTED
), -EINVAL
, error
);
1957 bus_assert_return(!bus_error_is_dirty(error
), -EINVAL
, error
);
1962 bus_assert_return(!bus_pid_changed(bus
), -ECHILD
, error
);
1963 bus_assert_return(!bus
->is_kernel
|| !(bus
->hello_flags
& KDBUS_HELLO_MONITOR
), -EROFS
, error
);
1965 if (!BUS_IS_OPEN(bus
->state
)) {
1970 r
= bus_ensure_running(bus
);
1974 i
= bus
->rqueue_size
;
1976 r
= bus_seal_message(bus
, m
, usec
);
1980 r
= bus_remarshal_message(bus
, &m
);
1984 r
= bus_send_internal(bus
, m
, &cookie
, true);
1988 timeout
= calc_elapse(m
->timeout
);
1993 while (i
< bus
->rqueue_size
) {
1994 sd_bus_message
*incoming
= NULL
;
1996 incoming
= bus
->rqueue
[i
];
1998 if (incoming
->reply_cookie
== cookie
) {
1999 /* Found a match! */
2001 memmove(bus
->rqueue
+ i
, bus
->rqueue
+ i
+ 1, sizeof(sd_bus_message
*) * (bus
->rqueue_size
- i
- 1));
2003 log_debug_bus_message(incoming
);
2005 if (incoming
->header
->type
== SD_BUS_MESSAGE_METHOD_RETURN
) {
2007 if (incoming
->n_fds
<= 0 || (bus
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
)) {
2011 sd_bus_message_unref(incoming
);
2016 r
= sd_bus_error_setf(error
, SD_BUS_ERROR_INCONSISTENT_MESSAGE
, "Reply message contained file descriptors which I couldn't accept. Sorry.");
2017 sd_bus_message_unref(incoming
);
2020 } else if (incoming
->header
->type
== SD_BUS_MESSAGE_METHOD_ERROR
) {
2021 r
= sd_bus_error_copy(error
, &incoming
->error
);
2022 sd_bus_message_unref(incoming
);
2029 } else if (BUS_MESSAGE_COOKIE(incoming
) == cookie
&&
2032 streq(bus
->unique_name
, incoming
->sender
)) {
2034 memmove(bus
->rqueue
+ i
, bus
->rqueue
+ i
+ 1, sizeof(sd_bus_message
*) * (bus
->rqueue_size
- i
- 1));
2037 /* Our own message? Somebody is trying
2038 * to send its own client a message,
2039 * let's not dead-lock, let's fail
2042 sd_bus_message_unref(incoming
);
2047 /* Try to read more, right-away */
2051 r
= bus_read_message(bus
, false, 0);
2053 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2054 bus_enter_closing(bus
);
2066 n
= now(CLOCK_MONOTONIC
);
2074 left
= (uint64_t) -1;
2076 r
= bus_poll(bus
, true, left
);
2084 r
= dispatch_wqueue(bus
);
2086 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2087 bus_enter_closing(bus
);
2096 return sd_bus_error_set_errno(error
, r
);
2099 _public_
int sd_bus_get_fd(sd_bus
*bus
) {
2101 assert_return(bus
, -EINVAL
);
2102 assert_return(bus
->input_fd
== bus
->output_fd
, -EPERM
);
2103 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2105 return bus
->input_fd
;
2108 _public_
int sd_bus_get_events(sd_bus
*bus
) {
2111 assert_return(bus
, -EINVAL
);
2112 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2114 if (!BUS_IS_OPEN(bus
->state
) && bus
->state
!= BUS_CLOSING
)
2117 if (bus
->state
== BUS_OPENING
)
2119 else if (bus
->state
== BUS_AUTHENTICATING
) {
2121 if (bus_socket_auth_needs_write(bus
))
2126 } else if (bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
) {
2127 if (bus
->rqueue_size
<= 0)
2129 if (bus
->wqueue_size
> 0)
2136 _public_
int sd_bus_get_timeout(sd_bus
*bus
, uint64_t *timeout_usec
) {
2137 struct reply_callback
*c
;
2139 assert_return(bus
, -EINVAL
);
2140 assert_return(timeout_usec
, -EINVAL
);
2141 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2143 if (!BUS_IS_OPEN(bus
->state
) && bus
->state
!= BUS_CLOSING
)
2146 if (bus
->track_queue
) {
2151 if (bus
->state
== BUS_CLOSING
) {
2156 if (bus
->state
== BUS_AUTHENTICATING
) {
2157 *timeout_usec
= bus
->auth_timeout
;
2161 if (bus
->state
!= BUS_RUNNING
&& bus
->state
!= BUS_HELLO
) {
2162 *timeout_usec
= (uint64_t) -1;
2166 if (bus
->rqueue_size
> 0) {
2171 c
= prioq_peek(bus
->reply_callbacks_prioq
);
2173 *timeout_usec
= (uint64_t) -1;
2177 if (c
->timeout
== 0) {
2178 *timeout_usec
= (uint64_t) -1;
2182 *timeout_usec
= c
->timeout
;
2186 static int process_timeout(sd_bus
*bus
) {
2187 _cleanup_bus_error_free_ sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2188 _cleanup_bus_message_unref_ sd_bus_message
* m
= NULL
;
2189 struct reply_callback
*c
;
2196 c
= prioq_peek(bus
->reply_callbacks_prioq
);
2200 n
= now(CLOCK_MONOTONIC
);
2204 r
= bus_message_new_synthetic_error(
2207 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY
, "Method call timed out"),
2212 r
= bus_seal_synthetic_message(bus
, m
);
2216 assert_se(prioq_pop(bus
->reply_callbacks_prioq
) == c
);
2219 ordered_hashmap_remove(bus
->reply_callbacks
, &c
->cookie
);
2222 slot
= container_of(c
, sd_bus_slot
, reply_callback
);
2224 bus
->iteration_counter
++;
2226 bus
->current_message
= m
;
2227 bus
->current_slot
= sd_bus_slot_ref(slot
);
2228 bus
->current_handler
= c
->callback
;
2229 bus
->current_userdata
= slot
->userdata
;
2230 r
= c
->callback(m
, slot
->userdata
, &error_buffer
);
2231 bus
->current_userdata
= NULL
;
2232 bus
->current_handler
= NULL
;
2233 bus
->current_slot
= NULL
;
2234 bus
->current_message
= NULL
;
2236 if (slot
->floating
) {
2237 bus_slot_disconnect(slot
);
2238 sd_bus_slot_unref(slot
);
2241 sd_bus_slot_unref(slot
);
2243 return bus_maybe_reply_error(m
, r
, &error_buffer
);
2246 static int process_hello(sd_bus
*bus
, sd_bus_message
*m
) {
2250 if (bus
->state
!= BUS_HELLO
)
2253 /* Let's make sure the first message on the bus is the HELLO
2254 * reply. But note that we don't actually parse the message
2255 * here (we leave that to the usual handling), we just verify
2256 * we don't let any earlier msg through. */
2258 if (m
->header
->type
!= SD_BUS_MESSAGE_METHOD_RETURN
&&
2259 m
->header
->type
!= SD_BUS_MESSAGE_METHOD_ERROR
)
2262 if (m
->reply_cookie
!= 1)
2268 static int process_reply(sd_bus
*bus
, sd_bus_message
*m
) {
2269 _cleanup_bus_message_unref_ sd_bus_message
*synthetic_reply
= NULL
;
2270 _cleanup_bus_error_free_ sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2271 struct reply_callback
*c
;
2278 if (m
->header
->type
!= SD_BUS_MESSAGE_METHOD_RETURN
&&
2279 m
->header
->type
!= SD_BUS_MESSAGE_METHOD_ERROR
)
2282 if (bus
->is_kernel
&& (bus
->hello_flags
& KDBUS_HELLO_MONITOR
))
2285 if (m
->destination
&& bus
->unique_name
&& !streq_ptr(m
->destination
, bus
->unique_name
))
2288 c
= ordered_hashmap_remove(bus
->reply_callbacks
, &m
->reply_cookie
);
2294 slot
= container_of(c
, sd_bus_slot
, reply_callback
);
2296 if (m
->n_fds
> 0 && !(bus
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
)) {
2298 /* If the reply contained a file descriptor which we
2299 * didn't want we pass an error instead. */
2301 r
= bus_message_new_synthetic_error(
2304 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE
, "Reply message contained file descriptor"),
2309 /* Copy over original timestamp */
2310 synthetic_reply
->realtime
= m
->realtime
;
2311 synthetic_reply
->monotonic
= m
->monotonic
;
2312 synthetic_reply
->seqnum
= m
->seqnum
;
2314 r
= bus_seal_synthetic_message(bus
, synthetic_reply
);
2318 m
= synthetic_reply
;
2320 r
= sd_bus_message_rewind(m
, true);
2325 if (c
->timeout
!= 0) {
2326 prioq_remove(bus
->reply_callbacks_prioq
, c
, &c
->prioq_idx
);
2330 bus
->current_slot
= sd_bus_slot_ref(slot
);
2331 bus
->current_handler
= c
->callback
;
2332 bus
->current_userdata
= slot
->userdata
;
2333 r
= c
->callback(m
, slot
->userdata
, &error_buffer
);
2334 bus
->current_userdata
= NULL
;
2335 bus
->current_handler
= NULL
;
2336 bus
->current_slot
= NULL
;
2338 if (slot
->floating
) {
2339 bus_slot_disconnect(slot
);
2340 sd_bus_slot_unref(slot
);
2343 sd_bus_slot_unref(slot
);
2345 return bus_maybe_reply_error(m
, r
, &error_buffer
);
2348 static int process_filter(sd_bus
*bus
, sd_bus_message
*m
) {
2349 _cleanup_bus_error_free_ sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2350 struct filter_callback
*l
;
2357 bus
->filter_callbacks_modified
= false;
2359 LIST_FOREACH(callbacks
, l
, bus
->filter_callbacks
) {
2362 if (bus
->filter_callbacks_modified
)
2365 /* Don't run this more than once per iteration */
2366 if (l
->last_iteration
== bus
->iteration_counter
)
2369 l
->last_iteration
= bus
->iteration_counter
;
2371 r
= sd_bus_message_rewind(m
, true);
2375 slot
= container_of(l
, sd_bus_slot
, filter_callback
);
2377 bus
->current_slot
= sd_bus_slot_ref(slot
);
2378 bus
->current_handler
= l
->callback
;
2379 bus
->current_userdata
= slot
->userdata
;
2380 r
= l
->callback(m
, slot
->userdata
, &error_buffer
);
2381 bus
->current_userdata
= NULL
;
2382 bus
->current_handler
= NULL
;
2383 bus
->current_slot
= sd_bus_slot_unref(slot
);
2385 r
= bus_maybe_reply_error(m
, r
, &error_buffer
);
2391 } while (bus
->filter_callbacks_modified
);
2396 static int process_match(sd_bus
*bus
, sd_bus_message
*m
) {
2403 bus
->match_callbacks_modified
= false;
2405 r
= bus_match_run(bus
, &bus
->match_callbacks
, m
);
2409 } while (bus
->match_callbacks_modified
);
2414 static int process_builtin(sd_bus
*bus
, sd_bus_message
*m
) {
2415 _cleanup_bus_message_unref_ sd_bus_message
*reply
= NULL
;
2421 if (bus
->hello_flags
& KDBUS_HELLO_MONITOR
)
2424 if (bus
->manual_peer_interface
)
2427 if (m
->header
->type
!= SD_BUS_MESSAGE_METHOD_CALL
)
2430 if (!streq_ptr(m
->interface
, "org.freedesktop.DBus.Peer"))
2433 if (m
->header
->flags
& BUS_MESSAGE_NO_REPLY_EXPECTED
)
2436 if (streq_ptr(m
->member
, "Ping"))
2437 r
= sd_bus_message_new_method_return(m
, &reply
);
2438 else if (streq_ptr(m
->member
, "GetMachineId")) {
2442 r
= sd_id128_get_machine(&id
);
2446 r
= sd_bus_message_new_method_return(m
, &reply
);
2450 r
= sd_bus_message_append(reply
, "s", sd_id128_to_string(id
, sid
));
2452 r
= sd_bus_message_new_method_errorf(
2454 SD_BUS_ERROR_UNKNOWN_METHOD
,
2455 "Unknown method '%s' on interface '%s'.", m
->member
, m
->interface
);
2461 r
= sd_bus_send(bus
, reply
, NULL
);
2468 static int process_fd_check(sd_bus
*bus
, sd_bus_message
*m
) {
2472 /* If we got a message with a file descriptor which we didn't
2473 * want to accept, then let's drop it. How can this even
2474 * happen? For example, when the kernel queues a message into
2475 * an activatable names's queue which allows fds, and then is
2476 * delivered to us later even though we ourselves did not
2479 if (bus
->hello_flags
& KDBUS_HELLO_MONITOR
)
2485 if (bus
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
)
2488 if (m
->header
->type
!= SD_BUS_MESSAGE_METHOD_CALL
)
2489 return 1; /* just eat it up */
2491 return sd_bus_reply_method_errorf(m
, SD_BUS_ERROR_INCONSISTENT_MESSAGE
, "Message contains file descriptors, which I cannot accept. Sorry.");
2494 static int process_message(sd_bus
*bus
, sd_bus_message
*m
) {
2500 bus
->current_message
= m
;
2501 bus
->iteration_counter
++;
2503 log_debug_bus_message(m
);
2505 r
= process_hello(bus
, m
);
2509 r
= process_reply(bus
, m
);
2513 r
= process_fd_check(bus
, m
);
2517 r
= process_filter(bus
, m
);
2521 r
= process_match(bus
, m
);
2525 r
= process_builtin(bus
, m
);
2529 r
= bus_process_object(bus
, m
);
2532 bus
->current_message
= NULL
;
2536 static int dispatch_track(sd_bus
*bus
) {
2539 if (!bus
->track_queue
)
2542 bus_track_dispatch(bus
->track_queue
);
2546 static int process_running(sd_bus
*bus
, bool hint_priority
, int64_t priority
, sd_bus_message
**ret
) {
2547 _cleanup_bus_message_unref_ sd_bus_message
*m
= NULL
;
2551 assert(bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
);
2553 r
= process_timeout(bus
);
2557 r
= dispatch_wqueue(bus
);
2561 r
= dispatch_track(bus
);
2565 r
= dispatch_rqueue(bus
, hint_priority
, priority
, &m
);
2571 r
= process_message(bus
, m
);
2576 r
= sd_bus_message_rewind(m
, true);
2585 if (m
->header
->type
== SD_BUS_MESSAGE_METHOD_CALL
) {
2587 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2588 strna(sd_bus_message_get_sender(m
)),
2589 strna(sd_bus_message_get_path(m
)),
2590 strna(sd_bus_message_get_interface(m
)),
2591 strna(sd_bus_message_get_member(m
)));
2593 r
= sd_bus_reply_method_errorf(
2595 SD_BUS_ERROR_UNKNOWN_OBJECT
,
2596 "Unknown object '%s'.", m
->path
);
2610 static int process_closing(sd_bus
*bus
, sd_bus_message
**ret
) {
2611 _cleanup_bus_message_unref_ sd_bus_message
*m
= NULL
;
2612 struct reply_callback
*c
;
2616 assert(bus
->state
== BUS_CLOSING
);
2618 c
= ordered_hashmap_first(bus
->reply_callbacks
);
2620 _cleanup_bus_error_free_ sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2623 /* First, fail all outstanding method calls */
2624 r
= bus_message_new_synthetic_error(
2627 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY
, "Connection terminated"),
2632 r
= bus_seal_synthetic_message(bus
, m
);
2636 if (c
->timeout
!= 0) {
2637 prioq_remove(bus
->reply_callbacks_prioq
, c
, &c
->prioq_idx
);
2641 ordered_hashmap_remove(bus
->reply_callbacks
, &c
->cookie
);
2644 slot
= container_of(c
, sd_bus_slot
, reply_callback
);
2646 bus
->iteration_counter
++;
2648 bus
->current_message
= m
;
2649 bus
->current_slot
= sd_bus_slot_ref(slot
);
2650 bus
->current_handler
= c
->callback
;
2651 bus
->current_userdata
= slot
->userdata
;
2652 r
= c
->callback(m
, slot
->userdata
, &error_buffer
);
2653 bus
->current_userdata
= NULL
;
2654 bus
->current_handler
= NULL
;
2655 bus
->current_slot
= NULL
;
2656 bus
->current_message
= NULL
;
2658 if (slot
->floating
) {
2659 bus_slot_disconnect(slot
);
2660 sd_bus_slot_unref(slot
);
2663 sd_bus_slot_unref(slot
);
2665 return bus_maybe_reply_error(m
, r
, &error_buffer
);
2668 /* Then, synthesize a Disconnected message */
2669 r
= sd_bus_message_new_signal(
2672 "/org/freedesktop/DBus/Local",
2673 "org.freedesktop.DBus.Local",
2678 bus_message_set_sender_local(bus
, m
);
2680 r
= bus_seal_synthetic_message(bus
, m
);
2686 bus
->current_message
= m
;
2687 bus
->iteration_counter
++;
2689 r
= process_filter(bus
, m
);
2693 r
= process_match(bus
, m
);
2705 bus
->current_message
= NULL
;
2710 static int bus_process_internal(sd_bus
*bus
, bool hint_priority
, int64_t priority
, sd_bus_message
**ret
) {
2711 BUS_DONT_DESTROY(bus
);
2714 /* Returns 0 when we didn't do anything. This should cause the
2715 * caller to invoke sd_bus_wait() before returning the next
2716 * time. Returns > 0 when we did something, which possibly
2717 * means *ret is filled in with an unprocessed message. */
2719 assert_return(bus
, -EINVAL
);
2720 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2722 /* We don't allow recursively invoking sd_bus_process(). */
2723 assert_return(!bus
->current_message
, -EBUSY
);
2724 assert(!bus
->current_slot
);
2726 switch (bus
->state
) {
2735 r
= bus_socket_process_opening(bus
);
2736 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2737 bus_enter_closing(bus
);
2745 case BUS_AUTHENTICATING
:
2746 r
= bus_socket_process_authenticating(bus
);
2747 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2748 bus_enter_closing(bus
);
2760 r
= process_running(bus
, hint_priority
, priority
, ret
);
2761 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2762 bus_enter_closing(bus
);
2772 return process_closing(bus
, ret
);
2775 assert_not_reached("Unknown state");
2778 _public_
int sd_bus_process(sd_bus
*bus
, sd_bus_message
**ret
) {
2779 return bus_process_internal(bus
, false, 0, ret
);
2782 _public_
int sd_bus_process_priority(sd_bus
*bus
, int64_t priority
, sd_bus_message
**ret
) {
2783 return bus_process_internal(bus
, true, priority
, ret
);
2786 static int bus_poll(sd_bus
*bus
, bool need_more
, uint64_t timeout_usec
) {
2787 struct pollfd p
[2] = {};
2790 usec_t m
= USEC_INFINITY
;
2794 if (bus
->state
== BUS_CLOSING
)
2797 if (!BUS_IS_OPEN(bus
->state
))
2800 e
= sd_bus_get_events(bus
);
2805 /* The caller really needs some more data, he doesn't
2806 * care about what's already read, or any timeouts
2807 * except its own. */
2811 /* The caller wants to process if there's something to
2812 * process, but doesn't care otherwise */
2814 r
= sd_bus_get_timeout(bus
, &until
);
2819 nw
= now(CLOCK_MONOTONIC
);
2820 m
= until
> nw
? until
- nw
: 0;
2824 if (timeout_usec
!= (uint64_t) -1 && (m
== (uint64_t) -1 || timeout_usec
< m
))
2827 p
[0].fd
= bus
->input_fd
;
2828 if (bus
->output_fd
== bus
->input_fd
) {
2832 p
[0].events
= e
& POLLIN
;
2833 p
[1].fd
= bus
->output_fd
;
2834 p
[1].events
= e
& POLLOUT
;
2838 r
= ppoll(p
, n
, m
== (uint64_t) -1 ? NULL
: timespec_store(&ts
, m
), NULL
);
2842 return r
> 0 ? 1 : 0;
2845 _public_
int sd_bus_wait(sd_bus
*bus
, uint64_t timeout_usec
) {
2847 assert_return(bus
, -EINVAL
);
2848 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2850 if (bus
->state
== BUS_CLOSING
)
2853 if (!BUS_IS_OPEN(bus
->state
))
2856 if (bus
->rqueue_size
> 0)
2859 return bus_poll(bus
, false, timeout_usec
);
2862 _public_
int sd_bus_flush(sd_bus
*bus
) {
2865 assert_return(bus
, -EINVAL
);
2866 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2868 if (bus
->state
== BUS_CLOSING
)
2871 if (!BUS_IS_OPEN(bus
->state
))
2874 r
= bus_ensure_running(bus
);
2878 if (bus
->wqueue_size
<= 0)
2882 r
= dispatch_wqueue(bus
);
2884 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2885 bus_enter_closing(bus
);
2892 if (bus
->wqueue_size
<= 0)
2895 r
= bus_poll(bus
, false, (uint64_t) -1);
2901 _public_
int sd_bus_add_filter(
2904 sd_bus_message_handler_t callback
,
2909 assert_return(bus
, -EINVAL
);
2910 assert_return(callback
, -EINVAL
);
2911 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2913 s
= bus_slot_allocate(bus
, !slot
, BUS_FILTER_CALLBACK
, sizeof(struct filter_callback
), userdata
);
2917 s
->filter_callback
.callback
= callback
;
2919 bus
->filter_callbacks_modified
= true;
2920 LIST_PREPEND(callbacks
, bus
->filter_callbacks
, &s
->filter_callback
);
2928 _public_
int sd_bus_add_match(
2932 sd_bus_message_handler_t callback
,
2935 struct bus_match_component
*components
= NULL
;
2936 unsigned n_components
= 0;
2937 sd_bus_slot
*s
= NULL
;
2940 assert_return(bus
, -EINVAL
);
2941 assert_return(match
, -EINVAL
);
2942 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2944 r
= bus_match_parse(match
, &components
, &n_components
);
2948 s
= bus_slot_allocate(bus
, !slot
, BUS_MATCH_CALLBACK
, sizeof(struct match_callback
), userdata
);
2954 s
->match_callback
.callback
= callback
;
2955 s
->match_callback
.cookie
= ++bus
->match_cookie
;
2957 if (bus
->bus_client
) {
2958 enum bus_match_scope scope
;
2960 scope
= bus_match_get_scope(components
, n_components
);
2962 /* Do not install server-side matches for matches
2963 * against the local service, interface or bus
2965 if (scope
!= BUS_MATCH_LOCAL
) {
2967 if (!bus
->is_kernel
) {
2968 /* When this is not a kernel transport, we
2969 * store the original match string, so that we
2970 * can use it to remove the match again */
2972 s
->match_callback
.match_string
= strdup(match
);
2973 if (!s
->match_callback
.match_string
) {
2979 r
= bus_add_match_internal(bus
, s
->match_callback
.match_string
, components
, n_components
, s
->match_callback
.cookie
);
2983 s
->match_added
= true;
2987 bus
->match_callbacks_modified
= true;
2988 r
= bus_match_add(&bus
->match_callbacks
, components
, n_components
, &s
->match_callback
);
2997 bus_match_parse_free(components
, n_components
);
2998 sd_bus_slot_unref(s
);
3003 int bus_remove_match_by_string(
3006 sd_bus_message_handler_t callback
,
3009 struct bus_match_component
*components
= NULL
;
3010 unsigned n_components
= 0;
3011 struct match_callback
*c
;
3014 assert_return(bus
, -EINVAL
);
3015 assert_return(match
, -EINVAL
);
3016 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3018 r
= bus_match_parse(match
, &components
, &n_components
);
3022 r
= bus_match_find(&bus
->match_callbacks
, components
, n_components
, NULL
, NULL
, &c
);
3026 sd_bus_slot_unref(container_of(c
, sd_bus_slot
, match_callback
));
3029 bus_match_parse_free(components
, n_components
);
3034 bool bus_pid_changed(sd_bus
*bus
) {
3037 /* We don't support people creating a bus connection and
3038 * keeping it around over a fork(). Let's complain. */
3040 return bus
->original_pid
!= getpid();
3043 static int io_callback(sd_event_source
*s
, int fd
, uint32_t revents
, void *userdata
) {
3044 sd_bus
*bus
= userdata
;
3049 r
= sd_bus_process(bus
, NULL
);
3056 static int time_callback(sd_event_source
*s
, uint64_t usec
, void *userdata
) {
3057 sd_bus
*bus
= userdata
;
3062 r
= sd_bus_process(bus
, NULL
);
3069 static int prepare_callback(sd_event_source
*s
, void *userdata
) {
3070 sd_bus
*bus
= userdata
;
3077 e
= sd_bus_get_events(bus
);
3081 if (bus
->output_fd
!= bus
->input_fd
) {
3083 r
= sd_event_source_set_io_events(bus
->input_io_event_source
, e
& POLLIN
);
3087 r
= sd_event_source_set_io_events(bus
->output_io_event_source
, e
& POLLOUT
);
3091 r
= sd_event_source_set_io_events(bus
->input_io_event_source
, e
);
3096 r
= sd_bus_get_timeout(bus
, &until
);
3102 j
= sd_event_source_set_time(bus
->time_event_source
, until
);
3107 r
= sd_event_source_set_enabled(bus
->time_event_source
, r
> 0);
3114 static int quit_callback(sd_event_source
*event
, void *userdata
) {
3115 sd_bus
*bus
= userdata
;
3125 static int attach_io_events(sd_bus
*bus
) {
3130 if (bus
->input_fd
< 0)
3136 if (!bus
->input_io_event_source
) {
3137 r
= sd_event_add_io(bus
->event
, &bus
->input_io_event_source
, bus
->input_fd
, 0, io_callback
, bus
);
3141 r
= sd_event_source_set_prepare(bus
->input_io_event_source
, prepare_callback
);
3145 r
= sd_event_source_set_priority(bus
->input_io_event_source
, bus
->event_priority
);
3149 r
= sd_event_source_set_description(bus
->input_io_event_source
, "bus-input");
3151 r
= sd_event_source_set_io_fd(bus
->input_io_event_source
, bus
->input_fd
);
3156 if (bus
->output_fd
!= bus
->input_fd
) {
3157 assert(bus
->output_fd
>= 0);
3159 if (!bus
->output_io_event_source
) {
3160 r
= sd_event_add_io(bus
->event
, &bus
->output_io_event_source
, bus
->output_fd
, 0, io_callback
, bus
);
3164 r
= sd_event_source_set_priority(bus
->output_io_event_source
, bus
->event_priority
);
3168 r
= sd_event_source_set_description(bus
->input_io_event_source
, "bus-output");
3170 r
= sd_event_source_set_io_fd(bus
->output_io_event_source
, bus
->output_fd
);
3179 static void detach_io_events(sd_bus
*bus
) {
3182 if (bus
->input_io_event_source
) {
3183 sd_event_source_set_enabled(bus
->input_io_event_source
, SD_EVENT_OFF
);
3184 bus
->input_io_event_source
= sd_event_source_unref(bus
->input_io_event_source
);
3187 if (bus
->output_io_event_source
) {
3188 sd_event_source_set_enabled(bus
->output_io_event_source
, SD_EVENT_OFF
);
3189 bus
->output_io_event_source
= sd_event_source_unref(bus
->output_io_event_source
);
3193 _public_
int sd_bus_attach_event(sd_bus
*bus
, sd_event
*event
, int priority
) {
3196 assert_return(bus
, -EINVAL
);
3197 assert_return(!bus
->event
, -EBUSY
);
3199 assert(!bus
->input_io_event_source
);
3200 assert(!bus
->output_io_event_source
);
3201 assert(!bus
->time_event_source
);
3204 bus
->event
= sd_event_ref(event
);
3206 r
= sd_event_default(&bus
->event
);
3211 bus
->event_priority
= priority
;
3213 r
= sd_event_add_time(bus
->event
, &bus
->time_event_source
, CLOCK_MONOTONIC
, 0, 0, time_callback
, bus
);
3217 r
= sd_event_source_set_priority(bus
->time_event_source
, priority
);
3221 r
= sd_event_source_set_description(bus
->time_event_source
, "bus-time");
3225 r
= sd_event_add_exit(bus
->event
, &bus
->quit_event_source
, quit_callback
, bus
);
3229 r
= sd_event_source_set_description(bus
->quit_event_source
, "bus-exit");
3233 r
= attach_io_events(bus
);
3240 sd_bus_detach_event(bus
);
3244 _public_
int sd_bus_detach_event(sd_bus
*bus
) {
3245 assert_return(bus
, -EINVAL
);
3250 detach_io_events(bus
);
3252 if (bus
->time_event_source
) {
3253 sd_event_source_set_enabled(bus
->time_event_source
, SD_EVENT_OFF
);
3254 bus
->time_event_source
= sd_event_source_unref(bus
->time_event_source
);
3257 if (bus
->quit_event_source
) {
3258 sd_event_source_set_enabled(bus
->quit_event_source
, SD_EVENT_OFF
);
3259 bus
->quit_event_source
= sd_event_source_unref(bus
->quit_event_source
);
3262 bus
->event
= sd_event_unref(bus
->event
);
3266 _public_ sd_event
* sd_bus_get_event(sd_bus
*bus
) {
3267 assert_return(bus
, NULL
);
3272 _public_ sd_bus_message
* sd_bus_get_current_message(sd_bus
*bus
) {
3273 assert_return(bus
, NULL
);
3275 return bus
->current_message
;
3278 _public_ sd_bus_slot
* sd_bus_get_current_slot(sd_bus
*bus
) {
3279 assert_return(bus
, NULL
);
3281 return bus
->current_slot
;
3284 _public_ sd_bus_message_handler_t
sd_bus_get_current_handler(sd_bus
*bus
) {
3285 assert_return(bus
, NULL
);
3287 return bus
->current_handler
;
3290 _public_
void* sd_bus_get_current_userdata(sd_bus
*bus
) {
3291 assert_return(bus
, NULL
);
3293 return bus
->current_userdata
;
3296 static int bus_default(int (*bus_open
)(sd_bus
**), sd_bus
**default_bus
, sd_bus
**ret
) {
3301 assert(default_bus
);
3304 return !!*default_bus
;
3307 *ret
= sd_bus_ref(*default_bus
);
3315 b
->default_bus_ptr
= default_bus
;
3323 _public_
int sd_bus_default_system(sd_bus
**ret
) {
3324 static thread_local sd_bus
*default_system_bus
= NULL
;
3326 return bus_default(sd_bus_open_system
, &default_system_bus
, ret
);
3329 _public_
int sd_bus_default_user(sd_bus
**ret
) {
3330 static thread_local sd_bus
*default_user_bus
= NULL
;
3332 return bus_default(sd_bus_open_user
, &default_user_bus
, ret
);
3335 _public_
int sd_bus_default(sd_bus
**ret
) {
3339 /* Let's try our best to reuse another cached connection. If
3340 * the starter bus type is set, connect via our normal
3341 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3342 * we can share the connection with the user/system default
3345 e
= secure_getenv("DBUS_STARTER_BUS_TYPE");
3347 if (streq(e
, "system"))
3348 return sd_bus_default_system(ret
);
3349 else if (STR_IN_SET(e
, "user", "session"))
3350 return sd_bus_default_user(ret
);
3353 /* No type is specified, so we have not other option than to
3354 * use the starter address if it is set. */
3356 e
= secure_getenv("DBUS_STARTER_ADDRESS");
3358 static thread_local sd_bus
*default_starter_bus
= NULL
;
3360 return bus_default(sd_bus_open
, &default_starter_bus
, ret
);
3363 /* Finally, if nothing is set use the cached connection for
3364 * the right scope */
3366 if (cg_pid_get_owner_uid(0, NULL
) >= 0)
3367 return sd_bus_default_user(ret
);
3369 return sd_bus_default_system(ret
);
3372 _public_
int sd_bus_get_tid(sd_bus
*b
, pid_t
*tid
) {
3373 assert_return(b
, -EINVAL
);
3374 assert_return(tid
, -EINVAL
);
3375 assert_return(!bus_pid_changed(b
), -ECHILD
);
3383 return sd_event_get_tid(b
->event
, tid
);
3388 _public_
int sd_bus_path_encode(const char *prefix
, const char *external_id
, char **ret_path
) {
3389 _cleanup_free_
char *e
= NULL
;
3392 assert_return(object_path_is_valid(prefix
), -EINVAL
);
3393 assert_return(external_id
, -EINVAL
);
3394 assert_return(ret_path
, -EINVAL
);
3396 e
= bus_label_escape(external_id
);
3400 ret
= strjoin(prefix
, "/", e
, NULL
);
3408 _public_
int sd_bus_path_decode(const char *path
, const char *prefix
, char **external_id
) {
3412 assert_return(object_path_is_valid(path
), -EINVAL
);
3413 assert_return(object_path_is_valid(prefix
), -EINVAL
);
3414 assert_return(external_id
, -EINVAL
);
3416 e
= object_path_startswith(path
, prefix
);
3418 *external_id
= NULL
;
3422 ret
= bus_label_unescape(e
);
3430 _public_
int sd_bus_try_close(sd_bus
*bus
) {
3433 assert_return(bus
, -EINVAL
);
3434 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3436 if (!bus
->is_kernel
)
3439 if (!BUS_IS_OPEN(bus
->state
))
3442 if (bus
->rqueue_size
> 0)
3445 if (bus
->wqueue_size
> 0)
3448 r
= bus_kernel_try_close(bus
);
3456 _public_
int sd_bus_get_description(sd_bus
*bus
, const char **description
) {
3457 assert_return(bus
, -EINVAL
);
3458 assert_return(description
, -EINVAL
);
3459 assert_return(bus
->description
, -ENXIO
);
3460 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3462 *description
= bus
->description
;
3466 int bus_get_root_path(sd_bus
*bus
) {
3469 if (bus
->cgroup_root
)
3472 r
= cg_get_root_path(&bus
->cgroup_root
);
3474 bus
->cgroup_root
= strdup("/");
3475 if (!bus
->cgroup_root
)
3484 _public_
int sd_bus_get_scope(sd_bus
*bus
, const char **scope
) {
3487 assert_return(bus
, -EINVAL
);
3488 assert_return(scope
, -EINVAL
);
3489 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3491 if (bus
->is_kernel
) {
3492 _cleanup_free_
char *n
= NULL
;
3495 r
= bus_kernel_get_bus_name(bus
, &n
);
3499 if (streq(n
, "0-system")) {
3504 dash
= strchr(n
, '-');
3505 if (streq_ptr(dash
, "-user")) {
3516 if (bus
->is_system
) {
3524 _public_
int sd_bus_get_address(sd_bus
*bus
, const char **address
) {
3526 assert_return(bus
, -EINVAL
);
3527 assert_return(address
, -EINVAL
);
3528 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3531 *address
= bus
->address
;
3538 _public_
int sd_bus_get_creds_mask(sd_bus
*bus
, uint64_t *mask
) {
3539 assert_return(bus
, -EINVAL
);
3540 assert_return(mask
, -EINVAL
);
3541 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3543 *mask
= bus
->creds_mask
;
3547 _public_
int sd_bus_is_bus_client(sd_bus
*bus
) {
3548 assert_return(bus
, -EINVAL
);
3549 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3551 return bus
->bus_client
;
3554 _public_
int sd_bus_is_server(sd_bus
*bus
) {
3555 assert_return(bus
, -EINVAL
);
3556 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3558 return bus
->is_server
;
3561 _public_
int sd_bus_is_anonymous(sd_bus
*bus
) {
3562 assert_return(bus
, -EINVAL
);
3563 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3565 return bus
->anonymous_auth
;
3568 _public_
int sd_bus_is_trusted(sd_bus
*bus
) {
3569 assert_return(bus
, -EINVAL
);
3570 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3572 return bus
->trusted
;
3575 _public_
int sd_bus_is_monitor(sd_bus
*bus
) {
3576 assert_return(bus
, -EINVAL
);
3577 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3579 return !!(bus
->hello_flags
& KDBUS_HELLO_MONITOR
);