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 assert_return(m
, -EINVAL
);
1955 assert_return(m
->header
->type
== SD_BUS_MESSAGE_METHOD_CALL
, -EINVAL
);
1956 assert_return(!(m
->header
->flags
& BUS_MESSAGE_NO_REPLY_EXPECTED
), -EINVAL
);
1957 assert_return(!bus_error_is_dirty(error
), -EINVAL
);
1962 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1963 assert_return(!bus
->is_kernel
|| !(bus
->hello_flags
& KDBUS_HELLO_MONITOR
), -EROFS
);
1965 if (!BUS_IS_OPEN(bus
->state
))
1968 r
= bus_ensure_running(bus
);
1972 i
= bus
->rqueue_size
;
1974 r
= bus_seal_message(bus
, m
, usec
);
1978 r
= bus_remarshal_message(bus
, &m
);
1982 r
= bus_send_internal(bus
, m
, &cookie
, true);
1986 timeout
= calc_elapse(m
->timeout
);
1991 while (i
< bus
->rqueue_size
) {
1992 sd_bus_message
*incoming
= NULL
;
1994 incoming
= bus
->rqueue
[i
];
1996 if (incoming
->reply_cookie
== cookie
) {
1997 /* Found a match! */
1999 memmove(bus
->rqueue
+ i
, bus
->rqueue
+ i
+ 1, sizeof(sd_bus_message
*) * (bus
->rqueue_size
- i
- 1));
2001 log_debug_bus_message(incoming
);
2003 if (incoming
->header
->type
== SD_BUS_MESSAGE_METHOD_RETURN
) {
2005 if (incoming
->n_fds
<= 0 || (bus
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
)) {
2009 sd_bus_message_unref(incoming
);
2014 r
= sd_bus_error_setf(error
, SD_BUS_ERROR_INCONSISTENT_MESSAGE
, "Reply message contained file descriptors which I couldn't accept. Sorry.");
2016 } else if (incoming
->header
->type
== SD_BUS_MESSAGE_METHOD_ERROR
)
2017 r
= sd_bus_error_copy(error
, &incoming
->error
);
2021 sd_bus_message_unref(incoming
);
2024 } else if (BUS_MESSAGE_COOKIE(incoming
) == cookie
&&
2027 streq(bus
->unique_name
, incoming
->sender
)) {
2029 memmove(bus
->rqueue
+ i
, bus
->rqueue
+ i
+ 1, sizeof(sd_bus_message
*) * (bus
->rqueue_size
- i
- 1));
2032 /* Our own message? Somebody is trying
2033 * to send its own client a message,
2034 * let's not dead-lock, let's fail
2037 sd_bus_message_unref(incoming
);
2041 /* Try to read more, right-away */
2045 r
= bus_read_message(bus
, false, 0);
2047 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2048 bus_enter_closing(bus
);
2060 n
= now(CLOCK_MONOTONIC
);
2066 left
= (uint64_t) -1;
2068 r
= bus_poll(bus
, true, left
);
2074 r
= dispatch_wqueue(bus
);
2076 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2077 bus_enter_closing(bus
);
2086 _public_
int sd_bus_get_fd(sd_bus
*bus
) {
2088 assert_return(bus
, -EINVAL
);
2089 assert_return(bus
->input_fd
== bus
->output_fd
, -EPERM
);
2090 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2092 return bus
->input_fd
;
2095 _public_
int sd_bus_get_events(sd_bus
*bus
) {
2098 assert_return(bus
, -EINVAL
);
2099 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2101 if (!BUS_IS_OPEN(bus
->state
) && bus
->state
!= BUS_CLOSING
)
2104 if (bus
->state
== BUS_OPENING
)
2106 else if (bus
->state
== BUS_AUTHENTICATING
) {
2108 if (bus_socket_auth_needs_write(bus
))
2113 } else if (bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
) {
2114 if (bus
->rqueue_size
<= 0)
2116 if (bus
->wqueue_size
> 0)
2123 _public_
int sd_bus_get_timeout(sd_bus
*bus
, uint64_t *timeout_usec
) {
2124 struct reply_callback
*c
;
2126 assert_return(bus
, -EINVAL
);
2127 assert_return(timeout_usec
, -EINVAL
);
2128 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2130 if (!BUS_IS_OPEN(bus
->state
) && bus
->state
!= BUS_CLOSING
)
2133 if (bus
->track_queue
) {
2138 if (bus
->state
== BUS_CLOSING
) {
2143 if (bus
->state
== BUS_AUTHENTICATING
) {
2144 *timeout_usec
= bus
->auth_timeout
;
2148 if (bus
->state
!= BUS_RUNNING
&& bus
->state
!= BUS_HELLO
) {
2149 *timeout_usec
= (uint64_t) -1;
2153 if (bus
->rqueue_size
> 0) {
2158 c
= prioq_peek(bus
->reply_callbacks_prioq
);
2160 *timeout_usec
= (uint64_t) -1;
2164 if (c
->timeout
== 0) {
2165 *timeout_usec
= (uint64_t) -1;
2169 *timeout_usec
= c
->timeout
;
2173 static int process_timeout(sd_bus
*bus
) {
2174 _cleanup_bus_error_free_ sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2175 _cleanup_bus_message_unref_ sd_bus_message
* m
= NULL
;
2176 struct reply_callback
*c
;
2183 c
= prioq_peek(bus
->reply_callbacks_prioq
);
2187 n
= now(CLOCK_MONOTONIC
);
2191 r
= bus_message_new_synthetic_error(
2194 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY
, "Method call timed out"),
2199 r
= bus_seal_synthetic_message(bus
, m
);
2203 assert_se(prioq_pop(bus
->reply_callbacks_prioq
) == c
);
2206 ordered_hashmap_remove(bus
->reply_callbacks
, &c
->cookie
);
2209 slot
= container_of(c
, sd_bus_slot
, reply_callback
);
2211 bus
->iteration_counter
++;
2213 bus
->current_message
= m
;
2214 bus
->current_slot
= sd_bus_slot_ref(slot
);
2215 bus
->current_handler
= c
->callback
;
2216 bus
->current_userdata
= slot
->userdata
;
2217 r
= c
->callback(m
, slot
->userdata
, &error_buffer
);
2218 bus
->current_userdata
= NULL
;
2219 bus
->current_handler
= NULL
;
2220 bus
->current_slot
= NULL
;
2221 bus
->current_message
= NULL
;
2223 if (slot
->floating
) {
2224 bus_slot_disconnect(slot
);
2225 sd_bus_slot_unref(slot
);
2228 sd_bus_slot_unref(slot
);
2230 return bus_maybe_reply_error(m
, r
, &error_buffer
);
2233 static int process_hello(sd_bus
*bus
, sd_bus_message
*m
) {
2237 if (bus
->state
!= BUS_HELLO
)
2240 /* Let's make sure the first message on the bus is the HELLO
2241 * reply. But note that we don't actually parse the message
2242 * here (we leave that to the usual handling), we just verify
2243 * we don't let any earlier msg through. */
2245 if (m
->header
->type
!= SD_BUS_MESSAGE_METHOD_RETURN
&&
2246 m
->header
->type
!= SD_BUS_MESSAGE_METHOD_ERROR
)
2249 if (m
->reply_cookie
!= 1)
2255 static int process_reply(sd_bus
*bus
, sd_bus_message
*m
) {
2256 _cleanup_bus_message_unref_ sd_bus_message
*synthetic_reply
= NULL
;
2257 _cleanup_bus_error_free_ sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2258 struct reply_callback
*c
;
2265 if (m
->header
->type
!= SD_BUS_MESSAGE_METHOD_RETURN
&&
2266 m
->header
->type
!= SD_BUS_MESSAGE_METHOD_ERROR
)
2269 if (bus
->is_kernel
&& (bus
->hello_flags
& KDBUS_HELLO_MONITOR
))
2272 if (m
->destination
&& bus
->unique_name
&& !streq_ptr(m
->destination
, bus
->unique_name
))
2275 c
= ordered_hashmap_remove(bus
->reply_callbacks
, &m
->reply_cookie
);
2281 slot
= container_of(c
, sd_bus_slot
, reply_callback
);
2283 if (m
->n_fds
> 0 && !(bus
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
)) {
2285 /* If the reply contained a file descriptor which we
2286 * didn't want we pass an error instead. */
2288 r
= bus_message_new_synthetic_error(
2291 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE
, "Reply message contained file descriptor"),
2296 /* Copy over original timestamp */
2297 synthetic_reply
->realtime
= m
->realtime
;
2298 synthetic_reply
->monotonic
= m
->monotonic
;
2299 synthetic_reply
->seqnum
= m
->seqnum
;
2301 r
= bus_seal_synthetic_message(bus
, synthetic_reply
);
2305 m
= synthetic_reply
;
2307 r
= sd_bus_message_rewind(m
, true);
2312 if (c
->timeout
!= 0) {
2313 prioq_remove(bus
->reply_callbacks_prioq
, c
, &c
->prioq_idx
);
2317 bus
->current_slot
= sd_bus_slot_ref(slot
);
2318 bus
->current_handler
= c
->callback
;
2319 bus
->current_userdata
= slot
->userdata
;
2320 r
= c
->callback(m
, slot
->userdata
, &error_buffer
);
2321 bus
->current_userdata
= NULL
;
2322 bus
->current_handler
= NULL
;
2323 bus
->current_slot
= NULL
;
2325 if (slot
->floating
) {
2326 bus_slot_disconnect(slot
);
2327 sd_bus_slot_unref(slot
);
2330 sd_bus_slot_unref(slot
);
2332 return bus_maybe_reply_error(m
, r
, &error_buffer
);
2335 static int process_filter(sd_bus
*bus
, sd_bus_message
*m
) {
2336 _cleanup_bus_error_free_ sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2337 struct filter_callback
*l
;
2344 bus
->filter_callbacks_modified
= false;
2346 LIST_FOREACH(callbacks
, l
, bus
->filter_callbacks
) {
2349 if (bus
->filter_callbacks_modified
)
2352 /* Don't run this more than once per iteration */
2353 if (l
->last_iteration
== bus
->iteration_counter
)
2356 l
->last_iteration
= bus
->iteration_counter
;
2358 r
= sd_bus_message_rewind(m
, true);
2362 slot
= container_of(l
, sd_bus_slot
, filter_callback
);
2364 bus
->current_slot
= sd_bus_slot_ref(slot
);
2365 bus
->current_handler
= l
->callback
;
2366 bus
->current_userdata
= slot
->userdata
;
2367 r
= l
->callback(m
, slot
->userdata
, &error_buffer
);
2368 bus
->current_userdata
= NULL
;
2369 bus
->current_handler
= NULL
;
2370 bus
->current_slot
= sd_bus_slot_unref(slot
);
2372 r
= bus_maybe_reply_error(m
, r
, &error_buffer
);
2378 } while (bus
->filter_callbacks_modified
);
2383 static int process_match(sd_bus
*bus
, sd_bus_message
*m
) {
2390 bus
->match_callbacks_modified
= false;
2392 r
= bus_match_run(bus
, &bus
->match_callbacks
, m
);
2396 } while (bus
->match_callbacks_modified
);
2401 static int process_builtin(sd_bus
*bus
, sd_bus_message
*m
) {
2402 _cleanup_bus_message_unref_ sd_bus_message
*reply
= NULL
;
2408 if (bus
->hello_flags
& KDBUS_HELLO_MONITOR
)
2411 if (bus
->manual_peer_interface
)
2414 if (m
->header
->type
!= SD_BUS_MESSAGE_METHOD_CALL
)
2417 if (!streq_ptr(m
->interface
, "org.freedesktop.DBus.Peer"))
2420 if (m
->header
->flags
& BUS_MESSAGE_NO_REPLY_EXPECTED
)
2423 if (streq_ptr(m
->member
, "Ping"))
2424 r
= sd_bus_message_new_method_return(m
, &reply
);
2425 else if (streq_ptr(m
->member
, "GetMachineId")) {
2429 r
= sd_id128_get_machine(&id
);
2433 r
= sd_bus_message_new_method_return(m
, &reply
);
2437 r
= sd_bus_message_append(reply
, "s", sd_id128_to_string(id
, sid
));
2439 r
= sd_bus_message_new_method_errorf(
2441 SD_BUS_ERROR_UNKNOWN_METHOD
,
2442 "Unknown method '%s' on interface '%s'.", m
->member
, m
->interface
);
2448 r
= sd_bus_send(bus
, reply
, NULL
);
2455 static int process_fd_check(sd_bus
*bus
, sd_bus_message
*m
) {
2459 /* If we got a message with a file descriptor which we didn't
2460 * want to accept, then let's drop it. How can this even
2461 * happen? For example, when the kernel queues a message into
2462 * an activatable names's queue which allows fds, and then is
2463 * delivered to us later even though we ourselves did not
2466 if (bus
->hello_flags
& KDBUS_HELLO_MONITOR
)
2472 if (bus
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
)
2475 if (m
->header
->type
!= SD_BUS_MESSAGE_METHOD_CALL
)
2476 return 1; /* just eat it up */
2478 return sd_bus_reply_method_errorf(m
, SD_BUS_ERROR_INCONSISTENT_MESSAGE
, "Message contains file descriptors, which I cannot accept. Sorry.");
2481 static int process_message(sd_bus
*bus
, sd_bus_message
*m
) {
2487 bus
->current_message
= m
;
2488 bus
->iteration_counter
++;
2490 log_debug_bus_message(m
);
2492 r
= process_hello(bus
, m
);
2496 r
= process_reply(bus
, m
);
2500 r
= process_fd_check(bus
, m
);
2504 r
= process_filter(bus
, m
);
2508 r
= process_match(bus
, m
);
2512 r
= process_builtin(bus
, m
);
2516 r
= bus_process_object(bus
, m
);
2519 bus
->current_message
= NULL
;
2523 static int dispatch_track(sd_bus
*bus
) {
2526 if (!bus
->track_queue
)
2529 bus_track_dispatch(bus
->track_queue
);
2533 static int process_running(sd_bus
*bus
, bool hint_priority
, int64_t priority
, sd_bus_message
**ret
) {
2534 _cleanup_bus_message_unref_ sd_bus_message
*m
= NULL
;
2538 assert(bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
);
2540 r
= process_timeout(bus
);
2544 r
= dispatch_wqueue(bus
);
2548 r
= dispatch_track(bus
);
2552 r
= dispatch_rqueue(bus
, hint_priority
, priority
, &m
);
2558 r
= process_message(bus
, m
);
2563 r
= sd_bus_message_rewind(m
, true);
2572 if (m
->header
->type
== SD_BUS_MESSAGE_METHOD_CALL
) {
2574 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2575 strna(sd_bus_message_get_sender(m
)),
2576 strna(sd_bus_message_get_path(m
)),
2577 strna(sd_bus_message_get_interface(m
)),
2578 strna(sd_bus_message_get_member(m
)));
2580 r
= sd_bus_reply_method_errorf(
2582 SD_BUS_ERROR_UNKNOWN_OBJECT
,
2583 "Unknown object '%s'.", m
->path
);
2597 static int process_closing(sd_bus
*bus
, sd_bus_message
**ret
) {
2598 _cleanup_bus_message_unref_ sd_bus_message
*m
= NULL
;
2599 struct reply_callback
*c
;
2603 assert(bus
->state
== BUS_CLOSING
);
2605 c
= ordered_hashmap_first(bus
->reply_callbacks
);
2607 _cleanup_bus_error_free_ sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2610 /* First, fail all outstanding method calls */
2611 r
= bus_message_new_synthetic_error(
2614 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY
, "Connection terminated"),
2619 r
= bus_seal_synthetic_message(bus
, m
);
2623 if (c
->timeout
!= 0) {
2624 prioq_remove(bus
->reply_callbacks_prioq
, c
, &c
->prioq_idx
);
2628 ordered_hashmap_remove(bus
->reply_callbacks
, &c
->cookie
);
2631 slot
= container_of(c
, sd_bus_slot
, reply_callback
);
2633 bus
->iteration_counter
++;
2635 bus
->current_message
= m
;
2636 bus
->current_slot
= sd_bus_slot_ref(slot
);
2637 bus
->current_handler
= c
->callback
;
2638 bus
->current_userdata
= slot
->userdata
;
2639 r
= c
->callback(m
, slot
->userdata
, &error_buffer
);
2640 bus
->current_userdata
= NULL
;
2641 bus
->current_handler
= NULL
;
2642 bus
->current_slot
= NULL
;
2643 bus
->current_message
= NULL
;
2645 if (slot
->floating
) {
2646 bus_slot_disconnect(slot
);
2647 sd_bus_slot_unref(slot
);
2650 sd_bus_slot_unref(slot
);
2652 return bus_maybe_reply_error(m
, r
, &error_buffer
);
2655 /* Then, synthesize a Disconnected message */
2656 r
= sd_bus_message_new_signal(
2659 "/org/freedesktop/DBus/Local",
2660 "org.freedesktop.DBus.Local",
2665 bus_message_set_sender_local(bus
, m
);
2667 r
= bus_seal_synthetic_message(bus
, m
);
2673 bus
->current_message
= m
;
2674 bus
->iteration_counter
++;
2676 r
= process_filter(bus
, m
);
2680 r
= process_match(bus
, m
);
2692 bus
->current_message
= NULL
;
2697 static int bus_process_internal(sd_bus
*bus
, bool hint_priority
, int64_t priority
, sd_bus_message
**ret
) {
2698 BUS_DONT_DESTROY(bus
);
2701 /* Returns 0 when we didn't do anything. This should cause the
2702 * caller to invoke sd_bus_wait() before returning the next
2703 * time. Returns > 0 when we did something, which possibly
2704 * means *ret is filled in with an unprocessed message. */
2706 assert_return(bus
, -EINVAL
);
2707 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2709 /* We don't allow recursively invoking sd_bus_process(). */
2710 assert_return(!bus
->current_message
, -EBUSY
);
2711 assert(!bus
->current_slot
);
2713 switch (bus
->state
) {
2722 r
= bus_socket_process_opening(bus
);
2723 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2724 bus_enter_closing(bus
);
2732 case BUS_AUTHENTICATING
:
2733 r
= bus_socket_process_authenticating(bus
);
2734 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2735 bus_enter_closing(bus
);
2747 r
= process_running(bus
, hint_priority
, priority
, ret
);
2748 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2749 bus_enter_closing(bus
);
2759 return process_closing(bus
, ret
);
2762 assert_not_reached("Unknown state");
2765 _public_
int sd_bus_process(sd_bus
*bus
, sd_bus_message
**ret
) {
2766 return bus_process_internal(bus
, false, 0, ret
);
2769 _public_
int sd_bus_process_priority(sd_bus
*bus
, int64_t priority
, sd_bus_message
**ret
) {
2770 return bus_process_internal(bus
, true, priority
, ret
);
2773 static int bus_poll(sd_bus
*bus
, bool need_more
, uint64_t timeout_usec
) {
2774 struct pollfd p
[2] = {};
2777 usec_t m
= USEC_INFINITY
;
2781 if (bus
->state
== BUS_CLOSING
)
2784 if (!BUS_IS_OPEN(bus
->state
))
2787 e
= sd_bus_get_events(bus
);
2792 /* The caller really needs some more data, he doesn't
2793 * care about what's already read, or any timeouts
2794 * except its own. */
2798 /* The caller wants to process if there's something to
2799 * process, but doesn't care otherwise */
2801 r
= sd_bus_get_timeout(bus
, &until
);
2806 nw
= now(CLOCK_MONOTONIC
);
2807 m
= until
> nw
? until
- nw
: 0;
2811 if (timeout_usec
!= (uint64_t) -1 && (m
== (uint64_t) -1 || timeout_usec
< m
))
2814 p
[0].fd
= bus
->input_fd
;
2815 if (bus
->output_fd
== bus
->input_fd
) {
2819 p
[0].events
= e
& POLLIN
;
2820 p
[1].fd
= bus
->output_fd
;
2821 p
[1].events
= e
& POLLOUT
;
2825 r
= ppoll(p
, n
, m
== (uint64_t) -1 ? NULL
: timespec_store(&ts
, m
), NULL
);
2829 return r
> 0 ? 1 : 0;
2832 _public_
int sd_bus_wait(sd_bus
*bus
, uint64_t timeout_usec
) {
2834 assert_return(bus
, -EINVAL
);
2835 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2837 if (bus
->state
== BUS_CLOSING
)
2840 if (!BUS_IS_OPEN(bus
->state
))
2843 if (bus
->rqueue_size
> 0)
2846 return bus_poll(bus
, false, timeout_usec
);
2849 _public_
int sd_bus_flush(sd_bus
*bus
) {
2852 assert_return(bus
, -EINVAL
);
2853 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2855 if (bus
->state
== BUS_CLOSING
)
2858 if (!BUS_IS_OPEN(bus
->state
))
2861 r
= bus_ensure_running(bus
);
2865 if (bus
->wqueue_size
<= 0)
2869 r
= dispatch_wqueue(bus
);
2871 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2872 bus_enter_closing(bus
);
2879 if (bus
->wqueue_size
<= 0)
2882 r
= bus_poll(bus
, false, (uint64_t) -1);
2888 _public_
int sd_bus_add_filter(
2891 sd_bus_message_handler_t callback
,
2896 assert_return(bus
, -EINVAL
);
2897 assert_return(callback
, -EINVAL
);
2898 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2900 s
= bus_slot_allocate(bus
, !slot
, BUS_FILTER_CALLBACK
, sizeof(struct filter_callback
), userdata
);
2904 s
->filter_callback
.callback
= callback
;
2906 bus
->filter_callbacks_modified
= true;
2907 LIST_PREPEND(callbacks
, bus
->filter_callbacks
, &s
->filter_callback
);
2915 _public_
int sd_bus_add_match(
2919 sd_bus_message_handler_t callback
,
2922 struct bus_match_component
*components
= NULL
;
2923 unsigned n_components
= 0;
2924 sd_bus_slot
*s
= NULL
;
2927 assert_return(bus
, -EINVAL
);
2928 assert_return(match
, -EINVAL
);
2929 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2931 r
= bus_match_parse(match
, &components
, &n_components
);
2935 s
= bus_slot_allocate(bus
, !slot
, BUS_MATCH_CALLBACK
, sizeof(struct match_callback
), userdata
);
2941 s
->match_callback
.callback
= callback
;
2942 s
->match_callback
.cookie
= ++bus
->match_cookie
;
2944 if (bus
->bus_client
) {
2945 enum bus_match_scope scope
;
2947 scope
= bus_match_get_scope(components
, n_components
);
2949 /* Do not install server-side matches for matches
2950 * against the local service, interface or bus
2952 if (scope
!= BUS_MATCH_LOCAL
) {
2954 if (!bus
->is_kernel
) {
2955 /* When this is not a kernel transport, we
2956 * store the original match string, so that we
2957 * can use it to remove the match again */
2959 s
->match_callback
.match_string
= strdup(match
);
2960 if (!s
->match_callback
.match_string
) {
2966 r
= bus_add_match_internal(bus
, s
->match_callback
.match_string
, components
, n_components
, s
->match_callback
.cookie
);
2970 s
->match_added
= true;
2974 bus
->match_callbacks_modified
= true;
2975 r
= bus_match_add(&bus
->match_callbacks
, components
, n_components
, &s
->match_callback
);
2984 bus_match_parse_free(components
, n_components
);
2985 sd_bus_slot_unref(s
);
2990 int bus_remove_match_by_string(
2993 sd_bus_message_handler_t callback
,
2996 struct bus_match_component
*components
= NULL
;
2997 unsigned n_components
= 0;
2998 struct match_callback
*c
;
3001 assert_return(bus
, -EINVAL
);
3002 assert_return(match
, -EINVAL
);
3003 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3005 r
= bus_match_parse(match
, &components
, &n_components
);
3009 r
= bus_match_find(&bus
->match_callbacks
, components
, n_components
, NULL
, NULL
, &c
);
3013 sd_bus_slot_unref(container_of(c
, sd_bus_slot
, match_callback
));
3016 bus_match_parse_free(components
, n_components
);
3021 bool bus_pid_changed(sd_bus
*bus
) {
3024 /* We don't support people creating a bus connection and
3025 * keeping it around over a fork(). Let's complain. */
3027 return bus
->original_pid
!= getpid();
3030 static int io_callback(sd_event_source
*s
, int fd
, uint32_t revents
, void *userdata
) {
3031 sd_bus
*bus
= userdata
;
3036 r
= sd_bus_process(bus
, NULL
);
3043 static int time_callback(sd_event_source
*s
, uint64_t usec
, void *userdata
) {
3044 sd_bus
*bus
= userdata
;
3049 r
= sd_bus_process(bus
, NULL
);
3056 static int prepare_callback(sd_event_source
*s
, void *userdata
) {
3057 sd_bus
*bus
= userdata
;
3064 e
= sd_bus_get_events(bus
);
3068 if (bus
->output_fd
!= bus
->input_fd
) {
3070 r
= sd_event_source_set_io_events(bus
->input_io_event_source
, e
& POLLIN
);
3074 r
= sd_event_source_set_io_events(bus
->output_io_event_source
, e
& POLLOUT
);
3078 r
= sd_event_source_set_io_events(bus
->input_io_event_source
, e
);
3083 r
= sd_bus_get_timeout(bus
, &until
);
3089 j
= sd_event_source_set_time(bus
->time_event_source
, until
);
3094 r
= sd_event_source_set_enabled(bus
->time_event_source
, r
> 0);
3101 static int quit_callback(sd_event_source
*event
, void *userdata
) {
3102 sd_bus
*bus
= userdata
;
3112 static int attach_io_events(sd_bus
*bus
) {
3117 if (bus
->input_fd
< 0)
3123 if (!bus
->input_io_event_source
) {
3124 r
= sd_event_add_io(bus
->event
, &bus
->input_io_event_source
, bus
->input_fd
, 0, io_callback
, bus
);
3128 r
= sd_event_source_set_prepare(bus
->input_io_event_source
, prepare_callback
);
3132 r
= sd_event_source_set_priority(bus
->input_io_event_source
, bus
->event_priority
);
3136 r
= sd_event_source_set_description(bus
->input_io_event_source
, "bus-input");
3138 r
= sd_event_source_set_io_fd(bus
->input_io_event_source
, bus
->input_fd
);
3143 if (bus
->output_fd
!= bus
->input_fd
) {
3144 assert(bus
->output_fd
>= 0);
3146 if (!bus
->output_io_event_source
) {
3147 r
= sd_event_add_io(bus
->event
, &bus
->output_io_event_source
, bus
->output_fd
, 0, io_callback
, bus
);
3151 r
= sd_event_source_set_priority(bus
->output_io_event_source
, bus
->event_priority
);
3155 r
= sd_event_source_set_description(bus
->input_io_event_source
, "bus-output");
3157 r
= sd_event_source_set_io_fd(bus
->output_io_event_source
, bus
->output_fd
);
3166 static void detach_io_events(sd_bus
*bus
) {
3169 if (bus
->input_io_event_source
) {
3170 sd_event_source_set_enabled(bus
->input_io_event_source
, SD_EVENT_OFF
);
3171 bus
->input_io_event_source
= sd_event_source_unref(bus
->input_io_event_source
);
3174 if (bus
->output_io_event_source
) {
3175 sd_event_source_set_enabled(bus
->output_io_event_source
, SD_EVENT_OFF
);
3176 bus
->output_io_event_source
= sd_event_source_unref(bus
->output_io_event_source
);
3180 _public_
int sd_bus_attach_event(sd_bus
*bus
, sd_event
*event
, int priority
) {
3183 assert_return(bus
, -EINVAL
);
3184 assert_return(!bus
->event
, -EBUSY
);
3186 assert(!bus
->input_io_event_source
);
3187 assert(!bus
->output_io_event_source
);
3188 assert(!bus
->time_event_source
);
3191 bus
->event
= sd_event_ref(event
);
3193 r
= sd_event_default(&bus
->event
);
3198 bus
->event_priority
= priority
;
3200 r
= sd_event_add_time(bus
->event
, &bus
->time_event_source
, CLOCK_MONOTONIC
, 0, 0, time_callback
, bus
);
3204 r
= sd_event_source_set_priority(bus
->time_event_source
, priority
);
3208 r
= sd_event_source_set_description(bus
->time_event_source
, "bus-time");
3212 r
= sd_event_add_exit(bus
->event
, &bus
->quit_event_source
, quit_callback
, bus
);
3216 r
= sd_event_source_set_description(bus
->quit_event_source
, "bus-exit");
3220 r
= attach_io_events(bus
);
3227 sd_bus_detach_event(bus
);
3231 _public_
int sd_bus_detach_event(sd_bus
*bus
) {
3232 assert_return(bus
, -EINVAL
);
3237 detach_io_events(bus
);
3239 if (bus
->time_event_source
) {
3240 sd_event_source_set_enabled(bus
->time_event_source
, SD_EVENT_OFF
);
3241 bus
->time_event_source
= sd_event_source_unref(bus
->time_event_source
);
3244 if (bus
->quit_event_source
) {
3245 sd_event_source_set_enabled(bus
->quit_event_source
, SD_EVENT_OFF
);
3246 bus
->quit_event_source
= sd_event_source_unref(bus
->quit_event_source
);
3249 bus
->event
= sd_event_unref(bus
->event
);
3253 _public_ sd_event
* sd_bus_get_event(sd_bus
*bus
) {
3254 assert_return(bus
, NULL
);
3259 _public_ sd_bus_message
* sd_bus_get_current_message(sd_bus
*bus
) {
3260 assert_return(bus
, NULL
);
3262 return bus
->current_message
;
3265 _public_ sd_bus_slot
* sd_bus_get_current_slot(sd_bus
*bus
) {
3266 assert_return(bus
, NULL
);
3268 return bus
->current_slot
;
3271 _public_ sd_bus_message_handler_t
sd_bus_get_current_handler(sd_bus
*bus
) {
3272 assert_return(bus
, NULL
);
3274 return bus
->current_handler
;
3277 _public_
void* sd_bus_get_current_userdata(sd_bus
*bus
) {
3278 assert_return(bus
, NULL
);
3280 return bus
->current_userdata
;
3283 static int bus_default(int (*bus_open
)(sd_bus
**), sd_bus
**default_bus
, sd_bus
**ret
) {
3288 assert(default_bus
);
3291 return !!*default_bus
;
3294 *ret
= sd_bus_ref(*default_bus
);
3302 b
->default_bus_ptr
= default_bus
;
3310 _public_
int sd_bus_default_system(sd_bus
**ret
) {
3311 static thread_local sd_bus
*default_system_bus
= NULL
;
3313 return bus_default(sd_bus_open_system
, &default_system_bus
, ret
);
3316 _public_
int sd_bus_default_user(sd_bus
**ret
) {
3317 static thread_local sd_bus
*default_user_bus
= NULL
;
3319 return bus_default(sd_bus_open_user
, &default_user_bus
, ret
);
3322 _public_
int sd_bus_default(sd_bus
**ret
) {
3326 /* Let's try our best to reuse another cached connection. If
3327 * the starter bus type is set, connect via our normal
3328 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3329 * we can share the connection with the user/system default
3332 e
= secure_getenv("DBUS_STARTER_BUS_TYPE");
3334 if (streq(e
, "system"))
3335 return sd_bus_default_system(ret
);
3336 else if (STR_IN_SET(e
, "user", "session"))
3337 return sd_bus_default_user(ret
);
3340 /* No type is specified, so we have not other option than to
3341 * use the starter address if it is set. */
3343 e
= secure_getenv("DBUS_STARTER_ADDRESS");
3345 static thread_local sd_bus
*default_starter_bus
= NULL
;
3347 return bus_default(sd_bus_open
, &default_starter_bus
, ret
);
3350 /* Finally, if nothing is set use the cached connection for
3351 * the right scope */
3353 if (cg_pid_get_owner_uid(0, NULL
) >= 0)
3354 return sd_bus_default_user(ret
);
3356 return sd_bus_default_system(ret
);
3359 _public_
int sd_bus_get_tid(sd_bus
*b
, pid_t
*tid
) {
3360 assert_return(b
, -EINVAL
);
3361 assert_return(tid
, -EINVAL
);
3362 assert_return(!bus_pid_changed(b
), -ECHILD
);
3370 return sd_event_get_tid(b
->event
, tid
);
3375 _public_
int sd_bus_path_encode(const char *prefix
, const char *external_id
, char **ret_path
) {
3376 _cleanup_free_
char *e
= NULL
;
3379 assert_return(object_path_is_valid(prefix
), -EINVAL
);
3380 assert_return(external_id
, -EINVAL
);
3381 assert_return(ret_path
, -EINVAL
);
3383 e
= bus_label_escape(external_id
);
3387 ret
= strjoin(prefix
, "/", e
, NULL
);
3395 _public_
int sd_bus_path_decode(const char *path
, const char *prefix
, char **external_id
) {
3399 assert_return(object_path_is_valid(path
), -EINVAL
);
3400 assert_return(object_path_is_valid(prefix
), -EINVAL
);
3401 assert_return(external_id
, -EINVAL
);
3403 e
= object_path_startswith(path
, prefix
);
3405 *external_id
= NULL
;
3409 ret
= bus_label_unescape(e
);
3417 _public_
int sd_bus_try_close(sd_bus
*bus
) {
3420 assert_return(bus
, -EINVAL
);
3421 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3423 if (!bus
->is_kernel
)
3426 if (!BUS_IS_OPEN(bus
->state
))
3429 if (bus
->rqueue_size
> 0)
3432 if (bus
->wqueue_size
> 0)
3435 r
= bus_kernel_try_close(bus
);
3443 _public_
int sd_bus_get_description(sd_bus
*bus
, const char **description
) {
3444 assert_return(bus
, -EINVAL
);
3445 assert_return(description
, -EINVAL
);
3446 assert_return(bus
->description
, -ENXIO
);
3447 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3449 *description
= bus
->description
;
3453 int bus_get_root_path(sd_bus
*bus
) {
3456 if (bus
->cgroup_root
)
3459 r
= cg_get_root_path(&bus
->cgroup_root
);
3461 bus
->cgroup_root
= strdup("/");
3462 if (!bus
->cgroup_root
)
3471 _public_
int sd_bus_get_scope(sd_bus
*bus
, const char **scope
) {
3474 assert_return(bus
, -EINVAL
);
3475 assert_return(scope
, -EINVAL
);
3476 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3478 if (bus
->is_kernel
) {
3479 _cleanup_free_
char *n
= NULL
;
3482 r
= bus_kernel_get_bus_name(bus
, &n
);
3486 if (streq(n
, "0-system")) {
3491 dash
= strchr(n
, '-');
3492 if (streq_ptr(dash
, "-user")) {
3503 if (bus
->is_system
) {
3511 _public_
int sd_bus_get_address(sd_bus
*bus
, const char **address
) {
3513 assert_return(bus
, -EINVAL
);
3514 assert_return(address
, -EINVAL
);
3515 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3518 *address
= bus
->address
;
3525 _public_
int sd_bus_get_creds_mask(sd_bus
*bus
, uint64_t *mask
) {
3526 assert_return(bus
, -EINVAL
);
3527 assert_return(mask
, -EINVAL
);
3528 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3530 *mask
= bus
->creds_mask
;
3534 _public_
int sd_bus_is_bus_client(sd_bus
*bus
) {
3535 assert_return(bus
, -EINVAL
);
3536 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3538 return bus
->bus_client
;
3541 _public_
int sd_bus_is_server(sd_bus
*bus
) {
3542 assert_return(bus
, -EINVAL
);
3543 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3545 return bus
->is_server
;
3548 _public_
int sd_bus_is_anonymous(sd_bus
*bus
) {
3549 assert_return(bus
, -EINVAL
);
3550 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3552 return bus
->anonymous_auth
;
3555 _public_
int sd_bus_is_trusted(sd_bus
*bus
) {
3556 assert_return(bus
, -EINVAL
);
3557 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3559 return bus
->trusted
;
3562 _public_
int sd_bus_is_monitor(sd_bus
*bus
) {
3563 assert_return(bus
, -EINVAL
);
3564 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3566 return !!(bus
->hello_flags
& KDBUS_HELLO_MONITOR
);