1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2013 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
35 #include "cgroup-util.h"
36 #include "hostname-util.h"
37 #include "bus-label.h"
40 #include "bus-internal.h"
41 #include "bus-message.h"
43 #include "bus-socket.h"
44 #include "bus-kernel.h"
45 #include "bus-control.h"
46 #include "bus-objects.h"
48 #include "bus-container.h"
49 #include "bus-protocol.h"
50 #include "bus-track.h"
53 #define log_debug_bus_message(m) \
55 sd_bus_message *_mm = (m); \
56 log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s", \
57 bus_message_type_to_string(_mm->header->type), \
58 strna(sd_bus_message_get_sender(_mm)), \
59 strna(sd_bus_message_get_destination(_mm)), \
60 strna(sd_bus_message_get_path(_mm)), \
61 strna(sd_bus_message_get_interface(_mm)), \
62 strna(sd_bus_message_get_member(_mm)), \
63 BUS_MESSAGE_COOKIE(_mm), \
65 strna(_mm->error.message)); \
68 static int bus_poll(sd_bus
*bus
, bool need_more
, uint64_t timeout_usec
);
69 static int attach_io_events(sd_bus
*b
);
70 static void detach_io_events(sd_bus
*b
);
72 static thread_local sd_bus
*default_system_bus
= NULL
;
73 static thread_local sd_bus
*default_user_bus
= NULL
;
74 static thread_local sd_bus
*default_starter_bus
= NULL
;
76 static void bus_close_fds(sd_bus
*b
) {
81 if (b
->input_fd
!= b
->output_fd
)
82 safe_close(b
->output_fd
);
83 b
->output_fd
= b
->input_fd
= safe_close(b
->input_fd
);
86 static void bus_reset_queues(sd_bus
*b
) {
89 while (b
->rqueue_size
> 0)
90 sd_bus_message_unref(b
->rqueue
[--b
->rqueue_size
]);
92 b
->rqueue
= mfree(b
->rqueue
);
93 b
->rqueue_allocated
= 0;
95 while (b
->wqueue_size
> 0)
96 sd_bus_message_unref(b
->wqueue
[--b
->wqueue_size
]);
98 b
->wqueue
= mfree(b
->wqueue
);
99 b
->wqueue_allocated
= 0;
102 static void bus_free(sd_bus
*b
) {
106 assert(!b
->track_queue
);
108 b
->state
= BUS_CLOSED
;
110 sd_bus_detach_event(b
);
112 while ((s
= b
->slots
)) {
113 /* At this point only floating slots can still be
114 * around, because the non-floating ones keep a
115 * reference to the bus, and we thus couldn't be
116 * destructing right now... We forcibly disconnect the
117 * slots here, so that they still can be referenced by
118 * apps, but are dead. */
121 bus_slot_disconnect(s
);
122 sd_bus_slot_unref(s
);
125 if (b
->default_bus_ptr
)
126 *b
->default_bus_ptr
= NULL
;
131 munmap(b
->kdbus_buffer
, KDBUS_POOL_SIZE
);
135 free(b
->unique_name
);
136 free(b
->auth_buffer
);
141 free(b
->cgroup_root
);
142 free(b
->description
);
145 strv_free(b
->exec_argv
);
147 close_many(b
->fds
, b
->n_fds
);
152 ordered_hashmap_free_free(b
->reply_callbacks
);
153 prioq_free(b
->reply_callbacks_prioq
);
155 assert(b
->match_callbacks
.type
== BUS_MATCH_ROOT
);
156 bus_match_free(&b
->match_callbacks
);
158 hashmap_free_free(b
->vtable_methods
);
159 hashmap_free_free(b
->vtable_properties
);
161 assert(hashmap_isempty(b
->nodes
));
162 hashmap_free(b
->nodes
);
164 bus_kernel_flush_memfd(b
);
166 assert_se(pthread_mutex_destroy(&b
->memfd_cache_mutex
) == 0);
171 _public_
int sd_bus_new(sd_bus
**ret
) {
174 assert_return(ret
, -EINVAL
);
180 r
->n_ref
= REFCNT_INIT
;
181 r
->input_fd
= r
->output_fd
= -1;
182 r
->message_version
= 1;
183 r
->creds_mask
|= SD_BUS_CREDS_WELL_KNOWN_NAMES
|SD_BUS_CREDS_UNIQUE_NAME
;
184 r
->hello_flags
|= KDBUS_HELLO_ACCEPT_FD
;
185 r
->attach_flags
|= KDBUS_ATTACH_NAMES
;
186 r
->original_pid
= getpid();
188 assert_se(pthread_mutex_init(&r
->memfd_cache_mutex
, NULL
) == 0);
190 /* We guarantee that wqueue always has space for at least one
192 if (!GREEDY_REALLOC(r
->wqueue
, r
->wqueue_allocated
, 1)) {
201 _public_
int sd_bus_set_address(sd_bus
*bus
, const char *address
) {
204 assert_return(bus
, -EINVAL
);
205 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
206 assert_return(address
, -EINVAL
);
207 assert_return(!bus_pid_changed(bus
), -ECHILD
);
219 _public_
int sd_bus_set_fd(sd_bus
*bus
, int input_fd
, int output_fd
) {
220 assert_return(bus
, -EINVAL
);
221 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
222 assert_return(input_fd
>= 0, -EBADF
);
223 assert_return(output_fd
>= 0, -EBADF
);
224 assert_return(!bus_pid_changed(bus
), -ECHILD
);
226 bus
->input_fd
= input_fd
;
227 bus
->output_fd
= output_fd
;
231 _public_
int sd_bus_set_exec(sd_bus
*bus
, const char *path
, char *const argv
[]) {
234 assert_return(bus
, -EINVAL
);
235 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
236 assert_return(path
, -EINVAL
);
237 assert_return(!strv_isempty(argv
), -EINVAL
);
238 assert_return(!bus_pid_changed(bus
), -ECHILD
);
250 free(bus
->exec_path
);
251 strv_free(bus
->exec_argv
);
259 _public_
int sd_bus_set_bus_client(sd_bus
*bus
, int b
) {
260 assert_return(bus
, -EINVAL
);
261 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
262 assert_return(!bus_pid_changed(bus
), -ECHILD
);
264 bus
->bus_client
= !!b
;
268 _public_
int sd_bus_set_monitor(sd_bus
*bus
, int b
) {
269 assert_return(bus
, -EINVAL
);
270 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
271 assert_return(!bus_pid_changed(bus
), -ECHILD
);
273 SET_FLAG(bus
->hello_flags
, KDBUS_HELLO_MONITOR
, b
);
277 _public_
int sd_bus_negotiate_fds(sd_bus
*bus
, int b
) {
278 assert_return(bus
, -EINVAL
);
279 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
280 assert_return(!bus_pid_changed(bus
), -ECHILD
);
282 SET_FLAG(bus
->hello_flags
, KDBUS_HELLO_ACCEPT_FD
, b
);
286 _public_
int sd_bus_negotiate_timestamp(sd_bus
*bus
, int b
) {
288 assert_return(bus
, -EINVAL
);
289 assert_return(!IN_SET(bus
->state
, BUS_CLOSING
, BUS_CLOSED
), -EPERM
);
290 assert_return(!bus_pid_changed(bus
), -ECHILD
);
292 new_flags
= bus
->attach_flags
;
293 SET_FLAG(new_flags
, KDBUS_ATTACH_TIMESTAMP
, b
);
295 if (bus
->attach_flags
== new_flags
)
298 bus
->attach_flags
= new_flags
;
299 if (bus
->state
!= BUS_UNSET
&& bus
->is_kernel
)
300 bus_kernel_realize_attach_flags(bus
);
305 _public_
int sd_bus_negotiate_creds(sd_bus
*bus
, int b
, uint64_t mask
) {
308 assert_return(bus
, -EINVAL
);
309 assert_return(mask
<= _SD_BUS_CREDS_ALL
, -EINVAL
);
310 assert_return(!IN_SET(bus
->state
, BUS_CLOSING
, BUS_CLOSED
), -EPERM
);
311 assert_return(!bus_pid_changed(bus
), -ECHILD
);
314 bus
->creds_mask
|= mask
;
316 bus
->creds_mask
&= ~mask
;
318 /* The well knowns we need unconditionally, so that matches can work */
319 bus
->creds_mask
|= SD_BUS_CREDS_WELL_KNOWN_NAMES
|SD_BUS_CREDS_UNIQUE_NAME
;
321 /* Make sure we don't lose the timestamp flag */
322 new_flags
= (bus
->attach_flags
& KDBUS_ATTACH_TIMESTAMP
) | attach_flags_to_kdbus(bus
->creds_mask
);
323 if (bus
->attach_flags
== new_flags
)
326 bus
->attach_flags
= new_flags
;
327 if (bus
->state
!= BUS_UNSET
&& bus
->is_kernel
)
328 bus_kernel_realize_attach_flags(bus
);
333 _public_
int sd_bus_set_server(sd_bus
*bus
, int b
, sd_id128_t server_id
) {
334 assert_return(bus
, -EINVAL
);
335 assert_return(b
|| sd_id128_equal(server_id
, SD_ID128_NULL
), -EINVAL
);
336 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
337 assert_return(!bus_pid_changed(bus
), -ECHILD
);
339 bus
->is_server
= !!b
;
340 bus
->server_id
= server_id
;
344 _public_
int sd_bus_set_anonymous(sd_bus
*bus
, int b
) {
345 assert_return(bus
, -EINVAL
);
346 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
347 assert_return(!bus_pid_changed(bus
), -ECHILD
);
349 bus
->anonymous_auth
= !!b
;
353 _public_
int sd_bus_set_trusted(sd_bus
*bus
, int b
) {
354 assert_return(bus
, -EINVAL
);
355 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
356 assert_return(!bus_pid_changed(bus
), -ECHILD
);
362 _public_
int sd_bus_set_description(sd_bus
*bus
, const char *description
) {
363 assert_return(bus
, -EINVAL
);
364 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
365 assert_return(!bus_pid_changed(bus
), -ECHILD
);
367 return free_and_strdup(&bus
->description
, description
);
370 _public_
int sd_bus_set_allow_interactive_authorization(sd_bus
*bus
, int b
) {
371 assert_return(bus
, -EINVAL
);
372 assert_return(!bus_pid_changed(bus
), -ECHILD
);
374 bus
->allow_interactive_authorization
= !!b
;
378 _public_
int sd_bus_get_allow_interactive_authorization(sd_bus
*bus
) {
379 assert_return(bus
, -EINVAL
);
380 assert_return(!bus_pid_changed(bus
), -ECHILD
);
382 return bus
->allow_interactive_authorization
;
385 static int hello_callback(sd_bus_message
*reply
, void *userdata
, sd_bus_error
*error
) {
393 assert(bus
->state
== BUS_HELLO
|| bus
->state
== BUS_CLOSING
);
395 r
= sd_bus_message_get_errno(reply
);
399 r
= sd_bus_message_read(reply
, "s", &s
);
403 if (!service_name_is_valid(s
) || s
[0] != ':')
406 bus
->unique_name
= strdup(s
);
407 if (!bus
->unique_name
)
410 if (bus
->state
== BUS_HELLO
)
411 bus
->state
= BUS_RUNNING
;
416 static int bus_send_hello(sd_bus
*bus
) {
417 _cleanup_bus_message_unref_ sd_bus_message
*m
= NULL
;
422 if (!bus
->bus_client
|| bus
->is_kernel
)
425 r
= sd_bus_message_new_method_call(
428 "org.freedesktop.DBus",
429 "/org/freedesktop/DBus",
430 "org.freedesktop.DBus",
435 return sd_bus_call_async(bus
, NULL
, m
, hello_callback
, NULL
, 0);
438 int bus_start_running(sd_bus
*bus
) {
441 if (bus
->bus_client
&& !bus
->is_kernel
) {
442 bus
->state
= BUS_HELLO
;
446 bus
->state
= BUS_RUNNING
;
450 static int parse_address_key(const char **p
, const char *key
, char **value
) {
451 size_t l
, n
= 0, allocated
= 0;
461 if (strncmp(*p
, key
, l
) != 0)
474 while (*a
!= ';' && *a
!= ',' && *a
!= 0) {
492 c
= (char) ((x
<< 4) | y
);
499 if (!GREEDY_REALLOC(r
, allocated
, n
+ 2))
523 static void skip_address_key(const char **p
) {
527 *p
+= strcspn(*p
, ",");
533 static int parse_unix_address(sd_bus
*b
, const char **p
, char **guid
) {
534 _cleanup_free_
char *path
= NULL
, *abstract
= NULL
;
543 while (**p
!= 0 && **p
!= ';') {
544 r
= parse_address_key(p
, "guid", guid
);
550 r
= parse_address_key(p
, "path", &path
);
556 r
= parse_address_key(p
, "abstract", &abstract
);
565 if (!path
&& !abstract
)
568 if (path
&& abstract
)
573 if (l
> sizeof(b
->sockaddr
.un
.sun_path
))
576 b
->sockaddr
.un
.sun_family
= AF_UNIX
;
577 strncpy(b
->sockaddr
.un
.sun_path
, path
, sizeof(b
->sockaddr
.un
.sun_path
));
578 b
->sockaddr_size
= offsetof(struct sockaddr_un
, sun_path
) + l
;
579 } else if (abstract
) {
580 l
= strlen(abstract
);
581 if (l
> sizeof(b
->sockaddr
.un
.sun_path
) - 1)
584 b
->sockaddr
.un
.sun_family
= AF_UNIX
;
585 b
->sockaddr
.un
.sun_path
[0] = 0;
586 strncpy(b
->sockaddr
.un
.sun_path
+1, abstract
, sizeof(b
->sockaddr
.un
.sun_path
)-1);
587 b
->sockaddr_size
= offsetof(struct sockaddr_un
, sun_path
) + 1 + l
;
593 static int parse_tcp_address(sd_bus
*b
, const char **p
, char **guid
) {
594 _cleanup_free_
char *host
= NULL
, *port
= NULL
, *family
= NULL
;
596 struct addrinfo
*result
, hints
= {
597 .ai_socktype
= SOCK_STREAM
,
598 .ai_flags
= AI_ADDRCONFIG
,
606 while (**p
!= 0 && **p
!= ';') {
607 r
= parse_address_key(p
, "guid", guid
);
613 r
= parse_address_key(p
, "host", &host
);
619 r
= parse_address_key(p
, "port", &port
);
625 r
= parse_address_key(p
, "family", &family
);
638 if (streq(family
, "ipv4"))
639 hints
.ai_family
= AF_INET
;
640 else if (streq(family
, "ipv6"))
641 hints
.ai_family
= AF_INET6
;
646 r
= getaddrinfo(host
, port
, &hints
, &result
);
650 return -EADDRNOTAVAIL
;
652 memcpy(&b
->sockaddr
, result
->ai_addr
, result
->ai_addrlen
);
653 b
->sockaddr_size
= result
->ai_addrlen
;
655 freeaddrinfo(result
);
660 static int parse_exec_address(sd_bus
*b
, const char **p
, char **guid
) {
662 unsigned n_argv
= 0, j
;
664 size_t allocated
= 0;
672 while (**p
!= 0 && **p
!= ';') {
673 r
= parse_address_key(p
, "guid", guid
);
679 r
= parse_address_key(p
, "path", &path
);
685 if (startswith(*p
, "argv")) {
689 ul
= strtoul(*p
+ 4, (char**) p
, 10);
690 if (errno
> 0 || **p
!= '=' || ul
> 256) {
698 if (!GREEDY_REALLOC0(argv
, allocated
, ul
+ 2)) {
706 r
= parse_address_key(p
, NULL
, argv
+ ul
);
721 /* Make sure there are no holes in the array, with the
722 * exception of argv[0] */
723 for (j
= 1; j
< n_argv
; j
++)
729 if (argv
&& argv
[0] == NULL
) {
730 argv
[0] = strdup(path
);
742 for (j
= 0; j
< n_argv
; j
++)
750 static int parse_kernel_address(sd_bus
*b
, const char **p
, char **guid
) {
751 _cleanup_free_
char *path
= NULL
;
759 while (**p
!= 0 && **p
!= ';') {
760 r
= parse_address_key(p
, "guid", guid
);
766 r
= parse_address_key(p
, "path", &path
);
785 static int parse_container_unix_address(sd_bus
*b
, const char **p
, char **guid
) {
786 _cleanup_free_
char *machine
= NULL
, *pid
= NULL
;
794 while (**p
!= 0 && **p
!= ';') {
795 r
= parse_address_key(p
, "guid", guid
);
801 r
= parse_address_key(p
, "machine", &machine
);
807 r
= parse_address_key(p
, "pid", &pid
);
816 if (!machine
== !pid
)
820 if (!machine_name_is_valid(machine
))
824 b
->machine
= machine
;
827 b
->machine
= mfree(b
->machine
);
831 r
= parse_pid(pid
, &b
->nspid
);
837 b
->sockaddr
.un
.sun_family
= AF_UNIX
;
838 strncpy(b
->sockaddr
.un
.sun_path
, "/var/run/dbus/system_bus_socket", sizeof(b
->sockaddr
.un
.sun_path
));
839 b
->sockaddr_size
= offsetof(struct sockaddr_un
, sun_path
) + strlen("/var/run/dbus/system_bus_socket");
844 static int parse_container_kernel_address(sd_bus
*b
, const char **p
, char **guid
) {
845 _cleanup_free_
char *machine
= NULL
, *pid
= NULL
;
853 while (**p
!= 0 && **p
!= ';') {
854 r
= parse_address_key(p
, "guid", guid
);
860 r
= parse_address_key(p
, "machine", &machine
);
866 r
= parse_address_key(p
, "pid", &pid
);
875 if (!machine
== !pid
)
879 if (!machine_name_is_valid(machine
))
883 b
->machine
= machine
;
886 b
->machine
= mfree(b
->machine
);
890 r
= parse_pid(pid
, &b
->nspid
);
896 r
= free_and_strdup(&b
->kernel
, "/sys/fs/kdbus/0-system/bus");
903 static void bus_reset_parsed_address(sd_bus
*b
) {
907 b
->sockaddr_size
= 0;
908 b
->exec_argv
= strv_free(b
->exec_argv
);
909 b
->exec_path
= mfree(b
->exec_path
);
910 b
->server_id
= SD_ID128_NULL
;
911 b
->kernel
= mfree(b
->kernel
);
912 b
->machine
= mfree(b
->machine
);
916 static int bus_parse_next_address(sd_bus
*b
) {
917 _cleanup_free_
char *guid
= NULL
;
925 if (b
->address
[b
->address_index
] == 0)
928 bus_reset_parsed_address(b
);
930 a
= b
->address
+ b
->address_index
;
939 if (startswith(a
, "unix:")) {
942 r
= parse_unix_address(b
, &a
, &guid
);
947 } else if (startswith(a
, "tcp:")) {
950 r
= parse_tcp_address(b
, &a
, &guid
);
956 } else if (startswith(a
, "unixexec:")) {
959 r
= parse_exec_address(b
, &a
, &guid
);
965 } else if (startswith(a
, "kernel:")) {
968 r
= parse_kernel_address(b
, &a
, &guid
);
973 } else if (startswith(a
, "x-machine-unix:")) {
976 r
= parse_container_unix_address(b
, &a
, &guid
);
981 } else if (startswith(a
, "x-machine-kernel:")) {
984 r
= parse_container_kernel_address(b
, &a
, &guid
);
997 r
= sd_id128_from_string(guid
, &b
->server_id
);
1002 b
->address_index
= a
- b
->address
;
1006 static int bus_start_address(sd_bus
*b
) {
1007 bool container_kdbus_available
= false;
1008 bool kdbus_available
= false;
1014 bool skipped
= false;
1019 * Usually, if you provide multiple different bus-addresses, we
1020 * try all of them in order. We use the first one that
1021 * succeeds. However, if you mix kernel and unix addresses, we
1022 * never try unix-addresses if a previous kernel address was
1023 * tried and kdbus was available. This is required to prevent
1024 * clients to fallback to the bus-proxy if kdbus is available
1025 * but failed (eg., too many connections).
1029 r
= bus_socket_exec(b
);
1030 else if ((b
->nspid
> 0 || b
->machine
) && b
->kernel
) {
1031 r
= bus_container_connect_kernel(b
);
1032 if (r
< 0 && !IN_SET(r
, -ENOENT
, -ESOCKTNOSUPPORT
))
1033 container_kdbus_available
= true;
1035 } else if ((b
->nspid
> 0 || b
->machine
) && b
->sockaddr
.sa
.sa_family
!= AF_UNSPEC
) {
1036 if (!container_kdbus_available
)
1037 r
= bus_container_connect_socket(b
);
1041 } else if (b
->kernel
) {
1042 r
= bus_kernel_connect(b
);
1043 if (r
< 0 && !IN_SET(r
, -ENOENT
, -ESOCKTNOSUPPORT
))
1044 kdbus_available
= true;
1046 } else if (b
->sockaddr
.sa
.sa_family
!= AF_UNSPEC
) {
1047 if (!kdbus_available
)
1048 r
= bus_socket_connect(b
);
1056 r
= attach_io_events(b
);
1061 b
->last_connect_error
= -r
;
1064 r
= bus_parse_next_address(b
);
1068 return b
->last_connect_error
? -b
->last_connect_error
: -ECONNREFUSED
;
1072 int bus_next_address(sd_bus
*b
) {
1075 bus_reset_parsed_address(b
);
1076 return bus_start_address(b
);
1079 static int bus_start_fd(sd_bus
*b
) {
1084 assert(b
->input_fd
>= 0);
1085 assert(b
->output_fd
>= 0);
1087 r
= fd_nonblock(b
->input_fd
, true);
1091 r
= fd_cloexec(b
->input_fd
, true);
1095 if (b
->input_fd
!= b
->output_fd
) {
1096 r
= fd_nonblock(b
->output_fd
, true);
1100 r
= fd_cloexec(b
->output_fd
, true);
1105 if (fstat(b
->input_fd
, &st
) < 0)
1108 if (S_ISCHR(b
->input_fd
))
1109 return bus_kernel_take_fd(b
);
1111 return bus_socket_take_fd(b
);
1114 _public_
int sd_bus_start(sd_bus
*bus
) {
1117 assert_return(bus
, -EINVAL
);
1118 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
1119 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1121 bus
->state
= BUS_OPENING
;
1123 if (bus
->is_server
&& bus
->bus_client
)
1126 if (bus
->input_fd
>= 0)
1127 r
= bus_start_fd(bus
);
1128 else if (bus
->address
|| bus
->sockaddr
.sa
.sa_family
!= AF_UNSPEC
|| bus
->exec_path
|| bus
->kernel
|| bus
->machine
)
1129 r
= bus_start_address(bus
);
1138 return bus_send_hello(bus
);
1141 _public_
int sd_bus_open(sd_bus
**ret
) {
1146 assert_return(ret
, -EINVAL
);
1148 /* Let's connect to the starter bus if it is set, and
1149 * otherwise to the bus that is appropropriate for the scope
1150 * we are running in */
1152 e
= secure_getenv("DBUS_STARTER_BUS_TYPE");
1154 if (streq(e
, "system"))
1155 return sd_bus_open_system(ret
);
1156 else if (STR_IN_SET(e
, "session", "user"))
1157 return sd_bus_open_user(ret
);
1160 e
= secure_getenv("DBUS_STARTER_ADDRESS");
1162 if (cg_pid_get_owner_uid(0, NULL
) >= 0)
1163 return sd_bus_open_user(ret
);
1165 return sd_bus_open_system(ret
);
1172 r
= sd_bus_set_address(b
, e
);
1176 b
->bus_client
= true;
1178 /* We don't know whether the bus is trusted or not, so better
1179 * be safe, and authenticate everything */
1181 b
->attach_flags
|= KDBUS_ATTACH_CAPS
| KDBUS_ATTACH_CREDS
;
1182 b
->creds_mask
|= SD_BUS_CREDS_UID
| SD_BUS_CREDS_EUID
| SD_BUS_CREDS_EFFECTIVE_CAPS
;
1184 r
= sd_bus_start(b
);
1196 int bus_set_address_system(sd_bus
*b
) {
1200 e
= secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1202 return sd_bus_set_address(b
, e
);
1204 return sd_bus_set_address(b
, DEFAULT_SYSTEM_BUS_ADDRESS
);
1207 _public_
int sd_bus_open_system(sd_bus
**ret
) {
1211 assert_return(ret
, -EINVAL
);
1217 r
= bus_set_address_system(b
);
1221 b
->bus_client
= true;
1222 b
->is_system
= true;
1224 /* Let's do per-method access control on the system bus. We
1225 * need the caller's UID and capability set for that. */
1227 b
->attach_flags
|= KDBUS_ATTACH_CAPS
| KDBUS_ATTACH_CREDS
;
1228 b
->creds_mask
|= SD_BUS_CREDS_UID
| SD_BUS_CREDS_EUID
| SD_BUS_CREDS_EFFECTIVE_CAPS
;
1230 r
= sd_bus_start(b
);
1242 int bus_set_address_user(sd_bus
*b
) {
1249 e
= secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1251 return sd_bus_set_address(b
, e
);
1253 r
= cg_pid_get_owner_uid(0, &uid
);
1257 e
= secure_getenv("XDG_RUNTIME_DIR");
1259 _cleanup_free_
char *ee
= NULL
;
1261 ee
= bus_address_escape(e
);
1265 (void) asprintf(&b
->address
, KERNEL_USER_BUS_ADDRESS_FMT
";" UNIX_USER_BUS_ADDRESS_FMT
, uid
, ee
);
1267 (void) asprintf(&b
->address
, KERNEL_USER_BUS_ADDRESS_FMT
, uid
);
1275 _public_
int sd_bus_open_user(sd_bus
**ret
) {
1279 assert_return(ret
, -EINVAL
);
1285 r
= bus_set_address_user(b
);
1289 b
->bus_client
= true;
1292 /* We don't do any per-method access control on the user
1296 r
= sd_bus_start(b
);
1308 int bus_set_address_system_remote(sd_bus
*b
, const char *host
) {
1309 _cleanup_free_
char *e
= NULL
;
1310 char *m
= NULL
, *c
= NULL
;
1315 /* Let's see if we shall enter some container */
1316 m
= strchr(host
, ':');
1320 /* Let's make sure this is not a port of some kind,
1321 * and is a valid machine name. */
1322 if (!in_charset(m
, "0123456789") && machine_name_is_valid(m
)) {
1325 /* Cut out the host part */
1326 t
= strndupa(host
, m
- host
- 1);
1327 e
= bus_address_escape(t
);
1331 c
= strjoina(",argv4=--machine=", m
);
1336 e
= bus_address_escape(host
);
1341 b
->address
= strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e
, ",argv3=systemd-stdio-bridge", c
, NULL
);
1348 _public_
int sd_bus_open_system_remote(sd_bus
**ret
, const char *host
) {
1352 assert_return(host
, -EINVAL
);
1353 assert_return(ret
, -EINVAL
);
1355 r
= sd_bus_new(&bus
);
1359 r
= bus_set_address_system_remote(bus
, host
);
1363 bus
->bus_client
= true;
1364 bus
->trusted
= false;
1365 bus
->is_system
= true;
1367 r
= sd_bus_start(bus
);
1379 int bus_set_address_system_machine(sd_bus
*b
, const char *machine
) {
1380 _cleanup_free_
char *e
= NULL
;
1385 e
= bus_address_escape(machine
);
1389 b
->address
= strjoin("x-machine-kernel:machine=", e
, ";x-machine-unix:machine=", e
, NULL
);
1396 _public_
int sd_bus_open_system_machine(sd_bus
**ret
, const char *machine
) {
1400 assert_return(machine
, -EINVAL
);
1401 assert_return(ret
, -EINVAL
);
1402 assert_return(machine_name_is_valid(machine
), -EINVAL
);
1404 r
= sd_bus_new(&bus
);
1408 r
= bus_set_address_system_machine(bus
, machine
);
1412 bus
->bus_client
= true;
1413 bus
->trusted
= false;
1414 bus
->is_system
= true;
1416 r
= sd_bus_start(bus
);
1428 _public_
void sd_bus_close(sd_bus
*bus
) {
1432 if (bus
->state
== BUS_CLOSED
)
1434 if (bus_pid_changed(bus
))
1437 bus
->state
= BUS_CLOSED
;
1439 sd_bus_detach_event(bus
);
1441 /* Drop all queued messages so that they drop references to
1442 * the bus object and the bus may be freed */
1443 bus_reset_queues(bus
);
1445 if (!bus
->is_kernel
)
1448 /* We'll leave the fd open in case this is a kernel bus, since
1449 * there might still be memblocks around that reference this
1450 * bus, and they might need to invoke the KDBUS_CMD_FREE
1451 * ioctl on the fd when they are freed. */
1454 _public_ sd_bus
* sd_bus_flush_close_unref(sd_bus
*bus
) {
1462 return sd_bus_unref(bus
);
1465 static void bus_enter_closing(sd_bus
*bus
) {
1468 if (bus
->state
!= BUS_OPENING
&&
1469 bus
->state
!= BUS_AUTHENTICATING
&&
1470 bus
->state
!= BUS_HELLO
&&
1471 bus
->state
!= BUS_RUNNING
)
1474 bus
->state
= BUS_CLOSING
;
1477 _public_ sd_bus
*sd_bus_ref(sd_bus
*bus
) {
1478 assert_return(bus
, NULL
);
1480 assert_se(REFCNT_INC(bus
->n_ref
) >= 2);
1485 _public_ sd_bus
*sd_bus_unref(sd_bus
*bus
) {
1491 i
= REFCNT_DEC(bus
->n_ref
);
1499 _public_
int sd_bus_is_open(sd_bus
*bus
) {
1501 assert_return(bus
, -EINVAL
);
1502 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1504 return BUS_IS_OPEN(bus
->state
);
1507 _public_
int sd_bus_can_send(sd_bus
*bus
, char type
) {
1510 assert_return(bus
, -EINVAL
);
1511 assert_return(bus
->state
!= BUS_UNSET
, -ENOTCONN
);
1512 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1514 if (bus
->hello_flags
& KDBUS_HELLO_MONITOR
)
1517 if (type
== SD_BUS_TYPE_UNIX_FD
) {
1518 if (!(bus
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
))
1521 r
= bus_ensure_running(bus
);
1525 return bus
->can_fds
;
1528 return bus_type_is_valid(type
);
1531 _public_
int sd_bus_get_bus_id(sd_bus
*bus
, sd_id128_t
*id
) {
1534 assert_return(bus
, -EINVAL
);
1535 assert_return(id
, -EINVAL
);
1536 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1538 r
= bus_ensure_running(bus
);
1542 *id
= bus
->server_id
;
1546 static int bus_seal_message(sd_bus
*b
, sd_bus_message
*m
, usec_t timeout
) {
1551 /* If we copy the same message to multiple
1552 * destinations, avoid using the same cookie
1554 b
->cookie
= MAX(b
->cookie
, BUS_MESSAGE_COOKIE(m
));
1559 timeout
= BUS_DEFAULT_TIMEOUT
;
1561 return bus_message_seal(m
, ++b
->cookie
, timeout
);
1564 static int bus_remarshal_message(sd_bus
*b
, sd_bus_message
**m
) {
1565 bool remarshal
= false;
1569 /* wrong packet version */
1570 if (b
->message_version
!= 0 && b
->message_version
!= (*m
)->header
->version
)
1573 /* wrong packet endianness */
1574 if (b
->message_endian
!= 0 && b
->message_endian
!= (*m
)->header
->endian
)
1577 /* TODO: kdbus-messages received from the kernel contain data which is
1578 * not allowed to be passed to KDBUS_CMD_SEND. Therefore, we have to
1579 * force remarshaling of the message. Technically, we could just
1580 * recreate the kdbus message, but that is non-trivial as other parts of
1581 * the message refer to m->kdbus already. This should be fixed! */
1582 if ((*m
)->kdbus
&& (*m
)->release_kdbus
)
1585 return remarshal
? bus_message_remarshal(b
, m
) : 0;
1588 int bus_seal_synthetic_message(sd_bus
*b
, sd_bus_message
*m
) {
1592 /* Fake some timestamps, if they were requested, and not
1593 * already initialized */
1594 if (b
->attach_flags
& KDBUS_ATTACH_TIMESTAMP
) {
1595 if (m
->realtime
<= 0)
1596 m
->realtime
= now(CLOCK_REALTIME
);
1598 if (m
->monotonic
<= 0)
1599 m
->monotonic
= now(CLOCK_MONOTONIC
);
1602 /* The bus specification says the serial number cannot be 0,
1603 * hence let's fill something in for synthetic messages. Since
1604 * synthetic messages might have a fake sender and we don't
1605 * want to interfere with the real sender's serial numbers we
1606 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1607 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1608 * even though kdbus can do 64bit. */
1609 return bus_message_seal(m
, 0xFFFFFFFFULL
, 0);
1612 static int bus_write_message(sd_bus
*bus
, sd_bus_message
*m
, bool hint_sync_call
, size_t *idx
) {
1619 r
= bus_kernel_write_message(bus
, m
, hint_sync_call
);
1621 r
= bus_socket_write_message(bus
, m
, idx
);
1626 if (bus
->is_kernel
|| *idx
>= BUS_MESSAGE_SIZE(m
))
1627 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64
" reply_cookie=%" PRIu64
" error=%s",
1628 bus_message_type_to_string(m
->header
->type
),
1629 strna(sd_bus_message_get_sender(m
)),
1630 strna(sd_bus_message_get_destination(m
)),
1631 strna(sd_bus_message_get_path(m
)),
1632 strna(sd_bus_message_get_interface(m
)),
1633 strna(sd_bus_message_get_member(m
)),
1634 BUS_MESSAGE_COOKIE(m
),
1636 strna(m
->error
.message
));
1641 static int dispatch_wqueue(sd_bus
*bus
) {
1645 assert(bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
);
1647 while (bus
->wqueue_size
> 0) {
1649 r
= bus_write_message(bus
, bus
->wqueue
[0], false, &bus
->windex
);
1653 /* Didn't do anything this time */
1655 else if (bus
->is_kernel
|| bus
->windex
>= BUS_MESSAGE_SIZE(bus
->wqueue
[0])) {
1656 /* Fully written. Let's drop the entry from
1659 * This isn't particularly optimized, but
1660 * well, this is supposed to be our worst-case
1661 * buffer only, and the socket buffer is
1662 * supposed to be our primary buffer, and if
1663 * it got full, then all bets are off
1666 bus
->wqueue_size
--;
1667 sd_bus_message_unref(bus
->wqueue
[0]);
1668 memmove(bus
->wqueue
, bus
->wqueue
+ 1, sizeof(sd_bus_message
*) * bus
->wqueue_size
);
1678 static int bus_read_message(sd_bus
*bus
, bool hint_priority
, int64_t priority
) {
1682 return bus_kernel_read_message(bus
, hint_priority
, priority
);
1684 return bus_socket_read_message(bus
);
1687 int bus_rqueue_make_room(sd_bus
*bus
) {
1690 if (bus
->rqueue_size
>= BUS_RQUEUE_MAX
)
1693 if (!GREEDY_REALLOC(bus
->rqueue
, bus
->rqueue_allocated
, bus
->rqueue_size
+ 1))
1699 static int dispatch_rqueue(sd_bus
*bus
, bool hint_priority
, int64_t priority
, sd_bus_message
**m
) {
1704 assert(bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
);
1706 /* Note that the priority logic is only available on kdbus,
1707 * where the rqueue is unused. We check the rqueue here
1708 * anyway, because it's simple... */
1711 if (bus
->rqueue_size
> 0) {
1712 /* Dispatch a queued message */
1714 *m
= bus
->rqueue
[0];
1715 bus
->rqueue_size
--;
1716 memmove(bus
->rqueue
, bus
->rqueue
+ 1, sizeof(sd_bus_message
*) * bus
->rqueue_size
);
1720 /* Try to read a new message */
1721 r
= bus_read_message(bus
, hint_priority
, priority
);
1731 static int bus_send_internal(sd_bus
*bus
, sd_bus_message
*_m
, uint64_t *cookie
, bool hint_sync_call
) {
1732 _cleanup_bus_message_unref_ sd_bus_message
*m
= sd_bus_message_ref(_m
);
1735 assert_return(m
, -EINVAL
);
1740 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1741 assert_return(!bus
->is_kernel
|| !(bus
->hello_flags
& KDBUS_HELLO_MONITOR
), -EROFS
);
1743 if (!BUS_IS_OPEN(bus
->state
))
1747 r
= sd_bus_can_send(bus
, SD_BUS_TYPE_UNIX_FD
);
1754 /* If the cookie number isn't kept, then we know that no reply
1756 if (!cookie
&& !m
->sealed
)
1757 m
->header
->flags
|= BUS_MESSAGE_NO_REPLY_EXPECTED
;
1759 r
= bus_seal_message(bus
, m
, 0);
1763 /* Remarshall if we have to. This will possibly unref the
1764 * message and place a replacement in m */
1765 r
= bus_remarshal_message(bus
, &m
);
1769 /* If this is a reply and no reply was requested, then let's
1770 * suppress this, if we can */
1774 if ((bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
) && bus
->wqueue_size
<= 0) {
1777 r
= bus_write_message(bus
, m
, hint_sync_call
, &idx
);
1779 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
1780 bus_enter_closing(bus
);
1787 if (!bus
->is_kernel
&& idx
< BUS_MESSAGE_SIZE(m
)) {
1788 /* Wasn't fully written. So let's remember how
1789 * much was written. Note that the first entry
1790 * of the wqueue array is always allocated so
1791 * that we always can remember how much was
1793 bus
->wqueue
[0] = sd_bus_message_ref(m
);
1794 bus
->wqueue_size
= 1;
1799 /* Just append it to the queue. */
1801 if (bus
->wqueue_size
>= BUS_WQUEUE_MAX
)
1804 if (!GREEDY_REALLOC(bus
->wqueue
, bus
->wqueue_allocated
, bus
->wqueue_size
+ 1))
1807 bus
->wqueue
[bus
->wqueue_size
++] = sd_bus_message_ref(m
);
1812 *cookie
= BUS_MESSAGE_COOKIE(m
);
1817 _public_
int sd_bus_send(sd_bus
*bus
, sd_bus_message
*m
, uint64_t *cookie
) {
1818 return bus_send_internal(bus
, m
, cookie
, false);
1821 _public_
int sd_bus_send_to(sd_bus
*bus
, sd_bus_message
*m
, const char *destination
, uint64_t *cookie
) {
1824 assert_return(m
, -EINVAL
);
1829 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1831 if (!BUS_IS_OPEN(bus
->state
))
1834 if (!streq_ptr(m
->destination
, destination
)) {
1839 r
= sd_bus_message_set_destination(m
, destination
);
1844 return sd_bus_send(bus
, m
, cookie
);
1847 static usec_t
calc_elapse(uint64_t usec
) {
1848 if (usec
== (uint64_t) -1)
1851 return now(CLOCK_MONOTONIC
) + usec
;
1854 static int timeout_compare(const void *a
, const void *b
) {
1855 const struct reply_callback
*x
= a
, *y
= b
;
1857 if (x
->timeout
!= 0 && y
->timeout
== 0)
1860 if (x
->timeout
== 0 && y
->timeout
!= 0)
1863 if (x
->timeout
< y
->timeout
)
1866 if (x
->timeout
> y
->timeout
)
1872 _public_
int sd_bus_call_async(
1876 sd_bus_message_handler_t callback
,
1880 _cleanup_bus_message_unref_ sd_bus_message
*m
= sd_bus_message_ref(_m
);
1881 _cleanup_bus_slot_unref_ sd_bus_slot
*s
= NULL
;
1884 assert_return(m
, -EINVAL
);
1885 assert_return(m
->header
->type
== SD_BUS_MESSAGE_METHOD_CALL
, -EINVAL
);
1886 assert_return(!(m
->header
->flags
& BUS_MESSAGE_NO_REPLY_EXPECTED
), -EINVAL
);
1887 assert_return(callback
, -EINVAL
);
1892 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1893 assert_return(!bus
->is_kernel
|| !(bus
->hello_flags
& KDBUS_HELLO_MONITOR
), -EROFS
);
1895 if (!BUS_IS_OPEN(bus
->state
))
1898 r
= ordered_hashmap_ensure_allocated(&bus
->reply_callbacks
, &uint64_hash_ops
);
1902 r
= prioq_ensure_allocated(&bus
->reply_callbacks_prioq
, timeout_compare
);
1906 r
= bus_seal_message(bus
, m
, usec
);
1910 r
= bus_remarshal_message(bus
, &m
);
1914 s
= bus_slot_allocate(bus
, !slot
, BUS_REPLY_CALLBACK
, sizeof(struct reply_callback
), userdata
);
1918 s
->reply_callback
.callback
= callback
;
1920 s
->reply_callback
.cookie
= BUS_MESSAGE_COOKIE(m
);
1921 r
= ordered_hashmap_put(bus
->reply_callbacks
, &s
->reply_callback
.cookie
, &s
->reply_callback
);
1923 s
->reply_callback
.cookie
= 0;
1927 s
->reply_callback
.timeout
= calc_elapse(m
->timeout
);
1928 if (s
->reply_callback
.timeout
!= 0) {
1929 r
= prioq_put(bus
->reply_callbacks_prioq
, &s
->reply_callback
, &s
->reply_callback
.prioq_idx
);
1931 s
->reply_callback
.timeout
= 0;
1936 r
= sd_bus_send(bus
, m
, &s
->reply_callback
.cookie
);
1947 int bus_ensure_running(sd_bus
*bus
) {
1952 if (bus
->state
== BUS_UNSET
|| bus
->state
== BUS_CLOSED
|| bus
->state
== BUS_CLOSING
)
1954 if (bus
->state
== BUS_RUNNING
)
1958 r
= sd_bus_process(bus
, NULL
);
1961 if (bus
->state
== BUS_RUNNING
)
1966 r
= sd_bus_wait(bus
, (uint64_t) -1);
1972 _public_
int sd_bus_call(
1976 sd_bus_error
*error
,
1977 sd_bus_message
**reply
) {
1979 _cleanup_bus_message_unref_ sd_bus_message
*m
= sd_bus_message_ref(_m
);
1985 bus_assert_return(m
, -EINVAL
, error
);
1986 bus_assert_return(m
->header
->type
== SD_BUS_MESSAGE_METHOD_CALL
, -EINVAL
, error
);
1987 bus_assert_return(!(m
->header
->flags
& BUS_MESSAGE_NO_REPLY_EXPECTED
), -EINVAL
, error
);
1988 bus_assert_return(!bus_error_is_dirty(error
), -EINVAL
, error
);
1993 bus_assert_return(!bus_pid_changed(bus
), -ECHILD
, error
);
1994 bus_assert_return(!bus
->is_kernel
|| !(bus
->hello_flags
& KDBUS_HELLO_MONITOR
), -EROFS
, error
);
1996 if (!BUS_IS_OPEN(bus
->state
)) {
2001 r
= bus_ensure_running(bus
);
2005 i
= bus
->rqueue_size
;
2007 r
= bus_seal_message(bus
, m
, usec
);
2011 r
= bus_remarshal_message(bus
, &m
);
2015 r
= bus_send_internal(bus
, m
, &cookie
, true);
2019 timeout
= calc_elapse(m
->timeout
);
2024 while (i
< bus
->rqueue_size
) {
2025 sd_bus_message
*incoming
= NULL
;
2027 incoming
= bus
->rqueue
[i
];
2029 if (incoming
->reply_cookie
== cookie
) {
2030 /* Found a match! */
2032 memmove(bus
->rqueue
+ i
, bus
->rqueue
+ i
+ 1, sizeof(sd_bus_message
*) * (bus
->rqueue_size
- i
- 1));
2034 log_debug_bus_message(incoming
);
2036 if (incoming
->header
->type
== SD_BUS_MESSAGE_METHOD_RETURN
) {
2038 if (incoming
->n_fds
<= 0 || (bus
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
)) {
2042 sd_bus_message_unref(incoming
);
2047 r
= sd_bus_error_setf(error
, SD_BUS_ERROR_INCONSISTENT_MESSAGE
, "Reply message contained file descriptors which I couldn't accept. Sorry.");
2048 sd_bus_message_unref(incoming
);
2051 } else if (incoming
->header
->type
== SD_BUS_MESSAGE_METHOD_ERROR
) {
2052 r
= sd_bus_error_copy(error
, &incoming
->error
);
2053 sd_bus_message_unref(incoming
);
2060 } else if (BUS_MESSAGE_COOKIE(incoming
) == cookie
&&
2063 streq(bus
->unique_name
, incoming
->sender
)) {
2065 memmove(bus
->rqueue
+ i
, bus
->rqueue
+ i
+ 1, sizeof(sd_bus_message
*) * (bus
->rqueue_size
- i
- 1));
2068 /* Our own message? Somebody is trying
2069 * to send its own client a message,
2070 * let's not dead-lock, let's fail
2073 sd_bus_message_unref(incoming
);
2078 /* Try to read more, right-away */
2082 r
= bus_read_message(bus
, false, 0);
2084 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2085 bus_enter_closing(bus
);
2097 n
= now(CLOCK_MONOTONIC
);
2105 left
= (uint64_t) -1;
2107 r
= bus_poll(bus
, true, left
);
2115 r
= dispatch_wqueue(bus
);
2117 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2118 bus_enter_closing(bus
);
2127 return sd_bus_error_set_errno(error
, r
);
2130 _public_
int sd_bus_get_fd(sd_bus
*bus
) {
2132 assert_return(bus
, -EINVAL
);
2133 assert_return(bus
->input_fd
== bus
->output_fd
, -EPERM
);
2134 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2136 return bus
->input_fd
;
2139 _public_
int sd_bus_get_events(sd_bus
*bus
) {
2142 assert_return(bus
, -EINVAL
);
2143 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2145 if (!BUS_IS_OPEN(bus
->state
) && bus
->state
!= BUS_CLOSING
)
2148 if (bus
->state
== BUS_OPENING
)
2150 else if (bus
->state
== BUS_AUTHENTICATING
) {
2152 if (bus_socket_auth_needs_write(bus
))
2157 } else if (bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
) {
2158 if (bus
->rqueue_size
<= 0)
2160 if (bus
->wqueue_size
> 0)
2167 _public_
int sd_bus_get_timeout(sd_bus
*bus
, uint64_t *timeout_usec
) {
2168 struct reply_callback
*c
;
2170 assert_return(bus
, -EINVAL
);
2171 assert_return(timeout_usec
, -EINVAL
);
2172 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2174 if (!BUS_IS_OPEN(bus
->state
) && bus
->state
!= BUS_CLOSING
)
2177 if (bus
->track_queue
) {
2182 if (bus
->state
== BUS_CLOSING
) {
2187 if (bus
->state
== BUS_AUTHENTICATING
) {
2188 *timeout_usec
= bus
->auth_timeout
;
2192 if (bus
->state
!= BUS_RUNNING
&& bus
->state
!= BUS_HELLO
) {
2193 *timeout_usec
= (uint64_t) -1;
2197 if (bus
->rqueue_size
> 0) {
2202 c
= prioq_peek(bus
->reply_callbacks_prioq
);
2204 *timeout_usec
= (uint64_t) -1;
2208 if (c
->timeout
== 0) {
2209 *timeout_usec
= (uint64_t) -1;
2213 *timeout_usec
= c
->timeout
;
2217 static int process_timeout(sd_bus
*bus
) {
2218 _cleanup_bus_error_free_ sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2219 _cleanup_bus_message_unref_ sd_bus_message
* m
= NULL
;
2220 struct reply_callback
*c
;
2227 c
= prioq_peek(bus
->reply_callbacks_prioq
);
2231 n
= now(CLOCK_MONOTONIC
);
2235 r
= bus_message_new_synthetic_error(
2238 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY
, "Method call timed out"),
2243 r
= bus_seal_synthetic_message(bus
, m
);
2247 assert_se(prioq_pop(bus
->reply_callbacks_prioq
) == c
);
2250 ordered_hashmap_remove(bus
->reply_callbacks
, &c
->cookie
);
2253 slot
= container_of(c
, sd_bus_slot
, reply_callback
);
2255 bus
->iteration_counter
++;
2257 bus
->current_message
= m
;
2258 bus
->current_slot
= sd_bus_slot_ref(slot
);
2259 bus
->current_handler
= c
->callback
;
2260 bus
->current_userdata
= slot
->userdata
;
2261 r
= c
->callback(m
, slot
->userdata
, &error_buffer
);
2262 bus
->current_userdata
= NULL
;
2263 bus
->current_handler
= NULL
;
2264 bus
->current_slot
= NULL
;
2265 bus
->current_message
= NULL
;
2267 if (slot
->floating
) {
2268 bus_slot_disconnect(slot
);
2269 sd_bus_slot_unref(slot
);
2272 sd_bus_slot_unref(slot
);
2274 return bus_maybe_reply_error(m
, r
, &error_buffer
);
2277 static int process_hello(sd_bus
*bus
, sd_bus_message
*m
) {
2281 if (bus
->state
!= BUS_HELLO
)
2284 /* Let's make sure the first message on the bus is the HELLO
2285 * reply. But note that we don't actually parse the message
2286 * here (we leave that to the usual handling), we just verify
2287 * we don't let any earlier msg through. */
2289 if (m
->header
->type
!= SD_BUS_MESSAGE_METHOD_RETURN
&&
2290 m
->header
->type
!= SD_BUS_MESSAGE_METHOD_ERROR
)
2293 if (m
->reply_cookie
!= 1)
2299 static int process_reply(sd_bus
*bus
, sd_bus_message
*m
) {
2300 _cleanup_bus_message_unref_ sd_bus_message
*synthetic_reply
= NULL
;
2301 _cleanup_bus_error_free_ sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2302 struct reply_callback
*c
;
2309 if (m
->header
->type
!= SD_BUS_MESSAGE_METHOD_RETURN
&&
2310 m
->header
->type
!= SD_BUS_MESSAGE_METHOD_ERROR
)
2313 if (bus
->is_kernel
&& (bus
->hello_flags
& KDBUS_HELLO_MONITOR
))
2316 if (m
->destination
&& bus
->unique_name
&& !streq_ptr(m
->destination
, bus
->unique_name
))
2319 c
= ordered_hashmap_remove(bus
->reply_callbacks
, &m
->reply_cookie
);
2325 slot
= container_of(c
, sd_bus_slot
, reply_callback
);
2327 if (m
->n_fds
> 0 && !(bus
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
)) {
2329 /* If the reply contained a file descriptor which we
2330 * didn't want we pass an error instead. */
2332 r
= bus_message_new_synthetic_error(
2335 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE
, "Reply message contained file descriptor"),
2340 /* Copy over original timestamp */
2341 synthetic_reply
->realtime
= m
->realtime
;
2342 synthetic_reply
->monotonic
= m
->monotonic
;
2343 synthetic_reply
->seqnum
= m
->seqnum
;
2345 r
= bus_seal_synthetic_message(bus
, synthetic_reply
);
2349 m
= synthetic_reply
;
2351 r
= sd_bus_message_rewind(m
, true);
2356 if (c
->timeout
!= 0) {
2357 prioq_remove(bus
->reply_callbacks_prioq
, c
, &c
->prioq_idx
);
2361 bus
->current_slot
= sd_bus_slot_ref(slot
);
2362 bus
->current_handler
= c
->callback
;
2363 bus
->current_userdata
= slot
->userdata
;
2364 r
= c
->callback(m
, slot
->userdata
, &error_buffer
);
2365 bus
->current_userdata
= NULL
;
2366 bus
->current_handler
= NULL
;
2367 bus
->current_slot
= NULL
;
2369 if (slot
->floating
) {
2370 bus_slot_disconnect(slot
);
2371 sd_bus_slot_unref(slot
);
2374 sd_bus_slot_unref(slot
);
2376 return bus_maybe_reply_error(m
, r
, &error_buffer
);
2379 static int process_filter(sd_bus
*bus
, sd_bus_message
*m
) {
2380 _cleanup_bus_error_free_ sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2381 struct filter_callback
*l
;
2388 bus
->filter_callbacks_modified
= false;
2390 LIST_FOREACH(callbacks
, l
, bus
->filter_callbacks
) {
2393 if (bus
->filter_callbacks_modified
)
2396 /* Don't run this more than once per iteration */
2397 if (l
->last_iteration
== bus
->iteration_counter
)
2400 l
->last_iteration
= bus
->iteration_counter
;
2402 r
= sd_bus_message_rewind(m
, true);
2406 slot
= container_of(l
, sd_bus_slot
, filter_callback
);
2408 bus
->current_slot
= sd_bus_slot_ref(slot
);
2409 bus
->current_handler
= l
->callback
;
2410 bus
->current_userdata
= slot
->userdata
;
2411 r
= l
->callback(m
, slot
->userdata
, &error_buffer
);
2412 bus
->current_userdata
= NULL
;
2413 bus
->current_handler
= NULL
;
2414 bus
->current_slot
= sd_bus_slot_unref(slot
);
2416 r
= bus_maybe_reply_error(m
, r
, &error_buffer
);
2422 } while (bus
->filter_callbacks_modified
);
2427 static int process_match(sd_bus
*bus
, sd_bus_message
*m
) {
2434 bus
->match_callbacks_modified
= false;
2436 r
= bus_match_run(bus
, &bus
->match_callbacks
, m
);
2440 } while (bus
->match_callbacks_modified
);
2445 static int process_builtin(sd_bus
*bus
, sd_bus_message
*m
) {
2446 _cleanup_bus_message_unref_ sd_bus_message
*reply
= NULL
;
2452 if (bus
->hello_flags
& KDBUS_HELLO_MONITOR
)
2455 if (bus
->manual_peer_interface
)
2458 if (m
->header
->type
!= SD_BUS_MESSAGE_METHOD_CALL
)
2461 if (!streq_ptr(m
->interface
, "org.freedesktop.DBus.Peer"))
2464 if (m
->header
->flags
& BUS_MESSAGE_NO_REPLY_EXPECTED
)
2467 if (streq_ptr(m
->member
, "Ping"))
2468 r
= sd_bus_message_new_method_return(m
, &reply
);
2469 else if (streq_ptr(m
->member
, "GetMachineId")) {
2473 r
= sd_id128_get_machine(&id
);
2477 r
= sd_bus_message_new_method_return(m
, &reply
);
2481 r
= sd_bus_message_append(reply
, "s", sd_id128_to_string(id
, sid
));
2483 r
= sd_bus_message_new_method_errorf(
2485 SD_BUS_ERROR_UNKNOWN_METHOD
,
2486 "Unknown method '%s' on interface '%s'.", m
->member
, m
->interface
);
2492 r
= sd_bus_send(bus
, reply
, NULL
);
2499 static int process_fd_check(sd_bus
*bus
, sd_bus_message
*m
) {
2503 /* If we got a message with a file descriptor which we didn't
2504 * want to accept, then let's drop it. How can this even
2505 * happen? For example, when the kernel queues a message into
2506 * an activatable names's queue which allows fds, and then is
2507 * delivered to us later even though we ourselves did not
2510 if (bus
->hello_flags
& KDBUS_HELLO_MONITOR
)
2516 if (bus
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
)
2519 if (m
->header
->type
!= SD_BUS_MESSAGE_METHOD_CALL
)
2520 return 1; /* just eat it up */
2522 return sd_bus_reply_method_errorf(m
, SD_BUS_ERROR_INCONSISTENT_MESSAGE
, "Message contains file descriptors, which I cannot accept. Sorry.");
2525 static int process_message(sd_bus
*bus
, sd_bus_message
*m
) {
2531 bus
->current_message
= m
;
2532 bus
->iteration_counter
++;
2534 log_debug_bus_message(m
);
2536 r
= process_hello(bus
, m
);
2540 r
= process_reply(bus
, m
);
2544 r
= process_fd_check(bus
, m
);
2548 r
= process_filter(bus
, m
);
2552 r
= process_match(bus
, m
);
2556 r
= process_builtin(bus
, m
);
2560 r
= bus_process_object(bus
, m
);
2563 bus
->current_message
= NULL
;
2567 static int dispatch_track(sd_bus
*bus
) {
2570 if (!bus
->track_queue
)
2573 bus_track_dispatch(bus
->track_queue
);
2577 static int process_running(sd_bus
*bus
, bool hint_priority
, int64_t priority
, sd_bus_message
**ret
) {
2578 _cleanup_bus_message_unref_ sd_bus_message
*m
= NULL
;
2582 assert(bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
);
2584 r
= process_timeout(bus
);
2588 r
= dispatch_wqueue(bus
);
2592 r
= dispatch_track(bus
);
2596 r
= dispatch_rqueue(bus
, hint_priority
, priority
, &m
);
2602 r
= process_message(bus
, m
);
2607 r
= sd_bus_message_rewind(m
, true);
2616 if (m
->header
->type
== SD_BUS_MESSAGE_METHOD_CALL
) {
2618 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2619 strna(sd_bus_message_get_sender(m
)),
2620 strna(sd_bus_message_get_path(m
)),
2621 strna(sd_bus_message_get_interface(m
)),
2622 strna(sd_bus_message_get_member(m
)));
2624 r
= sd_bus_reply_method_errorf(
2626 SD_BUS_ERROR_UNKNOWN_OBJECT
,
2627 "Unknown object '%s'.", m
->path
);
2641 static int process_closing(sd_bus
*bus
, sd_bus_message
**ret
) {
2642 _cleanup_bus_message_unref_ sd_bus_message
*m
= NULL
;
2643 struct reply_callback
*c
;
2647 assert(bus
->state
== BUS_CLOSING
);
2649 c
= ordered_hashmap_first(bus
->reply_callbacks
);
2651 _cleanup_bus_error_free_ sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2654 /* First, fail all outstanding method calls */
2655 r
= bus_message_new_synthetic_error(
2658 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY
, "Connection terminated"),
2663 r
= bus_seal_synthetic_message(bus
, m
);
2667 if (c
->timeout
!= 0) {
2668 prioq_remove(bus
->reply_callbacks_prioq
, c
, &c
->prioq_idx
);
2672 ordered_hashmap_remove(bus
->reply_callbacks
, &c
->cookie
);
2675 slot
= container_of(c
, sd_bus_slot
, reply_callback
);
2677 bus
->iteration_counter
++;
2679 bus
->current_message
= m
;
2680 bus
->current_slot
= sd_bus_slot_ref(slot
);
2681 bus
->current_handler
= c
->callback
;
2682 bus
->current_userdata
= slot
->userdata
;
2683 r
= c
->callback(m
, slot
->userdata
, &error_buffer
);
2684 bus
->current_userdata
= NULL
;
2685 bus
->current_handler
= NULL
;
2686 bus
->current_slot
= NULL
;
2687 bus
->current_message
= NULL
;
2689 if (slot
->floating
) {
2690 bus_slot_disconnect(slot
);
2691 sd_bus_slot_unref(slot
);
2694 sd_bus_slot_unref(slot
);
2696 return bus_maybe_reply_error(m
, r
, &error_buffer
);
2699 /* Then, synthesize a Disconnected message */
2700 r
= sd_bus_message_new_signal(
2703 "/org/freedesktop/DBus/Local",
2704 "org.freedesktop.DBus.Local",
2709 bus_message_set_sender_local(bus
, m
);
2711 r
= bus_seal_synthetic_message(bus
, m
);
2717 bus
->current_message
= m
;
2718 bus
->iteration_counter
++;
2720 r
= process_filter(bus
, m
);
2724 r
= process_match(bus
, m
);
2736 bus
->current_message
= NULL
;
2741 static int bus_process_internal(sd_bus
*bus
, bool hint_priority
, int64_t priority
, sd_bus_message
**ret
) {
2742 BUS_DONT_DESTROY(bus
);
2745 /* Returns 0 when we didn't do anything. This should cause the
2746 * caller to invoke sd_bus_wait() before returning the next
2747 * time. Returns > 0 when we did something, which possibly
2748 * means *ret is filled in with an unprocessed message. */
2750 assert_return(bus
, -EINVAL
);
2751 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2753 /* We don't allow recursively invoking sd_bus_process(). */
2754 assert_return(!bus
->current_message
, -EBUSY
);
2755 assert(!bus
->current_slot
);
2757 switch (bus
->state
) {
2766 r
= bus_socket_process_opening(bus
);
2767 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2768 bus_enter_closing(bus
);
2776 case BUS_AUTHENTICATING
:
2777 r
= bus_socket_process_authenticating(bus
);
2778 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2779 bus_enter_closing(bus
);
2791 r
= process_running(bus
, hint_priority
, priority
, ret
);
2792 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2793 bus_enter_closing(bus
);
2803 return process_closing(bus
, ret
);
2806 assert_not_reached("Unknown state");
2809 _public_
int sd_bus_process(sd_bus
*bus
, sd_bus_message
**ret
) {
2810 return bus_process_internal(bus
, false, 0, ret
);
2813 _public_
int sd_bus_process_priority(sd_bus
*bus
, int64_t priority
, sd_bus_message
**ret
) {
2814 return bus_process_internal(bus
, true, priority
, ret
);
2817 static int bus_poll(sd_bus
*bus
, bool need_more
, uint64_t timeout_usec
) {
2818 struct pollfd p
[2] = {};
2821 usec_t m
= USEC_INFINITY
;
2825 if (bus
->state
== BUS_CLOSING
)
2828 if (!BUS_IS_OPEN(bus
->state
))
2831 e
= sd_bus_get_events(bus
);
2836 /* The caller really needs some more data, he doesn't
2837 * care about what's already read, or any timeouts
2838 * except its own. */
2842 /* The caller wants to process if there's something to
2843 * process, but doesn't care otherwise */
2845 r
= sd_bus_get_timeout(bus
, &until
);
2850 nw
= now(CLOCK_MONOTONIC
);
2851 m
= until
> nw
? until
- nw
: 0;
2855 if (timeout_usec
!= (uint64_t) -1 && (m
== (uint64_t) -1 || timeout_usec
< m
))
2858 p
[0].fd
= bus
->input_fd
;
2859 if (bus
->output_fd
== bus
->input_fd
) {
2863 p
[0].events
= e
& POLLIN
;
2864 p
[1].fd
= bus
->output_fd
;
2865 p
[1].events
= e
& POLLOUT
;
2869 r
= ppoll(p
, n
, m
== (uint64_t) -1 ? NULL
: timespec_store(&ts
, m
), NULL
);
2873 return r
> 0 ? 1 : 0;
2876 _public_
int sd_bus_wait(sd_bus
*bus
, uint64_t timeout_usec
) {
2878 assert_return(bus
, -EINVAL
);
2879 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2881 if (bus
->state
== BUS_CLOSING
)
2884 if (!BUS_IS_OPEN(bus
->state
))
2887 if (bus
->rqueue_size
> 0)
2890 return bus_poll(bus
, false, timeout_usec
);
2893 _public_
int sd_bus_flush(sd_bus
*bus
) {
2896 assert_return(bus
, -EINVAL
);
2897 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2899 if (bus
->state
== BUS_CLOSING
)
2902 if (!BUS_IS_OPEN(bus
->state
))
2905 r
= bus_ensure_running(bus
);
2909 if (bus
->wqueue_size
<= 0)
2913 r
= dispatch_wqueue(bus
);
2915 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2916 bus_enter_closing(bus
);
2923 if (bus
->wqueue_size
<= 0)
2926 r
= bus_poll(bus
, false, (uint64_t) -1);
2932 _public_
int sd_bus_add_filter(
2935 sd_bus_message_handler_t callback
,
2940 assert_return(bus
, -EINVAL
);
2941 assert_return(callback
, -EINVAL
);
2942 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2944 s
= bus_slot_allocate(bus
, !slot
, BUS_FILTER_CALLBACK
, sizeof(struct filter_callback
), userdata
);
2948 s
->filter_callback
.callback
= callback
;
2950 bus
->filter_callbacks_modified
= true;
2951 LIST_PREPEND(callbacks
, bus
->filter_callbacks
, &s
->filter_callback
);
2959 _public_
int sd_bus_add_match(
2963 sd_bus_message_handler_t callback
,
2966 struct bus_match_component
*components
= NULL
;
2967 unsigned n_components
= 0;
2968 sd_bus_slot
*s
= NULL
;
2971 assert_return(bus
, -EINVAL
);
2972 assert_return(match
, -EINVAL
);
2973 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2975 r
= bus_match_parse(match
, &components
, &n_components
);
2979 s
= bus_slot_allocate(bus
, !slot
, BUS_MATCH_CALLBACK
, sizeof(struct match_callback
), userdata
);
2985 s
->match_callback
.callback
= callback
;
2986 s
->match_callback
.cookie
= ++bus
->match_cookie
;
2988 if (bus
->bus_client
) {
2989 enum bus_match_scope scope
;
2991 scope
= bus_match_get_scope(components
, n_components
);
2993 /* Do not install server-side matches for matches
2994 * against the local service, interface or bus
2996 if (scope
!= BUS_MATCH_LOCAL
) {
2998 if (!bus
->is_kernel
) {
2999 /* When this is not a kernel transport, we
3000 * store the original match string, so that we
3001 * can use it to remove the match again */
3003 s
->match_callback
.match_string
= strdup(match
);
3004 if (!s
->match_callback
.match_string
) {
3010 r
= bus_add_match_internal(bus
, s
->match_callback
.match_string
, components
, n_components
, s
->match_callback
.cookie
);
3014 s
->match_added
= true;
3018 bus
->match_callbacks_modified
= true;
3019 r
= bus_match_add(&bus
->match_callbacks
, components
, n_components
, &s
->match_callback
);
3028 bus_match_parse_free(components
, n_components
);
3029 sd_bus_slot_unref(s
);
3034 int bus_remove_match_by_string(
3037 sd_bus_message_handler_t callback
,
3040 struct bus_match_component
*components
= NULL
;
3041 unsigned n_components
= 0;
3042 struct match_callback
*c
;
3045 assert_return(bus
, -EINVAL
);
3046 assert_return(match
, -EINVAL
);
3047 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3049 r
= bus_match_parse(match
, &components
, &n_components
);
3053 r
= bus_match_find(&bus
->match_callbacks
, components
, n_components
, NULL
, NULL
, &c
);
3057 sd_bus_slot_unref(container_of(c
, sd_bus_slot
, match_callback
));
3060 bus_match_parse_free(components
, n_components
);
3065 bool bus_pid_changed(sd_bus
*bus
) {
3068 /* We don't support people creating a bus connection and
3069 * keeping it around over a fork(). Let's complain. */
3071 return bus
->original_pid
!= getpid();
3074 static int io_callback(sd_event_source
*s
, int fd
, uint32_t revents
, void *userdata
) {
3075 sd_bus
*bus
= userdata
;
3080 r
= sd_bus_process(bus
, NULL
);
3087 static int time_callback(sd_event_source
*s
, uint64_t usec
, void *userdata
) {
3088 sd_bus
*bus
= userdata
;
3093 r
= sd_bus_process(bus
, NULL
);
3100 static int prepare_callback(sd_event_source
*s
, void *userdata
) {
3101 sd_bus
*bus
= userdata
;
3108 e
= sd_bus_get_events(bus
);
3112 if (bus
->output_fd
!= bus
->input_fd
) {
3114 r
= sd_event_source_set_io_events(bus
->input_io_event_source
, e
& POLLIN
);
3118 r
= sd_event_source_set_io_events(bus
->output_io_event_source
, e
& POLLOUT
);
3122 r
= sd_event_source_set_io_events(bus
->input_io_event_source
, e
);
3127 r
= sd_bus_get_timeout(bus
, &until
);
3133 j
= sd_event_source_set_time(bus
->time_event_source
, until
);
3138 r
= sd_event_source_set_enabled(bus
->time_event_source
, r
> 0);
3145 static int quit_callback(sd_event_source
*event
, void *userdata
) {
3146 sd_bus
*bus
= userdata
;
3156 static int attach_io_events(sd_bus
*bus
) {
3161 if (bus
->input_fd
< 0)
3167 if (!bus
->input_io_event_source
) {
3168 r
= sd_event_add_io(bus
->event
, &bus
->input_io_event_source
, bus
->input_fd
, 0, io_callback
, bus
);
3172 r
= sd_event_source_set_prepare(bus
->input_io_event_source
, prepare_callback
);
3176 r
= sd_event_source_set_priority(bus
->input_io_event_source
, bus
->event_priority
);
3180 r
= sd_event_source_set_description(bus
->input_io_event_source
, "bus-input");
3182 r
= sd_event_source_set_io_fd(bus
->input_io_event_source
, bus
->input_fd
);
3187 if (bus
->output_fd
!= bus
->input_fd
) {
3188 assert(bus
->output_fd
>= 0);
3190 if (!bus
->output_io_event_source
) {
3191 r
= sd_event_add_io(bus
->event
, &bus
->output_io_event_source
, bus
->output_fd
, 0, io_callback
, bus
);
3195 r
= sd_event_source_set_priority(bus
->output_io_event_source
, bus
->event_priority
);
3199 r
= sd_event_source_set_description(bus
->input_io_event_source
, "bus-output");
3201 r
= sd_event_source_set_io_fd(bus
->output_io_event_source
, bus
->output_fd
);
3210 static void detach_io_events(sd_bus
*bus
) {
3213 if (bus
->input_io_event_source
) {
3214 sd_event_source_set_enabled(bus
->input_io_event_source
, SD_EVENT_OFF
);
3215 bus
->input_io_event_source
= sd_event_source_unref(bus
->input_io_event_source
);
3218 if (bus
->output_io_event_source
) {
3219 sd_event_source_set_enabled(bus
->output_io_event_source
, SD_EVENT_OFF
);
3220 bus
->output_io_event_source
= sd_event_source_unref(bus
->output_io_event_source
);
3224 _public_
int sd_bus_attach_event(sd_bus
*bus
, sd_event
*event
, int priority
) {
3227 assert_return(bus
, -EINVAL
);
3228 assert_return(!bus
->event
, -EBUSY
);
3230 assert(!bus
->input_io_event_source
);
3231 assert(!bus
->output_io_event_source
);
3232 assert(!bus
->time_event_source
);
3235 bus
->event
= sd_event_ref(event
);
3237 r
= sd_event_default(&bus
->event
);
3242 bus
->event_priority
= priority
;
3244 r
= sd_event_add_time(bus
->event
, &bus
->time_event_source
, CLOCK_MONOTONIC
, 0, 0, time_callback
, bus
);
3248 r
= sd_event_source_set_priority(bus
->time_event_source
, priority
);
3252 r
= sd_event_source_set_description(bus
->time_event_source
, "bus-time");
3256 r
= sd_event_add_exit(bus
->event
, &bus
->quit_event_source
, quit_callback
, bus
);
3260 r
= sd_event_source_set_description(bus
->quit_event_source
, "bus-exit");
3264 r
= attach_io_events(bus
);
3271 sd_bus_detach_event(bus
);
3275 _public_
int sd_bus_detach_event(sd_bus
*bus
) {
3276 assert_return(bus
, -EINVAL
);
3281 detach_io_events(bus
);
3283 if (bus
->time_event_source
) {
3284 sd_event_source_set_enabled(bus
->time_event_source
, SD_EVENT_OFF
);
3285 bus
->time_event_source
= sd_event_source_unref(bus
->time_event_source
);
3288 if (bus
->quit_event_source
) {
3289 sd_event_source_set_enabled(bus
->quit_event_source
, SD_EVENT_OFF
);
3290 bus
->quit_event_source
= sd_event_source_unref(bus
->quit_event_source
);
3293 bus
->event
= sd_event_unref(bus
->event
);
3297 _public_ sd_event
* sd_bus_get_event(sd_bus
*bus
) {
3298 assert_return(bus
, NULL
);
3303 _public_ sd_bus_message
* sd_bus_get_current_message(sd_bus
*bus
) {
3304 assert_return(bus
, NULL
);
3306 return bus
->current_message
;
3309 _public_ sd_bus_slot
* sd_bus_get_current_slot(sd_bus
*bus
) {
3310 assert_return(bus
, NULL
);
3312 return bus
->current_slot
;
3315 _public_ sd_bus_message_handler_t
sd_bus_get_current_handler(sd_bus
*bus
) {
3316 assert_return(bus
, NULL
);
3318 return bus
->current_handler
;
3321 _public_
void* sd_bus_get_current_userdata(sd_bus
*bus
) {
3322 assert_return(bus
, NULL
);
3324 return bus
->current_userdata
;
3327 static int bus_default(int (*bus_open
)(sd_bus
**), sd_bus
**default_bus
, sd_bus
**ret
) {
3332 assert(default_bus
);
3335 return !!*default_bus
;
3338 *ret
= sd_bus_ref(*default_bus
);
3346 b
->default_bus_ptr
= default_bus
;
3354 _public_
int sd_bus_default_system(sd_bus
**ret
) {
3355 return bus_default(sd_bus_open_system
, &default_system_bus
, ret
);
3359 _public_
int sd_bus_default_user(sd_bus
**ret
) {
3360 return bus_default(sd_bus_open_user
, &default_user_bus
, ret
);
3363 _public_
int sd_bus_default(sd_bus
**ret
) {
3367 /* Let's try our best to reuse another cached connection. If
3368 * the starter bus type is set, connect via our normal
3369 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3370 * we can share the connection with the user/system default
3373 e
= secure_getenv("DBUS_STARTER_BUS_TYPE");
3375 if (streq(e
, "system"))
3376 return sd_bus_default_system(ret
);
3377 else if (STR_IN_SET(e
, "user", "session"))
3378 return sd_bus_default_user(ret
);
3381 /* No type is specified, so we have not other option than to
3382 * use the starter address if it is set. */
3384 e
= secure_getenv("DBUS_STARTER_ADDRESS");
3387 return bus_default(sd_bus_open
, &default_starter_bus
, ret
);
3390 /* Finally, if nothing is set use the cached connection for
3391 * the right scope */
3393 if (cg_pid_get_owner_uid(0, NULL
) >= 0)
3394 return sd_bus_default_user(ret
);
3396 return sd_bus_default_system(ret
);
3399 _public_
int sd_bus_get_tid(sd_bus
*b
, pid_t
*tid
) {
3400 assert_return(b
, -EINVAL
);
3401 assert_return(tid
, -EINVAL
);
3402 assert_return(!bus_pid_changed(b
), -ECHILD
);
3410 return sd_event_get_tid(b
->event
, tid
);
3415 _public_
int sd_bus_path_encode(const char *prefix
, const char *external_id
, char **ret_path
) {
3416 _cleanup_free_
char *e
= NULL
;
3419 assert_return(object_path_is_valid(prefix
), -EINVAL
);
3420 assert_return(external_id
, -EINVAL
);
3421 assert_return(ret_path
, -EINVAL
);
3423 e
= bus_label_escape(external_id
);
3427 ret
= strjoin(prefix
, "/", e
, NULL
);
3435 _public_
int sd_bus_path_decode(const char *path
, const char *prefix
, char **external_id
) {
3439 assert_return(object_path_is_valid(path
), -EINVAL
);
3440 assert_return(object_path_is_valid(prefix
), -EINVAL
);
3441 assert_return(external_id
, -EINVAL
);
3443 e
= object_path_startswith(path
, prefix
);
3445 *external_id
= NULL
;
3449 ret
= bus_label_unescape(e
);
3457 _public_
int sd_bus_path_encode_many(char **out
, const char *path_template
, ...) {
3458 _cleanup_strv_free_
char **labels
= NULL
;
3459 char *path
, *path_pos
, **label_pos
;
3460 const char *sep
, *template_pos
;
3465 assert_return(out
, -EINVAL
);
3466 assert_return(path_template
, -EINVAL
);
3468 path_length
= strlen(path_template
);
3470 va_start(list
, path_template
);
3471 for (sep
= strchr(path_template
, '%'); sep
; sep
= strchr(sep
+ 1, '%')) {
3475 arg
= va_arg(list
, const char *);
3481 label
= bus_label_escape(arg
);
3487 r
= strv_consume(&labels
, label
);
3493 /* add label length, but account for the format character */
3494 path_length
+= strlen(label
) - 1;
3498 path
= malloc(path_length
+ 1);
3505 for (template_pos
= path_template
; *template_pos
; ) {
3506 sep
= strchrnul(template_pos
, '%');
3507 path_pos
= mempcpy(path_pos
, template_pos
, sep
- template_pos
);
3511 path_pos
= stpcpy(path_pos
, *label_pos
++);
3512 template_pos
= sep
+ 1;
3520 _public_
int sd_bus_path_decode_many(const char *path
, const char *path_template
, ...) {
3521 _cleanup_strv_free_
char **labels
= NULL
;
3522 const char *template_pos
, *path_pos
;
3528 * This decodes an object-path based on a template argument. The
3529 * template consists of a verbatim path, optionally including special
3532 * - Each occurrence of '%' in the template matches an arbitrary
3533 * substring of a label in the given path. At most one such
3534 * directive is allowed per label. For each such directive, the
3535 * caller must provide an output parameter (char **) via va_arg. If
3536 * NULL is passed, the given label is verified, but not returned.
3537 * For each matched label, the *decoded* label is stored in the
3538 * passed output argument, and the caller is responsible to free
3539 * it. Note that the output arguments are only modified if the
3540 * actualy path matched the template. Otherwise, they're left
3543 * This function returns <0 on error, 0 if the path does not match the
3544 * template, 1 if it matched.
3547 assert_return(path
, -EINVAL
);
3548 assert_return(path_template
, -EINVAL
);
3552 for (template_pos
= path_template
; *template_pos
; ) {
3557 /* verify everything until the next '%' matches verbatim */
3558 sep
= strchrnul(template_pos
, '%');
3559 length
= sep
- template_pos
;
3560 if (strncmp(path_pos
, template_pos
, length
))
3564 template_pos
+= length
;
3569 /* We found the next '%' character. Everything up until here
3570 * matched. We now skip ahead to the end of this label and make
3571 * sure it matches the tail of the label in the path. Then we
3572 * decode the string in-between and save it for later use. */
3574 ++template_pos
; /* skip over '%' */
3576 sep
= strchrnul(template_pos
, '/');
3577 length
= sep
- template_pos
; /* length of suffix to match verbatim */
3579 /* verify the suffixes match */
3580 sep
= strchrnul(path_pos
, '/');
3581 if (sep
- path_pos
< (ssize_t
)length
||
3582 strncmp(sep
- length
, template_pos
, length
))
3585 template_pos
+= length
; /* skip over matched label */
3586 length
= sep
- path_pos
- length
; /* length of sub-label to decode */
3588 /* store unescaped label for later use */
3589 label
= bus_label_unescape_n(path_pos
, length
);
3593 r
= strv_consume(&labels
, label
);
3597 path_pos
= sep
; /* skip decoded label and suffix */
3600 /* end of template must match end of path */
3604 /* copy the labels over to the caller */
3605 va_start(list
, path_template
);
3606 for (label_pos
= labels
; label_pos
&& *label_pos
; ++label_pos
) {
3609 arg
= va_arg(list
, char **);
3622 _public_
int sd_bus_try_close(sd_bus
*bus
) {
3625 assert_return(bus
, -EINVAL
);
3626 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3628 if (!bus
->is_kernel
)
3631 if (!BUS_IS_OPEN(bus
->state
))
3634 if (bus
->rqueue_size
> 0)
3637 if (bus
->wqueue_size
> 0)
3640 r
= bus_kernel_try_close(bus
);
3648 _public_
int sd_bus_get_description(sd_bus
*bus
, const char **description
) {
3649 assert_return(bus
, -EINVAL
);
3650 assert_return(description
, -EINVAL
);
3651 assert_return(bus
->description
, -ENXIO
);
3652 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3654 *description
= bus
->description
;
3658 int bus_get_root_path(sd_bus
*bus
) {
3661 if (bus
->cgroup_root
)
3664 r
= cg_get_root_path(&bus
->cgroup_root
);
3666 bus
->cgroup_root
= strdup("/");
3667 if (!bus
->cgroup_root
)
3676 _public_
int sd_bus_get_scope(sd_bus
*bus
, const char **scope
) {
3679 assert_return(bus
, -EINVAL
);
3680 assert_return(scope
, -EINVAL
);
3681 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3683 if (bus
->is_kernel
) {
3684 _cleanup_free_
char *n
= NULL
;
3687 r
= bus_kernel_get_bus_name(bus
, &n
);
3691 if (streq(n
, "0-system")) {
3696 dash
= strchr(n
, '-');
3697 if (streq_ptr(dash
, "-user")) {
3708 if (bus
->is_system
) {
3716 _public_
int sd_bus_get_address(sd_bus
*bus
, const char **address
) {
3718 assert_return(bus
, -EINVAL
);
3719 assert_return(address
, -EINVAL
);
3720 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3723 *address
= bus
->address
;
3730 _public_
int sd_bus_get_creds_mask(sd_bus
*bus
, uint64_t *mask
) {
3731 assert_return(bus
, -EINVAL
);
3732 assert_return(mask
, -EINVAL
);
3733 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3735 *mask
= bus
->creds_mask
;
3739 _public_
int sd_bus_is_bus_client(sd_bus
*bus
) {
3740 assert_return(bus
, -EINVAL
);
3741 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3743 return bus
->bus_client
;
3746 _public_
int sd_bus_is_server(sd_bus
*bus
) {
3747 assert_return(bus
, -EINVAL
);
3748 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3750 return bus
->is_server
;
3753 _public_
int sd_bus_is_anonymous(sd_bus
*bus
) {
3754 assert_return(bus
, -EINVAL
);
3755 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3757 return bus
->anonymous_auth
;
3760 _public_
int sd_bus_is_trusted(sd_bus
*bus
) {
3761 assert_return(bus
, -EINVAL
);
3762 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3764 return bus
->trusted
;
3767 _public_
int sd_bus_is_monitor(sd_bus
*bus
) {
3768 assert_return(bus
, -EINVAL
);
3769 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3771 return !!(bus
->hello_flags
& KDBUS_HELLO_MONITOR
);
3774 static void flush_close(sd_bus
*bus
) {
3778 /* Flushes and closes the specified bus. We take a ref before,
3779 * to ensure the flushing does not cause the bus to be
3782 sd_bus_flush_close_unref(sd_bus_ref(bus
));
3785 _public_
void sd_bus_default_flush_close(void) {
3786 flush_close(default_starter_bus
);
3787 flush_close(default_user_bus
);
3788 flush_close(default_system_bus
);